@neta-art/cohub-cli 10.8.3 → 10.11.0

package/dist/board-media.d.ts

@@ -0,0 +1,4 @@
+import { type BoardDocument, type BoardMediaFileResolver } from "@neta-art/cohub/board";
+export declare function boardMediaFileResolver(spaceId: string): BoardMediaFileResolver;
+export declare function settleBoardDocument(spaceId: string, document: BoardDocument): Promise<BoardDocument>;
+export declare function settleBoardPatch<T extends Record<string, unknown>>(spaceId: string, patch: T, current: (ids: string[]) => Promise<Record<string, unknown> | null>): Promise<T>;

package/dist/board-media.js

@@ -0,0 +1,63 @@
+import { execFile } from "node:child_process";
+import { resolve } from "node:path";
+import { promisify } from "node:util";
+import { diffMergePatch, mergePatch, parseBoardItem, settleBoardMediaSizes, } from "@neta-art/cohub/board";
+import { createClient } from "./client.js";
+import { WORKSPACE_ROOT } from "./space-files/operands.js";
+const run = promisify(execFile);
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const oriented = (width, height, turned) => width > 0 && height > 0 ? (turned ? { width: height, height: width } : { width, height }) : null;
+async function localMediaSize(file, type, signal) {
+    try {
+        if (type === "image") {
+            const { default: sharp } = await import("sharp");
+            const { width = 0, height = 0, orientation = 1 } = await sharp(file).metadata();
+            return oriented(width, height, orientation >= 5);
+        }
+        const { stdout } = await run("ffprobe", [
+            "-v", "error", "-select_streams", "v:0",
+            "-show_entries", "stream=width,height:stream_side_data=rotation", "-of", "json", file,
+        ], { signal, timeout: 5_000 });
+        const stream = JSON.parse(stdout).streams?.[0];
+        const rotation = stream?.side_data_list?.find((data) => data.rotation !== undefined)?.rotation ?? 0;
+        return oriented(stream?.width ?? 0, stream?.height ?? 0, Math.abs(rotation) % 180 === 90);
+    }
+    catch {
+        return null;
+    }
+}
+export function boardMediaFileResolver(spaceId) {
+    const local = process.env.COHUB_SPACE_ID === spaceId;
+    return async (path, type, signal) => {
+        const file = resolve(WORKSPACE_ROOT, path);
+        const size = local && file.startsWith(`${WORKSPACE_ROOT}/`) ? await localMediaSize(file, type, signal) : null;
+        return size ?? createClient().space(spaceId).files.resolveUrl(path, { purpose: "playback", signal }).catch(() => null);
+    };
+}
+export async function settleBoardDocument(spaceId, document) {
+    const settled = await settleBoardMediaSizes(document.items, { resolveFile: boardMediaFileResolver(spaceId) });
+    return Object.keys(settled).length ? { ...document, items: { ...document.items, ...settled } } : document;
+}
+export async function settleBoardPatch(spaceId, patch, current) {
+    const items = isRecord(patch.items) ? patch.items : {};
+    const created = {};
+    for (const [id, value] of Object.entries(items)) {
+        if (!isRecord(value) || (value.type !== "image" && value.type !== "video"))
+            continue;
+        const parsed = parseBoardItem(value, `items.${id}`);
+        if (parsed.ok)
+            created[id] = parsed.item;
+    }
+    const existing = Object.keys(created).length ? await current(Object.keys(created)) : null;
+    if (!existing)
+        return patch;
+    for (const [id, item] of Object.entries(existing)) {
+        if (isRecord(item) && item.type === created[id]?.type)
+            delete created[id];
+    }
+    const settled = await settleBoardMediaSizes(created, { resolveFile: boardMediaFileResolver(spaceId) });
+    if (!Object.keys(settled).length)
+        return patch;
+    const adopted = Object.entries(settled).map(([id, item]) => [id, mergePatch(items[id], diffMergePatch(created[id], item))]);
+    return { ...patch, items: { ...items, ...Object.fromEntries(adopted) } };
+}

package/dist/commands/boards/authoring.js

@@ -1,5 +1,6 @@
 import { readBoardJsonObject } from "../../board-command-support.js";
 import { loadBoardDocument, resolveBundledFonts } from "../../board-export.js";
+import { settleBoardDocument } from "../../board-media.js";
 import { boardPathTrack, boardSequencePatch, buildBoardScene, createBoardAnimationSampler, createNodeBoardRenderer, inspectBoardItems, } from "../../board-kernel.js";
 import { parseBoardTimes } from "../../board-time.js";
 import { handleHttp, json as outJson } from "../../output.js";
@@ -19,7 +20,8 @@ Checks native layout only, not camera cropping or content drawn inside scripts.
 Example: cohub boards inspect lesson.board --animation lecture --at 0:20s:1s --json`)
         .action(async (target, options) => {
         try {
-            const { document } = await loadBoardDocument(await resolveSpace(boards), target);
+            const spaceId = await resolveSpace(boards);
+            const document = await settleBoardDocument(spaceId, (await loadBoardDocument(spaceId, target)).document);
             const times = parseBoardTimes(options.at, "--at", 100);
             const sampler = options.animation ? createBoardAnimationSampler(document, options.animation) : null;
             const renderer = await createNodeBoardRenderer({ fonts: resolveBundledFonts() });

package/dist/commands/boards.js

@@ -2,9 +2,10 @@ import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
 import { mkdir } from "node:fs/promises";
 import { dirname } from "node:path";
-import { BOARD_PRESET_NAMES, BOARD_SCHEMA_TARGETS, BOARD_SCRIPT_API, boardJsonSchema, boardPresetTracks, boardSchemaOverview, isBoardPresetName, listBoardPresets, } from "@neta-art/cohub/board";
-import { BOARD_CREATE_INPUT_MAX_BYTES, BOARD_TRANSACTION_INPUT_MAX_BYTES, parseBoardJsonObject, readBoardJsonObject, resolveBoardId, writeBoardOutput, } from "../board-command-support.js";
+import { BOARD_PRESET_NAMES, BOARD_SCHEMA_TARGETS, BOARD_SCRIPT_API, BOARD_THEME_IDS, boardJsonSchema, boardPresetTracks, boardSchemaOverview, isBoardPresetName, listBoardPresets, } from "@neta-art/cohub/board";
+import { BOARD_CREATE_INPUT_MAX_BYTES, BOARD_TRANSACTION_INPUT_MAX_BYTES, parseBoardJsonObject, readBoardJsonObject, writeBoardOutput, } from "../board-command-support.js";
 import { BOARD_EXPORT_IMAGE_MEMORY_MIB } from "../board-export-resources.js";
+import { settleBoardPatch } from "../board-media.js";
 import { formatBoardTime, parseBoardTime, parseBoardTimes } from "../board-time.js";
 import { createClient, createRealtimeClient } from "../client.js";
 import { error, handleHttp, json as outJson, jsonRequested, ok, table } from "../output.js";
@@ -52,9 +53,9 @@ function list(value) {
     const entries = value?.split(",").map((entry) => entry.trim()).filter(Boolean);
     return entries?.length ? entries : undefined;
 }
-async function boardClient(boards, target) {
-    const spaceId = await resolveSpace(boards);
-    return createClient().space(spaceId).board(await resolveBoardId(spaceId, target));
+async function boardClient(boards, target, spaceId) {
+    spaceId ??= await resolveSpace(boards);
+    return createClient().space(spaceId).boards.open(target);
 }
 /** A patch from an inline argument, a file, or stdin (`-`). */
 async function readPatch(inline, input, maxBytes) {
@@ -158,7 +159,7 @@ function registerExportCommand(boards) {
         .option("--rect <rect>", "World rect as x,y,width,height")
         .option("--scale <factor>", "Output pixels per board unit", "2")
         .option("--padding <units>", "Padding around the content in board units")
-        .option("--theme <mode>", "dark or light", "dark")
+        .option("--theme <name>", `Cohub theme: ${BOARD_THEME_IDS.join(", ")}`, "dark")
         .option("--paper <mode>", "Output paper: paper or transparent", "paper")
         .option("--format <format>", `Override the format (${BOARD_EXPORT_FORMATS.join(", ")}, ${BOARD_VIDEO_FORMATS.join(", ")})`)
         .option("--quality <q>", "JPEG/WebP quality from 0 to 1", "0.92")
@@ -230,7 +231,7 @@ Examples:
                     ...(options.animation ? { animation: options.animation } : {}),
                     scale: parseNumber(options.scale ?? "2", "--scale", { min: 0.01, max: 16 }),
                     ...(options.padding === undefined ? {} : { padding: parseNumber(options.padding, "--padding", { min: 0 }) }),
-                    colorScheme: parseChoice(options.theme, "--theme", ["dark", "light"]),
+                    theme: parseChoice(options.theme, "--theme", BOARD_THEME_IDS),
                     background: parseChoice(options.paper, "--paper", ["paper", "transparent"]),
                     format: videoFormat,
                     fps,
@@ -271,7 +272,7 @@ Examples:
                 ...(options.animation ? { animation: options.animation } : {}),
                 scale: parseNumber(options.scale ?? "2", "--scale", { min: 0.01, max: 16 }),
                 ...(options.padding === undefined ? {} : { padding: parseNumber(options.padding, "--padding", { min: 0 }) }),
-                colorScheme: parseChoice(options.theme, "--theme", ["dark", "light"]),
+                theme: parseChoice(options.theme, "--theme", BOARD_THEME_IDS),
                 background: parseChoice(options.paper, "--paper", ["paper", "transparent"]),
                 format: parseExportFormat(options, out),
                 quality: parseNumber(options.quality ?? "0.92", "--quality", { min: 0, max: 1 }),
@@ -327,14 +328,16 @@ Times are milliseconds; 500ms, 12.5s and 2m also work on the command line.`);
   cohub boards create lesson.board -i lesson.json`)
         .action(async (path, options) => {
         try {
-            const document = options.input ? await readBoardJsonObject(options.input, BOARD_CREATE_INPUT_MAX_BYTES) : undefined;
+            const spaceId = await resolveSpace(boards);
+            const read = options.input ? await readBoardJsonObject(options.input, BOARD_CREATE_INPUT_MAX_BYTES) : undefined;
+            const document = read && await settleBoardPatch(spaceId, read, async () => ({}));
             const input = {
                 path,
                 mutationId: options.mutationId ?? randomUUID(),
                 ...(options.title ? { title: options.title } : {}),
                 ...(document ? { document: document } : {}),
             };
-            const result = await createClient().space(await resolveSpace(boards)).boards.create(input);
+            const result = await createClient().space(spaceId).boards.create(input);
             if (jsonRequested(options))
                 return outJson({ path, id: result.id, title: result.title, version: result.version });
             ok(`Created ${path}`);
@@ -411,8 +414,11 @@ Times are milliseconds; 500ms, 12.5s and 2m also work on the command line.`);
   cohub boards preset rise --targets a,b --animation intro | cohub boards apply plan.board -i -`)
         .action(async (target, inline, options) => {
         try {
-            const patch = await readPatch(inline, options.input, BOARD_TRANSACTION_INPUT_MAX_BYTES);
-            const result = await (await boardClient(boards, target)).apply(patch, {
+            const spaceId = await resolveSpace(boards);
+            const board = await boardClient(boards, target, spaceId);
+            const read = await readPatch(inline, options.input, BOARD_TRANSACTION_INPUT_MAX_BYTES);
+            const patch = await settleBoardPatch(spaceId, read, async (items) => options.replace ? {} : board.get({ only: ["items"], items }).then((result) => result.items ?? {}, () => null));
+            const result = await board.apply(patch, {
                 ...(options.replace ? { replace: true } : {}),
                 ...(options.cascade ? { cascade: true } : {}),
                 ...(options.dryRun ? { dryRun: true } : {}),
@@ -532,9 +538,9 @@ Presets: ${BOARD_PRESET_NAMES.join(", ")}
         .action(async (target, options) => {
         try {
             const spaceId = await resolveSpace(boards);
-            const boardId = await resolveBoardId(spaceId, target);
             const client = createRealtimeClient();
-            const board = client.space(spaceId).board(boardId);
+            const board = await client.space(spaceId).boards.open(target);
+            const boardId = board.id;
             if (!jsonRequested(options))
                 process.stderr.write(`Watching Board ${boardId}…\n`);
             const offConnection = client.onConnection((state) => {

package/dist/commands/feedback.d.ts

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

package/dist/commands/feedback.js

@@ -0,0 +1,129 @@
+import { openAsBlob } from "node:fs";
+import { stat } from "node:fs/promises";
+import { arch, platform, release } from "node:os";
+import { basename, resolve } from "node:path";
+import { mimeTypeForPath, readRequestSourceFromEnv, resolveApiBaseUrl, resolveCohubEnvironment } from "@neta-art/cohub";
+import { authSource } from "../auth.js";
+import { createClient } from "../client.js";
+import { collectOption, readPromptContent } from "../command-input.js";
+import { describeError } from "../network-error.js";
+import { error, json as outJson, jsonRequested, spinner } from "../output.js";
+import { readRuntimeDiagnosticEvents } from "../runtime/diagnostics.js";
+import { resolveRuntimeTarget } from "../runtime/launch.js";
+import { runtimeStateRoot } from "../runtime/native/config.js";
+import { explicitSpace } from "../space.js";
+// Shared with the web feedback dialog; cfeed enforces attachment limits server-side.
+const CFEED_ENDPOINT = "https://cfeed.neta.art/api/v1/feedback";
+const CFEED_APP = "cohub";
+const RUNTIME_LOG_MAX_BYTES = 5 * 1024 * 1024;
+const RUNTIME_LOG_EVENTS = 2_000;
+const USER_LOOKUP_TIMEOUT_MS = 3_000;
+const SUBMIT_TIMEOUT_MS = 120_000;
+async function readAttachment(path) {
+    const absolute = resolve(path);
+    const info = await stat(absolute).catch(() => null);
+    if (!info?.isFile())
+        return error(`Cannot attach ${path}`, "Pass a path to an existing file");
+    const type = mimeTypeForPath(absolute) ?? "application/octet-stream";
+    return new File([await openAsBlob(absolute, { type })], basename(absolute), { type });
+}
+async function runtimeLogFile(program, now) {
+    const spaceId = await resolveRuntimeTarget(program).catch((cause) => error("Cannot attach Runtime logs", describeError(cause)));
+    let events = await readRuntimeDiagnosticEvents(runtimeStateRoot(spaceId), { limit: RUNTIME_LOG_EVENTS });
+    let dropped = 0;
+    let text = JSON.stringify({ spaceId, dropped, events });
+    // Keep the newest events when the log exceeds the budget.
+    while (Buffer.byteLength(text) > RUNTIME_LOG_MAX_BYTES && events.length > 0) {
+        const count = Math.ceil(events.length / 2);
+        events = events.slice(count);
+        dropped += count;
+        text = JSON.stringify({ spaceId, dropped, events });
+    }
+    const stamp = now.toISOString().replace(/[-:]/g, "").replace(/\..+$/, "");
+    return new File([text], `cohub-runtime-${stamp}.json`, { type: "application/json" });
+}
+async function currentUserUuid() {
+    if (!authSource())
+        return null;
+    let timer;
+    const timeout = new Promise((done) => { timer = setTimeout(() => done(null), USER_LOOKUP_TIMEOUT_MS); });
+    const lookup = createClient().user.getMe().then((user) => user.uuid ?? null, () => null);
+    try {
+        return await Promise.race([lookup, timeout]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+async function submitFeedback(content, extra, files) {
+    const body = new FormData();
+    body.set("app", CFEED_APP);
+    body.set("content", content);
+    body.set("extra", JSON.stringify(extra));
+    for (const file of files)
+        body.append("files", file, file.name);
+    const response = await fetch(CFEED_ENDPOINT, { method: "POST", body, signal: AbortSignal.timeout(SUBMIT_TIMEOUT_MS) });
+    const payload = (await response.json().catch(() => null));
+    if (!response.ok)
+        throw new Error(payload?.error?.message ?? `${response.status} ${response.statusText}`);
+    if (!payload)
+        throw new Error("Feedback service returned an empty response");
+    return payload;
+}
+export function registerFeedback(program) {
+    program
+        .command("feedback [message...]")
+        .description("Send feedback or a bug report to the Cohub team")
+        .option("-f, --file <path>", "Attach a file; repeatable", collectOption, [])
+        .option("--runtime-logs", "Attach recent local Runtime diagnostics for the target Space")
+        .option("--json", "Output as JSON")
+        .addHelpText("after", `
+The message comes from arguments or stdin. CLI version, OS, environment, account,
+and COHUB_* Space/Chat context are attached automatically; your working directory is not.
+
+Examples:
+  $ cohub feedback "runtime up hangs after sign-in"
+  $ cohub feedback "Board export is blurry" -f board.png -f export.log
+  $ cohub feedback --runtime-logs "Codex chats stopped syncing"
+  $ cat report.md | cohub feedback`)
+        .action(async (words, opts) => {
+        const asJson = jsonRequested(opts);
+        const content = await readPromptContent(words);
+        const now = new Date();
+        const [files, userUuid] = await Promise.all([
+            Promise.all([
+                ...opts.file.map(readAttachment),
+                ...(opts.runtimeLogs ? [runtimeLogFile(program, now)] : []),
+            ]),
+            currentUserUuid(),
+        ]);
+        const extra = {
+            user_uuid: userUuid,
+            cli_version: program.version() ?? null,
+            node: process.versions.node,
+            os: `${platform()} ${release()}`,
+            arch: arch(),
+            env: resolveCohubEnvironment(),
+            api_base_url: resolveApiBaseUrl(),
+            space: explicitSpace(program),
+            source: readRequestSourceFromEnv(process.env, { via: "cli" }),
+            locale: Intl.DateTimeFormat().resolvedOptions().locale,
+            timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+            tty: Boolean(process.stdout.isTTY),
+            has_runtime_logs: Boolean(opts.runtimeLogs),
+        };
+        const sp = asJson ? null : spinner();
+        sp?.start("Sending feedback");
+        try {
+            const result = await submitFeedback(content, extra, files);
+            if (asJson)
+                return outJson(result);
+            sp?.stop(`Feedback sent · ${result.id}`);
+        }
+        catch (cause) {
+            if (sp)
+                process.stderr.write("\n");
+            error("Couldn't send feedback", describeError(cause));
+        }
+    });
+}

package/dist/index.js

@@ -6,6 +6,7 @@ import { registerAuth } from "./commands/auth.js";
 import { registerBoards } from "./commands/boards.js";
 import { registerChannels } from "./commands/channels.js";
 import { registerCronJobs } from "./commands/cron-jobs.js";
+import { registerFeedback } from "./commands/feedback.js";
 import { registerGenerations } from "./commands/generations.js";
 import { registerMe } from "./commands/me.js";
 import { registerModels } from "./commands/models.js";
@@ -71,6 +72,7 @@ Common commands:
   cohub models ls
   cohub models ls --model-type multimodal
   cohub generate "A calm lake at sunrise" --model <model> --output lake.png
+  cohub feedback "Describe the problem" -f screenshot.png
 
 Target space:
   -s <space>, then COHUB_SPACE_ID, then the current directory Runtime binding.
@@ -108,6 +110,7 @@ registerTasks(program);
 registerCronJobs(program);
 registerApps(program);
 registerRooms(program);
+registerFeedback(program);
 registerDesktop(program);
 registerLegacyUi(program);
 const argv = process.argv.slice(2);

package/dist/runtime/supervisor.js

@@ -90,6 +90,7 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
     };
     let closeInstance;
     let bridgeTask;
+    let retryDisconnectedBridge;
     let nativeStarted = false;
     let tokenInFlight = null;
     const token = (forceRefresh = false) => {
@@ -139,6 +140,9 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
                 let probeTimer;
                 let managed = false;
                 let childStopped = false;
+                let bridgeDisconnected = false;
+                let terminating = false;
+                let recoveryTimer;
                 let controlPipe = null;
                 try {
                     const initialToken = await token();
@@ -156,6 +160,8 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
                         bridge.once("error", (error) => diagnostics.log("error", "sandboxd.process_error", { error: serializeDiagnosticError(error) }));
                         bridge.once("exit", (code, exitSignal) => {
                             childStopped = true;
+                            clearTimeout(recoveryTimer);
+                            recoveryTimer = undefined;
                             if (!signal.aborted)
                                 diagnostics.log("warn", "sandboxd.process_exit", { code, signal: exitSignal });
                             // Descendants may still hold inherited pipes. After draining buffered
@@ -198,8 +204,10 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
                                 managed = true;
                             if (event.type === "connected" || event.type === "disconnected") {
                                 const connected = event.type === "connected";
+                                bridgeDisconnected = !connected;
                                 update({ workspaceConnected: connected });
                                 diagnostics.log(connected ? "info" : "warn", `sandboxd.${event.type}`);
+                                retryDisconnectedBridge?.();
                             }
                         }
                         catch {
@@ -238,6 +246,11 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
                     };
                     probeTimer = setTimeout(() => void probe(), 1000);
                     const terminate = () => {
+                        if (terminating || childStopped)
+                            return;
+                        terminating = true;
+                        clearTimeout(recoveryTimer);
+                        recoveryTimer = undefined;
                         // Windows has no SIGTERM; closing the managed stdin lets sandboxd stop gracefully.
                         if (process.platform === "win32")
                             bridge.stdin?.end();
@@ -246,6 +259,26 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
                         const timeout = setTimeout(() => bridge.kill("SIGKILL"), 3000);
                         void closed.finally(() => clearTimeout(timeout));
                     };
+                    // A managed bridge may be sleeping for five minutes after a lease
+                    // rejection. Retry only after it reports a lost connection and the
+                    // Harness has regained its lease; a connected bridge stays untouched.
+                    retryDisconnectedBridge = () => {
+                        if (signal.aborted || !status.harnessConnected || !bridgeDisconnected || terminating || childStopped) {
+                            clearTimeout(recoveryTimer);
+                            recoveryTimer = undefined;
+                        }
+                        else if (!recoveryTimer) {
+                            // Give the bridge its normal retry and channel reattachment
+                            // window before replacing a process stuck in config backoff.
+                            recoveryTimer = setTimeout(() => {
+                                recoveryTimer = undefined;
+                                if (!signal.aborted && status.harnessConnected && bridgeDisconnected && !terminating && !childStopped) {
+                                    diagnostics.log("info", "sandboxd.lease_recovery");
+                                    terminate();
+                                }
+                            }, 30_000);
+                        }
+                    };
                     signal.addEventListener("abort", terminate, { once: true });
                     if (signal.aborted)
                         terminate();
@@ -257,10 +290,12 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
                         diagnostics.log("warn", "sandboxd.restart_failed", { error: serializeDiagnosticError(error) });
                 }
                 finally {
+                    retryDisconnectedBridge = undefined;
                     childStopped = true;
                     controlPipe?.close();
                     clearTimeout(refreshTimer);
                     clearTimeout(probeTimer);
+                    clearTimeout(recoveryTimer);
                     update({ workspaceConnected: false });
                 }
                 if (Date.now() - startedAt > 60_000)
@@ -276,8 +311,8 @@ export async function runRuntime(config, onState, externalSignal, onDiagnostic)
         await serveRuntime({
             spaceId: config.spaceId, cwd: config.root, url: url.toString(), capabilities,
             runtimeId: status.runtimeId, diagnostics, token, signal, executor: native.executor,
-            onReady: () => update({ harnessConnected: true }),
-            onDisconnected: () => { native.connect(null); update({ harnessConnected: false }); },
+            onReady: () => { update({ harnessConnected: true }); retryDisconnectedBridge?.(); },
+            onDisconnected: () => { native.connect(null); update({ harnessConnected: false }); retryDisconnectedBridge?.(); },
             onNativeStop: (stop) => { native.stop(stop.sessionId, stop.turnId); },
             onNativeChannel: (send) => {
                 native.connect(send);

package/dist/space-files/operands.d.ts

@@ -11,6 +11,7 @@ export type FileOperand = SpaceOperand | LocalOperand;
 export declare class InvalidFileOperandError extends Error {
     name: string;
 }
+export declare const WORKSPACE_ROOT = "/workspace";
 export declare function normalizeSpacePath(raw: string): string;
 export declare function parseSpaceFileOperand(raw: string): SpaceOperand;
 export declare function parseCopyOperand(raw: string, currentSpaceDeclared: boolean): FileOperand;

package/dist/space-files/operands.js

@@ -3,7 +3,7 @@ import { parseSpaceRef } from "@neta-art/cohub";
 export class InvalidFileOperandError extends Error {
     name = "InvalidFileOperandError";
 }
-const WORKSPACE_ROOT = "/workspace";
+export const WORKSPACE_ROOT = "/workspace";
 const isWorkspacePath = (path) => path === WORKSPACE_ROOT || path.startsWith(`${WORKSPACE_ROOT}/`);
 export function normalizeSpacePath(raw) {
     let path = raw.trim();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "10.8.3",
+  "version": "10.11.0",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "engines": {
@@ -18,7 +18,7 @@
     "NOTICE"
   ],
   "dependencies": {
-    "@neta-art/cohub": "12.1.1",
+    "@neta-art/cohub": "12.3.0",
     "@neta-art/generation": "^0.1.40",
     "commander": "^15.0.0",
     "sharp": "^0.35.4",
@@ -28,8 +28,9 @@
     "access": "public"
   },
   "devDependencies": {
-    "@fontsource/geist": "^5.3.0",
-    "@fontsource/geist-mono": "^5.3.0",
+    "@fontsource-variable/figtree": "^5.3.0",
+    "@fontsource-variable/geist": "^5.3.0",
+    "@fontsource-variable/geist-mono": "^5.3.0",
     "@types/node": "26.6.4",
     "@types/ws": "^8.18.1",
     "pixi.js": "^8.20.1",
@@ -37,7 +38,7 @@
     "typescript": "^7.0.2"
   },
   "optionalDependencies": {
-    "@napi-rs/canvas": "^1.0.8"
+    "@napi-rs/canvas": "^1.0.13"
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json && tsdown",