@slock-ai/computer 0.0.6 → 0.0.8

package/dist/index.js

@@ -304,6 +304,13 @@ function upgradeStagingDir(slockHome, version) {
 function upgradeSnapshotPath(slockHome) {
   return path.join(computerDir(slockHome), "upgrade-snapshot.json");
 }
+function upgradeLogPath(slockHome) {
+  return path.join(computerDir(slockHome), "upgrade.log");
+}
+function formatUpgradeLogTimestamp(date = /* @__PURE__ */ new Date()) {
+  const iso = date.toISOString();
+  return iso.replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+}
 
 // src/output.ts
 var CliExit = class extends Error {
@@ -1411,6 +1418,44 @@ async function runResident(serverId, deps = {}) {
 }
 var RECONCILE_INTERVAL_MS = 5e3;
 var CHILD_RESTART_BACKOFF_MS = 2e3;
+var START_ENSURE_TIMEOUT_MS = 15e3;
+var START_ENSURE_POLL_INTERVAL_MS = 100;
+async function waitForManagedDaemonPids(slockHome, serverIds, deps) {
+  const readPidfile = deps.readPidfile ?? readPidfileAt;
+  const isAlive = deps.isProcessAlive ?? isProcessAlive2;
+  const sleep2 = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const timeoutMs = deps.ensureTimeoutMs ?? START_ENSURE_TIMEOUT_MS;
+  const pollIntervalMs = deps.ensurePollIntervalMs ?? START_ENSURE_POLL_INTERVAL_MS;
+  const deadline = Date.now() + timeoutMs;
+  const ready = /* @__PURE__ */ new Map();
+  while (ready.size < serverIds.length) {
+    for (const serverId of serverIds) {
+      if (ready.has(serverId)) continue;
+      const pid = await readPidfile(serverDaemonPidPath(slockHome, serverId));
+      if (pid && isAlive(pid)) ready.set(serverId, pid);
+    }
+    if (ready.size === serverIds.length) return ready;
+    const remaining = deadline - Date.now();
+    if (remaining <= 0) return ready;
+    await sleep2(Math.min(pollIntervalMs, remaining));
+  }
+  return ready;
+}
+function formatReadySummary(ready, serverIds, opts) {
+  if (opts.serverId && serverIds.length === 1) {
+    const pid = ready.get(opts.serverId);
+    return `Daemon for server ${opts.serverLabel ?? opts.serverId} is running${pid ? ` (pid ${pid})` : ""}.`;
+  }
+  return `Daemons for ${serverIds.length} managed server(s) are running.`;
+}
+function failStartEnsureTimeout(slockHome, serverIds, ready, opts) {
+  const missing = serverIds.filter((id) => !ready.has(id));
+  const target = opts.serverId && missing.length === 1 ? `${opts.serverLabel ?? opts.serverId}` : `${missing.length} daemon(s): ${missing.join(", ")}`;
+  fail(
+    "START_DAEMON_TIMEOUT",
+    `Timed out waiting for ${target} to start. Run \`slock-computer status\` and inspect ${supervisorLogPath(slockHome)} plus per-server daemon logs under ~/.slock/computer/servers/<serverId>/daemon.log.`
+  );
+}
 async function runSupervisorStartupRecovery(slockHome) {
   const parentHoldsLock = process.env[PARENT_LOCK_HELD_ENV_VAR] === "1";
   try {
@@ -1592,7 +1637,7 @@ async function runSupervise() {
   await new Promise(() => {
   });
 }
-async function runStart(opts = {}, _deps = {}) {
+async function runStart(opts = {}, deps = {}) {
   const slockHome = resolveSlockHome();
   const attached = await listAttachedServerIds(slockHome);
   if (attached.length === 0) {
@@ -1614,9 +1659,11 @@ async function runStart(opts = {}, _deps = {}) {
   const existing = await readPidfileAt(supervisorPidPath(slockHome));
   if (existing && isProcessAlive2(existing)) {
     info(`Supervisor already running (pid ${existing}).`);
-    info(
-      opts.serverId ? `Marked server ${opts.serverLabel ?? opts.serverId} as managed; its daemon will be ensured on next reconcile tick.` : `Marked all ${attached.length} attached server(s) as managed; their daemons will be ensured on next reconcile tick.`
-    );
+    const ready2 = await waitForManagedDaemonPids(slockHome, managedTargets, deps);
+    if (ready2.size !== managedTargets.length) {
+      failStartEnsureTimeout(slockHome, managedTargets, ready2, opts);
+    }
+    info(formatReadySummary(ready2, managedTargets, opts));
     return;
   }
   if (opts.foreground) {
@@ -1628,18 +1675,66 @@ async function runStart(opts = {}, _deps = {}) {
   }
   let pid;
   try {
-    pid = await spawnDetachedSupervisor(slockHome);
+    pid = await (deps.spawnDetachedSupervisor ?? spawnDetachedSupervisor)(slockHome);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     fail("SUPERVISOR_SPAWN_FAILED", msg);
   }
   info(`Supervisor started (pid ${pid}); keeps running after this terminal closes.`);
+  const ready = await waitForManagedDaemonPids(slockHome, managedTargets, deps);
+  if (ready.size !== managedTargets.length) {
+    failStartEnsureTimeout(slockHome, managedTargets, ready, opts);
+  }
+  info(formatReadySummary(ready, managedTargets, opts));
   info(
     `Managing ${managedTargets.length} of ${attached.length} attached server(s). Logs: ${supervisorLogPath(slockHome)}`
   );
   info(`Per-server daemon logs: ~/.slock/computer/servers/<serverId>/daemon.log`);
   info(`Check state with \`slock-computer status\`.`);
 }
+async function runStop(deps = {}) {
+  const slockHome = resolveSlockHome();
+  const readPidfile = deps.readPidfile ?? readPidfileAt;
+  const isAlive = deps.isProcessAlive ?? isProcessAlive2;
+  const killer = deps.killSupervisor ?? ((pid2) => {
+    process.kill(pid2, "SIGTERM");
+  });
+  const sleep2 = deps.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const pollIntervalMs = deps.pollIntervalMs ?? 200;
+  const timeoutMs = deps.timeoutMs ?? 5e3;
+  const pidfilePath = supervisorPidPath(slockHome);
+  const pid = await readPidfile(pidfilePath);
+  if (pid === null) {
+    info("Supervisor not running.");
+    return;
+  }
+  if (!isAlive(pid)) {
+    await clearPidfileAt(pidfilePath);
+    info(`Supervisor not running (cleared stale pidfile for pid ${pid}).`);
+    return;
+  }
+  try {
+    killer(pid);
+  } catch (err) {
+    fail(
+      "STOP_SIGNAL_FAILED",
+      `Failed to send SIGTERM to supervisor (pid ${pid}): ${err instanceof Error ? err.message : String(err)}. Check process permissions or run: kill ${pid}`
+    );
+  }
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isAlive(pid)) {
+      await clearPidfileAt(pidfilePath);
+      info(`Stopped supervisor (pid ${pid}).`);
+      return;
+    }
+    await sleep2(pollIntervalMs);
+  }
+  fail(
+    "STOP_TIMEOUT",
+    `Supervisor (pid ${pid}) did not exit within ${timeoutMs}ms after SIGTERM. Force-kill with: kill -9 ${pid}`
+  );
+}
 async function runDetach(serverId, serverLabel = serverId) {
   assertValidServerId(serverId);
   const slockHome = resolveSlockHome();
@@ -3298,7 +3393,30 @@ async function locateStagedTarball(stagedPath) {
   return join6(stagedPath, tgz);
 }
 
+// src/upgradeLog.ts
+import { chmod as chmod5, mkdir as mkdir12, open as open2 } from "fs/promises";
+var FILE_MODE = 384;
+async function appendUpgradeLogEntry(slockHome, entry) {
+  await mkdir12(computerDir(slockHome), { recursive: true });
+  const path2 = upgradeLogPath(slockHome);
+  const at = entry.at ?? formatUpgradeLogTimestamp();
+  const fullEntry = { ...entry, at };
+  const line = JSON.stringify(fullEntry) + "\n";
+  const handle = await open2(path2, "a", FILE_MODE);
+  try {
+    await handle.write(line);
+  } finally {
+    await handle.close();
+  }
+  if (process.platform !== "win32") {
+    await chmod5(path2, FILE_MODE);
+  }
+}
+
 // src/upgradeCli.ts
+function isEphemeralNpxContext(binaryDir) {
+  return binaryDir.split(/[\\/]/).includes("_npx");
+}
 async function defaultSpawnFreshSupervisor(slockHome) {
   await spawnDetachedSupervisor(slockHome);
 }
@@ -3348,6 +3466,18 @@ async function runUpgradeCli(slockHome, opts, deps = {}) {
   }
   const fromVersion = await (deps.currentVersion ?? defaultCurrentVersion)();
   const currentBinaryDir = (deps.currentBinaryDir ?? defaultCurrentBinaryDir)();
+  const isEphemeralFn = deps.isEphemeralNpxContext ?? isEphemeralNpxContext;
+  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)`
+    );
+  }
   if (targetVersion === fromVersion) {
     info(`Already at ${fromVersion} (channel ${channel2}). Nothing to do.`);
     return;
@@ -3400,14 +3530,35 @@ async function runUpgradeCli(slockHome, opts, deps = {}) {
       spawnFreshSupervisor: () => spawnFreshSupervisor(slockHome)
     }
   });
+  const bundle = (version) => ({
+    computerVersion: version
+  });
+  const logTrigger = opts.trigger ?? "cli";
   if (outcome.ok) {
     info(
       `Upgrade ${fromVersion} \u2192 ${targetVersion} succeeded (health-OK in ${outcome.restart?.healthAfterMs ?? 0}ms).`
     );
+    await appendUpgradeLogEntry(slockHome, {
+      fromBundle: bundle(fromVersion),
+      toBundle: bundle(targetVersion),
+      channel: channel2,
+      trigger: logTrigger,
+      outcome: "ok"
+    }).catch(() => {
+    });
     return;
   }
   const code = mapFailurePhaseToCode(outcome);
   const rolledBack = outcome.rolledBack === true ? " (swap rolled back)" : "";
+  await appendUpgradeLogEntry(slockHome, {
+    fromBundle: bundle(fromVersion),
+    toBundle: bundle(targetVersion),
+    channel: channel2,
+    trigger: logTrigger,
+    outcome: "err",
+    errorCode: code
+  }).catch(() => {
+  });
   fail(
     code,
     `Upgrade failed at phase=${outcome.phase}: ${outcome.reason ?? "unknown"}${rolledBack}.`
@@ -3473,7 +3624,7 @@ async function defaultCurrentVersion() {
 }
 
 // src/upgradeTestHarness.ts
-import { mkdir as mkdir12, readdir as readdir4, stat as stat3, writeFile as writeFile10 } from "fs/promises";
+import { mkdir as mkdir13, readdir as readdir4, stat as stat3, writeFile as writeFile10 } from "fs/promises";
 import { join as join8 } from "path";
 import { createHash as createHash4 } from "crypto";
 var PHASES = /* @__PURE__ */ new Set([
@@ -3544,7 +3695,7 @@ function buildSimulatedDeps(slockHome, opts) {
           if (opts.simulateFail === "extract") {
             return { exitCode: 1, stderr: "simulated extract failure" };
           }
-          await mkdir12(join8(destDir, "package"), { recursive: true });
+          await mkdir13(join8(destDir, "package"), { recursive: true });
           await writeFile10(join8(destDir, "package", "marker.txt"), `NEW@${targetVersion}`);
           return { exitCode: 0, stderr: "" };
         },
@@ -3605,7 +3756,7 @@ function buildSimulatedDeps(slockHome, opts) {
 }
 async function arrangeSnapshotFailure(slockHome) {
   const snapshotPath = join8(slockHome, "computer", "upgrade-snapshot.json");
-  await mkdir12(snapshotPath, { recursive: true });
+  await mkdir13(snapshotPath, { recursive: true });
 }
 async function pathInfo(path2) {
   try {
@@ -3660,12 +3811,12 @@ async function runUpgradeTestHarness(slockHome, opts, writer = (s) => process.st
     process.exitCode = 1;
     return;
   }
-  await mkdir12(slockHome, { recursive: true });
+  await mkdir13(slockHome, { recursive: true });
   if (opts.simulateFail === "snapshot") {
     await arrangeSnapshotFailure(slockHome);
   }
   const { opts: upgradeOpts } = buildSimulatedDeps(slockHome, opts);
-  await mkdir12(upgradeOpts.currentBinaryDir, { recursive: true });
+  await mkdir13(upgradeOpts.currentBinaryDir, { recursive: true });
   let outcome;
   try {
     outcome = await runUpgrade(slockHome, upgradeOpts);
@@ -3702,7 +3853,7 @@ async function runUpgradeTestHarness(slockHome, opts, writer = (s) => process.st
 }
 
 // src/upgradeInstallSmoke.ts
-import { copyFile, mkdir as mkdir13, readFile as readFile13 } from "fs/promises";
+import { copyFile, mkdir as mkdir14, readFile as readFile13 } from "fs/promises";
 import { createHash as createHash5 } from "crypto";
 import { dirname as dirname11, isAbsolute, join as join9, resolve as pathResolve } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -3725,7 +3876,7 @@ async function runUpgradeInstallSmoke(slockHome, opts, deps = {}) {
   const spawnFreshSupervisor = deps.spawnFreshSupervisor ?? (async (h) => {
     await spawnDetachedSupervisor(h);
   });
-  await mkdir13(slockHome, { recursive: true });
+  await mkdir14(slockHome, { recursive: true });
   const outcome = await runUpgrade(slockHome, {
     targetVersion: opts.targetVersion,
     fromVersion,
@@ -3868,6 +4019,9 @@ program.command("start").argument("[serverSlug]", "optional: verify this server
     })
   );
 }));
+program.command("stop").description("Stop the Computer supervisor (and all managed per-server daemons).").action(withCliExit(async () => {
+  await withMutationLock(() => runStop());
+}));
 program.command("doctor").argument("[serverSlug]", "optional: scope detail (recent crashes) to one server").description("Diagnose login + per-server attachments + per-server preflight (no secrets).").option("--json", "emit the machine-readable report").option("--cleanup", "after diagnosis, run the local residue cleanup pass").option("--fix", "alias for --cleanup (same behavior)").option("--reset-health", "clear <serverSlug>'s crash history so supervisor resumes auto-restart").action(
   withCliExit(
     async (serverSlug, opts) => {

package/package.json

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