@neta-art/cohub-cli 7.0.1 → 7.1.1

package/README.md

@@ -72,7 +72,8 @@ cohub -s <spaceId> spaces invites revoke <code> --yes
 cohub -s <spaceId> run -- git status
 ```
 
-Many space-scoped commands need a target Space:
+Many space-scoped commands need a target Space. Without an explicit target, commands
+also use the Space remembered for the current directory before falling back to Home:
 
 ```bash
 cohub -s <spaceId> spaces prompt "message" --json
@@ -88,14 +89,25 @@ cohub runtime up ./project --harness pi --harness codex
 cohub runtime up ./project --space <spaceId> --harness codex
 cohub -s <spaceId> spaces prompt "Continue" --harness codex
 cohub runtime status --space <spaceId>
+cohub runtime logs --space <spaceId> --follow
 ```
 
+Runtime diagnostics stay as redacted JSONL under the local Runtime state directory and
+are never uploaded automatically. Use `runtime logs --json` to export a failure report;
+events carry the local `runtimeId` plus server `requestId` / `traceparent` when a turn has
+reached the Agent trace.
+
 The Runtime uses WebSockets, native Pi RPC / Codex app-server, and existing cloud
 streaming. Local executables and credentials are required. `sandbox up` has been
 removed. Reconnection and result reconciliation are automatic; no recovery command is needed.
 When a result genuinely cannot be determined, the affected Chat offers an explicit stop
 confirmation. See [Runtime details](../../docs/local-runtime.md).
 
+When `--space` is omitted, Runtime remembers a Space for the canonical local directory,
+account, and environment in `~/.config/cohub/runtime-spaces.json`. The first start creates
+and records a local Space; later starts reuse it. An explicit `--space` or `COHUB_SPACE_ID`
+overrides and updates the directory binding.
+
 ## Chats and prompts
 
 Use `spaces prompt` for immediate sends, delayed sends, one-time schedules, recurring schedules, new Chats, and existing Chats.

package/dist/commands/desktop.d.ts

@@ -1,5 +1,14 @@
 import { resolveOpenSurface } from "@neta-art/cohub";
 import type { Command } from "commander";
 export { resolveOpenSurface };
+/**
+ * Optional disambiguation for file:// vs app://. Unlike ordinary
+ * Space-scoped commands, an unbound directory must not fall back to Home:
+ * the plain target should remain eligible for App resolution.
+ */
+export declare function resolveOptionalSpaceId(command: Command, options?: {
+    cwd?: string;
+    bindingsPath?: string;
+}): Promise<string | undefined>;
 export declare function registerDesktop(program: Command): void;
 export declare function registerLegacyUi(program: Command): void;

package/dist/commands/desktop.js

@@ -2,13 +2,18 @@ import { readFileSync } from "node:fs";
 import { HttpError, parseAppRef, resolveOpenSurface, DESKTOP_COMMAND_DEFAULT_TIMEOUT_MS, DESKTOP_COMMAND_MAX_TIMEOUT_MS, } from "@neta-art/cohub";
 import { createClient } from "../client.js";
 import { error, handleHttp, json as outJson, jsonRequested, ok } from "../output.js";
+import { resolveBoundSpace } from "../space.js";
 import { getAppByRef } from "../app-ref.js";
 export { resolveOpenSurface };
 const FILE_SCHEME = "file://";
 const APP_SCHEME = "app://";
 const LEGACY_WORK_SCHEME = "work://";
-/** Optional disambiguation for file:// vs app:// — do not fall back to Home. */
-function optionalSpaceId(command) {
+/**
+ * Optional disambiguation for file:// vs app://. Unlike ordinary
+ * Space-scoped commands, an unbound directory must not fall back to Home:
+ * the plain target should remain eligible for App resolution.
+ */
+export async function resolveOptionalSpaceId(command, options = {}) {
     let current = command;
     while (current) {
         const opts = current.opts();
@@ -16,7 +21,10 @@ function optionalSpaceId(command) {
             return opts.space.trim();
         current = current.parent ?? null;
     }
-    return process.env.COHUB_SPACE_ID?.trim() || undefined;
+    const fromEnvironment = process.env.COHUB_SPACE_ID?.trim();
+    if (fromEnvironment)
+        return fromEnvironment;
+    return (await resolveBoundSpace(options)) ?? undefined;
 }
 function parseFilePath(value) {
     const path = value.slice(FILE_SCHEME.length).trim();
@@ -86,7 +94,7 @@ async function resolveOpenTarget(client, command, value) {
         return { kind: "file", path: parseFilePath(value) };
     if (hasAppScheme(value))
         return resolveAppTarget(client, value);
-    const spaceId = optionalSpaceId(command);
+    const spaceId = await resolveOptionalSpaceId(command);
     if (spaceId) {
         try {
             await client.space(spaceId).files.read(value);
@@ -190,7 +198,7 @@ const OPEN_NOTES = `
 Notes:
   - Use file:// and app:// to make the target explicit; the legacy work://
     scheme is still accepted.
-  - A plain target checks the current Space for a file before resolving an app.
+  - A plain target checks the explicit Space or current directory Runtime binding for a file before resolving an app; it does not fall back to Home.
   - Opening a window is idempotent; repeating it re-activates the same tab.
   - --as picks the surface: window (a preview tab) or overlay (a transparent
     layer above the workspace). Without it, an App published with

package/dist/commands/run.d.ts

@@ -1,2 +1,13 @@
+type RunCliOptions = {
+    spaceId: string;
+    json: boolean;
+    async: boolean;
+    command: string;
+};
+export declare function parseRunCliOptions(argv: string[], spaceOptions?: {
+    cwd?: string;
+    bindingsPath?: string;
+}): Promise<RunCliOptions>;
 export declare function printRunHelp(): void;
 export declare function maybeHandleRunCommand(argv: string[]): Promise<boolean>;
+export {};

package/dist/commands/run.js

@@ -1,6 +1,6 @@
 import { createClient } from "../client.js";
 import { error, handleHttp, json as outJson, spinner } from "../output.js";
-import { missingSpaceError, resolveDefaultSpace } from "../space.js";
+import { resolveSpaceTarget } from "../space.js";
 const DEFAULT_WAIT_TIMEOUT_MS = (6 * 60 * 60 + 60) * 1000;
 const DEFAULT_POLL_INTERVAL_MS = 1500;
 function shellQuote(value) {
@@ -44,7 +44,7 @@ function parseSpaceId(tokens) {
     }
     return undefined;
 }
-async function parseRunCliOptions(argv) {
+export async function parseRunCliOptions(argv, spaceOptions = {}) {
     const runIndex = topLevelRunIndex(argv);
     if (runIndex < 0)
         return error("Invalid invocation", "Use `cohub run [options] <command>`");
@@ -104,7 +104,7 @@ async function parseRunCliOptions(argv) {
     if (!command) {
         return error("No command", "Pass --command <shell command>, or use `--` followed by the command.");
     }
-    const spaceId = explicitSpaceId || (await resolveDefaultSpace().catch(handleHttp)) || missingSpaceError();
+    const spaceId = await resolveSpaceTarget(explicitSpaceId, spaceOptions);
     return { spaceId, json, async, command };
 }
 export function printRunHelp() {
@@ -125,7 +125,7 @@ Examples:
   cohub -s <spaceId> run -- git status -sb
 
 Notes:
-  - Without -s or COHUB_SPACE_ID, the command targets your Home space.
+  - Without -s or COHUB_SPACE_ID, the command uses the current directory Runtime binding, then Home.
   - Use --command for commands that contain leading flags, or use -- before the shell command.
   - The command runs in /workspace.
 `);

package/dist/commands/runtime.js

@@ -1,4 +1,5 @@
 import { spawn } 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";
@@ -6,12 +7,77 @@ import { isLocalHarness, resolveCohubEnvironment, resolveWebsocketUrl } from "@n
 import { requireAccessToken } from "../auth.js";
 import { createClient } from "../client.js";
 import { error, json as outJson, jsonRequested } from "../output.js";
-import { resolveSpace } from "../space.js";
+import { currentIdentityKey, explicitSpace, resolveSpace } from "../space.js";
+import { canonicalRuntimeRoot, resolveRuntimeSpace } from "../runtime/space-binding.js";
 import { discoverHarnesses } from "../runtime/harness.js";
 import { serveRuntime } from "../runtime/connection.js";
 import { RuntimeSessionStore } from "../runtime/session-store.js";
 import { ensureSandboxdBinary } from "./sandboxd-binary.js";
+import { readRuntimeDiagnosticEvents, RuntimeDiagnosticReader, RuntimeDiagnostics, runtimeDiagnosticsDirectory, serializeDiagnosticError, } from "../runtime/diagnostics.js";
 export const resolveLocalSpaceName = (root, name) => name?.trim() || basename(root) || "local-space";
+function sandboxOutputLevel(value, stream) {
+    const level = typeof value === "string" ? value.toLowerCase() : "";
+    if (level.includes("error"))
+        return "error";
+    if (level.includes("warn"))
+        return "warn";
+    return stream === "stderr" ? "error" : "debug";
+}
+function captureSandboxOutput(stream, streamName, diagnostics) {
+    if (!stream)
+        return;
+    let pending = "";
+    const consume = (chunk) => {
+        pending += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+        let newline = pending.indexOf("\n");
+        while (newline >= 0) {
+            const line = pending.slice(0, newline).trim();
+            pending = pending.slice(newline + 1);
+            if (line)
+                recordSandboxOutput(line, streamName, diagnostics);
+            newline = pending.indexOf("\n");
+        }
+    };
+    stream.on("data", consume);
+    stream.on("end", () => {
+        if (pending.trim())
+            recordSandboxOutput(pending.trim(), streamName, diagnostics);
+    });
+}
+function recordSandboxOutput(line, streamName, diagnostics) {
+    let parsed = null;
+    try {
+        const value = JSON.parse(line);
+        if (value && typeof value === "object" && !Array.isArray(value))
+            parsed = value;
+    }
+    catch {
+        // Older or third-party binaries may still emit text logs.
+    }
+    const level = sandboxOutputLevel(parsed?.level, streamName);
+    const message = typeof parsed?.msg === "string" ? parsed.msg : line;
+    const data = parsed
+        ? Object.fromEntries(Object.entries(parsed).filter(([key]) => !["msg", "level", "time"].includes(key)))
+        : { message: line };
+    diagnostics.log(level, "sandboxd.log", {
+        stream: streamName,
+        message,
+        ...(level === "error" ? { error: { message } } : {}),
+        ...data,
+    }, { component: "sandboxd" });
+}
+function printDiagnostic(event) {
+    const scope = [event.component, event.event].filter(Boolean).join(".");
+    const context = [
+        event.connectionId && `connection=${event.connectionId}`,
+        event.sessionId && `session=${event.sessionId}`,
+        event.turnId && `turn=${event.turnId}`,
+        event.traceContext?.requestId && `request=${event.traceContext.requestId}`,
+        event.traceContext?.traceId && `trace=${event.traceContext.traceId}`,
+    ].filter(Boolean).join(" ");
+    const data = event.data && Object.keys(event.data).length > 0 ? ` ${JSON.stringify(event.data)}` : "";
+    process.stdout.write(`${event.timestamp} ${event.level.toUpperCase().padEnd(5)} ${scope}${context ? ` ${context}` : ""}${data}${event.error ? ` ${JSON.stringify(event.error)}` : ""}\n`);
+}
 export function parseRuntimeHarnesses(values) {
     const names = values.flatMap((value) => value.split(",")).map((name) => name.trim()).filter(Boolean);
     if (names.some((name) => !isLocalHarness(name)))
@@ -35,9 +101,10 @@ export function registerRuntime(program) {
         process.once("SIGINT", stop);
         process.once("SIGTERM", stop);
         try {
-            const root = resolve(dir ?? process.cwd());
-            if (!(await stat(root)).isDirectory())
+            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 harnesses = parseRuntimeHarnesses(options.harness);
             if (!options.yes) {
                 if (!process.stdin.isTTY)
@@ -54,47 +121,110 @@ export function registerRuntime(program) {
             }
             const capabilities = await discoverHarnesses(harnesses, options, root);
             const client = createClient();
-            const requested = options.space?.trim() || program.opts().space?.trim();
-            const spaceId = requested || (await client.spaces.create({ name: resolveLocalSpaceName(root, options.name), config: { sandbox: { provider: "local" } } })).space.id;
-            const sandbox = (await client.space(spaceId).sandbox.get()).sandbox;
-            if (sandbox?.provider !== "local")
-                throw new Error("Space does not have a local Runtime");
-            const binary = await ensureSandboxdBinary();
-            const wsBase = resolveWebsocketUrl({ url: process.env.COHUB_WS_URL });
-            const url = new URL(wsBase);
-            url.pathname = "/runtime/relay";
-            const relay = new URL(wsBase);
-            relay.pathname = "/sandbox/relay";
-            let bridge = null;
-            let bridgeClosed = Promise.resolve();
-            const token = await requireAccessToken();
+            const requested = options.space?.trim() || explicitSpace(program);
+            const validateLocalRuntime = async (spaceId) => {
+                const sandbox = (await client.space(spaceId).sandbox.get()).sandbox;
+                if (sandbox?.provider !== "local")
+                    throw new Error("Space does not have a local Runtime");
+            };
+            const { spaceId } = await resolveRuntimeSpace({
+                root,
+                identityKey: currentIdentityKey(),
+                explicitSpaceId: requested,
+                createSpace: async () => (await client.spaces.create({
+                    name: resolveLocalSpaceName(root, options.name),
+                    config: { sandbox: { provider: "local" } },
+                })).space.id,
+                validateSpace: validateLocalRuntime,
+            });
+            const spaceClient = client.space(spaceId);
+            const store = new RuntimeSessionStore(spaceId, { projectionSource: spaceClient });
+            const runtimeId = randomUUID();
+            const diagnostics = new RuntimeDiagnostics({ root: store.root, spaceId, runtimeId });
+            store.setDiagnostics(diagnostics);
+            diagnostics.log("info", "runtime.cli_started", {
+                platform: process.platform,
+                arch: process.arch,
+                node: process.versions.node,
+                harnesses,
+                proxyConfigured: ["HTTPS_PROXY", "HTTP_PROXY", "ALL_PROXY"].some((key) => Boolean(process.env[key]?.trim())),
+            });
             try {
-                await serveRuntime({
-                    spaceId, cwd: root, url: url.toString(), capabilities, harnesses: options,
-                    token: requireAccessToken, signal: controller.signal, store: new RuntimeSessionStore(spaceId, undefined, client.space(spaceId)),
-                    onReady: () => {
-                        if (!bridge) {
-                            bridge = spawn(binary, ["--local", "--space", spaceId, "--root", root, "--relay", process.env.COHUB_RELAY_URL?.trim() || relay.toString()], { stdio: ["ignore", "inherit", "inherit"], env: { ...process.env, COHUB_RELAY_TOKEN: token } });
-                            bridgeClosed = new Promise((resolveClosed) => bridge?.once("close", () => resolveClosed()));
-                            bridge.on("error", (cause) => { console.error(cause); controller.abort(); });
-                            bridge.once("exit", () => controller.abort());
-                        }
-                        const webUrl = `${resolveCohubEnvironment() === "prod" ? "https://cohub.live" : "https://dev.cohub.live"}/spaces/${spaceId}`;
-                        if (jsonRequested(options))
-                            outJson({ spaceId, root, harnesses, url: webUrl });
-                        else
-                            console.error(`Runtime connected: ${webUrl}`);
-                    },
+                const binary = await ensureSandboxdBinary({
+                    onStatus: (message) => diagnostics.log("info", "sandboxd.download", { message }, { component: "sandboxd" }),
                 });
+                const wsBase = resolveWebsocketUrl({ url: process.env.COHUB_WS_URL });
+                const url = new URL(wsBase);
+                url.pathname = "/runtime/relay";
+                const relay = new URL(wsBase);
+                relay.pathname = "/sandbox/relay";
+                let bridge = null;
+                let bridgeClosed = Promise.resolve();
+                let announced = false;
+                const token = await requireAccessToken();
+                try {
+                    await serveRuntime({
+                        spaceId,
+                        cwd: root,
+                        url: url.toString(),
+                        capabilities,
+                        harnesses: options,
+                        runtimeId,
+                        diagnostics,
+                        token: requireAccessToken,
+                        signal: controller.signal,
+                        store,
+                        onReady: () => {
+                            if (!bridge) {
+                                bridge = spawn(binary, ["--local", "--space", spaceId, "--root", root, "--relay", process.env.COHUB_RELAY_URL?.trim() || relay.toString()], {
+                                    stdio: ["ignore", "pipe", "pipe"],
+                                    env: {
+                                        ...process.env,
+                                        COHUB_RELAY_TOKEN: token,
+                                        COHUB_RUNTIME_ID: runtimeId,
+                                        COHUB_LOG_FORMAT: "json",
+                                    },
+                                });
+                                captureSandboxOutput(bridge.stdout, "stdout", diagnostics);
+                                captureSandboxOutput(bridge.stderr, "stderr", diagnostics);
+                                bridgeClosed = new Promise((resolveClosed) => bridge?.once("close", () => resolveClosed()));
+                                bridge.on("error", (cause) => {
+                                    diagnostics.log("error", "sandboxd.process_error", { error: serializeDiagnosticError(cause) }, { component: "sandboxd" });
+                                    console.error(cause);
+                                    controller.abort();
+                                });
+                                bridge.once("exit", (code, signal) => {
+                                    diagnostics.log(code === 0 ? "info" : "error", "sandboxd.process_exit", { code, signal }, { component: "sandboxd" });
+                                    controller.abort();
+                                });
+                            }
+                            if (announced)
+                                return;
+                            announced = true;
+                            const webUrl = `${resolveCohubEnvironment() === "prod" ? "https://cohub.live" : "https://dev.cohub.live"}/spaces/${spaceId}`;
+                            if (jsonRequested(options))
+                                outJson({ spaceId, root, harnesses, runtimeId, diagnosticsPath: diagnostics.logPath, url: webUrl });
+                            else
+                                console.error(`Runtime connected: ${webUrl} (runtimeId=${runtimeId}, logs=${diagnostics.logPath})`);
+                        },
+                    });
+                }
+                finally {
+                    if (bridge) {
+                        const child = bridge;
+                        child.kill("SIGTERM");
+                        const timeout = setTimeout(() => child.kill("SIGKILL"), 3000);
+                        await bridgeClosed;
+                        clearTimeout(timeout);
+                    }
+                }
+            }
+            catch (cause) {
+                diagnostics.log("error", "runtime.start_failed", { error: serializeDiagnosticError(cause) });
+                throw cause;
             }
             finally {
-                if (bridge) {
-                    const child = bridge;
-                    child.kill("SIGTERM");
-                    const timeout = setTimeout(() => child.kill("SIGKILL"), 3000);
-                    await bridgeClosed;
-                    clearTimeout(timeout);
-                }
+                await diagnostics.close().catch((error) => console.error("Runtime diagnostics close failed:", error));
             }
         }
         catch (cause) {
@@ -108,10 +238,91 @@ export function registerRuntime(program) {
     });
     runtime.command("status").description("Runtime status").option("-s, --space <id>", "Target Space").action(async (options) => {
         const spaceId = options.space?.trim() || await resolveSpace(program);
-        const { archives } = new RuntimeSessionStore(spaceId);
+        const client = createClient();
+        const spaceClient = client.space(spaceId);
+        const store = new RuntimeSessionStore(spaceId, { projectionSource: spaceClient });
         const [status, pendingLocalArchives, failedLocalArchives] = await Promise.all([
-            createClient().space(spaceId).getRuntime(), archives.pendingCount(), archives.failedCaptureCount(),
+            spaceClient.getRuntime(),
+            store.archives.pendingCount(),
+            store.archives.failedCaptureCount(),
         ]);
-        outJson({ ...status, pendingLocalArchives, failedLocalArchives });
+        outJson({
+            ...status,
+            diagnosticsPath: runtimeDiagnosticsDirectory(store.root),
+            pendingLocalArchives,
+            failedLocalArchives,
+        });
+    });
+    runtime.command("logs")
+        .description("Read local Runtime diagnostics")
+        .option("-s, --space <id>", "Target Space")
+        .option("-l, --limit <count>", "Number of events", "100")
+        .option("--follow", "Keep watching for new events")
+        .option("--json", "Print raw diagnostic events")
+        .action(async (options) => {
+        const spaceId = options.space?.trim() || await resolveSpace(program);
+        const store = new RuntimeSessionStore(spaceId, { projectionSource: createClient().space(spaceId) });
+        const limit = Number(options.limit ?? "100");
+        if (!Number.isSafeInteger(limit) || limit < 1 || limit > 10_000)
+            return error("Invalid diagnostic limit", "Use an integer between 1 and 10000 / 使用 1 到 10000 之间的整数");
+        const asJson = jsonRequested(options);
+        const reader = options.follow ? new RuntimeDiagnosticReader(store.root) : null;
+        const render = async () => {
+            const fresh = options.follow
+                ? await reader?.read({ limit }) ?? []
+                : await readRuntimeDiagnosticEvents(store.root, { limit });
+            if (options.follow && fresh.length === 0)
+                return;
+            if (asJson && options.follow) {
+                for (const event of fresh)
+                    process.stdout.write(`${JSON.stringify(event)}\n`);
+            }
+            else if (asJson) {
+                outJson(fresh);
+            }
+            else if (fresh.length === 0) {
+                process.stdout.write("No Runtime diagnostics / 未找到 Runtime 诊断记录\n");
+            }
+            else {
+                for (const event of fresh)
+                    printDiagnostic(event);
+            }
+        };
+        try {
+            await render();
+            if (!options.follow)
+                return;
+            await new Promise((resolve) => {
+                let timer = null;
+                let stopped = false;
+                const stop = () => {
+                    stopped = true;
+                    if (timer)
+                        clearTimeout(timer);
+                    process.removeListener("SIGINT", stop);
+                    process.removeListener("SIGTERM", stop);
+                    resolve();
+                };
+                const poll = async () => {
+                    if (stopped)
+                        return;
+                    try {
+                        await render();
+                    }
+                    catch {
+                        stop();
+                        return;
+                    }
+                    if (!stopped)
+                        timer = setTimeout(() => void poll(), 2_000);
+                };
+                timer = setTimeout(() => void poll(), 2_000);
+                process.once("SIGINT", stop);
+                process.once("SIGTERM", stop);
+            });
+        }
+        catch (cause) {
+            error("Runtime logs failed", cause instanceof Error ? cause.message : String(cause));
+        }
     });
 }

package/dist/commands/sandboxd-binary.d.ts

@@ -2,6 +2,8 @@ export declare const SANDBOXD_VERSION = "v1.82.4";
 export declare class SandboxdDownloadError extends Error {
     name: string;
 }
+export declare function validSandboxdArchiveEntries(entries: string[], version?: string): boolean;
+export declare function validateSandboxdArchive(archivePath: string, version?: string): Promise<string[]>;
 export type EnsureSandboxdOptions = {
     version?: string;
     onStatus?: (message: string) => void;

package/dist/commands/sandboxd-binary.js

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
 import { createReadStream, createWriteStream } from "node:fs";
-import { chmod, copyFile, mkdir, mkdtemp, rename, rm, stat } from "node:fs/promises";
+import { chmod, copyFile, mkdir, mkdtemp, rename, rm, stat, lstat } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { pipeline } from "node:stream/promises";
@@ -40,9 +40,13 @@ const cacheDir = (version) => join(homedir(), ".cache", "cohub", "sandboxd", ver
 const cachedBinaryPath = (version) => join(cacheDir(version), BINARY_NAME);
 const archiveName = (version, target) => `${BINARY_NAME}_${version}_${target.goos}_${target.goarch}.tar.gz`;
 const isExecutableFile = async (path) => {
-    const info = await stat(path).catch(() => null);
+    const info = await lstat(path).catch(() => null);
     return Boolean(info?.isFile());
 };
+const isSafeArchiveFile = async (path) => {
+    const info = await lstat(path).catch(() => null);
+    return Boolean(info?.isFile() && info.nlink === 1);
+};
 const sha256File = async (path) => {
     const hash = createHash("sha256");
     await pipeline(createReadStream(path), hash);
@@ -87,11 +91,18 @@ const fetchText = (url, accept) => withTimeout(`Download of ${url}`, async (sign
         throw new SandboxdDownloadError(`Download failed (${response.status}) for ${url}`);
     return (await response.text()).trim();
 });
-// List the entries of a `.tar.gz` without extracting, so we can reject archives
-// that contain anything other than the expected single binary (path traversal,
-// symlinks, extra entries) before touching the filesystem.
-const listTarGz = (archivePath) => new Promise((res, rej) => {
-    const child = spawn("tar", ["-tzf", archivePath], { stdio: ["ignore", "pipe", "pipe"] });
+// v1.82.4 is already public as a binary-only archive. The native watcher
+// release adds the two notices; the old shape is accepted only for this pin.
+const CURRENT_BINARY_ONLY_VERSION = "v1.82.4";
+export function validSandboxdArchiveEntries(entries, version = SANDBOXD_VERSION) {
+    const binaryOnly = version === CURRENT_BINARY_ONLY_VERSION && entries.length === 1 && entries[0] === BINARY_NAME;
+    const expected = [BINARY_NAME, "LICENSE", "NOTICE"];
+    const withNotices = entries.length === expected.length && expected.every((entry) => entries.includes(entry));
+    return binaryOnly || withNotices;
+}
+// Reject unexpected paths before extracting the checksum-verified release.
+const listTarGz = (archivePath, verbose = false) => new Promise((res, rej) => {
+    const child = spawn("tar", [verbose ? "-tvzf" : "-tzf", archivePath], { stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
     child.stdout.on("data", (chunk) => {
@@ -105,7 +116,18 @@ const listTarGz = (archivePath) => new Promise((res, rej) => {
         ? res(stdout.split("\n").map((line) => line.trim()).filter(Boolean))
         : rej(new SandboxdDownloadError(`tar listing failed: ${stderr.trim() || `exit ${code}`}`)));
 });
-// Extract a single-file `.tar.gz` using the system tar (universally present on
+export async function validateSandboxdArchive(archivePath, version = SANDBOXD_VERSION) {
+    const entries = await listTarGz(archivePath);
+    if (!validSandboxdArchiveEntries(entries, version)) {
+        throw new SandboxdDownloadError(`Unexpected sandbox archive contents: ${entries.join(", ") || "(empty)"}`);
+    }
+    const details = await listTarGz(archivePath, true);
+    if (details.length !== entries.length || details.some((line) => !line.startsWith("-") || /(?: link to | -> | == )/.test(line))) {
+        throw new SandboxdDownloadError("Sandbox archive must contain only regular files");
+    }
+    return entries;
+}
+// Extract the verified `.tar.gz` using the system tar (universally present on
 // macOS and Linux), keeping the CLI free of native archive dependencies.
 const extractTarGz = (archivePath, cwd) => new Promise((res, rej) => {
     const child = spawn("tar", ["-xzf", archivePath, "-C", cwd], { stdio: ["ignore", "ignore", "pipe"] });
@@ -163,16 +185,15 @@ const downloadAndVerify = async (version, target) => {
         if (actual !== expected) {
             throw new SandboxdDownloadError(`Checksum mismatch for ${name} (expected ${expected}, got ${actual})`);
         }
-        // Verify the archive contains exactly the expected binary before extracting,
-        // guarding against path traversal / unexpected entries from a tampered CDN.
-        const entries = await listTarGz(archivePath);
-        if (entries.length !== 1 || entries[0] !== BINARY_NAME) {
-            throw new SandboxdDownloadError(`Unexpected archive contents for ${name}: ${entries.join(", ") || "(empty)"}`);
-        }
-        // Extract the single binary from the archive.
+        const entries = await validateSandboxdArchive(archivePath, version);
         await extractTarGz(archivePath, tempDir);
+        for (const entry of entries) {
+            if (!(await isSafeArchiveFile(join(tempDir, entry)))) {
+                throw new SandboxdDownloadError(`Unsafe sandbox archive entry: ${entry}`);
+            }
+        }
         const extractedBinary = join(tempDir, BINARY_NAME);
-        if (!(await isExecutableFile(extractedBinary))) {
+        if (!(await isSafeArchiveFile(extractedBinary))) {
             throw new SandboxdDownloadError(`Archive ${name} did not contain ${BINARY_NAME}`);
         }
         // Atomically move into the version cache (fall back to copy across devices).

package/dist/index.js

@@ -37,7 +37,7 @@ program
     .summary("Work with Cohub from your terminal")
     .description("Send prompts, manage Space files, and publish public output.")
     .version(VERSION, "-v, --version", "Show version")
-    .option("-s, --space <id>", "Target Space ID (defaults to your Home space)")
+    .option("-s, --space <id>", "Target Space ID")
     .option("--json", "Print machine-readable JSON when supported")
     .helpOption("-h, --help", "Show help")
     .addHelpText("after", `
@@ -54,6 +54,7 @@ Common commands:
   cohub completion "Summarize AGENTS.md" --system-prompt AGENTS.md --stream
   cohub run -- git status
   cohub runtime up ./my-project
+  cohub runtime logs --follow
   cohub search "release notes"
   cohub -s <space-id> boards inspect <board-id>
   cohub -s <space-id> spaces turns ls --author others
@@ -68,13 +69,14 @@ Common commands:
   cohub generate "A calm lake at sunrise" --model <model> --output lake.png
 
 Target space:
-  -s <space-id>, then COHUB_SPACE_ID, then your Home space
+  -s <space-id>, then COHUB_SPACE_ID, then the current directory Runtime binding, then Home
 
 Environment:
   COHUB_SPACE_ID         Target Space ID when -s is omitted
   COHUB_EXECUTION_TOKEN  Use this token instead of the stored Logto session
   ENV=dev                Use the development Cohub environment
   HTTPS_PROXY            Honored for API and uploads (also HTTP_PROXY, NO_PROXY)
+  Runtime logs            ~/.local/state/cohub/runtime/<space-id>/diagnostics
 `);
 registerAuth(program);
 registerBoards(program);

package/dist/runtime/archive-store.d.ts

@@ -23,7 +23,9 @@ export declare class RuntimeArchiveStore {
     private readonly transport?;
     private flushing;
     private readonly capturing;
+    private errorReporter;
     constructor(root: string, transport?: ArchiveTransport | undefined);
+    setErrorReporter(reporter: ((error: unknown, index?: HarnessArchiveIndex) => void) | null): void;
     pendingCount(): Promise<number>;
     failedCaptureCount(): Promise<number>;
     hasCapture(turnId: string): Promise<boolean>;