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

package/dist/daemon/socket-line.cjs

@@ -1,93 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readLine = exports.writeLine = void 0;
-/**
- * Write a newline-delimited line to a socket.
- *
- * @param socket - The socket to write to.
- * @param line - The line to write (without trailing newline).
- */
-async function writeLine(socket, line) {
-    return new Promise((resolve, reject) => {
-        // A socket 'error' can fire while the write is in flight without ever
-        // reaching the write callback; without this listener Node would treat it
-        // as an unhandled 'error' event and crash the process.
-        const onError = (error) => {
-            socket.removeListener('error', onError);
-            reject(error);
-        };
-        socket.once('error', onError);
-        socket.write(`${line}\n`, (error) => {
-            if (error) {
-                // A failed write (e.g. EPIPE) is delivered BOTH here AND as a later
-                // 'error' event. Leave `onError` attached to handle that event —
-                // detaching here would let Node treat it as unhandled and crash the
-                // process. This reject settles the promise; `onError` detaches itself
-                // when/if the event arrives.
-                reject(error);
-                return;
-            }
-            socket.removeListener('error', onError);
-            resolve();
-        });
-    });
-}
-exports.writeLine = writeLine;
-/**
- * Read a single newline-delimited line from a socket.
- *
- * @param socket - The socket to read from.
- * @param timeoutMs - Optional timeout in milliseconds. Rejects with a timeout
- * error if no complete line is received within the limit.
- * @returns The line read (without trailing newline).
- */
-async function readLine(socket, timeoutMs) {
-    return new Promise((resolve, reject) => {
-        let buffer = '';
-        let timer;
-        if (timeoutMs !== undefined) {
-            timer = setTimeout(() => {
-                cleanup();
-                reject(new Error('Socket read timed out'));
-            }, timeoutMs);
-        }
-        const onData = (data) => {
-            buffer += data.toString();
-            const idx = buffer.indexOf('\n');
-            if (idx !== -1) {
-                cleanup();
-                resolve(buffer.slice(0, idx));
-            }
-        };
-        const onError = (error) => {
-            cleanup();
-            reject(error);
-        };
-        const onEnd = () => {
-            cleanup();
-            reject(new Error('Socket closed before response received'));
-        };
-        const onClose = () => {
-            cleanup();
-            reject(new Error('Socket closed before response received'));
-        };
-        /**
-         * Remove listeners registered by this call and clear the timeout.
-         */
-        function cleanup() {
-            if (timer !== undefined) {
-                clearTimeout(timer);
-            }
-            socket.removeListener('data', onData);
-            socket.removeListener('error', onError);
-            socket.removeListener('end', onEnd);
-            socket.removeListener('close', onClose);
-        }
-        socket.on('data', onData);
-        socket.once('error', onError);
-        socket.once('end', onEnd);
-        socket.once('close', onClose);
-    });
-}
-exports.readLine = readLine;
-//# sourceMappingURL=socket-line.cjs.map

package/dist/daemon/socket-line.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"socket-line.cjs","sourceRoot":"","sources":["../../src/daemon/socket-line.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Socket } from 'node:net';\n\n/**\n * Write a newline-delimited line to a socket.\n *\n * @param socket - The socket to write to.\n * @param line - The line to write (without trailing newline).\n */\nexport async function writeLine(socket: Socket, line: string): Promise<void> {\n  return new Promise((resolve, reject) => {\n    // A socket 'error' can fire while the write is in flight without ever\n    // reaching the write callback; without this listener Node would treat it\n    // as an unhandled 'error' event and crash the process.\n    const onError = (error: Error): void => {\n      socket.removeListener('error', onError);\n      reject(error);\n    };\n    socket.once('error', onError);\n\n    socket.write(`${line}\\n`, (error) => {\n      if (error) {\n        // A failed write (e.g. EPIPE) is delivered BOTH here AND as a later\n        // 'error' event. Leave `onError` attached to handle that event —\n        // detaching here would let Node treat it as unhandled and crash the\n        // process. This reject settles the promise; `onError` detaches itself\n        // when/if the event arrives.\n        reject(error);\n        return;\n      }\n      socket.removeListener('error', onError);\n      resolve();\n    });\n  });\n}\n\n/**\n * Read a single newline-delimited line from a socket.\n *\n * @param socket - The socket to read from.\n * @param timeoutMs - Optional timeout in milliseconds. Rejects with a timeout\n * error if no complete line is received within the limit.\n * @returns The line read (without trailing newline).\n */\nexport async function readLine(\n  socket: Socket,\n  timeoutMs?: number,\n): Promise<string> {\n  return new Promise((resolve, reject) => {\n    let buffer = '';\n    let timer: ReturnType<typeof setTimeout> | undefined;\n\n    if (timeoutMs !== undefined) {\n      timer = setTimeout(() => {\n        cleanup();\n        reject(new Error('Socket read timed out'));\n      }, timeoutMs);\n    }\n\n    const onData = (data: Buffer): void => {\n      buffer += data.toString();\n      const idx = buffer.indexOf('\\n');\n      if (idx !== -1) {\n        cleanup();\n        resolve(buffer.slice(0, idx));\n      }\n    };\n\n    const onError = (error: Error): void => {\n      cleanup();\n      reject(error);\n    };\n\n    const onEnd = (): void => {\n      cleanup();\n      reject(new Error('Socket closed before response received'));\n    };\n\n    const onClose = (): void => {\n      cleanup();\n      reject(new Error('Socket closed before response received'));\n    };\n\n    /**\n     * Remove listeners registered by this call and clear the timeout.\n     */\n    function cleanup(): void {\n      if (timer !== undefined) {\n        clearTimeout(timer);\n      }\n      socket.removeListener('data', onData);\n      socket.removeListener('error', onError);\n      socket.removeListener('end', onEnd);\n      socket.removeListener('close', onClose);\n    }\n\n    socket.on('data', onData);\n    socket.once('error', onError);\n    socket.once('end', onEnd);\n    socket.once('close', onClose);\n  });\n}\n"]}

package/dist/daemon/socket-line.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"socket-line.d.cts","sourceRoot":"","sources":["../../src/daemon/socket-line.ts"],"names":[],"mappings":";;;AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,iBAAiB;AAEvC;;;;;GAKG;AACH,wBAAsB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAyB3E;AAED;;;;;;;GAOG;AACH,wBAAsB,QAAQ,CAC5B,MAAM,EAAE,MAAM,EACd,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,CAAC,CAsDjB"}

package/dist/daemon/socket-line.d.mts

@@ -1,21 +0,0 @@
-/// <reference types="node" />
-/// <reference types="node/net" />
-/// <reference types="npm-which/node_modules/@types/node/net" />
-import type { Socket } from "node:net";
-/**
- * Write a newline-delimited line to a socket.
- *
- * @param socket - The socket to write to.
- * @param line - The line to write (without trailing newline).
- */
-export declare function writeLine(socket: Socket, line: string): Promise<void>;
-/**
- * Read a single newline-delimited line from a socket.
- *
- * @param socket - The socket to read from.
- * @param timeoutMs - Optional timeout in milliseconds. Rejects with a timeout
- * error if no complete line is received within the limit.
- * @returns The line read (without trailing newline).
- */
-export declare function readLine(socket: Socket, timeoutMs?: number): Promise<string>;
-//# sourceMappingURL=socket-line.d.mts.map

package/dist/daemon/socket-line.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"socket-line.d.mts","sourceRoot":"","sources":["../../src/daemon/socket-line.ts"],"names":[],"mappings":";;;AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,iBAAiB;AAEvC;;;;;GAKG;AACH,wBAAsB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAyB3E;AAED;;;;;;;GAOG;AACH,wBAAsB,QAAQ,CAC5B,MAAM,EAAE,MAAM,EACd,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,CAAC,CAsDjB"}

package/dist/daemon/socket-line.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"socket-line.mjs","sourceRoot":"","sources":["../../src/daemon/socket-line.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Socket } from 'node:net';\n\n/**\n * Write a newline-delimited line to a socket.\n *\n * @param socket - The socket to write to.\n * @param line - The line to write (without trailing newline).\n */\nexport async function writeLine(socket: Socket, line: string): Promise<void> {\n  return new Promise((resolve, reject) => {\n    // A socket 'error' can fire while the write is in flight without ever\n    // reaching the write callback; without this listener Node would treat it\n    // as an unhandled 'error' event and crash the process.\n    const onError = (error: Error): void => {\n      socket.removeListener('error', onError);\n      reject(error);\n    };\n    socket.once('error', onError);\n\n    socket.write(`${line}\\n`, (error) => {\n      if (error) {\n        // A failed write (e.g. EPIPE) is delivered BOTH here AND as a later\n        // 'error' event. Leave `onError` attached to handle that event —\n        // detaching here would let Node treat it as unhandled and crash the\n        // process. This reject settles the promise; `onError` detaches itself\n        // when/if the event arrives.\n        reject(error);\n        return;\n      }\n      socket.removeListener('error', onError);\n      resolve();\n    });\n  });\n}\n\n/**\n * Read a single newline-delimited line from a socket.\n *\n * @param socket - The socket to read from.\n * @param timeoutMs - Optional timeout in milliseconds. Rejects with a timeout\n * error if no complete line is received within the limit.\n * @returns The line read (without trailing newline).\n */\nexport async function readLine(\n  socket: Socket,\n  timeoutMs?: number,\n): Promise<string> {\n  return new Promise((resolve, reject) => {\n    let buffer = '';\n    let timer: ReturnType<typeof setTimeout> | undefined;\n\n    if (timeoutMs !== undefined) {\n      timer = setTimeout(() => {\n        cleanup();\n        reject(new Error('Socket read timed out'));\n      }, timeoutMs);\n    }\n\n    const onData = (data: Buffer): void => {\n      buffer += data.toString();\n      const idx = buffer.indexOf('\\n');\n      if (idx !== -1) {\n        cleanup();\n        resolve(buffer.slice(0, idx));\n      }\n    };\n\n    const onError = (error: Error): void => {\n      cleanup();\n      reject(error);\n    };\n\n    const onEnd = (): void => {\n      cleanup();\n      reject(new Error('Socket closed before response received'));\n    };\n\n    const onClose = (): void => {\n      cleanup();\n      reject(new Error('Socket closed before response received'));\n    };\n\n    /**\n     * Remove listeners registered by this call and clear the timeout.\n     */\n    function cleanup(): void {\n      if (timer !== undefined) {\n        clearTimeout(timer);\n      }\n      socket.removeListener('data', onData);\n      socket.removeListener('error', onError);\n      socket.removeListener('end', onEnd);\n      socket.removeListener('close', onClose);\n    }\n\n    socket.on('data', onData);\n    socket.once('error', onError);\n    socket.once('end', onEnd);\n    socket.once('close', onClose);\n  });\n}\n"]}

package/dist/daemon/stop-daemon.cjs

@@ -1,117 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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.cts.map

@@ -1 +0,0 @@
-{"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

@@ -1,28 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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.mjs.map

@@ -1 +0,0 @@
-{"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

@@ -1,20 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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.cts.map

@@ -1 +0,0 @@
-{"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

@@ -1,94 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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.mjs.map

@@ -1 +0,0 @@
-{"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"]}