@neta-art/cohub-cli 1.1.4 → 1.3.0

package/dist/commands/tasks.js

@@ -1,8 +1,7 @@
-import { resolveToken } from "../auth.js";
 import { createClient } from "../client.js";
-import { table, json as outJson, error, handleHttp } from "../output.js";
+import { table, json as outJson, handleHttp } from "../output.js";
 export function registerTasks(program) {
-    const cmd = program.command("tasks").description("Task management");
+    const cmd = program.command("tasks", { hidden: true }).description("Task runs");
     cmd
         .command("ls")
         .alias("list")
@@ -11,10 +10,7 @@ export function registerTasks(program) {
         .option("--space <id>", "Filter by space")
         .option("--json", "Output as JSON")
         .action(async (opts) => {
-        const token = resolveToken();
-        if (!token)
-            return error("Not authenticated", "Run 'cohub auth login <token>'");
-        const client = createClient(token);
+        const client = createClient();
         try {
             const filters = {};
             if (opts.cronJob)
@@ -42,10 +38,7 @@ export function registerTasks(program) {
         .description("Task run details")
         .option("--json", "Output as JSON")
         .action(async (id, opts) => {
-        const token = resolveToken();
-        if (!token)
-            return error("Not authenticated");
-        const client = createClient(token);
+        const client = createClient();
         try {
             const result = await client.tasks.get(id);
             if (opts.json)

package/dist/index.js

@@ -4,11 +4,12 @@ import { readFileSync } from "node:fs";
 import { registerAuth } from "./commands/auth.js";
 import { registerChannels } from "./commands/channels.js";
 import { registerCronJobs } from "./commands/cron-jobs.js";
+import { registerGenerations } from "./commands/generations.js";
 import { registerModels } from "./commands/models.js";
-import { registerPrompts } from "./commands/prompts.js";
-import { registerSessionAccess } from "./commands/session-access.js";
-import { registerSpaces } from "./commands/spaces.js";
+import { registerSearch } from "./commands/search.js";
+import { registerPrompt, registerSpaces } from "./commands/spaces.js";
 import { registerTasks } from "./commands/tasks.js";
+import { ensureCliSelfUpdated } from "./self-update.js";
 const VERSION = (() => {
     try {
         const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
@@ -20,17 +21,48 @@ const VERSION = (() => {
 })();
 const program = new Command("cohub");
 program
-    .version(VERSION)
-    .description("CLI for Cohub — spaces, sessions, and agent collaboration.")
-    .option("-s, --space <id>", "Target space ID")
-    .option("--json", "Output as JSON")
-    .helpOption("-h, --help", "Show help");
+    .name("cohub")
+    .summary("Work with Cohub from your terminal")
+    .description("Send prompts, inspect sessions, manage space files, and generate multimodal outputs.")
+    .version(VERSION, "-v, --version", "Show version")
+    .option("-s, --space <id>", "Target space ID for prompt, files, sessions, and space-scoped commands")
+    .option("--json", "Print machine-readable JSON when supported")
+    .helpOption("-h, --help", "Show help")
+    .addHelpText("after", `
+
+Common commands:
+  cohub auth login
+  cohub spaces ls
+  cohub -s <space-id> prompt "Fix the failing tests"
+  cohub search "release notes"
+  cohub -s <space-id> spaces sessions turns ls <session-id>
+  cohub -s <space-id> spaces files ls
+  cohub models ls
+  cohub models ls --model-type multimodal
+  cohub generate "A calm lake at sunrise" --model <model> --output lake.png
+
+Environment:
+  COHUB_EXECUTION_TOKEN  Use this token instead of the stored Logto session
+  ENV=dev                Use the development Cohub environment
+`);
 registerAuth(program);
+registerPrompt(program);
 registerSpaces(program);
 registerChannels(program);
+registerGenerations(program);
 registerModels(program);
-registerPrompts(program);
+registerSearch(program);
 registerTasks(program);
 registerCronJobs(program);
-registerSessionAccess(program);
+const isVersionRequest = (argv) => argv.some((arg) => arg === "-v" || arg === "--version");
+try {
+    if (!isVersionRequest(process.argv.slice(2))) {
+        await ensureCliSelfUpdated();
+    }
+}
+catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`cohub self-update failed: ${message}\n`);
+    process.exit(1);
+}
 program.parse();

package/dist/output.js

@@ -47,6 +47,9 @@ export function error(msg, detail) {
 }
 // -- HTTP error handler ------------------------------------------------------
 export function handleHttp(e) {
+    if (e instanceof Error && e.name === "AuthRequiredError") {
+        return error("Not authenticated", "Run `cohub auth login`.");
+    }
     const status = e.status;
     const body = e.body;
     const msg = e instanceof Error ? e.message : String(e);

package/dist/self-update.d.ts

@@ -0,0 +1 @@
+export declare function ensureCliSelfUpdated(): Promise<void>;

package/dist/self-update.js

@@ -0,0 +1,136 @@
+import { spawn } from "node:child_process";
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+const PACKAGE_NAME = "@neta-art/cohub-cli";
+const DEFAULT_INTERVAL_MS = 6 * 60 * 60 * 1000;
+const DEFAULT_TIMEOUT_MS = 60_000;
+const LOCK_STALE_MS = 5 * 60 * 1000;
+const STATE_PATH = join(homedir(), ".cache", "cohub-cli", "self-update.json");
+const LOCK_PATH = join(homedir(), ".cache", "cohub-cli", "self-update.lock");
+const parsePositiveIntEnv = (name, fallback) => {
+    const raw = process.env[name]?.trim();
+    if (!raw)
+        return fallback;
+    const value = Number.parseInt(raw, 10);
+    return Number.isFinite(value) && value > 0 ? value : fallback;
+};
+const getIntervalMs = () => {
+    const explicitMs = process.env.COHUB_CLI_UPDATE_INTERVAL_MS;
+    if (explicitMs?.trim())
+        return parsePositiveIntEnv("COHUB_CLI_UPDATE_INTERVAL_MS", DEFAULT_INTERVAL_MS);
+    const hours = process.env.COHUB_CLI_UPDATE_INTERVAL_HOURS;
+    if (hours?.trim()) {
+        const value = Number.parseFloat(hours);
+        if (Number.isFinite(value) && value > 0)
+            return Math.round(value * 60 * 60 * 1000);
+    }
+    return DEFAULT_INTERVAL_MS;
+};
+const getTimeoutMs = () => parsePositiveIntEnv("COHUB_CLI_UPDATE_TIMEOUT_MS", DEFAULT_TIMEOUT_MS);
+const readState = () => {
+    try {
+        return JSON.parse(readFileSync(STATE_PATH, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+};
+const writeState = () => {
+    mkdirSync(dirname(STATE_PATH), { recursive: true });
+    writeFileSync(STATE_PATH, `${JSON.stringify({ lastUpdatedAt: new Date().toISOString() }, null, 2)}\n`);
+};
+const isDue = () => {
+    const state = readState();
+    if (!state.lastUpdatedAt)
+        return true;
+    const lastUpdatedAt = Date.parse(state.lastUpdatedAt);
+    if (!Number.isFinite(lastUpdatedAt))
+        return true;
+    return Date.now() - lastUpdatedAt >= getIntervalMs();
+};
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const acquireLock = async (timeoutMs) => {
+    mkdirSync(dirname(LOCK_PATH), { recursive: true });
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        try {
+            mkdirSync(LOCK_PATH);
+            writeFileSync(join(LOCK_PATH, "pid"), `${process.pid}\n${Date.now()}\n`);
+            return true;
+        }
+        catch {
+            try {
+                const raw = readFileSync(join(LOCK_PATH, "pid"), "utf-8");
+                const timestamp = Number.parseInt(raw.trim().split(/\s+/).at(-1) ?? "0", 10);
+                if (!Number.isFinite(timestamp) || Date.now() - timestamp > LOCK_STALE_MS) {
+                    rmSync(LOCK_PATH, { recursive: true, force: true });
+                    continue;
+                }
+            }
+            catch {
+                rmSync(LOCK_PATH, { recursive: true, force: true });
+                continue;
+            }
+            await sleep(250);
+        }
+    }
+    return false;
+};
+const releaseLock = () => {
+    rmSync(LOCK_PATH, { recursive: true, force: true });
+};
+const runNpmUpdate = (timeoutMs) => {
+    return new Promise((resolve, reject) => {
+        const child = spawn("npm", ["install", "-g", `${PACKAGE_NAME}@latest`, "--silent"], {
+            stdio: ["ignore", "pipe", "pipe"],
+            env: process.env,
+        });
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+        child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+        const timer = setTimeout(() => {
+            child.kill("SIGTERM");
+            setTimeout(() => child.kill("SIGKILL"), 3000).unref();
+        }, timeoutMs);
+        timer.unref();
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.on("close", (code, signal) => {
+            clearTimeout(timer);
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            const stdout = Buffer.concat(stdoutChunks).toString().trim();
+            const stderr = Buffer.concat(stderrChunks).toString().trim();
+            const detail = [stderr, stdout].filter(Boolean).join("\n");
+            reject(new Error(`npm install -g ${PACKAGE_NAME}@latest failed${signal ? ` (${signal})` : code !== null ? ` (exit ${code})` : ""}${detail ? `:\n${detail}` : ""}`));
+        });
+    });
+};
+export async function ensureCliSelfUpdated() {
+    if (process.env.COHUB_CLI_AUTO_UPDATE === "0")
+        return;
+    if (!isDue())
+        return;
+    const timeoutMs = getTimeoutMs();
+    const locked = await acquireLock(timeoutMs);
+    if (!locked) {
+        throw new Error(`Timed out waiting for ${PACKAGE_NAME} self-update lock after ${timeoutMs}ms`);
+    }
+    try {
+        // Another process may have completed the update while this process was
+        // waiting for the lock.
+        if (!isDue())
+            return;
+        await runNpmUpdate(timeoutMs);
+        writeState();
+    }
+    finally {
+        releaseLock();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "1.1.4",
+  "version": "1.3.0",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "license": "UNLICENSED",
@@ -14,7 +14,7 @@
   ],
   "dependencies": {
     "commander": "^13.1.0",
-    "@neta-art/cohub": "1.7.1"
+    "@neta-art/cohub": "1.9.0"
   },
   "publishConfig": {
     "access": "public"