@neta-art/cohub-cli 4.0.0 → 6.0.0

package/dist/commands/boards.js

@@ -1,15 +1,11 @@
 import { randomUUID } from "node:crypto";
-import { BOARD_CREATE_INPUT_MAX_BYTES, BOARD_TRANSACTION_INPUT_MAX_BYTES, parseBoardJsonObject, readBoardJsonObject, resolveBoardId, writeBoardOutput, } from "../board-command-support.js";
+import { BOARD_CREATE_INPUT_MAX_BYTES, parseBoardJsonObject, readBoardJsonObject, resolveBoardId, writeBoardOutput, } from "../board-command-support.js";
 import { BOARD_EXPORT_FORMATS, formatFromPath, runBoardExport } from "../board-export.js";
 import { registerBoardDomainCommands } from "./board-domain.js";
 import { createClient, createRealtimeClient } from "../client.js";
 import { error, handleHttp, json as outJson, jsonRequested, ok, table } from "../output.js";
 import { resolveSpace } from "../space.js";
-const INSPECT_SECTIONS = ["nodes", "connections", "effects", "compositions", "playback"];
 export const parseJsonObject = parseBoardJsonObject;
-export async function readJsonObject(source, maxBytes = BOARD_TRANSACTION_INPUT_MAX_BYTES) {
-    return readBoardJsonObject(source, maxBytes);
-}
 function parseNumber(value, name, options = {}) {
     if (!value.trim())
         throw new Error(`${name} must be a finite number`);
@@ -24,15 +20,6 @@ function parseNumber(value, name, options = {}) {
         throw new Error(`${name} must be at most ${options.max}`);
     return parsed;
 }
-export function parseInspectSections(value) {
-    if (!value)
-        return undefined;
-    const sections = value.split(",").map((item) => item.trim()).filter(Boolean);
-    const unknown = sections.filter((section) => !INSPECT_SECTIONS.includes(section));
-    if (unknown.length > 0)
-        throw new Error(`Unknown Board section: ${unknown.join(", ")}`);
-    return [...new Set(sections)];
-}
 export function parseViewport(value) {
     if (!value)
         return undefined;
@@ -51,45 +38,11 @@ export function parseViewport(value) {
         throw new Error("viewport width and height must be greater than zero");
     return { x, y, width, height };
 }
-export function createTransactionInput(input, options) {
-    if ("boardId" in input)
-        throw new Error("transaction input must not contain boardId");
-    if (!Array.isArray(input.operations))
-        throw new Error("transaction input must contain an operations array");
-    const rawBaseVersion = options.baseVersion ?? input.baseVersion;
-    if (rawBaseVersion === undefined)
-        throw new Error("baseVersion is required in input or --base-version");
-    const baseVersion = parseNumber(String(rawBaseVersion), "baseVersion", { min: 0, integer: true });
-    const rawTxId = options.txId ?? input.txId;
-    if (rawTxId !== undefined && (typeof rawTxId !== "string" || !rawTxId.trim())) {
-        throw new Error("txId must be a non-empty string");
-    }
-    return {
-        ...input,
-        txId: typeof rawTxId === "string" ? rawTxId : randomUUID(),
-        baseVersion,
-        operations: input.operations,
-    };
-}
-function showBoard(result) {
-    table([
-        {
-            id: result.board.id,
-            title: result.board.title,
-            version: result.board.version,
-            nodes: result.nodes.length,
-            connections: result.connections.length,
-            effects: result.effects.length,
-            compositions: result.compositions.length,
-        },
-    ], [
+function showCreated(result) {
+    table([result.board], [
         { key: "id", label: "ID" },
         { key: "title", label: "Title" },
         { key: "version", label: "Version" },
-        { key: "nodes", label: "Nodes" },
-        { key: "connections", label: "Connections" },
-        { key: "effects", label: "Effects" },
-        { key: "compositions", label: "Compositions" },
     ]);
 }
 function showSummary(result) {
@@ -105,7 +58,7 @@ function showSummary(result) {
         { key: "id", label: "ID" },
         { key: "title", label: "TITLE" },
         { key: "version", label: "VERSION" },
-        { key: "nodes", label: "NODES" },
+        { key: "items", label: "ITEMS" },
         { key: "connections", label: "CONNECTIONS" },
         { key: "effects", label: "EFFECTS" },
         { key: "compositions", label: "COMPOSITIONS" },
@@ -113,23 +66,6 @@ function showSummary(result) {
         { key: "updatedAt", label: "UPDATED" },
     ]);
 }
-function showValidation(result) {
-    table([{ valid: result.valid, diagnostics: result.diagnostics.length }], [
-        { key: "valid", label: "Valid" },
-        { key: "diagnostics", label: "Diagnostics" },
-    ]);
-    if (result.diagnostics.length > 0) {
-        console.log();
-        table(result.diagnostics, [
-            { key: "severity", label: "Severity" },
-            { key: "code", label: "Code" },
-            { key: "path", label: "Path" },
-            { key: "message", label: "Message" },
-        ]);
-    }
-    console.log();
-    table([result.peakCost], Object.keys(result.peakCost).map((key) => ({ key, label: key })));
-}
 function showPlayback(result) {
     table([result], [
         { key: "playbackId", label: "Playback ID" },
@@ -156,38 +92,6 @@ function capabilityUnits(schema) {
         return detail ? [`${field}:${detail}`] : [];
     }).join(", ");
 }
-function registerTransactionCommand(boards, name) {
-    withJson(boards.command(`${name} <board>`)
-        .description(name === "validate" ? "Validate a transaction" : "Apply a transaction")
-        .requiredOption("-i, --input <file>", "Transaction JSON file; use - for stdin")
-        .option("--tx-id <id>", "Override txId; generated when omitted")
-        .option("--base-version <version>", "Override baseVersion")
-        .addHelpText("after", `
-Input example:
-  {"baseVersion":12,"operations":[{"type":"board.patch","payload":{"patch":{"title":"Launch plan"}}}]}
-
-Prefer semantic commands such as boards background, nodes, effects, or compositions for common edits.`))
-        .action(async (target, options) => {
-        try {
-            const transaction = createTransactionInput(await readJsonObject(options.input, BOARD_TRANSACTION_INPUT_MAX_BYTES), options);
-            const spaceId = resolveSpace(boards);
-            const boardId = await resolveBoardId(spaceId, target);
-            const board = createClient().space(spaceId).board(boardId);
-            const result = await board[name](transaction);
-            if (jsonRequested(options))
-                return outJson(result);
-            if (name === "validate")
-                showValidation(result);
-            else {
-                const receipt = result;
-                ok(`Board updated to version ${receipt.board.version}`);
-            }
-        }
-        catch (cause) {
-            handleHttp(cause);
-        }
-    });
-}
 function commandId(options) {
     return options.commandId?.trim() || randomUUID();
 }
@@ -313,14 +217,16 @@ export function registerBoards(program) {
         .description("Create a Board")
         .option("--title <title>", "Board title")
         .option("--mutation-id <id>", "Stable id for safe retries")
-        .option("-i, --input <file>", "BoardCreateInput fields; use - for stdin")
+        .option("-i, --input <file>", "Semantic Board seed JSON; use - for stdin")
         .addHelpText("after", `
-For normal use, create an empty Board and add content with boards nodes, effects, and compositions.
---input is intended for bulk creation and accepts BoardCreateInput fields except path and title.`))
+Create an empty Board, or provide items, connections, effects, compositions, and metadata in --input.
+Generate an editable seed:
+  cohub boards examples create > board.json
+  cohub boards create plan.board -i board.json`))
         .action(async (path, options) => {
         try {
             const content = options.input
-                ? await readJsonObject(options.input, BOARD_CREATE_INPUT_MAX_BYTES)
+                ? await readBoardJsonObject(options.input, BOARD_CREATE_INPUT_MAX_BYTES)
                 : {};
             if ("path" in content || "title" in content) {
                 throw new Error("create input must not contain path or title; use the command argument and --title");
@@ -336,7 +242,7 @@ For normal use, create an empty Board and add content with boards nodes, effects
             if (jsonRequested(options))
                 return outJson(result);
             ok(`Board created: ${result.board.id}`);
-            showBoard(result);
+            showCreated(result);
         }
         catch (cause) {
             handleHttp(cause);
@@ -344,31 +250,30 @@ For normal use, create an empty Board and add content with boards nodes, effects
     });
     withJson(boards.command("inspect <board>")
         .alias("get")
-        .description("Inspect a Board")
-        .option("--include <sections>", "Comma-separated nodes,connections,effects,compositions,playback")
-        .option("--viewport <rect>", "Viewport as x,y,width,height"))
+        .description("Show Board metadata and semantic resource counts")
+        .addHelpText("after", `
+Inspect content with:
+  cohub boards items list <board> --json
+  cohub boards effects list <board> --json
+  cohub boards compositions list <board> --json`))
         .action(async (target, options) => {
         try {
             const spaceId = resolveSpace(boards);
             const boardId = await resolveBoardId(spaceId, target);
-            const board = createClient().space(spaceId).board(boardId);
-            if (!jsonRequested(options) && !options.include && !options.viewport) {
-                return showSummary(await board.summary());
-            }
-            const result = await board.inspect({
-                include: parseInspectSections(options.include),
-                viewport: parseViewport(options.viewport),
-            });
+            const result = await createClient().space(spaceId).board(boardId).summary();
             if (jsonRequested(options))
                 return outJson(result);
-            showBoard(result);
+            showSummary(result);
         }
         catch (cause) {
             handleHttp(cause);
         }
     });
     withJson(boards.command("capabilities <board>")
-        .description("Show supported capabilities"))
+        .description("Show authoring schemas and runtime capabilities")
+        .addHelpText("after", `
+Use --json for complete Item, patch, mutation, effect, Composition, and create JSON Schemas.
+Use boards examples for editable starter JSON.`))
         .action(async (target, options) => {
         try {
             const spaceId = resolveSpace(boards);
@@ -388,30 +293,25 @@ For normal use, create an empty Board and add content with boards nodes, effects
                 { key: "coordinates", label: "Coordinates / units" },
                 { key: "digest", label: "Digest" },
             ]);
-            const nodes = result.nodes;
-            if (nodes) {
-                console.log();
-                table([{
-                        types: nodes.types.join(", "),
-                        colors: nodes.colors.join(", "),
-                        geos: nodes.geos.join(", "),
-                        drawPoints: nodes.coordinates.drawPoints,
-                        arrowEndpoints: nodes.coordinates.arrowEndpoints,
-                    }], [
-                    { key: "types", label: "Node types" },
-                    { key: "colors", label: "Colors" },
-                    { key: "geos", label: "Geo kinds" },
-                    { key: "drawPoints", label: "Draw points" },
-                    { key: "arrowEndpoints", label: "Arrow endpoints" },
-                ]);
-            }
+            console.log();
+            table([{
+                    types: result.items.types.join(", "),
+                    colors: result.items.colors.join(", "),
+                    shapes: result.items.shapes.join(", "),
+                    drawPoints: result.items.coordinates.drawPoints,
+                    arrowEndpoints: result.items.coordinates.arrowEndpoints,
+                }], [
+                { key: "types", label: "Item types" },
+                { key: "colors", label: "Colors" },
+                { key: "shapes", label: "Shapes" },
+                { key: "drawPoints", label: "Draw points" },
+                { key: "arrowEndpoints", label: "Arrow endpoints" },
+            ]);
         }
         catch (cause) {
             handleHttp(cause);
         }
     });
-    registerTransactionCommand(boards, "validate");
-    registerTransactionCommand(boards, "apply");
     registerBoardDomainCommands(boards);
     registerExportCommand(boards);
     withJson(boards.command("play <board> <composition-id>")
@@ -514,13 +414,13 @@ For normal use, create an empty Board and add content with boards nodes, effects
                         process.stdout.write(`${JSON.stringify(event)}\n`);
                         return;
                     }
-                    if (event.type === "board.transaction.applied") {
-                        process.stdout.write(`version ${event.payload.version}  transaction ${event.payload.txId}  operations ${event.payload.operations.length}\n`);
+                    if (event.type === "board.changed") {
+                        process.stdout.write(`version ${event.payload.version}  mutation ${event.payload.mutationId}\n`);
                     }
                     else if (event.type === "board.playback.changed") {
                         process.stdout.write(`${event.payload.status}  composition ${event.payload.compositionId}  position ${event.payload.position}\n`);
                     }
-                    else {
+                    else if (event.type === "board.awareness.updated") {
                         process.stdout.write(`awareness ${event.payload.actorName}  ${event.payload.update.type}\n`);
                     }
                 },

package/dist/commands/cron-jobs.js

@@ -9,7 +9,7 @@ function readJsonObject(pathOrJson) {
     return parsed;
 }
 export function registerCronJobs(program) {
-    const cmd = program.command("cron-jobs", { hidden: true }).description("Scheduled jobs");
+    const cmd = program.command("cron-jobs").description("Scheduled jobs");
     cmd
         .command("ls [spaceId]")
         .alias("list")

package/dist/commands/desktop.d.ts

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

package/dist/commands/desktop.js

@@ -0,0 +1,219 @@
+import { readFileSync } from "node:fs";
+import { HttpError, } from "@neta-art/cohub";
+import { parseAppRef, DESKTOP_COMMAND_DEFAULT_TIMEOUT_MS, DESKTOP_COMMAND_MAX_TIMEOUT_MS, } from "@neta-art/cohub";
+import { createClient } from "../client.js";
+import { error, handleHttp, json as outJson, jsonRequested, ok } from "../output.js";
+import { getAppByRef } from "../app-ref.js";
+const FILE_SCHEME = "file://";
+const APP_SCHEME = "app://";
+const LEGACY_WORK_SCHEME = "work://";
+function optionalSpaceId(command) {
+    let current = command;
+    while (current) {
+        const opts = current.opts();
+        if (typeof opts.space === "string" && opts.space.trim())
+            return opts.space.trim();
+        current = current.parent ?? null;
+    }
+    return process.env.COHUB_SPACE_ID?.trim() || undefined;
+}
+function parseFilePath(value) {
+    const path = value.slice(FILE_SCHEME.length).trim();
+    if (!path ||
+        path.startsWith("/") ||
+        path.includes("\0") ||
+        path.split("/").some((segment) => segment === "..") ||
+        path.includes("\\")) {
+        return error("Invalid file path", "Use a relative Space path after file://.");
+    }
+    return path;
+}
+function hasFileScheme(value) {
+    return value.toLowerCase().startsWith(FILE_SCHEME);
+}
+function hasAppScheme(value) {
+    const lowered = value.toLowerCase();
+    return lowered.startsWith(APP_SCHEME) || lowered.startsWith(LEGACY_WORK_SCHEME);
+}
+function readCallInput(opts) {
+    if (opts.data !== undefined && opts.input !== undefined) {
+        return error("Conflicting input", "Use either --data or --input, not both.");
+    }
+    const raw = opts.data !== undefined
+        ? opts.data
+        : opts.input !== undefined
+            ? opts.input === "-"
+                ? readFileSync(0, "utf-8")
+                : readFileSync(opts.input, "utf-8")
+            : undefined;
+    if (raw === undefined)
+        return undefined;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return error("Invalid input", "Call input must be valid JSON.");
+    }
+}
+function parseTimeout(value) {
+    if (!value)
+        return DESKTOP_COMMAND_DEFAULT_TIMEOUT_MS;
+    const parsed = Math.floor(Number(value));
+    if (!Number.isFinite(parsed) || parsed <= 0 || parsed > DESKTOP_COMMAND_MAX_TIMEOUT_MS) {
+        return error("Invalid timeout", `--timeout-ms must be between 1 and ${DESKTOP_COMMAND_MAX_TIMEOUT_MS} milliseconds.`);
+    }
+    return parsed;
+}
+async function resolveAppTarget(client, ref) {
+    const normalized = hasAppScheme(ref) ? ref.replace(/^[a-zA-Z]+:\/\//, "") : ref;
+    const parsed = parseAppRef(normalized);
+    const detail = await getAppByRef(client, normalized);
+    return {
+        kind: "app",
+        appId: detail.app.id,
+        label: detail.app.slug,
+        launch: {
+            ...(parsed.search ? { search: parsed.search } : {}),
+            ...(parsed.hash ? { hash: parsed.hash } : {}),
+        },
+    };
+}
+async function resolveOpenTarget(client, command, value) {
+    if (hasFileScheme(value))
+        return { kind: "file", path: parseFilePath(value) };
+    if (hasAppScheme(value))
+        return resolveAppTarget(client, value);
+    const spaceId = optionalSpaceId(command);
+    if (spaceId) {
+        try {
+            await client.space(spaceId).files.read(value);
+            return { kind: "file", path: value };
+        }
+        catch (cause) {
+            if (!(cause instanceof HttpError) || cause.status !== 404)
+                throw cause;
+        }
+    }
+    return resolveAppTarget(client, value);
+}
+function reportDispatch(record) {
+    if (record.status !== "pending") {
+        reportOutcome(record, Boolean(record.command.call));
+        return;
+    }
+    ok(`Desktop command dispatched (${record.commandId})`);
+}
+function reportOutcome(record, called) {
+    if (record.status === "applied") {
+        ok(called ? "App window shown and method called" : "Window shown");
+        if (record.result !== undefined) {
+            console.log(typeof record.result === "string" ? record.result : JSON.stringify(record.result, null, 2));
+        }
+        return;
+    }
+    error(`Desktop command ${record.status}`, record.error?.message ?? "The Cohub desktop did not apply this command.");
+}
+async function openWindow(target, opts, command) {
+    const callInput = opts.call ? readCallInput(opts) : undefined;
+    if (!opts.call && (opts.data !== undefined || opts.input !== undefined)) {
+        return error("Missing --call", "--data and --input only apply together with --call.");
+    }
+    if (opts.noWait && opts.timeoutMs !== undefined) {
+        return error("Conflicting wait options", "Use either --no-wait or --timeout-ms, not both.");
+    }
+    const timeoutMs = parseTimeout(opts.timeoutMs);
+    const client = createClient();
+    try {
+        const resolved = await resolveOpenTarget(client, command, target);
+        if (resolved.kind === "file" && opts.call) {
+            return error("Unsupported option", "--call only applies to app targets.");
+        }
+        const call = opts.call
+            ? { method: opts.call, ...(callInput === undefined ? {} : { input: callInput }) }
+            : undefined;
+        const input = {
+            command: {
+                type: "desktop.open",
+                target: resolved.kind === "file"
+                    ? resolved
+                    : {
+                        kind: "app",
+                        appId: resolved.appId,
+                        label: resolved.label,
+                        ...(resolved.launch.search || resolved.launch.hash ? { launch: resolved.launch } : {}),
+                    },
+                ...(call ? { call } : {}),
+            },
+            ...(opts.client ? { targetClientId: opts.client } : {}),
+            ...(opts.commandId ? { commandId: opts.commandId } : {}),
+        };
+        const record = opts.noWait
+            ? (await client.desktop.create(input)).command
+            : await client.desktop.run(input, { timeoutMs });
+        if (jsonRequested(opts))
+            return outJson(record);
+        if (opts.noWait)
+            return reportDispatch(record);
+        reportOutcome(record, Boolean(call));
+    }
+    catch (e) {
+        if (e instanceof Error && e.name === "AppRefParseError")
+            return error(e.message);
+        handleHttp(e);
+    }
+}
+const OPEN_HELP = `
+Commands reach only the desktop that originated the current chat, resolved
+from request provenance. Nothing else can be targeted.
+
+Examples:
+  cohub desktop open <app-or-file>
+  cohub desktop open file://src/main.ts
+  cohub desktop open app://alice/studio/launch
+  cohub desktop open alice/studio/launch
+  cohub desktop open https://cohub.live/alice/studio/w/launch?view=timeline
+  cohub desktop open <app-id> --call selection.get
+  cohub desktop open <app-id> --call board.focus --data '{"nodeId":"n1"}'
+`;
+const OPEN_NOTES = `
+Notes:
+  - Use file:// and app:// to make the target explicit; the legacy work://
+    scheme is still accepted.
+  - A plain target checks the current Space for a file before resolving an app.
+  - Opening a window is idempotent; repeating it re-activates the same tab.
+  - --call waits for the app to announce readiness, then invokes the method.
+  - Which methods exist is up to the app author.
+`;
+function registerOpen(parent, deprecated) {
+    const open = parent
+        .command(deprecated ? "preview <app-or-file>" : "open <app-or-file>")
+        .description(deprecated ? "Deprecated: use `cohub desktop open`" : "Open a file or app window on the Cohub desktop, optionally calling an app method")
+        .option("--call <method>", "Method the app registered via client.app.surface.handle()")
+        .option("--data <json>", "Inline JSON input for --call")
+        .option("-i, --input <file>", "JSON input file for --call; use - for stdin")
+        .option("--client <clientId>", "Target a specific desktop instance of your account")
+        .option("--command-id <id>", "Stable id so retries never dispatch twice")
+        .option("--no-wait", "Dispatch the command and exit without waiting for a result")
+        .option("--timeout-ms <ms>", `How long to wait for the desktop (default: ${DESKTOP_COMMAND_DEFAULT_TIMEOUT_MS}; max: ${DESKTOP_COMMAND_MAX_TIMEOUT_MS})`)
+        .option("--json", "Output as JSON")
+        .action(async (target, opts, thisCommand) => {
+        if (deprecated) {
+            ok("Deprecated: `cohub ui preview` is now `cohub desktop open`.");
+        }
+        await openWindow(target, opts, thisCommand);
+    });
+    open.addHelpText("after", deprecated ? OPEN_NOTES : OPEN_HELP + OPEN_NOTES);
+}
+export function registerDesktop(program) {
+    const desktop = program
+        .command("desktop")
+        .description("Drive the Cohub desktop that started this chat");
+    registerOpen(desktop, false);
+}
+export function registerLegacyUi(program) {
+    const ui = program
+        .command("ui", { hidden: true })
+        .description("Deprecated: use `cohub desktop open`")
+        .addHelpText("after", OPEN_HELP);
+    registerOpen(ui, true);
+}

package/dist/commands/profile.js

@@ -16,7 +16,7 @@ export function registerProfile(program) {
             const handle = result.profile.username ? `@${result.profile.username}` : result.profile.userUuid;
             console.log(`\n  ${result.profile.displayName} (${handle})`);
             console.log(`  Spaces: ${result.spaces.length}`);
-            console.log(`  Works:  ${result.works.length}\n`);
+            console.log(`  Apps:   ${result.apps.length}\n`);
             if (result.spaces.length > 0) {
                 console.log("  Spaces:");
                 for (const space of result.spaces) {
@@ -24,10 +24,10 @@ export function registerProfile(program) {
                 }
                 console.log("");
             }
-            if (result.works.length > 0) {
-                console.log("  Works:");
-                for (const work of result.works) {
-                    console.log(`    - ${work.title} ${work.publicUrl}`);
+            if (result.apps.length > 0) {
+                console.log("  Apps:");
+                for (const app of result.apps) {
+                    console.log(`    - ${app.title} ${app.publicUrl}`);
                 }
                 console.log("");
             }

package/dist/commands/tasks.js

@@ -2,7 +2,7 @@ import { createClient } from "../client.js";
 import { table, json as outJson, jsonRequested, handleHttp } from "../output.js";
 export function registerTasks(program, dependencies = {}) {
     const getClient = dependencies.createClient ?? createClient;
-    const cmd = program.command("tasks", { hidden: true }).description("Task runs");
+    const cmd = program.command("tasks").description("Task runs");
     cmd
         .command("ls")
         .alias("list")

package/dist/index.js

@@ -19,8 +19,8 @@ import { registerPrompt, registerSpaces } from "./commands/spaces.js";
 import { maybeHandleRunCommand } from "./commands/run.js";
 import { registerSandbox } from "./commands/sandbox.js";
 import { registerTasks } from "./commands/tasks.js";
-import { registerUi } from "./commands/ui.js";
-import { registerWorks } from "./commands/works.js";
+import { registerDesktop, registerLegacyUi } from "./commands/desktop.js";
+import { registerApps } from "./commands/apps.js";
 const VERSION = (() => {
     try {
         const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
@@ -55,8 +55,8 @@ Common commands:
   cohub -s <space-id> spaces sessions turns ls <session-id>
   cohub -s <space-id> spaces files ls
   cohub -s <space-id> public upload ./dist demo
-  cohub -s <space-id> works publish demo --file dist/index.html
-  cohub ui preview <work-id> --call selection.get
+  cohub -s <space-id> apps publish demo --file dist/index.html
+  cohub desktop open <app-id> --call selection.get
   cohub -s <space-id> spaces commerce products list
   cohub models ls
   cohub models ls --model-type multimodal
@@ -84,8 +84,9 @@ registerReferences(program);
 registerReferrals(program);
 registerTasks(program);
 registerCronJobs(program);
-registerWorks(program);
-registerUi(program);
+registerApps(program);
+registerDesktop(program);
+registerLegacyUi(program);
 const argv = process.argv.slice(2);
 if (await maybeHandleRunCommand(argv)) {
     process.exit();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "4.0.0",
+  "version": "6.0.0",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "license": "Apache-2.0",
@@ -19,7 +19,7 @@
     "commander": "^15.0.0",
     "pixi.js": "^8.19.0",
     "sharp": "^0.35.3",
-    "@neta-art/cohub": "6.0.0"
+    "@neta-art/cohub": "8.0.0"
   },
   "publishConfig": {
     "access": "public"

package/dist/commands/ui.d.ts

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