@neta-art/cohub-cli 8.4.0 → 8.4.1

package/dist/commands/boards.js

@@ -1,6 +1,5 @@
 import { randomUUID } from "node:crypto";
 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";
@@ -127,6 +126,16 @@ function parseExportRegion(options) {
     }
     return { kind: "all" };
 }
+const BOARD_EXPORT_FORMATS = ["png", "jpeg", "webp"];
+/** Infer the output format from the file extension, defaulting to PNG. */
+function formatFromPath(path) {
+    const lower = path.toLowerCase();
+    if (lower.endsWith(".jpg") || lower.endsWith(".jpeg"))
+        return "jpeg";
+    if (lower.endsWith(".webp"))
+        return "webp";
+    return "png";
+}
 function parseExportFormat(options, outPath) {
     if (!options.format)
         return formatFromPath(outPath);
@@ -170,6 +179,7 @@ function registerExportCommand(boards) {
             const out = options.out;
             if (!out)
                 throw new Error("--out is required");
+            const { runBoardExport } = await import("../board-export.js");
             const result = await runBoardExport({
                 spaceId: await resolveSpace(boards),
                 target: board,

package/dist/commands/desktop.js

@@ -1,5 +1,5 @@
 import { readFileSync } from "node:fs";
-import { HttpError, parseAppRef, resolveOpenSurface, DESKTOP_COMMAND_DEFAULT_TIMEOUT_MS, DESKTOP_COMMAND_MAX_TIMEOUT_MS, } from "@neta-art/cohub";
+import { HttpError, parseAppRef, resolveOpenSurface, DESKTOP_COMMAND_ACCEPT_TIMEOUT_MS, DESKTOP_COMMAND_DEFAULT_TIMEOUT_MS, DESKTOP_COMMAND_MAX_TIMEOUT_MS, DESKTOP_COMMAND_OPEN_TIMEOUT_MS, } from "@neta-art/cohub";
 import { createClient } from "../client.js";
 import { error, handleHttp, json as outJson, jsonRequested, ok } from "../output.js";
 import { resolveBoundSpace } from "../space.js";
@@ -66,7 +66,7 @@ function readCallInput(opts) {
 }
 function parseTimeout(value) {
     if (!value)
-        return DESKTOP_COMMAND_DEFAULT_TIMEOUT_MS;
+        return undefined;
     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.`);
@@ -200,6 +200,8 @@ Notes:
     scheme is still accepted.
   - A plain target checks the explicit Space or current directory Runtime binding for a file before resolving an app; it does not fall back to Home.
   - Opening a window is idempotent; repeating it re-activates the same tab.
+  - A desktop that does not respond within ${DESKTOP_COMMAND_ACCEPT_TIMEOUT_MS / 1_000} seconds (closed, asleep, or
+    offline) fails fast with no_active_client instead of waiting out the timeout.
   - --as picks the surface: window (a preview tab) or overlay (a transparent
     layer above the workspace). Without it, an App published with
     <meta name="cohub:surface" content="overlay"> opens as an overlay.
@@ -217,7 +219,7 @@ function registerOpen(parent, deprecated) {
         .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("--as <surface>", "Surface role for app targets: window (default) or overlay")
-        .option("--timeout-ms <ms>", `How long to wait for the desktop (default: ${DESKTOP_COMMAND_DEFAULT_TIMEOUT_MS}; max: ${DESKTOP_COMMAND_MAX_TIMEOUT_MS})`)
+        .option("--timeout-ms <ms>", `How long to wait for the desktop (default: ${DESKTOP_COMMAND_OPEN_TIMEOUT_MS}, or ${DESKTOP_COMMAND_DEFAULT_TIMEOUT_MS} with --call; max: ${DESKTOP_COMMAND_MAX_TIMEOUT_MS})`)
         .option("--json", "Output as JSON")
         .action(async (target, opts, thisCommand) => {
         if (deprecated) {

package/dist/self-update.d.ts

@@ -1,5 +1,6 @@
 export declare const SELF_UPDATE_WORKER_ENV = "COHUB_CLI_SELF_UPDATE_WORKER";
 export type CliSelfUpdateResult = "current" | "updated" | "updated-by-peer";
+export declare function isNewerVersion(candidate: string, installed: string | undefined): boolean;
 export declare function resolveSelfUpdateResult(beforeVersion: string | undefined, afterVersion: string | undefined, updatedByPeer: boolean): CliSelfUpdateResult;
 export declare const isCliSelfUpdateDue: () => boolean;
 export declare function startCliSelfUpdate(entrypoint: string): void;

package/dist/self-update.js

@@ -38,9 +38,9 @@ const readState = () => {
         return {};
     }
 };
-const writeState = () => {
+const writeState = (state) => {
     mkdirSync(dirname(STATE_PATH), { recursive: true });
-    writeFileSync(STATE_PATH, `${JSON.stringify({ lastUpdatedAt: new Date().toISOString() }, null, 2)}\n`);
+    writeFileSync(STATE_PATH, `${JSON.stringify({ checkedAt: new Date().toISOString(), ...state }, null, 2)}\n`);
 };
 const readInstalledVersion = () => {
     try {
@@ -51,19 +51,35 @@ const readInstalledVersion = () => {
         return undefined;
     }
 };
+const parseVersion = (value) => {
+    const match = /^(\d+)\.(\d+)\.(\d+)(-.+)?$/.exec(value.trim());
+    if (!match)
+        return null;
+    const core = [Number(match[1]), Number(match[2]), Number(match[3])];
+    return { core, prerelease: Boolean(match[4]) };
+};
+export function isNewerVersion(candidate, installed) {
+    const next = parseVersion(candidate);
+    if (!next)
+        return false;
+    const current = installed === undefined ? null : parseVersion(installed);
+    if (!current)
+        return true;
+    const [major, minor, patch] = next.core;
+    const [installedMajor, installedMinor, installedPatch] = current.core;
+    const delta = major - installedMajor || minor - installedMinor || patch - installedPatch;
+    return delta === 0 ? current.prerelease && !next.prerelease : delta > 0;
+}
 export function resolveSelfUpdateResult(beforeVersion, afterVersion, updatedByPeer) {
     if (beforeVersion !== undefined && beforeVersion === afterVersion)
         return "current";
     return updatedByPeer ? "updated-by-peer" : "updated";
 }
 export const isCliSelfUpdateDue = () => {
-    const state = readState();
-    if (!state.lastUpdatedAt)
+    const checkedAt = Date.parse(readState().checkedAt ?? "");
+    if (!Number.isFinite(checkedAt))
         return true;
-    const lastUpdatedAt = Date.parse(state.lastUpdatedAt);
-    if (!Number.isFinite(lastUpdatedAt))
-        return true;
-    return Date.now() - lastUpdatedAt >= getIntervalMs();
+    return Date.now() - checkedAt >= getIntervalMs();
 };
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 const acquireLock = async (timeoutMs) => {
@@ -96,9 +112,9 @@ const acquireLock = async (timeoutMs) => {
 const releaseLock = () => {
     rmSync(LOCK_PATH, { recursive: true, force: true });
 };
-const runNpmUpdate = (timeoutMs) => {
+const runNpm = (args, timeoutMs) => {
     return new Promise((resolve, reject) => {
-        const child = spawn("npm", ["install", "-g", `${PACKAGE_NAME}@latest`, "--silent"], {
+        const child = spawn("npm", args, {
             stdio: ["ignore", "pipe", "pipe"],
             env: process.env,
         });
@@ -117,14 +133,14 @@ const runNpmUpdate = (timeoutMs) => {
         });
         child.on("close", (code, signal) => {
             clearTimeout(timer);
+            const stdout = Buffer.concat(stdoutChunks).toString().trim();
             if (code === 0) {
-                resolve();
+                resolve(stdout);
                 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}` : ""}`));
+            reject(new Error(`npm ${args.join(" ")} failed${signal ? ` (${signal})` : code !== null ? ` (exit ${code})` : ""}${detail ? `:\n${detail}` : ""}`));
         });
     });
 };
@@ -156,9 +172,29 @@ export async function ensureCliSelfUpdated() {
         if (!isCliSelfUpdateDue()) {
             return resolveSelfUpdateResult(beforeVersion, readInstalledVersion(), true);
         }
-        await runNpmUpdate(timeoutMs);
-        writeState();
-        return resolveSelfUpdateResult(beforeVersion, readInstalledVersion(), false);
+        // Reinstalling briefly removes the `cohub` bin, so only do it for a newer release.
+        let latestVersion;
+        try {
+            latestVersion = await runNpm(["view", `${PACKAGE_NAME}@latest`, "version"], timeoutMs);
+            if (!isNewerVersion(latestVersion, beforeVersion)) {
+                writeState({ installedVersion: beforeVersion, latestVersion, result: "current" });
+                return "current";
+            }
+            await runNpm(["install", "-g", `${PACKAGE_NAME}@${latestVersion}`, "--silent"], timeoutMs);
+        }
+        catch (error) {
+            writeState({
+                installedVersion: beforeVersion,
+                latestVersion,
+                result: "failed",
+                error: (error instanceof Error ? error.message : String(error)).slice(0, 500),
+            });
+            throw error;
+        }
+        const afterVersion = readInstalledVersion();
+        const result = resolveSelfUpdateResult(beforeVersion, afterVersion, false);
+        writeState({ installedVersion: afterVersion, latestVersion, result });
+        return result;
     }
     finally {
         releaseLock();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "8.4.0",
+  "version": "8.4.1",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "engines": {
@@ -20,25 +20,29 @@
   "dependencies": {
     "@neta-art/generation": "^0.1.30",
     "commander": "^15.0.0",
-    "pixi.js": "^8.20.1",
     "sharp": "^0.35.4",
     "ws": "^8.21.3",
-    "@neta-art/cohub": "8.23.0"
+    "@neta-art/cohub": "8.24.0"
   },
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
+    "@fontsource/geist": "^5.3.0",
+    "@fontsource/geist-mono": "^5.3.0",
     "@types/node": "^26.4.0",
     "@types/ws": "^8.18.1",
+    "pixi.js": "^8.20.1",
+    "tsdown": "^0.22.14",
     "typescript": "^7.0.2"
   },
   "optionalDependencies": {
     "@napi-rs/canvas": "^1.0.8"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "tsc -p tsconfig.build.json && tsdown",
     "verify:sandboxd": "node --import tsx scripts/verify-sandboxd-release.ts",
+    "verify:board-kernel": "node --import tsx scripts/verify-board-kernel.ts",
     "test": "node ../../scripts/test/run.mjs 'tests/**/*.test.ts'",
     "test:runtime": "node --import tsx --test tests/runtime-*.integration.ts",
     "test:runtime:native": "node --import tsx tests/runtime-native.smoke.ts",