@slock-ai/computer 0.0.16 → 0.0.18

package/dist/lib/index.js

@@ -31,73 +31,253 @@ var StateReaderError = class extends Error {
     this.code = code;
   }
 };
-var MIGRATION_DETECTION_KINDS = ["match", "no-match", "ambiguous"];
+var MIGRATION_DETECTION_KINDS = ["candidates", "server-unavailable"];
 function isMigrationDetectionKind(value) {
   return typeof value === "string" && MIGRATION_DETECTION_KINDS.includes(value);
 }
 
 // src/lib/migration.ts
-import { readdir, readFile } from "fs/promises";
-import { join } from "path";
+import { readdir, readFile, stat } from "fs/promises";
+import { join, resolve } from "path";
 var MACHINE_DIR_PREFIX = "machine-";
-async function readOwnerEvidence(installRoot, machineDirName) {
-  const ownerFile = join(
-    installRoot,
-    "machines",
-    machineDirName,
-    "daemon.lock",
-    "owner.json"
-  );
+var FINGERPRINT_HEX_RE = /^[0-9a-f]{16}$/;
+async function readLocalOwners(installRoot) {
+  const machinesDir = join(installRoot, "machines");
+  let entries;
+  try {
+    entries = await readdir(machinesDir);
+  } catch {
+    return [];
+  }
+  const owners = [];
+  for (const name of entries) {
+    if (!name.startsWith(MACHINE_DIR_PREFIX)) continue;
+    const ownerPath = join(machinesDir, name, "daemon.lock", "owner.json");
+    let raw;
+    try {
+      raw = await readFile(ownerPath, "utf8");
+    } catch {
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      continue;
+    }
+    const fp = parsed.apiKeyFingerprint;
+    if (typeof fp !== "string" || !FINGERPRINT_HEX_RE.test(fp)) continue;
+    owners.push({ apiKeyFingerprint: fp, localPath: ownerPath });
+  }
+  return owners;
+}
+function indexLocalByFingerprint(owners) {
+  const map = /* @__PURE__ */ new Map();
+  for (const owner of owners) {
+    if (!map.has(owner.apiKeyFingerprint)) {
+      map.set(owner.apiKeyFingerprint, owner);
+    }
+  }
+  return map;
+}
+function intersect(localByFp, roster) {
+  const out = [];
+  for (const entry of roster) {
+    const local = localByFp.get(entry.apiKeyFingerprint);
+    if (!local) continue;
+    out.push({
+      apiKeyFingerprint: entry.apiKeyFingerprint,
+      daemonId: entry.daemonId,
+      localPath: local.localPath,
+      machineName: entry.machineName,
+      ...entry.hostname ? { hostname: entry.hostname } : {},
+      ...entry.lastSeenAt ? { lastSeenAt: entry.lastSeenAt } : {}
+    });
+  }
+  out.sort((a, b) => {
+    const aSeen = a.lastSeenAt ?? "";
+    const bSeen = b.lastSeenAt ?? "";
+    if (aSeen !== bSeen) {
+      if (aSeen === "") return 1;
+      if (bSeen === "") return -1;
+      return aSeen < bSeen ? 1 : -1;
+    }
+    return a.apiKeyFingerprint < b.apiKeyFingerprint ? -1 : a.apiKeyFingerprint > b.apiKeyFingerprint ? 1 : 0;
+  });
+  return out;
+}
+async function detectLegacyMigration(installRoot, serverSlug, client) {
+  const localOwners = await readLocalOwners(installRoot);
+  if (localOwners.length === 0) {
+    return { kind: "candidates", candidates: [] };
+  }
+  const result = await client.list(serverSlug);
+  if (result.status !== "success") {
+    return { kind: "server-unavailable" };
+  }
+  const localByFp = indexLocalByFingerprint(localOwners);
+  return { kind: "candidates", candidates: intersect(localByFp, result.entries) };
+}
+async function validateManualMigratePath(inputPath, roster) {
+  const absInput = resolve(inputPath);
+  let stats;
+  try {
+    stats = await stat(absInput);
+  } catch {
+    return { ok: false, code: "MIGRATE_FROM_NOT_FOUND" };
+  }
+  const ownerPath = stats.isDirectory() ? join(absInput, "daemon.lock", "owner.json") : absInput;
+  const candidateOwnerPath = await firstReadableOwner([
+    ownerPath,
+    join(absInput, "owner.json"),
+    absInput
+  ]);
+  if (!candidateOwnerPath) {
+    return { ok: false, code: "MIGRATE_FROM_INVALID" };
+  }
   let raw;
   try {
-    raw = await readFile(ownerFile, "utf8");
+    raw = await readFile(candidateOwnerPath, "utf8");
   } catch {
-    return {};
+    return { ok: false, code: "MIGRATE_FROM_INVALID" };
   }
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch {
-    return {};
+    return { ok: false, code: "MIGRATE_FROM_INVALID" };
+  }
+  const fp = parsed.apiKeyFingerprint;
+  if (typeof fp !== "string" || !FINGERPRINT_HEX_RE.test(fp)) {
+    return { ok: false, code: "MIGRATE_FROM_INVALID" };
   }
-  const machineName = typeof parsed.hostname === "string" && parsed.hostname.length > 0 ? parsed.hostname : void 0;
-  const serverUrl = typeof parsed.serverUrl === "string" && parsed.serverUrl.length > 0 ? parsed.serverUrl : void 0;
-  return { machineName, serverUrl };
+  const match = roster.find((r) => r.apiKeyFingerprint === fp);
+  if (!match) {
+    return { ok: false, code: "MIGRATE_FROM_NOT_OWNED" };
+  }
+  return {
+    ok: true,
+    candidate: {
+      apiKeyFingerprint: match.apiKeyFingerprint,
+      daemonId: match.daemonId,
+      localPath: candidateOwnerPath,
+      machineName: match.machineName,
+      ...match.hostname ? { hostname: match.hostname } : {},
+      ...match.lastSeenAt ? { lastSeenAt: match.lastSeenAt } : {}
+    }
+  };
 }
-async function detectLegacyMigration(installRoot, loggedInUserId) {
-  void loggedInUserId;
-  const machinesDir = join(installRoot, "machines");
-  let entries;
-  try {
-    entries = await readdir(machinesDir);
-  } catch {
-    return { kind: "no-match" };
+async function firstReadableOwner(paths) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const p of paths) {
+    if (seen.has(p)) continue;
+    seen.add(p);
+    try {
+      const st = await stat(p);
+      if (st.isFile()) return p;
+    } catch {
+    }
   }
-  const candidates = [];
-  for (const name of entries) {
-    if (!name.startsWith(MACHINE_DIR_PREFIX)) continue;
-    const evidence = await readOwnerEvidence(installRoot, name);
-    candidates.push({
-      machineId: name,
-      machineName: evidence.machineName,
-      serverUrl: evidence.serverUrl
+  return null;
+}
+
+// src/apiClient.ts
+import { fetch } from "undici";
+var LegacyMachinesClient = class {
+  constructor(baseUrl, accessToken) {
+    this.baseUrl = baseUrl;
+    this.accessToken = accessToken;
+  }
+  url(p) {
+    return new URL(p, this.baseUrl).toString();
+  }
+  async list(serverSlug) {
+    let res;
+    try {
+      res = await fetch(
+        this.url(`/api/computer/legacy-machines?serverSlug=${encodeURIComponent(serverSlug)}`),
+        {
+          method: "GET",
+          headers: { Authorization: `Bearer ${this.accessToken}` }
+        }
+      );
+    } catch {
+      return { status: "error", code: "request_failed" };
+    }
+    const body = await res.json().catch(() => null);
+    if (res.status === 200 && body && Array.isArray(body.entries)) {
+      const entries = body.entries.map((raw) => {
+        if (!raw || typeof raw !== "object") return null;
+        const e = raw;
+        if (typeof e.daemonId !== "string" || typeof e.apiKeyFingerprint !== "string" || typeof e.machineName !== "string") {
+          return null;
+        }
+        return {
+          daemonId: e.daemonId,
+          apiKeyFingerprint: e.apiKeyFingerprint,
+          machineName: e.machineName,
+          hostname: typeof e.hostname === "string" ? e.hostname : null,
+          lastSeenAt: typeof e.lastSeenAt === "string" ? e.lastSeenAt : null
+        };
+      }).filter((entry) => entry !== null);
+      return { status: "success", entries };
+    }
+    if (res.status === 401) return { status: "auth_required" };
+    if (res.status === 403) return { status: "not_authorized" };
+    if (res.status === 404) return { status: "disabled" };
+    const code = body && typeof body.code === "string" ? body.code : `http_${res.status}`;
+    return { status: "error", code };
+  }
+};
+var RunnersClient = class {
+  constructor(baseUrl, computerApiKey) {
+    this.baseUrl = baseUrl;
+    this.computerApiKey = computerApiKey;
+  }
+  url(p) {
+    return new URL(p, this.baseUrl).toString();
+  }
+  async list() {
+    const res = await fetch(this.url("/internal/computer/runners"), {
+      method: "GET",
+      headers: { Authorization: `Bearer ${this.computerApiKey}` }
     });
+    const body = await res.json().catch(() => null);
+    if (res.status === 200 && body && Array.isArray(body.runners)) {
+      return {
+        status: "success",
+        whitelist: Array.isArray(body.whitelist) ? body.whitelist : [],
+        runners: body.runners
+      };
+    }
+    if (res.status === 401 || res.status === 403) return { status: "unauthorized" };
+    const code = body && typeof body.code === "string" ? body.code : `http_${res.status}`;
+    return { status: "error", code };
   }
-  if (candidates.length === 0) return { kind: "no-match" };
-  if (candidates.length === 1) {
-    const only = candidates[0];
-    return {
-      kind: "match",
-      machineId: only.machineId,
-      machineName: only.machineName,
-      serverUrl: only.serverUrl
-    };
+  async stop(agentId) {
+    const res = await fetch(this.url(`/internal/computer/runners/${encodeURIComponent(agentId)}/stop`), {
+      method: "POST",
+      headers: { Authorization: `Bearer ${this.computerApiKey}`, "Content-Type": "application/json" },
+      body: "{}"
+    });
+    if (res.status === 200) return { status: "success" };
+    if (res.status === 404) return { status: "not_found" };
+    if (res.status === 401 || res.status === 403) return { status: "unauthorized" };
+    const body = await res.json().catch(() => null);
+    const code = body && typeof body.code === "string" ? body.code : `http_${res.status}`;
+    return { status: "error", code };
   }
-  return { kind: "ambiguous", candidates };
-}
+};
 
-// src/status.ts
-import { readFile as readFile5 } from "fs/promises";
+// src/setup.ts
+import { chmod as chmod4, mkdir as mkdir9, readFile as readFile8, rename as rename3, rm as rm2, writeFile as writeFile8 } from "fs/promises";
+import { dirname as dirname8 } from "path";
+import { fetch as fetch3 } from "undici";
+
+// src/serverState.ts
+import { readFile as readFile2, readdir as readdir2, writeFile, mkdir, unlink, access, chmod } from "fs/promises";
+import { dirname } from "path";
+import { constants as fsConstants } from "fs";
 
 // src/paths.ts
 import { createHash } from "crypto";
@@ -128,6 +308,9 @@ function serverDir(slockHome, serverId) {
 function serverAttachmentPath(slockHome, serverId) {
   return path.join(serverDir(slockHome, serverId), "runner.state.json");
 }
+function legacyServerAttachmentPath(slockHome, serverId) {
+  return path.join(serverDir(slockHome, serverId), "attachment.json");
+}
 function serverRunnerPidPath(slockHome, serverId) {
   return path.join(serverDir(slockHome, serverId), "server-runner.pid");
 }
@@ -161,9 +344,6 @@ function serviceLogPath(slockHome) {
 }
 
 // src/serverState.ts
-import { readFile as readFile2, readdir as readdir2, writeFile, mkdir, unlink, access, chmod } from "fs/promises";
-import { dirname } from "path";
-import { constants as fsConstants } from "fs";
 function parseAttachment(raw) {
   try {
     const a = JSON.parse(raw);
@@ -175,21 +355,33 @@ function parseAttachment(raw) {
         serverMachineId: a.serverMachineId,
         apiKey: a.apiKey,
         serverUrl: a.serverUrl,
-        attachedAt: typeof a.attachedAt === "string" ? a.attachedAt : void 0
+        attachedAt: typeof a.attachedAt === "string" ? a.attachedAt : void 0,
+        adoptedFromLegacy: a.adoptedFromLegacy === true ? true : void 0,
+        legacyMachineId: typeof a.legacyMachineId === "string" ? a.legacyMachineId : void 0
       };
     }
   } catch {
   }
   return null;
 }
-async function readServerAttachment(slockHome, serverId) {
-  if (!isValidServerId(serverId)) return null;
+async function readAttachmentAt(path2) {
   try {
-    return parseAttachment(await readFile2(serverAttachmentPath(slockHome, serverId), "utf8"));
+    return parseAttachment(await readFile2(path2, "utf8"));
   } catch {
     return null;
   }
 }
+async function readServerAttachment(slockHome, serverId) {
+  if (!isValidServerId(serverId)) return null;
+  const current = await readAttachmentAt(serverAttachmentPath(slockHome, serverId));
+  const legacy = await readAttachmentAt(legacyServerAttachmentPath(slockHome, serverId));
+  if (!current) return legacy;
+  if (!legacy) return current;
+  if (legacy.adoptedFromLegacy === true && current.adoptedFromLegacy !== true && legacy.serverMachineId !== current.serverMachineId) {
+    return legacy;
+  }
+  return current;
+}
 async function listAttachedServerIds(slockHome) {
   let entries;
   try {
@@ -214,12 +406,37 @@ async function listServerAttachments(slockHome) {
   return out;
 }
 
-// src/internal/process-primitives.ts
-import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2, unlink as unlink2 } from "fs/promises";
+// src/services/attach.ts
+import { chmod as chmod2, mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
 import { dirname as dirname2 } from "path";
+
+// src/services/login.ts
+import { mkdir as mkdir3, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname3 } from "path";
+
+// src/services/adoptLegacy.ts
+import { chmod as chmod3, mkdir as mkdir4, readFile as readFile4, writeFile as writeFile4, appendFile, stat as stat2 } from "fs/promises";
+import { createHash as createHash2 } from "crypto";
+import { dirname as dirname4, join as join2 } from "path";
+import { setTimeout as delay } from "timers/promises";
+
+// src/service.ts
+import { spawn as spawn2 } from "child_process";
+import { mkdir as mkdir8, readFile as readFile7, writeFile as writeFile7, open, rename as rename2 } from "fs/promises";
+import { dirname as dirname7, join as joinPath } from "path";
+import { fileURLToPath } from "url";
+
+// src/cleanup.ts
+import { readdir as readdir3, stat as stat3, unlink as unlink3, rm, rmdir, rename, mkdir as mkdir6 } from "fs/promises";
+import { spawn } from "child_process";
+import { join as join3 } from "path";
+
+// src/internal/process-primitives.ts
+import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile5, unlink as unlink2 } from "fs/promises";
+import { dirname as dirname5 } from "path";
 async function readPidfileAt(pidfilePath) {
   try {
-    const raw = (await readFile3(pidfilePath, "utf8")).trim();
+    const raw = (await readFile5(pidfilePath, "utf8")).trim();
     const pid = Number.parseInt(raw, 10);
     return Number.isInteger(pid) && pid > 0 ? pid : null;
   } catch {
@@ -236,6 +453,37 @@ function isProcessAlive(pid) {
   }
 }
 
+// src/cleanup.ts
+var TMP_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+
+// src/health.ts
+import { readFile as readFile6, writeFile as writeFile6, unlink as unlink4, mkdir as mkdir7, appendFile as appendFile2 } from "fs/promises";
+import { dirname as dirname6 } from "path";
+var CRASH_WINDOW_MS = 6e4;
+var DEGRADED_THRESHOLD = 3;
+async function readHealthFile(slockHome, serverId) {
+  if (!isValidServerId(serverId)) return { crashes: [] };
+  try {
+    const raw = await readFile6(serverHealthPath(slockHome, serverId), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && Array.isArray(parsed.crashes)) {
+      return parsed;
+    }
+  } catch {
+  }
+  return { crashes: [] };
+}
+async function isDegraded(slockHome, serverId, nowMs = Date.now()) {
+  const file = await readHealthFile(slockHome, serverId);
+  if (file.fatalConfig) return true;
+  const cutoffMs = nowMs - CRASH_WINDOW_MS;
+  const recent = file.crashes.filter((c) => {
+    const t = new Date(c.at).getTime();
+    return Number.isFinite(t) && t >= cutoffMs;
+  });
+  return recent.length >= DEGRADED_THRESHOLD;
+}
+
 // src/internal/service-pid-fallback.ts
 async function findLiveServicePidReadOnly(slockHome, deps = {}) {
   const readPidfile = deps.readPidfile ?? readPidfileAt;
@@ -271,38 +519,60 @@ async function walkFallback(slockHome, readPidfile, isAlive, clearStale) {
   };
 }
 
-// src/health.ts
-import { readFile as readFile4, writeFile as writeFile3, unlink as unlink3, mkdir as mkdir3, appendFile } from "fs/promises";
-import { dirname as dirname3 } from "path";
-var CRASH_WINDOW_MS = 6e4;
-var DEGRADED_THRESHOLD = 3;
-async function readHealthFile(slockHome, serverId) {
-  if (!isValidServerId(serverId)) return { crashes: [] };
-  try {
-    const raw = await readFile4(serverHealthPath(slockHome, serverId), "utf8");
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed === "object" && Array.isArray(parsed.crashes)) {
-      return parsed;
+// src/services/detach.ts
+import { fetch as fetch2 } from "undici";
+
+// src/setup.ts
+var MIGRATION_FRESH_TRIGGERS = [
+  "empty-intersection",
+  "explicit-zero",
+  "eof",
+  "non-tty",
+  "server-unavailable"
+];
+async function pickMigrationCandidateFromInput(candidates, read, write) {
+  write(
+    "Migration: detected legacy daemon(s) on this Computer that match the target server.\n"
+  );
+  candidates.forEach((c, i) => {
+    const host = c.hostname ? ` (${c.hostname})` : "";
+    const seen = c.lastSeenAt ? ` last seen ${c.lastSeenAt}` : "";
+    write(`  ${i + 1}. ${c.machineName}${host}${seen}
+`);
+    write(`     local: ${c.localPath}
+`);
+  });
+  write("  0. Fresh attach (skip migration)\n");
+  write("  m. Migrate from a different on-disk path\n");
+  while (true) {
+    write("Choose [1]: ");
+    const { line, eof } = await read();
+    if (eof) return { kind: "fresh" };
+    const trimmed = line.trim();
+    const norm = trimmed.toLowerCase();
+    if (norm === "m") {
+      write("Path to legacy machine dir or owner.json: ");
+      const { line: pathLine } = await read();
+      return { kind: "manual", path: pathLine.trim() };
     }
-  } catch {
+    if (norm.length === 0) return { kind: "candidate", index: 0 };
+    if (norm === "0") return { kind: "fresh" };
+    const n = Number.parseInt(norm, 10);
+    if (Number.isFinite(n) && String(n) === norm && n >= 1 && n <= candidates.length) {
+      return { kind: "candidate", index: n - 1 };
+    }
+    write(
+      `Invalid selection "${trimmed}". Enter 1..${candidates.length}, 0, or m.
+`
+    );
   }
-  return { crashes: [] };
-}
-async function isDegraded(slockHome, serverId, nowMs = Date.now()) {
-  const file = await readHealthFile(slockHome, serverId);
-  if (file.fatalConfig) return true;
-  const cutoffMs = nowMs - CRASH_WINDOW_MS;
-  const recent = file.crashes.filter((c) => {
-    const t = new Date(c.at).getTime();
-    return Number.isFinite(t) && t >= cutoffMs;
-  });
-  return recent.length >= DEGRADED_THRESHOLD;
 }
 
 // src/status.ts
+import { readFile as readFile9 } from "fs/promises";
 async function readUserSession(path2) {
   try {
-    const parsed = JSON.parse(await readFile5(path2, "utf8"));
+    const parsed = JSON.parse(await readFile9(path2, "utf8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
       return { state: "present", session: parsed, error: null };
     }
@@ -368,48 +638,6 @@ async function buildStatusReport(installRoot) {
   };
 }
 
-// src/apiClient.ts
-import { fetch } from "undici";
-var RunnersClient = class {
-  constructor(baseUrl, computerApiKey) {
-    this.baseUrl = baseUrl;
-    this.computerApiKey = computerApiKey;
-  }
-  url(p) {
-    return new URL(p, this.baseUrl).toString();
-  }
-  async list() {
-    const res = await fetch(this.url("/internal/computer/runners"), {
-      method: "GET",
-      headers: { Authorization: `Bearer ${this.computerApiKey}` }
-    });
-    const body = await res.json().catch(() => null);
-    if (res.status === 200 && body && Array.isArray(body.runners)) {
-      return {
-        status: "success",
-        whitelist: Array.isArray(body.whitelist) ? body.whitelist : [],
-        runners: body.runners
-      };
-    }
-    if (res.status === 401 || res.status === 403) return { status: "unauthorized" };
-    const code = body && typeof body.code === "string" ? body.code : `http_${res.status}`;
-    return { status: "error", code };
-  }
-  async stop(agentId) {
-    const res = await fetch(this.url(`/internal/computer/runners/${encodeURIComponent(agentId)}/stop`), {
-      method: "POST",
-      headers: { Authorization: `Bearer ${this.computerApiKey}`, "Content-Type": "application/json" },
-      body: "{}"
-    });
-    if (res.status === 200) return { status: "success" };
-    if (res.status === 404) return { status: "not_found" };
-    if (res.status === 401 || res.status === 403) return { status: "unauthorized" };
-    const body = await res.json().catch(() => null);
-    const code = body && typeof body.code === "string" ? body.code : `http_${res.status}`;
-    return { status: "error", code };
-  }
-};
-
 // src/lib/readers.ts
 async function readServiceStatus(installRoot) {
   return buildStatusReport(installRoot);
@@ -497,7 +725,7 @@ function isServiceState(value) {
 }
 
 // src/upgradeLog.ts
-import { chmod as chmod2, mkdir as mkdir4, open } from "fs/promises";
+import { chmod as chmod5, mkdir as mkdir10, open as open2 } from "fs/promises";
 var UPGRADE_ERROR_CODES = [
   "UPGRADE_DEPS_CHANGED",
   "UPGRADE_NETWORK_FAILED",
@@ -541,7 +769,9 @@ function assertUpgradeLogEntry(entry) {
 }
 export {
   IPC_ERROR_CODES,
+  LegacyMachinesClient,
   MIGRATION_DETECTION_KINDS,
+  MIGRATION_FRESH_TRIGGERS,
   RUNNER_STATE_VALUES,
   SERVICE_STATE_VALUES,
   STATE_READER_ERROR_CODES,
@@ -555,6 +785,8 @@ export {
   isRunnerState,
   isServiceState,
   listRunners,
+  pickMigrationCandidateFromInput,
   readRunnerStatus,
-  readServiceStatus
+  readServiceStatus,
+  validateManualMigratePath
 };

package/package.json

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