@neta-art/cohub-cli 3.8.0 → 3.8.2

package/bin/cohub.js

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-import "../dist/index.js";
+import "../dist/bootstrap.js";

package/dist/bootstrap.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bootstrap.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import { relaunchCli } from "./launcher.js";
+import { ensureCliSelfUpdated } from "./self-update.js";
+const argv = process.argv.slice(2);
+const isVersionRequest = argv.some((arg) => arg === "-v" || arg === "--version");
+let shouldRelaunch = false;
+try {
+    if (!isVersionRequest) {
+        shouldRelaunch = await ensureCliSelfUpdated() !== "current";
+    }
+}
+catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`cohub self-update failed: ${message}\n`);
+    process.stderr.write("run with --version to skip self-update\n");
+    process.exit(1);
+}
+if (shouldRelaunch) {
+    const entrypoint = process.argv[1];
+    if (!entrypoint) {
+        process.stderr.write("cohub failed to locate its updated entrypoint\n");
+        process.exit(1);
+    }
+    try {
+        process.exitCode = await relaunchCli(entrypoint, argv);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`cohub failed to launch the updated CLI: ${message}\n`);
+        process.exitCode = 1;
+    }
+}
+else {
+    await import("./index.js");
+}

package/dist/index.js

@@ -20,7 +20,6 @@ import { registerSandbox } from "./commands/sandbox.js";
 import { registerTasks } from "./commands/tasks.js";
 import { registerUi } from "./commands/ui.js";
 import { registerWorks } from "./commands/works.js";
-import { ensureCliSelfUpdated } from "./self-update.js";
 const VERSION = (() => {
     try {
         const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
@@ -84,20 +83,8 @@ registerTasks(program);
 registerCronJobs(program);
 registerWorks(program);
 registerUi(program);
-const isVersionRequest = (argv) => argv.some((arg) => arg === "-v" || arg === "--version");
-try {
-    const argv = process.argv.slice(2);
-    if (await maybeHandleRunCommand(argv)) {
-        process.exit();
-    }
-    if (!isVersionRequest(argv)) {
-        await ensureCliSelfUpdated();
-    }
-}
-catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    process.stderr.write(`cohub self-update failed: ${message}\n`);
-    process.stderr.write("run with --version to skip self-update\n");
-    process.exit(1);
+const argv = process.argv.slice(2);
+if (await maybeHandleRunCommand(argv)) {
+    process.exit();
 }
 program.parse();

package/dist/launcher.d.ts

@@ -0,0 +1,2 @@
+export declare function exitCodeForChild(code: number | null, signal: NodeJS.Signals | null): number;
+export declare function relaunchCli(entrypoint: string, argv: string[]): Promise<number>;

package/dist/launcher.js

@@ -0,0 +1,38 @@
+import { spawn } from "node:child_process";
+import { constants } from "node:os";
+const FORWARDED_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+export function exitCodeForChild(code, signal) {
+    if (code !== null)
+        return code;
+    if (!signal)
+        return 1;
+    return 128 + (constants.signals[signal] ?? 1);
+}
+export function relaunchCli(entrypoint, argv) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [entrypoint, ...argv], {
+            env: process.env,
+            stdio: "inherit",
+        });
+        const signalHandlers = FORWARDED_SIGNALS.map((signal) => {
+            const forward = () => {
+                if (child.exitCode === null && child.signalCode === null)
+                    child.kill(signal);
+            };
+            process.on(signal, forward);
+            return [signal, forward];
+        });
+        const cleanup = () => {
+            for (const [signal, forward] of signalHandlers)
+                process.off(signal, forward);
+        };
+        child.once("error", (error) => {
+            cleanup();
+            reject(error);
+        });
+        child.once("close", (code, signal) => {
+            cleanup();
+            resolve(exitCodeForChild(code, signal));
+        });
+    });
+}

package/dist/self-update.d.ts

@@ -1 +1,3 @@
-export declare function ensureCliSelfUpdated(): Promise<void>;
+export type CliSelfUpdateResult = "current" | "updated" | "updated-by-peer";
+export declare function resolveSelfUpdateResult(beforeVersion: string | undefined, afterVersion: string | undefined, updatedByPeer: boolean): CliSelfUpdateResult;
+export declare function ensureCliSelfUpdated(): Promise<CliSelfUpdateResult>;

package/dist/self-update.js

@@ -8,6 +8,7 @@ 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 PACKAGE_PATH = new URL("../package.json", import.meta.url);
 const parsePositiveIntEnv = (name, fallback) => {
     const raw = process.env[name]?.trim();
     if (!raw)
@@ -40,6 +41,20 @@ const writeState = () => {
     mkdirSync(dirname(STATE_PATH), { recursive: true });
     writeFileSync(STATE_PATH, `${JSON.stringify({ lastUpdatedAt: new Date().toISOString() }, null, 2)}\n`);
 };
+const readInstalledVersion = () => {
+    try {
+        const pkg = JSON.parse(readFileSync(PACKAGE_PATH, "utf-8"));
+        return typeof pkg.version === "string" ? pkg.version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+export function resolveSelfUpdateResult(beforeVersion, afterVersion, updatedByPeer) {
+    if (beforeVersion !== undefined && beforeVersion === afterVersion)
+        return "current";
+    return updatedByPeer ? "updated-by-peer" : "updated";
+}
 const isDue = () => {
     const state = readState();
     if (!state.lastUpdatedAt)
@@ -114,9 +129,10 @@ const runNpmUpdate = (timeoutMs) => {
 };
 export async function ensureCliSelfUpdated() {
     if (process.env.COHUB_CLI_AUTO_UPDATE === "0")
-        return;
+        return "current";
     if (!isDue())
-        return;
+        return "current";
+    const beforeVersion = readInstalledVersion();
     const timeoutMs = getTimeoutMs();
     const locked = await acquireLock(timeoutMs);
     if (!locked) {
@@ -125,10 +141,12 @@ export async function ensureCliSelfUpdated() {
     try {
         // Another process may have completed the update while this process was
         // waiting for the lock.
-        if (!isDue())
-            return;
+        if (!isDue()) {
+            return resolveSelfUpdateResult(beforeVersion, readInstalledVersion(), true);
+        }
         await runNpmUpdate(timeoutMs);
         writeState();
+        return resolveSelfUpdateResult(beforeVersion, readInstalledVersion(), false);
     }
     finally {
         releaseLock();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "3.8.0",
+  "version": "3.8.2",
   "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.3.0"
+    "@neta-art/cohub": "5.3.2"
   },
   "publishConfig": {
     "access": "public"