@slock-ai/computer 0.0.8 → 0.0.9

package/dist/index.js

@@ -314,9 +314,16 @@ function formatUpgradeLogTimestamp(date = /* @__PURE__ */ new Date()) {
 
 // src/output.ts
 var CliExit = class extends Error {
-  constructor(exitCode) {
-    super(`CliExit(${exitCode})`);
+  /**
+   * v8.3.3 PR-2c — carry the closed-set / stderr token through the thrown
+   * error so callers can pattern-match without parsing stderr. Optional
+   * because some callsites throw `new CliExit(code)` directly without a
+   * named token (e.g. the harness EX_CONFIG paths).
+   */
+  constructor(exitCode, code) {
+    super(`CliExit(${exitCode}${code ? ` ${code}` : ""})`);
     this.exitCode = exitCode;
+    this.code = code;
     this.name = "CliExit";
   }
 };
@@ -327,7 +334,7 @@ function info(line) {
 function fail(code, message, exitCode = 1) {
   process.stderr.write(`${JSON.stringify({ ok: false, code, message })}
 `);
-  throw new CliExit(exitCode);
+  throw new CliExit(exitCode, code);
 }
 
 // src/serverUrl.ts
@@ -351,7 +358,11 @@ async function runLogin(opts) {
   try {
     grant = await client.authorize("slock-computer");
   } catch (err) {
-    fail("DEVICE_AUTHORIZE_FAILED", err instanceof Error ? err.message : String(err));
+    const reason = err instanceof Error ? err.message : String(err);
+    fail(
+      "DEVICE_AUTHORIZE_FAILED",
+      `Could not start device login at ${baseUrl}: ${reason}. Check that the server URL is correct and reachable.`
+    );
   }
   const verificationUri = grant.verificationUriComplete || grant.verificationUri;
   const verifyUrl = new URL(verificationUri, baseUrl).toString();
@@ -3396,7 +3407,49 @@ async function locateStagedTarball(stagedPath) {
 // src/upgradeLog.ts
 import { chmod as chmod5, mkdir as mkdir12, open as open2 } from "fs/promises";
 var FILE_MODE = 384;
+var UPGRADE_ERROR_CODES = [
+  "UPGRADE_DEPS_CHANGED",
+  "UPGRADE_NETWORK_FAILED",
+  "UPGRADE_INTEGRITY_FAILED",
+  "UPGRADE_SWAP_FAILED",
+  "UPGRADE_RESTART_FAILED",
+  "UPGRADE_NO_TARGET",
+  "UPGRADE_ALREADY_RUNNING"
+];
+var UPGRADE_ERROR_CODE_SET = new Set(UPGRADE_ERROR_CODES);
+function assertUpgradeLogEntry(entry) {
+  const e = entry;
+  if (e.outcome === "ok") {
+    if (e.errorCode !== void 0) {
+      throw new TypeError(
+        `UpgradeLogEntry contract violation: outcome="ok" must not carry errorCode (got "${e.errorCode}").`
+      );
+    }
+  } else if (e.outcome === "err") {
+    if (e.errorCode === void 0) {
+      throw new TypeError(
+        `UpgradeLogEntry contract violation: outcome="err" requires errorCode from the v8.3.3 closed-set (${UPGRADE_ERROR_CODES.join(" | ")}).`
+      );
+    }
+    if (!UPGRADE_ERROR_CODE_SET.has(e.errorCode)) {
+      throw new TypeError(
+        `UpgradeLogEntry contract violation: errorCode "${e.errorCode}" is not in the v8.3.3 closed 7-value set (${UPGRADE_ERROR_CODES.join(" | ")}).`
+      );
+    }
+  } else {
+    throw new TypeError(
+      `UpgradeLogEntry contract violation: outcome must be "ok" or "err" (got "${e.outcome}").`
+    );
+  }
+  if (typeof e.fromBundle?.computerVersion !== "string" || e.fromBundle.computerVersion.length === 0) {
+    throw new TypeError(`UpgradeLogEntry contract violation: fromBundle.computerVersion must be a non-empty string.`);
+  }
+  if (typeof e.toBundle?.computerVersion !== "string" || e.toBundle.computerVersion.length === 0) {
+    throw new TypeError(`UpgradeLogEntry contract violation: toBundle.computerVersion must be a non-empty string.`);
+  }
+}
 async function appendUpgradeLogEntry(slockHome, entry) {
+  assertUpgradeLogEntry(entry);
   await mkdir12(computerDir(slockHome), { recursive: true });
   const path2 = upgradeLogPath(slockHome);
   const at = entry.at ?? formatUpgradeLogTimestamp();
@@ -3417,6 +3470,19 @@ async function appendUpgradeLogEntry(slockHome, entry) {
 function isEphemeralNpxContext(binaryDir) {
   return binaryDir.split(/[\\/]/).includes("_npx");
 }
+async function readBundledDaemonVersion(binaryDir) {
+  try {
+    const pkgPath = join7(binaryDir, "package.json");
+    const raw = await readFile12(pkgPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const pinned = parsed.dependencies?.["@slock-ai/daemon"];
+    if (typeof pinned !== "string" || pinned.length === 0) return null;
+    if (pinned === "workspace:*") return null;
+    return pinned;
+  } catch {
+    return null;
+  }
+}
 async function defaultSpawnFreshSupervisor(slockHome) {
   await spawnDetachedSupervisor(slockHome);
 }
@@ -3470,16 +3536,20 @@ async function runUpgradeCli(slockHome, opts, deps = {}) {
   if (isEphemeralFn(currentBinaryDir)) {
     fail(
       "UPGRADE_EPHEMERAL_CONTEXT",
-      `Cannot upgrade from an ephemeral npx context (${currentBinaryDir}).
-The currently installed Computer service runs from a different install root, which this command cannot reach. To upgrade, manually replace the persistent install:
-  npx -y @slock-ai/computer@latest stop
-  rm -rf ~/.npm/_npx/<persistent-hash>/
-  npx -y @slock-ai/computer@latest start
-(Find the persistent hash via: ls -d ~/.npm/_npx/*/node_modules/@slock-ai/computer)`
+      `You're running upgrade via the npx ephemeral entrypoint, which can't reach your installed Computer service. Please run the installed \`slock-computer upgrade\` instead. If \`slock-computer\` isn't on your PATH, install it globally first: \`npm i -g @slock-ai/computer@latest\`.`
     );
   }
   if (targetVersion === fromVersion) {
-    info(`Already at ${fromVersion} (channel ${channel2}). Nothing to do.`);
+    info(`Already at ${fromVersion} (channel ${channel2}). No upgrade target.`);
+    await appendUpgradeLogEntry(slockHome, {
+      fromBundle: { computerVersion: fromVersion },
+      toBundle: { computerVersion: fromVersion },
+      channel: channel2,
+      trigger: opts.trigger ?? "cli",
+      outcome: "err",
+      errorCode: "UPGRADE_NO_TARGET"
+    }).catch(() => {
+    });
     return;
   }
   info(`Planning upgrade: ${fromVersion} \u2192 ${targetVersion} (channel ${channel2}).`);
@@ -3530,9 +3600,9 @@ The currently installed Computer service runs from a different install root, whi
       spawnFreshSupervisor: () => spawnFreshSupervisor(slockHome)
     }
   });
-  const bundle = (version) => ({
-    computerVersion: version
-  });
+  const readBundledFn = deps.readBundledDaemonVersion ?? readBundledDaemonVersion;
+  const bundledDaemonVersion = await readBundledFn(currentBinaryDir);
+  const bundle = (version) => bundledDaemonVersion !== null ? { computerVersion: version, bundledDaemonVersion } : { computerVersion: version };
   const logTrigger = opts.trigger ?? "cli";
   if (outcome.ok) {
     info(
@@ -3548,8 +3618,28 @@ The currently installed Computer service runs from a different install root, whi
     });
     return;
   }
-  const code = mapFailurePhaseToCode(outcome);
   const rolledBack = outcome.rolledBack === true ? " (swap rolled back)" : "";
+  if (outcome.phase === "drain") {
+    info(
+      `Upgrade deferred: --drain=defer and daemons are busy. Re-run when idle, or use --force to interrupt in-flight turns.`
+    );
+    return;
+  }
+  if (outcome.phase === "cleanup") {
+    info(
+      `Upgrade ${fromVersion} \u2192 ${targetVersion} succeeded; cleanup phase reported a non-fatal issue: ${outcome.reason ?? "unknown"}. Active layout + supervisor are healthy.`
+    );
+    await appendUpgradeLogEntry(slockHome, {
+      fromBundle: bundle(fromVersion),
+      toBundle: bundle(targetVersion),
+      channel: channel2,
+      trigger: logTrigger,
+      outcome: "ok"
+    }).catch(() => {
+    });
+    return;
+  }
+  const code = mapFailurePhaseToCode(outcome);
   await appendUpgradeLogEntry(slockHome, {
     fromBundle: bundle(fromVersion),
     toBundle: bundle(targetVersion),
@@ -3566,26 +3656,27 @@ The currently installed Computer service runs from a different install root, whi
 }
 function mapFailurePhaseToCode(outcome) {
   switch (outcome.phase) {
-    case "drain":
-      return "UPGRADE_DEFERRED";
     case "stage":
-      return "UPGRADE_DOWNLOAD_FAILED";
+      return "UPGRADE_NETWORK_FAILED";
     case "verify":
-      return "UPGRADE_VERIFY_FAILED";
+      return "UPGRADE_INTEGRITY_FAILED";
     case "preflight":
       return "UPGRADE_DEPS_CHANGED";
     case "snapshot":
-      return "UPGRADE_SNAPSHOT_FAILED";
+      return "UPGRADE_SWAP_FAILED";
     case "extract":
-      return "UPGRADE_EXTRACT_FAILED";
+      return "UPGRADE_INTEGRITY_FAILED";
     case "swap":
       return "UPGRADE_SWAP_FAILED";
     case "restart":
       return "UPGRADE_RESTART_FAILED";
     case "rolling_health":
-      return "UPGRADE_DAEMON_HEALTH_FAILED";
+      return "UPGRADE_RESTART_FAILED";
+    case "drain":
     case "cleanup":
-      return "UPGRADE_CLEANUP_FAILED";
+      throw new Error(
+        `mapFailurePhaseToCode: phase=${outcome.phase} should be handled by caller (silenced), not mapped to a closed-set code`
+      );
   }
 }
 async function defaultFetchDistTags() {
@@ -3946,6 +4037,19 @@ async function defaultCurrentVersionLocal() {
   );
 }
 
+// src/version.ts
+import { createRequire as createRequire2 } from "module";
+function readComputerVersion(moduleUrl = import.meta.url) {
+  try {
+    const require2 = createRequire2(moduleUrl);
+    const pkg = require2("../package.json");
+    return typeof pkg.version === "string" && pkg.version.length > 0 ? pkg.version : "0.0.0-dev";
+  } catch {
+    return "0.0.0-dev";
+  }
+}
+var COMPUTER_VERSION = readComputerVersion();
+
 // src/index.ts
 function withCliExit(fn) {
   return async (...args) => {
@@ -3961,7 +4065,7 @@ function withCliExit(fn) {
   };
 }
 var program = new Command();
-program.name("slock-computer").description("Slock Computer \u2014 local-machine control plane (login + N per-server attachments).").version("0.0.3");
+program.name("slock-computer").description("Slock Computer \u2014 local-machine control plane (login + N per-server attachments).").version(COMPUTER_VERSION);
 program.command("login").description("Log in via device-code (one user identity per Computer / SLOCK_HOME).").option("--server-url <url>", `Slock API base URL; defaults to SLOCK_SERVER_URL or ${DEFAULT_SLOCK_SERVER_URL}`).action(withCliExit(async (opts) => {
   await runLogin({ serverUrl: opts.serverUrl });
 }));
@@ -4081,15 +4185,41 @@ program.command("upgrade").description(
         }
         drain = opts.drain;
       }
-      await withMutationLock(
-        () => runUpgradeCli(resolveSlockHome(), {
-          dryRun: opts.dryRun,
-          channel: opts.channel,
-          targetVersion: opts.targetVersion,
-          drain,
-          force: opts.force
-        })
-      );
+      const slockHome = resolveSlockHome();
+      try {
+        await withMutationLock(
+          () => runUpgradeCli(slockHome, {
+            dryRun: opts.dryRun,
+            channel: opts.channel,
+            targetVersion: opts.targetVersion,
+            drain,
+            force: opts.force
+          })
+        );
+      } catch (err) {
+        if (err instanceof CliExit && err.code === "CONCURRENT_OPERATION") {
+          try {
+            const currentVersion = await defaultCurrentVersion();
+            const channel2 = opts.channel ?? await readChannel(slockHome);
+            await appendUpgradeLogEntry(slockHome, {
+              fromBundle: { computerVersion: currentVersion },
+              toBundle: { computerVersion: currentVersion },
+              channel: channel2,
+              trigger: "cli",
+              outcome: "err",
+              errorCode: "UPGRADE_ALREADY_RUNNING"
+            }).catch(() => {
+            });
+          } catch {
+          }
+          process.stderr.write(
+            `slock-computer: UPGRADE_ALREADY_RUNNING: Another upgrade attempt is currently holding the mutation lock. Wait for it to finish and retry, or check \`~/.slock/computer/upgrade.log\` for the in-flight attempt.
+`
+          );
+          throw new CliExit(1, "UPGRADE_ALREADY_RUNNING");
+        }
+        throw err;
+      }
     }
   )
 );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slock-ai/computer",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "Slock Computer — standalone human/local-machine control-plane CLI (login + attach). Distinct from the agent-facing @slock-ai/cli.",
   "type": "module",
   "bin": {