@metamask-previews/wallet-cli 0.0.0-preview-b3db565c8 → 0.0.0-preview-8bfa290fb

package/dist/daemon/stop-daemon.cjs

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stopDaemon = void 0;
+const promises_1 = require("node:fs/promises");
+const daemon_client_js_1 = require("./daemon-client.cjs");
+const utils_js_1 = require("./utils.cjs");
+/**
+ * Stop the daemon, preferring a graceful shutdown.
+ *
+ * Resolution order when a live daemon is present:
+ * 1. If the socket is responsive, request a graceful `shutdown` over it.
+ * 2. If the recorded PID is still alive, escalate to SIGTERM.
+ * 3. ...then SIGKILL.
+ *
+ * Signals (steps 2-3) are only ever sent against a PID that is observed alive.
+ * The socket-absent + alive-PID branch trades a small risk of signalling a
+ * recycled PID for the larger risk of leaving an orphan daemon holding the
+ * SQLite database — which `daemon purge` would otherwise wipe out from under
+ * it.
+ *
+ * When the socket is NOT responsive AND the recorded PID is dead (or there is
+ * no PID file), there is no live daemon: a lingering socket or PID file is
+ * stale leftovers from a daemon that already exited — typically one that
+ * crashed without running its own cleanup. Those files are removed and the
+ * stop is reported as successful, rather than failing on a daemon that is
+ * already gone.
+ *
+ * @param socketPath - The daemon socket path.
+ * @param pidPath - The daemon PID file path.
+ * @param log - Optional logging function for status messages.
+ * @returns True if the daemon was stopped (or was not running).
+ */
+async function stopDaemon(socketPath, pidPath, log) {
+    const pid = await (0, utils_js_1.readPidFile)(pidPath);
+    const ping = await (0, daemon_client_js_1.pingDaemon)(socketPath);
+    const socketObserved = ping.status === 'responsive' || ping.status === 'unreachable';
+    const processAlive = pid !== undefined && (0, utils_js_1.isProcessAlive)(pid);
+    // Only `absent` and `refused` prove no live daemon; `permission`/`timeout`/
+    // `protocol` may be a wedged or foreign daemon, so those fall through.
+    const socketProvenGone = ping.status === 'absent' ||
+        (ping.status === 'unreachable' && ping.reason === 'refused');
+    if (socketProvenGone && !processAlive) {
+        await cleanupFile(pidPath, 'PID file', log);
+        await cleanupFile(socketPath, 'socket file', log);
+        return true;
+    }
+    log?.('Stopping daemon...');
+    let stopped = false;
+    // Strategy 1: Graceful socket-based shutdown.
+    if (ping.status === 'responsive') {
+        try {
+            await (0, daemon_client_js_1.sendCommand)({ socketPath, method: 'shutdown' });
+        }
+        catch (error) {
+            log?.(`Graceful shutdown request failed: ${String(error)}`);
+        }
+        // A quiet socket does not prove the process exited; require the recorded
+        // pid to be gone too, so a daemon that outlived its socket falls through to
+        // SIGTERM/SIGKILL rather than being orphaned.
+        stopped = await (0, utils_js_1.waitFor)(async () => (await (0, daemon_client_js_1.pingDaemon)(socketPath)).status !== 'responsive' &&
+            (pid === undefined || !(0, utils_js_1.isProcessAlive)(pid)), 5000);
+    }
+    // Strategy 2: SIGTERM. Signal when either the socket was observed or the
+    // recorded PID is alive; the absent+alive case typically means someone
+    // removed the socket from under a live daemon.
+    if (!stopped && processAlive && pid !== undefined) {
+        if (!socketObserved) {
+            log?.(`Socket at ${socketPath} is absent but recorded pid ${pid} is alive; signalling anyway.`);
+        }
+        try {
+            if ((0, utils_js_1.sendSignal)(pid, 'SIGTERM')) {
+                stopped = await (0, utils_js_1.waitFor)(() => !(0, utils_js_1.isProcessAlive)(pid), 5000);
+            }
+            else {
+                stopped = true; // Process already gone (ESRCH).
+            }
+        }
+        catch (error) {
+            log?.(`SIGTERM failed: ${String(error)}`);
+        }
+    }
+    // Strategy 3: SIGKILL.
+    if (!stopped && processAlive && pid !== undefined) {
+        try {
+            if ((0, utils_js_1.sendSignal)(pid, 'SIGKILL')) {
+                stopped = await (0, utils_js_1.waitFor)(() => !(0, utils_js_1.isProcessAlive)(pid), 2000);
+            }
+            else {
+                stopped = true; // Process already gone (ESRCH).
+            }
+        }
+        catch (error) {
+            log?.(`SIGKILL failed: ${String(error)}`);
+        }
+    }
+    if (stopped) {
+        await cleanupFile(pidPath, 'PID file', log);
+        await cleanupFile(socketPath, 'socket file', log);
+        log?.('Daemon stopped.');
+    }
+    return stopped;
+}
+exports.stopDaemon = stopDaemon;
+/**
+ * Remove a file best-effort, logging any failure rather than letting it
+ * propagate. ENOENT is silently ignored via `force: true`.
+ *
+ * @param path - The file path to remove.
+ * @param label - Human-readable label for log messages.
+ * @param log - Optional log sink.
+ */
+async function cleanupFile(path, label, log) {
+    await (0, promises_1.rm)(path, { force: true }).catch((error) => {
+        log?.(`Failed to remove ${label}: ${String(error)}`);
+    });
+}
+//# sourceMappingURL=stop-daemon.cjs.map

package/dist/daemon/stop-daemon.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stop-daemon.cjs","sourceRoot":"","sources":["../../src/daemon/stop-daemon.ts"],"names":[],"mappings":"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","sourcesContent":["import { rm } from 'node:fs/promises';\n\nimport { pingDaemon, sendCommand } from './daemon-client.js';\nimport { isProcessAlive, readPidFile, sendSignal, waitFor } from './utils.js';\n\n/**\n * Stop the daemon, preferring a graceful shutdown.\n *\n * Resolution order when a live daemon is present:\n * 1. If the socket is responsive, request a graceful `shutdown` over it.\n * 2. If the recorded PID is still alive, escalate to SIGTERM.\n * 3. ...then SIGKILL.\n *\n * Signals (steps 2-3) are only ever sent against a PID that is observed alive.\n * The socket-absent + alive-PID branch trades a small risk of signalling a\n * recycled PID for the larger risk of leaving an orphan daemon holding the\n * SQLite database — which `daemon purge` would otherwise wipe out from under\n * it.\n *\n * When the socket is NOT responsive AND the recorded PID is dead (or there is\n * no PID file), there is no live daemon: a lingering socket or PID file is\n * stale leftovers from a daemon that already exited — typically one that\n * crashed without running its own cleanup. Those files are removed and the\n * stop is reported as successful, rather than failing on a daemon that is\n * already gone.\n *\n * @param socketPath - The daemon socket path.\n * @param pidPath - The daemon PID file path.\n * @param log - Optional logging function for status messages.\n * @returns True if the daemon was stopped (or was not running).\n */\nexport async function stopDaemon(\n  socketPath: string,\n  pidPath: string,\n  log?: (message: string) => void,\n): Promise<boolean> {\n  const pid = await readPidFile(pidPath);\n  const ping = await pingDaemon(socketPath);\n  const socketObserved =\n    ping.status === 'responsive' || ping.status === 'unreachable';\n  const processAlive = pid !== undefined && isProcessAlive(pid);\n\n  // Only `absent` and `refused` prove no live daemon; `permission`/`timeout`/\n  // `protocol` may be a wedged or foreign daemon, so those fall through.\n  const socketProvenGone =\n    ping.status === 'absent' ||\n    (ping.status === 'unreachable' && ping.reason === 'refused');\n\n  if (socketProvenGone && !processAlive) {\n    await cleanupFile(pidPath, 'PID file', log);\n    await cleanupFile(socketPath, 'socket file', log);\n    return true;\n  }\n\n  log?.('Stopping daemon...');\n\n  let stopped = false;\n\n  // Strategy 1: Graceful socket-based shutdown.\n  if (ping.status === 'responsive') {\n    try {\n      await sendCommand({ socketPath, method: 'shutdown' });\n    } catch (error) {\n      log?.(`Graceful shutdown request failed: ${String(error)}`);\n    }\n    // A quiet socket does not prove the process exited; require the recorded\n    // pid to be gone too, so a daemon that outlived its socket falls through to\n    // SIGTERM/SIGKILL rather than being orphaned.\n    stopped = await waitFor(\n      async () =>\n        (await pingDaemon(socketPath)).status !== 'responsive' &&\n        (pid === undefined || !isProcessAlive(pid)),\n      5_000,\n    );\n  }\n\n  // Strategy 2: SIGTERM. Signal when either the socket was observed or the\n  // recorded PID is alive; the absent+alive case typically means someone\n  // removed the socket from under a live daemon.\n  if (!stopped && processAlive && pid !== undefined) {\n    if (!socketObserved) {\n      log?.(\n        `Socket at ${socketPath} is absent but recorded pid ${pid} is alive; signalling anyway.`,\n      );\n    }\n    try {\n      if (sendSignal(pid, 'SIGTERM')) {\n        stopped = await waitFor(() => !isProcessAlive(pid), 5_000);\n      } else {\n        stopped = true; // Process already gone (ESRCH).\n      }\n    } catch (error) {\n      log?.(`SIGTERM failed: ${String(error)}`);\n    }\n  }\n\n  // Strategy 3: SIGKILL.\n  if (!stopped && processAlive && pid !== undefined) {\n    try {\n      if (sendSignal(pid, 'SIGKILL')) {\n        stopped = await waitFor(() => !isProcessAlive(pid), 2_000);\n      } else {\n        stopped = true; // Process already gone (ESRCH).\n      }\n    } catch (error) {\n      log?.(`SIGKILL failed: ${String(error)}`);\n    }\n  }\n\n  if (stopped) {\n    await cleanupFile(pidPath, 'PID file', log);\n    await cleanupFile(socketPath, 'socket file', log);\n    log?.('Daemon stopped.');\n  }\n\n  return stopped;\n}\n\n/**\n * Remove a file best-effort, logging any failure rather than letting it\n * propagate. ENOENT is silently ignored via `force: true`.\n *\n * @param path - The file path to remove.\n * @param label - Human-readable label for log messages.\n * @param log - Optional log sink.\n */\nasync function cleanupFile(\n  path: string,\n  label: string,\n  log: ((message: string) => void) | undefined,\n): Promise<void> {\n  await rm(path, { force: true }).catch((error: unknown) => {\n    log?.(`Failed to remove ${label}: ${String(error)}`);\n  });\n}\n"]}

package/dist/daemon/{stop-daemon.d.ts → stop-daemon.d.cts}

@@ -25,4 +25,4 @@
  * @returns True if the daemon was stopped (or was not running).
  */
 export declare function stopDaemon(socketPath: string, pidPath: string, log?: (message: string) => void): Promise<boolean>;
-//# sourceMappingURL=stop-daemon.d.ts.map
+//# sourceMappingURL=stop-daemon.d.cts.map

package/dist/daemon/stop-daemon.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stop-daemon.d.cts","sourceRoot":"","sources":["../../src/daemon/stop-daemon.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,UAAU,CAC9B,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GAC9B,OAAO,CAAC,OAAO,CAAC,CAiFlB"}

package/dist/daemon/stop-daemon.d.mts

@@ -0,0 +1,28 @@
+/**
+ * Stop the daemon, preferring a graceful shutdown.
+ *
+ * Resolution order when a live daemon is present:
+ * 1. If the socket is responsive, request a graceful `shutdown` over it.
+ * 2. If the recorded PID is still alive, escalate to SIGTERM.
+ * 3. ...then SIGKILL.
+ *
+ * Signals (steps 2-3) are only ever sent against a PID that is observed alive.
+ * The socket-absent + alive-PID branch trades a small risk of signalling a
+ * recycled PID for the larger risk of leaving an orphan daemon holding the
+ * SQLite database — which `daemon purge` would otherwise wipe out from under
+ * it.
+ *
+ * When the socket is NOT responsive AND the recorded PID is dead (or there is
+ * no PID file), there is no live daemon: a lingering socket or PID file is
+ * stale leftovers from a daemon that already exited — typically one that
+ * crashed without running its own cleanup. Those files are removed and the
+ * stop is reported as successful, rather than failing on a daemon that is
+ * already gone.
+ *
+ * @param socketPath - The daemon socket path.
+ * @param pidPath - The daemon PID file path.
+ * @param log - Optional logging function for status messages.
+ * @returns True if the daemon was stopped (or was not running).
+ */
+export declare function stopDaemon(socketPath: string, pidPath: string, log?: (message: string) => void): Promise<boolean>;
+//# sourceMappingURL=stop-daemon.d.mts.map

package/dist/daemon/stop-daemon.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stop-daemon.d.mts","sourceRoot":"","sources":["../../src/daemon/stop-daemon.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,UAAU,CAC9B,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,GAC9B,OAAO,CAAC,OAAO,CAAC,CAiFlB"}

package/dist/daemon/{stop-daemon.js → stop-daemon.mjs}

@@ -1,6 +1,6 @@
-import { rm } from 'node:fs/promises';
-import { pingDaemon, sendCommand } from './daemon-client.js';
-import { isProcessAlive, readPidFile, sendSignal, waitFor } from './utils.js';
+import { rm } from "node:fs/promises";
+import { pingDaemon, sendCommand } from "./daemon-client.mjs";
+import { isProcessAlive, readPidFile, sendSignal, waitFor } from "./utils.mjs";
 /**
  * Stop the daemon, preferring a graceful shutdown.
  *
@@ -55,7 +55,7 @@ export async function stopDaemon(socketPath, pidPath, log) {
         // pid to be gone too, so a daemon that outlived its socket falls through to
         // SIGTERM/SIGKILL rather than being orphaned.
         stopped = await waitFor(async () => (await pingDaemon(socketPath)).status !== 'responsive' &&
-            (pid === undefined || !isProcessAlive(pid)), 5_000);
+            (pid === undefined || !isProcessAlive(pid)), 5000);
     }
     // Strategy 2: SIGTERM. Signal when either the socket was observed or the
     // recorded PID is alive; the absent+alive case typically means someone
@@ -66,7 +66,7 @@ export async function stopDaemon(socketPath, pidPath, log) {
         }
         try {
             if (sendSignal(pid, 'SIGTERM')) {
-                stopped = await waitFor(() => !isProcessAlive(pid), 5_000);
+                stopped = await waitFor(() => !isProcessAlive(pid), 5000);
             }
             else {
                 stopped = true; // Process already gone (ESRCH).
@@ -80,7 +80,7 @@ export async function stopDaemon(socketPath, pidPath, log) {
     if (!stopped && processAlive && pid !== undefined) {
         try {
             if (sendSignal(pid, 'SIGKILL')) {
-                stopped = await waitFor(() => !isProcessAlive(pid), 2_000);
+                stopped = await waitFor(() => !isProcessAlive(pid), 2000);
             }
             else {
                 stopped = true; // Process already gone (ESRCH).
@@ -110,4 +110,4 @@ async function cleanupFile(path, label, log) {
         log?.(`Failed to remove ${label}: ${String(error)}`);
     });
 }
-//# sourceMappingURL=stop-daemon.js.map
+//# sourceMappingURL=stop-daemon.mjs.map

package/dist/daemon/stop-daemon.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stop-daemon.mjs","sourceRoot":"","sources":["../../src/daemon/stop-daemon.ts"],"names":[],"mappings":"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","sourcesContent":["import { rm } from 'node:fs/promises';\n\nimport { pingDaemon, sendCommand } from './daemon-client.js';\nimport { isProcessAlive, readPidFile, sendSignal, waitFor } from './utils.js';\n\n/**\n * Stop the daemon, preferring a graceful shutdown.\n *\n * Resolution order when a live daemon is present:\n * 1. If the socket is responsive, request a graceful `shutdown` over it.\n * 2. If the recorded PID is still alive, escalate to SIGTERM.\n * 3. ...then SIGKILL.\n *\n * Signals (steps 2-3) are only ever sent against a PID that is observed alive.\n * The socket-absent + alive-PID branch trades a small risk of signalling a\n * recycled PID for the larger risk of leaving an orphan daemon holding the\n * SQLite database — which `daemon purge` would otherwise wipe out from under\n * it.\n *\n * When the socket is NOT responsive AND the recorded PID is dead (or there is\n * no PID file), there is no live daemon: a lingering socket or PID file is\n * stale leftovers from a daemon that already exited — typically one that\n * crashed without running its own cleanup. Those files are removed and the\n * stop is reported as successful, rather than failing on a daemon that is\n * already gone.\n *\n * @param socketPath - The daemon socket path.\n * @param pidPath - The daemon PID file path.\n * @param log - Optional logging function for status messages.\n * @returns True if the daemon was stopped (or was not running).\n */\nexport async function stopDaemon(\n  socketPath: string,\n  pidPath: string,\n  log?: (message: string) => void,\n): Promise<boolean> {\n  const pid = await readPidFile(pidPath);\n  const ping = await pingDaemon(socketPath);\n  const socketObserved =\n    ping.status === 'responsive' || ping.status === 'unreachable';\n  const processAlive = pid !== undefined && isProcessAlive(pid);\n\n  // Only `absent` and `refused` prove no live daemon; `permission`/`timeout`/\n  // `protocol` may be a wedged or foreign daemon, so those fall through.\n  const socketProvenGone =\n    ping.status === 'absent' ||\n    (ping.status === 'unreachable' && ping.reason === 'refused');\n\n  if (socketProvenGone && !processAlive) {\n    await cleanupFile(pidPath, 'PID file', log);\n    await cleanupFile(socketPath, 'socket file', log);\n    return true;\n  }\n\n  log?.('Stopping daemon...');\n\n  let stopped = false;\n\n  // Strategy 1: Graceful socket-based shutdown.\n  if (ping.status === 'responsive') {\n    try {\n      await sendCommand({ socketPath, method: 'shutdown' });\n    } catch (error) {\n      log?.(`Graceful shutdown request failed: ${String(error)}`);\n    }\n    // A quiet socket does not prove the process exited; require the recorded\n    // pid to be gone too, so a daemon that outlived its socket falls through to\n    // SIGTERM/SIGKILL rather than being orphaned.\n    stopped = await waitFor(\n      async () =>\n        (await pingDaemon(socketPath)).status !== 'responsive' &&\n        (pid === undefined || !isProcessAlive(pid)),\n      5_000,\n    );\n  }\n\n  // Strategy 2: SIGTERM. Signal when either the socket was observed or the\n  // recorded PID is alive; the absent+alive case typically means someone\n  // removed the socket from under a live daemon.\n  if (!stopped && processAlive && pid !== undefined) {\n    if (!socketObserved) {\n      log?.(\n        `Socket at ${socketPath} is absent but recorded pid ${pid} is alive; signalling anyway.`,\n      );\n    }\n    try {\n      if (sendSignal(pid, 'SIGTERM')) {\n        stopped = await waitFor(() => !isProcessAlive(pid), 5_000);\n      } else {\n        stopped = true; // Process already gone (ESRCH).\n      }\n    } catch (error) {\n      log?.(`SIGTERM failed: ${String(error)}`);\n    }\n  }\n\n  // Strategy 3: SIGKILL.\n  if (!stopped && processAlive && pid !== undefined) {\n    try {\n      if (sendSignal(pid, 'SIGKILL')) {\n        stopped = await waitFor(() => !isProcessAlive(pid), 2_000);\n      } else {\n        stopped = true; // Process already gone (ESRCH).\n      }\n    } catch (error) {\n      log?.(`SIGKILL failed: ${String(error)}`);\n    }\n  }\n\n  if (stopped) {\n    await cleanupFile(pidPath, 'PID file', log);\n    await cleanupFile(socketPath, 'socket file', log);\n    log?.('Daemon stopped.');\n  }\n\n  return stopped;\n}\n\n/**\n * Remove a file best-effort, logging any failure rather than letting it\n * propagate. ENOENT is silently ignored via `force: true`.\n *\n * @param path - The file path to remove.\n * @param label - Human-readable label for log messages.\n * @param log - Optional log sink.\n */\nasync function cleanupFile(\n  path: string,\n  label: string,\n  log: ((message: string) => void) | undefined,\n): Promise<void> {\n  await rm(path, { force: true }).catch((error: unknown) => {\n    log?.(`Failed to remove ${label}: ${String(error)}`);\n  });\n}\n"]}

package/dist/daemon/types.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineHandler = void 0;
+/**
+ * Bundle a params struct with the handler that runs once `params` is
+ * validated. The server invokes `run` only after `paramsStruct` accepts the
+ * value, so `run` can trust the type of its argument.
+ *
+ * The returned definition erases `TParams` to `unknown` so heterogeneous
+ * handlers can share an {@link RpcHandlerMap}.
+ *
+ * @param paramsStruct - Struct that validates `params` for this method.
+ * @param run - Handler invoked with the validated params.
+ * @returns An {@link RpcHandlerDefinition} suitable for an {@link RpcHandlerMap}.
+ */
+function defineHandler(paramsStruct, run) {
+    return { paramsStruct, run };
+}
+exports.defineHandler = defineHandler;
+//# sourceMappingURL=types.cjs.map

package/dist/daemon/types.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.cjs","sourceRoot":"","sources":["../../src/daemon/types.ts"],"names":[],"mappings":";;;AAiDA;;;;;;;;;;;GAWG;AACH,SAAgB,aAAa,CAC3B,YAA6B,EAC7B,GAAiC;IAEjC,OAAO,EAAE,YAAY,EAAE,GAAG,EAGzB,CAAC;AACJ,CAAC;AARD,sCAQC","sourcesContent":["import type { Struct } from '@metamask/superstruct';\nimport type { Json } from '@metamask/utils';\n\nimport type { Password, Srp } from './secrets.js';\n\n/**\n * Sink for daemon diagnostic messages. A backgrounded daemon's stdio may be\n * discarded, so hosts supply a logger that writes somewhere durable.\n */\nexport type Logger = (message: string) => void;\n\n/**\n * A function that handles a JSON-RPC method call after its params have been\n * validated by the corresponding {@link RpcHandlerDefinition.paramsStruct}.\n */\nexport type RpcHandler<TParams, TResult> = (\n  params: TParams,\n) => Promise<TResult>;\n\n/**\n * Definition for a single JSON-RPC method: the struct that validates\n * incoming `params` plus the handler that runs once `params` is known to\n * match.\n *\n * The server (see `rpc-socket-server.ts`) validates the raw `params` against\n * `paramsStruct` before invoking `run`, so each handler body can trust the\n * shape of its input without re-checking.\n */\nexport type RpcHandlerDefinition<TParams, TResult extends Json | void> = {\n  paramsStruct: Struct<TParams>;\n  run: RpcHandler<TParams, TResult>;\n};\n\n/**\n * A map of RPC method names to their handler definitions.\n *\n * `TParams` is erased to `unknown` here so definitions with different narrow\n * params types (e.g. `null` vs. a tuple) can coexist in the same map. Consumers\n * therefore see each `run` as accepting `unknown` and must validate `params`\n * against the paired `paramsStruct` before invoking it — which is exactly what\n * the server (see `rpc-socket-server.ts`) does. The concrete `TParams` is\n * captured inside {@link defineHandler}, where the struct and handler are bound\n * together.\n */\nexport type RpcHandlerMap = Record<\n  string,\n  RpcHandlerDefinition<unknown, Json | void>\n>;\n\n/**\n * Bundle a params struct with the handler that runs once `params` is\n * validated. The server invokes `run` only after `paramsStruct` accepts the\n * value, so `run` can trust the type of its argument.\n *\n * The returned definition erases `TParams` to `unknown` so heterogeneous\n * handlers can share an {@link RpcHandlerMap}.\n *\n * @param paramsStruct - Struct that validates `params` for this method.\n * @param run - Handler invoked with the validated params.\n * @returns An {@link RpcHandlerDefinition} suitable for an {@link RpcHandlerMap}.\n */\nexport function defineHandler<TParams, TResult extends Json | void>(\n  paramsStruct: Struct<TParams>,\n  run: RpcHandler<TParams, TResult>,\n): RpcHandlerDefinition<unknown, TResult> {\n  return { paramsStruct, run } as unknown as RpcHandlerDefinition<\n    unknown,\n    TResult\n  >;\n}\n\n/**\n * Typed wrapper around `wallet.messenger.call` used by the `call` RPC.\n *\n * The messenger is strongly typed by action name; the daemon exposes the full\n * messenger surface over the socket and dispatches by string, so we consolidate\n * the unsafe cast into a single, documented escape hatch instead of repeating\n * it at each call site.\n */\nexport type RpcDispatcher = (action: string, ...args: Json[]) => Promise<Json>;\n\n/**\n * Resolved paths for daemon state files.\n */\nexport type DaemonPaths = {\n  socketPath: string;\n  pidPath: string;\n  logPath: string;\n  dbPath: string;\n};\n\n/**\n * Status information returned by the daemon's `getStatus` RPC method.\n */\nexport type DaemonStatusInfo = {\n  pid: number;\n  uptime: number;\n};\n\n/**\n * Configuration passed to the daemon spawner.\n *\n * `password` is optional: when omitted, the daemon starts without unlocking\n * the keyring, and the caller is expected to use `mm wallet unlock` before\n * any keyring-bound operation. First-run startup still requires both\n * `password` and `srp`; without `password`, the daemon will exit during\n * startup with a clear error. `srp` is always required by the type and\n * forwarded to the daemon; it is only consumed on first run.\n */\nexport type DaemonSpawnConfig = {\n  dataDir: string;\n  infuraProjectId: string;\n  password?: Password;\n  srp: Srp;\n  packageRoot: string;\n};\n"]}

package/dist/daemon/{types.d.ts → types.d.cts}

@@ -1,6 +1,6 @@
-import type { Struct } from '@metamask/superstruct';
-import type { Json } from '@metamask/utils';
-import type { Password, Srp } from './secrets.js';
+import type { Struct } from "@metamask/superstruct";
+import type { Json } from "@metamask/utils";
+import type { Password, Srp } from "./secrets.cjs";
 /**
  * Sink for daemon diagnostic messages. A backgrounded daemon's stdio may be
  * discarded, so hosts supply a logger that writes somewhere durable.
@@ -91,4 +91,4 @@ export type DaemonSpawnConfig = {
     srp: Srp;
     packageRoot: string;
 };
-//# sourceMappingURL=types.d.ts.map
+//# sourceMappingURL=types.d.cts.map

package/dist/daemon/types.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.cts","sourceRoot":"","sources":["../../src/daemon/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,8BAA8B;AACpD,OAAO,KAAK,EAAE,IAAI,EAAE,wBAAwB;AAE5C,OAAO,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,sBAAqB;AAElD;;;GAGG;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;AAE/C;;;GAGG;AACH,MAAM,MAAM,UAAU,CAAC,OAAO,EAAE,OAAO,IAAI,CACzC,MAAM,EAAE,OAAO,KACZ,OAAO,CAAC,OAAO,CAAC,CAAC;AAEtB;;;;;;;;GAQG;AACH,MAAM,MAAM,oBAAoB,CAAC,OAAO,EAAE,OAAO,SAAS,IAAI,GAAG,IAAI,IAAI;IACvE,YAAY,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;IAC9B,GAAG,EAAE,UAAU,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;CACnC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAChC,MAAM,EACN,oBAAoB,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI,CAAC,CAC3C,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,SAAS,IAAI,GAAG,IAAI,EAChE,YAAY,EAAE,MAAM,CAAC,OAAO,CAAC,EAC7B,GAAG,EAAE,UAAU,CAAC,OAAO,EAAE,OAAO,CAAC,GAChC,oBAAoB,CAAC,OAAO,EAAE,OAAO,CAAC,CAKxC;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAE/E;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,GAAG,EAAE,GAAG,CAAC;IACT,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC"}

package/dist/daemon/types.d.mts

@@ -0,0 +1,94 @@
+import type { Struct } from "@metamask/superstruct";
+import type { Json } from "@metamask/utils";
+import type { Password, Srp } from "./secrets.mjs";
+/**
+ * Sink for daemon diagnostic messages. A backgrounded daemon's stdio may be
+ * discarded, so hosts supply a logger that writes somewhere durable.
+ */
+export type Logger = (message: string) => void;
+/**
+ * A function that handles a JSON-RPC method call after its params have been
+ * validated by the corresponding {@link RpcHandlerDefinition.paramsStruct}.
+ */
+export type RpcHandler<TParams, TResult> = (params: TParams) => Promise<TResult>;
+/**
+ * Definition for a single JSON-RPC method: the struct that validates
+ * incoming `params` plus the handler that runs once `params` is known to
+ * match.
+ *
+ * The server (see `rpc-socket-server.ts`) validates the raw `params` against
+ * `paramsStruct` before invoking `run`, so each handler body can trust the
+ * shape of its input without re-checking.
+ */
+export type RpcHandlerDefinition<TParams, TResult extends Json | void> = {
+    paramsStruct: Struct<TParams>;
+    run: RpcHandler<TParams, TResult>;
+};
+/**
+ * A map of RPC method names to their handler definitions.
+ *
+ * `TParams` is erased to `unknown` here so definitions with different narrow
+ * params types (e.g. `null` vs. a tuple) can coexist in the same map. Consumers
+ * therefore see each `run` as accepting `unknown` and must validate `params`
+ * against the paired `paramsStruct` before invoking it — which is exactly what
+ * the server (see `rpc-socket-server.ts`) does. The concrete `TParams` is
+ * captured inside {@link defineHandler}, where the struct and handler are bound
+ * together.
+ */
+export type RpcHandlerMap = Record<string, RpcHandlerDefinition<unknown, Json | void>>;
+/**
+ * Bundle a params struct with the handler that runs once `params` is
+ * validated. The server invokes `run` only after `paramsStruct` accepts the
+ * value, so `run` can trust the type of its argument.
+ *
+ * The returned definition erases `TParams` to `unknown` so heterogeneous
+ * handlers can share an {@link RpcHandlerMap}.
+ *
+ * @param paramsStruct - Struct that validates `params` for this method.
+ * @param run - Handler invoked with the validated params.
+ * @returns An {@link RpcHandlerDefinition} suitable for an {@link RpcHandlerMap}.
+ */
+export declare function defineHandler<TParams, TResult extends Json | void>(paramsStruct: Struct<TParams>, run: RpcHandler<TParams, TResult>): RpcHandlerDefinition<unknown, TResult>;
+/**
+ * Typed wrapper around `wallet.messenger.call` used by the `call` RPC.
+ *
+ * The messenger is strongly typed by action name; the daemon exposes the full
+ * messenger surface over the socket and dispatches by string, so we consolidate
+ * the unsafe cast into a single, documented escape hatch instead of repeating
+ * it at each call site.
+ */
+export type RpcDispatcher = (action: string, ...args: Json[]) => Promise<Json>;
+/**
+ * Resolved paths for daemon state files.
+ */
+export type DaemonPaths = {
+    socketPath: string;
+    pidPath: string;
+    logPath: string;
+    dbPath: string;
+};
+/**
+ * Status information returned by the daemon's `getStatus` RPC method.
+ */
+export type DaemonStatusInfo = {
+    pid: number;
+    uptime: number;
+};
+/**
+ * Configuration passed to the daemon spawner.
+ *
+ * `password` is optional: when omitted, the daemon starts without unlocking
+ * the keyring, and the caller is expected to use `mm wallet unlock` before
+ * any keyring-bound operation. First-run startup still requires both
+ * `password` and `srp`; without `password`, the daemon will exit during
+ * startup with a clear error. `srp` is always required by the type and
+ * forwarded to the daemon; it is only consumed on first run.
+ */
+export type DaemonSpawnConfig = {
+    dataDir: string;
+    infuraProjectId: string;
+    password?: Password;
+    srp: Srp;
+    packageRoot: string;
+};
+//# sourceMappingURL=types.d.mts.map

package/dist/daemon/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","sourceRoot":"","sources":["../../src/daemon/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,8BAA8B;AACpD,OAAO,KAAK,EAAE,IAAI,EAAE,wBAAwB;AAE5C,OAAO,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,sBAAqB;AAElD;;;GAGG;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;AAE/C;;;GAGG;AACH,MAAM,MAAM,UAAU,CAAC,OAAO,EAAE,OAAO,IAAI,CACzC,MAAM,EAAE,OAAO,KACZ,OAAO,CAAC,OAAO,CAAC,CAAC;AAEtB;;;;;;;;GAQG;AACH,MAAM,MAAM,oBAAoB,CAAC,OAAO,EAAE,OAAO,SAAS,IAAI,GAAG,IAAI,IAAI;IACvE,YAAY,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC;IAC9B,GAAG,EAAE,UAAU,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;CACnC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,CAChC,MAAM,EACN,oBAAoB,CAAC,OAAO,EAAE,IAAI,GAAG,IAAI,CAAC,CAC3C,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,SAAS,IAAI,GAAG,IAAI,EAChE,YAAY,EAAE,MAAM,CAAC,OAAO,CAAC,EAC7B,GAAG,EAAE,UAAU,CAAC,OAAO,EAAE,OAAO,CAAC,GAChC,oBAAoB,CAAC,OAAO,EAAE,OAAO,CAAC,CAKxC;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;AAE/E;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,GAAG,EAAE,GAAG,CAAC;IACT,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC"}

package/dist/daemon/{types.js → types.mjs}

@@ -13,4 +13,4 @@
 export function defineHandler(paramsStruct, run) {
     return { paramsStruct, run };
 }
-//# sourceMappingURL=types.js.map
+//# sourceMappingURL=types.mjs.map

package/dist/daemon/types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.mjs","sourceRoot":"","sources":["../../src/daemon/types.ts"],"names":[],"mappings":"AAiDA;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,aAAa,CAC3B,YAA6B,EAC7B,GAAiC;IAEjC,OAAO,EAAE,YAAY,EAAE,GAAG,EAGzB,CAAC;AACJ,CAAC","sourcesContent":["import type { Struct } from '@metamask/superstruct';\nimport type { Json } from '@metamask/utils';\n\nimport type { Password, Srp } from './secrets.js';\n\n/**\n * Sink for daemon diagnostic messages. A backgrounded daemon's stdio may be\n * discarded, so hosts supply a logger that writes somewhere durable.\n */\nexport type Logger = (message: string) => void;\n\n/**\n * A function that handles a JSON-RPC method call after its params have been\n * validated by the corresponding {@link RpcHandlerDefinition.paramsStruct}.\n */\nexport type RpcHandler<TParams, TResult> = (\n  params: TParams,\n) => Promise<TResult>;\n\n/**\n * Definition for a single JSON-RPC method: the struct that validates\n * incoming `params` plus the handler that runs once `params` is known to\n * match.\n *\n * The server (see `rpc-socket-server.ts`) validates the raw `params` against\n * `paramsStruct` before invoking `run`, so each handler body can trust the\n * shape of its input without re-checking.\n */\nexport type RpcHandlerDefinition<TParams, TResult extends Json | void> = {\n  paramsStruct: Struct<TParams>;\n  run: RpcHandler<TParams, TResult>;\n};\n\n/**\n * A map of RPC method names to their handler definitions.\n *\n * `TParams` is erased to `unknown` here so definitions with different narrow\n * params types (e.g. `null` vs. a tuple) can coexist in the same map. Consumers\n * therefore see each `run` as accepting `unknown` and must validate `params`\n * against the paired `paramsStruct` before invoking it — which is exactly what\n * the server (see `rpc-socket-server.ts`) does. The concrete `TParams` is\n * captured inside {@link defineHandler}, where the struct and handler are bound\n * together.\n */\nexport type RpcHandlerMap = Record<\n  string,\n  RpcHandlerDefinition<unknown, Json | void>\n>;\n\n/**\n * Bundle a params struct with the handler that runs once `params` is\n * validated. The server invokes `run` only after `paramsStruct` accepts the\n * value, so `run` can trust the type of its argument.\n *\n * The returned definition erases `TParams` to `unknown` so heterogeneous\n * handlers can share an {@link RpcHandlerMap}.\n *\n * @param paramsStruct - Struct that validates `params` for this method.\n * @param run - Handler invoked with the validated params.\n * @returns An {@link RpcHandlerDefinition} suitable for an {@link RpcHandlerMap}.\n */\nexport function defineHandler<TParams, TResult extends Json | void>(\n  paramsStruct: Struct<TParams>,\n  run: RpcHandler<TParams, TResult>,\n): RpcHandlerDefinition<unknown, TResult> {\n  return { paramsStruct, run } as unknown as RpcHandlerDefinition<\n    unknown,\n    TResult\n  >;\n}\n\n/**\n * Typed wrapper around `wallet.messenger.call` used by the `call` RPC.\n *\n * The messenger is strongly typed by action name; the daemon exposes the full\n * messenger surface over the socket and dispatches by string, so we consolidate\n * the unsafe cast into a single, documented escape hatch instead of repeating\n * it at each call site.\n */\nexport type RpcDispatcher = (action: string, ...args: Json[]) => Promise<Json>;\n\n/**\n * Resolved paths for daemon state files.\n */\nexport type DaemonPaths = {\n  socketPath: string;\n  pidPath: string;\n  logPath: string;\n  dbPath: string;\n};\n\n/**\n * Status information returned by the daemon's `getStatus` RPC method.\n */\nexport type DaemonStatusInfo = {\n  pid: number;\n  uptime: number;\n};\n\n/**\n * Configuration passed to the daemon spawner.\n *\n * `password` is optional: when omitted, the daemon starts without unlocking\n * the keyring, and the caller is expected to use `mm wallet unlock` before\n * any keyring-bound operation. First-run startup still requires both\n * `password` and `srp`; without `password`, the daemon will exit during\n * startup with a clear error. `srp` is always required by the type and\n * forwarded to the daemon; it is only consumed on first run.\n */\nexport type DaemonSpawnConfig = {\n  dataDir: string;\n  infuraProjectId: string;\n  password?: Password;\n  srp: Srp;\n  packageRoot: string;\n};\n"]}

package/dist/daemon/utils.cjs

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitFor = exports.sendSignal = exports.isProcessAlive = exports.readPidFile = exports.isStringArray = exports.emptyToUndefined = exports.formatJsonRpcError = exports.makeDaemonConnectionError = exports.isErrorWithCode = void 0;
+const utils_1 = require("@metamask/utils");
+const promises_1 = require("node:fs/promises");
+/**
+ * Check whether an unknown error is a Node.js system error with the given code.
+ *
+ * @param error - The error to check.
+ * @param code - The expected error code (e.g. 'ENOENT', 'EPERM').
+ * @returns True if the error matches the code.
+ */
+function isErrorWithCode(error, code) {
+    return (0, utils_1.isErrorWithCode)(error) && error.code === code;
+}
+exports.isErrorWithCode = isErrorWithCode;
+/**
+ * Turn an error thrown while contacting the daemon socket into a user-facing
+ * message for `Command.error`, so every command reports the same failure the
+ * same way. Distinguishes a stopped daemon (`ENOENT`/`ECONNREFUSED`), a
+ * connection dropped mid-request (`ECONNRESET`), and a permission problem
+ * (`EACCES`/`EPERM`), falling back to the raw error message.
+ *
+ * @param error - The value thrown while contacting the daemon.
+ * @returns A human-readable explanation of the failure.
+ */
+function makeDaemonConnectionError(error) {
+    if (isErrorWithCode(error, 'ENOENT') ||
+        isErrorWithCode(error, 'ECONNREFUSED')) {
+        return 'Daemon is not running. Start it with `mm daemon start`.';
+    }
+    // A reset drops an already-established connection, so the daemon was running
+    // — most likely it crashed mid-request. Don't tell the user to start it.
+    if (isErrorWithCode(error, 'ECONNRESET')) {
+        return ('Lost the connection to the daemon; it may have crashed while ' +
+            'handling the request. Check `mm daemon status` and the daemon log.');
+    }
+    if (isErrorWithCode(error, 'EACCES') || isErrorWithCode(error, 'EPERM')) {
+        return ('Cannot connect to the daemon socket: permission denied. ' +
+            'The socket may be owned by another user, or MM_DAEMON_DATA_DIR ' +
+            'may point to a directory you cannot access.');
+    }
+    return error instanceof Error ? error.message : String(error);
+}
+exports.makeDaemonConnectionError = makeDaemonConnectionError;
+/**
+ * Format the error of a JSON-RPC failure response into a user-facing message
+ * for `Command.error`, so every command reports RPC failures the same way.
+ *
+ * @param error - The `error` field of a JSON-RPC failure response.
+ * @returns The error message annotated with its numeric code.
+ */
+function formatJsonRpcError(error) {
+    return `${error.message} (code ${String(error.code)})`;
+}
+exports.formatJsonRpcError = formatJsonRpcError;
+/**
+ * Treat an empty string the same as `undefined` — "no value supplied". Used
+ * to normalise `--password ''` and `MM_WALLET_PASSWORD=''` so they trigger
+ * the interactive prompt rather than sending an empty string to the keyring.
+ *
+ * @param value - The value to normalise.
+ * @returns `undefined` if `value` is `undefined` or `''`; `value` otherwise.
+ */
+function emptyToUndefined(value) {
+    return value === '' ? undefined : value;
+}
+exports.emptyToUndefined = emptyToUndefined;
+/**
+ * Check whether a value is an array of strings. Used to validate untyped RPC
+ * results (e.g. the daemon's `listActions`) before treating them as `string[]`.
+ *
+ * @param value - The value to check.
+ * @returns True if the value is an array whose every element is a string.
+ */
+function isStringArray(value) {
+    return (Array.isArray(value) && value.every((item) => typeof item === 'string'));
+}
+exports.isStringArray = isStringArray;
+/**
+ * Read a PID from a file. The file may contain just the PID, or the PID on
+ * the first line followed by additional metadata (e.g. start time written by
+ * the daemon).
+ *
+ * @param pidPath - The PID file path.
+ * @returns The PID, or undefined if the file is missing or its first line is
+ * not a positive integer.
+ */
+async function readPidFile(pidPath) {
+    let contents;
+    try {
+        contents = await (0, promises_1.readFile)(pidPath, 'utf-8');
+    }
+    catch (error) {
+        if (isErrorWithCode(error, 'ENOENT')) {
+            return undefined;
+        }
+        throw error;
+    }
+    // String.prototype.split always returns at least one element, so [0] is safe.
+    const pid = Number(contents.split('\n')[0].trim());
+    return Number.isInteger(pid) && pid > 0 ? pid : undefined;
+}
+exports.readPidFile = readPidFile;
+/**
+ * Check whether a process is alive by sending signal 0.
+ *
+ * Treats `ESRCH` as "process is gone", `EPERM` as "process exists but we
+ * cannot signal it" (still alive from our perspective), and rethrows
+ * anything else so the caller can surface unexpected failures rather than
+ * silently assuming the process is dead.
+ *
+ * @param pid - The process ID to check.
+ * @returns True if the process exists.
+ */
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (isErrorWithCode(error, 'ESRCH')) {
+            return false;
+        }
+        if (isErrorWithCode(error, 'EPERM')) {
+            return true;
+        }
+        throw error;
+    }
+}
+exports.isProcessAlive = isProcessAlive;
+/**
+ * Send a signal to a process. Returns true if the signal was sent, false if
+ * the process does not exist (ESRCH). Re-throws on permission errors and
+ * other failures.
+ *
+ * @param pid - The process ID.
+ * @param signal - The signal to send.
+ * @returns True if the signal was delivered, false if the process is gone.
+ */
+function sendSignal(pid, signal) {
+    try {
+        process.kill(pid, signal);
+        return true;
+    }
+    catch (error) {
+        if (isErrorWithCode(error, 'ESRCH')) {
+            return false;
+        }
+        throw error;
+    }
+}
+exports.sendSignal = sendSignal;
+/**
+ * Poll until a condition is met or the timeout elapses.
+ *
+ * @param check - A function that returns true when the condition is met.
+ * @param timeoutMs - Maximum time to wait in milliseconds.
+ * @returns True if the condition was met, false on timeout.
+ */
+async function waitFor(check, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (await check()) {
+            return true;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 250));
+    }
+    return false;
+}
+exports.waitFor = waitFor;
+//# sourceMappingURL=utils.cjs.map

package/dist/daemon/utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.cjs","sourceRoot":"","sources":["../../src/daemon/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import type { JsonRpcError } from '@metamask/utils';\nimport { isErrorWithCode as hasErrorCode } from '@metamask/utils';\nimport { readFile } from 'node:fs/promises';\n\n/**\n * Check whether an unknown error is a Node.js system error with the given code.\n *\n * @param error - The error to check.\n * @param code - The expected error code (e.g. 'ENOENT', 'EPERM').\n * @returns True if the error matches the code.\n */\nexport function isErrorWithCode(error: unknown, code: string): boolean {\n  return hasErrorCode(error) && error.code === code;\n}\n\n/**\n * Turn an error thrown while contacting the daemon socket into a user-facing\n * message for `Command.error`, so every command reports the same failure the\n * same way. Distinguishes a stopped daemon (`ENOENT`/`ECONNREFUSED`), a\n * connection dropped mid-request (`ECONNRESET`), and a permission problem\n * (`EACCES`/`EPERM`), falling back to the raw error message.\n *\n * @param error - The value thrown while contacting the daemon.\n * @returns A human-readable explanation of the failure.\n */\nexport function makeDaemonConnectionError(error: unknown): string {\n  if (\n    isErrorWithCode(error, 'ENOENT') ||\n    isErrorWithCode(error, 'ECONNREFUSED')\n  ) {\n    return 'Daemon is not running. Start it with `mm daemon start`.';\n  }\n  // A reset drops an already-established connection, so the daemon was running\n  // — most likely it crashed mid-request. Don't tell the user to start it.\n  if (isErrorWithCode(error, 'ECONNRESET')) {\n    return (\n      'Lost the connection to the daemon; it may have crashed while ' +\n      'handling the request. Check `mm daemon status` and the daemon log.'\n    );\n  }\n  if (isErrorWithCode(error, 'EACCES') || isErrorWithCode(error, 'EPERM')) {\n    return (\n      'Cannot connect to the daemon socket: permission denied. ' +\n      'The socket may be owned by another user, or MM_DAEMON_DATA_DIR ' +\n      'may point to a directory you cannot access.'\n    );\n  }\n  return error instanceof Error ? error.message : String(error);\n}\n\n/**\n * Format the error of a JSON-RPC failure response into a user-facing message\n * for `Command.error`, so every command reports RPC failures the same way.\n *\n * @param error - The `error` field of a JSON-RPC failure response.\n * @returns The error message annotated with its numeric code.\n */\nexport function formatJsonRpcError(error: JsonRpcError): string {\n  return `${error.message} (code ${String(error.code)})`;\n}\n\n/**\n * Treat an empty string the same as `undefined` — \"no value supplied\". Used\n * to normalise `--password ''` and `MM_WALLET_PASSWORD=''` so they trigger\n * the interactive prompt rather than sending an empty string to the keyring.\n *\n * @param value - The value to normalise.\n * @returns `undefined` if `value` is `undefined` or `''`; `value` otherwise.\n */\nexport function emptyToUndefined(\n  value: string | undefined,\n): string | undefined {\n  return value === '' ? undefined : value;\n}\n\n/**\n * Check whether a value is an array of strings. Used to validate untyped RPC\n * results (e.g. the daemon's `listActions`) before treating them as `string[]`.\n *\n * @param value - The value to check.\n * @returns True if the value is an array whose every element is a string.\n */\nexport function isStringArray(value: unknown): value is string[] {\n  return (\n    Array.isArray(value) && value.every((item) => typeof item === 'string')\n  );\n}\n\n/**\n * Read a PID from a file. The file may contain just the PID, or the PID on\n * the first line followed by additional metadata (e.g. start time written by\n * the daemon).\n *\n * @param pidPath - The PID file path.\n * @returns The PID, or undefined if the file is missing or its first line is\n * not a positive integer.\n */\nexport async function readPidFile(\n  pidPath: string,\n): Promise<number | undefined> {\n  let contents: string;\n  try {\n    contents = await readFile(pidPath, 'utf-8');\n  } catch (error: unknown) {\n    if (isErrorWithCode(error, 'ENOENT')) {\n      return undefined;\n    }\n    throw error;\n  }\n  // String.prototype.split always returns at least one element, so [0] is safe.\n  const pid = Number(contents.split('\\n')[0].trim());\n  return Number.isInteger(pid) && pid > 0 ? pid : undefined;\n}\n\n/**\n * Check whether a process is alive by sending signal 0.\n *\n * Treats `ESRCH` as \"process is gone\", `EPERM` as \"process exists but we\n * cannot signal it\" (still alive from our perspective), and rethrows\n * anything else so the caller can surface unexpected failures rather than\n * silently assuming the process is dead.\n *\n * @param pid - The process ID to check.\n * @returns True if the process exists.\n */\nexport function isProcessAlive(pid: number): boolean {\n  try {\n    process.kill(pid, 0);\n    return true;\n  } catch (error: unknown) {\n    if (isErrorWithCode(error, 'ESRCH')) {\n      return false;\n    }\n    if (isErrorWithCode(error, 'EPERM')) {\n      return true;\n    }\n    throw error;\n  }\n}\n\n/**\n * Send a signal to a process. Returns true if the signal was sent, false if\n * the process does not exist (ESRCH). Re-throws on permission errors and\n * other failures.\n *\n * @param pid - The process ID.\n * @param signal - The signal to send.\n * @returns True if the signal was delivered, false if the process is gone.\n */\nexport function sendSignal(pid: number, signal: NodeJS.Signals): boolean {\n  try {\n    process.kill(pid, signal);\n    return true;\n  } catch (error: unknown) {\n    if (isErrorWithCode(error, 'ESRCH')) {\n      return false;\n    }\n    throw error;\n  }\n}\n\n/**\n * Poll until a condition is met or the timeout elapses.\n *\n * @param check - A function that returns true when the condition is met.\n * @param timeoutMs - Maximum time to wait in milliseconds.\n * @returns True if the condition was met, false on timeout.\n */\nexport async function waitFor(\n  check: () => boolean | Promise<boolean>,\n  timeoutMs: number,\n): Promise<boolean> {\n  const deadline = Date.now() + timeoutMs;\n  while (Date.now() < deadline) {\n    if (await check()) {\n      return true;\n    }\n    await new Promise((resolve) => setTimeout(resolve, 250));\n  }\n  return false;\n}\n"]}

package/dist/daemon/{utils.d.ts → utils.d.cts}

@@ -1,4 +1,5 @@
-import type { JsonRpcError } from '@metamask/utils';
+/// <reference types="node" />
+import type { JsonRpcError } from "@metamask/utils";
 /**
  * Check whether an unknown error is a Node.js system error with the given code.
  *
@@ -83,4 +84,4 @@ export declare function sendSignal(pid: number, signal: NodeJS.Signals): boolean
  * @returns True if the condition was met, false on timeout.
  */
 export declare function waitFor(check: () => boolean | Promise<boolean>, timeoutMs: number): Promise<boolean>;
-//# sourceMappingURL=utils.d.ts.map
+//# sourceMappingURL=utils.d.cts.map

package/dist/daemon/utils.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.cts","sourceRoot":"","sources":["../../src/daemon/utils.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,wBAAwB;AAIpD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAErE;AAED;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAuBhE;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAE9D;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,GAAG,SAAS,GACxB,MAAM,GAAG,SAAS,CAEpB;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,EAAE,CAI/D;AAED;;;;;;;;GAQG;AACH,wBAAsB,WAAW,CAC/B,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAa7B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAanD;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,OAAO,CAUvE;AAED;;;;;;GAMG;AACH,wBAAsB,OAAO,CAC3B,KAAK,EAAE,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,EACvC,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,OAAO,CAAC,CASlB"}