@nowcrew/daemon 0.5.30 → 0.5.31

package/dist/local-executor.js

@@ -16,6 +16,8 @@ import { decodeExternalOutputEvent, extractExternalAnswer, ExternalAnswerDecoder
 import { cleanupMaterializedAttachments as cleanupAttachments, executionAttachmentDirectory, materializeAttachments, } from "./attachments.js";
 import { routeRuntimeAttachments, runtimeCapability, } from "./runtime-capabilities.js";
 import { awaitWithCancellation, RuntimeCancelledError, } from "./runtime-cancellation.js";
+import { isRuntimeReadyEvent, } from "./runtime-startup-gate.js";
+import { dslog } from "./slog.js";
 function truncateUtf8(value, maxBytes) {
     if (maxBytes <= 0)
         return "";
@@ -198,6 +200,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
     }), dependencies.cancellation);
     let materialized = null;
     let knownAttachmentDirectory = null;
+    let startupReservation = null;
     try {
         if (isDeepSeekCodex && !providerConfig.providerApiKey) {
             throw new Error("DeepSeek API key is not configured for this Agent");
@@ -288,6 +291,28 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const launchRuntime = dependencies.launchRuntime ?? launchLegacyRuntime;
         if (dependencies.cancellation?.isRequested())
             throw new RuntimeCancelledError();
+        startupReservation = dependencies.startupGate?.reserve(runtime.name) ?? null;
+        if (startupReservation !== null) {
+            const startupQueueEnteredAt = Date.now();
+            dslog("runtime.start_queued", "runtime 等待启动许可", {
+                execution_id: input.executionId,
+                runtime: runtime.name,
+                queued: startupReservation.isQueued(),
+            });
+            try {
+                await awaitWithCancellation(startupReservation.ready, dependencies.cancellation);
+                dslog("runtime.start_granted", "runtime 获得启动许可", {
+                    execution_id: input.executionId,
+                    runtime: runtime.name,
+                    startup_queue_ms: Date.now() - startupQueueEnteredAt,
+                });
+            }
+            catch (error) {
+                startupReservation.release();
+                throw error;
+            }
+        }
+        const runtimeLaunchAt = Date.now();
         const child = await launchRuntime({
             runtime: runtime.name,
             bin: runtime.name,
@@ -321,11 +346,30 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         const externalOutput = new ExternalAnswerDecoder();
         // 每轮独立:tool_use/result 关联状态不能跨 execution 泄漏。
         const consoleFormatter = createConsoleFormatter();
+        let runtimeReady = false;
+        let resolveRuntimeReady;
+        const runtimeReadySignal = new Promise((resolve) => { resolveRuntimeReady = resolve; });
+        let runtimeReadyNotification = Promise.resolve();
+        const markRuntimeReady = () => {
+            if (runtimeReady)
+                return;
+            runtimeReady = true;
+            startupReservation?.release();
+            dslog("runtime.start_ready", "runtime 已完成初始化", {
+                execution_id: input.executionId,
+                runtime: runtime.name,
+                startup_ms: Date.now() - runtimeLaunchAt,
+            });
+            runtimeReadyNotification = Promise.resolve(callbacks.onRuntimeReady?.(runtime.name));
+            resolveRuntimeReady();
+        };
         const readline = createInterface({ input: child.stdout });
         readline.on("line", (line) => {
             const event = parseLine(line);
             if (!event)
                 return;
+            if (isRuntimeReadyEvent(runtime.name, event))
+                markRuntimeReady();
             const meta = extractRunMeta(event);
             if (meta.sessionId)
                 sessionId = meta.sessionId;
@@ -358,6 +402,39 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         });
         let runtimeExit;
         try {
+            if (startupReservation !== null) {
+                let startupTimer;
+                let startupOutcome;
+                try {
+                    startupOutcome = await awaitWithCancellation(Promise.race([
+                        runtimeReadySignal.then(() => ({ kind: "ready" })),
+                        child.exit.then((exit) => ({ kind: "exit", exit })),
+                        new Promise((resolve) => {
+                            startupTimer = setTimeout(() => resolve({ kind: "timeout" }), dependencies.startupTimeoutMs ?? 60_000);
+                        }),
+                    ]), dependencies.cancellation);
+                }
+                finally {
+                    if (startupTimer !== undefined)
+                        clearTimeout(startupTimer);
+                }
+                if (startupOutcome.kind !== "ready") {
+                    if (startupOutcome.kind === "timeout") {
+                        dslog("runtime.start_timeout", "runtime 启动超时", {
+                            level: "ERROR",
+                            execution_id: input.executionId,
+                            runtime: runtime.name,
+                            startup_timeout_ms: dependencies.startupTimeoutMs ?? 60_000,
+                        });
+                        await child.cancel?.();
+                    }
+                    startupReservation.release();
+                    throw new Error(startupOutcome.kind === "timeout"
+                        ? `${runtime.name} startup timed out`
+                        : `${runtime.name} exited before signaling ready (exit ${startupOutcome.exit.exitCode})`);
+                }
+                await runtimeReadyNotification;
+            }
             runtimeExit = await awaitWithCancellation(child.exit, dependencies.cancellation);
         }
         catch (error) {
@@ -415,6 +492,7 @@ async function executeLocalUnlocked(input, callbacks, dependencies) {
         };
     }
     finally {
+        startupReservation?.release();
         const attachmentDirectories = new Set([
             ...(knownAttachmentDirectory === null ? [] : [knownAttachmentDirectory]),
             ...(materialized === null ? [] : [materialized.directory]),

package/dist/machine-info.js

@@ -25,6 +25,7 @@ export const DAEMON_CAPABILITIES = [
     "execution_external_output_v1",
     "execution_attachments_v1",
     "execution_answer_stream_v1",
+    "execution_machine_queue_v1",
 ];
 export const EXECUTION_PROTOCOL = Object.freeze({ min: 1, max: 1 });
 /** 候选 runtime CLI:展示名 → 可执行文件名。 */
@@ -117,7 +118,21 @@ export async function collectMachineHello(agentsRoot, executionLimits, runtimePl
         capabilities: DAEMON_CAPABILITIES,
         ...(backend.supported ? {
             executionProtocol: EXECUTION_PROTOCOL,
-            executionLimits: Object.freeze({ ...executionLimits }),
+            executionLimits: Object.freeze({
+                maxPromptBytes: executionLimits.maxPromptBytes,
+                maxTimeoutMs: executionLimits.maxTimeoutMs,
+                maxEventBytes: executionLimits.maxEventBytes,
+                maxParallelPerAgent: executionLimits.maxParallelPerAgent,
+                maxQueuedPerAgent: executionLimits.maxQueuedPerAgent,
+            }),
+            executionScheduler: Object.freeze({
+                maxParallelTotal: executionLimits.maxParallelTotal,
+                maxQueuedTotal: executionLimits.maxQueuedTotal,
+                maxStartingTotal: executionLimits.maxStartingTotal,
+                maxStartingPerRuntime: executionLimits.maxStartingPerRuntime,
+                startupGapMs: executionLimits.startupGapMs,
+                startupTimeoutMs: executionLimits.startupTimeoutMs,
+            }),
         } : {}),
         agentHandles,
     };

package/dist/remote/claude-bridge.js

@@ -0,0 +1,402 @@
+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, REMOTE_PROTOCOL_VERSION, } from "./protocol.js";
+import { resolveClaudeWrapperSession } from "./wrapper.js";
+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) {
+    return {
+        type: "user",
+        message: { role: "user", content: text },
+        parent_tool_use_id: null,
+        session_id: sessionId,
+    };
+}
+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 terminalInteractions = [];
+    let terminalHandler = null;
+    let active = null;
+    let stopped = false;
+    let socket = null;
+    let reconnectTimer;
+    let assistantPrinted = false;
+    const url = new URL("/ws/channel", context.gatewayUrl);
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    const send = (value) => {
+        if (socket?.readyState === WebSocket.OPEN)
+            socket.send(JSON.stringify(ChannelToGatewaySchema.parse(value)));
+    };
+    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 finishInteraction = (requestId, value, local) => {
+        const interaction = interactions.get(requestId);
+        if (!interaction)
+            return;
+        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,
+            });
+    };
+    const connectGateway = () => new Promise((resolve, reject) => {
+        const next = new WebSocket(url, { headers: { authorization: `Bearer ${context.token}` } });
+        socket = next;
+        next.once("open", () => {
+            register();
+            if (active)
+                send({ type: "bridge.status", protocolVersion: REMOTE_PROTOCOL_VERSION, sessionId: parsed.sessionId, busy: true });
+            for (const interaction of interactions.values())
+                send(interaction.requestFrame);
+            resolve();
+        });
+        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.prompt")
+                enqueue({ text: frame.data.text, requestId: frame.data.requestId });
+            else if (frame.data.type === "bridge.approval_response") {
+                finishInteraction(frame.data.requestId, { decision: frame.data.decision }, false);
+            }
+            else if (frame.data.type === "bridge.question_response") {
+                finishInteraction(frame.data.requestId, { answers: frame.data.answers }, false);
+            }
+        });
+        next.once("error", reject);
+        next.on("close", () => {
+            if (socket === next)
+                socket = null;
+            if (!stopped)
+                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));
+        send({ type: "bridge.status", protocolVersion: REMOTE_PROTOCOL_VERSION, sessionId: parsed.sessionId, busy: true });
+    };
+    function enqueue(value) {
+        inputs.push(value);
+        sendNext();
+    }
+    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,
+            };
+            send(requestFrame);
+            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] ?? ""]])) };
+            });
+            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),
+        };
+        send(requestFrame);
+        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);
+        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();
+    const conversation = 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 } : {}),
+        },
+    });
+    const 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())
+            enqueue({ text: line.trim(), requestId: null });
+        terminal.prompt();
+    });
+    terminal.on("close", () => { stopped = true; conversation.close(); });
+    process.stdout.write(`Claude mobile session ${parsed.sessionId}\n`);
+    terminal.prompt();
+    if (parsed.initialPrompt)
+        enqueue({ text: parsed.initialPrompt, requestId: null });
+    const stop = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        if (reconnectTimer)
+            clearTimeout(reconnectTimer);
+        inputStream.close();
+        conversation.close();
+        terminal.close();
+        socket?.close();
+        for (const id of [...interactions.keys()])
+            finishInteraction(id, { decision: "deny" }, true);
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    try {
+        for await (const message of conversation) {
+            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?.requestId && result)
+                send({
+                    type: "channel.reply",
+                    protocolVersion: REMOTE_PROTOCOL_VERSION,
+                    sessionId: parsed.sessionId,
+                    requestId: completedInput.requestId,
+                    text: result,
+                });
+            active = null;
+            send({ type: "bridge.status", protocolVersion: REMOTE_PROTOCOL_VERSION, sessionId: parsed.sessionId, busy: false });
+            terminal.prompt();
+            sendNext();
+        }
+        return stopped ? 0 : 1;
+    }
+    finally {
+        process.off("SIGINT", stop);
+        process.off("SIGTERM", stop);
+        stop();
+    }
+}