jumper-app 0.1.0

package/dist/cli.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+const DEFAULT_RELAY_URL = "wss://relay.jumper.sh";
+function printHelp() {
+    process.stdout.write([
+        "jumper-app",
+        "",
+        "Starts the Jumper bridge server for the iOS app.",
+        "",
+        "Environment variables:",
+        "  PORT         HTTP/WebSocket port (default: 8787)",
+        "  HOST         Bind host (default: 0.0.0.0)",
+        "  PUBLIC_HOST  Public host:port shown in connect instructions",
+        `  RELAY_URL    Relay websocket URL (default: ${DEFAULT_RELAY_URL})`,
+        "",
+        "Examples:",
+        "  npx jumper-app",
+        "  PORT=9000 npx jumper-app",
+        "  RELAY_URL= npx jumper-app",
+        "",
+    ].join("\n"));
+}
+if (process.argv.includes("--help") || process.argv.includes("-h")) {
+    printHelp();
+    process.exit(0);
+}
+if (!process.env.RELAY_URL) {
+    process.env.RELAY_URL = DEFAULT_RELAY_URL;
+}
+await import("./index.js");
+export {};

package/dist/index.js

@@ -0,0 +1,941 @@
+import { spawn } from "node:child_process";
+import crypto from "node:crypto";
+import { existsSync } from "node:fs";
+import fs from "node:fs/promises";
+import http from "node:http";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+import QRCode from "qrcode";
+import { WebSocketServer } from "ws";
+import { RelayClient } from "./relay-client.js";
+import { loadRelaySession, nowIso, loadState, saveRelaySession, saveState } from "./state.js";
+const PORT = Number(process.env.PORT ?? "8787");
+const HOST = process.env.HOST ?? "0.0.0.0";
+const RELAY_URL = process.env.RELAY_URL;
+const PROJECTS_ROOT = process.env.PROJECTS_ROOT ?? path.join(os.homedir(), "dev", "cc-bridge-projects");
+const KEYBOARD_TIMEOUT_MS = 20_000;
+const MAX_SELECTED_TEXT_CHARS = 2_000;
+const MAX_CONTEXT_SIDE_CHARS = 1_000;
+const MAX_CONVERSATION_ENTRY_CHARS = 600;
+const MAX_CONVERSATION_ENTRIES = 12;
+function slugify(name) {
+    const s = name
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9-_]+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "");
+    if (!s)
+        throw new Error("Invalid project name");
+    return s;
+}
+function isObject(v) {
+    return typeof v === "object" && v !== null;
+}
+function expandHomePath(input) {
+    const trimmed = input.trim();
+    if (trimmed === "~")
+        return os.homedir();
+    if (trimmed.startsWith("~/"))
+        return path.join(os.homedir(), trimmed.slice(2));
+    if (trimmed.startsWith("~\\"))
+        return path.join(os.homedir(), trimmed.slice(2));
+    return trimmed;
+}
+function normalizeProjectPath(input) {
+    const trimmed = input.trim();
+    if (trimmed.length === 0)
+        throw new Error("Project path cannot be empty");
+    const expanded = expandHomePath(trimmed);
+    if (path.isAbsolute(expanded)) {
+        return path.normalize(expanded);
+    }
+    // Relative paths from mobile are ambiguous; anchor them to the user's home directory.
+    return path.resolve(os.homedir(), expanded);
+}
+async function normalizeStateProjectPaths(state) {
+    const normalizedProjects = state.projects.map((project) => {
+        const normalizedPath = normalizeProjectPath(project.path);
+        if (normalizedPath === project.path)
+            return project;
+        return { ...project, path: normalizedPath };
+    });
+    const changed = normalizedProjects.some((project, index) => project !== state.projects[index]);
+    if (!changed)
+        return state;
+    const next = { ...state, projects: normalizedProjects };
+    await saveState(next);
+    return next;
+}
+function claudeProjectDir(cwd) {
+    return path.join(os.homedir(), ".claude", "projects", cwd.split(path.sep).join("-"));
+}
+function claudeHistoryCandidates(projectPath) {
+    const trimmed = projectPath.trim();
+    const expanded = expandHomePath(trimmed);
+    const resolvedRaw = path.resolve(trimmed);
+    const resolvedExpanded = path.resolve(expanded);
+    return Array.from(new Set([trimmed, expanded, resolvedRaw, resolvedExpanded].filter((v) => v.length > 0)));
+}
+async function findHistoryFileBySessionId(sessionId) {
+    const projectsDir = path.join(os.homedir(), ".claude", "projects");
+    if (!existsSync(projectsDir))
+        return undefined;
+    const entries = await fs.readdir(projectsDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const candidate = path.join(projectsDir, entry.name, `${sessionId}.jsonl`);
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+function extractAssistantText(entry) {
+    if (!isObject(entry) || entry.type !== "assistant")
+        return null;
+    if (!isObject(entry.message))
+        return null;
+    const content = entry.message.content;
+    if (!Array.isArray(content))
+        return null;
+    const parts = [];
+    for (const block of content) {
+        if (!isObject(block))
+            continue;
+        if (block.type !== "text")
+            continue;
+        if (typeof block.text !== "string")
+            continue;
+        parts.push(block.text);
+    }
+    if (parts.length === 0)
+        return null;
+    return parts.join("");
+}
+function extractUserText(entry) {
+    if (!isObject(entry) || entry.type !== "user")
+        return null;
+    if (!isObject(entry.message))
+        return null;
+    if (entry.message.role !== "user")
+        return null;
+    if (typeof entry.message.content !== "string")
+        return null;
+    return entry.message.content;
+}
+async function loadClaudeHistory(projectPath, sessionId) {
+    let filePath = claudeHistoryCandidates(projectPath)
+        .map((cwd) => path.join(claudeProjectDir(cwd), `${sessionId}.jsonl`))
+        .find((candidate) => existsSync(candidate));
+    if (!filePath) {
+        filePath = await findHistoryFileBySessionId(sessionId);
+    }
+    if (!filePath)
+        return { messages: [], events: [] };
+    const raw = await fs.readFile(filePath, "utf8");
+    const lines = raw.split("\n").filter((line) => line.trim().length > 0);
+    const messages = [];
+    const events = [];
+    lines.forEach((line, index) => {
+        const entry = JSON.parse(line);
+        if (!isObject(entry))
+            return;
+        if (entry.type === "assistant" ||
+            entry.type === "user" ||
+            entry.type === "progress" ||
+            entry.type === "result") {
+            events.push(entry);
+        }
+        const userText = extractUserText(entry);
+        if (typeof userText === "string") {
+            const id = typeof entry.uuid === "string" ? entry.uuid : `history-user:${index}`;
+            messages.push({ id, role: "user", text: userText });
+            return;
+        }
+        const assistantText = extractAssistantText(entry);
+        if (typeof assistantText === "string") {
+            const id = typeof entry.uuid === "string" ? entry.uuid : `history-assistant:${index}`;
+            messages.push({ id, role: "assistant", text: assistantText });
+        }
+    });
+    return { messages, events };
+}
+function send(ws, msg) {
+    ws.send(JSON.stringify(msg));
+}
+function parseMessagePayload(payload) {
+    if (!payload || typeof payload !== "object")
+        throw new Error("Message must be an object");
+    const t = payload.type;
+    if (typeof t !== "string")
+        throw new Error("Message missing type");
+    return payload;
+}
+function parseMessage(data) {
+    const text = typeof data === "string" ? data : data.toString("utf8");
+    const parsed = JSON.parse(text);
+    return parseMessagePayload(parsed);
+}
+function jsonResponse(res, statusCode, value) {
+    res.writeHead(statusCode, { "content-type": "application/json" });
+    res.end(JSON.stringify(value));
+}
+async function readJsonBody(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    }
+    const text = Buffer.concat(chunks).toString("utf8");
+    return JSON.parse(text);
+}
+function parseUploadImageBody(payload) {
+    if (!isObject(payload))
+        return null;
+    if (typeof payload.chatId !== "string" ||
+        typeof payload.fileName !== "string" ||
+        typeof payload.mimeType !== "string" ||
+        typeof payload.base64 !== "string") {
+        return null;
+    }
+    return {
+        chatId: payload.chatId,
+        fileName: payload.fileName,
+        mimeType: payload.mimeType,
+        base64: payload.base64,
+    };
+}
+function clampText(value, maxLength) {
+    if (value.length <= maxLength)
+        return value;
+    return value.slice(0, maxLength);
+}
+function optionalString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    return value;
+}
+function optionalStringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const strings = value.filter((item) => typeof item === "string");
+    if (strings.length === 0)
+        return undefined;
+    return strings;
+}
+function optionalStringRecord(value) {
+    if (!isObject(value))
+        return undefined;
+    const entries = Object.entries(value).filter((entry) => {
+        const [, v] = entry;
+        return typeof v === "string";
+    });
+    if (entries.length === 0)
+        return undefined;
+    return Object.fromEntries(entries);
+}
+function sanitizeConversationEntry(value) {
+    if (!isObject(value))
+        return null;
+    if (typeof value.text !== "string")
+        return null;
+    const entry = {
+        text: clampText(value.text, MAX_CONVERSATION_ENTRY_CHARS),
+    };
+    const senderIdentifier = optionalString(value.senderIdentifier);
+    if (senderIdentifier)
+        entry.senderIdentifier = senderIdentifier;
+    const sentDate = optionalString(value.sentDate);
+    if (sentDate)
+        entry.sentDate = sentDate;
+    const entryIdentifier = optionalString(value.entryIdentifier);
+    if (entryIdentifier)
+        entry.entryIdentifier = entryIdentifier;
+    if (typeof value.replyThreadIdentifier === "string" || value.replyThreadIdentifier === null) {
+        entry.replyThreadIdentifier = value.replyThreadIdentifier;
+    }
+    const primaryRecipientIdentifiers = optionalStringArray(value.primaryRecipientIdentifiers);
+    if (primaryRecipientIdentifiers)
+        entry.primaryRecipientIdentifiers = primaryRecipientIdentifiers;
+    return entry;
+}
+function sanitizeConversationContext(value) {
+    if (!isObject(value))
+        return undefined;
+    const context = {};
+    const threadIdentifier = optionalString(value.threadIdentifier);
+    if (threadIdentifier)
+        context.threadIdentifier = threadIdentifier;
+    if (Array.isArray(value.entries)) {
+        const entries = value.entries
+            .map((entry) => sanitizeConversationEntry(entry))
+            .filter((entry) => entry !== null);
+        if (entries.length > 0)
+            context.entries = entries;
+    }
+    const selfIdentifiers = optionalStringArray(value.selfIdentifiers);
+    if (selfIdentifiers)
+        context.selfIdentifiers = selfIdentifiers;
+    const responsePrimaryRecipientIdentifiers = optionalStringArray(value.responsePrimaryRecipientIdentifiers);
+    if (responsePrimaryRecipientIdentifiers) {
+        context.responsePrimaryRecipientIdentifiers = responsePrimaryRecipientIdentifiers;
+    }
+    const participantNameByIdentifier = optionalStringRecord(value.participantNameByIdentifier);
+    if (participantNameByIdentifier) {
+        context.participantNameByIdentifier = participantNameByIdentifier;
+    }
+    if (Object.keys(context).length === 0)
+        return undefined;
+    return context;
+}
+function sanitizeKeyboardRequest(value) {
+    if (!isObject(value))
+        return null;
+    if (typeof value.prompt !== "string")
+        return null;
+    const request = { prompt: value.prompt };
+    if (typeof value.selectedText === "string") {
+        request.selectedText = clampText(value.selectedText, MAX_SELECTED_TEXT_CHARS);
+    }
+    if (typeof value.documentContextBeforeInput === "string") {
+        request.documentContextBeforeInput = clampText(value.documentContextBeforeInput, MAX_CONTEXT_SIDE_CHARS);
+    }
+    if (typeof value.documentContextAfterInput === "string") {
+        request.documentContextAfterInput = clampText(value.documentContextAfterInput, MAX_CONTEXT_SIDE_CHARS);
+    }
+    if (typeof value.documentIdentifier === "string") {
+        request.documentIdentifier = value.documentIdentifier;
+    }
+    const conversationContext = sanitizeConversationContext(value.conversationContext);
+    if (conversationContext)
+        request.conversationContext = conversationContext;
+    return request;
+}
+function buildKeyboardPrompt(input) {
+    const sections = [
+        "You are drafting a reply on behalf of the user in another app.",
+        "Return only the reply text the user can send. Do not add explanations or labels.",
+    ];
+    if (typeof input.selectedText === "string" && input.selectedText.trim().length > 0) {
+        sections.push(`Selected text (highest priority context):\n${input.selectedText}`);
+    }
+    const entries = input.conversationContext?.entries?.slice(-MAX_CONVERSATION_ENTRIES) ?? [];
+    if (entries.length > 0) {
+        const lines = entries.map((entry, index) => {
+            const sender = entry.senderIdentifier ?? "participant";
+            const date = entry.sentDate ? ` (${entry.sentDate})` : "";
+            return `${index + 1}. ${sender}${date}: ${entry.text}`;
+        });
+        sections.push(`Recent conversation entries:\n${lines.join("\n")}`);
+    }
+    const before = input.documentContextBeforeInput?.trim() ?? "";
+    const after = input.documentContextAfterInput?.trim() ?? "";
+    if (before.length > 0 || after.length > 0) {
+        sections.push(["Nearby text context:", `Before cursor: ${before || "(none)"}`, `After cursor: ${after || "(none)"}`].join("\n"));
+    }
+    if (typeof input.documentIdentifier === "string" && input.documentIdentifier.trim().length > 0) {
+        sections.push(`Document identifier: ${input.documentIdentifier}`);
+    }
+    sections.push(`User instruction:\n${input.prompt}`);
+    return sections.join("\n\n");
+}
+function extractClaudeTextDelta(event) {
+    if (!isObject(event) || event.type !== "stream_event")
+        return null;
+    if (!isObject(event.event) || event.event.type !== "content_block_delta")
+        return null;
+    if (!isObject(event.event.delta) || event.event.delta.type !== "text_delta")
+        return null;
+    if (typeof event.event.delta.text !== "string")
+        return null;
+    return event.event.delta.text;
+}
+function extractClaudeResultText(event) {
+    if (!isObject(event) || event.type !== "result")
+        return null;
+    if (typeof event.result !== "string")
+        return null;
+    return event.result;
+}
+function runKeyboardPrompt(prompt) {
+    return new Promise((resolve) => {
+        const startedAt = Date.now();
+        let timedOut = false;
+        let resultText = "";
+        let deltaText = "";
+        let lastStderr = "";
+        const child = spawn("claude", [
+            "-p",
+            prompt,
+            "--output-format",
+            "stream-json",
+            "--verbose",
+            "--include-partial-messages",
+            "--permission-mode",
+            "bypassPermissions",
+            "--tools",
+            "default",
+        ], {
+            cwd: PROJECTS_ROOT,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: process.env,
+        });
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGKILL");
+        }, KEYBOARD_TIMEOUT_MS);
+        const rlOut = readline.createInterface({ input: child.stdout });
+        rlOut.on("line", (line) => {
+            if (!line.trim())
+                return;
+            const event = JSON.parse(line);
+            const result = extractClaudeResultText(event);
+            if (typeof result === "string") {
+                resultText = result;
+            }
+            const delta = extractClaudeTextDelta(event);
+            if (typeof delta === "string") {
+                deltaText += delta;
+            }
+        });
+        const rlErr = readline.createInterface({ input: child.stderr });
+        rlErr.on("line", (line) => {
+            if (!line.trim())
+                return;
+            lastStderr = line;
+        });
+        child.on("exit", (exitCode, signal) => {
+            clearTimeout(timeout);
+            rlOut.close();
+            rlErr.close();
+            const durationMs = Date.now() - startedAt;
+            if (timedOut) {
+                resolve({
+                    ok: false,
+                    statusCode: 502,
+                    error: `Claude timed out after ${KEYBOARD_TIMEOUT_MS / 1000}s`,
+                    durationMs,
+                });
+                return;
+            }
+            if (signal) {
+                resolve({
+                    ok: false,
+                    statusCode: 502,
+                    error: `Claude exited with signal ${signal}`,
+                    durationMs,
+                });
+                return;
+            }
+            if (exitCode !== 0) {
+                resolve({
+                    ok: false,
+                    statusCode: 502,
+                    error: lastStderr || `Claude exited with code ${String(exitCode)}`,
+                    durationMs,
+                });
+                return;
+            }
+            const reply = (resultText.trim().length > 0 ? resultText : deltaText).trim();
+            if (reply.length === 0) {
+                resolve({
+                    ok: false,
+                    statusCode: 502,
+                    error: "Claude returned an empty reply",
+                    durationMs,
+                });
+                return;
+            }
+            resolve({ ok: true, reply, durationMs });
+        });
+    });
+}
+function fileExtension(fileName, mimeType) {
+    const ext = path.extname(fileName).toLowerCase();
+    if (ext)
+        return ext;
+    if (mimeType === "image/png")
+        return ".png";
+    if (mimeType === "image/gif")
+        return ".gif";
+    if (mimeType === "image/webp")
+        return ".webp";
+    if (mimeType === "image/heic")
+        return ".heic";
+    return ".jpg";
+}
+async function uploadImage(state, body) {
+    const chat = state.chats.find((entry) => entry.id === body.chatId);
+    if (!chat) {
+        throw new Error("Unknown chat");
+    }
+    const project = state.projects.find((entry) => entry.id === chat.projectId);
+    if (!project) {
+        throw new Error("Unknown project");
+    }
+    const projectPath = normalizeProjectPath(project.path);
+    const relativeDirFs = path.join(".claude", "tmp", chat.id);
+    const relativeDir = relativeDirFs.split(path.sep).join("/");
+    const id = crypto.randomUUID();
+    const ext = fileExtension(body.fileName, body.mimeType);
+    const storedFileName = `${id}${ext}`;
+    const relativePath = `${relativeDir}/${storedFileName}`;
+    const absoluteDir = path.join(projectPath, relativeDirFs);
+    const absolutePath = path.join(projectPath, relativePath);
+    const bytes = Buffer.from(body.base64, "base64");
+    await fs.mkdir(absoluteDir, { recursive: true });
+    await fs.writeFile(absolutePath, bytes);
+    return {
+        id,
+        name: body.fileName,
+        mimeType: body.mimeType,
+        relativePath,
+        sizeBytes: bytes.byteLength,
+    };
+}
+function buildClaudePrompt(text, attachments, projectPath) {
+    if (attachments.length === 0)
+        return text;
+    const attachmentLines = attachments.map((attachment, index) => `${index + 1}. ${path.join(projectPath, attachment.relativePath)} (${attachment.mimeType})`);
+    const textPart = text.trim().length > 0 ? text : "Please analyze the attached image.";
+    return `${textPart}\n\nAttached files:\n${attachmentLines.join("\n")}`;
+}
+function wsUrlForHost(hostWithPort, secure) {
+    return `${secure ? "wss" : "ws"}://${hostWithPort}/ws`;
+}
+function connectLinkForServer(serverUrl) {
+    return `mobile://connect?server=${encodeURIComponent(serverUrl)}`;
+}
+function connectPageUrlForServer(hostWithPort, secure) {
+    return `${secure ? "https" : "http"}://${hostWithPort}/connect`;
+}
+function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}
+async function main() {
+    await fs.mkdir(PROJECTS_ROOT, { recursive: true });
+    const suggestedHost = process.env.PUBLIC_HOST ?? `${os.hostname()}:${PORT}`;
+    const suggestedWs = wsUrlForHost(suggestedHost, false);
+    const suggestedConnectPage = connectPageUrlForServer(suggestedHost, false);
+    const suggestedDeepLink = connectLinkForServer(suggestedWs);
+    console.log(`[cc-bridge] projects root: ${PROJECTS_ROOT}`);
+    console.log(`[cc-bridge] host: ${HOST}`);
+    console.log(`[cc-bridge] ws: ws://${HOST}:${PORT}/ws`);
+    console.log(`[cc-bridge] connect page: ${suggestedConnectPage}`);
+    console.log(`[cc-bridge] connect link: ${suggestedDeepLink}`);
+    const active = new Map();
+    let state = await loadState();
+    state = await normalizeStateProjectPaths(state);
+    const handleClientMessage = async (msg, reply) => {
+        if (msg.type === "projects.list") {
+            reply({ type: "projects.list.result", projects: state.projects });
+            return;
+        }
+        if (msg.type === "projects.create") {
+            const projectPath = msg.path
+                ? normalizeProjectPath(msg.path)
+                : path.resolve(path.join(PROJECTS_ROOT, slugify(msg.name)));
+            await fs.mkdir(projectPath, { recursive: true });
+            const project = { id: crypto.randomUUID(), name: msg.name, path: projectPath, createdAt: nowIso() };
+            state = { ...state, projects: [...state.projects, project] };
+            await saveState(state);
+            reply({ type: "projects.create.result", project });
+            return;
+        }
+        if (msg.type === "chats.list") {
+            const chats = msg.projectId ? state.chats.filter((c) => c.projectId === msg.projectId) : state.chats;
+            reply({ type: "chats.list.result", chats });
+            return;
+        }
+        if (msg.type === "chats.create") {
+            const project = state.projects.find((p) => p.id === msg.projectId);
+            if (!project)
+                throw new Error("Unknown project");
+            const chat = {
+                id: crypto.randomUUID(),
+                projectId: msg.projectId,
+                title: msg.title,
+                sessionId: null,
+                createdAt: nowIso(),
+            };
+            state = { ...state, chats: [...state.chats, chat] };
+            await saveState(state);
+            reply({ type: "chats.create.result", chat });
+            return;
+        }
+        if (msg.type === "chats.history") {
+            const chat = state.chats.find((c) => c.id === msg.chatId);
+            if (!chat)
+                throw new Error("Unknown chat");
+            if (!chat.sessionId) {
+                reply({ type: "chats.history.result", chatId: chat.id, messages: [], events: [] });
+                return;
+            }
+            const project = state.projects.find((p) => p.id === chat.projectId);
+            if (!project)
+                throw new Error("Unknown project");
+            const projectPath = normalizeProjectPath(project.path);
+            const history = await loadClaudeHistory(projectPath, chat.sessionId);
+            reply({
+                type: "chats.history.result",
+                chatId: chat.id,
+                messages: history.messages,
+                events: history.events,
+            });
+            return;
+        }
+        if (msg.type === "chats.cancel") {
+            const child = active.get(msg.chatId);
+            if (child)
+                child.kill("SIGINT");
+            return;
+        }
+        if (msg.type === "upload-image") {
+            const attachment = await uploadImage(state, msg);
+            reply({ type: "upload-image.result", attachment });
+            return;
+        }
+        if (msg.type === "chats.send") {
+            const chat = state.chats.find((c) => c.id === msg.chatId);
+            if (!chat)
+                throw new Error("Unknown chat");
+            if (active.has(chat.id))
+                throw new Error("Chat is busy");
+            const project = state.projects.find((p) => p.id === chat.projectId);
+            if (!project)
+                throw new Error("Unknown project");
+            const projectPath = normalizeProjectPath(project.path);
+            const prompt = buildClaudePrompt(msg.text, msg.attachments ?? [], projectPath);
+            const args = [];
+            if (chat.sessionId)
+                args.push("-r", chat.sessionId);
+            args.push("-p", prompt, "--output-format", "stream-json", "--verbose", "--include-partial-messages", "--permission-mode", "bypassPermissions", "--tools", "default");
+            const child = spawn("claude", args, {
+                cwd: projectPath,
+                stdio: ["ignore", "pipe", "pipe"],
+                env: process.env,
+            });
+            active.set(chat.id, child);
+            const onLine = async (line) => {
+                if (!line.trim())
+                    return;
+                const event = JSON.parse(line);
+                reply({ type: "claude.event", chatId: chat.id, event });
+                const maybe = event;
+                if (maybe.type === "system" && maybe.subtype === "init" && typeof maybe.session_id === "string") {
+                    const idx = state.chats.findIndex((c) => c.id === chat.id);
+                    if (idx === -1)
+                        return;
+                    const existing = state.chats[idx];
+                    if (!existing)
+                        return;
+                    const updated = { ...existing, sessionId: maybe.session_id };
+                    state = {
+                        ...state,
+                        chats: [...state.chats.slice(0, idx), updated, ...state.chats.slice(idx + 1)],
+                    };
+                    await saveState(state);
+                }
+            };
+            const rlOut = readline.createInterface({ input: child.stdout });
+            rlOut.on("line", (line) => void onLine(line));
+            const rlErr = readline.createInterface({ input: child.stderr });
+            rlErr.on("line", (line) => reply({ type: "claude.event", chatId: chat.id, event: { type: "stderr", line } }));
+            child.on("exit", (exitCode, signal) => {
+                active.delete(chat.id);
+                rlOut.close();
+                rlErr.close();
+                reply({ type: "claude.done", chatId: chat.id, exitCode, signal });
+            });
+            return;
+        }
+        const unreachable = msg;
+        throw new Error(`Unhandled message: ${unreachable.type}`);
+    };
+    const httpServer = http.createServer(async (req, res) => {
+        const requestUrl = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+        const protoHeader = req.headers["x-forwarded-proto"];
+        const proto = Array.isArray(protoHeader) ? protoHeader[0] : protoHeader;
+        const secure = proto === "https";
+        const hostHeader = req.headers["x-forwarded-host"] ?? req.headers.host ?? `localhost:${PORT}`;
+        const hostWithPort = (Array.isArray(hostHeader) ? hostHeader[0] : hostHeader) ?? `localhost:${PORT}`;
+        if (req.method === "GET" && requestUrl.pathname === "/health") {
+            jsonResponse(res, 200, { ok: true, serverVersion: "0.1.0" });
+            return;
+        }
+        if (req.method === "GET" && requestUrl.pathname === "/connect") {
+            const explicitServer = requestUrl.searchParams.get("server");
+            const serverUrl = explicitServer ?? wsUrlForHost(hostWithPort, secure);
+            const deepLink = connectLinkForServer(serverUrl);
+            const qrCodeImage = await QRCode.toDataURL(deepLink, {
+                width: 320,
+                margin: 1,
+            });
+            const manualConnectPage = connectPageUrlForServer(hostWithPort, secure);
+            res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+            res.end(`<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>cc-bridge Connect</title>
+    <style>
+      :root {
+        color-scheme: light;
+      }
+      body {
+        margin: 0;
+        min-height: 100vh;
+        display: grid;
+        place-items: center;
+        background: radial-gradient(circle at 10% 20%, #fff7ed, #f5f5f4 45%, #e7e5e4);
+        font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+        color: #1c1917;
+      }
+      .card {
+        width: min(680px, calc(100vw - 32px));
+        background: #ffffff;
+        border: 1px solid rgba(0, 0, 0, 0.08);
+        border-radius: 20px;
+        padding: 22px;
+        box-sizing: border-box;
+        box-shadow: 0 16px 50px rgba(0, 0, 0, 0.08);
+      }
+      h1 {
+        margin: 0 0 6px;
+        font-size: 28px;
+        line-height: 1.1;
+      }
+      p {
+        margin: 0;
+        color: #57534e;
+        line-height: 1.45;
+      }
+      .layout {
+        display: grid;
+        gap: 20px;
+        margin-top: 18px;
+      }
+      @media (min-width: 680px) {
+        .layout {
+          grid-template-columns: 320px 1fr;
+          align-items: center;
+        }
+      }
+      .qr {
+        width: 100%;
+        max-width: 320px;
+        justify-self: center;
+        border-radius: 16px;
+        border: 1px solid rgba(0, 0, 0, 0.08);
+        background: #fff;
+      }
+      .steps {
+        display: grid;
+        gap: 10px;
+      }
+      .step {
+        display: grid;
+        grid-template-columns: 24px 1fr;
+        gap: 10px;
+        align-items: start;
+      }
+      .num {
+        width: 24px;
+        height: 24px;
+        border-radius: 999px;
+        background: #b45309;
+        color: #fff;
+        font-size: 13px;
+        font-weight: 700;
+        display: grid;
+        place-items: center;
+      }
+      .mono {
+        font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+        padding: 10px 12px;
+        border-radius: 12px;
+        background: #f5f5f4;
+        border: 1px solid rgba(0, 0, 0, 0.08);
+        margin-top: 10px;
+        font-size: 12px;
+        line-height: 1.35;
+        word-break: break-all;
+      }
+      .buttons {
+        margin-top: 12px;
+        display: flex;
+        flex-wrap: wrap;
+        gap: 8px;
+      }
+      button,
+      a.button {
+        border: 0;
+        border-radius: 10px;
+        padding: 10px 14px;
+        background: #1c1917;
+        color: #fff;
+        font-weight: 600;
+        cursor: pointer;
+        text-decoration: none;
+      }
+      a.secondary {
+        background: #e7e5e4;
+        color: #292524;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="card">
+      <h1>Connect iPhone to cc-bridge</h1>
+      <p>Scan once. The app saves your server URL and connects automatically.</p>
+
+      <div class="layout">
+        <img class="qr" src="${qrCodeImage}" alt="QR code to connect mobile app" />
+        <div class="steps">
+          <div class="step">
+            <div class="num">1</div>
+            <p>Open your iPhone camera and scan this QR code.</p>
+          </div>
+          <div class="step">
+            <div class="num">2</div>
+            <p>Tap the banner to open the cc-bridge app.</p>
+          </div>
+          <div class="step">
+            <div class="num">3</div>
+            <p>It stores the bridge server URL and reconnects automatically.</p>
+          </div>
+
+          <div class="mono" id="server-url">${escapeHtml(serverUrl)}</div>
+          <div class="buttons">
+            <button id="copy-server">Copy Server URL</button>
+            <a class="button secondary" href="${escapeHtml(deepLink)}">Open Link</a>
+            <a class="button secondary" href="${escapeHtml(manualConnectPage)}">Refresh</a>
+          </div>
+        </div>
+      </div>
+    </div>
+    <script>
+      const button = document.getElementById("copy-server");
+      const value = document.getElementById("server-url")?.textContent || "";
+      button?.addEventListener("click", async () => {
+        await navigator.clipboard.writeText(value);
+        button.textContent = "Copied";
+        setTimeout(() => {
+          button.textContent = "Copy Server URL";
+        }, 1200);
+      });
+    </script>
+  </body>
+</html>`);
+            return;
+        }
+        if (req.method === "POST" && requestUrl.pathname === "/upload-image") {
+            const payload = await readJsonBody(req);
+            const body = parseUploadImageBody(payload);
+            if (!body) {
+                jsonResponse(res, 400, { error: "Invalid upload-image payload" });
+                return;
+            }
+            const chat = state.chats.find((entry) => entry.id === body.chatId);
+            if (!chat) {
+                jsonResponse(res, 404, { error: "Unknown chat" });
+                return;
+            }
+            const project = state.projects.find((entry) => entry.id === chat.projectId);
+            if (!project) {
+                jsonResponse(res, 404, { error: "Unknown project" });
+                return;
+            }
+            const attachment = await uploadImage(state, body);
+            jsonResponse(res, 200, { attachment });
+            return;
+        }
+        if (req.method === "POST" && requestUrl.pathname === "/keyboard/respond") {
+            const payload = await readJsonBody(req);
+            const body = sanitizeKeyboardRequest(payload);
+            if (!body) {
+                jsonResponse(res, 400, { error: "Invalid keyboard payload" });
+                return;
+            }
+            if (body.prompt.trim().length === 0) {
+                jsonResponse(res, 400, { error: "prompt is required" });
+                return;
+            }
+            const synthesizedPrompt = buildKeyboardPrompt(body);
+            const outcome = await runKeyboardPrompt(synthesizedPrompt);
+            if (!outcome.ok) {
+                jsonResponse(res, outcome.statusCode, { error: outcome.error });
+                return;
+            }
+            const response = {
+                reply: outcome.reply,
+                durationMs: outcome.durationMs,
+            };
+            jsonResponse(res, 200, response);
+            return;
+        }
+        res.writeHead(200, { "content-type": "text/plain" });
+        res.end("cc-bridge\n");
+    });
+    const wss = new WebSocketServer({ noServer: true });
+    httpServer.on("upgrade", (req, socket, head) => {
+        if (req.url !== "/ws") {
+            socket.destroy();
+            return;
+        }
+        wss.handleUpgrade(req, socket, head, (ws) => wss.emit("connection", ws, req));
+    });
+    wss.on("connection", (ws) => {
+        ws.on("message", async (data) => {
+            const msg = parseMessage(data);
+            await handleClientMessage(msg, (message) => send(ws, message));
+        });
+    });
+    if (RELAY_URL) {
+        const relaySession = await loadRelaySession();
+        const relayClient = new RelayClient({
+            relayUrl: RELAY_URL,
+            session: relaySession,
+            onPairingCode: (message) => {
+                console.log(`[cc-bridge] relay code: ${message.code}`);
+                console.log("[cc-bridge] Enter this code in the mobile app to connect.");
+            },
+            onPaired: async (session) => {
+                await saveRelaySession(session);
+                console.log(`[cc-bridge] relay paired: session ${session.sessionId}`);
+            },
+            onPayload: async (payload) => {
+                const msg = parseMessagePayload(payload);
+                await handleClientMessage(msg, (message) => relayClient.send(JSON.stringify(message)));
+            },
+            onControlMessage: (message) => {
+                if (message.type === "relay.peer_connected") {
+                    console.log(`[cc-bridge] relay peer connected: ${message.peer}`);
+                    return;
+                }
+                if (message.type === "relay.peer_disconnected") {
+                    console.log(`[cc-bridge] relay peer disconnected: ${message.peer}`);
+                    return;
+                }
+                if (message.type === "relay.reconnected") {
+                    console.log(`[cc-bridge] relay reconnected: ${message.role}`);
+                    return;
+                }
+                if (message.type === "relay.error") {
+                    console.log(`[cc-bridge] relay error: ${message.message}`);
+                }
+            },
+        });
+        relayClient.connect();
+        console.log(`[cc-bridge] relay: ${RELAY_URL}`);
+    }
+    httpServer.listen(PORT, HOST);
+}
+void main();

package/dist/relay-client.js

@@ -0,0 +1,128 @@
+import { WebSocket } from "ws";
+const RECONNECT_DELAY_MS = 3_000;
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function isRelayRole(value) {
+    return value === "bridge" || value === "mobile";
+}
+function isRelayControlMessage(value) {
+    if (!isObject(value) || typeof value.type !== "string")
+        return false;
+    if (value.type === "relay.registered") {
+        return typeof value.code === "string" && typeof value.sessionId === "string";
+    }
+    if (value.type === "relay.paired") {
+        return (typeof value.sessionId === "string" &&
+            typeof value.sessionToken === "string" &&
+            isRelayRole(value.role));
+    }
+    if (value.type === "relay.reconnected") {
+        return isRelayRole(value.role);
+    }
+    if (value.type === "relay.peer_connected" || value.type === "relay.peer_disconnected") {
+        return isRelayRole(value.peer);
+    }
+    if (value.type === "relay.error") {
+        return typeof value.message === "string";
+    }
+    return false;
+}
+function relayWsUrl(relayUrl, session) {
+    const url = new URL(relayUrl);
+    url.pathname = "/ws/bridge";
+    url.search = "";
+    if (session) {
+        url.searchParams.set("session", session.sessionId);
+        url.searchParams.set("token", session.sessionToken);
+    }
+    return url.toString();
+}
+function rawDataToText(data) {
+    if (typeof data === "string")
+        return data;
+    if (Array.isArray(data)) {
+        return data
+            .map((chunk) => chunk instanceof ArrayBuffer
+            ? Buffer.from(new Uint8Array(chunk)).toString("utf8")
+            : Buffer.from(chunk).toString("utf8"))
+            .join("");
+    }
+    if (data instanceof ArrayBuffer)
+        return Buffer.from(new Uint8Array(data)).toString("utf8");
+    return Buffer.from(data).toString("utf8");
+}
+export class RelayClient {
+    options;
+    socket = null;
+    reconnectTimer = null;
+    stopped = false;
+    session;
+    constructor(options) {
+        this.options = options;
+        this.session = options.session;
+    }
+    connect() {
+        this.stopped = false;
+        this.connectNow();
+    }
+    close() {
+        this.stopped = true;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.socket) {
+            this.socket.close();
+            this.socket = null;
+        }
+    }
+    send(data) {
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+            throw new Error("Relay websocket is not open");
+        }
+        this.socket.send(data);
+    }
+    connectNow() {
+        const socket = new WebSocket(relayWsUrl(this.options.relayUrl, this.session));
+        this.socket = socket;
+        socket.on("message", async (data) => {
+            const payload = JSON.parse(rawDataToText(data));
+            if (isRelayControlMessage(payload)) {
+                this.handleControlMessage(payload);
+                return;
+            }
+            await this.options.onPayload(payload);
+        });
+        socket.on("close", () => {
+            if (this.socket === socket)
+                this.socket = null;
+            if (this.stopped)
+                return;
+            this.scheduleReconnect();
+        });
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimer)
+            return;
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.connectNow();
+        }, RECONNECT_DELAY_MS);
+    }
+    handleControlMessage(message) {
+        this.options.onControlMessage?.(message);
+        if (message.type === "relay.registered") {
+            this.options.onPairingCode(message);
+            return;
+        }
+        if (message.type === "relay.paired" && message.role === "bridge") {
+            const session = {
+                sessionId: message.sessionId,
+                sessionToken: message.sessionToken,
+            };
+            this.session = session;
+            void this.options.onPaired(session);
+        }
+    }
+}

package/dist/state.js

@@ -0,0 +1,74 @@
+import fs from "node:fs/promises";
+import { existsSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const STATE_DIR = path.join(os.homedir(), ".cc-bridge");
+const TOKENS_PATH = path.join(STATE_DIR, "tokens.json");
+const STATE_PATH = path.join(STATE_DIR, "state.json");
+const RELAY_SESSION_PATH = path.join(STATE_DIR, "relay-session.json");
+async function ensureStateDir() {
+    await fs.mkdir(STATE_DIR, { recursive: true });
+}
+export async function loadTokens() {
+    await ensureStateDir();
+    if (!existsSync(TOKENS_PATH))
+        return [];
+    const raw = await fs.readFile(TOKENS_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed))
+        throw new Error("tokens.json must be an array");
+    return parsed;
+}
+export async function saveTokens(tokens) {
+    await ensureStateDir();
+    await fs.writeFile(TOKENS_PATH, JSON.stringify(tokens, null, 2) + "\n", "utf8");
+}
+export async function loadState() {
+    await ensureStateDir();
+    if (!existsSync(STATE_PATH))
+        return { projects: [], chats: [] };
+    const raw = await fs.readFile(STATE_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object")
+        throw new Error("state.json must be an object");
+    const o = parsed;
+    if (!Array.isArray(o.projects) || !Array.isArray(o.chats)) {
+        throw new Error("state.json must have projects[] and chats[]");
+    }
+    return { projects: o.projects, chats: o.chats };
+}
+export async function saveState(state) {
+    await ensureStateDir();
+    await fs.writeFile(STATE_PATH, JSON.stringify(state, null, 2) + "\n", "utf8");
+}
+export async function loadRelaySession() {
+    await ensureStateDir();
+    if (!existsSync(RELAY_SESSION_PATH))
+        return null;
+    const raw = await fs.readFile(RELAY_SESSION_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") {
+        throw new Error("relay-session.json must be an object");
+    }
+    const maybe = parsed;
+    if (typeof maybe.sessionId !== "string" || typeof maybe.sessionToken !== "string") {
+        throw new Error("relay-session.json must include sessionId and sessionToken");
+    }
+    return { sessionId: maybe.sessionId, sessionToken: maybe.sessionToken };
+}
+export async function saveRelaySession(session) {
+    await ensureStateDir();
+    await fs.writeFile(RELAY_SESSION_PATH, JSON.stringify(session, null, 2) + "\n", "utf8");
+}
+export async function clearRelaySession() {
+    await ensureStateDir();
+    if (!existsSync(RELAY_SESSION_PATH))
+        return;
+    await fs.rm(RELAY_SESSION_PATH);
+}
+export function nowIso() {
+    return new Date().toISOString();
+}
+export function tokenRecord(token, deviceName) {
+    return { token, deviceName, createdAt: nowIso() };
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "jumper-app",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "bin": {
+    "jumper-app": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "start": "node dist/cli.js",
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "prepack": "pnpm run build"
+  },
+  "dependencies": {
+    "qrcode": "^1.5.4",
+    "ws": "^8.18.3"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.0",
+    "@types/qrcode": "^1.5.5",
+    "@types/ws": "^8.18.1",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.2"
+  }
+}