@neta-art/cohub-cli 3.9.5 → 3.10.0

package/README.md

@@ -1,6 +1,6 @@
 # @neta-art/cohub-cli
 
-CLI for [Cohub](https://cohub.run) — work with Spaces, Chats, files, Saves, Tasks, scheduled prompts, search, and multimodal generation from your terminal.
+CLI for [Cohub](https://cohub.live) — work with Spaces, Chats, files, Saves, Tasks, scheduled prompts, search, and multimodal generation from your terminal.
 
 ## Installation
 
@@ -158,7 +158,37 @@ cohub -s <spaceId> boards watch <boardId> --json
 ```
 
 Pass nodes, effects, and sequences as JSON when creating a Board. The path and
-title stay explicit in the command:
+title stay explicit in the command. Inspect `boards capabilities --json` for the
+supported node types, enums, and coordinate spaces.
+
+```json
+{
+  "nodes": [
+    {
+      "nodeId": "goal",
+      "type": "geo",
+      "parentId": null,
+      "orderKey": null,
+      "x": 80,
+      "y": 80,
+      "width": 240,
+      "height": 120,
+      "rotation": 0,
+      "refKind": null,
+      "refPath": null,
+      "refUrl": null,
+      "view": {},
+      "style": {},
+      "data": {
+        "geo": "rectangle",
+        "text": "Ship",
+        "color": "green",
+        "fillOpacity": 0.12
+      }
+    }
+  ]
+}
+```
 
 ```bash
 cohub -s <spaceId> boards create boards/plan.board \

package/dist/commands/boards.js

@@ -347,6 +347,23 @@ export function registerBoards(program) {
                 { key: "renderers", label: "Renderers" },
                 { 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" },
+                ]);
+            }
         }
         catch (cause) {
             handleHttp(cause);

package/dist/commands/me.js

@@ -43,17 +43,35 @@ export function registerMe(program) {
         }
     });
     meCmd
-        .command("usage [days]")
-        .description("Your aggregated usage across all spaces (default: 30 days)")
+        .command("activity")
+        .description("Show your activity across all spaces")
+        .option("--days <n>", "Show the last N days (default: 30)")
+        .option("--from <date>", "Start at this ISO 8601 date")
+        .option("--to <date>", "Stop before this ISO 8601 date")
         .option("--json", "Output as JSON")
-        .action(async (days, opts) => {
+        .addHelpText("after", "\nExamples:\n  $ cohub me activity --days 7\n  $ cohub me activity --from 2026-01-01 --to 2026-02-01")
+        .action(async (opts) => {
+        if (opts.days && (opts.from || opts.to)) {
+            process.stderr.write("\n  ✗ Invalid range\n    --days cannot be combined with --from or --to\n\n");
+            process.exitCode = 1;
+            return;
+        }
+        if (opts.to && !opts.from) {
+            process.stderr.write("\n  ✗ Invalid range\n    --from is required when --to is provided\n\n");
+            process.exitCode = 1;
+            return;
+        }
         const client = createClient();
         try {
-            const usage = await client.user.getUsage(days ? parseInteger(days, "days", 1) : 30);
+            const activity = await client.user.getActivity({
+                days: opts.days ? parseInteger(opts.days, "days", 1) : undefined,
+                from: opts.from,
+                to: opts.to,
+            });
             if (jsonRequested(opts))
-                return outJson(usage);
-            console.log("\n  Summary:");
-            table([usage.summary], [
+                return outJson(activity);
+            console.log(`\n  ${activity.range.from} → ${activity.range.to}`);
+            table([activity.summary], [
                 { key: "totalTokens", label: "Tokens" },
                 { key: "costTotal", label: "Cost ($)" },
                 { key: "requestCount", label: "Requests" },

package/dist/commands/public.d.ts

@@ -0,0 +1,20 @@
+import type { CohubHttpClient } from "@neta-art/cohub";
+import type { Command } from "commander";
+type LocalPublicFile = {
+    id: string;
+    localPath: string;
+    publicPath: string;
+    size: number;
+    mimeType: string;
+};
+type PublicCommandDeps = {
+    createClient?: () => CohubHttpClient;
+    fetch?: typeof fetch;
+};
+export declare function collectPublicUpload(source: string, destination?: string): Promise<{
+    files: LocalPublicFile[];
+    destination: string;
+    entryPath: string | null;
+}>;
+export declare function registerPublic(program: Command, deps?: PublicCommandDeps): Command;
+export {};

package/dist/commands/public.js

@@ -0,0 +1,281 @@
+import { randomUUID } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { lstat, readdir } from "node:fs/promises";
+import { basename, extname, relative, resolve } from "node:path";
+import { createClient } from "../client.js";
+import { error, handleHttp, json as outJson, jsonRequested } from "../output.js";
+import { resolveSpace } from "../space.js";
+const UPLOAD_CONCURRENCY = 4;
+const MIME_TYPES = {
+    ".aac": "audio/aac",
+    ".avi": "video/x-msvideo",
+    ".avif": "image/avif",
+    ".css": "text/css; charset=utf-8",
+    ".csv": "text/csv; charset=utf-8",
+    ".gif": "image/gif",
+    ".htm": "text/html; charset=utf-8",
+    ".html": "text/html; charset=utf-8",
+    ".ico": "image/x-icon",
+    ".jpeg": "image/jpeg",
+    ".jpg": "image/jpeg",
+    ".js": "text/javascript; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".m4a": "audio/mp4",
+    ".md": "text/markdown; charset=utf-8",
+    ".mov": "video/quicktime",
+    ".mp3": "audio/mpeg",
+    ".mp4": "video/mp4",
+    ".ogg": "audio/ogg",
+    ".ogv": "video/ogg",
+    ".pdf": "application/pdf",
+    ".png": "image/png",
+    ".svg": "image/svg+xml",
+    ".txt": "text/plain; charset=utf-8",
+    ".wasm": "application/wasm",
+    ".wav": "audio/wav",
+    ".webm": "video/webm",
+    ".webp": "image/webp",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".xml": "application/xml; charset=utf-8",
+    ".zip": "application/zip",
+};
+function hasControlCharacters(value) {
+    return [...value].some((char) => {
+        const code = char.charCodeAt(0);
+        return code <= 0x1f || (code >= 0x7f && code <= 0x9f);
+    });
+}
+function terminalText(value) {
+    return [...value].map((char) => {
+        const code = char.charCodeAt(0);
+        return code <= 0x1f || (code >= 0x7f && code <= 0x9f)
+            ? `\\u${code.toString(16).padStart(4, "0")}`
+            : char;
+    }).join("");
+}
+function normalizePublicPath(input) {
+    const value = input.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
+    if (!value || value.startsWith("/") || hasControlCharacters(value)) {
+        return error("Invalid public path");
+    }
+    const parts = value.split("/");
+    if (parts.some((part) => !part || part === "." || part === "..")) {
+        return error("Invalid public path");
+    }
+    return parts.join("/");
+}
+function mimeTypeForPath(path) {
+    return MIME_TYPES[extname(path).toLowerCase()] ?? "application/octet-stream";
+}
+async function walkDirectory(root, directory, destination) {
+    const names = await readdir(directory);
+    names.sort((left, right) => left.localeCompare(right));
+    const files = [];
+    for (const name of names) {
+        const localPath = resolve(directory, name);
+        const info = await lstat(localPath);
+        if (info.isSymbolicLink())
+            return error("Symlinks are not supported", relative(root, localPath));
+        if (info.isDirectory()) {
+            files.push(...await walkDirectory(root, localPath, destination));
+            continue;
+        }
+        if (!info.isFile())
+            continue;
+        const nestedPath = relative(root, localPath).replace(/\\/g, "/");
+        const publicPath = normalizePublicPath(`${destination}/${nestedPath}`);
+        files.push({
+            id: randomUUID(),
+            localPath,
+            publicPath,
+            size: info.size,
+            mimeType: mimeTypeForPath(localPath),
+        });
+    }
+    return files;
+}
+export async function collectPublicUpload(source, destination) {
+    const localPath = resolve(source);
+    const info = await lstat(localPath).catch(() => null);
+    if (!info)
+        return error("Source not found", source);
+    if (info.isSymbolicLink())
+        return error("Symlinks are not supported", source);
+    if (info.isFile()) {
+        const publicPath = normalizePublicPath(destination
+            ? destination.endsWith("/") ? `${destination}${basename(localPath)}` : destination
+            : basename(localPath));
+        return {
+            destination: publicPath,
+            entryPath: publicPath,
+            files: [{
+                    id: randomUUID(),
+                    localPath,
+                    publicPath,
+                    size: info.size,
+                    mimeType: mimeTypeForPath(localPath),
+                }],
+        };
+    }
+    if (!info.isDirectory())
+        return error("Source must be a file or directory", source);
+    const target = normalizePublicPath(destination ?? basename(localPath));
+    const files = await walkDirectory(localPath, localPath, target);
+    if (files.length === 0)
+        return error("Directory contains no files", source);
+    const indexPath = `${target}/index.html`;
+    return {
+        files,
+        destination: `${target}/`,
+        entryPath: files.some((file) => file.publicPath === indexPath) ? indexPath : null,
+    };
+}
+async function mapSettledWithConcurrency(items, concurrency, mapper) {
+    const errors = [];
+    let nextIndex = 0;
+    const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+        while (nextIndex < items.length) {
+            const index = nextIndex++;
+            try {
+                await mapper(items[index]);
+            }
+            catch (cause) {
+                errors.push(cause instanceof Error ? cause : new Error(String(cause)));
+            }
+        }
+    });
+    await Promise.all(workers);
+    return errors;
+}
+async function putPublicFile(file, plan, fetchImpl) {
+    const response = await fetchImpl(plan.uploadUrl, {
+        method: "PUT",
+        headers: plan.headers,
+        body: createReadStream(file.localPath),
+        duplex: "half",
+    });
+    if (response.ok)
+        return;
+    const detail = await response.text().catch(() => "");
+    if (response.status === 409 || response.status === 412) {
+        throw new Error(`${file.publicPath} already exists. Use --overwrite.`);
+    }
+    throw new Error(`Failed to upload ${file.publicPath}: HTTP ${response.status}${detail ? ` — ${detail}` : ""}`);
+}
+function uploadFailure(errors) {
+    if (errors.length === 1)
+        return errors[0];
+    const first = errors[0]?.message ?? "Upload failed";
+    return new Error(`${first} (${errors.length} files failed)`);
+}
+async function uploadPublic(command, source, destination, opts, deps) {
+    const client = deps.createClient?.() ?? createClient();
+    const spaceId = resolveSpace(command);
+    try {
+        const upload = await collectPublicUpload(source, destination);
+        const plan = await client.space(spaceId).publicFiles.createUpload({
+            overwrite: Boolean(opts.overwrite),
+            entries: upload.files.map((file) => ({
+                id: file.id,
+                relativePath: file.publicPath,
+                size: file.size,
+                mimeType: file.mimeType,
+            })),
+        });
+        if (opts.overwrite && !jsonRequested(opts)) {
+            process.stderr.write(`Overwrite enabled for ${upload.destination}\n`);
+        }
+        const filesById = new Map(upload.files.map((file) => [file.id, file]));
+        const plansByPath = new Map(plan.entries.map((entry) => [entry.path, entry]));
+        const entryPlan = upload.entryPath ? plansByPath.get(upload.entryPath) : undefined;
+        const assetPlans = entryPlan
+            ? plan.entries.filter((entry) => entry.id !== entryPlan.id)
+            : plan.entries;
+        const uploadPlans = async (entries) => mapSettledWithConcurrency(entries, UPLOAD_CONCURRENCY, async (entry) => {
+            const file = filesById.get(entry.id);
+            if (!file)
+                throw new Error(`Missing local file for ${entry.path}`);
+            await putPublicFile(file, entry, deps.fetch ?? fetch);
+        });
+        const assetErrors = await uploadPlans(assetPlans);
+        if (assetErrors.length > 0)
+            throw uploadFailure(assetErrors);
+        if (entryPlan) {
+            const entryErrors = await uploadPlans([entryPlan]);
+            if (entryErrors.length > 0)
+                throw uploadFailure(entryErrors);
+        }
+        const entryUrl = entryPlan?.publicUrl ?? null;
+        if (jsonRequested(opts)) {
+            outJson({
+                uploaded: upload.files.length,
+                overwrite: Boolean(opts.overwrite),
+                destination: upload.destination,
+                url: entryUrl,
+            });
+            return;
+        }
+        console.log(entryUrl ?? `Uploaded ${upload.files.length} files to ${upload.destination}`);
+    }
+    catch (exception) {
+        handleHttp(exception);
+    }
+}
+async function listPublic(command, path, opts, deps) {
+    const client = deps.createClient?.() ?? createClient();
+    try {
+        const publicFiles = client.space(resolveSpace(command)).publicFiles;
+        const entries = [];
+        let cursor;
+        do {
+            const page = await publicFiles.list(path ?? "", {
+                recursive: opts.recursive,
+                limit: 1000,
+                cursor,
+            });
+            if (jsonRequested(opts))
+                entries.push(...page.entries);
+            else
+                for (const entry of page.entries) {
+                    console.log(`${terminalText(entry.name)}${entry.kind === "directory" ? "/" : ""}`);
+                }
+            cursor = page.nextCursor ?? undefined;
+        } while (cursor);
+        if (jsonRequested(opts))
+            return outJson({ path: path ?? "", entries, nextCursor: null });
+    }
+    catch (exception) {
+        handleHttp(exception);
+    }
+}
+async function printPublicUrl(command, path, deps) {
+    const client = deps.createClient?.() ?? createClient();
+    try {
+        const result = await client.space(resolveSpace(command)).publicFiles.url(path);
+        console.log(result.url);
+    }
+    catch (exception) {
+        handleHttp(exception);
+    }
+}
+export function registerPublic(program, deps = {}) {
+    const publicCommand = program
+        .command("public")
+        .description("Upload and manage public Space files");
+    publicCommand
+        .command("upload <source> [destination]")
+        .description("Upload a file or directory")
+        .option("--overwrite", "Replace existing public files")
+        .action((source, destination, opts, command) => uploadPublic(command, source, destination, opts, deps));
+    publicCommand
+        .command("ls [path]")
+        .description("List public files")
+        .option("-r, --recursive", "List files recursively")
+        .action((path, opts, command) => listPublic(command, path, opts, deps));
+    publicCommand
+        .command("url <path>")
+        .description("Print a public file URL")
+        .action((path, _opts, command) => printPublicUrl(command, path, deps));
+    return publicCommand;
+}

package/dist/commands/referrals.js

@@ -1,7 +1,7 @@
 import { createClient } from "../client.js";
 import { error, handleHttp, json as outJson, jsonRequested, ok, table } from "../output.js";
 function referralUrl(code) {
-    const origin = process.env.COHUB_WEB_URL?.replace(/\/+$/, "") ?? "https://cohub.run";
+    const origin = process.env.COHUB_WEB_URL?.replace(/\/+$/, "") ?? "https://cohub.live";
     return `${origin}/referrals/${code}`;
 }
 async function confirmRotate(opts) {

package/dist/commands/sandbox.js

@@ -9,7 +9,7 @@ import { error, json as outJson, jsonRequested, ok, spinner } from "../output.js
 import { resolveSpace } from "../space.js";
 import { ensureSandboxdBinary, SandboxdDownloadError } from "./sandboxd-binary.js";
 // Derive the gateway relay control endpoint from the realtime websocket URL,
-// e.g. wss://gateway.cohub.run/ws -> wss://gateway.cohub.run/sandbox/relay.
+// e.g. wss://gateway.cohub.live/ws -> wss://gateway.cohub.live/sandbox/relay.
 const resolveRelayUrl = () => {
     const explicit = process.env.COHUB_RELAY_URL?.trim();
     if (explicit)
@@ -27,7 +27,7 @@ const confirm = async (question) => {
         rl.close();
     }
 };
-const webBaseUrl = () => resolveCohubEnvironment() === "prod" ? "https://cohub.run" : "https://dev.cohub.run";
+const webBaseUrl = () => resolveCohubEnvironment() === "prod" ? "https://cohub.live" : "https://dev.cohub.live";
 export const resolveLocalSpaceName = (rootDir, requestedName) => requestedName?.trim() || basename(rootDir) || "local-space";
 // Consent copy is deliberately explicit: a local sandbox runs agent-issued
 // shell commands as the current OS user. File RPCs are fenced to the folder,

package/dist/commands/space-invitations.js

@@ -34,7 +34,7 @@ export function parseSpaceInvitationCreateOptions(options) {
     return { role, ttlSeconds: days * 24 * 60 * 60, maxUses };
 }
 function invitationUrl(invitation) {
-    const origin = process.env.COHUB_WEB_URL?.replace(/\/+$/, "") ?? "https://cohub.run";
+    const origin = process.env.COHUB_WEB_URL?.replace(/\/+$/, "") ?? "https://cohub.live";
     return `${origin}${buildSpaceInvitePath({
         spaceId: invitation.spaceId,
         ownerUsername: invitation.ownerUsername,

package/dist/commands/ui.js

@@ -72,7 +72,7 @@ resolved from request provenance. Nothing else can be targeted.
 Examples:
   cohub ui preview <work-id>
   cohub ui preview alice/studio/launch
-  cohub ui preview https://cohub.run/alice/studio/w/launch?view=timeline
+  cohub ui preview https://cohub.live/alice/studio/w/launch?view=timeline
   cohub ui preview <work-id> --call selection.get
   cohub ui preview <work-id> --call board.focus --data '{"nodeId":"n1"}'
 `);

package/dist/index.js

@@ -10,6 +10,7 @@ import { registerMe } from "./commands/me.js";
 import { registerModels } from "./commands/models.js";
 import { registerProfile } from "./commands/profile.js";
 import { registerPrompts } from "./commands/prompts.js";
+import { registerPublic } from "./commands/public.js";
 import { registerSkills } from "./commands/skills.js";
 import { registerSearch } from "./commands/search.js";
 import { registerReferences } from "./commands/references.js";
@@ -33,9 +34,9 @@ const program = new Command("cohub");
 program
     .name("cohub")
     .summary("Work with Cohub from your terminal")
-    .description("Send prompts, inspect sessions, manage space files, and generate multimodal outputs.")
+    .description("Send prompts, manage Space files, and publish public output.")
     .version(VERSION, "-v, --version", "Show version")
-    .option("-s, --space <id>", "Target space ID for prompt, files, sessions, and space-scoped commands")
+    .option("-s, --space <id>", "Target Space ID")
     .option("--json", "Print machine-readable JSON when supported")
     .helpOption("-h, --help", "Show help")
     .addHelpText("after", `
@@ -53,6 +54,7 @@ Common commands:
   cohub -s <space-id> spaces turns ls --author others
   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> spaces commerce products list
@@ -75,6 +77,7 @@ registerChannels(program);
 registerGenerations(program);
 registerModels(program);
 registerPrompts(program);
+registerPublic(program);
 registerSkills(program);
 registerSearch(program);
 registerReferences(program);

package/dist/output.js

@@ -112,11 +112,22 @@ function errorPresentationFromHttpError(e) {
     return null;
 }
 export function handleHttp(e) {
+    const status = e.status;
+    const body = e.body;
+    if (jsonRequested()) {
+        const payload = body && typeof body === "object"
+            ? body
+            : {
+                code: e.code ?? "CLI_ERROR",
+                message: e instanceof Error ? e.message : String(e),
+                ...(status ? { status } : {}),
+            };
+        process.stderr.write(`${JSON.stringify(payload, null, 2)}\n`);
+        process.exit(1);
+    }
     if (e instanceof Error && e.name === "AuthRequiredError") {
         return error("not authenticated", "run `cohub auth login`");
     }
-    const status = e.status;
-    const body = e.body;
     if (status === 402) {
         const conversion = extractBillingPayload(body)?.conversion;
         if (conversion) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "3.9.5",
+  "version": "3.10.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": "5.6.0"
+    "@neta-art/cohub": "5.8.0"
   },
   "publishConfig": {
     "access": "public"