@nowcrew/daemon 0.6.6 → 0.6.8

package/dist/remote/claude-bridge.js

@@ -1,558 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { createInterface } from "node:readline";
-import { query, } from "@anthropic-ai/claude-agent-sdk";
-import { WebSocket } from "ws";
-import { z } from "zod";
-import { toConsoleLines } from "../console.js";
-import { ChannelToGatewaySchema, GatewayToChannelSchema, MAX_CLAUDE_INPUT_QUEUE_BYTES, MAX_CLAUDE_INPUT_QUEUE_ITEMS, MAX_REMOTE_PROMPT_BYTES, MAX_REMOTE_WEBSOCKET_BUFFER_BYTES, REMOTE_PROTOCOL_VERSION, } from "./protocol.js";
-import { resolveClaudeWrapperSession } from "./wrapper.js";
-const MAX_CLAUDE_INPUT_DEDUP_ENTRIES = 1_000;
-export function claudeInputQueueStatus(outstandingItems, outstandingBytes, text) {
-    const byteLength = Buffer.byteLength(text, "utf8");
-    if (byteLength > MAX_REMOTE_PROMPT_BYTES)
-        return "prompt_too_large";
-    if (outstandingItems >= MAX_CLAUDE_INPUT_QUEUE_ITEMS
-        || outstandingBytes + byteLength > MAX_CLAUDE_INPUT_QUEUE_BYTES)
-        return "queue_full";
-    return "accepted";
-}
-export function shouldReconnectClaudeChannel(closeCode) {
-    return closeCode !== 4001;
-}
-class InputStream {
-    values = [];
-    waiters = [];
-    stopped = false;
-    push(value) {
-        if (this.stopped)
-            return;
-        const waiter = this.waiters.shift();
-        if (waiter)
-            waiter({ value, done: false });
-        else
-            this.values.push(value);
-    }
-    close() {
-        this.stopped = true;
-        for (const waiter of this.waiters.splice(0))
-            waiter({ value: undefined, done: true });
-    }
-    [Symbol.asyncIterator]() {
-        return {
-            next: () => {
-                const value = this.values.shift();
-                if (value)
-                    return Promise.resolve({ value, done: false });
-                if (this.stopped)
-                    return Promise.resolve({ value: undefined, done: true });
-                return new Promise((resolve) => this.waiters.push(resolve));
-            },
-        };
-    }
-}
-const AskQuestionInputSchema = z.object({
-    questions: z.array(z.object({
-        question: z.string().min(1),
-        header: z.string().default("Question"),
-        options: z.array(z.object({
-            label: z.string(),
-            description: z.string().default(""),
-        }).passthrough()).default([]),
-    }).passthrough()).min(1).max(4),
-}).passthrough();
-function takeValue(args, index, option) {
-    const value = args[index + 1];
-    if (!value || value.startsWith("-"))
-        throw new Error(`${option} requires a value`);
-    return value;
-}
-function splitTools(value) {
-    return value.split(/[ ,]+/).map((part) => part.trim()).filter(Boolean);
-}
-export function parseClaudeBridgeArgs(userArgs) {
-    const resolved = resolveClaudeWrapperSession(userArgs);
-    const options = {};
-    const prompts = [];
-    let title;
-    const args = resolved.args;
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        const inline = (name) => arg.startsWith(`${name}=`) ? arg.slice(name.length + 1) : null;
-        if (["--session-id", "--resume", "-r"].includes(arg)) {
-            index += 1;
-            continue;
-        }
-        if (arg.startsWith("--session-id=") || arg.startsWith("--resume="))
-            continue;
-        if (arg === "--model" || arg === "--effort" || arg === "--permission-mode" || arg === "--name" || arg === "-n"
-            || arg === "--add-dir" || arg === "--allowedTools" || arg === "--allowed-tools"
-            || arg === "--disallowedTools" || arg === "--disallowed-tools" || arg === "--settings") {
-            const value = takeValue(args, index, arg);
-            index += 1;
-            if (arg === "--model")
-                options.model = value;
-            else if (arg === "--effort")
-                options.effort = z.enum(["low", "medium", "high", "xhigh", "max"]).parse(value);
-            else if (arg === "--permission-mode")
-                options.permissionMode = z.enum(["default", "acceptEdits", "bypassPermissions", "plan", "dontAsk", "auto"]).parse(value);
-            else if (arg === "--name" || arg === "-n")
-                title = value;
-            else if (arg === "--add-dir")
-                (options.additionalDirectories ??= []).push(value);
-            else if (arg === "--allowedTools" || arg === "--allowed-tools")
-                options.allowedTools = splitTools(value);
-            else if (arg === "--disallowedTools" || arg === "--disallowed-tools")
-                options.disallowedTools = splitTools(value);
-            else
-                options.settings = value;
-            continue;
-        }
-        const model = inline("--model");
-        const effort = inline("--effort");
-        const permission = inline("--permission-mode");
-        const name = inline("--name");
-        if (model !== null)
-            options.model = model;
-        else if (effort !== null)
-            options.effort = z.enum(["low", "medium", "high", "xhigh", "max"]).parse(effort);
-        else if (permission !== null)
-            options.permissionMode = z.enum(["default", "acceptEdits", "bypassPermissions", "plan", "dontAsk", "auto"]).parse(permission);
-        else if (name !== null)
-            title = name;
-        else if (arg === "--dangerously-skip-permissions") {
-            options.permissionMode = "bypassPermissions";
-            options.allowDangerouslySkipPermissions = true;
-        }
-        else if (arg.startsWith("-")) {
-            throw new Error(`Claude mobile bridge does not support ${arg}`);
-        }
-        else
-            prompts.push(arg);
-    }
-    const hasResume = userArgs.some((value) => value === "--resume" || value === "-r" || value.startsWith("--resume="));
-    return {
-        sessionId: resolved.sessionId,
-        resume: hasResume,
-        ...(title === undefined ? {} : { title }),
-        ...(prompts.length === 0 ? {} : { initialPrompt: prompts.join(" ") }),
-        options,
-    };
-}
-function userMessage(sessionId, text, uuid, timestamp) {
-    return {
-        type: "user",
-        message: { role: "user", content: text },
-        parent_tool_use_id: null,
-        session_id: sessionId,
-        uuid,
-        timestamp,
-    };
-}
-function preview(input) {
-    const command = typeof input.command === "string" ? input.command : null;
-    const path = typeof input.file_path === "string" ? input.file_path : null;
-    return (command ?? path ?? JSON.stringify(input)).slice(0, 16_000);
-}
-function printMessage(message) {
-    let printedText = false;
-    for (const line of toConsoleLines(message)) {
-        if (line.stream === "result" || !line.text.trim())
-            continue;
-        if (line.stream === "text")
-            printedText = true;
-        const prefix = line.stream === "thinking" ? "Thinking: "
-            : line.stream === "tool" ? "Tool: "
-                : line.stream === "tool_result" ? "Result: "
-                    : line.stream === "error" ? "Error: " : "";
-        process.stdout.write(`\n${prefix}${line.text}\n`);
-    }
-    return printedText;
-}
-export async function runClaudeBridge(userArgs, context) {
-    const parsed = parseClaudeBridgeArgs(userArgs);
-    const generation = randomUUID();
-    const inputStream = new InputStream();
-    const inputs = [];
-    const interactions = new Map();
-    const acceptedRemoteInputs = new Set();
-    const terminalInteractions = [];
-    let terminalHandler = null;
-    let active = null;
-    let outstandingInputBytes = 0;
-    let stopped = false;
-    let cleaned = false;
-    let superseded = false;
-    let channelReady = false;
-    let hasRegisteredOnce = false;
-    let socket = null;
-    let reconnectTimer;
-    let assistantPrinted = false;
-    let conversation = null;
-    let terminal = null;
-    const url = new URL("/ws/channel", context.gatewayUrl);
-    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
-    const send = (value) => {
-        if (socket?.readyState !== WebSocket.OPEN)
-            return false;
-        const frame = ChannelToGatewaySchema.parse(value);
-        if (frame.type !== "channel.register" && !channelReady)
-            return false;
-        const serialized = JSON.stringify(frame);
-        if (socket.bufferedAmount + Buffer.byteLength(serialized, "utf8") > MAX_REMOTE_WEBSOCKET_BUFFER_BYTES) {
-            socket.close(1013, "outbound buffer limit");
-            return false;
-        }
-        try {
-            socket.send(serialized);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    };
-    const register = () => send({
-        type: "channel.register",
-        protocolVersion: REMOTE_PROTOCOL_VERSION,
-        sessionId: parsed.sessionId,
-        cwd: context.cwd,
-        pid: process.pid,
-        generation,
-        ...(parsed.title === undefined ? {} : { title: parsed.title }),
-    });
-    const sendActiveLocalUserMessage = () => {
-        if (!active || active.requestId !== null)
-            return;
-        send({
-            type: "bridge.user_message",
-            protocolVersion: REMOTE_PROTOCOL_VERSION,
-            sessionId: parsed.sessionId,
-            messageId: active.messageId,
-            text: active.text,
-            createdAt: active.createdAt,
-        });
-    };
-    const finishInteraction = (requestId, value, local) => {
-        const interaction = interactions.get(requestId);
-        if (!interaction)
-            return false;
-        interactions.delete(requestId);
-        const index = terminalInteractions.indexOf(requestId);
-        if (index >= 0)
-            terminalInteractions.splice(index, 1);
-        terminalHandler = null;
-        interaction.resolve(value);
-        if (local)
-            send({
-                type: "bridge.resolved",
-                protocolVersion: REMOTE_PROTOCOL_VERSION,
-                sessionId: parsed.sessionId,
-                requestId,
-            });
-        return true;
-    };
-    const stop = () => {
-        if (cleaned)
-            return;
-        cleaned = true;
-        stopped = true;
-        channelReady = false;
-        if (reconnectTimer)
-            clearTimeout(reconnectTimer);
-        inputStream.close();
-        conversation?.close();
-        terminal?.close();
-        socket?.close();
-        for (const id of [...interactions.keys()])
-            finishInteraction(id, { decision: "deny" }, true);
-    };
-    const acknowledgeDelivery = (deliveryId, status) => {
-        send({
-            type: "channel.delivery_ack",
-            protocolVersion: REMOTE_PROTOCOL_VERSION,
-            sessionId: parsed.sessionId,
-            generation,
-            deliveryId,
-            status,
-        });
-    };
-    const connectGateway = () => new Promise((resolve, reject) => {
-        const next = new WebSocket(url, { headers: { authorization: `Bearer ${context.token}` } });
-        socket = next;
-        channelReady = false;
-        let settled = false;
-        let registrationTimer;
-        next.once("open", () => {
-            if (!register()) {
-                next.close(1013, "registration delivery failed");
-                return;
-            }
-            registrationTimer = setTimeout(() => next.close(1008, "registration timeout"), 2_000);
-        });
-        next.on("message", (raw) => {
-            let decoded;
-            try {
-                decoded = JSON.parse(raw.toString());
-            }
-            catch {
-                return;
-            }
-            const frame = GatewayToChannelSchema.safeParse(decoded);
-            if (!frame.success)
-                return;
-            if (frame.data.type === "channel.registered") {
-                if (frame.data.sessionId !== parsed.sessionId || frame.data.generation !== generation) {
-                    next.close(1008, "registration mismatch");
-                    return;
-                }
-                if (registrationTimer)
-                    clearTimeout(registrationTimer);
-                channelReady = true;
-                hasRegisteredOnce = true;
-                if (active) {
-                    sendActiveLocalUserMessage();
-                    send({ type: "bridge.status", protocolVersion: REMOTE_PROTOCOL_VERSION, sessionId: parsed.sessionId, busy: true });
-                }
-                for (const interaction of interactions.values())
-                    send(interaction.requestFrame);
-                if (!settled) {
-                    settled = true;
-                    resolve();
-                }
-                return;
-            }
-            if (!channelReady)
-                return;
-            if (frame.data.type === "channel.prompt") {
-                if (acceptedRemoteInputs.has(frame.data.requestId)) {
-                    acknowledgeDelivery(frame.data.deliveryId, "accepted");
-                    return;
-                }
-                const status = enqueue({ text: frame.data.text, requestId: frame.data.requestId });
-                if (status === "accepted") {
-                    acceptedRemoteInputs.add(frame.data.requestId);
-                    while (acceptedRemoteInputs.size > MAX_CLAUDE_INPUT_DEDUP_ENTRIES) {
-                        const oldest = acceptedRemoteInputs.values().next().value;
-                        if (!oldest)
-                            break;
-                        acceptedRemoteInputs.delete(oldest);
-                    }
-                }
-                acknowledgeDelivery(frame.data.deliveryId, status === "accepted" ? "accepted" : "queue_full");
-            }
-            else if (frame.data.type === "bridge.approval_response") {
-                const accepted = finishInteraction(frame.data.requestId, { decision: frame.data.decision }, false);
-                acknowledgeDelivery(frame.data.deliveryId, accepted ? "accepted" : "not_pending");
-            }
-            else if (frame.data.type === "bridge.question_response") {
-                const accepted = finishInteraction(frame.data.requestId, { answers: frame.data.answers }, false);
-                acknowledgeDelivery(frame.data.deliveryId, accepted ? "accepted" : "not_pending");
-            }
-            else if (frame.data.type === "channel.permission_response") {
-                acknowledgeDelivery(frame.data.deliveryId, "not_pending");
-            }
-        });
-        next.once("error", (error) => {
-            if (!settled) {
-                settled = true;
-                reject(error);
-            }
-        });
-        next.on("close", (code) => {
-            if (registrationTimer)
-                clearTimeout(registrationTimer);
-            const wasCurrent = socket === next;
-            if (wasCurrent) {
-                socket = null;
-                channelReady = false;
-            }
-            if (code === 4001) {
-                superseded = true;
-                process.stderr.write("NowCrew remote: this Claude session was replaced by a newer bridge.\n");
-                stop();
-                if (!settled) {
-                    settled = true;
-                    reject(new Error("Claude remote bridge was superseded"));
-                }
-                return;
-            }
-            if (!settled) {
-                settled = true;
-                reject(new Error(`Claude remote gateway closed before registration (${code})`));
-            }
-            if (wasCurrent && hasRegisteredOnce && !stopped && shouldReconnectClaudeChannel(code)) {
-                reconnectTimer = setTimeout(() => { void connectGateway().catch(() => { }); }, 1_000);
-            }
-        });
-    });
-    const sendNext = () => {
-        if (active || inputs.length === 0 || stopped)
-            return;
-        active = inputs.shift();
-        assistantPrinted = false;
-        inputStream.push(userMessage(parsed.sessionId, active.text, active.messageId, active.createdAt));
-        sendActiveLocalUserMessage();
-        send({ type: "bridge.status", protocolVersion: REMOTE_PROTOCOL_VERSION, sessionId: parsed.sessionId, busy: true });
-    };
-    function enqueue(value) {
-        const status = claudeInputQueueStatus(inputs.length + (active ? 1 : 0), outstandingInputBytes, value.text);
-        if (status !== "accepted")
-            return status;
-        const queued = {
-            ...value,
-            byteLength: Buffer.byteLength(value.text, "utf8"),
-            messageId: (value.requestId ?? randomUUID()),
-            createdAt: new Date().toISOString(),
-        };
-        outstandingInputBytes += queued.byteLength;
-        inputs.push(queued);
-        sendNext();
-        return "accepted";
-    }
-    const waitForInteraction = (interaction, render, handleLine) => {
-        const promise = new Promise((resolve) => {
-            interactions.set(interaction.id, { ...interaction, resolve });
-        });
-        terminalInteractions.push(interaction.id);
-        render();
-        terminalHandler = (line) => {
-            const result = handleLine(line);
-            if (result)
-                finishInteraction(interaction.id, result, true);
-        };
-        return promise;
-    };
-    const canUseTool = async (toolName, input, { signal }) => {
-        const requestId = randomUUID();
-        if (toolName === "AskUserQuestion") {
-            const parsedQuestions = AskQuestionInputSchema.safeParse(input);
-            if (!parsedQuestions.success)
-                return { behavior: "deny", message: "Unsupported question format" };
-            const questions = parsedQuestions.data.questions.map((question, index) => ({
-                id: `q${index}`,
-                header: question.header,
-                question: question.question,
-                isSecret: false,
-                options: question.options,
-            }));
-            const requestFrame = {
-                type: "bridge.question",
-                protocolVersion: REMOTE_PROTOCOL_VERSION,
-                sessionId: parsed.sessionId,
-                requestId,
-                questions,
-            };
-            const waiting = waitForInteraction({ id: requestId, kind: "question", questions, requestFrame }, () => {
-                process.stdout.write("\nInput needed:\n");
-                for (const [index, question] of questions.entries()) {
-                    process.stdout.write(`${index + 1}. ${question.header}: ${question.question}\n`);
-                    for (const option of question.options)
-                        process.stdout.write(`   - ${option.label}: ${option.description}\n`);
-                }
-                process.stdout.write("Answer: ");
-            }, (line) => {
-                const values = line.split(";").map((value) => value.trim());
-                return { answers: Object.fromEntries(questions.map((question, index) => [question.id, [values[index] ?? ""]])) };
-            });
-            send(requestFrame);
-            signal.addEventListener("abort", () => finishInteraction(requestId, { decision: "deny" }, true), { once: true });
-            const result = await waiting;
-            if (!result.answers)
-                return { behavior: "deny", message: "User input cancelled" };
-            const answers = Object.fromEntries(questions.map((question) => [
-                question.question,
-                result.answers?.[question.id]?.join(", ") ?? "",
-            ]));
-            return { behavior: "allow", updatedInput: { ...input, answers } };
-        }
-        const requestFrame = {
-            type: "bridge.approval",
-            protocolVersion: REMOTE_PROTOCOL_VERSION,
-            sessionId: parsed.sessionId,
-            requestId,
-            tool: toolName,
-            preview: preview(input),
-        };
-        const waiting = waitForInteraction({ id: requestId, kind: "approval", requestFrame }, () => process.stdout.write(`\nApproval required: ${toolName}\n${preview(input)}\nAllow? `), (line) => /^(y|yes|allow)$/i.test(line.trim()) ? { decision: "allow" }
-            : /^(n|no|deny)$/i.test(line.trim()) ? { decision: "deny" } : null);
-        send(requestFrame);
-        signal.addEventListener("abort", () => finishInteraction(requestId, { decision: "deny" }, true), { once: true });
-        const result = await waiting;
-        return result.decision === "allow"
-            ? { behavior: "allow", updatedInput: input }
-            : { behavior: "deny", message: "User denied this action" };
-    };
-    await connectGateway();
-    if (stopped)
-        return 1;
-    const activeConversation = query({
-        prompt: inputStream,
-        options: {
-            cwd: context.cwd,
-            canUseTool,
-            settingSources: ["user", "project", "local"],
-            includePartialMessages: false,
-            ...(parsed.resume ? { resume: parsed.sessionId } : { sessionId: parsed.sessionId }),
-            ...parsed.options,
-            ...(process.env.NOWCREW_CLAUDE_BIN ? { pathToClaudeCodeExecutable: process.env.NOWCREW_CLAUDE_BIN } : {}),
-        },
-    });
-    conversation = activeConversation;
-    terminal = createInterface({ input: process.stdin, output: process.stdout });
-    terminal.setPrompt("› ");
-    terminal.on("line", (line) => {
-        if (terminalHandler && terminalInteractions.length > 0)
-            terminalHandler(line);
-        else if (line.trim()) {
-            const status = enqueue({ text: line.trim(), requestId: null });
-            if (status !== "accepted")
-                process.stderr.write(`NowCrew remote: input rejected (${status}).\n`);
-        }
-        terminal.prompt();
-    });
-    terminal.on("close", stop);
-    process.stdout.write(`Claude mobile session ${parsed.sessionId}\n`);
-    terminal.prompt();
-    if (parsed.initialPrompt) {
-        const status = enqueue({ text: parsed.initialPrompt, requestId: null });
-        if (status !== "accepted")
-            process.stderr.write(`NowCrew remote: initial input rejected (${status}).\n`);
-    }
-    process.once("SIGINT", stop);
-    process.once("SIGTERM", stop);
-    try {
-        for await (const message of activeConversation) {
-            if (message.type === "assistant")
-                assistantPrinted = printMessage(message) || assistantPrinted;
-            else
-                printMessage(message);
-            if (message.type !== "result")
-                continue;
-            const result = message.subtype === "success" && "result" in message && typeof message.result === "string"
-                ? message.result.trim()
-                : "";
-            if (!assistantPrinted && result)
-                process.stdout.write(`\n${result}\n`);
-            const completedInput = active;
-            if (completedInput)
-                send({
-                    type: "channel.reply",
-                    protocolVersion: REMOTE_PROTOCOL_VERSION,
-                    sessionId: parsed.sessionId,
-                    requestId: completedInput.messageId,
-                    text: result,
-                });
-            if (completedInput)
-                outstandingInputBytes = Math.max(0, outstandingInputBytes - completedInput.byteLength);
-            active = null;
-            send({ type: "bridge.status", protocolVersion: REMOTE_PROTOCOL_VERSION, sessionId: parsed.sessionId, busy: false });
-            terminal.prompt();
-            sendNext();
-        }
-        return superseded ? 1 : stopped ? 0 : 1;
-    }
-    finally {
-        process.off("SIGINT", stop);
-        process.off("SIGTERM", stop);
-        stop();
-    }
-}