@neta-art/cohub-cli 10.1.0 → 10.3.0

package/dist/commands/rooms-rtc.js

@@ -0,0 +1,171 @@
+import { spawn } from "node:child_process";
+import { HttpError } from "@neta-art/cohub";
+import { createRealtimeClient } from "../client.js";
+import { readRoomLines } from "./rooms-connect.js";
+import { ensureRtcBinary } from "./rooms-rtc-binary.js";
+export async function runRoomRtc(roomId, options) {
+    if (options.delivery !== "reliable" && options.delivery !== "latest")
+        throw new Error("--delivery must be reliable or latest");
+    if (options.dataInput && !options.channel)
+        throw new Error("--data-input requires --channel");
+    if ([options.audio, options.video, options.dataInput].filter((value) => value === "-").length > 1)
+        throw new Error("Only one input can use stdin");
+    const maxBytes = Number(options.maxBytes);
+    if (!Number.isSafeInteger(maxBytes) || maxBytes < 0)
+        throw new Error("--max-bytes must be a non-negative safe integer");
+    const client = createRealtimeClient();
+    const sessions = new Set();
+    const pending = new Set();
+    let room;
+    let helper;
+    let control;
+    let exit;
+    let killTimer;
+    let stopped = false;
+    let failure;
+    const stop = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        helper?.kill("SIGTERM");
+        if (helper)
+            killTimer = setTimeout(() => helper?.kill("SIGKILL"), 5_000);
+    };
+    const fail = (cause) => { failure ??= cause; stop(); };
+    const send = (value) => {
+        if (!control || control.destroyed || stopped)
+            return;
+        const line = `${JSON.stringify(value)}\n`;
+        if (Buffer.byteLength(line) > 256 * 1024 || control.writableLength > 1024 * 1024)
+            throw new Error("RTC control input is too slow or too large");
+        control.write(line);
+    };
+    let previousMembers = "";
+    const report = (value) => {
+        const output = options.output === "-" ? process.stderr : process.stdout;
+        if (output.writableLength > 1024 * 1024)
+            throw new Error("RTC output is too slow");
+        output.write(`${JSON.stringify(value)}\n`);
+    };
+    const release = async (sessionId) => {
+        if (!sessions.has(sessionId))
+            return;
+        await client.rooms.signalRtc(roomId, { method: "DELETE", path: `/${sessionId}` });
+        sessions.delete(sessionId);
+    };
+    const request = async (message) => {
+        try {
+            if (!["GET", "POST", "PUT", "PATCH", "DELETE"].includes(message.method))
+                throw new Error("Invalid RTC signaling method");
+            const opening = message.method === "POST" && message.path === "";
+            const body = await client.rooms.signalRtc(roomId, {
+                method: message.method,
+                path: message.path,
+                body: opening ? { ticket: "hosted", participantId: room?.participantId } : message.method === "GET" ? undefined : message.body,
+            });
+            if (opening && body.sessionId)
+                sessions.add(body.sessionId);
+            if (message.method === "GET" && room) {
+                const snapshot = await client.rooms.get(roomId);
+                send({ kind: "members", body: snapshot.members.map(({ participantId, publications }) => ({ participantId, publications })) });
+                previousMembers = "";
+            }
+            send({ kind: "response", id: message.id, body });
+        }
+        catch (cause) {
+            send({ kind: "response", id: message.id, error: cause instanceof Error ? cause.message : String(cause), code: cause instanceof HttpError ? cause.code : "RTC_FAILED" });
+        }
+    };
+    const track = (task) => {
+        pending.add(task);
+        void task.catch(fail).finally(() => pending.delete(task));
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+    process.stdout.on("error", fail);
+    process.stderr.on("error", fail);
+    try {
+        const binary = await ensureRtcBinary(options.helper);
+        if (stopped)
+            return;
+        room = await client.rooms.connect(roomId);
+        if (stopped)
+            return;
+        room.onStateChange((state) => {
+            try {
+                report({ kind: "room", state });
+            }
+            catch (cause) {
+                fail(cause);
+            }
+            if (state === "closed" || state === "expired")
+                stop();
+        });
+        helper = spawn(binary, [], { stdio: ["inherit", "inherit", "inherit", "pipe", "pipe"] });
+        control = helper.stdio[3];
+        const events = helper.stdio[4];
+        control.on("error", fail);
+        exit = new Promise((resolve, reject) => {
+            helper?.once("error", reject);
+            helper?.once("close", (code, signal) => {
+                if (killTimer)
+                    clearTimeout(killTimer);
+                if (code === 0 || stopped && signal === "SIGTERM")
+                    resolve();
+                else
+                    reject(new Error(`RTC helper exited with ${signal ?? code}`));
+            });
+        });
+        void exit.catch(fail);
+        send({ protocol: 1, ...options, maxBytes, participantId: room.participantId });
+        const updateMembers = () => {
+            const body = room?.members.map(({ participantId, publications }) => ({ participantId, publications }));
+            const next = JSON.stringify(body);
+            if (next === previousMembers)
+                return;
+            send({ kind: "members", body });
+            previousMembers = next;
+        };
+        room.onMembersChanged(() => { try {
+            updateMembers();
+        }
+        catch (cause) {
+            fail(cause);
+        } });
+        updateMembers();
+        report({ kind: "connected", roomId, participantId: room.participantId });
+        for await (const line of readRoomLines(events, 256 * 1024)) {
+            const message = JSON.parse(line);
+            if (message.kind === "request") {
+                if (pending.size >= 16)
+                    throw new Error("Too many pending RTC requests");
+                track(request(message));
+            }
+            else if (message.kind === "release") {
+                await release(message.sessionId);
+            }
+            else
+                report(message);
+        }
+        await exit;
+    }
+    finally {
+        stop();
+        await exit?.catch((cause) => { failure ??= cause; });
+        if (killTimer)
+            clearTimeout(killTimer);
+        await Promise.allSettled(pending);
+        const results = await Promise.allSettled([...sessions].map(release));
+        for (const result of results)
+            if (result.status === "rejected")
+                failure ??= result.reason;
+        await room?.disconnect().catch((cause) => { failure ??= cause; });
+        await client.disconnect().catch((cause) => { failure ??= cause; });
+        process.removeListener("SIGINT", stop);
+        process.removeListener("SIGTERM", stop);
+        process.stdout.removeListener("error", fail);
+        process.stderr.removeListener("error", fail);
+    }
+    if (failure)
+        throw failure;
+}

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,4 +1,4 @@
-export declare const SANDBOXD_VERSION = "v2.61.1";
+export declare const SANDBOXD_VERSION = "v2.67.0";
 export declare class SandboxdDownloadError extends Error {
     name: string;
 }

package/dist/commands/sandboxd-binary.js

@@ -7,7 +7,7 @@ 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.67.0";
 const BINARY_NAME = "cohub-sandboxd";
 // Public CDN prefix hosting the release archives (the repo is private, so the
 // GitHub Release assets are not publicly downloadable). Overridable for staging

package/dist/commands/spaces.js

@@ -3,10 +3,12 @@ import { basename, dirname, relative, resolve, sep } from "node:path";
 import { readSentTurns, readSessionTurnOrigin, resolveCohubEnvironment } from "@neta-art/cohub";
 import { uploadAvatarAsset, uploadChatImageAsset } from "../avatar.js";
 import { createClient } from "../client.js";
+import { collectOption, readPromptContent } from "../command-input.js";
 import { table, json as outJson, jsonRequested, ok, error, handleHttp, formatEpochMs, truncateText } from "../output.js";
 import { SESSION_STATUS_COLUMN } from "../session-status.js";
 import { resolveSpace } from "../space.js";
 import { uploadLocalFiles } from "../space-files/upload.js";
+import { registerDecisionCommand } from "./decision.js";
 import { registerSpaceCommerce } from "./space-commerce.js";
 import { registerSpaceFileTransfer } from "./space-files.js";
 import { registerSpaceActivity } from "./space-activity.js";
@@ -33,9 +35,6 @@ function parseInteger(value, name, options = {}) {
         return error(`Invalid ${name}`, `${name} must be at most ${options.max}`);
     return parsed;
 }
-function collectOption(value, previous = []) {
-    return [...previous, value];
-}
 function parseEnvOptions(values) {
     if (!values?.length)
         return undefined;
@@ -181,18 +180,6 @@ async function confirmRestart(opts) {
     if (answer !== "y" && answer !== "yes")
         return error("Cancelled");
 }
-async function readPromptContent(words, options = {}) {
-    let content = words.join(" ");
-    if (!content && !process.stdin.isTTY) {
-        const chunks = [];
-        for await (const chunk of process.stdin)
-            chunks.push(chunk);
-        content = Buffer.concat(chunks).toString().trim();
-    }
-    if (!content && !options.allowEmpty)
-        return error("No content", "Pass as argument or pipe via stdin");
-    return content;
-}
 async function sendPrompt(command, words, opts) {
     const content = await readPromptContent(words, { allowEmpty: Boolean(opts.image?.length) });
     const scheduleFlags = [opts.delayMs, opts.at, opts.cron].filter((value) => value !== undefined);
@@ -379,6 +366,7 @@ export function registerPrompt(program) {
         .option("--thinking-level <level>", "Thinking level: off|minimal|low|medium|high|xhigh")
         .option("--json", "Output as JSON")
         .action((words, opts) => runCompletionCommand(program, words, opts));
+    registerDecisionCommand(program);
 }
 export function registerSpaceCreate(spacesCmd, dependencies = {}) {
     const getClient = dependencies.createClient ?? createClient;
@@ -699,6 +687,7 @@ export function registerSpaces(program) {
         .option("--thinking-level <level>", "Thinking level: off|minimal|low|medium|high|xhigh")
         .option("--json", "Output as JSON")
         .action((words, opts) => runCompletionCommand(spacesCmd, words, opts));
+    registerDecisionCommand(spacesCmd);
     // ── spaces files ──
     registerFiles(spacesCmd);
     registerSpaceDisplays(spacesCmd);

package/dist/index.js

@@ -54,6 +54,7 @@ Common commands:
   cohub spaces ls
   cohub prompt "Fix the failing tests"
   cohub completion "Summarize AGENTS.md" --system-prompt AGENTS.md --stream
+  cohub decision "I was charged twice" -q questions.json
   cohub run -- git status
   cohub runtime up ./my-project
   cohub runtime logs --follow
@@ -74,7 +75,7 @@ Common commands:
 Target space:
   -s <space>, then COHUB_SPACE_ID, then the current directory Runtime binding.
   <space> is an ID, a slug you own such as home, or username/slug.
-  prompt, completion, generate, apps, and public fall back to your Home Space;
+  prompt, completion, decision, generate, apps, and public fall back to your Home Space;
   other Space commands need a target.
 
 Environment:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "10.1.0",
+  "version": "10.3.0",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "engines": {
@@ -18,8 +18,8 @@
     "NOTICE"
   ],
   "dependencies": {
-    "@neta-art/cohub": "11.1.0",
-    "@neta-art/generation": "^0.1.33",
+    "@neta-art/cohub": "11.3.0",
+    "@neta-art/generation": "^0.1.35",
     "commander": "^15.0.0",
     "sharp": "^0.35.4",
     "ws": "^8.21.3"
@@ -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",