@slock-ai/computer 0.0.14 → 0.0.15

package/dist/lib/index.js

@@ -2,6 +2,7 @@
 var IPC_ERROR_CODES = [
   "IPC_FRAME_TOO_LARGE",
   "IPC_PROTOCOL_VERSION_UNSUPPORTED",
+  "IPC_PROTOCOL_HANDSHAKE_FAILED",
   "IPC_HEARTBEAT_TIMEOUT",
   "IPC_MALFORMED_FRAME",
   "IPC_REQUEST_TIMEOUT",
@@ -21,6 +22,402 @@ var ServiceClientError = class extends Error {
     if (cause !== void 0) this.cause = cause;
   }
 };
+var STATE_READER_ERROR_CODES = ["NOT_ATTACHED", "INVALID_ATTACHMENT"];
+var StateReaderError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "StateReaderError";
+    this.code = code;
+  }
+};
+var MIGRATION_DETECTION_KINDS = ["match", "no-match", "ambiguous"];
+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";
+var MACHINE_DIR_PREFIX = "machine-";
+async function readOwnerEvidence(installRoot, machineDirName) {
+  const ownerFile = join(
+    installRoot,
+    "machines",
+    machineDirName,
+    "daemon.lock",
+    "owner.json"
+  );
+  let raw;
+  try {
+    raw = await readFile(ownerFile, "utf8");
+  } catch {
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return {};
+  }
+  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 };
+}
+async function detectLegacyMigration(installRoot, loggedInUserId) {
+  void loggedInUserId;
+  const machinesDir = join(installRoot, "machines");
+  let entries;
+  try {
+    entries = await readdir(machinesDir);
+  } catch {
+    return { kind: "no-match" };
+  }
+  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
+    });
+  }
+  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
+    };
+  }
+  return { kind: "ambiguous", candidates };
+}
+
+// src/status.ts
+import { readFile as readFile5 } from "fs/promises";
+
+// src/paths.ts
+import { createHash } from "crypto";
+import os from "os";
+import path from "path";
+function computerDir(slockHome) {
+  return path.join(slockHome, "computer");
+}
+function userSessionPath(slockHome) {
+  return path.join(computerDir(slockHome), "user-session.json");
+}
+var SERVER_ID_RE = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
+function isValidServerId(serverId) {
+  return SERVER_ID_RE.test(serverId);
+}
+function assertValidServerId(serverId) {
+  if (!isValidServerId(serverId)) {
+    throw new Error(`invalid server id: ${JSON.stringify(serverId)} (expected a UUID)`);
+  }
+  return serverId;
+}
+function serversDir(slockHome) {
+  return path.join(computerDir(slockHome), "servers");
+}
+function serverDir(slockHome, serverId) {
+  return path.join(serversDir(slockHome), assertValidServerId(serverId));
+}
+function serverAttachmentPath(slockHome, serverId) {
+  return path.join(serverDir(slockHome, serverId), "attachment.json");
+}
+function serverDaemonPidPath(slockHome, serverId) {
+  return path.join(serverDir(slockHome, serverId), "daemon.pid");
+}
+function serverDaemonLogPath(slockHome, serverId) {
+  return path.join(serverDir(slockHome, serverId), "daemon.log");
+}
+function serverHealthPath(slockHome, serverId) {
+  return path.join(serverDir(slockHome, serverId), "health.json");
+}
+function supervisorPidPath(slockHome) {
+  return path.join(computerDir(slockHome), "supervisor.pid");
+}
+function supervisorLogPath(slockHome) {
+  return path.join(computerDir(slockHome), "supervisor.log");
+}
+
+// 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);
+    if (a.kind === "computer-attachment" && typeof a.serverId === "string" && typeof a.serverMachineId === "string" && typeof a.apiKey === "string" && a.apiKey.length > 0 && typeof a.serverUrl === "string") {
+      return {
+        kind: "computer-attachment",
+        serverId: a.serverId,
+        serverSlug: typeof a.serverSlug === "string" && a.serverSlug.length > 0 ? a.serverSlug : void 0,
+        serverMachineId: a.serverMachineId,
+        apiKey: a.apiKey,
+        serverUrl: a.serverUrl,
+        attachedAt: typeof a.attachedAt === "string" ? a.attachedAt : void 0
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+async function readServerAttachment(slockHome, serverId) {
+  if (!isValidServerId(serverId)) return null;
+  try {
+    return parseAttachment(await readFile2(serverAttachmentPath(slockHome, serverId), "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function listAttachedServerIds(slockHome) {
+  let entries;
+  try {
+    entries = await readdir2(serversDir(slockHome));
+  } catch {
+    return [];
+  }
+  const ids = [];
+  for (const name of entries) {
+    if (!isValidServerId(name)) continue;
+    if (await readServerAttachment(slockHome, name)) ids.push(name);
+  }
+  return ids.sort();
+}
+async function listServerAttachments(slockHome) {
+  const ids = await listAttachedServerIds(slockHome);
+  const out = [];
+  for (const id of ids) {
+    const a = await readServerAttachment(slockHome, id);
+    if (a) out.push(a);
+  }
+  return out;
+}
+
+// src/internal/process-primitives.ts
+import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2, unlink as unlink2 } from "fs/promises";
+import { dirname as dirname2 } from "path";
+async function readPidfileAt(pidfilePath) {
+  try {
+    const raw = (await readFile3(pidfilePath, "utf8")).trim();
+    const pid = Number.parseInt(raw, 10);
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+
+// 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;
+    }
+  } 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/status.ts
+async function readUserSession(path2) {
+  try {
+    const parsed = JSON.parse(await readFile5(path2, "utf8"));
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return { state: "present", session: parsed, error: null };
+    }
+    return { state: "invalid", session: null, error: "not a JSON object" };
+  } catch (err) {
+    if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") {
+      return { state: "missing", session: null, error: null };
+    }
+    return {
+      state: "invalid",
+      session: null,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function str(v) {
+  return typeof v === "string" && v.length > 0 ? v : null;
+}
+async function pidStatus(pidfile) {
+  const pid = await readPidfileAt(pidfile);
+  return pid !== null && isProcessAlive(pid) ? { running: true, pid } : { running: false };
+}
+async function deriveHealth(slockHome, serverId, daemon) {
+  if (!daemon.running) return "offline";
+  if (await isDegraded(slockHome, serverId)) return "degraded";
+  return "ok";
+}
+async function buildStatusReport(installRoot) {
+  const sessionRead = await readUserSession(userSessionPath(installRoot));
+  const session = sessionRead.session;
+  const attachments = await listServerAttachments(installRoot);
+  const supervisor = {
+    ...await pidStatus(supervisorPidPath(installRoot)),
+    logPath: supervisorLogPath(installRoot)
+  };
+  const servers = [];
+  for (const a of attachments) {
+    const daemon = await pidStatus(serverDaemonPidPath(installRoot, a.serverId));
+    servers.push({
+      serverId: a.serverId,
+      serverSlug: a.serverSlug ?? null,
+      serverMachineId: a.serverMachineId,
+      serverUrl: a.serverUrl,
+      attachedAt: a.attachedAt ?? null,
+      daemonLogPath: serverDaemonLogPath(installRoot, a.serverId),
+      daemon,
+      health: await deriveHealth(installRoot, a.serverId, daemon)
+    });
+  }
+  const loggedIn = session?.kind === "user-session" && typeof session.accessToken === "string" && session.accessToken.length > 0;
+  return {
+    slockHome: installRoot,
+    loggedIn,
+    userId: session ? str(session.userId) : null,
+    loginServerUrl: session ? str(session.serverUrl) : null,
+    userSessionError: sessionRead.state === "invalid" ? sessionRead.error : null,
+    supervisor,
+    servers
+  };
+}
+
+// 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);
+}
+async function readRunnerStatus(installRoot, serverId) {
+  const report = await buildStatusReport(installRoot);
+  const server = report.servers.find((s) => s.serverId === serverId);
+  if (!server) {
+    throw new StateReaderError(
+      "NOT_ATTACHED",
+      `Server ${serverId} is not attached to this Computer.`
+    );
+  }
+  const attachment = await readServerAttachment(installRoot, serverId);
+  if (!attachment) {
+    throw new StateReaderError(
+      "INVALID_ATTACHMENT",
+      `Attachment for server ${serverId} is missing or invalid.`
+    );
+  }
+  const client = new RunnersClient(attachment.serverUrl, attachment.apiKey);
+  const result = await client.list();
+  if (result.status === "success") {
+    return { status: "ok", server, whitelist: result.whitelist, runners: result.runners };
+  }
+  if (result.status === "unauthorized") {
+    return { status: "unauthorized", server };
+  }
+  return { status: "error", server, code: result.code };
+}
+async function listRunners(installRoot, opts = {}) {
+  const all = await listServerAttachments(installRoot);
+  let subset = all;
+  if (opts.serverId !== void 0) {
+    const found = all.find((a) => a.serverId === opts.serverId);
+    if (!found) {
+      throw new StateReaderError(
+        "NOT_ATTACHED",
+        `Server ${opts.serverId} is not attached to this Computer.`
+      );
+    }
+    subset = [found];
+  }
+  const servers = [];
+  for (const a of subset) {
+    const client = new RunnersClient(a.serverUrl, a.apiKey);
+    const result = await client.list();
+    const idCols = { serverId: a.serverId, serverSlug: a.serverSlug ?? null };
+    if (result.status === "success") {
+      servers.push({
+        ...idCols,
+        status: "ok",
+        whitelist: result.whitelist,
+        runners: result.runners
+      });
+    } else if (result.status === "unauthorized") {
+      servers.push({ ...idCols, status: "unauthorized" });
+    } else {
+      servers.push({ ...idCols, status: "error", code: result.code });
+    }
+  }
+  return { servers };
+}
 
 // src/lib/state.ts
 var RUNNER_STATE_VALUES = [
@@ -45,14 +442,7 @@ function isServiceState(value) {
 }
 
 // src/upgradeLog.ts
-import { chmod, mkdir, open } from "fs/promises";
-
-// src/paths.ts
-import { createHash } from "crypto";
-import os from "os";
-import path from "path";
-
-// src/upgradeLog.ts
+import { chmod as chmod2, mkdir as mkdir4, open } from "fs/promises";
 var UPGRADE_ERROR_CODES = [
   "UPGRADE_DEPS_CHANGED",
   "UPGRADE_NETWORK_FAILED",
@@ -96,12 +486,20 @@ function assertUpgradeLogEntry(entry) {
 }
 export {
   IPC_ERROR_CODES,
+  MIGRATION_DETECTION_KINDS,
   RUNNER_STATE_VALUES,
   SERVICE_STATE_VALUES,
+  STATE_READER_ERROR_CODES,
   ServiceClientError,
+  StateReaderError,
   UPGRADE_ERROR_CODES,
   assertUpgradeLogEntry,
+  detectLegacyMigration,
   isIpcErrorCode,
+  isMigrationDetectionKind,
   isRunnerState,
-  isServiceState
+  isServiceState,
+  listRunners,
+  readRunnerStatus,
+  readServiceStatus
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slock-ai/computer",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "description": "Slock Computer — standalone human/local-machine control-plane CLI (login + attach). Distinct from the agent-facing @slock-ai/cli.",
   "type": "module",
   "bin": {
@@ -28,7 +28,7 @@
     "commander": "^12.1.0",
     "proper-lockfile": "^4.1.2",
     "undici": "^7.24.7",
-    "@slock-ai/daemon": "0.55.0"
+    "@slock-ai/daemon": "0.55.1"
   },
   "devDependencies": {
     "@types/node": "^25.5.0",