@neta-art/cohub-cli 7.1.2 → 8.0.0

package/dist/runtime/connection.d.ts

@@ -1,4 +1,4 @@
-import { type RuntimeCapabilities } from "@neta-art/cohub";
+import { type RuntimeCapabilities, type NativeRuntimeEvent } from "@neta-art/cohub";
 import { type HarnessOptions } from "./harness.js";
 import { type RuntimeSessionStore } from "./session-store.js";
 import { type RuntimeDiagnostics } from "./diagnostics.js";
@@ -8,12 +8,14 @@ export type RuntimeConnectionOptions = {
     url: string;
     capabilities: RuntimeCapabilities;
     harnesses: HarnessOptions;
-    token: () => Promise<string>;
+    token: (forceRefresh?: boolean) => Promise<string>;
     signal: AbortSignal;
     store: RuntimeSessionStore;
     onReady: () => void;
+    onDisconnected?: () => void;
     runtimeId?: string;
     diagnostics?: RuntimeDiagnostics;
     leaseConflictTimeoutMs?: number;
+    onNativeChannel?: (send: (event: NativeRuntimeEvent) => Promise<unknown>) => void;
 };
 export declare function serveRuntime(options: RuntimeConnectionOptions): Promise<void>;

package/dist/runtime/connection.js

@@ -16,7 +16,7 @@ export async function serveRuntime(options) {
     const flush = () => options.store.flushArchives(uploadSignal).catch((error) => {
         if (!uploadSignal.aborted) {
             log("warn", "archive.flush_failed", { error: serializeDiagnosticError(error) });
-            console.error("Archive pending:", error);
+            // The diagnostic sink handles terminal presentation and throttling.
         }
     });
     const timer = setInterval(() => {
@@ -31,22 +31,36 @@ export async function serveRuntime(options) {
     try {
         while (!options.signal.aborted) {
             attempt += 1;
-            const outcome = await connect({
-                ...options,
-                runtimeId,
-                attempt,
-                onReady: () => {
-                    backoff = 500;
-                    attempt = 0;
-                    conflictSince = null;
-                    options.onReady();
-                    void flush();
-                },
-            });
+            let readyAt = 0;
+            let outcome;
+            try {
+                outcome = await connect({
+                    ...options,
+                    runtimeId,
+                    attempt,
+                    onReady: () => {
+                        readyAt = Date.now();
+                        conflictSince = null;
+                        options.onReady();
+                        void flush();
+                    },
+                });
+            }
+            catch (error) {
+                if (options.signal.aborted)
+                    return;
+                log("warn", "runtime.connection_failed", { error: serializeDiagnosticError(error) });
+                outcome = "retry";
+            }
+            options.onDisconnected?.();
             if (options.signal.aborted)
                 return;
             if (outcome === "fatal")
-                throw new Error("Runtime connection rejected");
+                throw new Error("Runtime connection rejected / Runtime 连接被拒绝，请检查权限或升级 CLI");
+            if (readyAt && Date.now() - readyAt >= 60_000) {
+                backoff = 500;
+                attempt = 0;
+            }
             if (outcome === "conflict") {
                 conflictSince ??= Date.now();
                 if (Date.now() - conflictSince >= (options.leaseConflictTimeoutMs ?? 90_000)) {
@@ -58,8 +72,8 @@ export async function serveRuntime(options) {
                 delayMs: backoff,
                 outcome,
             });
-            await delay(backoff, undefined, { signal: options.signal }).catch(() => undefined);
-            backoff = Math.min(10_000, backoff * 2);
+            await delay(backoff / 2 + Math.random() * backoff / 2, undefined, { signal: options.signal }).catch(() => undefined);
+            backoff = Math.min(30_000, backoff * 2);
         }
     }
     finally {
@@ -91,7 +105,7 @@ async function connect(options) {
         currentToken = await options.token();
     }
     catch (error) {
-        log("error", "runtime.auth_token_failed", { error: serializeDiagnosticError(error) });
+        log("warn", error instanceof Error && error.name === "AuthRequiredError" ? "runtime.auth_required" : "runtime.auth_token_failed", { error: serializeDiagnosticError(error) });
         throw error;
     }
     const runtimeUrl = new URL(options.url);
@@ -105,7 +119,10 @@ async function connect(options) {
     let connectionId = null;
     let fatal = false;
     let conflict = false;
+    let unauthorized = false;
     let readyTimer;
+    const nativePending = new Map();
+    let nativeChannelReady = false;
     const send = (frame) => {
         if (socket.readyState !== WebSocket.OPEN || socket.bufferedAmount > RUNTIME_MAX_FRAME_BYTES) {
             log("warn", "runtime.frame_send_unavailable", {
@@ -127,6 +144,23 @@ async function connect(options) {
             execution.controller.abort();
         socket.close();
     };
+    const sendNative = (event) => new Promise((resolve, reject) => {
+        if (!nativeChannelReady || !connectionId) {
+            reject(new Error("Runtime native channel is unavailable"));
+            return;
+        }
+        const requestId = randomUUID();
+        const timer = setTimeout(() => { nativePending.delete(requestId); reject(new Error("Native Runtime event timed out")); }, 30_000);
+        nativePending.set(requestId, { resolve, reject, timer });
+        try {
+            send({ type: "runtime.native", requestId, event });
+        }
+        catch (error) {
+            clearTimeout(timer);
+            nativePending.delete(requestId);
+            reject(error instanceof Error ? error : new Error(String(error)));
+        }
+    });
     options.signal.addEventListener("abort", stop, { once: true });
     const heartbeat = setInterval(() => {
         const heartbeatAgeMs = Date.now() - lastHeartbeat;
@@ -174,10 +208,11 @@ async function connect(options) {
     }, 10_000);
     const closed = new Promise((resolve) => {
         socket.addEventListener("close", (event) => {
-            fatal = [4400, 4401, 4403].includes(event.code);
+            unauthorized = event.code === 4401;
+            fatal = [4400, 4403].includes(event.code);
             conflict = event.code === 4409;
             disconnected.abort();
-            log(fatal || conflict ? "error" : "warn", "runtime.websocket.closed", {
+            log(options.signal.aborted ? "debug" : fatal || conflict ? "error" : "warn", "runtime.websocket.closed", {
                 code: event.code,
                 reason: event.reason,
                 durationMs: Date.now() - connectedAt,
@@ -185,8 +220,13 @@ async function connect(options) {
                 fatal,
                 conflict,
             }, { connectionId });
-            if (!options.signal.aborted)
-                console.error(`Runtime disconnected (${event.code}): ${event.reason}`);
+            nativeChannelReady = false;
+            for (const pending of nativePending.values()) {
+                clearTimeout(pending.timer);
+                pending.reject(new Error("Runtime native channel disconnected"));
+            }
+            nativePending.clear();
+            options.onDisconnected?.();
             for (const execution of active.values()) {
                 log("error", "runtime.execution_transport_lost", {
                     code: event.code,
@@ -246,6 +286,8 @@ async function connect(options) {
                     connectionId,
                     durationMs: Date.now() - connectedAt,
                 }, { connectionId });
+                nativeChannelReady = true;
+                options.onNativeChannel?.(sendNative);
                 options.onReady();
                 let recoveryBatch = 0;
                 for await (const executions of options.store.pendingExecutionBatches()) {
@@ -264,6 +306,19 @@ async function connect(options) {
                 lastHeartbeat = Date.now();
                 return;
             }
+            if (raw.type === "runtime.native.result") {
+                const result = raw;
+                const pending = result.requestId ? nativePending.get(result.requestId) : null;
+                if (!pending)
+                    return;
+                clearTimeout(pending.timer);
+                nativePending.delete(result.requestId ?? "");
+                if (result.error)
+                    pending.reject(new Error(result.error));
+                else
+                    pending.resolve(result.result);
+                return;
+            }
             const frame = runtimeCommandSchema.parse(raw);
             if (frame.type === "session.context") {
                 log("debug", "runtime.context_received", {
@@ -294,7 +349,7 @@ async function connect(options) {
                         revision: frame.revision,
                         error: serializeDiagnosticError(error),
                     }, context);
-                    console.error("Runtime acknowledgement failed; result retained:", error);
+                    // Keep the receipt; the next reconciliation can retry acknowledgement.
                     active.delete(frame.requestId);
                     send({ type: "runtime.event", requestId: frame.requestId, event: { type: "turn.error", message: "Local acknowledgement failed; result retained" } });
                     return;
@@ -353,7 +408,7 @@ async function connect(options) {
                     catch (error) {
                         if (!recovery.controller.signal.aborted) {
                             log("error", "runtime.recovery_failed", { error: serializeDiagnosticError(error) }, context);
-                            console.error("Runtime recovery failed; original files retained:", error);
+                            // Original files and receipts remain available for reconciliation.
                             try {
                                 send({ type: "runtime.event", requestId: frame.requestId, event: { type: "turn.error", uncertain: true, message: "Result unavailable; files retained" } });
                             }
@@ -523,5 +578,7 @@ async function connect(options) {
         clearInterval(heartbeat);
         options.signal.removeEventListener("abort", stop);
     }
+    if (unauthorized && !options.signal.aborted)
+        await options.token(true);
     return fatal ? "fatal" : conflict ? "conflict" : "retry";
 }

package/dist/runtime/diagnostics.d.ts

@@ -50,6 +50,8 @@ export type RuntimeDiagnosticsOptions = {
     logFlushIntervalMs?: number;
     maxLogFileBytes?: number;
     maxTotalLogBytes?: number;
+    /** Receives only the redacted event, before asynchronous disk I/O. */
+    onEvent?: (event: RuntimeDiagnostic) => void;
 };
 export type ReadRuntimeDiagnosticsOptions = {
     limit?: number;
@@ -64,6 +66,7 @@ export declare class RuntimeDiagnostics {
     readonly logPath: string;
     private readonly spaceId;
     private readonly component;
+    private readonly onEvent?;
     private readonly logFlushIntervalMs;
     private readonly maxLogFileBytes;
     private readonly maxTotalLogBytes;

package/dist/runtime/diagnostics.js

@@ -134,6 +134,7 @@ export class RuntimeDiagnostics {
     logPath;
     spaceId;
     component;
+    onEvent;
     logFlushIntervalMs;
     maxLogFileBytes;
     maxTotalLogBytes;
@@ -153,6 +154,7 @@ export class RuntimeDiagnostics {
         this.runtimeId = options.runtimeId ?? randomUUID();
         this.spaceId = options.spaceId;
         this.component = options.component ?? "runtime";
+        this.onEvent = options.onEvent;
         this.logFlushIntervalMs = options.logFlushIntervalMs ?? DEFAULT_LOG_FLUSH_INTERVAL_MS;
         this.maxLogFileBytes = options.maxLogFileBytes ?? DEFAULT_MAX_LOG_FILE_BYTES;
         this.maxTotalLogBytes = options.maxTotalLogBytes ?? DEFAULT_MAX_TOTAL_LOG_BYTES;
@@ -193,6 +195,7 @@ export class RuntimeDiagnostics {
             ...(diagnosticError ? { error: diagnosticError } : {}),
         });
         this.enqueueWrite(value);
+        this.onEvent?.(value);
     }
     async close() {
         this.closed = true;

package/dist/runtime/harness.d.ts

@@ -6,6 +6,9 @@ export type HarnessOptions = {
     pi?: string;
     codex?: string;
 };
+export declare function harnessExecutableCandidates(binary: string, cwd: string, path: string, platform?: NodeJS.Platform, pathExt?: string | undefined): string[];
+/** Discover installed executables only; authentication/capability errors stay explicit. */
+export declare function installedHarnesses(cwd: string, options: HarnessOptions, path?: string): Promise<("pi" | "codex")[]>;
 export type HarnessResult = {
     state: NativeSession;
     event: Extract<RuntimeExecutionEvent, {

package/dist/runtime/harness.js

@@ -1,8 +1,40 @@
+import { access, stat } from "node:fs/promises";
+import { constants } from "node:fs";
+import { delimiter, join, resolve, win32 } from "node:path";
 import { JsonRpcProcess, record } from "./json-rpc.js";
 import { codexModelCatalog } from "./model-catalog.js";
 import { codexTokenTotals, codexUsage, subtractCodexTokens } from "./codex-usage.js";
 import { downloadPublicImage } from "../safe-remote-image.js";
 import { serializeDiagnosticError } from "./diagnostics.js";
+export function harnessExecutableCandidates(binary, cwd, path, platform = process.platform, pathExt = process.env.PATHEXT) {
+    const windows = platform === "win32";
+    const paths = windows ? win32 : { delimiter, join, resolve };
+    const extensions = windows && !win32.extname(binary)
+        ? ["", ...(pathExt || ".COM;.EXE;.BAT;.CMD").split(";").filter((ext) => /^\.[a-z0-9]+$/i.test(ext))]
+        : [""];
+    const roots = binary.includes("/") || binary.includes("\\")
+        ? [paths.resolve(cwd, binary)]
+        : path.split(paths.delimiter).map((directory) => directory.replace(/^"(.*)"$/, "$1")).filter(Boolean).map((directory) => paths.resolve(cwd, directory, binary));
+    return roots.flatMap((root) => extensions.map((ext) => `${root}${ext}`));
+}
+/** Discover installed executables only; authentication/capability errors stay explicit. */
+export async function installedHarnesses(cwd, options, path = process.env.PATH ?? "") {
+    const names = options.pi || options.codex ? ["pi", "codex"].filter((name) => options[name]) : ["pi", "codex"];
+    const found = await Promise.all(names.map(async (name) => {
+        const binary = options[name] || name;
+        const candidates = harnessExecutableCandidates(binary, cwd, path);
+        for (const candidate of candidates) {
+            try {
+                await access(candidate, process.platform === "win32" ? constants.F_OK : constants.X_OK);
+                if ((await stat(candidate)).isFile())
+                    return name;
+            }
+            catch { /* Try the next PATH entry. */ }
+        }
+        return null;
+    }));
+    return found.filter((name) => name !== null);
+}
 const runtimeEnvironment = (input) => ({ COHUB_SPACE_ID: input.spaceId, COHUB_SESSION_ID: input.sessionId, COHUB_TURN_ID: input.turnId });
 const array = (value) => Array.isArray(value) ? value : [];
 const text = (value) => typeof value === "string" ? value : "";
@@ -49,7 +81,8 @@ function createAbortEscalation(rpc, signal, interrupt) {
 }
 /** Native files stay authoritative; archival failure only degrades cross-host resume. */
 async function finishHarnessTurn(store, state, message, resume, turnId, diagnosticContext) {
-    const archive = await store.archive(state, turnId, diagnosticContext).catch((error) => { console.error("Native archive unavailable; local files retained:", error); return null; });
+    // The store records a redacted diagnostic; native files remain authoritative.
+    const archive = await store.archive(state, turnId, diagnosticContext).catch(() => null);
     return { state, event: { type: "turn.end", message, resume, archive } };
 }
 export async function discoverHarnesses(harnesses, options, cwd) {

package/dist/runtime/instance.d.ts

@@ -0,0 +1,5 @@
+import type { RuntimeSummary } from "./presentation.js";
+export declare function runtimeInstanceDirectory(identity: string, spaceId: string): string;
+export declare function requestRuntimeInstance(directory: string, action?: "status" | "stop", force?: boolean): Promise<RuntimeSummary | null>;
+/** Private local IPC is both the single-instance guard and the control surface. */
+export declare function ownRuntimeInstance(directory: string, status: () => RuntimeSummary, stop: (force: boolean) => Promise<void>): Promise<() => Promise<void>>;

package/dist/runtime/instance.js

@@ -0,0 +1,159 @@
+import { createHash, randomUUID } from "node:crypto";
+import { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { createConnection, createServer } from "node:net";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { withRuntimeSpaceBindingsLock } from "./space-binding.js";
+export function runtimeInstanceDirectory(identity, spaceId) {
+    const key = createHash("sha256").update(`${identity}\0${spaceId}`).digest("hex").slice(0, 24);
+    return join(homedir(), ".local", "state", "cohub", "instances", key);
+}
+function alive(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return true;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== "ESRCH";
+    }
+}
+async function readRecord(directory) {
+    try {
+        const value = JSON.parse(await readFile(join(directory, "owner.json"), "utf8"));
+        if (!Number.isSafeInteger(value.pid) || typeof value.nonce !== "string" || typeof value.socket !== "string")
+            throw new Error("Invalid Runtime instance record / Runtime 实例记录无效");
+        return value;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+function request(record, action, force = false) {
+    return new Promise((resolve, reject) => {
+        const socket = createConnection(record.socket);
+        const timer = setTimeout(() => { socket.destroy(); reject(new Error("Runtime control timed out / Runtime 控制连接超时")); }, 3000);
+        let buffer = "";
+        let settled = false;
+        const finish = (error, value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            socket.destroy();
+            if (error)
+                reject(error);
+            else if (value)
+                resolve(value);
+        };
+        socket.on("connect", () => socket.write(`${JSON.stringify({ nonce: record.nonce, action, force })}\n`));
+        socket.on("error", (error) => finish(error));
+        socket.on("close", () => finish(new Error("Runtime control closed / Runtime 控制连接已关闭")));
+        socket.on("data", (chunk) => {
+            buffer += chunk.toString();
+            if (buffer.length > 64 * 1024) {
+                finish(new Error("Runtime response too large"));
+                return;
+            }
+            if (!buffer.includes("\n"))
+                return;
+            try {
+                const response = JSON.parse(buffer.slice(0, buffer.indexOf("\n")));
+                if (response.error)
+                    finish(new Error(response.error));
+                else if (response.nonce !== record.nonce || response.status?.pid !== record.pid)
+                    finish(new Error("Runtime identity changed / Runtime 身份已变化"));
+                else
+                    finish(undefined, response.status);
+            }
+            catch (error) {
+                finish(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    });
+}
+export async function requestRuntimeInstance(directory, action = "status", force = false) {
+    const record = await readRecord(directory);
+    if (!record || !alive(record.pid))
+        return null;
+    try {
+        return await request(record, action, force);
+    }
+    catch (error) {
+        // A reused PID is not proof of ownership. Missing/refused endpoints cannot
+        // belong to a serving Runtime; timeouts and permission errors remain uncertain.
+        if (["ENOENT", "ECONNREFUSED"].includes(error.code ?? ""))
+            return null;
+        throw error;
+    }
+}
+/** Private local IPC is both the single-instance guard and the control surface. */
+export async function ownRuntimeInstance(directory, status, stop) {
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    return withRuntimeSpaceBindingsLock(async () => {
+        if (await requestRuntimeInstance(directory))
+            throw new Error("Runtime already running; use status / Runtime 已在运行，请使用 status");
+        const socketPath = process.platform === "win32"
+            ? `\\\\.\\pipe\\cohub-${createHash("sha256").update(directory).digest("hex").slice(0, 24)}`
+            : join(directory, "control.sock");
+        if (process.platform !== "win32")
+            await rm(socketPath, { force: true });
+        const record = { pid: process.pid, nonce: randomUUID(), socket: socketPath };
+        const clients = new Set();
+        const server = createServer((socket) => {
+            clients.add(socket);
+            socket.setTimeout(3000, () => socket.destroy());
+            socket.on("error", () => socket.destroy());
+            socket.on("close", () => clients.delete(socket));
+            let input = "";
+            socket.on("data", (chunk) => {
+                input += chunk.toString();
+                if (input.length > 4096) {
+                    socket.destroy();
+                    return;
+                }
+                if (!input.includes("\n"))
+                    return;
+                socket.removeAllListeners("data");
+                void (async () => {
+                    const message = JSON.parse(input.slice(0, input.indexOf("\n")));
+                    if (message.nonce !== record.nonce) {
+                        socket.destroy();
+                        return;
+                    }
+                    if (message.action === "stop")
+                        await stop(message.force === true);
+                    else if (message.action !== "status")
+                        throw new Error("Unknown Runtime control request");
+                    socket.end(`${JSON.stringify({ nonce: record.nonce, status: status() })}\n`);
+                })().catch((error) => socket.end(`${JSON.stringify({ error: error instanceof Error ? error.message : String(error) })}\n`));
+            });
+        });
+        await new Promise((resolve, reject) => {
+            server.once("error", reject);
+            server.listen(socketPath, () => { server.removeListener("error", reject); resolve(); });
+        });
+        try {
+            if (process.platform !== "win32")
+                await chmod(socketPath, 0o600);
+            const temporary = join(directory, `${record.nonce}.tmp`);
+            await writeFile(temporary, JSON.stringify(record), { mode: 0o600 });
+            await rename(temporary, join(directory, "owner.json"));
+        }
+        catch (error) {
+            server.close();
+            throw error;
+        }
+        return async () => {
+            for (const client of clients)
+                client.destroy();
+            await new Promise((resolve) => server.close(() => resolve()));
+            // Never remove a replacement owner's files.
+            if ((await readRecord(directory))?.nonce === record.nonce)
+                await rm(join(directory, "owner.json"));
+        };
+    }, { path: join(directory, "owner.json") });
+}

package/dist/runtime/launch.d.ts

@@ -0,0 +1,20 @@
+import type { Command } from "commander";
+import { type RuntimeSummary } from "./presentation.js";
+import { type RuntimeLaunch } from "./supervisor.js";
+export type RuntimeUpOptions = {
+    space?: string;
+    new?: boolean;
+    name?: string;
+    harness: string[];
+    pi?: string;
+    codex?: string;
+    yes?: boolean;
+    json?: boolean;
+    detach?: boolean;
+    verbose?: boolean;
+};
+export declare const resolveLocalSpaceName: (root: string, name?: string) => string;
+export declare function parseRuntimeHarnesses(values: string[]): ("pi" | "codex")[];
+export declare function resolveRuntimeTarget(program: Command, target?: string): Promise<string>;
+export declare function startBackgroundRuntime(config: RuntimeLaunch): Promise<RuntimeSummary>;
+export declare function runtimeUp(program: Command, dir: string | undefined, options: RuntimeUpOptions): Promise<void>;