@neta-art/cohub-cli 9.1.2 → 10.0.0

package/dist/board-time.js

@@ -6,6 +6,12 @@ export function parseBoardTime(value, name = "time") {
     return Math.round(Number(match[1]) * (UNITS[(match[2] ?? "").toLowerCase()] ?? 1) * 1000) / 1000;
 }
 export function parseBoardTimes(value, name = "--at", limit = 10_000) {
+    if (value.includes(",")) {
+        const entries = value.split(",");
+        if (entries.length > limit)
+            throw new Error(`${name}: frame count exceeds the limit of ${limit}`);
+        return entries.map((entry) => parseBoardTime(entry, name));
+    }
     const parts = value.split(":");
     if (parts.length === 1)
         return [parseBoardTime(value, name)];

package/dist/commands/boards/authoring.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerBoardAuthoringCommands(boards: Command): void;

package/dist/commands/boards/authoring.js

@@ -0,0 +1,90 @@
+import { readBoardJsonObject } from "../../board-command-support.js";
+import { loadBoardDocument, resolveBundledFonts } from "../../board-export.js";
+import { boardPathTrack, boardSequencePatch, buildBoardScene, createBoardAnimationSampler, createNodeBoardRenderer, inspectBoardScene, measureBoardText, } from "../../board-kernel.js";
+import { parseBoardTimes } from "../../board-time.js";
+import { handleHttp, json as outJson } from "../../output.js";
+import { resolveSpace } from "../../space.js";
+export function registerBoardAuthoringCommands(boards) {
+    boards
+        .command("inspect <board>")
+        .description("Measure items and report visible layout hints without changing the Board")
+        .option("--animation <id>", "Animation to sample")
+        .option("--at <times>", "Time, comma-separated times, or start:end:step", "0")
+        .option("--items <ids>", "Limit measurements to comma-separated item ids")
+        .option("--json", "Output as JSON")
+        .action(async (target, options) => {
+        try {
+            const { document } = await loadBoardDocument(await resolveSpace(boards), target);
+            const times = parseBoardTimes(options.at, "--at", 100);
+            const sampler = options.animation ? createBoardAnimationSampler(document, options.animation) : null;
+            const renderer = await createNodeBoardRenderer({ fonts: resolveBundledFonts() });
+            try {
+                const ids = options.items ? new Set(options.items.split(",")) : null;
+                outJson({
+                    samples: times.map((time) => {
+                        const scene = sampler?.at(time).scene ?? buildBoardScene(document);
+                        return {
+                            time,
+                            diagnostics: inspectBoardScene(scene),
+                            items: scene.items
+                                .filter((item) => !ids || ids.has(item.id))
+                                .map((item) => ({
+                                id: item.id,
+                                bounds: item.frame,
+                                ...(item.type === "text" ? { text: measureBoardText(item.props) } : {}),
+                            })),
+                        };
+                    }),
+                });
+            }
+            finally {
+                renderer.destroy();
+            }
+        }
+        catch (cause) {
+            handleHttp(cause);
+        }
+    });
+    boards
+        .command("sequence <board>")
+        .description("Compile chapters to an apply-ready animation patch; does not write")
+        .requiredOption("-i, --input <file>", "JSON with a chapters array; use - for stdin")
+        .requiredOption("--animation <id>", "Parent animation id; recompiling replaces its tracks")
+        .action(async (target, options) => {
+        try {
+            const input = await readBoardJsonObject(options.input);
+            if (!Array.isArray(input.chapters) ||
+                input.chapters.some((chapter) => !chapter || typeof chapter !== "object" || typeof chapter.animation !== "string"))
+                throw new Error("Input needs a chapters array with animation IDs.");
+            const { document } = await loadBoardDocument(await resolveSpace(boards), target);
+            outJson(boardSequencePatch(document, options.animation, input.chapters));
+        }
+        catch (cause) {
+            handleHttp(cause);
+        }
+    });
+    boards
+        .command("path <target>")
+        .description("Sample a polyline into a position track; does not write")
+        .requiredOption("-i, --input <file>", "JSON with points, duration (ms), optional at, samples and orient")
+        .action(async (target, options) => {
+        try {
+            const input = await readBoardJsonObject(options.input);
+            if (!Array.isArray(input.points) || input.points.some((point) => !point || typeof point !== "object"))
+                throw new Error("Input needs a points array.");
+            if (typeof input.duration !== "number")
+                throw new Error("Input needs duration in milliseconds.");
+            if (input.orient !== undefined && typeof input.orient !== "boolean")
+                throw new Error("orient must be boolean.");
+            outJson(boardPathTrack(target, input.points, {
+                duration: input.duration,
+                ...(input.at === undefined ? {} : { at: Number(input.at) }),
+                ...(input.samples === undefined ? {} : { samples: Number(input.samples) }),
+                orient: input.orient,
+            }));
+        }
+        catch (cause) {
+            handleHttp(cause);
+        }
+    });
+}

package/dist/commands/boards/examples.js

@@ -1,4 +1,5 @@
 import { json } from "../../output.js";
+import { BOARD_SCRIPT_DRAWING_EXAMPLE } from "../../board-kernel.js";
 /**
  * Starter documents for `boards create -i` and patches for `boards apply -i`.
  * Every example is a valid Board patch; `boards.test.ts` checks that.
@@ -64,14 +65,11 @@ export const BOARD_EXAMPLES = {
             },
         },
     },
-    sketch: {
-        description: "A code-drawn item; `src` is a module in the Space exporting draw(ctx, frame).",
+    custom: {
+        description: "Custom Canvas content; use --module to print scripts/wave.js.",
         value: {
             items: {
-                wave: { type: "sketch", position: { x: 0, y: 0 }, size: { width: 640, height: 360 }, props: { src: "sketches/wave.js", params: { amplitude: 60 } } },
-            },
-            animations: {
-                loop: { duration: 4000, play: "always", tracks: {} },
+                wave: { type: "custom", position: { x: 0, y: 0 }, size: { width: 640, height: 360 }, script: { src: "scripts/wave.js", params: { amplitude: 60 } } },
             },
         },
     },
@@ -79,11 +77,18 @@ export const BOARD_EXAMPLES = {
 export function registerBoardExampleCommands(boards) {
     boards.command("examples [name]")
         .description("Print a starter Board document or list the examples")
+        .option("--module", "Print the custom example's JavaScript module")
         .addHelpText("after", `
 Examples are valid input for create and apply:
   cohub boards examples lesson > lesson.json
   cohub boards create lesson.board -i lesson.json`)
-        .action((name) => {
+        .action((name, options) => {
+        if (options.module) {
+            if (name !== "custom")
+                throw new Error("--module requires the custom example.");
+            process.stdout.write(BOARD_SCRIPT_DRAWING_EXAMPLE);
+            return;
+        }
         if (!name) {
             for (const [key, example] of Object.entries(BOARD_EXAMPLES))
                 console.log(`${key.padEnd(10)} ${example.description}`);

package/dist/commands/boards.js

@@ -9,6 +9,7 @@ import { createClient, createRealtimeClient } from "../client.js";
 import { error, handleHttp, json as outJson, jsonRequested, ok, table } from "../output.js";
 import { resolveSpace } from "../space.js";
 import { registerBoardExampleCommands } from "./boards/examples.js";
+import { registerBoardAuthoringCommands } from "./boards/authoring.js";
 export const parseJsonObject = parseBoardJsonObject;
 function withJson(command) {
     return command.option("--json", "Output as JSON");
@@ -86,7 +87,7 @@ function showPlayback(playback) {
 }
 /** One region flag at most: being told to pick beats guessing which one wins. */
 function parseExportRegion(options) {
-    const chosen = [options.frame && "--frame", options.items && "--items", options.rect && "--rect"].filter(Boolean);
+    const chosen = [options.camera && "--camera", options.frame && "--frame", options.items && "--items", options.rect && "--rect"].filter(Boolean);
     if (chosen.length > 1)
         throw new Error(`Pick one region: ${chosen.join(", ")} cannot be combined.`);
     if (options.frame)
@@ -137,7 +138,9 @@ function registerExportCommand(boards) {
     withJson(boards.command("export <board>")
         .description("Render a Board to an image, or an animation to a frame sequence")
         .requiredOption("-o, --out <file>", "Output file; the extension picks the format. Sequences need %d, e.g. frames/%04d.png")
-        .option("--at <time>", "A moment (12.5s) or a range start:end:step (0:10s:100ms)")
+        .option("--at <time>", "A moment, comma-separated moments, or start:end:step")
+        .option("--camera", "Follow the animation camera")
+        .option("--size <widthxheight>", "Camera viewport in pixels", "1600x900")
         .option("--animation <id>", "Animation the --at times refer to")
         .option("--frame <item-id>", "Export one frame as a page")
         .option("--items <ids>", "Comma-separated item ids")
@@ -158,9 +161,25 @@ Examples:
   cohub boards export plan.board --animation lecture --at 4.5s -o moment.png
   cohub boards export plan.board --animation lecture --at 0:6s:40ms -o frames/%04d.png`)
         .action(async (target, options) => {
+        const controller = new AbortController();
+        const cancel = () => controller.abort(new Error("Export cancelled."));
+        process.once("SIGINT", cancel);
         try {
             const out = options.out;
             const times = options.at ? parseBoardTimes(options.at) : undefined;
+            let camera;
+            if (options.camera) {
+                if (!options.animation || !times)
+                    throw new Error("--camera needs --animation and --at.");
+                const size = /^(\d+)x(\d+)$/.exec(options.size ?? "1600x900");
+                if (!size?.[1] || !size[2])
+                    throw new Error("--size must be widthxheight, e.g. 1600x900.");
+                camera = { width: parseNumber(size[1], "width", { min: 1, max: 8192 }), height: parseNumber(size[2], "height", { min: 1, max: 8192 }) };
+            }
+            const progress = (completed, total) => {
+                if (!jsonRequested(options) && (completed === total || completed % 30 === 0))
+                    process.stderr.write(`Rendered ${completed}/${total} frames\n`);
+            };
             const pathVideoFormat = videoFormatFromPath(out);
             const requestedFormat = options.format?.toLowerCase();
             if (requestedFormat && ![...BOARD_EXPORT_FORMATS, ...BOARD_VIDEO_FORMATS].includes(requestedFormat))
@@ -183,6 +202,10 @@ Examples:
                 const result = await runBoardVideoExport({
                     spaceId: await resolveSpace(boards),
                     target,
+                    camera,
+                    onProgress: progress,
+                    signal: controller.signal,
+                    force: options.force,
                     region: parseExportRegion(options),
                     times,
                     ...(options.animation ? { animation: options.animation } : {}),
@@ -203,10 +226,25 @@ Examples:
                     console.log(`  ! ${warning}`);
                 return;
             }
+            const written = [];
+            for (let index = 0; index < (times?.length ?? 1); index++) {
+                const path = sequence ? framePath(out, index) : out;
+                if (!options.force && existsSync(path))
+                    throw new Error(`${path} already exists; use --force to replace it.`);
+            }
             const { runBoardExport } = await import("../board-export.js");
             const result = await runBoardExport({
                 spaceId: await resolveSpace(boards),
                 target,
+                camera,
+                onProgress: progress,
+                signal: controller.signal,
+                onFrame: async (frame, index) => {
+                    const path = sequence ? framePath(out, index) : out;
+                    await mkdir(dirname(path), { recursive: true });
+                    await writeBoardOutput(path, frame.bytes, Boolean(options.force));
+                    written.push({ path, time: frame.time, width: frame.width, height: frame.height, bytes: frame.bytes.length });
+                },
                 region: parseExportRegion(options),
                 ...(times ? { times } : {}),
                 ...(options.animation ? { animation: options.animation } : {}),
@@ -220,18 +258,11 @@ Examples:
             });
             if (!result)
                 return error("Nothing to export: the region contains no items.");
-            const written = [];
-            for (const [index, frame] of result.frames.entries()) {
-                const path = sequence ? framePath(out, index) : out;
-                await mkdir(dirname(path), { recursive: true });
-                await writeBoardOutput(path, frame.bytes, Boolean(options.force));
-                written.push({ path, time: frame.time, width: frame.width, height: frame.height, bytes: frame.bytes.length });
-            }
             if (jsonRequested(options))
                 return outJson({ files: written, warnings: result.warnings });
-            const first = result.frames[0];
+            const first = written[0];
             if (first) {
-                const what = sequence ? `${written.length} frames` : (first.format ?? "png").toUpperCase();
+                const what = sequence ? `${written.length} frames` : parseExportFormat(options, out).toUpperCase();
                 ok(`Exported ${first.width}×${first.height} ${what} to ${sequence ? dirname(out) || "." : out}`);
             }
             for (const warning of result.warnings)
@@ -240,6 +271,9 @@ Examples:
         catch (cause) {
             handleHttp(cause);
         }
+        finally {
+            process.removeListener("SIGINT", cancel);
+        }
     });
 }
 // ─── Commands ────────────────────────────────────────────────────────────────
@@ -460,6 +494,7 @@ Presets: ${BOARD_PRESET_NAMES.join(", ")}
     });
     registerBoardExampleCommands(boards);
     registerExportCommand(boards);
+    registerBoardAuthoringCommands(boards);
     registerPlaybackCommands(boards);
     withJson(boards.command("watch <board>")
         .description("Stream Board changes and playback as they happen"))

package/dist/commands/rooms.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from "commander";
+export declare function parseDuration(name: string, value: string): number;
+export declare function registerRooms(program: Command): void;

package/dist/commands/rooms.js

@@ -0,0 +1,232 @@
+import { getAppByRef } from "../app-ref.js";
+import { createClient } from "../client.js";
+import { error, handleHttp, json as outJson, jsonRequested, ok, table, truncateText } from "../output.js";
+const DURATION_RE = /^(\d+)(ms|s|m|h|d)?$/i;
+const DURATION_UNITS = { ms: 1, s: 1_000, m: 60_000, h: 3_600_000, d: 86_400_000 };
+export function parseDuration(name, value) {
+    const match = DURATION_RE.exec(value.trim());
+    if (!match)
+        return error(`Invalid ${name}`, "Use a duration such as 90s, 10m or 2h.");
+    return Number(match[1]) * (DURATION_UNITS[(match[2] ?? "s").toLowerCase()] ?? 1_000);
+}
+function seconds(name, value, range) {
+    const result = Math.round(parseDuration(name, value) / 1000);
+    if (result < range[0] || result > range[1]) {
+        return error(`Invalid ${name}`, `Use a duration from ${formatSeconds(range[0])} to ${formatSeconds(range[1])}.`);
+    }
+    return result;
+}
+const formatSeconds = (value) => (value % 3600 === 0 ? `${value / 3600}h` : value % 60 === 0 ? `${value / 60}m` : `${value}s`);
+const MINUTE = 60;
+const DAY = 24 * 60 * MINUTE;
+function parseJson(name, value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return error(`Invalid ${name}`, `${name} must be JSON, e.g. '{"text":"hi"}'.`);
+    }
+}
+async function readStdin() {
+    let input = "";
+    for await (const chunk of process.stdin)
+        input += chunk;
+    return input;
+}
+function parsePresence(value) {
+    const presence = parseJson("presence", value);
+    if (presence === null || (typeof presence === "object" && !Array.isArray(presence)))
+        return presence;
+    return error("Invalid presence", "presence must be a JSON object, or null to clear it.");
+}
+const short = (participantId) => participantId.slice(0, 8);
+function printMembers(view) {
+    table(view.members.map((member) => ({
+        member: `${short(member.participantId)}${member.participantId === view.participantId ? " (you)" : ""}`,
+        kind: member.kind ?? "user",
+        model: member.model?.id ?? "",
+        presence: member.presence ? truncateText(JSON.stringify(member.presence), 60) : "",
+    })), [
+        { key: "member", label: "Member" },
+        { key: "kind", label: "Kind" },
+        { key: "model", label: "Model" },
+        { key: "presence", label: "Presence" },
+    ]);
+}
+function printView(view) {
+    console.log(`Room ${view.room.code} · ${view.room.id}`);
+    console.log(`You are ${view.participantId} · sequence ${view.sequence} · expires ${view.room.expiresAt}\n`);
+    printMembers(view);
+}
+const formatEvent = (event) => `#${event.sequence} ${event.type} from ${event.self ? "you" : short(event.sender.participantId)} ${JSON.stringify(event.data)}`;
+function printEvents(roomId, page, options) {
+    if (page.truncated)
+        console.log("Some earlier events are no longer in the room history.");
+    if (page.events.length === 0)
+        console.log("No new events.");
+    for (const event of page.events)
+        console.log(formatEvent(event));
+    const filter = options.types.map((type) => ` --type '${type}'`).join("");
+    const wait = options.wait ? ` --wait ${options.wait}` : "";
+    console.log(`\nNext: cohub rooms events ${roomId} --after ${page.cursor}${filter}${wait}`);
+}
+const collect = (value, previous = []) => [...previous, value];
+async function withClient(run) {
+    try {
+        return await run(createClient());
+    }
+    catch (e) {
+        return handleHttp(e);
+    }
+}
+export function registerRooms(program) {
+    const rooms = program
+        .command("rooms")
+        .description("Take part in App rooms: join, read and publish events, set presence")
+        .addHelpText("after", `
+A room belongs to a published App. Join one with an invite from the App
+(room.invite()), or create one for an App you manage. Your seat stays while
+you use it and lapses after --idle without a call.
+
+An Agent waits for the room in a background command and wakes when it returns:
+  cohub rooms join <invite> --presence '{"name":"Guide"}'
+  cohub rooms events <room> --type 'chat.*' --wait 10m
+  cohub rooms publish <room> chat.message '{"text":"Hello"}'
+`);
+    rooms
+        .command("create")
+        .description("Create a room for an App you manage, with an invite and a link to it")
+        .requiredOption("--app <app>", "App: ID, URL, or username/space/app")
+        .option("--code <code>", "Room code people type or open with ?room=")
+        .option("--ttl <duration>", "Room lifetime, 1m to 24h (default 2h)")
+        .option("--max <count>", "Most members at once, 2 to 128 (default 16)")
+        .option("--seat-per-user", "Give each person one App seat across tabs")
+        .option("--json", "Output as JSON")
+        .action((opts) => withClient(async (client) => {
+        const app = await getAppByRef(client, opts.app);
+        const created = await client.rooms.create({
+            appId: app.app.id,
+            ...(opts.code ? { code: opts.code } : {}),
+            ...(opts.ttl ? { expiresInSeconds: seconds("ttl", opts.ttl, [MINUTE, DAY]) } : {}),
+            ...(opts.max ? { maxParticipants: Number(opts.max) } : {}),
+            ...(opts.seatPerUser ? { seatPerUser: true } : {}),
+        });
+        if (jsonRequested(opts))
+            return outJson(created);
+        console.log(`Room ${created.room.code} · ${created.room.id}`);
+        if (created.url)
+            console.log(`Open: ${created.url}`);
+        console.log(`Invite (until ${created.expiresAt}):\n${created.invite}\n`);
+        console.log(`Join: cohub rooms join <invite>`);
+    }));
+    rooms
+        .command("join <invite>")
+        .description("Take a seat in a room with an invite")
+        .option("--presence <json>", "What others see about you, e.g. '{\"name\":\"Guide\"}'")
+        .option("--idle <duration>", "Leave after this long without a call, 1m to 24h (default 30m)")
+        .option("--json", "Output as JSON")
+        .action((invite, opts) => withClient(async (client) => {
+        const view = await client.rooms.join({
+            invite,
+            ...(opts.presence !== undefined ? { presence: parsePresence(opts.presence) } : {}),
+            ...(opts.idle ? { idleSeconds: seconds("idle", opts.idle, [MINUTE, DAY]) } : {}),
+        });
+        if (jsonRequested(opts))
+            return outJson(view);
+        printView(view);
+        console.log(`\nWait for events: cohub rooms events ${view.room.id} --after ${view.sequence} --wait 10m`);
+    }));
+    rooms
+        .command("get <room>")
+        .description("Show the room, its members and your seat")
+        .option("--json", "Output as JSON")
+        .action((roomId, opts) => withClient(async (client) => {
+        const view = await client.rooms.get(roomId);
+        if (jsonRequested(opts))
+            return outJson(view);
+        printView(view);
+    }));
+    rooms
+        .command("events <room>")
+        .description("Read published events, oldest first; --wait holds until someone else publishes")
+        .option("--after <sequence>", "Only events after this sequence")
+        .option("--type <pattern>", "Event type to include, * matches any text; repeatable", collect)
+        .option("--wait <duration>", "Wait up to this long for a new event from someone else")
+        .option("--follow", "Keep printing events as they arrive")
+        .option("--limit <count>", "Most events to return")
+        .option("--json", "Output as JSON")
+        .action((roomId, opts) => withClient(async (client) => {
+        const types = opts.type ?? [];
+        const after = opts.after === undefined ? undefined : Number(opts.after);
+        if (after !== undefined && (!Number.isInteger(after) || after < 0))
+            return error("Invalid --after", "Use a sequence number.");
+        const limit = opts.limit === undefined ? undefined : Number(opts.limit);
+        if (opts.follow)
+            return follow(client, roomId, { after, types, json: jsonRequested(opts) });
+        const page = await client.rooms.events(roomId, {
+            after,
+            types,
+            ...(limit ? { limit } : {}),
+            ...(opts.wait ? { waitMs: parseDuration("wait", opts.wait) } : {}),
+        });
+        if (jsonRequested(opts))
+            return outJson(page);
+        printEvents(roomId, page, { types, wait: opts.wait });
+    }));
+    rooms
+        .command("publish <room> <type> [data]")
+        .description("Publish an event to everyone in the room; data is JSON, or - for stdin")
+        .option("--json", "Output as JSON")
+        .action((roomId, type, data, opts) => withClient(async (client) => {
+        const payload = data === undefined ? null : parseJson("data", data === "-" ? await readStdin() : data);
+        const result = await client.rooms.publish(roomId, type, payload);
+        if (jsonRequested(opts))
+            return outJson(result);
+        ok(`Published #${result.sequence} ${type}`);
+    }));
+    rooms
+        .command("presence <room> <json>")
+        .description("Set what others see about you; null clears it")
+        .option("--json", "Output as JSON")
+        .action((roomId, value, opts) => withClient(async (client) => {
+        const result = await client.rooms.setPresence(roomId, parsePresence(value));
+        if (jsonRequested(opts))
+            return outJson(result);
+        ok("Presence updated");
+    }));
+    rooms
+        .command("invite <room>")
+        .description("Create an invite to a room you are in")
+        .option("--ttl <duration>", "How long the invite admits people (default 10m)")
+        .option("--json", "Output as JSON")
+        .action((roomId, opts) => withClient(async (client) => {
+        const invite = await client.rooms.invite(roomId, opts.ttl ? { expiresInSeconds: seconds("ttl", opts.ttl, [MINUTE, DAY]) } : {});
+        if (jsonRequested(opts))
+            return outJson(invite);
+        console.log(`Invite (until ${invite.expiresAt}):\n${invite.invite}`);
+    }));
+    rooms
+        .command("leave <room>")
+        .description("Give up your seat")
+        .option("--json", "Output as JSON")
+        .action((roomId, opts) => withClient(async (client) => {
+        const result = await client.rooms.leave(roomId);
+        if (jsonRequested(opts))
+            return outJson(result);
+        ok(result.left ? "Left the room" : "You were not in this room");
+    }));
+}
+async function follow(client, roomId, input) {
+    const controller = new AbortController();
+    process.once("SIGINT", () => controller.abort());
+    let after = input.after ?? (await client.rooms.get(roomId)).sequence;
+    while (!controller.signal.aborted) {
+        const page = await client.rooms.events(roomId, { after, types: input.types, waitMs: 25_000, signal: controller.signal })
+            .catch((e) => (controller.signal.aborted ? null : Promise.reject(e)));
+        if (!page)
+            break;
+        for (const event of page.events)
+            console.log(input.json ? JSON.stringify(event) : formatEvent(event));
+        after = page.cursor;
+    }
+}

package/dist/index.js

@@ -21,6 +21,7 @@ import { registerRuntime } from "./commands/runtime.js";
 import { registerTasks } from "./commands/tasks.js";
 import { registerDesktop, registerLegacyUi } from "./commands/desktop.js";
 import { registerApps } from "./commands/apps.js";
+import { registerRooms } from "./commands/rooms.js";
 import { formatUnknownCommandError, resolveHelpPath } from "./help-path.js";
 const VERSION = (() => {
     try {
@@ -63,6 +64,7 @@ Common commands:
   cohub -s <space-id> public upload ./dist demo
   cohub -s <space-id> apps publish demo --file dist/index.html
   cohub desktop open <app-id> --call selection.get
+  cohub rooms join <invite>
   cohub -s <space-id> spaces commerce products list
   cohub models ls
   cohub models ls --model-type multimodal
@@ -100,6 +102,7 @@ registerReferrals(program);
 registerTasks(program);
 registerCronJobs(program);
 registerApps(program);
+registerRooms(program);
 registerDesktop(program);
 registerLegacyUi(program);
 const argv = process.argv.slice(2);

package/dist/runtime/model-catalog.d.ts

@@ -9,6 +9,6 @@ type Model = RuntimeCapabilities["models"][number];
  * to the picker's rule, and Cohub always sends the chosen level explicitly.
  */
 export declare function piModelCatalog(entries: unknown[], state: JsonRecord): Model[];
-/** Codex's built-in catalog is not authoritative for an arbitrary custom provider. */
+/** Use Codex's picker-visible model/list for every provider, including custom providers. */
 export declare function codexModelCatalog(configResponse: JsonRecord, entries: unknown[]): Model[];
 export {};

package/dist/runtime/model-catalog.js

@@ -45,14 +45,12 @@ function codexThinking(model, configuredEffort) {
         ...(defaultThinkingLevel ? { defaultThinkingLevel } : {}),
     };
 }
-/** Codex's built-in catalog is not authoritative for an arbitrary custom provider. */
+/** Use Codex's picker-visible model/list for every provider, including custom providers. */
 export function codexModelCatalog(configResponse, entries) {
     const config = record(configResponse.config);
     const provider = typeof config.model_provider === "string" ? config.model_provider : "openai";
     const configuredModel = typeof config.model === "string" ? config.model : null;
-    const customCatalog = typeof config.model_catalog_json === "string";
-    const catalog = provider !== "openai" && !customCatalog ? [] : entries;
-    const models = catalog.flatMap((value) => {
+    const models = entries.flatMap((value) => {
         const model = record(value);
         const id = typeof model.model === "string" ? model.model : typeof model.id === "string" ? model.id : null;
         if (!id || model.hidden)

package/dist/safe-remote-image.d.ts

@@ -25,4 +25,8 @@ export declare function downloadPublicImage(input: string, options?: RemoteImage
     bytes: Uint8Array;
     mimeType: string;
 }>;
+export declare function downloadPublicAudio(input: string, options?: RemoteImageDownloadOptions): Promise<{
+    bytes: Uint8Array;
+    mimeType: string;
+}>;
 export {};