@slock-ai/daemon 0.41.0 → 0.41.1-alpha.0

package/dist/{chunk-KFVDXO5Y.js → chunk-JAB3HALZ.js}

@@ -4,8 +4,8 @@ import {
 } from "./chunk-JG7ONJZ6.js";
 
 // src/core.ts
-import path11 from "path";
-import os4 from "os";
+import path12 from "path";
+import os5 from "os";
 import { createRequire } from "module";
 import { accessSync } from "fs";
 import { fileURLToPath } from "url";
@@ -1097,7 +1097,7 @@ function normalizeExecOutput(raw) {
   return Buffer.isBuffer(raw) ? raw.toString("utf8") : String(raw ?? "");
 }
 function resolveCommandOnWindows(command, env, execFileSyncFn) {
-  const script = "$cmd = Get-Command -Name $args[0] -ErrorAction Stop | Select-Object -First 1; if ($cmd.Path) { $cmd.Path } elseif ($cmd.Source) { $cmd.Source } elseif ($cmd.Definition) { $cmd.Definition }";
+  const script = "& {$cmd = Get-Command -Name $args[0] -ErrorAction Stop | Select-Object -First 1; if ($cmd.Path) { $cmd.Path } elseif ($cmd.Source) { $cmd.Source } elseif ($cmd.Definition) { $cmd.Definition } }";
   try {
     const output = normalizeExecOutput(execFileSyncFn("powershell.exe", [
       "-NoProfile",
@@ -4585,6 +4585,112 @@ var ReminderCache = class {
   }
 };
 
+// src/machineLock.ts
+import { createHash, randomUUID as randomUUID2 } from "crypto";
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync3, rmSync, statSync, writeFileSync as writeFileSync7 } from "fs";
+import os4 from "os";
+import path11 from "path";
+var DEFAULT_MACHINE_STATE_ROOT = path11.join(os4.homedir(), ".slock", "machines");
+var INCOMPLETE_LOCK_STALE_MS = 3e4;
+var DaemonMachineLockConflictError = class extends Error {
+  code = "DAEMON_MACHINE_LOCK_HELD";
+  constructor(lockDir, owner) {
+    const ownerText = owner ? `pid=${owner.pid}, startedAt=${owner.startedAt}, host=${owner.hostname}` : "unknown owner";
+    super(
+      `Another Slock daemon is already running for this machine key (${ownerText}). Lock: ${lockDir}. Stop the existing daemon first, or use a different machine key/state directory.`
+    );
+    this.name = "DaemonMachineLockConflictError";
+  }
+};
+function apiKeyFingerprint(apiKey) {
+  return createHash("sha256").update(apiKey).digest("hex");
+}
+function getDaemonMachineLockId(apiKey) {
+  return `machine-${apiKeyFingerprint(apiKey).slice(0, 16)}`;
+}
+function ownerPath(lockDir) {
+  return path11.join(lockDir, "owner.json");
+}
+function readOwner(lockDir) {
+  try {
+    return JSON.parse(readFileSync3(ownerPath(lockDir), "utf8"));
+  } catch {
+    return null;
+  }
+}
+function lockAgeMs(lockDir) {
+  try {
+    return Date.now() - statSync(lockDir).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = typeof err === "object" && err && "code" in err ? err.code : void 0;
+    return code !== "ESRCH";
+  }
+}
+function acquireDaemonMachineLock(options) {
+  const rootDir = options.rootDir ?? DEFAULT_MACHINE_STATE_ROOT;
+  const fingerprint = apiKeyFingerprint(options.apiKey);
+  const lockId = getDaemonMachineLockId(options.apiKey);
+  const machineDir = path11.join(rootDir, lockId);
+  const lockDir = path11.join(machineDir, "daemon.lock");
+  const token = randomUUID2();
+  mkdirSync4(machineDir, { recursive: true });
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      mkdirSync4(lockDir);
+      const owner = {
+        pid: process.pid,
+        token,
+        hostname: os4.hostname(),
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        serverUrl: options.serverUrl,
+        apiKeyFingerprint: fingerprint.slice(0, 16)
+      };
+      try {
+        writeFileSync7(ownerPath(lockDir), `${JSON.stringify(owner, null, 2)}
+`, { mode: 384 });
+      } catch (err) {
+        rmSync(lockDir, { recursive: true, force: true });
+        throw err;
+      }
+      return {
+        lockId,
+        machineDir,
+        lockDir,
+        release: () => {
+          const currentOwner = readOwner(lockDir);
+          if (currentOwner?.pid === process.pid && currentOwner.token === token) {
+            rmSync(lockDir, { recursive: true, force: true });
+          }
+        }
+      };
+    } catch (err) {
+      const code = typeof err === "object" && err && "code" in err ? err.code : void 0;
+      if (code !== "EEXIST") throw err;
+      const owner = readOwner(lockDir);
+      if (owner?.pid && isProcessAlive(owner.pid)) {
+        throw new DaemonMachineLockConflictError(lockDir, owner);
+      }
+      if (!owner) {
+        const ageMs = lockAgeMs(lockDir);
+        if (ageMs === null || ageMs < INCOMPLETE_LOCK_STALE_MS) {
+          throw new DaemonMachineLockConflictError(lockDir, null);
+        }
+      }
+      rmSync(lockDir, { recursive: true, force: true });
+    }
+  }
+  throw new DaemonMachineLockConflictError(lockDir, readOwner(lockDir));
+}
+
 // src/core.ts
 var DAEMON_CLI_USAGE = "Usage: slock-daemon --server-url <url> --api-key <key>";
 function parseDaemonCliArgs(args) {
@@ -4606,23 +4712,23 @@ function readDaemonVersion(moduleUrl = import.meta.url) {
   }
 }
 function resolveChatBridgePath(moduleUrl = import.meta.url) {
-  const dirname = path11.dirname(fileURLToPath(moduleUrl));
-  const jsPath = path11.resolve(dirname, "chat-bridge.js");
+  const dirname = path12.dirname(fileURLToPath(moduleUrl));
+  const jsPath = path12.resolve(dirname, "chat-bridge.js");
   try {
     accessSync(jsPath);
     return jsPath;
   } catch {
-    return path11.resolve(dirname, "chat-bridge.ts");
+    return path12.resolve(dirname, "chat-bridge.ts");
   }
 }
 function resolveSlockCliPath(moduleUrl = import.meta.url) {
-  const thisDir = path11.dirname(fileURLToPath(moduleUrl));
-  const bundledDistPath = path11.resolve(thisDir, "cli", "index.js");
+  const thisDir = path12.dirname(fileURLToPath(moduleUrl));
+  const bundledDistPath = path12.resolve(thisDir, "cli", "index.js");
   try {
     accessSync(bundledDistPath);
     return bundledDistPath;
   } catch {
-    const workspaceDistPath = path11.resolve(thisDir, "..", "..", "cli", "dist", "index.js");
+    const workspaceDistPath = path12.resolve(thisDir, "..", "..", "cli", "dist", "index.js");
     accessSync(workspaceDistPath);
     return workspaceDistPath;
   }
@@ -4701,6 +4807,7 @@ var DaemonCore = class {
   connection;
   reminderCache;
   tracer;
+  machineLock = null;
   constructor(options) {
     this.options = options;
     this.daemonVersion = options.daemonVersion ?? readDaemonVersion();
@@ -4731,15 +4838,39 @@ var DaemonCore = class {
     });
     this.connection = connection;
   }
+  resolveMachineStateRoot() {
+    if (this.options.machineStateDir) return this.options.machineStateDir;
+    if (this.options.dataDir) return path12.join(path12.dirname(this.options.dataDir), "machines");
+    return DEFAULT_MACHINE_STATE_ROOT;
+  }
   start() {
     logger.info("[Slock Daemon] Starting...");
-    this.connection.connect();
+    if (!this.machineLock) {
+      this.machineLock = acquireDaemonMachineLock({
+        apiKey: this.options.apiKey,
+        serverUrl: this.options.serverUrl,
+        rootDir: this.resolveMachineStateRoot()
+      });
+      logger.info(`[Slock Daemon] Acquired machine lock: ${this.machineLock.lockDir}`);
+    }
+    try {
+      this.connection.connect();
+    } catch (err) {
+      this.machineLock.release();
+      this.machineLock = null;
+      throw err;
+    }
   }
   async stop() {
     logger.info("[Slock Daemon] Shutting down...");
     this.reminderCache.clear();
-    await this.agentManager.stopAll();
-    this.connection.disconnect();
+    try {
+      await this.agentManager.stopAll();
+    } finally {
+      this.connection.disconnect();
+      this.machineLock?.release();
+      this.machineLock = null;
+    }
   }
   get connected() {
     return this.connection.connected;
@@ -4900,8 +5031,8 @@ var DaemonCore = class {
       capabilities: ["agent:start", "agent:stop", "agent:deliver", "workspace:files"],
       runtimes,
       runningAgents: this.agentManager.getRunningAgentIds(),
-      hostname: this.options.hostname ?? os4.hostname(),
-      os: this.options.osDescription ?? `${os4.platform()} ${os4.arch()}`,
+      hostname: this.options.hostname ?? os5.hostname(),
+      os: this.options.osDescription ?? `${os5.platform()} ${os5.arch()}`,
       daemonVersion: this.daemonVersion
     });
     for (const agentId of this.agentManager.getRunningAgentIds()) {

package/dist/core.js

@@ -9,7 +9,7 @@ import {
   resolveSlockCliPath,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories
-} from "./chunk-KFVDXO5Y.js";
+} from "./chunk-JAB3HALZ.js";
 import {
   subscribeDaemonLogs
 } from "./chunk-JG7ONJZ6.js";

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   DAEMON_CLI_USAGE,
   DaemonCore,
   parseDaemonCliArgs
-} from "./chunk-KFVDXO5Y.js";
+} from "./chunk-JAB3HALZ.js";
 import "./chunk-JG7ONJZ6.js";
 
 // src/index.ts
@@ -13,7 +13,12 @@ if (!parsedArgs) {
   process.exit(1);
 }
 var daemon = new DaemonCore(parsedArgs);
-daemon.start();
+try {
+  daemon.start();
+} catch (err) {
+  console.error(err instanceof Error ? err.message : err);
+  process.exit(1);
+}
 var shutdown = async () => {
   await daemon.stop();
   process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slock-ai/daemon",
-  "version": "0.41.0",
+  "version": "0.41.1-alpha.0",
   "type": "module",
   "bin": {
     "slock-daemon": "dist/index.js"