@neta-art/cohub-cli 10.2.0 → 10.4.1

package/dist/commands/rooms.js

@@ -136,6 +136,51 @@ An Agent waits for the room in a background command and wakes when it returns:
         printView(view);
         console.log(`\nWait for events: cohub rooms events ${view.room.id} --after ${view.sequence} --wait 10m`);
     }));
+    rooms
+        .command("connect <room>")
+        .description("Stream room events and members over realtime; disconnecting keeps your seat")
+        .option("--after <sequence>", "Replay retained events after this sequence")
+        .option("--input", "Accept NDJSON publish/send/presence commands on stdin")
+        .option("--json", "Output newline-delimited JSON")
+        .action(async (roomId, opts) => {
+        try {
+            const { connectToRoom } = await import("./rooms-connect.js");
+            await connectToRoom(roomId, { ...opts, json: jsonRequested(opts) });
+        }
+        catch (cause) {
+            handleHttp(cause);
+        }
+    });
+    rooms
+        .command("rtc <room>")
+        .description("Stream RTC media and data through the Go/Pion helper")
+        .option("--helper <path>", "Use a local cohub-rtc binary")
+        .option("--channel <name>", "Open a JSON/binary RTC data channel")
+        .option("--delivery <policy>", "Data channel delivery: reliable or latest", "reliable")
+        .option("--data-input <path>", "NDJSON channel input file or - for stdin")
+        .option("--audio <path>", "Audio input file or - for stdin")
+        .option("--audio-format <format>", "Audio input: pcm or opus (Ogg)", "pcm")
+        .option("--rate <hz>", "Audio sample rate", "48000")
+        .option("--channels <count>", "Audio channels", "1")
+        .option("--video <path>", "Video input file or - for stdin")
+        .option("--video-format <format>", "Video input: i420 or vp8 (IVF)", "i420")
+        .option("--size <widthxheight>", "Video frame dimensions")
+        .option("--fps <rate>", "Video frame rate", "30")
+        .option("--output <directory|->", "Receive framed media into unique .rtc files or binary stdout")
+        .option("--receive-format <format>", "Receive rtp packets or raw decoded frames", "rtp")
+        .option("--receive-size <widthxheight>", "Decoded I420 output dimensions", "640x360")
+        .option("--max-bytes <bytes>", "Stop after this many received bytes; 0 is unlimited", "1073741824")
+        .option("--participant <id>", "Only receive this participant's tracks")
+        .option("--json", "Output newline-delimited JSON")
+        .action(async (roomId, opts) => {
+        try {
+            const { runRoomRtc } = await import("./rooms-rtc.js");
+            await runRoomRtc(roomId, opts);
+        }
+        catch (cause) {
+            handleHttp(cause);
+        }
+    });
     rooms
         .command("get <room>")
         .description("Show the room, its members and your seat")

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

@@ -1,9 +1,9 @@
-export declare const SANDBOXD_VERSION = "v2.61.1";
+export declare const SANDBOXD_VERSION = "v2.68.0";
 export declare class SandboxdDownloadError extends Error {
     name: string;
 }
-export declare function validSandboxdArchiveEntries(entries: string[]): boolean;
-export declare function validateSandboxdArchive(archivePath: string): Promise<string[]>;
+export declare function validSandboxdArchiveEntries(entries: string[], goos: string): boolean;
+export declare function validateSandboxdArchive(archivePath: string, goos: string): Promise<string[]>;
 export type EnsureSandboxdOptions = {
     version?: string;
     onStatus?: (message: string) => void;

package/dist/commands/sandboxd-binary.js

@@ -7,8 +7,9 @@ import { dirname, join } from "node:path";
 import { pipeline } from "node:stream/promises";
 import { Readable } from "node:stream";
 // Pin only after all platform artifacts are published to the public CDN.
-export const SANDBOXD_VERSION = "v2.61.1";
+export const SANDBOXD_VERSION = "v2.68.0";
 const BINARY_NAME = "cohub-sandboxd";
+const binaryName = (goos) => goos === "windows" ? `${BINARY_NAME}.exe` : BINARY_NAME;
 // Public CDN prefix hosting the release archives (the repo is private, so the
 // GitHub Release assets are not publicly downloadable). Overridable for staging
 // or self-hosting.
@@ -16,7 +17,7 @@ const cdnBaseUrl = () => (process.env.COHUB_SANDBOXD_CDN_BASE_URL?.trim() || "ht
 const DOWNLOAD_TIMEOUT_MS = 120_000;
 const LOCK_STALE_MS = 5 * 60 * 1000;
 // Map Node's platform/arch to the Go GOOS/GOARCH used in release asset names.
-const GOOS_BY_PLATFORM = { darwin: "darwin", linux: "linux" };
+const GOOS_BY_PLATFORM = { darwin: "darwin", linux: "linux", win32: "windows" };
 const GOARCH_BY_ARCH = { x64: "amd64", arm64: "arm64" };
 export class SandboxdDownloadError extends Error {
     name = "SandboxdDownloadError";
@@ -30,7 +31,7 @@ const resolveTarget = () => {
     return { goos, goarch };
 };
 const cacheDir = (version) => join(homedir(), ".cache", "cohub", "sandboxd", version);
-const cachedBinaryPath = (version) => join(cacheDir(version), BINARY_NAME);
+const cachedBinaryPath = (version, target) => join(cacheDir(version), binaryName(target.goos));
 const archiveName = (version, target) => `${BINARY_NAME}_${version}_${target.goos}_${target.goarch}.tar.gz`;
 const isExecutableFile = async (path) => {
     const info = await lstat(path).catch(() => null);
@@ -85,14 +86,23 @@ const fetchText = (url, accept) => withTimeout(`Download of ${url}`, async (sign
     return (await response.text()).trim();
 });
 // Every published release ships the binary alongside its LICENSE and NOTICE.
-const EXPECTED_ARCHIVE_ENTRIES = [BINARY_NAME, "LICENSE", "NOTICE"];
-export function validSandboxdArchiveEntries(entries) {
-    return (entries.length === EXPECTED_ARCHIVE_ENTRIES.length &&
-        EXPECTED_ARCHIVE_ENTRIES.every((entry) => entries.includes(entry)));
+export function validSandboxdArchiveEntries(entries, goos) {
+    const expected = [binaryName(goos), "LICENSE", "NOTICE"];
+    return (entries.length === expected.length &&
+        expected.every((entry) => entries.includes(entry)));
 }
+// Git for Windows puts GNU tar on PATH, which treats `C:\...` as a remote host.
+// Use the system bsdtar (Windows 10+) instead.
+const tarCommand = () => {
+    if (process.platform !== "win32")
+        return "tar";
+    if (!process.env.SystemRoot)
+        throw new SandboxdDownloadError("SystemRoot is not set; cannot locate tar.exe");
+    return join(process.env.SystemRoot, "System32", "tar.exe");
+};
 // 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"] });
+    const child = spawn(tarCommand(), [verbose ? "-tvzf" : "-tzf", archivePath], { stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
     child.stdout.on("data", (chunk) => {
@@ -106,9 +116,9 @@ const listTarGz = (archivePath, verbose = false) => new Promise((res, rej) => {
         ? res(stdout.split("\n").map((line) => line.trim()).filter(Boolean))
         : rej(new SandboxdDownloadError(`tar listing failed: ${stderr.trim() || `exit ${code}`}`)));
 });
-export async function validateSandboxdArchive(archivePath) {
+export async function validateSandboxdArchive(archivePath, goos) {
     const entries = await listTarGz(archivePath);
-    if (!validSandboxdArchiveEntries(entries)) {
+    if (!validSandboxdArchiveEntries(entries, goos)) {
         throw new SandboxdDownloadError(`Unexpected sandbox archive contents: ${entries.join(", ") || "(empty)"}`);
     }
     const details = await listTarGz(archivePath, true);
@@ -120,7 +130,7 @@ export async function validateSandboxdArchive(archivePath) {
 // 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"] });
+    const child = spawn(tarCommand(), ["-xzf", archivePath, "-C", cwd], { stdio: ["ignore", "ignore", "pipe"] });
     let stderr = "";
     child.stderr.on("data", (chunk) => {
         stderr += chunk.toString();
@@ -175,19 +185,19 @@ const downloadAndVerify = async (version, target) => {
         if (actual !== expected) {
             throw new SandboxdDownloadError(`Checksum mismatch for ${name} (expected ${expected}, got ${actual})`);
         }
-        const entries = await validateSandboxdArchive(archivePath);
+        const entries = await validateSandboxdArchive(archivePath, target.goos);
         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);
+        const extractedBinary = join(tempDir, binaryName(target.goos));
         if (!(await isSafeArchiveFile(extractedBinary))) {
-            throw new SandboxdDownloadError(`Archive ${name} did not contain ${BINARY_NAME}`);
+            throw new SandboxdDownloadError(`Archive ${name} did not contain ${binaryName(target.goos)}`);
         }
         // Atomically move into the version cache (fall back to copy across devices).
-        const dest = cachedBinaryPath(version);
+        const dest = cachedBinaryPath(version, target);
         await mkdir(dirname(dest), { recursive: true });
         await rename(extractedBinary, dest).catch(async (err) => {
             if (err.code !== "EXDEV")
@@ -212,10 +222,10 @@ export const ensureSandboxdBinary = async (options = {}) => {
         return override;
     }
     const version = options.version?.trim() || SANDBOXD_VERSION;
-    const cached = cachedBinaryPath(version);
+    const target = resolveTarget();
+    const cached = cachedBinaryPath(version, target);
     if (await isExecutableFile(cached))
         return cached;
-    const target = resolveTarget();
     return withLock(version, async () => {
         // Re-check inside the lock: another process may have finished downloading.
         if (await isExecutableFile(cached))

package/dist/runtime/harness.d.ts

@@ -5,6 +5,11 @@ export type HarnessOptions = {
     codex?: string;
 };
 export declare function harnessExecutableCandidates(binary: string, cwd: string, path: string, platform?: NodeJS.Platform, pathExt?: string | undefined): string[];
+/**
+ * Windows npm/pnpm installs expose harnesses as .cmd shims, which cannot be spawned
+ * without a shell. Run an .exe directly, or the shim's Node entry with this Node.
+ */
+export declare function harnessCommand(binary: string, args: string[], cwd: string): [string, string[]];
 /** Discover installed executables only; authentication/capability errors stay explicit. */
 export declare function installedHarnesses(cwd: string, options: HarnessOptions, path?: string): Promise<("pi" | "codex")[]>;
 /** Aborted streams leave tool calls with an empty id or name. */

package/dist/runtime/harness.js

@@ -1,5 +1,5 @@
 import { access, stat } from "node:fs/promises";
-import { constants } from "node:fs";
+import { constants, readFileSync, statSync } from "node:fs";
 import { delimiter, join, resolve, win32 } from "node:path";
 import { JsonRpcProcess, record } from "./json-rpc.js";
 import { codexModelCatalog, piModelCatalog } from "./model-catalog.js";
@@ -7,14 +7,40 @@ import { downloadPublicImage } from "../safe-remote-image.js";
 export function harnessExecutableCandidates(binary, cwd, path, platform = process.platform, pathExt = process.env.PATHEXT) {
     const windows = platform === "win32";
     const paths = windows ? win32 : { delimiter, join, resolve };
+    // Windows runs only PATHEXT names; npm/pnpm also write an extensionless sh script beside the .cmd shim.
     const extensions = windows && !win32.extname(binary)
-        ? ["", ...(pathExt || ".COM;.EXE;.BAT;.CMD").split(";").filter((ext) => /^\.[a-z0-9]+$/i.test(ext))]
+        ? (pathExt || ".COM;.EXE;.BAT;.CMD").split(";").filter((ext) => /^\.[a-z0-9]+$/i.test(ext))
         : [""];
     const roots = binary.includes("/") || binary.includes("\\")
         ? [paths.resolve(cwd, binary)]
         : path.split(paths.delimiter).map((directory) => directory.replace(/^"(.*)"$/, "$1")).filter(Boolean).map((directory) => paths.resolve(cwd, directory, binary));
     return roots.flatMap((root) => extensions.map((ext) => `${root}${ext}`));
 }
+/**
+ * Windows npm/pnpm installs expose harnesses as .cmd shims, which cannot be spawned
+ * without a shell. Run an .exe directly, or the shim's Node entry with this Node.
+ */
+export function harnessCommand(binary, args, cwd) {
+    if (process.platform !== "win32")
+        return [binary, args];
+    const path = harnessExecutableCandidates(binary, cwd, process.env.PATH ?? "").find((candidate) => statSync(candidate, { throwIfNoEntry: false })?.isFile());
+    if (!path)
+        throw new Error(`${binary} was not found on PATH`);
+    const extension = win32.extname(path).toLowerCase();
+    if (extension === ".exe" || extension === ".com")
+        return [path, args];
+    if ([".js", ".mjs", ".cjs"].includes(extension))
+        return [process.execPath, [path, ...args]];
+    if (extension === ".cmd") {
+        // npm (cmd-shim): SET "_prog=node" … "%dp0%\entry" %*; pnpm (@zkochan/cmd-shim): node  "%~dp0\entry" %*
+        const shim = readFileSync(path, "utf8");
+        const runsNode = /SET "_prog=node"/i.test(shim) || /^\s*node\s+"%~dp0\\/im.test(shim);
+        const entry = runsNode ? /"%~?dp0%?\\([^"]+)"\s+%\*/i.exec(shim)?.[1] : undefined;
+        if (entry)
+            return [process.execPath, [win32.join(win32.dirname(path), entry), ...args]];
+    }
+    throw new Error(`Cannot run ${path} without a shell; pass --pi/--codex with an .exe or Node script`);
+}
 /** Discover installed executables only; authentication/capability errors stay explicit. */
 export async function installedHarnesses(cwd, options, path = process.env.PATH ?? "") {
     const names = options.pi || options.codex ? ["pi", "codex"].filter((name) => options[name]) : ["pi", "codex"];
@@ -64,7 +90,7 @@ async function initializeCodex(rpc) {
 export async function discoverHarnesses(harnesses, options, cwd) {
     const models = [];
     await Promise.all(harnesses.map(async (harness) => {
-        const rpc = new JsonRpcProcess(options[harness] || harness, harness === "pi" ? ["--mode", "rpc", "--no-session"] : ["app-server", "--listen", "stdio://"], cwd, harness);
+        const rpc = new JsonRpcProcess(...harnessCommand(options[harness] || harness, harness === "pi" ? ["--mode", "rpc", "--no-session"] : ["app-server", "--listen", "stdio://"], cwd), cwd, harness);
         try {
             if (harness === "pi") {
                 const result = await rpc.request("get_available_models");

package/dist/runtime/json-rpc.js

@@ -67,7 +67,7 @@ export class JsonRpcProcess {
     closing = null;
     constructor(binary, args, cwd, mode, context = {}) {
         this.mode = mode;
-        this.child = spawn(binary, args, { cwd, env: { ...harnessEnvironment(), ...context }, stdio: "pipe", detached: process.platform !== "win32" });
+        this.child = spawn(binary, args, { cwd, env: { ...harnessEnvironment(), ...context }, stdio: "pipe", detached: process.platform !== "win32", windowsHide: true });
         this.closed = new Promise((resolve) => this.child.once("close", () => resolve()));
         const decoder = new JsonLineDecoder((value) => this.receive(value));
         this.child.stdout.on("data", (chunk) => { try {

package/dist/runtime/launch.js

@@ -1,7 +1,8 @@
-import { fork } from "node:child_process";
+import { execFile, fork } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { stat } from "node:fs/promises";
-import { basename, resolve } from "node:path";
+import { basename, join, resolve } from "node:path";
+import { promisify } from "node:util";
 import { createInterface } from "node:readline/promises";
 import { isLocalHarness } from "@neta-art/cohub";
 import { discoverHarnesses, installedHarnesses } from "./harness.js";
@@ -23,11 +24,11 @@ export function parseRuntimeHarnesses(values) {
 export function parseRuntimeDisplay(value, platform = process.platform, env = process.env) {
     if (value === false)
         return undefined;
-    if (value === undefined && platform !== "darwin" && (platform !== "linux" || !env.DISPLAY))
+    if (value === undefined && platform !== "darwin" && platform !== "win32" && (platform !== "linux" || !env.DISPLAY))
         return undefined;
     const spec = value === undefined || value === true ? "auto" : value.trim();
-    if (!/^(auto|macos|x11(:[\w.:-]+)?|xvfb(:\d{3,4}x\d{3,4})?)$/.test(spec)) {
-        throw new Error("Display must be auto, macos, x11[:display] or xvfb[:WIDTHxHEIGHT]");
+    if (!/^(auto|macos|windows|x11(:[\w.:-]+)?|xvfb(:\d{3,4}x\d{3,4})?)$/.test(spec)) {
+        throw new Error("Display must be auto, macos, windows, x11[:display] or xvfb[:WIDTHxHEIGHT]");
     }
     if (platform === "linux" && spec === "auto" && !env.DISPLAY) {
         throw new Error(env.WAYLAND_DISPLAY
@@ -52,7 +53,9 @@ 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"] });
+        // fork forwards spawn options; windowsHide keeps a detached Windows worker from opening a console.
+        const forkOptions = { detached: true, stdio: ["ignore", "ignore", "ignore", "ipc"], windowsHide: true };
+        const child = fork(workerUrl, [], forkOptions);
         const diagnosticConsole = createDiagnosticConsole(config.verbose);
         let last = null;
         let settled = false;
@@ -89,7 +92,19 @@ export async function startBackgroundRuntime(config) {
         child.send(config);
     });
 }
+/** Collaborators execute as this OS user; an elevated Windows token would grant them administrator rights. */
+async function assertNotElevatedOnWindows() {
+    if (process.platform !== "win32")
+        return;
+    if (!process.env.SystemRoot)
+        throw new Error("SystemRoot is not set; cannot check terminal elevation");
+    const { stdout } = await promisify(execFile)(join(process.env.SystemRoot, "System32", "whoami.exe"), ["/groups"], { encoding: "utf8", windowsHide: true });
+    // High (S-1-16-12288) and System (S-1-16-16384) integrity labels mark an elevated token.
+    if (/\bS-1-16-(?:12288|16384)\b/.test(stdout))
+        throw new Error("Run cohub runtime up from a non-elevated terminal");
+}
 export async function runtimeUp(program, dir, options) {
+    await assertNotElevatedOnWindows();
     const requestedRoot = resolve(dir ?? process.cwd());
     if (!(await stat(requestedRoot)).isDirectory())
         throw new Error("Workspace is not a directory");

package/dist/runtime/native/attach.js

@@ -1,6 +1,6 @@
 import { createInterface } from "node:readline/promises";
 import { serializeDiagnosticError } from "../diagnostics.js";
-import { CODEX_SHARED_MIN_VERSION, supportsSharedServer } from "./codex-link.js";
+import { CODEX_SHARED_MIN_VERSION, sharedServerAvailable, supportsSharedServer } from "./codex-link.js";
 import { PI_MIN_VERSION } from "./pi-link.js";
 import { atLeast, formatVersion, harnessVersion } from "./version.js";
 import { readNativeConfig, runtimeStateRoot, writeNativeConfig } from "./config.js";
@@ -43,7 +43,10 @@ export async function ensureNativeSync(input, log = (line) => process.stderr.wri
     let codexShared = previous?.codexShared ?? false;
     if (input.harnesses.includes("codex") && !codexShared) {
         const version = await harnessVersion(input.executables?.codex || "codex");
-        if (!supportsSharedServer(version)) {
+        if (!sharedServerAvailable) {
+            log("Shared Codex sessions are unavailable on Windows; terminal Codex chats sync read-only\n");
+        }
+        else if (!supportsSharedServer(version)) {
             log(`Codex ${formatVersion(version)} predates the shared app-server (${CODEX_SHARED_MIN_VERSION.join(".")}+); terminal Codex chats sync read-only\n`);
         }
         else {

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

@@ -18,6 +18,8 @@ export interface CodexChannel {
     readonly shared: boolean;
     readonly closed: boolean;
 }
+/** Codex's shared server listens on an AF_UNIX socket, which Node cannot reach on Windows. */
+export declare const sharedServerAvailable: boolean;
 export declare const supportsSharedServer: (version: Version | null) => boolean;
 /** A private app-server over stdio, used when no shared one is available; it lives for one Turn. */
 export declare function openPrivateServer(rpc: JsonRpcProcess): Promise<CodexChannel>;

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

@@ -15,7 +15,9 @@ const DAEMON_START_TIMEOUT_MS = 30_000;
 const codexHome = () => process.env.CODEX_HOME?.trim() || join(homedir(), ".codex");
 /** The socket every Codex client on this machine discovers; a terminal `codex` attaches to it. */
 const codexControlSocket = () => join(codexHome(), "app-server-control", "app-server-control.sock");
-export const supportsSharedServer = (version) => atLeast(version, CODEX_SHARED_MIN_VERSION);
+/** Codex's shared server listens on an AF_UNIX socket, which Node cannot reach on Windows. */
+export const sharedServerAvailable = process.platform !== "win32";
+export const supportsSharedServer = (version) => sharedServerAvailable && atLeast(version, CODEX_SHARED_MIN_VERSION);
 /** Start the shared app-server when none is running. */
 async function ensureSharedServer(binary, cwd) {
     if (existsSync(codexControlSocket()) && await probe())

package/dist/runtime/native/execution.js

@@ -1,4 +1,4 @@
-import { imageForPi } from "../harness.js";
+import { harnessCommand, imageForPi } from "../harness.js";
 import { JsonRpcProcess, record, RpcProcessClosedError } from "../json-rpc.js";
 import { describeError } from "../../network-error.js";
 import { ProcessCleanupUncertainError } from "../process-group.js";
@@ -55,7 +55,7 @@ async function runPi(executor, turn, context) {
     let begun = false;
     try {
         if (!link) {
-            host = new JsonRpcProcess(executor.executables.pi || "pi", ["--mode", "rpc", "--session", session.path, "-e", executor.piExtension], executor.cwd, "pi", turnEnvironment(input));
+            host = new JsonRpcProcess(...harnessCommand(executor.executables.pi || "pi", ["--mode", "rpc", "--session", session.path, "-e", executor.piExtension], executor.cwd), executor.cwd, "pi", turnEnvironment(input));
             watchHost(host, executor.diagnostics, context);
             const rpc = host;
             // Nobody is at this Pi's terminal to answer an extension's question.
@@ -209,7 +209,7 @@ async function runCodex(executor, turn, context) {
     let begun = false;
     try {
         if (!channel) {
-            host = new JsonRpcProcess(executor.executables.codex || "codex", ["app-server", "--listen", "stdio://"], executor.cwd, "codex", turnEnvironment(input));
+            host = new JsonRpcProcess(...harnessCommand(executor.executables.codex || "codex", ["app-server", "--listen", "stdio://"], executor.cwd), executor.cwd, "codex", turnEnvironment(input));
             watchHost(host, executor.diagnostics, context);
             channel = await openPrivateServer(host);
         }

package/dist/runtime/native/ingest.js

@@ -4,6 +4,7 @@ import { NATIVE_INGEST_MAX_TURNS, SETTLED_TURN_STATUSES } from "@neta-art/cohub"
 import { acceptsDirectory, acceptsTranscript, readSessionHeader, readTranscript, transcriptRoots } from "./adapters.js";
 import { nativeTurnId } from "./identity.js";
 import { ensurePlainCodexRollout } from "./transcript.js";
+import { containsNativePath } from "./paths.js";
 const missing = (error) => error?.code === "ENOENT";
 /** Transcripts read in parallel per lane. The live lane never waits behind a backfill. */
 const LIVE_CONCURRENCY = 2;
@@ -39,9 +40,8 @@ const BOUNDARY_OVERLAP = Math.max(...Object.values(BOUNDARIES).flat().map((token
 const IMPORT_FAILURES_KEPT = 100;
 /** Headers are read this many at a time; each costs one small read. */
 const HEADER_CONCURRENCY = 16;
-const within = (root, cwd) => cwd === root || cwd.startsWith(`${root}/`);
 /** Whether a session in `cwd` belongs to the directory bound at `root`. */
-export const owns = (root, cwd, nested = []) => Boolean(cwd) && within(root, cwd) && !nested.some((inner) => within(inner, cwd));
+export const owns = (root, cwd, nested = []) => Boolean(cwd) && containsNativePath(root, cwd) && !nested.some((inner) => containsNativePath(inner, cwd));
 /** Every transcript of the bound directory and its subdirectories, newest first. */
 export async function discoverTranscripts(cwd, harnesses, options = {}) {
     const found = [];
@@ -144,7 +144,7 @@ export class NativeIngest {
         return owns(this.options.cwd, cwd, this.nested);
     }
     exclude(nested) {
-        this.nested = nested.filter((root) => root !== this.options.cwd && within(this.options.cwd, root));
+        this.nested = nested.filter((root) => !containsNativePath(root, this.options.cwd) && containsNativePath(this.options.cwd, root));
     }
     configure(harnesses, enabledAt) {
         const added = harnesses.filter((harness) => !this.harnesses.includes(harness));
@@ -560,7 +560,7 @@ export class NativeIngest {
     }
     harnessFor(path) {
         for (const harness of this.harnesses) {
-            if (transcriptRoots(harness).some((root) => path.startsWith(`${root}/`)) && acceptsTranscript(path, harness, this.options.cwd))
+            if (transcriptRoots(harness).some((root) => containsNativePath(root, path)) && acceptsTranscript(path, harness, this.options.cwd))
                 return harness;
         }
         return null;

package/dist/runtime/native/paths.d.ts

@@ -0,0 +1,2 @@
+/** Whether a native path is the root itself or one of its descendants. */
+export declare function containsNativePath(root: string, path: string, platform?: NodeJS.Platform): boolean;

package/dist/runtime/native/paths.js

@@ -0,0 +1,7 @@
+import { posix, win32 } from "node:path";
+/** Whether a native path is the root itself or one of its descendants. */
+export function containsNativePath(root, path, platform = process.platform) {
+    const paths = platform === "win32" ? win32 : posix;
+    const relative = paths.relative(root, path);
+    return relative === "" || relative !== ".." && !relative.startsWith(`..${paths.sep}`) && !paths.isAbsolute(relative);
+}

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

@@ -1,6 +1,6 @@
 // Cohub control bridge for Pi. Self-contained: Node built-ins only, so it installs as one file.
 import { createHash } from "node:crypto";
-import { existsSync, realpathSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { connect } from "node:net";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
@@ -103,7 +103,17 @@ export default function cohub(pi) {
         const path = locateSocket(ctx.cwd);
         if (!path)
             return;
-        const current = connect(path);
+        // On Windows the socket file names the Runtime's private named pipe.
+        let endpoint = path;
+        if (process.platform === "win32") {
+            try {
+                endpoint = readFileSync(path, "utf8").trim();
+            }
+            catch {
+                return;
+            }
+        }
+        const current = connect(endpoint);
         socket = current;
         buffer = "";
         current.on("connect", () => send({

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

@@ -1,5 +1,6 @@
+import { randomUUID } from "node:crypto";
 import { createServer } from "node:net";
-import { chmod, mkdir, rm } from "node:fs/promises";
+import { chmod, mkdir, rename, rm, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 import { COHUB_PI_PROTOCOL } from "./pi-extension.js";
 const MAX_LINE_BYTES = 8 * 1024 * 1024;
@@ -68,17 +69,33 @@ export class PiLink {
     }
     async listen(signal) {
         const { socketPath } = this.options;
+        const windows = process.platform === "win32";
+        // Windows named pipes share one global namespace: listen on a random name and
+        // publish it at socketPath, so another account cannot pre-claim the endpoint.
+        const endpoint = windows ? `\\\\.\\pipe\\cohub-pi-${randomUUID()}` : socketPath;
         // The socket accepts commands that drive the user's agent: only this user may reach it.
         await mkdir(dirname(socketPath), { recursive: true, mode: 0o700 });
-        if (process.platform !== "win32")
+        if (!windows)
             await chmod(dirname(socketPath), 0o700);
         await rm(socketPath, { force: true });
         const server = createServer((socket) => this.accept(socket));
         await new Promise((resolve, reject) => {
             server.once("error", reject);
-            server.listen(socketPath, () => { server.removeListener("error", reject); resolve(); });
+            server.listen(endpoint, () => { server.removeListener("error", reject); resolve(); });
         });
-        if (process.platform !== "win32")
+        if (windows) {
+            const temporary = `${socketPath}.${randomUUID()}.tmp`;
+            try {
+                await writeFile(temporary, endpoint, { mode: 0o600 });
+                await rename(temporary, socketPath);
+            }
+            catch (error) {
+                server.close();
+                await rm(temporary, { force: true });
+                throw error;
+            }
+        }
+        else
             await chmod(socketPath, 0o600);
         this.server = server;
         signal.addEventListener("abort", () => {

package/dist/runtime/native/version.js

@@ -1,8 +1,11 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
+import { harnessCommand } from "../harness.js";
 /** A harness binary's own version, or `null` when it cannot say. */
 export async function harnessVersion(binary) {
-    const { stdout } = await promisify(execFile)(binary, ["--version"], { encoding: "utf8", timeout: 15_000 }).catch(() => ({ stdout: "" }));
+    const { stdout } = await Promise.resolve()
+        .then(() => promisify(execFile)(...harnessCommand(binary, ["--version"], process.cwd()), { encoding: "utf8", timeout: 15_000, windowsHide: true }))
+        .catch(() => ({ stdout: "" }));
     const match = /(\d+)\.(\d+)\.(\d+)/.exec(stdout);
     return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
 }

package/dist/runtime/supervisor.js

@@ -1,7 +1,9 @@
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
+import { createServer } from "node:net";
 import { createInterface } from "node:readline";
 import { setTimeout as delay } from "node:timers/promises";
+import { PassThrough } from "node:stream";
 import { resolveWebsocketUrl } from "@neta-art/cohub";
 import { AuthRequiredError, resolveAccessToken } from "../auth.js";
 import { createClient } from "../client.js";
@@ -22,6 +24,24 @@ export function sandboxOutputLevel(value, stream) {
         return level;
     return stream === "stderr" ? "warn" : "debug";
 }
+/**
+ * Windows cannot hand sandboxd an extra inherited pipe, so control frames use a
+ * named pipe instead. Only the first client is accepted; the name is unguessable.
+ */
+async function listenWindowsControlPipe() {
+    const path = `\\\\.\\pipe\\cohub-sandboxd-${randomUUID()}`;
+    const stream = new PassThrough();
+    const server = createServer((socket) => {
+        server.close();
+        socket.on("error", () => stream.end());
+        socket.pipe(stream);
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(path, () => { server.removeListener("error", reject); resolve(); });
+    });
+    return { path, stream, close: () => { server.close(); stream.end(); } };
+}
 export async function runRuntime(config, onState, externalSignal, onDiagnostic) {
     const controller = new AbortController();
     const signal = externalSignal ? AbortSignal.any([externalSignal, controller.signal]) : controller.signal;
@@ -119,12 +139,16 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
                 let probeTimer;
                 let managed = false;
                 let childStopped = false;
+                let controlPipe = null;
                 try {
                     const initialToken = await token();
                     signal.throwIfAborted();
+                    if (process.platform === "win32")
+                        controlPipe = await listenWindowsControlPipe();
                     const bridge = spawn(binary, ["--local", "--space", config.spaceId, "--root", config.root, "--relay", process.env.COHUB_RELAY_URL?.trim() || relay.toString()], {
-                        stdio: ["pipe", "pipe", "pipe", "pipe"],
-                        env: { ...process.env, COHUB_RELAY_TOKEN: initialToken, COHUB_RUNTIME_ID: status.runtimeId, COHUB_LOG_FORMAT: "json", COHUB_RUNTIME_MANAGED: "1", COHUB_DISPLAY: config.display ?? "" },
+                        stdio: controlPipe ? ["pipe", "pipe", "pipe"] : ["pipe", "pipe", "pipe", "pipe"],
+                        windowsHide: true,
+                        env: { ...process.env, COHUB_RELAY_TOKEN: initialToken, COHUB_RUNTIME_ID: status.runtimeId, COHUB_LOG_FORMAT: "json", COHUB_RUNTIME_MANAGED: "1", COHUB_DISPLAY: config.display ?? "", ...(controlPipe ? { COHUB_RUNTIME_CONTROL_PIPE: controlPipe.path } : {}) },
                     });
                     bridge.stdin?.on("error", () => undefined);
                     const closed = new Promise((resolve) => {
@@ -153,7 +177,7 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
                             diagnostics.log(sandboxOutputLevel(parsed?.level, streamName), "sandboxd.log", { ...data, message: parsed?.msg ?? line }, { component: "sandboxd" });
                         });
                     }
-                    const control = bridge.stdio[3];
+                    const control = controlPipe ? controlPipe.stream : bridge.stdio[3];
                     const events = createInterface({ input: control });
                     events.on("line", (line) => {
                         try {
@@ -202,7 +226,11 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
                     };
                     probeTimer = setTimeout(() => void probe(), 1000);
                     const terminate = () => {
-                        bridge.kill("SIGTERM");
+                        // Windows has no SIGTERM; closing the managed stdin lets sandboxd stop gracefully.
+                        if (process.platform === "win32")
+                            bridge.stdin?.end();
+                        else
+                            bridge.kill("SIGTERM");
                         const timeout = setTimeout(() => bridge.kill("SIGKILL"), 3000);
                         void closed.finally(() => clearTimeout(timeout));
                     };
@@ -218,6 +246,7 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
                 }
                 finally {
                     childStopped = true;
+                    controlPipe?.close();
                     clearTimeout(refreshTimer);
                     clearTimeout(probeTimer);
                     update({ workspaceConnected: false });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "10.2.0",
+  "version": "10.4.1",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "engines": {
@@ -18,7 +18,7 @@
     "NOTICE"
   ],
   "dependencies": {
-    "@neta-art/cohub": "11.2.0",
+    "@neta-art/cohub": "11.3.1",
     "@neta-art/generation": "^0.1.35",
     "commander": "^15.0.0",
     "sharp": "^0.35.4",
@@ -42,6 +42,7 @@
   "scripts": {
     "build": "tsc -p tsconfig.build.json && tsdown",
     "verify:sandboxd": "node --import tsx scripts/verify-sandboxd-release.ts",
+    "verify:rtc": "node --import tsx scripts/verify-rtc-release.ts",
     "verify:board-kernel": "node --import tsx scripts/verify-board-kernel.ts",
     "test": "node ../../scripts/test/run.mjs 'tests/**/*.test.ts'",
     "test:runtime": "node --import tsx --test tests/runtime-*.integration.ts",