@neta-art/cohub-cli 7.1.2 → 8.0.0

package/dist/runtime/launch.js

@@ -0,0 +1,176 @@
+import { fork } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { stat } from "node:fs/promises";
+import { basename, resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { isLocalHarness } from "@neta-art/cohub";
+import { discoverHarnesses, installedHarnesses } from "./harness.js";
+import { requireAccessToken } from "../auth.js";
+import { createClient } from "../client.js";
+import { currentIdentityKey, explicitSpace } from "../space.js";
+import { canonicalRuntimeRoot, getRuntimeSpaceBinding, resolveRuntimeSpace } from "./space-binding.js";
+import { requestRuntimeInstance, runtimeInstanceDirectory } from "./instance.js";
+import { createDiagnosticConsole, printRuntimeSummary, runtimeWebUrl } from "./presentation.js";
+import { runRuntime } from "./supervisor.js";
+export const resolveLocalSpaceName = (root, name) => name?.trim() || basename(root) || "local-space";
+export function parseRuntimeHarnesses(values) {
+    const names = values.flatMap((value) => value.split(",")).map((name) => name.trim()).filter(Boolean);
+    if (names.some((name) => !isLocalHarness(name)))
+        throw new Error("Harness must be pi or codex / Harness 必须是 pi 或 codex");
+    return [...new Set(names.length ? names : ["pi"])];
+}
+export async function resolveRuntimeTarget(program, target) {
+    const spaceId = target?.trim() || explicitSpace(program) || (await getRuntimeSpaceBinding(process.cwd(), currentIdentityKey()))?.spaceId;
+    if (!spaceId)
+        throw new Error("No directory binding. Use --space <id> or runtime up / 此目录未绑定 Space，请使用 --space <id> 或 runtime up");
+    return spaceId;
+}
+export async function startBackgroundRuntime(config) {
+    return new Promise((resolve, reject) => {
+        // Keep the same Node executable and loader (also works from source in tests).
+        const workerUrl = new URL(import.meta.url.endsWith(".ts") ? "./worker.ts" : "./worker.js", import.meta.url);
+        const child = fork(workerUrl, [], { detached: true, stdio: ["ignore", "ignore", "ignore", "ipc"] });
+        const diagnosticConsole = createDiagnosticConsole(config.verbose);
+        let last = null;
+        let settled = false;
+        const finish = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            child.removeAllListeners("message");
+            // Let already queued IPC messages drain before closing Node's channel.
+            setImmediate(() => { if (child.connected)
+                child.disconnect(); child.unref(); });
+            if (error)
+                reject(error);
+            else if (last)
+                resolve(last);
+            else
+                reject(new Error("Runtime did not start / Runtime 未启动"));
+        };
+        const timeout = setTimeout(() => finish(last ? undefined : new Error("Runtime startup timed out / Runtime 启动超时")), 30_000);
+        child.on("error", (error) => finish(error));
+        child.on("exit", (code) => finish(new Error(`Runtime exited (${code}) / Runtime 已退出`)));
+        child.on("message", (message) => {
+            if (message.type === "status" && message.status) {
+                last = message.status;
+                if (last.state === "ready")
+                    finish();
+            }
+            else if (message.type === "failed")
+                finish(new Error(message.error ?? "Runtime failed"));
+            else if (message.type === "diagnostic" && message.event)
+                diagnosticConsole(message.event);
+        });
+        child.send(config);
+    });
+}
+export async function runtimeUp(program, dir, options) {
+    const requestedRoot = resolve(dir ?? process.cwd());
+    if (!(await stat(requestedRoot)).isDirectory())
+        throw new Error("Workspace is not a directory / 工作区不是目录");
+    const root = await canonicalRuntimeRoot(requestedRoot);
+    const requested = options.space?.trim() || explicitSpace(program);
+    if (options.new && requested)
+        throw new Error("--new cannot be combined with --space or COHUB_SPACE_ID / --new 不能与显式 Space 同时使用");
+    if (options.name && requested)
+        throw new Error("--name only applies to a new Space / --name 仅用于新建 Space");
+    const identity = currentIdentityKey();
+    if (!identity) {
+        await requireAccessToken();
+        throw new Error("Cannot identify the signed-in account / 无法识别当前登录账号");
+    }
+    const binding = await getRuntimeSpaceBinding(root, identity);
+    const existingId = requested || binding?.spaceId;
+    let harnesses = parseRuntimeHarnesses(options.harness);
+    if (existingId && !options.new) {
+        const existing = await requestRuntimeInstance(runtimeInstanceDirectory(identity, existingId));
+        if (existing) {
+            if (existing.root !== root || options.harness.length && [...existing.harnesses].sort().join() !== [...harnesses].sort().join() || options.pi || options.codex) {
+                throw new Error("Runtime is running with a different configuration. Use down first / Runtime 正使用不同配置运行，请先 down");
+            }
+            printRuntimeSummary(existing, options.json, true);
+            return;
+        }
+    }
+    if (!options.harness.length)
+        harnesses = await installedHarnesses(root, options);
+    if (!harnesses.length)
+        throw new Error("Install and sign in to Pi or Codex, or pass --harness / 请安装并登录 Pi 或 Codex，或显式指定 --harness");
+    let createNew = Boolean(options.new);
+    let name = resolveLocalSpaceName(root, options.name);
+    if (!options.yes) {
+        if (!process.stdin.isTTY)
+            throw new Error("Use --yes to authorize local execution / 请使用 --yes 授权本地执行");
+        const rl = createInterface({ input: process.stdin, output: process.stderr });
+        try {
+            if (!requested && binding) {
+                process.stderr.write(`\nLinked Space / 已关联 Space\n  ${runtimeWebUrl(binding.spaceId)}\n`);
+                const answer = (await rl.question("Reuse this Space? [Y/n, q to cancel] / 复用此 Space？[Y/n，q 取消] ")).trim().toLowerCase();
+                if (answer === "q")
+                    return;
+                createNew = answer === "n" || answer === "no";
+            }
+            else if (!requested) {
+                const answer = (await rl.question("Create a new Space? [Y/n] / 创建新 Space？[Y/n] ")).trim().toLowerCase();
+                if (answer && answer !== "y" && answer !== "yes")
+                    return;
+            }
+            if (binding && createNew && !options.name)
+                name = `${name}-${randomUUID().slice(0, 6)}`;
+            if (!requested && (!binding || createNew))
+                name = (await rl.question(`Space name / Space 名称 [${name}]: `)).trim() || name;
+            process.stderr.write(`\nDirectory / 目录  ${root}\n${requested ? `Space / 空间  ${runtimeWebUrl(requested)}\n` : ""}`);
+            const answer = await rl.question("Collaborators can execute as your OS user, beyond this folder. Allow? [y/N] / 协作者可使用你的系统身份执行命令，不限于此目录。允许？[y/N] ");
+            if (!/^y(es)?$/i.test(answer.trim()))
+                return;
+        }
+        finally {
+            rl.close();
+        }
+    }
+    if (options.yes && createNew && binding && !options.name)
+        name = `${name}-${randomUUID().slice(0, 6)}`;
+    if (createNew && binding && await requestRuntimeInstance(runtimeInstanceDirectory(identity, binding.spaceId))) {
+        throw new Error("Stop the existing Runtime before rebinding this directory / 请先停止此目录的 Runtime，再创建新绑定");
+    }
+    // Fail local preflight before creating remote state; the worker reuses this catalog.
+    const capabilities = await discoverHarnesses(harnesses, options, root);
+    const client = createClient();
+    const { spaceId, source } = await resolveRuntimeSpace({
+        root, identityKey: identity, explicitSpaceId: requested,
+        newSpace: createNew, expectedSpaceId: binding?.spaceId ?? null,
+        createSpace: async () => (await client.spaces.create({ name, config: { sandbox: { provider: "local" } } })).space.id,
+        validateSpace: async (id) => {
+            const sandbox = (await client.space(id).sandbox.get()).sandbox;
+            if (sandbox?.provider !== "local")
+                throw new Error("Space does not have a local Runtime / 此 Space 不是本地 Runtime");
+        },
+    });
+    const config = { spaceId, root, identity, harnesses, capabilities, executables: { pi: options.pi, codex: options.codex }, background: Boolean(options.detach), verbose: options.verbose };
+    const existing = await requestRuntimeInstance(runtimeInstanceDirectory(identity, spaceId));
+    if (existing) {
+        if (existing.root !== root)
+            throw new Error("This Space is running in another directory / 此 Space 已在另一目录运行");
+        printRuntimeSummary(existing, options.json, true);
+        return;
+    }
+    if (options.detach) {
+        const summary = await startBackgroundRuntime(config);
+        printRuntimeSummary(summary, options.json, source === "binding");
+        if (summary.state !== "ready")
+            process.exitCode = 2;
+    }
+    else {
+        let announced = false;
+        await runRuntime(config, (status) => {
+            if (!announced && status.state === "ready") {
+                announced = true;
+                printRuntimeSummary(status, options.json, source === "binding");
+            }
+            else if (!announced && status.state === "starting" && !options.json)
+                process.stderr.write(`Connecting / 正在连接\n  ${runtimeWebUrl(spaceId)}\n  Logs / 日志  ${status.diagnosticsPath}\n`);
+        });
+    }
+}

package/dist/runtime/native-codex-hook.d.ts

@@ -0,0 +1 @@
+export declare function runCodexNativeHook(payload: unknown): Promise<void>;

package/dist/runtime/native-codex-hook.js

@@ -0,0 +1,28 @@
+import { pathToFileURL } from "node:url";
+import { requestNativeDaemon } from "./native-ipc.js";
+export async function runCodexNativeHook(payload) {
+    if (process.env.COHUB_TURN_ID || process.env.COHUB_EXECUTION_TOKEN)
+        return;
+    const value = payload;
+    if (!value || typeof value.cwd !== "string" || typeof value.session_id !== "string")
+        throw new Error("Invalid Codex hook identity / Codex Hook 身份无效");
+    if (typeof value.transcript_path !== "string" || !value.transcript_path)
+        return;
+    const result = await requestNativeDaemon({ harness: "codex", cwd: value.cwd, path: value.transcript_path, nativeSessionId: value.session_id });
+    if (!result.ok)
+        throw new Error(result.message);
+}
+async function main() {
+    let input = "";
+    for await (const chunk of process.stdin) {
+        input += chunk.toString();
+        if (Buffer.byteLength(input) > 4 * 1024 * 1024)
+            throw new Error("Codex hook input is too large / Codex Hook 输入过大");
+    }
+    await runCodexNativeHook(JSON.parse(input));
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    void main().catch((error) => {
+        process.stderr.write(`Cohub sync pending; native execution continues / Cohub 待同步，原生执行继续: ${error instanceof Error ? error.message : String(error)}\n`);
+    });
+}

package/dist/runtime/native-install.d.ts

@@ -0,0 +1,21 @@
+export declare function codexNativeHookBlock(node: string, hook: string): string;
+export declare function verifyNativeSyncSupport(harnesses: ("pi" | "codex")[], cwd: string, executables?: {
+    pi?: string;
+    codex?: string;
+}): Promise<void>;
+/** Install once in the user's native configuration; data collection remains explicitly project-scoped. */
+export declare function installNativeSync(input: {
+    root: string;
+    spaceId: string;
+    identity: string;
+    harnesses: ("pi" | "codex")[];
+    disabled?: boolean;
+    executables?: {
+        pi?: string;
+        codex?: string;
+    };
+}): Promise<{
+    configPath: string;
+    harnesses: ("codex" | "pi")[];
+    enabled: boolean;
+}>;

package/dist/runtime/native-install.js

@@ -0,0 +1,130 @@
+import { createHash, randomUUID } from "node:crypto";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { lstat, mkdir, open, readFile, rename, rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { atomicRuntimeJson } from "./archive-store.js";
+import { nativeRuntimeRoot, nativeSyncConfigPath, readNativeSyncConfig } from "./native-sync.js";
+import { withRuntimeSpaceBindingsLock } from "./space-binding.js";
+const START = "# BEGIN COHUB NATIVE SYNC";
+const END = "# END COHUB NATIVE SYNC";
+const shellQuote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+const missing = (error) => error.code === "ENOENT";
+export function codexNativeHookBlock(node, hook) {
+    const command = `${shellQuote(node)} ${shellQuote(hook)}`;
+    return `${START}\n${["SessionStart", "UserPromptSubmit", "PostToolUse", "Stop", "Interrupt", "SessionEnd"].map((event) => `[[hooks.${event}]]\n[[hooks.${event}.hooks]]\ntype = "command"\ncommand = ${JSON.stringify(command)}\ntimeout = ${event === "SessionEnd" || event === "Interrupt" ? 3 : 10}\n`).join("\n")}${END}\n`;
+}
+async function installText(path, update) {
+    await withRuntimeSpaceBindingsLock(async () => {
+        const info = await lstat(path).catch((error) => { if (missing(error))
+            return null; throw error; });
+        if (info && (!info.isFile() || info.isSymbolicLink()))
+            throw new Error(`Refusing to replace a non-regular file / 不覆盖非普通文件: ${path}`);
+        const original = info ? await readFile(path, "utf8") : null;
+        const next = update(original);
+        if (next === original)
+            return;
+        await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+        if (original !== null) {
+            const backup = `${path}.cohub-backup-${createHash("sha256").update(original).digest("hex").slice(0, 16)}`;
+            const file = await open(backup, "wx", 0o600).catch((error) => { if (error.code === "EEXIST")
+                return null; throw error; });
+            if (file) {
+                try {
+                    await file.writeFile(original);
+                    await file.sync();
+                }
+                finally {
+                    await file.close();
+                }
+            }
+        }
+        const temporary = `${path}.${randomUUID()}.tmp`;
+        try {
+            const file = await open(temporary, "wx", info?.mode ?? 0o600);
+            try {
+                await file.writeFile(next);
+                await file.sync();
+            }
+            finally {
+                await file.close();
+            }
+            const current = await readFile(path, "utf8").catch((error) => { if (missing(error))
+                return null; throw error; });
+            if (current !== original)
+                throw new Error(`Configuration changed during installation / 安装期间配置已变化: ${path}`);
+            await rename(temporary, path);
+            const directory = await open(dirname(path), "r");
+            try {
+                await directory.sync();
+            }
+            finally {
+                await directory.close();
+            }
+        }
+        finally {
+            await rm(temporary, { force: true });
+        }
+    }, { lockPath: `${path}.cohub-lock` });
+}
+export async function verifyNativeSyncSupport(harnesses, cwd, executables = {}) {
+    for (const harness of harnesses) {
+        const { stdout } = await promisify(execFile)(executables[harness] || harness, harness === "pi" ? ["--version"] : ["features", "list"], { cwd, encoding: "utf8", timeout: 15_000, maxBuffer: 1024 * 1024 });
+        if (harness === "pi") {
+            const version = /\b(\d+)\.(\d+)\.(\d+)\b/.exec(stdout);
+            if (!version || Number(version[1]) === 0 && (Number(version[2]) < 85 || Number(version[2]) === 85 && Number(version[3]) < 1))
+                throw new Error("Native sync requires Pi 0.85.1+ / 原生同步需要 Pi 0.85.1 或更高版本");
+        }
+        else if (!/^hooks\s+stable\s+true\s*$/m.test(stdout))
+            throw new Error("Install a Codex version with stable Hooks and enable hooks first / 请安装支持稳定 Hooks 的 Codex 版本并启用 Hooks");
+    }
+}
+/** Install once in the user's native configuration; data collection remains explicitly project-scoped. */
+export async function installNativeSync(input) {
+    if (!input.disabled)
+        await verifyNativeSyncSupport(input.harnesses, input.root, input.executables);
+    const runtimeRoot = nativeRuntimeRoot(input.spaceId);
+    const configPath = nativeSyncConfigPath(runtimeRoot, input.identity);
+    const extension = new URL(import.meta.url.endsWith(".ts") ? "./native-pi-extension.ts" : "./native-pi-extension.js", import.meta.url);
+    const hook = fileURLToPath(new URL(import.meta.url.endsWith(".ts") ? "./native-codex-hook.ts" : "./native-codex-hook.js", import.meta.url));
+    if (!input.disabled)
+        for (const harness of input.harnesses) {
+            if (harness === "pi") {
+                const content = `// Cohub native Turn sync / Cohub 原生 Turn 同步\nexport { default } from ${JSON.stringify(extension.href)};\n`;
+                await installText(join(process.env.PI_CODING_AGENT_DIR?.trim() || join(homedir(), ".pi", "agent"), "extensions", "cohub.ts"), (existing) => {
+                    if (existing !== null && existing !== content)
+                        throw new Error("Pi Cohub extension already exists; preserve it and review manually / Pi Cohub 扩展已存在，请保留并手动核对");
+                    return content;
+                });
+            }
+            else {
+                const block = codexNativeHookBlock(process.execPath, hook);
+                await installText(join(process.env.CODEX_HOME?.trim() || join(homedir(), ".codex"), "config.toml"), (existing) => {
+                    if (existing?.includes(block))
+                        return existing;
+                    if (existing?.includes(START) || existing?.includes(END))
+                        throw new Error("Codex Cohub hook block differs; preserve it and review manually / Codex Cohub Hook 配置不同，请保留并手动核对");
+                    if (existing && /^\s*hooks\s*=/m.test(existing))
+                        throw new Error("Inline Codex hooks require manual merging / 内联 Codex Hooks 需要手动合并");
+                    return `${existing ?? ""}${existing?.endsWith("\n") ? "\n" : "\n\n"}${block}`;
+                });
+            }
+        }
+    await withRuntimeSpaceBindingsLock(async () => {
+        const previous = await readNativeSyncConfig(runtimeRoot, input.identity);
+        if (previous && previous.root !== input.root)
+            throw new Error("Space native sync belongs to another directory / 此 Space 原生同步属于其他目录");
+        const harnesses = new Set(previous?.harnesses ?? []);
+        for (const harness of input.harnesses) {
+            if (input.disabled)
+                harnesses.delete(harness);
+            else
+                harnesses.add(harness);
+        }
+        const config = { version: 1, identity: input.identity, spaceId: input.spaceId, root: input.root, harnesses: [...harnesses] };
+        await atomicRuntimeJson(configPath, config);
+    }, { path: configPath });
+    return { configPath, harnesses: input.harnesses, enabled: !input.disabled };
+}

package/dist/runtime/native-ipc.d.ts

@@ -0,0 +1,26 @@
+import type { NativeSyncStore } from "./native-sync-store.js";
+type NativeIpcRequest = {
+    type: "native.capture";
+    harness: "pi" | "codex";
+    cwd: string;
+    path: string;
+    nativeSessionId: string;
+    settled?: boolean;
+    leafId?: string | null;
+};
+type NativeIpcResponse = {
+    ok: true;
+    pendingTurns: number;
+} | {
+    ok: false;
+    message: string;
+};
+export declare function nativeDaemonSocketFor(cwd: string): Promise<string | null>;
+export declare function requestNativeDaemon(input: Omit<NativeIpcRequest, "type">): Promise<NativeIpcResponse>;
+export declare function serveNativeDaemon(input: {
+    runtimeRoot: string;
+    handle: (request: NativeIpcRequest) => Promise<{
+        store: NativeSyncStore | null;
+    }>;
+}): Promise<() => Promise<void>>;
+export {};

package/dist/runtime/native-ipc.js

@@ -0,0 +1,101 @@
+import { createConnection, createServer } from "node:net";
+import { mkdir, rm } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { nativeRuntimeRoot } from "./native-sync.js";
+import { currentIdentityKey } from "../space.js";
+import { canonicalRuntimeRoot, getRuntimeSpaceBinding } from "./space-binding.js";
+const MAX_LINE_BYTES = 4 * 1024 * 1024;
+const socketPath = (runtimeRoot) => join(runtimeRoot, "native", "daemon.sock");
+const parse = (raw) => {
+    const value = JSON.parse(raw);
+    if (value?.type !== "native.capture" || !["pi", "codex"].includes(value.harness)
+        || typeof value.cwd !== "string" || typeof value.path !== "string" || typeof value.nativeSessionId !== "string") {
+        throw new Error("Invalid native daemon request / 原生 Daemon 请求无效");
+    }
+    return value;
+};
+export async function nativeDaemonSocketFor(cwd) {
+    const identity = currentIdentityKey();
+    if (!identity)
+        return null;
+    const root = await canonicalRuntimeRoot(cwd);
+    const binding = await getRuntimeSpaceBinding(root, identity);
+    return binding ? socketPath(nativeRuntimeRoot(binding.spaceId)) : null;
+}
+export async function requestNativeDaemon(input) {
+    const path = await nativeDaemonSocketFor(input.cwd);
+    if (!path)
+        return { ok: false, message: "Native Runtime is not bound / 原生 Runtime 未绑定" };
+    return new Promise((resolve, reject) => {
+        const socket = createConnection(path);
+        let buffer = "";
+        const timer = setTimeout(() => { socket.destroy(); reject(new Error("Native Runtime daemon timed out / 原生 Runtime Daemon 超时")); }, 15_000);
+        const finish = (error, result) => {
+            clearTimeout(timer);
+            socket.destroy();
+            if (error)
+                reject(error);
+            else
+                resolve(result ?? { ok: false, message: "Empty daemon response / Daemon 返回为空" });
+        };
+        socket.once("error", (error) => finish(error));
+        socket.on("data", (chunk) => {
+            buffer += chunk.toString();
+            if (Buffer.byteLength(buffer) > MAX_LINE_BYTES) {
+                finish(new Error("Native daemon response too large"));
+                return;
+            }
+            const newline = buffer.indexOf("\n");
+            if (newline < 0)
+                return;
+            try {
+                finish(undefined, JSON.parse(buffer.slice(0, newline)));
+            }
+            catch (error) {
+                finish(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+        socket.once("connect", () => socket.write(`${JSON.stringify({ type: "native.capture", ...input })}\n`));
+    });
+}
+export async function serveNativeDaemon(input) {
+    const path = socketPath(input.runtimeRoot);
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await rm(path, { force: true });
+    const server = createServer((socket) => {
+        let buffer = "";
+        let closed = false;
+        const respond = (value) => {
+            if (closed)
+                return;
+            closed = true;
+            socket.end(`${JSON.stringify(value)}\n`);
+        };
+        socket.setTimeout(20_000, () => socket.destroy());
+        socket.once("error", () => { closed = true; });
+        socket.on("data", (chunk) => {
+            buffer += chunk.toString();
+            if (Buffer.byteLength(buffer) > MAX_LINE_BYTES) {
+                socket.destroy();
+                return;
+            }
+            const newline = buffer.indexOf("\n");
+            if (newline < 0)
+                return;
+            socket.removeAllListeners("data");
+            void (async () => {
+                const request = parse(buffer.slice(0, newline));
+                const result = await input.handle(request);
+                respond({ ok: true, pendingTurns: result.store ? (await result.store.status()).pendingTurns : 0 });
+            })().catch((error) => respond({ ok: false, message: error instanceof Error ? error.message : String(error) }));
+        });
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(path, () => { server.removeListener("error", reject); resolve(); });
+    });
+    return async () => {
+        await new Promise((resolve) => server.close(() => resolve()));
+        await rm(path, { force: true });
+    };
+}

package/dist/runtime/native-pi-extension.d.ts

@@ -0,0 +1,20 @@
+type PiContext = {
+    cwd: string;
+    sessionManager: {
+        getSessionFile(): string | undefined;
+        getSessionId(): string;
+        getLeafId(): string | null;
+    };
+    abort(): void;
+    isIdle(): boolean;
+    ui: {
+        notify(message: string, level: "info" | "warning" | "error"): void;
+        setStatus(key: string, value: string | undefined): void;
+    };
+};
+type PiExtension = {
+    on(event: string, handler: (event: unknown, context: PiContext) => Promise<void> | void): void;
+};
+/** Thin native adapter. The Runtime Daemon owns Cohub auth, WS, retries and archives. */
+export default function cohubNativeExtension(pi: PiExtension): void;
+export {};

package/dist/runtime/native-pi-extension.js

@@ -0,0 +1,47 @@
+import { requestNativeDaemon } from "./native-ipc.js";
+/** Thin native adapter. The Runtime Daemon owns Cohub auth, WS, retries and archives. */
+export default function cohubNativeExtension(pi) {
+    if (process.env.COHUB_TURN_ID || process.env.COHUB_EXECUTION_TOKEN)
+        return;
+    let context = null;
+    let captures = Promise.resolve();
+    let lastError = "";
+    let timer;
+    const report = (error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message !== lastError)
+            context?.ui.notify(`Cohub sync pending / Cohub 待同步: ${message}`, "warning");
+        lastError = message;
+    };
+    const capture = (ctx, settled = false) => {
+        context = ctx;
+        const path = ctx.sessionManager.getSessionFile();
+        if (!path)
+            return Promise.resolve();
+        captures = captures.then(async () => {
+            const result = await requestNativeDaemon({ harness: "pi", cwd: ctx.cwd, path, nativeSessionId: ctx.sessionManager.getSessionId(), leafId: ctx.sessionManager.getLeafId(), settled });
+            if (!result.ok)
+                throw new Error(result.message);
+            ctx.ui.setStatus("cohub", "Cohub");
+            lastError = "";
+        }).catch(report);
+        return captures;
+    };
+    pi.on("session_start", async (_event, ctx) => {
+        await capture(ctx, ctx.isIdle());
+        if (timer)
+            clearInterval(timer);
+        timer = setInterval(() => { void capture(ctx, ctx.isIdle()); }, 5000);
+        timer.unref();
+    });
+    pi.on("message_end", (_event, ctx) => capture(ctx));
+    pi.on("agent_settled", (_event, ctx) => capture(ctx, true));
+    pi.on("session_shutdown", async (_event, ctx) => {
+        if (timer)
+            clearInterval(timer);
+        timer = undefined;
+        await captures;
+        ctx.ui.setStatus("cohub", undefined);
+        context = null;
+    });
+}

package/dist/runtime/native-sync-store.d.ts

@@ -0,0 +1,97 @@
+import type { NativeTurnBinding, NativeTurnComplete, NativeTurnStart, NativeTurnProgress } from "@neta-art/cohub";
+import { RuntimeArchiveStore, type ArchiveTransport } from "./archive-store.js";
+import type { NativeTranscript } from "./native-transcript.js";
+export declare const nativeIdentityHash: (identity: string) => string;
+export declare function nativeStableId(value: string): string;
+type NativeBinding = {
+    version: 1;
+    identity: string;
+    spaceId: string;
+    harness: "pi" | "codex";
+    nativeSessionId: string;
+    instanceKey?: string;
+    path: string;
+    originSessionId: string;
+    sessionId: string | null;
+    throughTurnId: string | null;
+    throughBytes: number;
+    anchors: Array<{
+        turnId: string;
+        sizeBytes: number;
+        sha256: string;
+    }>;
+};
+export type NativeTurnReceipt = {
+    version: 1;
+    turnId: string;
+    key: string;
+    parentKey: string | null;
+    parentCloudTurnId: string | null;
+    userContent: NativeTurnStart["userContent"];
+    startedAt: string;
+    endBytes: number;
+    contentEndBytes?: number;
+    result: NativeTurnComplete | null;
+    progress?: NativeTurnProgress;
+};
+export type NativeSyncTransport = ArchiveTransport & {
+    startNativeTurn?(input: NativeTurnStart, options?: {
+        signal?: AbortSignal;
+    }): Promise<NativeTurnBinding>;
+    completeNativeTurn?(sessionId: string, turnId: string, input: NativeTurnComplete, options?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        completed: true;
+        artifactsPending?: boolean;
+    }>;
+    heartbeatNativeTurn?(sessionId: string, turnId: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        abortRequested: boolean;
+        status: string;
+    }>;
+    updateNativeTurn?(sessionId: string, turnId: string, input: NativeTurnProgress, options?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        accepted: boolean;
+    }>;
+};
+export type NativeSyncOptions = {
+    runtimeRoot: string;
+    spaceId: string;
+    identity: string;
+    harness: "pi" | "codex";
+    nativeSessionId: string;
+    instanceKey?: string;
+    transport?: NativeSyncTransport;
+};
+/** Turn receipts are append-only. Capture never waits for the network; network ACKs live in separate files. */
+export declare class NativeSyncStore {
+    readonly options: NativeSyncOptions;
+    readonly root: string;
+    readonly archives: RuntimeArchiveStore;
+    private archiveFailure;
+    constructor(options: NativeSyncOptions);
+    private bindingPath;
+    private turnId;
+    private receiptPath;
+    private acknowledgementPath;
+    private pendingPath;
+    private requestPath;
+    private cloudBindingPath;
+    binding(): Promise<NativeBinding>;
+    private initialize;
+    capture(path: string, transcript: NativeTranscript): Promise<void>;
+    receipts(pendingOnly?: boolean): Promise<NativeTurnReceipt[]>;
+    status(): Promise<{
+        harness: "codex" | "pi";
+        nativeSessionId: string;
+        sessionId: string | null;
+        pendingTurns: number;
+        pendingArchives: number;
+    }>;
+    flush(signal: AbortSignal, onAbort?: () => void): Promise<void>;
+    private cloudArchive;
+}
+export declare function listNativeSyncStores(runtimeRoot: string, spaceId: string, identity: string, transport?: NativeSyncTransport): Promise<NativeSyncStore[]>;
+export {};