@neta-art/cohub-cli 1.17.3 → 1.17.5

package/README.md

@@ -173,6 +173,29 @@ cohub -s <spaceId> spaces files rm <path>
 
 Confirm before deleting files or directories.
 
+## Works
+
+Publish and manage Work entries from a Space workspace.
+
+```bash
+cohub -s <spaceId> works ls --json
+cohub works get <workId> --json
+cohub -s <spaceId> works publish demo --file dist/index.html
+cohub -s <spaceId> works publish site --dir dist
+cohub -s <spaceId> works publish app --port 3000
+cohub works update <workId> --publish-version
+cohub works versions <workId> --json
+cohub works rm <workId> --yes
+```
+
+Resolve a published Work by public identity:
+
+```bash
+cohub works resolve <workSlug> --owner <username> --space-slug <spaceSlug>
+```
+
+Use `--json` for machine-readable output. The resolve command requires both `--owner` and `--space-slug` so missing public profile data fails with a clear message.
+
 ## Saves
 
 ```bash
@@ -210,7 +233,7 @@ Confirm before enabling, disabling, or deleting recurring scheduled prompts.
 
 Confirm before:
 
-- deleting files or directories
+- deleting files, directories, or Works
 - creating scheduled or recurring prompts with side effects
 - enabling, disabling, or deleting recurring scheduled prompts
 - changing access policies, member roles, or membership

package/dist/avatar.d.ts

@@ -13,3 +13,18 @@ export declare function uploadAvatarAsset(input: {
     uploadUrl: string;
     uploadFields: Record<string, string>;
 }>;
+export declare function normalizeChatImageFile(path: string): Promise<Buffer>;
+export declare function uploadChatImageAsset(input: {
+    client: CohubHttpClient;
+    spaceId: string;
+    sessionId: string;
+    path: string;
+}): Promise<{
+    purpose: PublicAssetPurpose;
+    objectKey: string;
+    publicUrl: string;
+    uploadMethod: "POST";
+    uploadUrl: string;
+    uploadFields: Record<string, string>;
+    size: number;
+}>;

package/dist/avatar.js

@@ -10,26 +10,31 @@ export async function normalizeAvatarFile(path) {
 }
 export async function uploadAvatarAsset(input) {
     const body = await normalizeAvatarFile(input.path);
-    const plan = await input.client.publicAssets.createUpload({
+    return input.client.publicAssets.upload({
         purpose: input.purpose,
         spaceId: input.spaceId,
-        file: {
-            size: body.byteLength,
-            mimeType: "image/webp",
-        },
+        file: new Blob([new Uint8Array(body)], { type: "image/webp" }),
+        mimeType: "image/webp",
+        filename: "avatar.webp",
     });
-    const formData = new FormData();
-    for (const [key, value] of Object.entries(plan.asset.uploadFields)) {
-        formData.append(key, value);
-    }
-    formData.append("file", new Blob([new Uint8Array(body)], { type: "image/webp" }), "avatar.webp");
-    const response = await fetch(plan.asset.uploadUrl, {
-        method: plan.asset.uploadMethod,
-        body: formData,
+}
+const CHAT_IMAGE_MAX_EDGE = 2160;
+const CHAT_IMAGE_QUALITY = 86;
+export async function normalizeChatImageFile(path) {
+    return sharp(path)
+        .rotate()
+        .resize(CHAT_IMAGE_MAX_EDGE, CHAT_IMAGE_MAX_EDGE, { fit: "inside", withoutEnlargement: true })
+        .webp({ quality: CHAT_IMAGE_QUALITY })
+        .toBuffer();
+}
+export async function uploadChatImageAsset(input) {
+    const body = await normalizeChatImageFile(input.path);
+    const asset = await input.client.publicAssets.uploadChatImageAttachment({
+        spaceId: input.spaceId,
+        sessionId: input.sessionId,
+        file: new Blob([new Uint8Array(body)], { type: "image/webp" }),
+        mimeType: "image/webp",
+        filename: "image.webp",
     });
-    if (!response.ok) {
-        const detail = await response.text().catch(() => "");
-        throw new Error(`Avatar upload failed: HTTP ${response.status}${detail ? ` — ${detail}` : ""}`);
-    }
-    return plan.asset;
+    return { ...asset, size: body.byteLength };
 }

package/dist/commands/spaces.js

@@ -3,7 +3,7 @@ import { createReadStream } from "node:fs";
 import { readdir, stat } from "node:fs/promises";
 import { basename, dirname, relative, resolve, sep } from "node:path";
 import { resolveCohubEnvironment } from "@neta-art/cohub";
-import { uploadAvatarAsset } from "../avatar.js";
+import { uploadAvatarAsset, uploadChatImageAsset } from "../avatar.js";
 import { createClient } from "../client.js";
 import { table, json as outJson, jsonRequested, ok, error, handleHttp } from "../output.js";
 import { resolveSpace } from "../space.js";
@@ -156,7 +156,7 @@ async function confirmRestart(opts) {
     if (answer !== "y" && answer !== "yes")
         return error("Cancelled");
 }
-async function readPromptContent(words) {
+async function readPromptContent(words, options = {}) {
     let content = words.join(" ");
     if (!content && !process.stdin.isTTY) {
         const chunks = [];
@@ -164,12 +164,12 @@ async function readPromptContent(words) {
             chunks.push(chunk);
         content = Buffer.concat(chunks).toString().trim();
     }
-    if (!content)
+    if (!content && !options.allowEmpty)
         return error("No content", "Pass as argument or pipe via stdin");
     return content;
 }
 async function sendPrompt(command, words, opts) {
-    const content = await readPromptContent(words);
+    const content = await readPromptContent(words, { allowEmpty: Boolean(opts.image?.length) });
     const scheduleFlags = [opts.delayMs, opts.at, opts.cron].filter((value) => value !== undefined);
     if (scheduleFlags.length > 1)
         return error("Conflicting schedule", "Use only one of --delay-ms, --at, or --cron");
@@ -185,11 +185,35 @@ async function sendPrompt(command, words, opts) {
                 : opts.cron
                     ? { mode: "repeat", cronExpression: opts.cron, timezone: opts.timezone }
                     : undefined;
+        const sessionId = opts.session;
+        const imagePaths = opts.image ?? [];
+        const imageSessionId = imagePaths.length
+            ? sessionId ?? error("Missing session", "Pass --session when attaching images.")
+            : "";
+        const imageBlocks = imagePaths.length
+            ? await Promise.all(imagePaths.map(async (path) => {
+                const asset = await uploadChatImageAsset({ client, spaceId, sessionId: imageSessionId, path });
+                return {
+                    type: "image",
+                    source: { type: "url", url: asset.publicUrl },
+                    _meta: {
+                        filename: basename(path),
+                        mediaType: "image/webp",
+                        size: asset.size,
+                        objectKey: asset.objectKey,
+                    },
+                };
+            }))
+            : [];
+        const promptContent = [
+            ...(content ? [{ type: "text", text: content }] : []),
+            ...imageBlocks,
+        ];
         const result = await client.space(spaceId).prompt({
-            sessionId: opts.session,
-            title: opts.title,
+            sessionId,
+            title: sessionId === opts.session ? opts.title : undefined,
             source: opts.source?.trim() || "cli",
-            content: [{ type: "text", text: content }],
+            content: promptContent,
             model: opts.model,
             provider: opts.provider,
             accessMode: opts.readOnly ? "read_only" : "full_access",
@@ -225,6 +249,7 @@ export function registerPrompt(program) {
         .option("--cron <expression>", "Repeat using a 5-field cron expression")
         .option("--timezone <tz>", "IANA timezone for --cron, e.g. Asia/Shanghai")
         .option("--label <ref>", "Attach a label, e.g. Bug or Area/Frontend", collectOption, [])
+        .option("--image <path>", "Attach an image", collectOption, [])
         .option("--json", "Output as JSON")
         .action((words, opts) => sendPrompt(program, words, opts));
 }
@@ -385,6 +410,7 @@ export function registerSpaces(program) {
         .option("--cron <expression>", "Repeat using a 5-field cron expression")
         .option("--timezone <tz>", "IANA timezone for --cron, e.g. Asia/Shanghai")
         .option("--label <ref>", "Attach a label, e.g. Bug or Area/Frontend", collectOption, [])
+        .option("--image <path>", "Attach an image", collectOption, [])
         .option("--json", "Output as JSON")
         .action((words, opts) => sendPrompt(spacesCmd, words, opts));
     // ── spaces files ──
@@ -1356,12 +1382,17 @@ function registerCheckpoints(spacesCmd) {
         .command("ls")
         .alias("list")
         .description("List checkpoints")
+        .option("--limit <n>", "Maximum checkpoints to return", (value) => Number(value))
+        .option("--cursor <cursor>", "Pagination cursor")
         .option("--json", "Output as JSON")
         .action(async (opts) => {
         const spaceId = resolveSpace(spacesCmd);
         const client = createClient();
         try {
-            const result = await client.space(spaceId).checkpoints.list();
+            const result = await client.space(spaceId).checkpoints.list({
+                limit: opts.limit,
+                cursor: opts.cursor,
+            });
             if (jsonRequested(opts))
                 return outJson(result);
             if (result.checkpoints.length === 0) {

package/dist/commands/works.d.ts

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

package/dist/commands/works.js

@@ -0,0 +1,266 @@
+import { createClient } from "../client.js";
+import { error, handleHttp, json as outJson, jsonRequested, ok, table } from "../output.js";
+import { resolveSpace } from "../space.js";
+const WORK_STATUSES = ["draft", "published", "disabled"];
+const collectOption = (value, previous = []) => [...previous, value];
+function parseChoice(value, name, choices) {
+    if (choices.includes(value))
+        return value;
+    return error(`Invalid ${name}`, `Use one of: ${choices.join(", ")}`);
+}
+function parseJsonObject(value, name) {
+    if (!value)
+        return undefined;
+    try {
+        const parsed = JSON.parse(value);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+            return parsed;
+    }
+    catch {
+        // handled below
+    }
+    return error(`Invalid ${name}`, `${name} must be a JSON object`);
+}
+function compactObject(input) {
+    return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
+}
+function resolveTarget(opts) {
+    const targets = [
+        opts.file ? { targetType: "file", targetRef: opts.file } : null,
+        opts.dir ? { targetType: "directory", targetRef: opts.dir } : null,
+        opts.port ? { targetType: "port", targetRef: opts.port } : null,
+    ].filter((target) => Boolean(target));
+    if (targets.length === 0)
+        return null;
+    if (targets.length > 1)
+        return error("Conflicting target", "Use only one of --file, --dir, or --port");
+    return targets[0] ?? null;
+}
+function resolveStatus(opts) {
+    const values = [opts.status, opts.draft ? "draft" : undefined, opts.disabled ? "disabled" : undefined].filter(Boolean);
+    if (values.length > 1)
+        return error("Conflicting status", "Use only one of --status, --draft, or --disabled");
+    return values[0] ? parseChoice(values[0], "status", WORK_STATUSES) : "published";
+}
+function printWork(work) {
+    table([work], [
+        { key: "id", label: "ID" },
+        { key: "slug", label: "Slug" },
+        { key: "status", label: "Status" },
+        { key: "targetType", label: "Target" },
+        { key: "targetRef", label: "Ref" },
+        { key: "latestVersion", label: "Version" },
+        { key: "publishedAt", label: "Published" },
+    ]);
+}
+async function confirmDelete(opts) {
+    if (opts.yes)
+        return;
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        return error("Confirmation required", "Pass --yes to delete the work.");
+    process.stdout.write("Deleting a work also removes its versions and viewer grants. Continue? [y/N] ");
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+        break;
+    }
+    const answer = Buffer.concat(chunks).toString().trim().toLowerCase();
+    if (answer !== "y" && answer !== "yes")
+        return error("Cancelled");
+}
+export function registerWorks(program) {
+    const worksCmd = program.command("works").description("Work management");
+    worksCmd
+        .command("ls")
+        .alias("list")
+        .description("List works in the target space")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        const spaceId = resolveSpace(worksCmd);
+        const client = createClient();
+        try {
+            const result = await client.works.listBySpace(spaceId);
+            if (jsonRequested(opts))
+                return outJson(result);
+            table(result.works, [
+                { key: "id", label: "ID" },
+                { key: "slug", label: "Slug" },
+                { key: "status", label: "Status" },
+                { key: "targetType", label: "Target" },
+                { key: "targetRef", label: "Ref" },
+                { key: "latestVersion", label: "Version" },
+                { key: "publishedAt", label: "Published" },
+            ]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    worksCmd
+        .command("get <id>")
+        .description("Show work details")
+        .option("--json", "Output as JSON")
+        .action(async (id, opts) => {
+        const client = createClient();
+        try {
+            const result = await client.works.get(id);
+            if (jsonRequested(opts))
+                return outJson(result);
+            printWork(result.work);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    worksCmd
+        .command("resolve <workSlug>")
+        .description("Resolve a published work by owner and space slug")
+        .option("--owner <username>", "Owner username")
+        .option("--space-slug <slug>", "Space slug")
+        .option("--json", "Output as JSON")
+        .action(async (workSlug, opts) => {
+        if (!opts.owner?.trim())
+            return error("Missing owner username", "Pass --owner <username>.");
+        if (!opts.spaceSlug?.trim())
+            return error("Missing space slug", "Pass --space-slug <slug>.");
+        const client = createClient();
+        try {
+            const result = await client.works.getBySlug(opts.owner.trim(), opts.spaceSlug.trim(), workSlug);
+            if (jsonRequested(opts))
+                return outJson(result);
+            printWork(result.work);
+            if (result.content?.url)
+                console.log(`\nURL: ${result.content.url}`);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    worksCmd
+        .command("publish <slug>")
+        .description("Create or publish a work in the target space")
+        .option("--file <path>", "Publish a HTML file")
+        .option("--dir <path>", "Publish a directory site")
+        .option("--port <port>", "Publish a public sandbox port")
+        .option("--draft", "Create as draft")
+        .option("--disabled", "Create as disabled")
+        .option("--status <status>", "Work status: draft, published, disabled")
+        .option("--work-scope <scope>", "Scope granted to the work runtime", collectOption, [])
+        .option("--viewer-scope <scope>", "Scope viewers may request", collectOption, [])
+        .option("--meta <json>", "Work metadata as a JSON object")
+        .option("--json", "Output as JSON")
+        .action(async (slug, opts) => {
+        const target = resolveTarget(opts);
+        if (!target)
+            return error("Missing target", "Use one of --file, --dir, or --port.");
+        const spaceId = resolveSpace(worksCmd);
+        const client = createClient();
+        const status = resolveStatus(opts);
+        const input = {
+            spaceId,
+            slug,
+            status,
+            targetType: target.targetType,
+            targetRef: target.targetRef,
+            workScopes: opts.workScope,
+            allowedViewerScopes: opts.viewerScope,
+            meta: parseJsonObject(opts.meta, "meta"),
+        };
+        try {
+            const result = await client.works.create(input);
+            if (jsonRequested(opts))
+                return outJson(result);
+            ok(`Work published: ${result.work.id}`);
+            printWork(result.work);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    worksCmd
+        .command("update <id>")
+        .description("Update work settings or publish a new version")
+        .option("--slug <slug>", "New work slug")
+        .option("--file <path>", "Use a HTML file target")
+        .option("--dir <path>", "Use a directory site target")
+        .option("--port <port>", "Use a public sandbox port target")
+        .option("--draft", "Set status to draft")
+        .option("--disabled", "Set status to disabled")
+        .option("--status <status>", "Work status: draft, published, disabled")
+        .option("--publish-version", "Force publishing a new version")
+        .option("--work-scope <scope>", "Scope granted to the work runtime", collectOption, [])
+        .option("--viewer-scope <scope>", "Scope viewers may request", collectOption, [])
+        .option("--clear-work-scopes", "Clear work runtime scopes")
+        .option("--clear-viewer-scopes", "Clear viewer-requestable scopes")
+        .option("--meta <json>", "Work metadata as a JSON object")
+        .option("--json", "Output as JSON")
+        .action(async (id, opts) => {
+        const target = resolveTarget(opts);
+        if (opts.clearWorkScopes && opts.workScope?.length)
+            return error("Conflicting work scopes", "Use either --work-scope or --clear-work-scopes.");
+        if (opts.clearViewerScopes && opts.viewerScope?.length)
+            return error("Conflicting viewer scopes", "Use either --viewer-scope or --clear-viewer-scopes.");
+        const input = compactObject({
+            slug: opts.slug,
+            status: opts.status || opts.draft || opts.disabled ? resolveStatus(opts) : undefined,
+            targetType: target?.targetType,
+            targetRef: target?.targetRef,
+            publishVersion: opts.publishVersion || undefined,
+            workScopes: opts.clearWorkScopes ? [] : opts.workScope?.length ? opts.workScope : undefined,
+            allowedViewerScopes: opts.clearViewerScopes ? [] : opts.viewerScope?.length ? opts.viewerScope : undefined,
+            meta: opts.meta !== undefined ? parseJsonObject(opts.meta, "meta") ?? null : undefined,
+        });
+        if (Object.keys(input).length === 0)
+            return error("Nothing to update", "Pass --slug, --file, --dir, --port, --status, --publish-version, --work-scope, --viewer-scope, --clear-work-scopes, --clear-viewer-scopes, or --meta.");
+        const client = createClient();
+        try {
+            const result = await client.works.update(id, input);
+            if (jsonRequested(opts))
+                return outJson(result);
+            ok("Work updated");
+            printWork(result.work);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    worksCmd
+        .command("versions <id>")
+        .description("List work versions")
+        .option("--json", "Output as JSON")
+        .action(async (id, opts) => {
+        const client = createClient();
+        try {
+            const result = await client.works.listVersions(id);
+            if (jsonRequested(opts))
+                return outJson(result);
+            table(result.versions, [
+                { key: "version", label: "Version" },
+                { key: "id", label: "ID" },
+                { key: "status", label: "Status" },
+                { key: "targetType", label: "Target" },
+                { key: "targetRef", label: "Ref" },
+                { key: "publishedAt", label: "Published" },
+            ]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+    worksCmd
+        .command("rm <id>")
+        .alias("delete")
+        .description("Delete a work")
+        .option("-y, --yes", "Confirm deletion")
+        .action(async (id, opts) => {
+        await confirmDelete(opts);
+        const client = createClient();
+        try {
+            await client.works.delete(id);
+            ok("Work deleted");
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
+}

package/dist/index.js

@@ -10,6 +10,7 @@ import { registerProfile } from "./commands/profile.js";
 import { registerSearch } from "./commands/search.js";
 import { registerPrompt, registerSpaces } from "./commands/spaces.js";
 import { registerTasks } from "./commands/tasks.js";
+import { registerWorks } from "./commands/works.js";
 import { ensureCliSelfUpdated } from "./self-update.js";
 const VERSION = (() => {
     try {
@@ -39,6 +40,7 @@ Common commands:
   cohub search "release notes"
   cohub -s <space-id> spaces sessions turns ls <session-id>
   cohub -s <space-id> spaces files ls
+  cohub -s <space-id> works publish demo --file dist/index.html
   cohub models ls
   cohub models ls --model-type multimodal
   cohub generate "A calm lake at sunrise" --model <model> --output lake.png
@@ -57,6 +59,7 @@ registerModels(program);
 registerSearch(program);
 registerTasks(program);
 registerCronJobs(program);
+registerWorks(program);
 const isVersionRequest = (argv) => argv.some((arg) => arg === "-v" || arg === "--version");
 try {
     if (!isVersionRequest(process.argv.slice(2))) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "1.17.3",
+  "version": "1.17.5",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "license": "UNLICENSED",
@@ -16,7 +16,7 @@
     "@neta-art/generation": "^0.1.5",
     "commander": "^14.0.3",
     "sharp": "^0.34.5",
-    "@neta-art/cohub": "1.28.0"
+    "@neta-art/cohub": "1.28.2"
   },
   "publishConfig": {
     "access": "public"