Telegraph Publisher

config/.env

# Telegraph API access token
# Get one by running: sh scripts/create_account.sh --name "YourName"
TELEGRAPH_ACCESS_TOKEN=your_token_here

# GitHub-backed permanent media hosting (recommended)
# Public repo in owner/repo format, for example: yourname/telegraph-assets
GITHUB_TOKEN=your_github_token_here
GITHUB_ASSETS_REPO=owner/repo
GITHUB_ASSETS_BRANCH=main
GITHUB_ASSETS_BASE_DIR=pages
GITHUB_MANIFESTS_DIR=manifests

#!/bin/sh
# Get Telegraph account info
# Usage: sh account_info.sh [--fields short_name,author_name,author_url,auth_url,page_count]

set -e

SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
. "$SCRIPT_DIR/common.sh"
load_config

# Parse arguments
FIELDS="short_name,author_name,author_url,page_count"

while [ $# -gt 0 ]; do
    case "$1" in
        --fields) FIELDS="$2"; shift 2 ;;
        --with-auth-url) FIELDS="short_name,author_name,author_url,auth_url,page_count"; shift ;;
        *)        shift ;;
    esac
done

# Convert comma-separated fields to JSON array format for API
# Telegraph expects: fields=["short_name","author_name"]
_fields_json="["
_first=1
_ifs_save="$IFS"
IFS=","
for _f in $FIELDS; do
    if [ "$_first" = "1" ]; then
        _fields_json="${_fields_json}\"$_f\""
        _first=0
    else
        _fields_json="${_fields_json},\"$_f\""
    fi
done
IFS="$_ifs_save"
_fields_json="${_fields_json}]"

_result=$(telegraph_post "getAccountInfo" \
    -d "access_token=$TELEGRAPH_ACCESS_TOKEN" \
    --data-urlencode "fields=$_fields_json")

# Use parse_response.py for human-readable output
echo "$_result" | python3 "$SCRIPT_DIR/parse_response.py" account_info

#!/bin/sh
# Common functions for Telegraph Publisher skill
# POSIX sh compatible — no bashisms

set -e

SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
CONFIG_FILE="$SCRIPT_DIR/../config/.env"

TELEGRAPH_API="https://api.telegra.ph"
GITHUB_API="https://api.github.com"

# Ensure tmp directory exists
TPH_TMPDIR="${TMPDIR:-/tmp}"
mkdir -p "$TPH_TMPDIR"

# --------------- Config ---------------

load_config() {
    if [ -f "$CONFIG_FILE" ]; then
        # shellcheck disable=SC1090
        . "$CONFIG_FILE"
    fi

    if [ -z "$TELEGRAPH_ACCESS_TOKEN" ]; then
        echo "Error: TELEGRAPH_ACCESS_TOKEN not found." >&2
        echo "Set in config/.env or environment. See config/README.md." >&2
        exit 1
    fi
}

# load_config_optional — does not fail if token is missing
load_config_optional() {
    if [ -f "$CONFIG_FILE" ]; then
        # shellcheck disable=SC1090
        . "$CONFIG_FILE"
    fi
}

load_github_config() {
    load_config_optional

    if [ -z "$GITHUB_TOKEN" ]; then
        echo "Error: GITHUB_TOKEN not found." >&2
        echo "Set in config/.env or environment. See config/README.md." >&2
        exit 1
    fi

    if [ -z "$GITHUB_ASSETS_REPO" ]; then
        echo "Error: GITHUB_ASSETS_REPO not found." >&2
        echo "Expected format: owner/repo" >&2
        echo "Set in config/.env or environment. See config/README.md." >&2
        exit 1
    fi

    GITHUB_ASSETS_BRANCH="${GITHUB_ASSETS_BRANCH:-main}"
    GITHUB_ASSETS_BASE_DIR="${GITHUB_ASSETS_BASE_DIR:-pages}"
    GITHUB_MANIFESTS_DIR="${GITHUB_MANIFESTS_DIR:-manifests}"
}

check_python3() {
    if ! command -v python3 >/dev/null 2>&1; then
        echo "Error: python3 is required but not found." >&2
        exit 1
    fi
}

check_curl() {
    if ! command -v curl >/dev/null 2>&1; then
        echo "Error: curl is required but not found." >&2
        exit 1
    fi
}

check_prerequisites() {
    check_python3
    check_curl
}

make_secure_tmpdir() {
    _old_umask=$(umask)
    umask 077
    _tmpdir=$(mktemp -d "${TPH_TMPDIR}/tph_XXXXXX")
    umask "$_old_umask"
    echo "$_tmpdir"
}

slugify_filename() {
    python3 - "$1" <<'PY'
import os, re, sys

name = os.path.basename(sys.argv[1])
base, ext = os.path.splitext(name)
base = re.sub(r'[^A-Za-z0-9._-]+', '-', base.strip().lower()).strip('-')
if not base:
    base = 'asset'
print(base + ext.lower())
PY
}

# --------------- API helpers ---------------

# telegraph_post <method> [curl_args...]
# Makes POST request to Telegraph API. Returns body.
telegraph_post() {
    _tp_method="$1"
    shift
    _tp_url="${TELEGRAPH_API}/${_tp_method}"
    _tp_tmpfile="${TPH_TMPDIR}/telegraph_response_$$.json"
    trap 'rm -f "$_tp_tmpfile"' EXIT

    curl -s -X POST "$@" "$_tp_url" > "$_tp_tmpfile" || {
        echo "Error: curl failed for $_tp_url" >&2
        return 1
    }

    # Check API-level error
    _tp_ok=$(json_extract_bool "$_tp_tmpfile" "ok")
    if [ "$_tp_ok" = "false" ]; then
        _tp_error=$(json_extract_field "$_tp_tmpfile" "error")
        echo "Error: Telegraph API: $_tp_error" >&2
        cat "$_tp_tmpfile" >&2
        return 1
    fi

    cat "$_tp_tmpfile"
}

# --------------- JSON helpers (flat fields only) ---------------

# json_extract_field <file> <field_name> — extracts string value
json_extract_field() {
    grep -o "\"$2\"[[:space:]]*:[[:space:]]*\"[^\"]*\"" "$1" | head -1 | sed 's/.*:[[:space:]]*"//;s/"$//'
}

# json_extract_number <file> <field_name> — extracts numeric value
json_extract_number() {
    grep -o "\"$2\"[[:space:]]*:[[:space:]]*[0-9]*" "$1" | head -1 | sed 's/.*:[[:space:]]*//'
}

# json_extract_bool <file> <field_name> — extracts true/false
json_extract_bool() {
    grep -o "\"$2\"[[:space:]]*:[[:space:]]*[a-z]*" "$1" | head -1 | sed 's/.*:[[:space:]]*//'
}

#!/usr/bin/env python3
"""Convert HTML fragment to Telegraph Node JSON format.

Usage:
  echo '<p>Hello <b>world</b></p>' | python3 content_converter.py
  python3 content_converter.py < article.html
  python3 content_converter.py --check-size    # reads Node JSON from stdin, prints byte size
  python3 content_converter.py --split --output-dir DIR  # reads Node JSON from stdin, splits into parts

Supported Telegraph tags (output whitelist):
  a, aside, b, blockquote, br, code, em, figcaption, figure,
  h3, h4, hr, i, iframe, img, li, ol, p, pre, s, strong, u, ul, video

Special input handling:
  table, thead, tr, th, td -> converted to a monospace preformatted table

Unsupported tags are stripped (children preserved).
Only href and src attributes are kept.
"""

import json
import re
import sys
import os
from html.parser import HTMLParser

# Tags that Telegraph API accepts
ALLOWED_TAGS = frozenset([
    'a', 'aside', 'b', 'blockquote', 'br', 'code', 'em', 'figcaption',
    'figure', 'h3', 'h4', 'hr', 'i', 'iframe', 'img', 'li', 'ol',
    'p', 'pre', 's', 'strong', 'u', 'ul', 'video'
])

# Only these attributes are allowed by Telegraph
ALLOWED_ATTRS = frozenset(['href', 'src'])

# Tags that are block-level (for splitting)
BLOCK_TAGS = frozenset(['h3', 'h4', 'p', 'blockquote', 'pre', 'ul', 'ol', 'figure', 'hr', 'aside'])

# Void elements (no closing tag)
VOID_TAGS = frozenset(['br', 'hr', 'img'])

# Size limit in bytes (60KB threshold, Telegraph limit is 64KB)
SIZE_LIMIT = 61440


def format_table_mono(rows, header_idx=-1):
    """Format table rows as a monospace table using box-drawing chars."""
    if not rows:
        return ""

    n_cols = max(len(row) for row in rows)
    widths = [0] * n_cols

    for row in rows:
        for i, cell in enumerate(row):
            widths[i] = max(widths[i], len(cell.strip()))

    widths = [max(w, 1) for w in widths]

    def sep(left, mid, right, fill='-'):
        if fill == '-':
            fill = '─'
        return left + mid.join(fill * (w + 2) for w in widths) + right

    lines = [sep('┌', '┬', '┐')]
    for idx, row in enumerate(rows):
        cells = []
        for i in range(n_cols):
            val = row[i].strip() if i < len(row) else ''
            cells.append(f" {val:<{widths[i]}} ")
        lines.append('│' + '│'.join(cells) + '│')
        if idx == header_idx:
            lines.append(sep('├', '┼', '┤'))
    lines.append(sep('└', '┴', '┘'))
    return '\n'.join(lines)


class TelegraphHTMLParser(HTMLParser):
    """Parse HTML fragment into Telegraph Node array."""

    def __init__(self):
        super().__init__()
        self.result = []
        self.stack = []  # stack of (tag_or_none, children_list)
        self.stack.append((None, self.result))
        self._in_table = False
        self._table_rows = []
        self._current_row = []
        self._current_cell = []
        self._header_row_idx = -1
        self._in_thead = False

    def handle_starttag(self, tag, attrs):
        tag = tag.lower()

        if tag == 'table':
            self._in_table = True
            self._table_rows = []
            self._current_row = []
            self._current_cell = []
            self._header_row_idx = -1
            self._in_thead = False
            return

        if self._in_table:
            if tag == 'thead':
                self._in_thead = True
            elif tag == 'tr':
                self._current_row = []
            elif tag in ('td', 'th'):
                self._current_cell = []
                if tag == 'th' or self._in_thead:
                    self._header_row_idx = len(self._table_rows)
            return

        if tag in ALLOWED_TAGS:
            node = {'tag': tag}
            filtered_attrs = {}
            for k, v in attrs:
                if k.lower() in ALLOWED_ATTRS and v:
                    # Normalize YouTube URLs in iframe src
                    if k.lower() == 'src' and tag == 'iframe':
                        v = normalize_youtube_embed(v)
                    filtered_attrs[k.lower()] = v
            if filtered_attrs:
                node['attrs'] = filtered_attrs
            if tag not in VOID_TAGS:
                node['children'] = []
                self.stack.append((tag, node['children']))
            # Add to parent's children
            _, parent_children = self.stack[-1] if tag in VOID_TAGS else self.stack[-2]
            parent_children.append(node)
        else:
            # Unsupported tag: skip tag, children go to parent
            pass

    def handle_endtag(self, tag):
        tag = tag.lower()

        if tag == 'table' and self._in_table:
            self._in_table = False
            if self._table_rows:
                _, parent_children = self.stack[-1]
                parent_children.append({
                    'tag': 'pre',
                    'children': [format_table_mono(self._table_rows, self._header_row_idx)]
                })
            self._table_rows = []
            self._current_row = []
            self._current_cell = []
            self._header_row_idx = -1
            self._in_thead = False
            return

        if self._in_table:
            if tag == 'thead':
                self._in_thead = False
            elif tag in ('td', 'th'):
                self._current_row.append(''.join(self._current_cell))
                self._current_cell = []
            elif tag == 'tr':
                if self._current_row:
                    self._table_rows.append(self._current_row)
                self._current_row = []
            return

        if tag in ALLOWED_TAGS and tag not in VOID_TAGS:
            # Pop from stack if matching
            if self.stack and self.stack[-1][0] == tag:
                self.stack.pop()

    def handle_data(self, data):
        if not data.strip() and not data:
            return
        if self._in_table:
            if data:
                self._current_cell.append(data)
            return
        if data:
            _, parent_children = self.stack[-1]
            parent_children.append(data)

    def handle_entityref(self, name):
        from html import unescape
        char = unescape(f'&{name};')
        if self._in_table:
            self._current_cell.append(char)
            return
        _, parent_children = self.stack[-1]
        parent_children.append(char)

    def handle_charref(self, name):
        from html import unescape
        char = unescape(f'&#{name};')
        if self._in_table:
            self._current_cell.append(char)
            return
        _, parent_children = self.stack[-1]
        parent_children.append(char)


def normalize_youtube_embed(url):
    """Normalize YouTube URL to embed format."""
    # Already embed format
    if '/embed/' in url:
        return url

    # youtube.com/watch?v=ID or youtu.be/ID
    video_id = None
    m = re.search(r'[?&]v=([a-zA-Z0-9_-]{11})', url)
    if m:
        video_id = m.group(1)
    else:
        m = re.search(r'youtu\.be/([a-zA-Z0-9_-]{11})', url)
        if m:
            video_id = m.group(1)

    if video_id:
        return f'https://www.youtube.com/embed/{video_id}'

    return url


def html_to_nodes(html_str):
    """Convert HTML string to Telegraph Node array."""
    parser = TelegraphHTMLParser()
    parser.feed(html_str)
    return clean_nodes(parser.result)


def clean_nodes(nodes):
    """Remove empty text nodes and empty elements."""
    cleaned = []
    for node in nodes:
        if isinstance(node, str):
            # Skip whitespace-only strings
            if not node.strip():
                continue
            cleaned.append(node)
        elif isinstance(node, dict):
            if 'children' in node:
                node['children'] = clean_nodes(node['children'])
                # Remove block elements with no meaningful children
                if not node['children'] and node['tag'] not in VOID_TAGS:
                    if node['tag'] in BLOCK_TAGS:
                        continue
                    # Remove empty inline containers too
                    del node['children']
            cleaned.append(node)
    return cleaned


def serialize_size(nodes):
    """Return UTF-8 byte size of serialized Node JSON."""
    return len(json.dumps(nodes, ensure_ascii=False).encode('utf-8'))


def split_nodes(nodes, max_size=SIZE_LIMIT):
    """Split Node array into parts, each under max_size bytes.

    Strategy:
    1. Split by top-level h3 boundaries (sections)
    2. If a section exceeds limit, split by block-level elements
    3. If a single element exceeds limit, raise error
    """
    # First, try splitting by h3 sections
    sections = []
    current_section = []

    for node in nodes:
        if isinstance(node, dict) and node.get('tag') == 'h3' and current_section:
            sections.append(current_section)
            current_section = [node]
        else:
            current_section.append(node)
    if current_section:
        sections.append(current_section)

    # Now pack sections into parts respecting size limit
    parts = []
    current_part = []
    current_size = 2  # for [ ]

    for section in sections:
        section_size = serialize_size(section)

        if section_size > max_size:
            # Section too large — split by individual block elements
            if current_part:
                parts.append(current_part)
                current_part = []
                current_size = 2

            for element in section:
                elem_size = serialize_size([element])
                if elem_size > max_size:
                    tag = element.get('tag', 'text') if isinstance(element, dict) else 'text'
                    print(f"Error: Single element too large ({elem_size} bytes): <{tag}>. Split manually.",
                          file=sys.stderr)
                    sys.exit(1)

                if current_size + elem_size > max_size:
                    if current_part:
                        parts.append(current_part)
                    current_part = [element]
                    current_size = 2 + elem_size
                else:
                    current_part.append(element)
                    current_size += elem_size
        else:
            if current_size + section_size > max_size:
                if current_part:
                    parts.append(current_part)
                current_part = list(section)
                current_size = 2 + section_size
            else:
                current_part.extend(section)
                current_size += section_size

    if current_part:
        parts.append(current_part)

    return parts


def main():
    args = sys.argv[1:]

    if '--check-size' in args:
        data = sys.stdin.read()
        nodes = json.loads(data)
        print(serialize_size(nodes))
        return

    if '--split' in args:
        output_dir = '.'
        if '--output-dir' in args:
            idx = args.index('--output-dir')
            output_dir = args[idx + 1]

        data = sys.stdin.read()
        nodes = json.loads(data)
        parts = split_nodes(nodes)

        os.makedirs(output_dir, exist_ok=True)
        for i, part in enumerate(parts, 1):
            path = os.path.join(output_dir, f'part_{i}.json')
            with open(path, 'w', encoding='utf-8') as f:
                json.dump(part, f, ensure_ascii=False)
            size = serialize_size(part)
            print(f"part_{i}.json: {size} bytes", file=sys.stderr)

        print(len(parts))
        return

    # Default: convert HTML from stdin to Node JSON
    html_input = sys.stdin.read()
    nodes = html_to_nodes(html_input)
    print(json.dumps(nodes, ensure_ascii=False))


if __name__ == '__main__':
    main()

#!/bin/sh
# Create or manage a Telegraph account
# Usage:
#   sh create_account.sh --name "Author Name" [--author-url "https://..."]
#   sh create_account.sh --revoke   # Rotate token (requires existing token in config)

set -e

SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
. "$SCRIPT_DIR/common.sh"

# Parse arguments
SHORT_NAME=""
AUTHOR_NAME=""
AUTHOR_URL=""
REVOKE=""

while [ $# -gt 0 ]; do
    case "$1" in
        --name)       SHORT_NAME="$2"; AUTHOR_NAME="$2"; shift 2 ;;
        --author-url) AUTHOR_URL="$2"; shift 2 ;;
        --revoke)     REVOKE="1"; shift ;;
        *)            shift ;;
    esac
done

if [ -n "$REVOKE" ]; then
    load_config
    echo "Revoking access token and generating new one..." >&2

    _result=$(telegraph_post "revokeAccessToken" \
        -d "access_token=$TELEGRAPH_ACCESS_TOKEN")

    _tmpfile="${TPH_TMPDIR}/telegraph_revoke_$$.json"
    printf '%s' "$_result" > "$_tmpfile"

    _new_token=$(json_extract_field "$_tmpfile" "access_token")
    _auth_url=$(json_extract_field "$_tmpfile" "auth_url")
    rm -f "$_tmpfile"

    echo "=== Token Revoked ==="
    echo "New access_token: $_new_token"
    echo "Auth URL (open in browser, valid 5 min): $_auth_url"
    echo ""
    echo "Update your config/.env with the new token."
    exit 0
fi

if [ -z "$SHORT_NAME" ]; then
    echo "Usage: sh create_account.sh --name \"Your Name\" [--author-url URL]" >&2
    echo "       sh create_account.sh --revoke" >&2
    exit 1
fi

# Build curl args as proper argv
set -- --data-urlencode "short_name=$SHORT_NAME"
if [ -n "$AUTHOR_NAME" ]; then
    set -- "$@" --data-urlencode "author_name=$AUTHOR_NAME"
fi
if [ -n "$AUTHOR_URL" ]; then
    set -- "$@" --data-urlencode "author_url=$AUTHOR_URL"
fi

_result=$(telegraph_post "createAccount" "$@")

_tmpfile="${TPH_TMPDIR}/telegraph_create_$$.json"
printf '%s' "$_result" > "$_tmpfile"

_token=$(json_extract_field "$_tmpfile" "access_token")
_auth_url=$(json_extract_field "$_tmpfile" "auth_url")
_short=$(json_extract_field "$_tmpfile" "short_name")
rm -f "$_tmpfile"

echo "=== Telegraph Account Created ==="
echo "Short name:    $_short"
echo "Access token:  $_token"
echo "Auth URL:      $_auth_url"
echo ""
echo "Next steps:"
echo "1. Save the token to config/.env:"
echo "   TELEGRAPH_ACCESS_TOKEN=$_token"
echo ""
echo "2. Open Auth URL in browser (valid 5 min, single use)"
echo "   to bind this account to your browser session."
echo "   After that, pages you create will be visible at telegra.ph"

#!/bin/sh
# Create a Telegraph page with auto-split for large content
# Usage:
#   sh create_page.sh --title "My Article" --content-file content.json
#   sh create_page.sh --title "My Article" --html-file article.html
#   sh create_page.sh --title "My Article" --html "<p>Hello</p>"
#   sh create_page.sh --title "My Article" --html-file big.html --author-name "Author"

set -e

SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
. "$SCRIPT_DIR/common.sh"
load_config

# Parse arguments
TITLE=""
CONTENT_FILE=""
HTML_FILE=""
HTML_INLINE=""
AUTHOR_NAME=""
AUTHOR_URL=""

while [ $# -gt 0 ]; do
    case "$1" in
        --title)        TITLE="$2"; shift 2 ;;
        --content-file) CONTENT_FILE="$2"; shift 2 ;;
        --html-file)    HTML_FILE="$2"; shift 2 ;;
        --html)         HTML_INLINE="$2"; shift 2 ;;
        --author-name)  AUTHOR_NAME="$2"; shift 2 ;;
        --author-url)   AUTHOR_URL="$2"; shift 2 ;;
        *)              shift ;;
    esac
done

if [ -z "$TITLE" ]; then
    echo "Usage: sh create_page.sh --title TITLE (--content-file FILE | --html-file FILE | --html HTML)" >&2
    exit 1
fi

# --------------- Resolve content to Node JSON ---------------

if [ -n "$CONTENT_FILE" ]; then
    if [ ! -f "$CONTENT_FILE" ]; then
        echo "Error: Content file not found: $CONTENT_FILE" >&2
        exit 1
    fi
    _content=$(cat "$CONTENT_FILE")
elif [ -n "$HTML_FILE" ]; then
    if [ ! -f "$HTML_FILE" ]; then
        echo "Error: HTML file not found: $HTML_FILE" >&2
        exit 1
    fi
    _content=$(python3 "$SCRIPT_DIR/content_converter.py" < "$HTML_FILE")
elif [ -n "$HTML_INLINE" ]; then
    _content=$(printf '%s' "$HTML_INLINE" | python3 "$SCRIPT_DIR/content_converter.py")
else
    echo "Error: Provide --content-file, --html-file, or --html" >&2
    exit 1
fi

# --------------- Helper: build common author args ---------------
# Appends --data-urlencode author_name/author_url to positional params
# Call: _build_author_args; then use "$@"
_build_author_args() {
    if [ -n "$AUTHOR_NAME" ]; then
        set -- "$@" --data-urlencode "author_name=$AUTHOR_NAME"
    fi
    if [ -n "$AUTHOR_URL" ]; then
        set -- "$@" --data-urlencode "author_url=$AUTHOR_URL"
    fi
    # Return args via stdout, one per line — caller collects
}

# --------------- Check size and split if needed ---------------

_size=$(printf '%s' "$_content" | python3 "$SCRIPT_DIR/content_converter.py" --check-size)

if [ "$_size" -gt 61440 ]; then
    echo "Content size: ${_size} bytes (limit: 64KB). Auto-splitting..." >&2

    # Create work directory
    WORK_DIR="${TPH_TMPDIR}/telegraph_split_$$"
    mkdir -p "$WORK_DIR"
    trap 'rm -rf "$WORK_DIR"' EXIT

    # Split content
    printf '%s' "$_content" | python3 "$SCRIPT_DIR/content_converter.py" --split --output-dir "$WORK_DIR"

    # Count parts
    _part_count=$(ls "$WORK_DIR"/part_*.json 2>/dev/null | wc -l | tr -d ' ')

    if [ "$_part_count" -eq 0 ]; then
        echo "Error: Split produced no parts." >&2
        exit 1
    fi

    echo "Split into $_part_count parts." >&2

    # Create child pages (from last to first), collect URLs into a file
    _urls_file="$WORK_DIR/part_urls.txt"
    : > "$_urls_file"

    _part_num="$_part_count"
    while [ "$_part_num" -ge 1 ]; do
        _part_file="$WORK_DIR/part_${_part_num}.json"
        _part_title="${TITLE} — part ${_part_num}"
        _part_content=$(cat "$_part_file")

        set -- -d "access_token=$TELEGRAPH_ACCESS_TOKEN"
        set -- "$@" --data-urlencode "title=$_part_title"
        set -- "$@" --data-urlencode "content=$_part_content"
        set -- "$@" -d "return_content=false"
        if [ -n "$AUTHOR_NAME" ]; then
            set -- "$@" --data-urlencode "author_name=$AUTHOR_NAME"
        fi
        if [ -n "$AUTHOR_URL" ]; then
            set -- "$@" --data-urlencode "author_url=$AUTHOR_URL"
        fi

        _result=$(telegraph_post "createPage" "$@")

        _result_file="${WORK_DIR}/result_${_part_num}.json"
        printf '%s' "$_result" > "$_result_file"
        _url=$(json_extract_field "$_result_file" "url")
        echo "${_part_num}|${_url}" >> "$_urls_file"

        echo "  Part $_part_num: $_url" >&2
        _part_num=$(( _part_num - 1 ))
    done

    # Build index page content via Python (safe JSON construction)
    _index_content=$(python3 -c "
import json, sys
lines = open('$_urls_file').read().strip().split('\n')
lines.sort(key=lambda l: int(l.split('|')[0]))
total = len(lines)
nodes = [{'tag': 'p', 'children': ['This article was split into ' + str(total) + ' parts due to size.']}]
for line in lines:
    if not line.strip():
        continue
    num, url = line.strip().split('|', 1)
    nodes.append({'tag': 'p', 'children': [{'tag': 'a', 'attrs': {'href': url}, 'children': ['Part ' + num]}]})
print(json.dumps(nodes, ensure_ascii=False))
")

    set -- -d "access_token=$TELEGRAPH_ACCESS_TOKEN"
    set -- "$@" --data-urlencode "title=$TITLE"
    set -- "$@" --data-urlencode "content=$_index_content"
    set -- "$@" -d "return_content=false"
    if [ -n "$AUTHOR_NAME" ]; then
        set -- "$@" --data-urlencode "author_name=$AUTHOR_NAME"
    fi
    if [ -n "$AUTHOR_URL" ]; then
        set -- "$@" --data-urlencode "author_url=$AUTHOR_URL"
    fi

    _result=$(telegraph_post "createPage" "$@")

    _result_file="${WORK_DIR}/result_index.json"
    printf '%s' "$_result" > "$_result_file"
    _url=$(json_extract_field "$_result_file" "url")
    _path=$(json_extract_field "$_result_file" "path")

    echo ""
    echo "=== Article Published (multi-part) ==="
    echo "Index URL: $_url"
    echo "Path:      $_path"
    echo "Parts:     $_part_count"
    exit 0
fi

# --------------- Single page publish ---------------

set -- -d "access_token=$TELEGRAPH_ACCESS_TOKEN"
set -- "$@" --data-urlencode "title=$TITLE"
set -- "$@" --data-urlencode "content=$_content"
set -- "$@" -d "return_content=false"

if [ -n "$AUTHOR_NAME" ]; then
    set -- "$@" --data-urlencode "author_name=$AUTHOR_NAME"
fi
if [ -n "$AUTHOR_URL" ]; then
    set -- "$@" --data-urlencode "author_url=$AUTHOR_URL"
fi

_result=$(telegraph_post "createPage" "$@")

_tmpfile="${TPH_TMPDIR}/telegraph_create_page_$$.json"
printf '%s' "$_result" > "$_tmpfile"

_url=$(json_extract_field "$_tmpfile" "url")
_path=$(json_extract_field "$_tmpfile" "path")
rm -f "$_tmpfile"

echo "=== Page Published ==="
echo "URL:  $_url"
echo "Path: $_path"

#!/usr/bin/env python3
"""Encode diagram source for PlantUML/Mermaid public rendering servers.

Usage:
  python3 diagram_encode.py plantuml < diagram.puml
  python3 diagram_encode.py mermaid < diagram.mmd
  echo "graph LR; A-->B" | python3 diagram_encode.py mermaid

Output: full render URL

PlantUML: https://www.plantuml.com/plantuml/png/ENCODED
Mermaid:  https://mermaid.ink/img/pako:ENCODED
"""

import base64
import json
import sys
import zlib


# --------------- PlantUML encoding ---------------

# PlantUML uses a custom 6-bit encoding with a specific alphabet
PLANTUML_ALPHABET = (
    '0123456789'
    'ABCDEFGHIJ'
    'KLMNOPQRST'
    'UVWXYZ'
    'abcdefghij'
    'klmnopqrst'
    'uvwxyz'
    '-_'
)


def _plantuml_encode_6bit(b):
    """Encode a single 6-bit value to PlantUML alphabet char."""
    if 0 <= b < len(PLANTUML_ALPHABET):
        return PLANTUML_ALPHABET[b]
    return '?'


def _plantuml_encode_3bytes(b1, b2, b3):
    """Encode 3 bytes into 4 PlantUML chars."""
    c1 = b1 >> 2
    c2 = ((b1 & 0x3) << 4) | (b2 >> 4)
    c3 = ((b2 & 0xF) << 2) | (b3 >> 6)
    c4 = b3 & 0x3F
    return (
        _plantuml_encode_6bit(c1)
        + _plantuml_encode_6bit(c2)
        + _plantuml_encode_6bit(c3)
        + _plantuml_encode_6bit(c4)
    )


def encode_plantuml(text):
    """Encode PlantUML source to URL-safe string for plantuml.com."""
    data = zlib.compress(text.encode('utf-8'), 9)
    # Strip zlib header (2 bytes) and checksum (4 bytes) for raw deflate
    data = data[2:-4]

    result = ''
    i = 0
    while i < len(data):
        if i + 2 < len(data):
            result += _plantuml_encode_3bytes(data[i], data[i + 1], data[i + 2])
        elif i + 1 < len(data):
            result += _plantuml_encode_3bytes(data[i], data[i + 1], 0)
        else:
            result += _plantuml_encode_3bytes(data[i], 0, 0)
        i += 3

    return f'https://www.plantuml.com/plantuml/png/{result}'


# --------------- Mermaid encoding ---------------

def encode_mermaid(text):
    """Encode Mermaid source to URL for mermaid.ink.

    Format: https://mermaid.ink/img/pako:PAYLOAD
    PAYLOAD = URL-safe base64 (no padding) of raw deflate of compact JSON.
    """
    payload = json.dumps(
        {'code': text, 'mermaid': {'theme': 'default'}},
        separators=(',', ':'),
        ensure_ascii=False
    )

    # pako.deflate output (full zlib with header+checksum, not raw deflate)
    compressed = zlib.compress(payload.encode('utf-8'), 9)

    # URL-safe base64 without padding
    encoded = base64.urlsafe_b64encode(compressed).rstrip(b'=').decode('ascii')

    return f'https://mermaid.ink/img/pako:{encoded}'


# --------------- CLI ---------------

def main():
    if len(sys.argv) < 2 or sys.argv[1] not in ('plantuml', 'mermaid'):
        print('Usage: python3 diagram_encode.py plantuml|mermaid < source', file=sys.stderr)
        sys.exit(1)

    diagram_type = sys.argv[1]
    source = sys.stdin.read()

    if not source.strip():
        print('Error: Empty diagram source.', file=sys.stderr)
        sys.exit(1)

    if diagram_type == 'plantuml':
        print(encode_plantuml(source))
    else:
        print(encode_mermaid(source))


if __name__ == '__main__':
    main()

#!/bin/sh
# Edit an existing Telegraph page
# Usage:
#   sh edit_page.sh --path "Page-Title-03-09" --title "New Title" --content-file content.json
#   sh edit_page.sh --path "Page-Title-03-09" --title "New Title" --html-file article.html
#   sh edit_page.sh --path "Page-Title-03-09" --title "New Title" --html "<p>Inline HTML</p>"

set -e

SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
. "$SCRIPT_DIR/common.sh"
load_config

# Parse arguments
PAGE_PATH=""
TITLE=""
CONTENT_FILE=""
HTML_FILE=""
HTML_INLINE=""
AUTHOR_NAME=""
AUTHOR_URL=""

while [ $# -gt 0 ]; do
    case "$1" in
        --path)         PAGE_PATH="$2"; shift 2 ;;
        --title)        TITLE="$2"; shift 2 ;;
        --content-file) CONTENT_FILE="$2"; shift 2 ;;
        --html-file)    HTML_FILE="$2"; shift 2 ;;
        --html)         HTML_INLINE="$2"; shift 2 ;;
        --author-name)  AUTHOR_NAME="$2"; shift 2 ;;
        --author-url)   AUTHOR_URL="$2"; shift 2 ;;
        *)              shift ;;
    esac
done

if [ -z "$PAGE_PATH" ] || [ -z "$TITLE" ]; then
    echo "Usage: sh edit_page.sh --path PATH --title TITLE (--content-file FILE | --html-file FILE | --html HTML)" >&2
    exit 1
fi

# Resolve content
if [ -n "$CONTENT_FILE" ]; then
    if [ ! -f "$CONTENT_FILE" ]; then
        echo "Error: Content file not found: $CONTENT_FILE" >&2
        exit 1
    fi
    _content=$(cat "$CONTENT_FILE")
elif [ -n "$HTML_FILE" ]; then
    if [ ! -f "$HTML_FILE" ]; then
        echo "Error: HTML file not found: $HTML_FILE" >&2
        exit 1
    fi
    _content=$(python3 "$SCRIPT_DIR/content_converter.py" < "$HTML_FILE")
elif [ -n "$HTML_INLINE" ]; then
    _content=$(printf '%s' "$HTML_INLINE" | python3 "$SCRIPT_DIR/content_converter.py")
else
    echo "Error: Provide --content-file, --html-file, or --html" >&2
    exit 1
fi

# Build request as proper argv
set -- -d "access_token=$TELEGRAPH_ACCESS_TOKEN"
set -- "$@" --data-urlencode "title=$TITLE"
set -- "$@" --data-urlencode "content=$_content"
set -- "$@" -d "return_content=false"

if [ -n "$AUTHOR_NAME" ]; then
    set -- "$@" --data-urlencode "author_name=$AUTHOR_NAME"
fi
if [ -n "$AUTHOR_URL" ]; then
    set -- "$@" --data-urlencode "author_url=$AUTHOR_URL"
fi

_result=$(telegraph_post "editPage/$PAGE_PATH" "$@")

_tmpfile="${TPH_TMPDIR}/telegraph_edit_$$.json"
printf '%s' "$_result" > "$_tmpfile"

_url=$(json_extract_field "$_tmpfile" "url")
_path=$(json_extract_field "$_tmpfile" "path")
rm -f "$_tmpfile"

echo "=== Page Updated ==="
echo "URL:  $_url"
echo "Path: $_path"

#!/bin/sh
# Delete all GitHub-backed assets for a Telegraph page using its manifest.
#
# Usage:
#   sh github_delete_page_assets.sh --page-path my-page-path

set -e

SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
. "$SCRIPT_DIR/common.sh"

check_prerequisites
load_github_config

PAGE_PATH=""

while [ $# -gt 0 ]; do
    case "$1" in
        --page-path) PAGE_PATH="$2"; shift 2 ;;
        *) shift ;;
    esac
done

if [ -z "$PAGE_PATH" ]; then
    echo "Usage: sh github_delete_page_assets.sh --page-path TELEGRAPH_PATH" >&2
    exit 1
fi

TMP_DIR=$(make_secure_tmpdir)
trap 'rm -rf "$TMP_DIR"' EXIT

MANIFEST_REPO_PATH="${GITHUB_MANIFESTS_DIR%/}/${PAGE_PATH}.json"
MANIFEST_RESPONSE="$TMP_DIR/manifest_response.json"
MANIFEST_BODY="$TMP_DIR/manifest_body.json"
ASSETS_LIST="$TMP_DIR/assets.tsv"

set -- \
    -H "Accept: application/vnd.github+json" \
    -H "Authorization: Bearer $GITHUB_TOKEN" \
    -H "X-GitHub-Api-Version: 2022-11-28"
MANIFEST_GET_CODE=$(curl -sS -o "$MANIFEST_RESPONSE" -w '%{http_code}' "$@" \
    "${GITHUB_API}/repos/${GITHUB_ASSETS_REPO}/contents/${MANIFEST_REPO_PATH}?ref=${GITHUB_ASSETS_BRANCH}")

case "$MANIFEST_GET_CODE" in
    200) ;;
    404)
        echo "Error: Manifest not found for page path: ${PAGE_PATH}" >&2
        echo "Expected: ${MANIFEST_REPO_PATH}" >&2
        exit 1
        ;;
    *)
        echo "Error: GitHub manifest lookup failed for ${MANIFEST_REPO_PATH} (HTTP ${MANIFEST_GET_CODE})." >&2
        cat "$MANIFEST_RESPONSE" >&2
        exit 1
        ;;
esac

MANIFEST_SHA=$(python3 - "$MANIFEST_RESPONSE" "$MANIFEST_BODY" <<'PY'
import base64, json, sys
data = json.load(open(sys.argv[1]))
print(data.get("sha", ""))
content = data.get("content", "")
if content:
    decoded = base64.b64decode(content)
    open(sys.argv[2], "w", encoding="utf-8").write(decoded.decode("utf-8"))
PY
)

python3 "$SCRIPT_DIR/github_manifest.py" list < "$MANIFEST_BODY" > "$ASSETS_LIST"

DELETED_COUNT=0
TAB=$(printf '\t')
while IFS="$TAB" read -r ASSET_PATH ASSET_SHA ASSET_CDN_URL ASSET_COMMIT_SHA; do
    [ -z "$ASSET_PATH" ] && continue

    if [ -z "$ASSET_SHA" ]; then
        echo "Warning: Missing SHA for asset ${ASSET_PATH}, fetching current SHA..." >&2
        ASSET_META_RESPONSE="$TMP_DIR/asset_meta_$$.json"
        set -- \
            -H "Accept: application/vnd.github+json" \
            -H "Authorization: Bearer $GITHUB_TOKEN" \
            -H "X-GitHub-Api-Version: 2022-11-28"
        ASSET_META_CODE=$(curl -sS -o "$ASSET_META_RESPONSE" -w '%{http_code}' "$@" \
            "${GITHUB_API}/repos/${GITHUB_ASSETS_REPO}/contents/${ASSET_PATH}?ref=${GITHUB_ASSETS_BRANCH}")
        case "$ASSET_META_CODE" in
            200)
                ASSET_SHA=$(python3 - "$ASSET_META_RESPONSE" <<'PY'
import json, sys
data = json.load(open(sys.argv[1]))
print(data.get("sha", ""))
PY
)
                ;;
            404)
                echo "Warning: Asset already missing: ${ASSET_PATH}" >&2
                continue
                ;;
            *)
                echo "Error: Failed to fetch SHA for ${ASSET_PATH} (HTTP ${ASSET_META_CODE})." >&2
                cat "$ASSET_META_RESPONSE" >&2
                exit 1
                ;;
        esac
    fi

    DELETE_PAYLOAD=$(python3 - "$ASSET_PATH" "$ASSET_SHA" "$GITHUB_ASSETS_BRANCH" <<'PY'
import json, sys
asset_path, sha, branch = sys.argv[1:4]
print(json.dumps({
    "message": f"telegraph-publisher: delete {asset_path}",
    "sha": sha,
    "branch": branch,
}, separators=(",", ":")))
PY
)

ASSET_DELETE_RESPONSE="$TMP_DIR/delete_$$.json"
    set -- \
        -H "Accept: application/vnd.github+json" \
        -H "Authorization: Bearer $GITHUB_TOKEN" \
        -H "X-GitHub-Api-Version: 2022-11-28" \
        -H "Content-Type: application/json"
    ASSET_DELETE_CODE=$(printf '%s' "$DELETE_PAYLOAD" | curl -sS -o "$ASSET_DELETE_RESPONSE" -w '%{http_code}' "$@" \
    -X DELETE \
    -d @- \
    "${GITHUB_API}/repos/${GITHUB_ASSETS_REPO}/contents/${ASSET_PATH}")

    case "$ASSET_DELETE_CODE" in
        200)
            DELETED_COUNT=$(( DELETED_COUNT + 1 ))
            echo "Deleted asset: ${ASSET_PATH}" >&2
            ;;
        404)
            echo "Warning: Asset already missing: ${ASSET_PATH}" >&2
            ;;
        *)
            echo "Error: Failed to delete asset ${ASSET_PATH} (HTTP ${ASSET_DELETE_CODE})." >&2
            cat "$ASSET_DELETE_RESPONSE" >&2
            exit 1
            ;;
    esac
done < "$ASSETS_LIST"

MANIFEST_DELETE_PAYLOAD=$(python3 - "$MANIFEST_REPO_PATH" "$MANIFEST_SHA" "$GITHUB_ASSETS_BRANCH" <<'PY'
import json, sys
manifest_path, sha, branch = sys.argv[1:4]
print(json.dumps({
    "message": f"telegraph-publisher: delete manifest {manifest_path}",
    "sha": sha,
    "branch": branch,
}, separators=(",", ":")))
PY
)

MANIFEST_DELETE_RESPONSE="$TMP_DIR/delete_manifest.json"
set -- \
    -H "Accept: application/vnd.github+json" \
    -H "Authorization: Bearer $GITHUB_TOKEN" \
    -H "X-GitHub-Api-Version: 2022-11-28" \
    -H "Content-Type: application/json"
MANIFEST_DELETE_CODE=$(printf '%s' "$MANIFEST_DELETE_PAYLOAD" | curl -sS -o "$MANIFEST_DELETE_RESPONSE" -w '%{http_code}' "$@" \
    -X DELETE \
    -d @- \
    "${GITHUB_API}/repos/${GITHUB_ASSETS_REPO}/contents/${MANIFEST_REPO_PATH}")

case "$MANIFEST_DELETE_CODE" in
    200)
        echo "Deleted manifest: ${MANIFEST_REPO_PATH}" >&2
        ;;
    *)
        echo "Error: Failed to delete manifest ${MANIFEST_REPO_PATH} (HTTP ${MANIFEST_DELETE_CODE})." >&2
        cat "$MANIFEST_DELETE_RESPONSE" >&2
        exit 1
        ;;
esac

echo "Deleted ${DELETED_COUNT} asset(s) for page path ${PAGE_PATH}."

#!/usr/bin/env python3
"""Helpers for Telegraph GitHub asset manifests.

Commands:
  merge <page_path> <asset_path> <asset_sha> <cdn_url> <commit_sha>
  list
"""

from __future__ import annotations

import json
import sys
from datetime import datetime, timezone


def utc_now() -> str:
    return (
        datetime.now(timezone.utc)
        .replace(microsecond=0)
        .isoformat()
        .replace("+00:00", "Z")
    )


def read_manifest() -> dict:
    raw = sys.stdin.read().strip()
    if not raw:
        return {}
    return json.loads(raw)


def cmd_merge(args: list[str]) -> int:
    if len(args) != 5:
        print(
            "Usage: github_manifest.py merge <page_path> <asset_path> <asset_sha> <cdn_url> <commit_sha>",
            file=sys.stderr,
        )
        return 1

    page_path, asset_path, asset_sha, cdn_url, commit_sha = args
    manifest = read_manifest() or {}
    assets = manifest.get("assets", [])

    updated_asset = {
        "path": asset_path,
        "sha": asset_sha,
        "cdn_url": cdn_url,
        "commit_sha": commit_sha,
    }

    replaced = False
    result_assets = []
    for asset in assets:
        if asset.get("path") == asset_path:
            result_assets.append(updated_asset)
            replaced = True
        else:
            result_assets.append(asset)
    if not replaced:
        result_assets.append(updated_asset)

    result_assets.sort(key=lambda item: item.get("path", ""))

    manifest = {
        "path": page_path,
        "assets": result_assets,
        "updated_at": utc_now(),
    }
    print(json.dumps(manifest, ensure_ascii=False, indent=2))
    return 0


def cmd_list() -> int:
    manifest = read_manifest()
    for asset in manifest.get("assets", []):
        print(
            "\t".join(
                [
                    asset.get("path", ""),
                    asset.get("sha", ""),
                    asset.get("cdn_url", ""),
                    asset.get("commit_sha", ""),
                ]
            )
        )
    return 0


def main() -> int:
    if len(sys.argv) < 2:
        print("Usage: github_manifest.py <merge|list> ...", file=sys.stderr)
        return 1

    cmd = sys.argv[1]
    if cmd == "merge":
        return cmd_merge(sys.argv[2:])
    if cmd == "list":
        return cmd_list()

    print(f"Unknown command: {cmd}", file=sys.stderr)
    return 1


if __name__ == "__main__":
    raise SystemExit(main())

#!/bin/sh
# Upload a local asset to GitHub Contents API and register it in the page manifest.
#
# Usage:
#   sh github_upload.sh --file ./hero.webp --page-path my-page-path
#   sh github_upload.sh --file ./hero.webp --page-path my-page-path --name hero.webp

set -e

SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
. "$SCRIPT_DIR/common.sh"

check_prerequisites
load_github_config

FILE=""
PAGE_PATH=""
ASSET_NAME=""

while [ $# -gt 0 ]; do
    case "$1" in
        --file) FILE="$2"; shift 2 ;;
        --page-path) PAGE_PATH="$2"; shift 2 ;;
        --name) ASSET_NAME="$2"; shift 2 ;;
        *) shift ;;
    esac
done

if [ -z "$FILE" ] || [ -z "$PAGE_PATH" ]; then
    echo "Usage: sh github_upload.sh --file FILE --page-path TELEGRAPH_PATH [--name NAME]" >&2
    exit 1
fi

if [ ! -f "$FILE" ]; then
    echo "Error: File not found: $FILE" >&2
    exit 1
fi

if [ -z "$ASSET_NAME" ]; then
    ASSET_NAME=$(slugify_filename "$FILE")
fi

TMP_DIR=$(make_secure_tmpdir)
trap 'rm -rf "$TMP_DIR"' EXIT

REPO_PATH="${GITHUB_ASSETS_BASE_DIR%/}/${PAGE_PATH}/${ASSET_NAME}"
MANIFEST_REPO_PATH="${GITHUB_MANIFESTS_DIR%/}/${PAGE_PATH}.json"
FILE_B64=$(base64 < "$FILE" | tr -d '\n')

ASSET_GET_RESPONSE="$TMP_DIR/asset_get.json"
ASSET_PUT_RESPONSE="$TMP_DIR/asset_put.json"
MANIFEST_GET_RESPONSE="$TMP_DIR/manifest_get.json"
MANIFEST_BODY="$TMP_DIR/manifest_body.json"
MANIFEST_PUT_RESPONSE="$TMP_DIR/manifest_put.json"

ASSET_SHA=""
MANIFEST_SHA=""

set -- \
    -H "Accept: application/vnd.github+json" \
    -H "Authorization: Bearer $GITHUB_TOKEN" \
    -H "X-GitHub-Api-Version: 2022-11-28"
ASSET_GET_CODE=$(curl -sS -o "$ASSET_GET_RESPONSE" -w '%{http_code}' "$@" \
    "${GITHUB_API}/repos/${GITHUB_ASSETS_REPO}/contents/${REPO_PATH}?ref=${GITHUB_ASSETS_BRANCH}")

case "$ASSET_GET_CODE" in
    200)
        ASSET_SHA=$(python3 - "$ASSET_GET_RESPONSE" <<'PY'
import json, sys
data = json.load(open(sys.argv[1]))
print(data.get("sha", ""))
PY
)
        ;;
    404) ;;
    *)
        echo "Error: GitHub asset lookup failed for ${REPO_PATH} (HTTP ${ASSET_GET_CODE})." >&2
        cat "$ASSET_GET_RESPONSE" >&2
        exit 1
        ;;
esac

ASSET_PAYLOAD=$(python3 - "$REPO_PATH" "$ASSET_SHA" "$GITHUB_ASSETS_BRANCH" "$FILE_B64" <<'PY'
import json, sys
repo_path, sha, branch, content = sys.argv[1:5]
payload = {
    "message": f"telegraph-publisher: upsert {repo_path}",
    "content": content,
    "branch": branch,
}
if sha:
    payload["sha"] = sha
print(json.dumps(payload, separators=(",", ":")))
PY
)

set -- \
    -H "Accept: application/vnd.github+json" \
    -H "Authorization: Bearer $GITHUB_TOKEN" \
    -H "X-GitHub-Api-Version: 2022-11-28" \
    -H "Content-Type: application/json"
ASSET_PUT_CODE=$(printf '%s' "$ASSET_PAYLOAD" | curl -sS -o "$ASSET_PUT_RESPONSE" -w '%{http_code}' "$@" \
    -X PUT \
    -d @- \
    "${GITHUB_API}/repos/${GITHUB_ASSETS_REPO}/contents/${REPO_PATH}")

case "$ASSET_PUT_CODE" in
    200|201) ;;
    *)
        echo "Error: GitHub asset upload failed for ${REPO_PATH} (HTTP ${ASSET_PUT_CODE})." >&2
        cat "$ASSET_PUT_RESPONSE" >&2
        exit 1
        ;;
esac

ASSET_META=$(python3 - "$ASSET_PUT_RESPONSE" <<'PY'
import json, sys
data = json.load(open(sys.argv[1]))
content = data.get("content", {})
commit = data.get("commit", {})
print(content.get("path", ""))
print(content.get("sha", ""))
print(commit.get("sha", ""))
PY
)

ASSET_PATH=$(printf '%s\n' "$ASSET_META" | sed -n '1p')
ASSET_SHA=$(printf '%s\n' "$ASSET_META" | sed -n '2p')
COMMIT_SHA=$(printf '%s\n' "$ASSET_META" | sed -n '3p')

if [ -z "$ASSET_PATH" ] || [ -z "$ASSET_SHA" ] || [ -z "$COMMIT_SHA" ]; then
    echo "Error: Unexpected GitHub upload response." >&2
    cat "$ASSET_PUT_RESPONSE" >&2
    exit 1
fi

CDN_URL="https://cdn.jsdelivr.net/gh/${GITHUB_ASSETS_REPO}@${COMMIT_SHA}/${ASSET_PATH}"

: > "$MANIFEST_BODY"
set -- \
    -H "Accept: application/vnd.github+json" \
    -H "Authorization: Bearer $GITHUB_TOKEN" \
    -H "X-GitHub-Api-Version: 2022-11-28"
MANIFEST_GET_CODE=$(curl -sS -o "$MANIFEST_GET_RESPONSE" -w '%{http_code}' "$@" \
    "${GITHUB_API}/repos/${GITHUB_ASSETS_REPO}/contents/${MANIFEST_REPO_PATH}?ref=${GITHUB_ASSETS_BRANCH}")

case "$MANIFEST_GET_CODE" in
    200)
        MANIFEST_SHA=$(python3 - "$MANIFEST_GET_RESPONSE" "$MANIFEST_BODY" <<'PY'
import base64, json, sys
data = json.load(open(sys.argv[1]))
print(data.get("sha", ""))
content = data.get("content", "")
if content:
    decoded = base64.b64decode(content)
    open(sys.argv[2], "w", encoding="utf-8").write(decoded.decode("utf-8"))
PY
)
        ;;
    404) ;;
    *)
        echo "Error: GitHub manifest lookup failed for ${MANIFEST_REPO_PATH} (HTTP ${MANIFEST_GET_CODE})." >&2
        cat "$MANIFEST_GET_RESPONSE" >&2
        exit 1
        ;;
esac

MANIFEST_JSON=$(python3 "$SCRIPT_DIR/github_manifest.py" merge \
    "$PAGE_PATH" "$ASSET_PATH" "$ASSET_SHA" "$CDN_URL" "$COMMIT_SHA" < "$MANIFEST_BODY")
MANIFEST_B64=$(printf '%s' "$MANIFEST_JSON" | base64 | tr -d '\n')

MANIFEST_PAYLOAD=$(python3 - "$MANIFEST_REPO_PATH" "$MANIFEST_SHA" "$GITHUB_ASSETS_BRANCH" "$MANIFEST_B64" <<'PY'
import json, sys
repo_path, sha, branch, content = sys.argv[1:5]
payload = {
    "message": f"telegraph-publisher: update manifest {repo_path}",
    "content": content,
    "branch": branch,
}
if sha:
    payload["sha"] = sha
print(json.dumps(payload, separators=(",", ":")))
PY
)

set -- \
    -H "Accept: application/vnd.github+json" \
    -H "Authorization: Bearer $GITHUB_TOKEN" \
    -H "X-GitHub-Api-Version: 2022-11-28" \
    -H "Content-Type: application/json"
MANIFEST_PUT_CODE=$(printf '%s' "$MANIFEST_PAYLOAD" | curl -sS -o "$MANIFEST_PUT_RESPONSE" -w '%{http_code}' "$@" \
    -X PUT \
    -d @- \
    "${GITHUB_API}/repos/${GITHUB_ASSETS_REPO}/contents/${MANIFEST_REPO_PATH}")

case "$MANIFEST_PUT_CODE" in
    200|201) ;;
    *)
        echo "Error: GitHub manifest update failed for ${MANIFEST_REPO_PATH} (HTTP ${MANIFEST_PUT_CODE})." >&2
        cat "$MANIFEST_PUT_RESPONSE" >&2
        exit 1
        ;;
esac

echo "$CDN_URL"
echo "GitHub asset stored: ${ASSET_PATH}" >&2
echo "Manifest updated: ${MANIFEST_REPO_PATH}" >&2