@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/infra/node-pairing.js

@@ -1,97 +1,38 @@
 import { randomUUID } from "node:crypto";
-import fs from "node:fs/promises";
-import path from "node:path";
-import { resolveStateDir } from "../config/paths.js";
+import { createAsyncLock, pruneExpiredPending, readJsonFile, resolvePairingPaths, upsertPendingPairingRequest, writeJsonAtomic, } from "./pairing-files.js";
+import { generatePairingToken, verifyPairingToken } from "./pairing-token.js";
 const PENDING_TTL_MS = 5 * 60 * 1000;
-function resolvePaths(baseDir) {
-    const root = baseDir ?? resolveStateDir();
-    const dir = path.join(root, "nodes");
-    return {
-        dir,
-        pendingPath: path.join(dir, "pending.json"),
-        pairedPath: path.join(dir, "paired.json"),
-    };
-}
-async function readJSON(filePath) {
-    try {
-        const raw = await fs.readFile(filePath, "utf8");
-        return JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-}
-async function writeJSONAtomic(filePath, value) {
-    const dir = path.dirname(filePath);
-    await fs.mkdir(dir, { recursive: true });
-    const tmp = `${filePath}.${randomUUID()}.tmp`;
-    await fs.writeFile(tmp, JSON.stringify(value, null, 2), "utf8");
-    try {
-        await fs.chmod(tmp, 0o600);
-    }
-    catch {
-        // best-effort; ignore on platforms without chmod
-    }
-    await fs.rename(tmp, filePath);
-    try {
-        await fs.chmod(filePath, 0o600);
-    }
-    catch {
-        // best-effort; ignore on platforms without chmod
-    }
-}
-function pruneExpiredPending(pendingById, nowMs) {
-    for (const [id, req] of Object.entries(pendingById)) {
-        if (nowMs - req.ts > PENDING_TTL_MS) {
-            delete pendingById[id];
-        }
-    }
-}
-let lock = Promise.resolve();
-async function withLock(fn) {
-    const prev = lock;
-    let release;
-    lock = new Promise((resolve) => {
-        release = resolve;
-    });
-    await prev;
-    try {
-        return await fn();
-    }
-    finally {
-        release?.();
-    }
-}
+const withLock = createAsyncLock();
 async function loadState(baseDir) {
-    const { pendingPath, pairedPath } = resolvePaths(baseDir);
+    const { pendingPath, pairedPath } = resolvePairingPaths(baseDir, "nodes");
     const [pending, paired] = await Promise.all([
-        readJSON(pendingPath),
-        readJSON(pairedPath),
+        readJsonFile(pendingPath),
+        readJsonFile(pairedPath),
     ]);
     const state = {
         pendingById: pending ?? {},
         pairedByNodeId: paired ?? {},
     };
-    pruneExpiredPending(state.pendingById, Date.now());
+    pruneExpiredPending(state.pendingById, Date.now(), PENDING_TTL_MS);
     return state;
 }
 async function persistState(state, baseDir) {
-    const { pendingPath, pairedPath } = resolvePaths(baseDir);
+    const { pendingPath, pairedPath } = resolvePairingPaths(baseDir, "nodes");
     await Promise.all([
-        writeJSONAtomic(pendingPath, state.pendingById),
-        writeJSONAtomic(pairedPath, state.pairedByNodeId),
+        writeJsonAtomic(pendingPath, state.pendingById),
+        writeJsonAtomic(pairedPath, state.pairedByNodeId),
     ]);
 }
 function normalizeNodeId(nodeId) {
     return nodeId.trim();
 }
 function newToken() {
-    return randomUUID().replaceAll("-", "");
+    return generatePairingToken();
 }
 export async function listNodePairing(baseDir) {
     const state = await loadState(baseDir);
-    const pending = Object.values(state.pendingById).sort((a, b) => b.ts - a.ts);
-    const paired = Object.values(state.pairedByNodeId).sort((a, b) => b.approvedAtMs - a.approvedAtMs);
+    const pending = Object.values(state.pendingById).toSorted((a, b) => b.ts - a.ts);
+    const paired = Object.values(state.pairedByNodeId).toSorted((a, b) => b.approvedAtMs - a.approvedAtMs);
     return { pending, paired };
 }
 export async function getPairedNode(nodeId, baseDir) {
@@ -105,40 +46,39 @@ export async function requestNodePairing(req, baseDir) {
         if (!nodeId) {
             throw new Error("nodeId required");
         }
-        const existing = Object.values(state.pendingById).find((p) => p.nodeId === nodeId);
-        if (existing) {
-            return { status: "pending", request: existing, created: false };
-        }
-        const isRepair = Boolean(state.pairedByNodeId[nodeId]);
-        const request = {
-            requestId: randomUUID(),
-            nodeId,
-            displayName: req.displayName,
-            platform: req.platform,
-            version: req.version,
-            coreVersion: req.coreVersion,
-            uiVersion: req.uiVersion,
-            deviceFamily: req.deviceFamily,
-            modelIdentifier: req.modelIdentifier,
-            caps: req.caps,
-            commands: req.commands,
-            permissions: req.permissions,
-            remoteIp: req.remoteIp,
-            silent: req.silent,
-            isRepair,
-            ts: Date.now(),
-        };
-        state.pendingById[request.requestId] = request;
-        await persistState(state, baseDir);
-        return { status: "pending", request, created: true };
+        return await upsertPendingPairingRequest({
+            pendingById: state.pendingById,
+            isExisting: (pending) => pending.nodeId === nodeId,
+            isRepair: Boolean(state.pairedByNodeId[nodeId]),
+            createRequest: (isRepair) => ({
+                requestId: randomUUID(),
+                nodeId,
+                displayName: req.displayName,
+                platform: req.platform,
+                version: req.version,
+                coreVersion: req.coreVersion,
+                uiVersion: req.uiVersion,
+                deviceFamily: req.deviceFamily,
+                modelIdentifier: req.modelIdentifier,
+                caps: req.caps,
+                commands: req.commands,
+                permissions: req.permissions,
+                remoteIp: req.remoteIp,
+                silent: req.silent,
+                isRepair,
+                ts: Date.now(),
+            }),
+            persist: async () => await persistState(state, baseDir),
+        });
     });
 }
 export async function approveNodePairing(requestId, baseDir) {
     return await withLock(async () => {
         const state = await loadState(baseDir);
         const pending = state.pendingById[requestId];
-        if (!pending)
+        if (!pending) {
             return null;
+        }
         const now = Date.now();
         const existing = state.pairedByNodeId[pending.nodeId];
         const node = {
@@ -168,8 +108,9 @@ export async function rejectNodePairing(requestId, baseDir) {
     return await withLock(async () => {
         const state = await loadState(baseDir);
         const pending = state.pendingById[requestId];
-        if (!pending)
+        if (!pending) {
             return null;
+        }
         delete state.pendingById[requestId];
         await persistState(state, baseDir);
         return { requestId, nodeId: pending.nodeId };
@@ -179,17 +120,19 @@ export async function verifyNodeToken(nodeId, token, baseDir) {
     const state = await loadState(baseDir);
     const normalized = normalizeNodeId(nodeId);
     const node = state.pairedByNodeId[normalized];
-    if (!node)
+    if (!node) {
         return { ok: false };
-    return node.token === token ? { ok: true, node } : { ok: false };
+    }
+    return verifyPairingToken(token, node.token) ? { ok: true, node } : { ok: false };
 }
 export async function updatePairedNodeMetadata(nodeId, patch, baseDir) {
     await withLock(async () => {
         const state = await loadState(baseDir);
         const normalized = normalizeNodeId(nodeId);
         const existing = state.pairedByNodeId[normalized];
-        if (!existing)
+        if (!existing) {
             return;
+        }
         const next = {
             ...existing,
             displayName: patch.displayName ?? existing.displayName,
@@ -215,11 +158,13 @@ export async function renamePairedNode(nodeId, displayName, baseDir) {
         const state = await loadState(baseDir);
         const normalized = normalizeNodeId(nodeId);
         const existing = state.pairedByNodeId[normalized];
-        if (!existing)
+        if (!existing) {
             return null;
+        }
         const trimmed = displayName.trim();
-        if (!trimmed)
+        if (!trimmed) {
             throw new Error("displayName required");
+        }
         const next = { ...existing, displayName: trimmed };
         state.pairedByNodeId[normalized] = next;
         await persistState(state, baseDir);

package/dist/infra/npm-integrity.js

@@ -0,0 +1,45 @@
+export async function resolveNpmIntegrityDrift(params) {
+    if (!params.expectedIntegrity || !params.resolution.integrity) {
+        return { proceed: true };
+    }
+    if (params.expectedIntegrity === params.resolution.integrity) {
+        return { proceed: true };
+    }
+    const integrityDrift = {
+        expectedIntegrity: params.expectedIntegrity,
+        actualIntegrity: params.resolution.integrity,
+    };
+    const payload = params.createPayload({
+        spec: params.spec,
+        expectedIntegrity: integrityDrift.expectedIntegrity,
+        actualIntegrity: integrityDrift.actualIntegrity,
+        resolution: params.resolution,
+    });
+    let proceed = true;
+    if (params.onIntegrityDrift) {
+        proceed = await params.onIntegrityDrift(payload);
+    }
+    else {
+        params.warn?.(payload);
+    }
+    return { integrityDrift, proceed, payload };
+}
+export async function resolveNpmIntegrityDriftWithDefaultMessage(params) {
+    const driftResult = await resolveNpmIntegrityDrift({
+        spec: params.spec,
+        expectedIntegrity: params.expectedIntegrity,
+        resolution: params.resolution,
+        createPayload: (drift) => ({ ...drift }),
+        onIntegrityDrift: params.onIntegrityDrift,
+        warn: (driftPayload) => {
+            params.warn?.(`Integrity drift detected for ${driftPayload.resolution.resolvedSpec ?? driftPayload.spec}: expected ${driftPayload.expectedIntegrity}, got ${driftPayload.actualIntegrity}`);
+        },
+    });
+    if (!driftResult.proceed && driftResult.payload) {
+        return {
+            integrityDrift: driftResult.integrityDrift,
+            error: `aborted: npm package integrity drift detected for ${driftResult.payload.resolution.resolvedSpec ?? driftResult.payload.spec}`,
+        };
+    }
+    return { integrityDrift: driftResult.integrityDrift };
+}

package/dist/infra/npm-pack-install.js

@@ -0,0 +1,40 @@
+import { packNpmSpecToArchive, withTempDir, } from "./install-source-utils.js";
+import { resolveNpmIntegrityDriftWithDefaultMessage, } from "./npm-integrity.js";
+export async function installFromNpmSpecArchive(params) {
+    return await withTempDir(params.tempDirPrefix, async (tmpDir) => {
+        const packedResult = await packNpmSpecToArchive({
+            spec: params.spec,
+            timeoutMs: params.timeoutMs,
+            cwd: tmpDir,
+        });
+        if (!packedResult.ok) {
+            return packedResult;
+        }
+        const npmResolution = {
+            ...packedResult.metadata,
+            resolvedAt: new Date().toISOString(),
+        };
+        const driftResult = await resolveNpmIntegrityDriftWithDefaultMessage({
+            spec: params.spec,
+            expectedIntegrity: params.expectedIntegrity,
+            resolution: npmResolution,
+            onIntegrityDrift: params.onIntegrityDrift,
+            warn: params.warn,
+        });
+        if (driftResult.error) {
+            return {
+                ok: false,
+                error: driftResult.error,
+            };
+        }
+        const installResult = await params.installFromArchive({
+            archivePath: packedResult.archivePath,
+        });
+        return {
+            ok: true,
+            installResult,
+            npmResolution,
+            integrityDrift: driftResult.integrityDrift,
+        };
+    });
+}

package/dist/infra/outbound/bound-delivery-router.js

@@ -0,0 +1,88 @@
+import { getSessionBindingService, } from "./session-binding-service.js";
+function isActiveBinding(record) {
+    return record.status === "active";
+}
+function resolveBindingForRequester(requester, bindings) {
+    const matchingChannelAccount = bindings.filter((entry) => entry.conversation.channel === requester.channel &&
+        entry.conversation.accountId === requester.accountId);
+    if (matchingChannelAccount.length === 0) {
+        return null;
+    }
+    const exactConversation = matchingChannelAccount.find((entry) => entry.conversation.conversationId === requester.conversationId);
+    if (exactConversation) {
+        return exactConversation;
+    }
+    if (matchingChannelAccount.length === 1) {
+        return matchingChannelAccount[0] ?? null;
+    }
+    return null;
+}
+export function createBoundDeliveryRouter(service = getSessionBindingService()) {
+    return {
+        resolveDestination: (input) => {
+            const targetSessionKey = input.targetSessionKey.trim();
+            if (!targetSessionKey) {
+                return {
+                    binding: null,
+                    mode: "fallback",
+                    reason: "missing-target-session",
+                };
+            }
+            const activeBindings = service.listBySession(targetSessionKey).filter(isActiveBinding);
+            if (activeBindings.length === 0) {
+                return {
+                    binding: null,
+                    mode: "fallback",
+                    reason: "no-active-binding",
+                };
+            }
+            if (!input.requester) {
+                if (activeBindings.length === 1) {
+                    return {
+                        binding: activeBindings[0] ?? null,
+                        mode: "bound",
+                        reason: "single-active-binding",
+                    };
+                }
+                return {
+                    binding: null,
+                    mode: "fallback",
+                    reason: "ambiguous-without-requester",
+                };
+            }
+            const requester = {
+                channel: input.requester.channel.trim().toLowerCase(),
+                accountId: input.requester.accountId.trim(),
+                conversationId: input.requester.conversationId.trim(),
+                parentConversationId: input.requester.parentConversationId?.trim() || undefined,
+            };
+            if (!requester.channel || !requester.conversationId) {
+                return {
+                    binding: null,
+                    mode: "fallback",
+                    reason: "invalid-requester",
+                };
+            }
+            const fromRequester = resolveBindingForRequester(requester, activeBindings);
+            if (fromRequester) {
+                return {
+                    binding: fromRequester,
+                    mode: "bound",
+                    reason: "requester-match",
+                };
+            }
+            if (activeBindings.length === 1 && !input.failClosed) {
+                return {
+                    binding: activeBindings[0] ?? null,
+                    mode: "bound",
+                    reason: "single-active-binding-fallback",
+                };
+            }
+            return {
+                binding: null,
+                mode: "fallback",
+                reason: "no-requester-match",
+            };
+        },
+    };
+}

package/dist/infra/outbound/channel-adapters.js

@@ -1,16 +1,29 @@
+import { Separator, TextDisplay } from "@buape/carbon";
+import { DiscordUiContainer } from "../../discord/ui.js";
+class CrossContextContainer extends DiscordUiContainer {
+    constructor({ originLabel, message, cfg, accountId }) {
+        const trimmed = message.trim();
+        const components = [];
+        if (trimmed) {
+            components.push(new TextDisplay(message));
+            components.push(new Separator({ divider: true, spacing: "small" }));
+        }
+        components.push(new TextDisplay(`*From ${originLabel}*`));
+        super({ cfg, accountId, components });
+    }
+}
 const DEFAULT_ADAPTER = {
-    supportsEmbeds: false,
+    supportsComponentsV2: false,
 };
 const DISCORD_ADAPTER = {
-    supportsEmbeds: true,
-    buildCrossContextEmbeds: (originLabel) => [
-        {
-            description: `From ${originLabel}`,
-        },
+    supportsComponentsV2: true,
+    buildCrossContextComponents: ({ originLabel, message, cfg, accountId }) => [
+        new CrossContextContainer({ originLabel, message, cfg, accountId }),
     ],
 };
 export function getChannelMessageAdapter(channel) {
-    if (channel === "discord")
+    if (channel === "discord") {
         return DISCORD_ADAPTER;
+    }
     return DEFAULT_ADAPTER;
 }

package/dist/infra/outbound/channel-selection.js

@@ -5,35 +5,41 @@ function isKnownChannel(value) {
     return getMessageChannels().includes(value);
 }
 function isAccountEnabled(account) {
-    if (!account || typeof account !== "object")
+    if (!account || typeof account !== "object") {
         return true;
+    }
     const enabled = account.enabled;
     return enabled !== false;
 }
 async function isPluginConfigured(plugin, cfg) {
     const accountIds = plugin.config.listAccountIds(cfg);
-    if (accountIds.length === 0)
+    if (accountIds.length === 0) {
         return false;
+    }
     for (const accountId of accountIds) {
         const account = plugin.config.resolveAccount(cfg, accountId);
         const enabled = plugin.config.isEnabled
             ? plugin.config.isEnabled(account, cfg)
             : isAccountEnabled(account);
-        if (!enabled)
+        if (!enabled) {
             continue;
-        if (!plugin.config.isConfigured)
+        }
+        if (!plugin.config.isConfigured) {
             return true;
+        }
         const configured = await plugin.config.isConfigured(account, cfg);
-        if (configured)
+        if (configured) {
             return true;
+        }
     }
     return false;
 }
 export async function listConfiguredMessageChannels(cfg) {
     const channels = [];
     for (const plugin of listChannelPlugins()) {
-        if (!isKnownChannel(plugin.id))
+        if (!isKnownChannel(plugin.id)) {
             continue;
+        }
         if (await isPluginConfigured(plugin, cfg)) {
             channels.push(plugin.id);
         }

package/dist/infra/outbound/envelope.js

@@ -7,7 +7,7 @@ export function buildOutboundResultEnvelope(params) {
         : params.payloads.length === 0
             ? []
             : isOutboundPayloadJson(params.payloads[0])
-                ? params.payloads
+                ? [...params.payloads]
                 : normalizeOutboundPayloadsForJson(params.payloads);
     if (params.flattenDelivery !== false && params.delivery && !params.meta && !hasPayloads) {
         return params.delivery;

package/dist/infra/outbound/format.js

@@ -2,11 +2,13 @@ import { getChannelPlugin } from "../../channels/plugins/index.js";
 import { getChatChannelMeta, normalizeChatChannelId } from "../../channels/registry.js";
 const resolveChannelLabel = (channel) => {
     const pluginLabel = getChannelPlugin(channel)?.meta.label;
-    if (pluginLabel)
+    if (pluginLabel) {
         return pluginLabel;
+    }
     const normalized = normalizeChatChannelId(channel);
-    if (normalized)
+    if (normalized) {
         return getChatChannelMeta(normalized).label;
+    }
     return channel;
 };
 export function formatOutboundDeliverySummary(channel, result) {
@@ -15,14 +17,18 @@ export function formatOutboundDeliverySummary(channel, result) {
     }
     const label = resolveChannelLabel(result.channel);
     const base = `✅ Sent via ${label}. Message ID: ${result.messageId}`;
-    if ("chatId" in result)
+    if ("chatId" in result) {
         return `${base} (chat ${result.chatId})`;
-    if ("channelId" in result)
+    }
+    if ("channelId" in result) {
         return `${base} (channel ${result.channelId})`;
-    if ("roomId" in result)
+    }
+    if ("roomId" in result) {
         return `${base} (room ${result.roomId})`;
-    if ("conversationId" in result)
+    }
+    if ("conversationId" in result) {
         return `${base} (conversation ${result.conversationId})`;
+    }
     return base;
 }
 export function buildOutboundDeliveryJson(params) {