@boxcompute/cli 0.2.0 → 0.2.2

package/README.md

@@ -61,9 +61,11 @@ Deploy the server release with both Sandbox API v1 and v2 before publishing CLI
 contract. After that, clients need only upgrade the package:
 
 ```sh
-npm install --global @boxcompute/cli@latest
+bxc update
 ```
 
-The installation refreshes untouched managed skills before the client's next
-agent session. The new CLI uses v2 for multi-instance sandboxes and gives a
-server-first upgrade message if it reaches an older deployment.
+`bxc up` is the short alias. If the automatic update cannot invoke npm, use
+`npm install --global @boxcompute/cli@latest` manually. Updating preserves the
+saved BoxCompute credential and refreshes untouched managed skills before the
+client's next agent session. The new CLI uses v2 for multi-instance sandboxes
+and gives a server-first upgrade message if it reaches an older deployment.

package/dist/cli.d.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { spawn } from "node:child_process";
 import { type Connection } from "./config.js";
 import { detectHarnesses, installSkill, readSkill, removeSkill, syncManagedSkills } from "./skill.js";
 type Io = {
@@ -12,6 +13,7 @@ export type CliDependencies = {
     now?: () => number;
     sleep?: (milliseconds: number) => Promise<void>;
     openBrowser?: (url: string) => void;
+    installUpdate?: (version: string) => Promise<void>;
     loadConnection?: (env: NodeJS.ProcessEnv) => Promise<Connection>;
     loadSavedUrl?: (env: NodeJS.ProcessEnv) => Promise<string | null>;
     saveConnection?: (url: string, token: string, env: NodeJS.ProcessEnv) => Promise<void>;
@@ -22,6 +24,18 @@ export type CliDependencies = {
     readSkill?: typeof readSkill;
     syncManagedSkills?: typeof syncManagedSkills;
 };
+type BrowserRuntime = {
+    env?: NodeJS.ProcessEnv;
+    kernelRelease?: string;
+    spawn?: typeof spawn;
+    system?: NodeJS.Platform;
+};
+export declare function browserLaunch(url: string, runtime?: Pick<BrowserRuntime, "env" | "kernelRelease" | "system">): {
+    command: string;
+    args: string[];
+    detached: boolean;
+};
+export declare function openBrowser(url: string, runtime?: BrowserRuntime): void;
 export declare function runCli(argv: string[], supplied?: CliDependencies): Promise<number>;
 export declare function formatCliError(error: unknown): string;
 export {};

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
 import { readFileSync, realpathSync } from "node:fs";
-import { hostname, platform } from "node:os";
+import { hostname, platform, release } from "node:os";
 import { fileURLToPath } from "node:url";
 import { BoxComputeClient, BoxComputeHttpError, publicRequest, } from "./client.js";
 import { clearConnection, loadConnection, loadSavedUrl, saveConnection, } from "./config.js";
@@ -15,6 +15,7 @@ Usage: bxc [options] [command]
 Commands:
 
   version                         Print the version number and exit
+  update                          [alias: up] Update the CLI to the latest npm release
   login                           Log in through BoxCompute in your browser
   logout                          Revoke and remove the saved CLI credential
   auth                            [alias: login] Authentication commands
@@ -48,6 +49,7 @@ Login options:
 Examples:
 
   $ bxc login
+  $ bxc update
   $ bxc skill detect
   $ bxc skill install
   $ bxc workspaces
@@ -105,13 +107,104 @@ Supported harnesses:
 class UsageError extends Error {
     constructor(message) { super(message); this.name = "UsageError"; }
 }
-function browser(url) {
-    const system = platform();
-    const command = system === "darwin" ? "open" : system === "win32" ? "cmd" : "xdg-open";
-    const args = system === "win32" ? ["/c", "start", "", url] : [url];
-    const child = spawn(command, args, { detached: true, stdio: "ignore" });
-    child.on("error", () => undefined);
-    child.unref();
+export function browserLaunch(url, runtime = {}) {
+    const system = runtime.system ?? platform();
+    const env = runtime.env ?? process.env;
+    const kernelRelease = runtime.kernelRelease ?? release();
+    const isWsl = system === "linux" && Boolean(env.WSL_DISTRO_NAME || env.WSL_INTEROP || /microsoft/i.test(kernelRelease));
+    if (isWsl)
+        return { command: "explorer.exe", args: [url], detached: false };
+    if (system === "darwin")
+        return { command: "open", args: [url], detached: true };
+    if (system === "win32")
+        return { command: "cmd", args: ["/c", "start", "", url], detached: true };
+    return { command: "xdg-open", args: [url], detached: true };
+}
+export function openBrowser(url, runtime = {}) {
+    const launch = browserLaunch(url, runtime);
+    try {
+        const child = (runtime.spawn ?? spawn)(launch.command, launch.args, {
+            detached: launch.detached,
+            stdio: "ignore",
+        });
+        child.on("error", () => undefined);
+        child.unref();
+    }
+    catch {
+        // The approval URL is always printed before this best-effort launch. Keep
+        // polling so headless shells and restricted WSL interop can authenticate.
+    }
+}
+function releaseVersion(value) {
+    if (typeof value !== "string")
+        return null;
+    const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(value);
+    if (!match)
+        return null;
+    const parts = match.slice(1).map(Number);
+    return parts.every(Number.isSafeInteger) ? parts : null;
+}
+function compareReleaseVersions(left, right) {
+    for (let index = 0; index < left.length; index += 1) {
+        if (left[index] !== right[index])
+            return left[index] - right[index];
+    }
+    return 0;
+}
+async function installCliUpdate(version) {
+    const executable = platform() === "win32" ? "npm.cmd" : "npm";
+    await new Promise((resolve, reject) => {
+        let child;
+        try {
+            child = spawn(executable, ["install", "--global", `@boxcompute/cli@${version}`], {
+                stdio: ["ignore", "ignore", "inherit"],
+            });
+        }
+        catch (error) {
+            reject(error);
+            return;
+        }
+        child.once("error", reject);
+        child.once("exit", (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`npm exited with code ${code ?? "unknown"}`));
+        });
+    });
+}
+async function updateCli(dependencies) {
+    let response;
+    try {
+        response = await dependencies.fetch("https://registry.npmjs.org/%40boxcompute%2Fcli/latest", {
+            headers: { accept: "application/json" },
+        });
+    }
+    catch (error) {
+        throw new Error(`Could not check npm for updates: ${error?.message ?? String(error)}`);
+    }
+    if (!response.ok)
+        throw new Error(`Could not check npm for updates (HTTP ${response.status})`);
+    const latest = (await response.json()).version;
+    const currentParts = releaseVersion(CLI_VERSION);
+    const latestParts = releaseVersion(latest);
+    if (!currentParts || !latestParts || typeof latest !== "string") {
+        throw new Error("npm returned an invalid BoxCompute CLI version");
+    }
+    if (compareReleaseVersions(latestParts, currentParts) <= 0) {
+        emit(dependencies.io, dependencies.json, { updated: false, version: CLI_VERSION }, `BoxCompute CLI is already up to date (${CLI_VERSION}).\n`);
+        return 0;
+    }
+    write(dependencies.io.stderr, `Updating BoxCompute CLI from ${CLI_VERSION} to ${latest}…\n`);
+    try {
+        await dependencies.install(latest);
+    }
+    catch (error) {
+        throw new Error(`Could not install @boxcompute/cli@${latest}: ${error?.message ?? String(error)}. ` +
+            `Run \`npm install --global @boxcompute/cli@${latest}\` manually.`);
+    }
+    emit(dependencies.io, dependencies.json, { updated: true, previousVersion: CLI_VERSION, version: latest }, `Updated BoxCompute CLI to ${latest}.\n`);
+    return 0;
 }
 const delay = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
 const write = (stream, value) => { stream.write(value); };
@@ -251,7 +344,8 @@ export async function runCli(argv, supplied = {}) {
     const fetchImpl = supplied.fetch ?? fetch;
     const now = supplied.now ?? Date.now;
     const sleep = supplied.sleep ?? delay;
-    const openBrowser = supplied.openBrowser ?? browser;
+    const openBrowserImpl = supplied.openBrowser ?? openBrowser;
+    const installUpdate = supplied.installUpdate ?? installCliUpdate;
     const load = supplied.loadConnection ?? loadConnection;
     const savedUrl = supplied.loadSavedUrl ?? loadSavedUrl;
     const save = supplied.saveConnection ?? saveConnection;
@@ -277,6 +371,8 @@ export async function runCli(argv, supplied = {}) {
     let command = args.shift();
     if (command === "login")
         command = "auth";
+    if (command === "up")
+        command = "update";
     if (command === "skills")
         command = "skill";
     if (command === "list" || command === "ls")
@@ -323,7 +419,12 @@ export async function runCli(argv, supplied = {}) {
             emit(io, json, { authenticated: false }, "BoxCompute CLI credential revoked and removed.\n");
             return 0;
         }
-        return authenticate(args, { env, io, json, fetch: fetchImpl, now, sleep, openBrowser, loadSavedUrl: savedUrl, saveConnection: save });
+        return authenticate(args, { env, io, json, fetch: fetchImpl, now, sleep, openBrowser: openBrowserImpl, loadSavedUrl: savedUrl, saveConnection: save });
+    }
+    if (command === "update") {
+        if (args.length)
+            throw new UsageError("update takes no options");
+        return updateCli({ fetch: fetchImpl, install: installUpdate, io, json });
     }
     if (command === "skill") {
         let action = args.shift();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@boxcompute/cli",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Connect local AI agents to BoxCompute sandboxes",
   "keywords": [
     "boxcompute",