@neta-art/cohub-cli 7.1.2 → 8.0.1

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");
+        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")); }, 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")));
+        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"));
+                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");
+        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/json-rpc.d.ts

@@ -17,6 +17,8 @@ export declare function harnessEnvironment(): NodeJS.ProcessEnv;
 export declare class JsonRpcProcess {
     private mode;
     private child;
+    /** Process-group id of the harness process, for deferred cleanup confirmation. */
+    get processGroupId(): number | null;
     private pending;
     private listeners;
     private failureListeners;

package/dist/runtime/json-rpc.js

@@ -50,6 +50,8 @@ export function harnessEnvironment() {
 export class JsonRpcProcess {
     mode;
     child;
+    /** Process-group id of the harness process, for deferred cleanup confirmation. */
+    get processGroupId() { return this.child.pid ?? null; }
     pending = new Map();
     listeners = new Set();
     failureListeners = new Set();

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>;

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");
+    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");
+    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"));
+        };
+        const timeout = setTimeout(() => finish(last ? undefined : new Error("Runtime startup timed out")), 30_000);
+        child.on("error", (error) => finish(error));
+        child.on("exit", (code) => finish(new Error(`Runtime exited (${code})`)));
+        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");
+    if (options.name && requested)
+        throw new Error("--name only applies to a new 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");
+            }
+            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");
+    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");
+        const rl = createInterface({ input: process.stdin, output: process.stderr });
+        try {
+            if (!requested && binding) {
+                process.stderr.write(`\nLinked Space\n  ${runtimeWebUrl(binding.spaceId)}\n`);
+                const answer = (await rl.question("Reuse this Space? [Y/n, q to cancel] ")).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] ")).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 [${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] ");
+            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");
+    }
+    // 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");
+        },
+    });
+    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");
+        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");
+    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");
+    }
+    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: ${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+");
+        }
+        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");
+    }
+}
+/** 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\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");
+                    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");
+                    if (existing && /^\s*hooks\s*=/m.test(existing))
+                        throw new Error("Inline Codex hooks require manual merging");
+                    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");
+        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 {};