@neta-art/cohub-cli 1.20.1 → 1.20.3

package/README.md

@@ -60,19 +60,25 @@ cohub spaces prompt -h
 ```bash
 cohub spaces ls --json
 cohub spaces get <spaceId> --json
+cohub -s <spaceId> spaces get
+COHUB_SPACE_ID=<spaceId> cohub spaces get
 cohub spaces create --name "<name>" --description "<description>" --json
+cohub spaces update <spaceId> --slug <space-slug>
 cohub spaces rename <spaceId> "<new name>"
+cohub -s <spaceId> run -- git status
 ```
 
 Many space-scoped commands need a target Space:
 
 ```bash
 cohub -s <spaceId> spaces prompt "message" --json
+COHUB_SPACE_ID=<spaceId> cohub spaces prompt "message" --json
 ```
 
 ## Chats and prompts
 
 Use `spaces prompt` for immediate sends, delayed sends, one-time schedules, recurring schedules, new Chats, and existing Chats.
+Use `run` for a one-off shell command in the current Space workspace.
 
 ```bash
 # Send now
@@ -175,9 +181,11 @@ Confirm before deleting files or directories.
 
 ## Works
 
-Publish and manage Work entries from a Space workspace.
+Publish and manage Work entries from a Space workspace. Public Work URLs require a username and a Space slug.
 
 ```bash
+cohub profile update --username <username>
+cohub spaces update <spaceId> --slug <space-slug>
 cohub -s <spaceId> works ls --json
 cohub works get <workId> --json
 cohub -s <spaceId> works publish demo --file dist/index.html
@@ -204,6 +212,16 @@ cohub -s <spaceId> spaces checkpoints get <checkpointId> --json
 cohub -s <spaceId> spaces checkpoints create "<description>" --json
 ```
 
+## Run commands
+
+```bash
+cohub -s <spaceId> run -- git status
+cohub -s <spaceId> run --command "pnpm test"
+cohub -s <spaceId> run --async --command "pnpm build"
+```
+
+Use `run` for one-off shell commands in a Space workspace. Use `--async` to queue and return immediately.
+
 ## Tasks
 
 ```bash

package/dist/commands/profile.js

@@ -1,8 +1,33 @@
 import { uploadAvatarAsset } from "../avatar.js";
 import { createClient } from "../client.js";
-import { json as outJson, jsonRequested, ok, handleHttp } from "../output.js";
+import { json as outJson, jsonRequested, ok, error, handleHttp } from "../output.js";
 export function registerProfile(program) {
     const profileCmd = program.command("profile").description("Manage your profile");
+    profileCmd
+        .command("update")
+        .description("Update your profile")
+        .option("--username <username>", "Public username")
+        .option("--display-name <name>", "Display name")
+        .option("--json", "Output as JSON")
+        .action(async (opts) => {
+        const input = {
+            username: opts.username,
+            displayName: opts.displayName,
+        };
+        if (input.username === undefined && input.displayName === undefined) {
+            return error("Nothing to update", "Pass --username or --display-name.");
+        }
+        const client = createClient();
+        try {
+            const result = await client.user.updateProfile(input);
+            if (jsonRequested(opts))
+                return outJson(result);
+            ok("Profile updated");
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
     profileCmd
         .command("avatar <path>")
         .description("Upload your avatar")

package/dist/commands/run.d.ts

@@ -0,0 +1 @@
+export declare function maybeHandleRunCommand(argv: string[]): Promise<boolean>;

package/dist/commands/run.js

@@ -0,0 +1,233 @@
+import { createClient } from "../client.js";
+import { error, handleHttp, json as outJson, spinner } from "../output.js";
+const DEFAULT_WAIT_TIMEOUT_MS = (6 * 60 * 60 + 60) * 1000;
+const DEFAULT_POLL_INTERVAL_MS = 1500;
+function shellQuote(value) {
+    if (value.length === 0)
+        return "''";
+    if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(value))
+        return value;
+    return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function shellJoin(values) {
+    return values.map((value) => shellQuote(value)).join(" ");
+}
+function topLevelRunIndex(argv) {
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === "--")
+            return -1;
+        if (token === "-s" || token === "--space") {
+            index += 1;
+            continue;
+        }
+        if (token.startsWith("--space=") || token === "--json")
+            continue;
+        if (token.startsWith("-"))
+            continue;
+        return token === "run" ? index : -1;
+    }
+    return -1;
+}
+function parseSpaceId(tokens) {
+    for (let index = 0; index < tokens.length; index += 1) {
+        const token = tokens[index];
+        if (token === "-s" || token === "--space") {
+            const value = tokens[index + 1];
+            if (!value)
+                return error("Missing space", `${token} requires a value`);
+            return value.trim() || undefined;
+        }
+        if (token.startsWith("--space="))
+            return token.slice("--space=".length).trim() || undefined;
+    }
+    return undefined;
+}
+function parseRunCliOptions(argv) {
+    const runIndex = topLevelRunIndex(argv);
+    if (runIndex < 0)
+        return error("Invalid invocation", "Use `cohub run [options] <command>`");
+    const beforeRun = argv.slice(0, runIndex);
+    const afterRun = argv.slice(runIndex + 1);
+    let spaceId = parseSpaceId(beforeRun) ?? process.env.COHUB_SPACE_ID?.trim() ?? "";
+    let json = beforeRun.includes("--json");
+    let async = false;
+    let commandOption = null;
+    let positionalTokens = [];
+    for (let index = 0; index < afterRun.length; index += 1) {
+        const token = afterRun[index];
+        if (token === "-h" || token === "--help") {
+            printRunHelp();
+            process.exit(0);
+        }
+        if (token === "--async") {
+            async = true;
+            continue;
+        }
+        if (token === "--json") {
+            json = true;
+            continue;
+        }
+        if (token === "-c" || token === "--command") {
+            const value = afterRun[index + 1];
+            if (!value)
+                return error("Missing command", `${token} requires a value`);
+            if (commandOption !== null || positionalTokens.length > 0) {
+                return error("Conflicting command input", "Use either --command or positional command tokens, not both.");
+            }
+            commandOption = value;
+            index += 1;
+            continue;
+        }
+        if (token.startsWith("--command=")) {
+            if (commandOption !== null || positionalTokens.length > 0) {
+                return error("Conflicting command input", "Use either --command or positional command tokens, not both.");
+            }
+            commandOption = token.slice("--command=".length);
+            continue;
+        }
+        if (token === "--") {
+            if (commandOption !== null) {
+                return error("Conflicting command input", "Use either --command or positional command tokens, not both.");
+            }
+            positionalTokens = afterRun.slice(index + 1);
+            break;
+        }
+        if (commandOption !== null) {
+            return error("Conflicting command input", "Use either --command or positional command tokens, not both.");
+        }
+        positionalTokens = afterRun.slice(index);
+        break;
+    }
+    const command = commandOption?.trim() || shellJoin(positionalTokens).trim();
+    if (!command) {
+        return error("No command", "Pass --command <shell command>, or use `--` followed by the command.");
+    }
+    if (!spaceId) {
+        return error("Missing required space", "Add -s, --space <id> before `run` or set COHUB_SPACE_ID.");
+    }
+    return { spaceId, json, async, command };
+}
+function printRunHelp() {
+    process.stdout.write(`
+Usage:
+  cohub [-s <spaceId>] run [options] -- <shell command>
+  cohub [-s <spaceId>] run --command <shell command>
+
+Options:
+  -c, --command <command>  Shell command to execute in the space workspace
+      --async              Queue the command and return immediately
+      --json               Output as JSON
+  -h, --help               Show this help
+
+Examples:
+  cohub -s <spaceId> run --command "git status"
+  cohub -s <spaceId> run --async --command "pnpm test"
+  cohub -s <spaceId> run -- git status -sb
+
+Notes:
+  - Use --command for commands that contain leading flags, or use -- before the shell command.
+  - The command runs in /workspace.
+`);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function formatElapsed(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const restSeconds = seconds % 60;
+    if (minutes < 60)
+        return restSeconds > 0 ? `${minutes}m ${restSeconds}s` : `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    const restMinutes = minutes % 60;
+    return restMinutes > 0 ? `${hours}h ${restMinutes}m` : `${hours}h`;
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function parseRunResult(detail) {
+    const result = asRecord(detail.run.result);
+    const terminationRecord = asRecord(result?.termination);
+    return {
+        exitCode: typeof result?.exitCode === "number" ? result.exitCode : null,
+        termination: terminationRecord && (terminationRecord.reason === "exited" || terminationRecord.reason === "timed_out" || terminationRecord.reason === "aborted")
+            ? {
+                reason: terminationRecord.reason,
+                exitCode: typeof terminationRecord.exitCode === "number" ? terminationRecord.exitCode : null,
+                ...(typeof terminationRecord.timeoutSecs === "number" ? { timeoutSecs: terminationRecord.timeoutSecs } : {}),
+                ...(typeof terminationRecord.message === "string" ? { message: terminationRecord.message } : {}),
+            }
+            : undefined,
+        durationMs: typeof result?.durationMs === "number" ? result.durationMs : 0,
+        output: typeof result?.output === "string" ? result.output : "",
+        truncated: Boolean(result?.truncated),
+    };
+}
+function writeOutput(output) {
+    if (!output)
+        return;
+    process.stdout.write(output.endsWith("\n") ? output : `${output}\n`);
+}
+async function waitForRunCompletion(taskRunId, showSpinner) {
+    const client = createClient();
+    const startedAt = Date.now();
+    const spin = showSpinner ? spinner() : null;
+    if (spin)
+        spin.start(`Waiting for command task ${taskRunId}`);
+    while (true) {
+        const detail = await client.tasks.get(taskRunId);
+        if (detail.run.status === "completed" || detail.run.status === "failed") {
+            if (spin)
+                spin.stop(`Finished in ${formatElapsed(Date.now() - startedAt)}`);
+            return detail;
+        }
+        const elapsedMs = Date.now() - startedAt;
+        if (elapsedMs > DEFAULT_WAIT_TIMEOUT_MS) {
+            if (spin)
+                spin.stop(`Timed out after ${formatElapsed(DEFAULT_WAIT_TIMEOUT_MS)}`);
+            return error("Timed out waiting for run command", `taskRunId: ${taskRunId}`);
+        }
+        if (spin)
+            spin.update(`Running... ${formatElapsed(elapsedMs)}`);
+        await sleep(DEFAULT_POLL_INTERVAL_MS);
+    }
+}
+async function handleRunCli(argv) {
+    const opts = parseRunCliOptions(argv);
+    const client = createClient();
+    try {
+        const { taskRunId } = await client.space(opts.spaceId).runCommand({ command: opts.command });
+        if (opts.async) {
+            if (opts.json)
+                return outJson({ taskRunId });
+            process.stderr.write(`  Command queued — taskRunId: ${taskRunId}\n`);
+            return;
+        }
+        const detail = await waitForRunCompletion(taskRunId, !opts.json);
+        if (detail.run.status === "failed") {
+            const message = detail.run.errorMessage?.trim() || `Command task failed: ${taskRunId}`;
+            return error(message);
+        }
+        const result = parseRunResult(detail);
+        if (opts.json) {
+            return outJson({ taskRunId, run: detail.run, progress: detail.progress, ...result });
+        }
+        writeOutput(result.output);
+        process.exitCode = result.exitCode ?? 0;
+        process.stderr.write(`  Command finished — taskRunId: ${taskRunId}, exitCode: ${result.exitCode ?? "unknown"}, duration: ${formatElapsed(result.durationMs)}${result.truncated ? ", output truncated" : ""}\n`);
+    }
+    catch (e) {
+        handleHttp(e);
+    }
+}
+export async function maybeHandleRunCommand(argv) {
+    if (topLevelRunIndex(argv) < 0)
+        return false;
+    await handleRunCli(argv);
+    return true;
+}

package/dist/commands/spaces.js

@@ -296,18 +296,20 @@ export function registerSpaces(program) {
     });
     // ── spaces get ──
     spacesCmd
-        .command("get <id>")
+        .command("get [id]")
         .description("Show space details")
         .option("--json", "Output as JSON")
         .action(async (id, opts) => {
+        const spaceId = id?.trim() || resolveSpace(spacesCmd);
         const client = createClient();
         try {
-            const space = await client.spaces.get(id);
+            const space = await client.spaces.get(spaceId);
             if (jsonRequested(opts))
                 return outJson(space);
             table([space], [
                 { key: "id", label: "ID" },
                 { key: "name", label: "Name" },
+                { key: "slug", label: "Slug" },
                 { key: "description", label: "Description" },
                 { key: "status", label: "Status" },
                 { key: "createdAt", label: "Created" },
@@ -348,6 +350,37 @@ export function registerSpaces(program) {
             handleHttp(e);
         }
     });
+    // ── spaces update ──
+    spacesCmd
+        .command("update <id>")
+        .description("Update a space")
+        .option("--name <name>", "Space name")
+        .option("--slug <slug>", "Public space slug")
+        .option("--json", "Output as JSON")
+        .action(async (id, opts) => {
+        const input = {
+            name: opts.name,
+            slug: opts.slug,
+        };
+        if (input.name === undefined && input.slug === undefined) {
+            return error("Nothing to update", "Pass --name or --slug.");
+        }
+        const client = createClient();
+        try {
+            const result = await client.space(id).update(input);
+            if (jsonRequested(opts))
+                return outJson(result);
+            ok("Space updated");
+            table([result.space], [
+                { key: "id", label: "ID" },
+                { key: "name", label: "Name" },
+                { key: "slug", label: "Slug" },
+            ]);
+        }
+        catch (e) {
+            handleHttp(e);
+        }
+    });
     // ── spaces rename ──
     spacesCmd
         .command("rename <id> <name>")

package/dist/index.js

@@ -10,6 +10,7 @@ import { registerModels } from "./commands/models.js";
 import { registerProfile } from "./commands/profile.js";
 import { registerSearch } from "./commands/search.js";
 import { registerPrompt, registerSpaces } from "./commands/spaces.js";
+import { maybeHandleRunCommand } from "./commands/run.js";
 import { registerTasks } from "./commands/tasks.js";
 import { registerWorks } from "./commands/works.js";
 import { ensureCliSelfUpdated } from "./self-update.js";
@@ -38,6 +39,7 @@ Common commands:
   cohub profile avatar ./avatar.png
   cohub spaces ls
   cohub -s <space-id> prompt "Fix the failing tests"
+  cohub -s <space-id> run -- git status
   cohub search "release notes"
   cohub -s <space-id> spaces sessions turns ls <session-id>
   cohub -s <space-id> spaces files ls
@@ -64,7 +66,11 @@ registerCronJobs(program);
 registerWorks(program);
 const isVersionRequest = (argv) => argv.some((arg) => arg === "-v" || arg === "--version");
 try {
-    if (!isVersionRequest(process.argv.slice(2))) {
+    const argv = process.argv.slice(2);
+    if (await maybeHandleRunCommand(argv)) {
+        process.exit();
+    }
+    if (!isVersionRequest(argv)) {
         await ensureCliSelfUpdated();
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "1.20.1",
+  "version": "1.20.3",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "license": "UNLICENSED",