@morty-build/cli 0.3.0 → 0.4.1

package/dist/{cli-QFRCPBAC.js → cli-TTSS5YD2.js}

@@ -36,10 +36,10 @@ import {
   validateLocalPath,
   validatePairingId,
   writeInstallationFile
-} from "./chunk-HIGGFLQ3.js";
+} from "./chunk-IXGJ5G6B.js";
 import {
   package_default
-} from "./chunk-SYR2NZQ5.js";
+} from "./chunk-ME4HCJOA.js";
 
 // ../../node_modules/.pnpm/commander@15.0.0/node_modules/commander/lib/error.js
 var CommanderError = class extends Error {
@@ -4194,26 +4194,15 @@ var RuntimeAgentProcesses = class {
 
 // src/storage/daemon/daemon-lock.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { readFile as readFile5, rename, unlink } from "node:fs/promises";
+import { access, rename, unlink } from "node:fs/promises";
 import { join as join9 } from "node:path";
 import { DatabaseSync } from "node:sqlite";
-import { setTimeout as delay } from "node:timers/promises";
 var SQLITE_BUSY = 5;
-var OWNERSHIP_CONTENTION_MILLISECONDS = 2e3;
-async function removeLockFile(path2) {
-  const released = `${path2}.${randomUUID4()}.released`;
-  try {
-    await rename(path2, released);
-  } catch {
-    return;
-  }
-  await unlink(released).catch(() => void 0);
-}
 function holdDaemonOwnership(path2) {
   const database = new DatabaseSync(path2);
   try {
-    database.exec("BEGIN EXCLUSIVE");
-    database.exec("PRAGMA locking_mode = EXCLUSIVE");
+    database.exec("BEGIN IMMEDIATE");
+    return () => database.close();
   } catch (cause) {
     database.close();
     if (cause instanceof Error && "errcode" in cause && cause.errcode === SQLITE_BUSY) {
@@ -4221,112 +4210,46 @@ function holdDaemonOwnership(path2) {
     }
     throw cause;
   }
-  try {
-    database.exec(
-      "CREATE TABLE IF NOT EXISTS daemon_owner (singleton INTEGER PRIMARY KEY CHECK (singleton = 1), pid INTEGER NOT NULL)"
-    );
-    const previous = database.prepare("SELECT pid FROM daemon_owner").get();
-    database.prepare("INSERT OR REPLACE INTO daemon_owner (singleton, pid) VALUES (1, ?)").run(process.pid);
-    database.exec("COMMIT");
-    return {
-      previousOwner: typeof previous?.["pid"] === "number" ? previous["pid"] : null,
-      release: () => database.close()
-    };
-  } catch (cause) {
-    database.close();
-    throw cause;
-  }
-}
-async function takeLockFile(path2, previousOwner) {
-  for (let attempt = 0; attempt < 2; attempt += 1) {
-    try {
-      await createInstallationFile(path2, `${process.pid.toString()}
-`);
-      return async () => await removeLockFile(path2);
-    } catch (cause) {
-      if (!isNodeError(cause, "EEXIST")) {
-        throw cause;
-      }
-      const encoded = await readFile5(path2, "utf8").catch(() => "");
-      const pid = Number(encoded.trim());
-      if (Number.isSafeInteger(pid) && pid > 1 && pid !== previousOwner) {
-        try {
-          process.kill(pid, 0);
-          return null;
-        } catch (probeCause) {
-          if (!isNodeError(probeCause, "ESRCH")) {
-            return null;
-          }
-        }
-      }
-      await removeLockFile(path2);
-    }
-  }
-  return null;
-}
-async function contendForDaemonOwnership(stateDirectory, filename) {
-  const path2 = join9(stateDirectory, filename);
-  const deadline = Date.now() + OWNERSHIP_CONTENTION_MILLISECONDS;
-  for (; ; ) {
-    const ownership = holdDaemonOwnership(`${path2}.sqlite`);
-    if (ownership !== null) {
-      return ownership;
-    }
-    if (await daemonLockExists(stateDirectory, filename) || Date.now() >= deadline) {
-      return null;
-    }
-    await delay(20 + Math.random() * 30);
-  }
 }
 async function acquireDaemonLock(stateDirectory, filename = "manager.lock") {
   const path2 = join9(stateDirectory, filename);
-  const ownership = await contendForDaemonOwnership(stateDirectory, filename);
-  if (ownership === null) {
+  const release = holdDaemonOwnership(`${path2}.sqlite`);
+  if (release === null) {
     return null;
   }
-  let releaseLockFile = null;
   try {
-    releaseLockFile = await takeLockFile(path2, ownership.previousOwner);
-  } finally {
-    if (releaseLockFile === null) {
-      ownership.release();
-    }
-  }
-  if (releaseLockFile === null) {
-    return null;
+    await writeInstallationFile(path2, `${process.pid.toString()}
+`, AbortSignal.timeout(1e4));
+  } catch (cause) {
+    release();
+    throw cause;
   }
-  const release = releaseLockFile;
   return async () => {
-    await release();
-    ownership.release();
+    try {
+      const detached = `${path2}.${randomUUID4()}.released`;
+      await rename(path2, detached);
+      await unlink(detached);
+    } finally {
+      release();
+    }
   };
 }
 async function daemonLockExists(stateDirectory, filename = "manager.lock") {
+  const path2 = join9(stateDirectory, `${filename}.sqlite`);
   try {
-    const pid = Number((await readFile5(join9(stateDirectory, filename), "utf8")).trim());
-    if (!Number.isSafeInteger(pid) || pid <= 1) {
-      return true;
-    }
-    try {
-      process.kill(pid, 0);
-    } catch (cause) {
-      if (isNodeError(cause, "ESRCH")) {
-        return false;
-      }
-      if (!isNodeError(cause, "EPERM")) {
-        throw cause;
-      }
-    }
-    return true;
+    await access(path2);
   } catch (cause) {
     if (isNodeError(cause, "ENOENT")) {
       return false;
     }
-    if (isNodeError(cause, "EPERM")) {
-      return true;
-    }
     throw cause;
   }
+  const release = holdDaemonOwnership(path2);
+  if (release === null) {
+    return true;
+  }
+  release();
+  return false;
 }
 
 // src/daemon/control/local-client.ts
@@ -4335,7 +4258,7 @@ import { createConnection } from "node:net";
 
 // src/storage/daemon/control-token.ts
 import { randomBytes } from "node:crypto";
-import { readFile as readFile6 } from "node:fs/promises";
+import { readFile as readFile5 } from "node:fs/promises";
 import { join as join10 } from "node:path";
 function controlTokenPath(stateDirectory) {
   return join10(stateDirectory, "manager.token");
@@ -4343,7 +4266,7 @@ function controlTokenPath(stateDirectory) {
 async function readOrCreateControlToken(stateDirectory) {
   const path2 = controlTokenPath(stateDirectory);
   try {
-    return (await readFile6(path2, "utf8")).trim();
+    return (await readFile5(path2, "utf8")).trim();
   } catch (cause) {
     if (!isNodeError(cause, "ENOENT")) {
       throw cause;
@@ -4358,7 +4281,7 @@ async function readOrCreateControlToken(stateDirectory) {
     if (!isNodeError(cause, "EEXIST")) {
       throw cause;
     }
-    return (await readFile6(path2, "utf8")).trim();
+    return (await readFile5(path2, "utf8")).trim();
   }
 }
 
@@ -4366,8 +4289,8 @@ async function readOrCreateControlToken(stateDirectory) {
 var CONTROL_TIMEOUT_MILLISECONDS = 13e4;
 var MAXIMUM_MESSAGE_BYTES = 64 * 1024;
 var managerPlatform = platformSupportFor(process.platform);
-function controlSocketPath(stateDirectory, endpoint = "manager") {
-  const installationHash = createHash("sha256").update(endpoint === "manager" ? stateDirectory : `${stateDirectory}:worker`).digest("hex").slice(0, 32);
+function controlSocketPath(stateDirectory) {
+  const installationHash = createHash("sha256").update(stateDirectory).digest("hex").slice(0, 32);
   return managerPlatform.controlSocketPath(installationHash);
 }
 async function readSocketMessage(socket, signal) {
@@ -4416,11 +4339,11 @@ async function readSocketMessage(socket, signal) {
     signal.addEventListener("abort", abort, { once: true });
   });
 }
-async function sendLocalRequest(stateDirectory, endpoint, command, signal) {
+async function sendLocalRequest(stateDirectory, command, signal) {
   const token = await readOrCreateControlToken(stateDirectory);
   const deadline = AbortSignal.any([signal, AbortSignal.timeout(CONTROL_TIMEOUT_MILLISECONDS)]);
   deadline.throwIfAborted();
-  const path2 = controlSocketPath(stateDirectory, endpoint);
+  const path2 = controlSocketPath(stateDirectory);
   await managerPlatform.validateControlPeer(path2, deadline);
   const socket = createConnection(path2);
   try {
@@ -4446,11 +4369,11 @@ async function sendLocalRequest(stateDirectory, endpoint, command, signal) {
 
 // src/daemon/control/local-server.ts
 import { createServer } from "node:net";
-async function serveLocalControl(stateDirectory, endpoint, signal, handle, onListening = () => void 0, onResponse = () => void 0) {
+async function serveLocalControl(stateDirectory, signal, handle, onListening = () => void 0, onResponse = () => void 0) {
   signal.throwIfAborted();
   const token = await readOrCreateControlToken(stateDirectory);
   const platform = platformSupportFor(process.platform);
-  const path2 = controlSocketPath(stateDirectory, endpoint);
+  const path2 = controlSocketPath(stateDirectory);
   const secured = Promise.withResolvers();
   void secured.promise.catch(() => void 0);
   const sockets = /* @__PURE__ */ new Set();
@@ -4592,7 +4515,7 @@ var DaemonRuntimeError = class extends Error {
 };
 async function reloadDaemon(stateDirectory, signal) {
   try {
-    const response = await sendLocalRequest(stateDirectory, "manager", { kind: "reload" }, signal);
+    const response = await sendLocalRequest(stateDirectory, { kind: "reload" }, signal);
     if (typeof response !== "object" || response === null || !("kind" in response) || response.kind !== "reloaded") {
       throw new Error("Saved configuration could not be applied to the running daemon");
     }
@@ -4604,7 +4527,7 @@ async function reloadDaemon(stateDirectory, signal) {
 }
 async function releaseIdleAgentProcesses(stateDirectory, signal) {
   try {
-    const response = await sendLocalRequest(stateDirectory, "manager", { kind: "release" }, signal);
+    const response = await sendLocalRequest(stateDirectory, { kind: "release" }, signal);
     if (typeof response === "object" && response !== null && "kind" in response && response.kind === "released") {
       return;
     }
@@ -4739,8 +4662,8 @@ async function runDaemonRuntime(version, combined, shutdown, rejectionGuard) {
     let reload = Promise.resolve();
     const handle = async (request) => {
       if (typeof request === "object" && request !== null && "kind" in request) {
-        if (request.kind === "status" || request.kind === "ensure") {
-          return { kind: "status", protocolVersion: 2, worker: { pid: process.pid, version } };
+        if (request.kind === "status") {
+          return { kind: "status", protocolVersion: 3, daemon: { pid: process.pid, version } };
         }
         if (request.kind === "stop") {
           return { kind: "stopped" };
@@ -4751,7 +4674,7 @@ async function runDaemonRuntime(version, combined, shutdown, rejectionGuard) {
         return { kind: "released" };
       }
       if (typeof request !== "object" || request === null || !("kind" in request) || request.kind !== "reload") {
-        return { kind: "error", code: "invalid_reload", message: "Expected a configuration reload" };
+        return { kind: "error", code: "unsupported_operation", message: "Unknown local control operation" };
       }
       const running = new Set(active.keys());
       const pending = reload.then(reconcile).then(async () => await refreshRunningCatalogs(running));
@@ -4769,32 +4692,17 @@ async function runDaemonRuntime(version, combined, shutdown, rejectionGuard) {
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         })
       );
-      const servers = ["manager"];
-      const results = await Promise.allSettled(
-        servers.map(async (endpoint) => {
-          try {
-            await serveLocalControl(
-              control.stateDirectory,
-              endpoint,
-              combined,
-              handle,
-              () => void 0,
-              (response) => {
-                if (typeof response === "object" && response !== null && "kind" in response && response.kind === "stopped") {
-                  shutdown.abort();
-                }
-              }
-            );
-          } finally {
+      await serveLocalControl(
+        control.stateDirectory,
+        combined,
+        handle,
+        () => void 0,
+        (response) => {
+          if (typeof response === "object" && response !== null && "kind" in response && response.kind === "stopped") {
             shutdown.abort();
           }
-        })
-      );
-      for (const result of results) {
-        if (result.status === "rejected") {
-          throw result.reason;
         }
-      }
+      );
       if (shutdown.signal.reason instanceof DaemonRuntimeError) {
         throw shutdown.signal.reason;
       }
@@ -4809,28 +4717,25 @@ async function runDaemonRuntime(version, combined, shutdown, rejectionGuard) {
 }
 
 // src/cli/handler/daemon/install.ts
-import { readFile as readFile7, rm as rm4 } from "node:fs/promises";
+import { readFile as readFile6, rm as rm4 } from "node:fs/promises";
 import { join as join11 } from "node:path";
 
 // src/daemon/lifecycle/daemon-client.ts
 import { spawn as spawn2 } from "node:child_process";
 import { once as once2 } from "node:events";
-import { setTimeout as delay2 } from "node:timers/promises";
+import { setTimeout as delay } from "node:timers/promises";
 
 // src/daemon/control/protocol.ts
 var lifecycleResponse = external_exports.discriminatedUnion("kind", [
-  external_exports.object({
+  external_exports.strictObject({
     kind: external_exports.literal("status"),
-    protocolVersion: external_exports.literal(2),
-    worker: external_exports.object({ pid: external_exports.number().int().positive(), version: external_exports.string() }).readonly().nullable()
+    protocolVersion: external_exports.literal(3),
+    daemon: external_exports.strictObject({ pid: external_exports.number().int().positive(), version: external_exports.string() }).readonly()
   }),
-  external_exports.object({ kind: external_exports.literal("stopped") }),
-  external_exports.object({ kind: external_exports.literal("error"), code: external_exports.string(), message: external_exports.string() })
+  external_exports.strictObject({ kind: external_exports.literal("stopped") }),
+  external_exports.strictObject({ kind: external_exports.literal("error"), code: external_exports.string(), message: external_exports.string() })
 ]).readonly();
-function decodeKnownLifecycleResponse(value) {
-  if (typeof value === "object" && value !== null && "kind" in value && typeof value.kind === "string" && !["status", "stopped", "error"].includes(value.kind)) {
-    return null;
-  }
+function decodeLifecycleResponse(value) {
   return lifecycleResponse.parse(value);
 }
 
@@ -4873,7 +4778,7 @@ async function waitForDaemonExit(stateDirectory, signal) {
   }
   throw deadline.reason;
 }
-async function ensureDaemon(stateDirectory, _version, signal) {
+async function ensureDaemon(stateDirectory, signal) {
   const running = await readDaemonVersion(stateDirectory, signal);
   if (running !== null) {
     return running;
@@ -4884,11 +4789,9 @@ async function ensureDaemon(stateDirectory, _version, signal) {
 }
 async function readDaemonVersion(stateDirectory, signal) {
   try {
-    const response = decodeKnownLifecycleResponse(
-      await sendLocalRequest(stateDirectory, "manager", { kind: "status" }, signal)
-    );
-    if (response?.kind === "status") {
-      return response.worker?.version ?? null;
+    const response = decodeLifecycleResponse(await sendLocalRequest(stateDirectory, { kind: "status" }, signal));
+    if (response.kind === "status") {
+      return response.daemon.version;
     }
   } catch (cause) {
     if (!isNodeError(cause, "ENOENT") && !isNodeError(cause, "ECONNREFUSED")) {
@@ -4902,18 +4805,18 @@ async function waitForDaemon(stateDirectory, version, entry, signal) {
   let child;
   while (!signal.aborted) {
     try {
-      const response = decodeKnownLifecycleResponse(
-        await sendLocalRequest(stateDirectory, "manager", { kind: "status" }, signal)
+      const response = decodeLifecycleResponse(
+        await sendLocalRequest(stateDirectory, { kind: "status" }, signal)
       );
-      if (response?.kind === "error") {
+      if (response.kind === "error") {
         throw new Error(response.message);
       }
-      if (response?.kind === "status" && response.worker !== null) {
+      if (response.kind === "status") {
         if (daemonStarted) {
           process.stdout.write(`Morty daemon ${version} started
 `);
         }
-        return response.worker.version;
+        return response.daemon.version;
       }
       throw new Error("The daemon could not return its status");
     } catch (cause) {
@@ -4946,13 +4849,13 @@ async function stopDaemon(stateDirectory, signal) {
   while (true) {
     deadline.throwIfAborted();
     try {
-      const response = decodeKnownLifecycleResponse(
-        await sendLocalRequest(stateDirectory, "manager", { kind: "stop" }, deadline)
+      const response = decodeLifecycleResponse(
+        await sendLocalRequest(stateDirectory, { kind: "stop" }, deadline)
       );
-      if (response?.kind === "error") {
+      if (response.kind === "error") {
         throw new Error(response.message);
       }
-      if (response?.kind !== "stopped") {
+      if (response.kind !== "stopped") {
         throw new Error("The Morty daemon returned an unexpected response");
       }
       await waitForDaemonExit(stateDirectory, deadline);
@@ -4965,7 +4868,7 @@ async function stopDaemon(stateDirectory, signal) {
       if (!await daemonLockExists(stateDirectory)) {
         return { kind: "stopped" };
       }
-      await delay2(50, void 0, { signal: deadline });
+      await delay(50, void 0, { signal: deadline });
     }
   }
 }
@@ -4998,7 +4901,7 @@ async function install(options, context) {
     switched = true;
     await recordInstallationState({ kind: "switched", previous, candidate }, signal);
     if (running !== null) {
-      const started = await ensureDaemon(control.stateDirectory, candidate.version, signal);
+      const started = await ensureDaemon(control.stateDirectory, signal);
       if (started !== candidate.version) {
         throw new Error("A competing startup selected another Morty version");
       }
@@ -5014,13 +4917,13 @@ async function install(options, context) {
         if (previous !== null) {
           await selectRelease(previous, recovery);
           if (running !== null) {
-            await ensureDaemon(control.stateDirectory, previous.version, recovery);
+            await ensureDaemon(control.stateDirectory, recovery);
           }
         } else {
           await rm4(join11(executableDirectory(), "current.json"), { force: true });
         }
       } else if (running !== null && previous !== null) {
-        await ensureDaemon(control.stateDirectory, previous.version, recovery);
+        await ensureDaemon(control.stateDirectory, recovery);
       }
       await recordInstallationState({ kind: "failed", recovered: true, installed: previous }, recovery);
     } catch (recoveryError) {
@@ -5067,7 +4970,7 @@ function registerInstallCommands(program2, context) {
     process.stdout.write(`Installed: ${release?.version ?? "not installed"}
 `);
     try {
-      const operation = await readFile7(join11(executableDirectory(), "operation.json"), {
+      const operation = await readFile6(join11(executableDirectory(), "operation.json"), {
         encoding: "utf8",
         signal: context.shutdownSignal
       });
@@ -5103,7 +5006,7 @@ function registerReleaseCommand(program2, context) {
 function registerStartCommand(program2, context) {
   program2.command("start").description("ensure the daemon is running and optionally activate a saved connection").addOption(valueOption("--connection <connection-id>", "saved Runtime connection identifier")).action(async (options) => {
     const control = await openMortyControlInstallation(context.shutdownSignal, process.env);
-    await ensureDaemon(control.stateDirectory, context.version, context.shutdownSignal);
+    await ensureDaemon(control.stateDirectory, context.shutdownSignal);
     const installation = await openMortyCliInstallation(context.shutdownSignal, process.env);
     if (options.connection !== void 0) {
       await installation.setConnectionActivation(options.connection, "active", context.shutdownSignal);
@@ -5118,7 +5021,7 @@ function registerUpgradeCommand(program2, context) {
   program2.command("restart").description("restart the daemon using the installed Morty release").action(async () => {
     const control = await openMortyControlInstallation(context.shutdownSignal, process.env);
     await stopDaemon(control.stateDirectory, context.shutdownSignal);
-    const version = await ensureDaemon(control.stateDirectory, context.version, context.shutdownSignal);
+    const version = await ensureDaemon(control.stateDirectory, context.shutdownSignal);
     process.stdout.write(`Morty daemon ${version} restarted.
 `);
   });
@@ -5143,7 +5046,7 @@ import { fork } from "node:child_process";
 import { join as join14, resolve as resolve3 } from "node:path";
 
 // src/storage/diagnostics/relay-probe-files.ts
-import { mkdir as mkdir3, readFile as readFile8, rm as rm5, stat as stat2, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir3, readFile as readFile7, rm as rm5, stat as stat2, writeFile as writeFile3 } from "node:fs/promises";
 import { join as join12 } from "node:path";
 var ProbeConfigurationFileError = class extends Error {
   code = "probe_config_invalid";
@@ -5157,7 +5060,7 @@ async function readPrivateProbeConfiguration(path2, signal) {
     );
   }
   try {
-    return JSON.parse(await readFile8(path2, { encoding: "utf8", signal }));
+    return JSON.parse(await readFile7(path2, { encoding: "utf8", signal }));
   } catch {
     signal.throwIfAborted();
     throw new ProbeConfigurationFileError("The pairing configuration is not valid JSON");
@@ -5727,7 +5630,7 @@ function registerDiagnoseCommand(program2, context) {
 import { join as join16, relative as relative3, resolve as resolve4 } from "node:path";
 
 // src/storage/logs/log-files.ts
-import { lstat as lstat2, readdir as readdir4, readFile as readFile9 } from "node:fs/promises";
+import { lstat as lstat2, readdir as readdir4, readFile as readFile8 } from "node:fs/promises";
 import { join as join15, relative as relative2 } from "node:path";
 var LOG_FILE_NAME_PATTERN = /^[\w.-]{1,128}\.log$/u;
 var INSTALLATIONS_DIRECTORY = "installations";
@@ -5804,7 +5707,7 @@ async function readOwnedLogFile(path2, signal) {
     return { kind: "skipped" };
   }
   try {
-    return { kind: "read", content: await readFile9(path2, { encoding: "utf8", signal }) };
+    return { kind: "read", content: await readFile8(path2, { encoding: "utf8", signal }) };
   } catch (cause) {
     if (signal.aborted) {
       throw cause;
@@ -6031,7 +5934,7 @@ function registerPairAction(command, context) {
   ).addOption(valueOption("--pairing <runtime-pairing-id>", "Runtime pairing identifier")).addOption(valueOption("--workspace <directory>", "default workspace directory")).action(async (options) => {
     const requested = await requirePairOptions(options, command, process.stdin, context.shutdownSignal);
     const control = await openMortyControlInstallation(context.shutdownSignal, process.env);
-    await ensureDaemon(control.stateDirectory, context.version, context.shutdownSignal);
+    await ensureDaemon(control.stateDirectory, context.shutdownSignal);
     const installation = await openMortyCliInstallation(context.shutdownSignal, process.env);
     process.stdout.write(`morty version: ${context.version}
 `);
@@ -6223,4 +6126,4 @@ async function runCLI() {
 export {
   runCLI
 };
-//# sourceMappingURL=cli-QFRCPBAC.js.map
+//# sourceMappingURL=cli-TTSS5YD2.js.map