@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/cli/memory-cli.js

@@ -4,17 +4,18 @@ import os from "node:os";
 import path from "node:path";
 import { resolveDefaultAgentId } from "../agents/agent-scope.js";
 import { loadConfig } from "../config/config.js";
+import { resolveStateDir } from "../config/paths.js";
 import { resolveSessionTranscriptsDirForAgent } from "../config/sessions/paths.js";
 import { setVerbose } from "../globals.js";
-import { withProgress, withProgressTotals } from "./progress.js";
-import { formatErrorMessage, withManager } from "./cli-utils.js";
 import { getMemorySearchManager } from "../memory/index.js";
-import { listMemoryFiles } from "../memory/internal.js";
+import { listMemoryFiles, normalizeExtraMemoryPaths } from "../memory/internal.js";
 import { defaultRuntime } from "../runtime.js";
 import { formatDocsLink } from "../terminal/links.js";
 import { colorize, isRich, theme } from "../terminal/theme.js";
-import { resolveStateDir } from "../config/paths.js";
 import { shortenHomeInString, shortenHomePath } from "../utils.js";
+import { formatErrorMessage, withManager } from "./cli-utils.js";
+import { formatHelpExamples } from "./help-format.js";
+import { withProgress, withProgressTotals } from "./progress.js";
 function formatSourceLabel(source, workspaceDir, agentId) {
     if (source === "memory") {
         return shortenHomeInString(`memory (MEMORY.md + ${path.join(workspaceDir, "memory")}${path.sep}*.md)`);
@@ -27,20 +28,39 @@ function formatSourceLabel(source, workspaceDir, agentId) {
 }
 function resolveAgent(cfg, agent) {
     const trimmed = agent?.trim();
-    if (trimmed)
+    if (trimmed) {
         return trimmed;
+    }
     return resolveDefaultAgentId(cfg);
 }
 function resolveAgentIds(cfg, agent) {
     const trimmed = agent?.trim();
-    if (trimmed)
+    if (trimmed) {
         return [trimmed];
+    }
     const list = cfg.agents?.list ?? [];
     if (list.length > 0) {
         return list.map((entry) => entry.id).filter(Boolean);
     }
     return [resolveDefaultAgentId(cfg)];
 }
+function formatExtraPaths(workspaceDir, extraPaths) {
+    return normalizeExtraMemoryPaths(workspaceDir, extraPaths).map((entry) => shortenHomePath(entry));
+}
+async function withMemoryManagerForAgent(params) {
+    await withManager({
+        getManager: () => getMemorySearchManager({
+            cfg: params.cfg,
+            agentId: params.agentId,
+        }),
+        onMissing: (error) => defaultRuntime.log(error ?? "Memory search disabled."),
+        onCloseError: (err) => defaultRuntime.error(`Memory manager close failed: ${formatErrorMessage(err)}`),
+        close: async (manager) => {
+            await manager.close?.();
+        },
+        run: params.run,
+    });
+}
 async function checkReadableFile(pathname) {
     try {
         await fs.access(pathname, fsSync.constants.R_OK);
@@ -48,8 +68,9 @@ async function checkReadableFile(pathname) {
     }
     catch (err) {
         const code = err.code;
-        if (code === "ENOENT")
+        if (code === "ENOENT") {
             return { exists: false };
+        }
         return {
             exists: true,
             issue: `${shortenHomePath(pathname)} not readable (${code ?? "error"})`,
@@ -74,17 +95,41 @@ async function scanSessionFiles(agentId) {
         return { source: "sessions", totalFiles: null, issues };
     }
 }
-async function scanMemoryFiles(workspaceDir) {
+async function scanMemoryFiles(workspaceDir, extraPaths = []) {
     const issues = [];
     const memoryFile = path.join(workspaceDir, "MEMORY.md");
     const altMemoryFile = path.join(workspaceDir, "memory.md");
     const memoryDir = path.join(workspaceDir, "memory");
     const primary = await checkReadableFile(memoryFile);
     const alt = await checkReadableFile(altMemoryFile);
-    if (primary.issue)
+    if (primary.issue) {
         issues.push(primary.issue);
-    if (alt.issue)
+    }
+    if (alt.issue) {
         issues.push(alt.issue);
+    }
+    const resolvedExtraPaths = normalizeExtraMemoryPaths(workspaceDir, extraPaths);
+    for (const extraPath of resolvedExtraPaths) {
+        try {
+            const stat = await fs.lstat(extraPath);
+            if (stat.isSymbolicLink()) {
+                continue;
+            }
+            const extraCheck = await checkReadableFile(extraPath);
+            if (extraCheck.issue) {
+                issues.push(extraCheck.issue);
+            }
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === "ENOENT") {
+                issues.push(`additional memory path missing (${shortenHomePath(extraPath)})`);
+            }
+            else {
+                issues.push(`additional memory path not accessible (${shortenHomePath(extraPath)}): ${code ?? "error"}`);
+            }
+        }
+    }
     let dirReadable = null;
     try {
         await fs.access(memoryDir, fsSync.constants.R_OK);
@@ -104,7 +149,7 @@ async function scanMemoryFiles(workspaceDir) {
     let listed = [];
     let listedOk = false;
     try {
-        listed = await listMemoryFiles(workspaceDir);
+        listed = await listMemoryFiles(workspaceDir, resolvedExtraPaths);
         listedOk = true;
     }
     catch (err) {
@@ -121,10 +166,12 @@ async function scanMemoryFiles(workspaceDir) {
     else {
         const files = new Set(listedOk ? listed : []);
         if (!listedOk) {
-            if (primary.exists)
+            if (primary.exists) {
                 files.add(memoryFile);
-            if (alt.exists)
+            }
+            if (alt.exists) {
                 files.add(altMemoryFile);
+            }
         }
         totalFiles = files.size;
     }
@@ -133,11 +180,37 @@ async function scanMemoryFiles(workspaceDir) {
     }
     return { source: "memory", totalFiles, issues };
 }
+async function summarizeQmdIndexArtifact(manager) {
+    const status = manager.status?.();
+    if (!status || status.backend !== "qmd") {
+        return null;
+    }
+    const dbPath = status.dbPath?.trim();
+    if (!dbPath) {
+        return null;
+    }
+    let stat;
+    try {
+        stat = await fs.stat(dbPath);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code === "ENOENT") {
+            throw new Error(`QMD index file not found: ${shortenHomePath(dbPath)}`, { cause: err });
+        }
+        throw new Error(`QMD index file check failed: ${shortenHomePath(dbPath)} (${code ?? "error"})`, { cause: err });
+    }
+    if (!stat.isFile() || stat.size <= 0) {
+        throw new Error(`QMD index file is empty: ${shortenHomePath(dbPath)}`);
+    }
+    return `QMD index: ${shortenHomePath(dbPath)} (${stat.size} bytes)`;
+}
 async function scanMemorySources(params) {
     const scans = [];
+    const extraPaths = params.extraPaths ?? [];
     for (const source of params.sources) {
         if (source === "memory") {
-            scans.push(await scanMemoryFiles(params.workspaceDir));
+            scans.push(await scanMemoryFiles(params.workspaceDir, extraPaths));
         }
         if (source === "sessions") {
             scans.push(await scanSessionFiles(params.agentId));
@@ -157,43 +230,42 @@ export async function runMemoryStatus(opts) {
     const agentIds = resolveAgentIds(cfg, opts.agent);
     const allResults = [];
     for (const agentId of agentIds) {
-        await withManager({
-            getManager: () => getMemorySearchManager({ cfg, agentId }),
-            onMissing: (error) => defaultRuntime.log(error ?? "Memory search disabled."),
-            onCloseError: (err) => defaultRuntime.error(`Memory manager close failed: ${formatErrorMessage(err)}`),
-            close: async (manager) => {
-                await manager.close?.();
-            },
+        await withMemoryManagerForAgent({
+            cfg,
+            agentId,
             run: async (manager) => {
                 const deep = Boolean(opts.deep || opts.index);
                 let embeddingProbe;
                 let indexError;
+                const syncFn = manager.sync ? manager.sync.bind(manager) : undefined;
                 if (deep) {
-                    await withProgress({ label: "Checking memory…", total: 2 }, async (progress) => {
-                        progress.setLabel("Probing vector…");
+                    await withProgress({ label: "Checking memory\u2026", total: 2 }, async (progress) => {
+                        progress.setLabel("Probing vector\u2026");
                         await manager.probeVectorAvailability();
                         progress.tick();
-                        progress.setLabel("Probing embeddings…");
+                        progress.setLabel("Probing embeddings\u2026");
                         embeddingProbe = await manager.probeEmbeddingAvailability();
                         progress.tick();
                     });
-                    if (opts.index) {
+                    if (opts.index && syncFn) {
                         await withProgressTotals({
-                            label: "Indexing memory…",
+                            label: "Indexing memory\u2026",
                             total: 0,
                             fallback: opts.verbose ? "line" : undefined,
                         }, async (update, progress) => {
                             try {
-                                await manager.sync?.({
+                                await syncFn({
                                     reason: "cli",
+                                    force: Boolean(opts.force),
                                     progress: (syncUpdate) => {
                                         update({
                                             completed: syncUpdate.completed,
                                             total: syncUpdate.total,
                                             label: syncUpdate.label,
                                         });
-                                        if (syncUpdate.label)
+                                        if (syncUpdate.label) {
                                             progress.setLabel(syncUpdate.label);
+                                        }
                                     },
                                 });
                             }
@@ -204,6 +276,9 @@ export async function runMemoryStatus(opts) {
                             }
                         });
                     }
+                    else if (opts.index && !syncFn) {
+                        defaultRuntime.log("Memory backend does not support manual reindex.");
+                    }
                 }
                 else {
                     await manager.probeVectorAvailability();
@@ -216,6 +291,7 @@ export async function runMemoryStatus(opts) {
                         workspaceDir,
                         agentId,
                         sources,
+                        extraPaths: status.extraPaths,
                     })
                     : undefined;
                 allResults.push({ agentId, status, embeddingProbe, indexError, scan });
@@ -240,8 +316,8 @@ export async function runMemoryStatus(opts) {
         const chunksIndexed = status.chunks ?? 0;
         const totalFiles = scan?.totalFiles ?? null;
         const indexedLabel = totalFiles === null
-            ? `${filesIndexed}/? files · ${chunksIndexed} chunks`
-            : `${filesIndexed}/${totalFiles} files · ${chunksIndexed} chunks`;
+            ? `${filesIndexed}/? files \u00b7 ${chunksIndexed} chunks`
+            : `${filesIndexed}/${totalFiles} files \u00b7 ${chunksIndexed} chunks`;
         if (opts.index) {
             const line = indexError ? `Memory index failed: ${indexError}` : "Memory index complete.";
             defaultRuntime.log(line);
@@ -251,11 +327,15 @@ export async function runMemoryStatus(opts) {
         const storePath = status.dbPath ? shortenHomePath(status.dbPath) : "<unknown>";
         const workspacePath = status.workspaceDir ? shortenHomePath(status.workspaceDir) : "<unknown>";
         const sourceList = status.sources?.length ? status.sources.join(", ") : null;
+        const extraPaths = status.workspaceDir
+            ? formatExtraPaths(status.workspaceDir, status.extraPaths ?? [])
+            : [];
         const lines = [
             `${heading("Memory Search")} ${muted(`(${agentId})`)}`,
             `${label("Provider")} ${info(status.provider)} ${muted(`(requested: ${requestedProvider})`)}`,
             `${label("Model")} ${info(modelLabel)}`,
             sourceList ? `${label("Sources")} ${info(sourceList)}` : null,
+            extraPaths.length ? `${label("Extra paths")} ${info(extraPaths.join(", "))}` : null,
             `${label("Indexed")} ${success(indexedLabel)}`,
             `${label("Dirty")} ${status.dirty ? warn("yes") : muted("no")}`,
             `${label("Store")} ${info(storePath)}`,
@@ -272,11 +352,11 @@ export async function runMemoryStatus(opts) {
         if (status.sourceCounts?.length) {
             lines.push(label("By source"));
             for (const entry of status.sourceCounts) {
-                const total = scan?.sources.find((scanEntry) => scanEntry.source === entry.source)?.totalFiles;
+                const total = scan?.sources?.find((scanEntry) => scanEntry.source === entry.source)?.totalFiles;
                 const counts = total === null
-                    ? `${entry.files}/? files · ${entry.chunks} chunks`
-                    : `${entry.files}/${total} files · ${entry.chunks} chunks`;
-                lines.push(`  ${accent(entry.source)} ${muted("·")} ${muted(counts)}`);
+                    ? `${entry.files}/? files \u00b7 ${entry.chunks} chunks`
+                    : `${entry.files}/${total} files \u00b7 ${entry.chunks} chunks`;
+                lines.push(`  ${accent(entry.source)} ${muted("\u00b7")} ${muted(counts)}`);
             }
         }
         if (status.fallback) {
@@ -361,8 +441,13 @@ export async function runMemoryStatus(opts) {
 export function registerMemoryCli(program) {
     const memory = program
         .command("memory")
-        .description("Memory search tools")
-        .addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/memory", "docs.molt.bot/cli/memory")}\n`);
+        .description("Search, inspect, and reindex memory files")
+        .addHelpText("after", () => `\n${theme.heading("Examples:")}\n${formatHelpExamples([
+        ["poolbot memory status", "Show index and provider status."],
+        ["poolbot memory index --force", "Force a full reindex."],
+        ['poolbot memory search --query "deployment notes"', "Search indexed memory entries."],
+        ["poolbot memory status --json", "Output machine-readable JSON."],
+    ])}\n\n${theme.muted("Docs:")} ${formatDocsLink("/cli/memory", "docs.molt.bot/cli/memory")}\n`);
     memory
         .command("status")
         .description("Show memory search index status")
@@ -385,15 +470,12 @@ export function registerMemoryCli(program) {
         const cfg = loadConfig();
         const agentIds = resolveAgentIds(cfg, opts.agent);
         for (const agentId of agentIds) {
-            await withManager({
-                getManager: () => getMemorySearchManager({ cfg, agentId }),
-                onMissing: (error) => defaultRuntime.log(error ?? "Memory search disabled."),
-                onCloseError: (err) => defaultRuntime.error(`Memory manager close failed: ${formatErrorMessage(err)}`),
-                close: async (manager) => {
-                    await manager.close?.();
-                },
+            await withMemoryManagerForAgent({
+                cfg,
+                agentId,
                 run: async (manager) => {
                     try {
+                        const syncFn = manager.sync ? manager.sync.bind(manager) : undefined;
                         if (opts.verbose) {
                             const status = manager.status();
                             const rich = isRich();
@@ -403,13 +485,21 @@ export function registerMemoryCli(program) {
                             const warn = (text) => colorize(rich, theme.warn, text);
                             const label = (text) => muted(`${text}:`);
                             const sourceLabels = (status.sources ?? []).map((source) => formatSourceLabel(source, status.workspaceDir ?? "", agentId));
+                            const extraPaths = status.workspaceDir
+                                ? formatExtraPaths(status.workspaceDir, status.extraPaths ?? [])
+                                : [];
+                            const requestedProvider = status.requestedProvider ?? status.provider;
+                            const modelLabel = status.model ?? status.provider;
                             const lines = [
                                 `${heading("Memory Index")} ${muted(`(${agentId})`)}`,
-                                `${label("Provider")} ${info(status.provider)} ${muted(`(requested: ${status.requestedProvider ?? status.provider})`)}`,
-                                `${label("Model")} ${info(status.model ?? status.provider)}`,
+                                `${label("Provider")} ${info(status.provider)} ${muted(`(requested: ${requestedProvider})`)}`,
+                                `${label("Model")} ${info(modelLabel)}`,
                                 sourceLabels.length
                                     ? `${label("Sources")} ${info(sourceLabels.join(", "))}`
                                     : null,
+                                extraPaths.length
+                                    ? `${label("Extra paths")} ${info(extraPaths.join(", "))}`
+                                    : null,
                             ].filter(Boolean);
                             if (status.fallback) {
                                 lines.push(`${label("Fallback")} ${warn(status.fallback.from)}`);
@@ -418,7 +508,7 @@ export function registerMemoryCli(program) {
                             defaultRuntime.log("");
                         }
                         const startedAt = Date.now();
-                        let lastLabel = "Indexing memory…";
+                        let lastLabel = "Indexing memory\u2026";
                         let lastCompleted = 0;
                         let lastTotal = 0;
                         const formatElapsed = () => {
@@ -429,12 +519,14 @@ export function registerMemoryCli(program) {
                             return `${minutes}:${String(remainingSeconds).padStart(2, "0")}`;
                         };
                         const formatEta = () => {
-                            if (lastTotal <= 0 || lastCompleted <= 0)
+                            if (lastTotal <= 0 || lastCompleted <= 0) {
                                 return null;
+                            }
                             const elapsedMs = Math.max(1, Date.now() - startedAt);
                             const rate = lastCompleted / elapsedMs;
-                            if (!Number.isFinite(rate) || rate <= 0)
+                            if (!Number.isFinite(rate) || rate <= 0) {
                                 return null;
+                            }
                             const remainingMs = Math.max(0, (lastTotal - lastCompleted) / rate);
                             const seconds = Math.floor(remainingMs / 1000);
                             const minutes = Math.floor(seconds / 60);
@@ -445,11 +537,15 @@ export function registerMemoryCli(program) {
                             const elapsed = formatElapsed();
                             const eta = formatEta();
                             return eta
-                                ? `${lastLabel} · elapsed ${elapsed} · eta ${eta}`
-                                : `${lastLabel} · elapsed ${elapsed}`;
+                                ? `${lastLabel} \u00b7 elapsed ${elapsed} \u00b7 eta ${eta}`
+                                : `${lastLabel} \u00b7 elapsed ${elapsed}`;
                         };
+                        if (!syncFn) {
+                            defaultRuntime.log("Memory backend does not support manual reindex.");
+                            return;
+                        }
                         await withProgressTotals({
-                            label: "Indexing memory…",
+                            label: "Indexing memory\u2026",
                             total: 0,
                             fallback: opts.verbose ? "line" : undefined,
                         }, async (update, progress) => {
@@ -457,12 +553,13 @@ export function registerMemoryCli(program) {
                                 progress.setLabel(buildLabel());
                             }, 1000);
                             try {
-                                await manager.sync?.({
+                                await syncFn({
                                     reason: "cli",
-                                    force: opts.force,
+                                    force: Boolean(opts.force),
                                     progress: (syncUpdate) => {
-                                        if (syncUpdate.label)
+                                        if (syncUpdate.label) {
                                             lastLabel = syncUpdate.label;
+                                        }
                                         lastCompleted = syncUpdate.completed;
                                         lastTotal = syncUpdate.total;
                                         update({
@@ -478,6 +575,10 @@ export function registerMemoryCli(program) {
                                 clearInterval(interval);
                             }
                         });
+                        const qmdIndexSummary = await summarizeQmdIndexArtifact(manager);
+                        if (qmdIndexSummary) {
+                            defaultRuntime.log(qmdIndexSummary);
+                        }
                         defaultRuntime.log(`Memory index updated (${agentId}).`);
                     }
                     catch (err) {
@@ -500,13 +601,9 @@ export function registerMemoryCli(program) {
         .action(async (query, opts) => {
         const cfg = loadConfig();
         const agentId = resolveAgent(cfg, opts.agent);
-        await withManager({
-            getManager: () => getMemorySearchManager({ cfg, agentId }),
-            onMissing: (error) => defaultRuntime.log(error ?? "Memory search disabled."),
-            onCloseError: (err) => defaultRuntime.error(`Memory manager close failed: ${formatErrorMessage(err)}`),
-            close: async (manager) => {
-                await manager.close?.();
-            },
+        await withMemoryManagerForAgent({
+            cfg,
+            agentId,
             run: async (manager) => {
                 let results;
                 try {

package/dist/cli/node-cli/register.js

@@ -1,9 +1,10 @@
-import { formatDocsLink } from "../../terminal/links.js";
-import { theme } from "../../terminal/theme.js";
 import { loadNodeHostConfig } from "../../node-host/config.js";
 import { runNodeHost } from "../../node-host/runner.js";
-import { runNodeDaemonInstall, runNodeDaemonRestart, runNodeDaemonStatus, runNodeDaemonStop, runNodeDaemonUninstall, } from "./daemon.js";
+import { formatDocsLink } from "../../terminal/links.js";
+import { theme } from "../../terminal/theme.js";
 import { parsePort } from "../daemon-cli/shared.js";
+import { formatHelpExamples } from "../help-format.js";
+import { runNodeDaemonInstall, runNodeDaemonRestart, runNodeDaemonStatus, runNodeDaemonStop, runNodeDaemonUninstall, } from "./daemon.js";
 function parsePortWithFallback(value, fallback) {
     const parsed = parsePort(value);
     return parsed ?? fallback;
@@ -11,8 +12,16 @@ function parsePortWithFallback(value, fallback) {
 export function registerNodeCli(program) {
     const node = program
         .command("node")
-        .description("Run a headless node host (system.run/system.which)")
-        .addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/cli/node", "docs.molt.bot/cli/node")}\n`);
+        .description("Run and manage the headless node host service")
+        .addHelpText("after", () => `\n${theme.heading("Examples:")}\n${formatHelpExamples([
+        [
+            "poolbot node run --host 127.0.0.1 --port 18789",
+            "Run the node host in the foreground.",
+        ],
+        ["poolbot node status", "Check node host service status."],
+        ["poolbot node install", "Install the node host service."],
+        ["poolbot node restart", "Restart the installed node host service."],
+    ])}\n\n${theme.muted("Docs:")} ${formatDocsLink("/cli/node", "docs.molt.bot/cli/node")}\n`);
     node
         .command("run")
         .description("Run the headless node host (foreground)")

package/dist/cli/nodes-cli/register.push.js

@@ -0,0 +1,63 @@
+import { defaultRuntime } from "../../runtime.js";
+import { getNodesTheme, runNodesCommand } from "./cli-utils.js";
+import { callGatewayCli, nodesCallOpts, resolveNodeId } from "./rpc.js";
+function normalizeEnvironment(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "sandbox" || normalized === "production") {
+        return normalized;
+    }
+    return null;
+}
+export function registerNodesPushCommand(nodes) {
+    nodesCallOpts(nodes
+        .command("push")
+        .description("Send an APNs test push to an iOS node")
+        .requiredOption("--node <idOrNameOrIp>", "Node id, name, or IP")
+        .option("--title <text>", "Push title", "Pool Bot")
+        .option("--body <text>", "Push body")
+        .option("--environment <sandbox|production>", "Override APNs environment")
+        .action(async (opts) => {
+        await runNodesCommand("push", async () => {
+            const nodeId = await resolveNodeId(opts, String(opts.node ?? ""));
+            const title = String(opts.title ?? "").trim() || "Pool Bot";
+            const body = String(opts.body ?? "").trim() || `Push test for node ${nodeId}`;
+            const environment = normalizeEnvironment(opts.environment);
+            if (opts.environment && !environment) {
+                throw new Error("invalid --environment (use sandbox|production)");
+            }
+            const params = {
+                nodeId,
+                title,
+                body,
+            };
+            if (environment) {
+                params.environment = environment;
+            }
+            const result = await callGatewayCli("push.test", opts, params);
+            if (opts.json) {
+                defaultRuntime.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            const parsed = typeof result === "object" && result !== null
+                ? result
+                : {};
+            const ok = parsed.ok === true;
+            const status = typeof parsed.status === "number" ? parsed.status : 0;
+            const reason = typeof parsed.reason === "string" && parsed.reason.trim().length > 0
+                ? parsed.reason.trim()
+                : undefined;
+            const env = typeof parsed.environment === "string" && parsed.environment.trim().length > 0
+                ? parsed.environment.trim()
+                : "unknown";
+            const { ok: okLabel, error: errorLabel } = getNodesTheme();
+            const label = ok ? okLabel : errorLabel;
+            defaultRuntime.log(label(`push.test status=${status} ok=${ok} env=${env}`));
+            if (reason) {
+                defaultRuntime.log(`reason: ${reason}`);
+            }
+        });
+    }), { timeoutMs: 25_000 });
+}

package/dist/cli/nodes-media-utils.js

@@ -0,0 +1,26 @@
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import { resolvePreferredPoolbotTmpDir } from "../infra/tmp-poolbot-dir.js";
+export function asRecord(value) {
+    return typeof value === "object" && value !== null ? value : {};
+}
+export function asString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+export function asNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+export function asBoolean(value) {
+    return typeof value === "boolean" ? value : undefined;
+}
+export function resolveTempPathParts(opts) {
+    const tmpDir = opts.tmpDir ?? resolvePreferredPoolbotTmpDir();
+    if (!opts.tmpDir) {
+        fs.mkdirSync(tmpDir, { recursive: true, mode: 0o700 });
+    }
+    return {
+        tmpDir,
+        id: opts.id ?? randomUUID(),
+        ext: opts.ext.startsWith(".") ? opts.ext : `.${opts.ext}`,
+    };
+}

package/dist/cli/outbound-send-deps.js

@@ -1,11 +1,4 @@
-// Provider docking: extend this mapping when adding new outbound send deps.
+import { createOutboundSendDepsFromCliSource, } from "./outbound-send-mapping.js";
 export function createOutboundSendDeps(deps) {
-    return {
-        sendWhatsApp: deps.sendMessageWhatsApp,
-        sendTelegram: deps.sendMessageTelegram,
-        sendDiscord: deps.sendMessageDiscord,
-        sendSlack: deps.sendMessageSlack,
-        sendSignal: deps.sendMessageSignal,
-        sendIMessage: deps.sendMessageIMessage,
-    };
+    return createOutboundSendDepsFromCliSource(deps);
 }

package/dist/cli/outbound-send-mapping.js

@@ -0,0 +1,11 @@
+// Provider docking: extend this mapping when adding new outbound send deps.
+export function createOutboundSendDepsFromCliSource(deps) {
+    return {
+        sendWhatsApp: deps.sendMessageWhatsApp,
+        sendTelegram: deps.sendMessageTelegram,
+        sendDiscord: deps.sendMessageDiscord,
+        sendSlack: deps.sendMessageSlack,
+        sendSignal: deps.sendMessageSignal,
+        sendIMessage: deps.sendMessageIMessage,
+    };
+}