@poolzin/pool-bot 2026.3.4 → 2026.3.7

package/dist/hooks/message-hook-mappers.js

@@ -0,0 +1,179 @@
+export function deriveInboundMessageHookContext(ctx, overrides) {
+    const content = overrides?.content ??
+        (typeof ctx.BodyForCommands === "string"
+            ? ctx.BodyForCommands
+            : typeof ctx.RawBody === "string"
+                ? ctx.RawBody
+                : typeof ctx.Body === "string"
+                    ? ctx.Body
+                    : "");
+    const channelId = (ctx.OriginatingChannel ?? ctx.Surface ?? ctx.Provider ?? "").toLowerCase();
+    const conversationId = ctx.OriginatingTo ?? ctx.To ?? ctx.From ?? undefined;
+    const isGroup = Boolean(ctx.GroupSubject || ctx.GroupChannel);
+    return {
+        from: ctx.From ?? "",
+        to: ctx.To,
+        content,
+        body: ctx.Body,
+        bodyForAgent: ctx.BodyForAgent,
+        transcript: ctx.Transcript,
+        timestamp: typeof ctx.Timestamp === "number" && Number.isFinite(ctx.Timestamp)
+            ? ctx.Timestamp
+            : undefined,
+        channelId,
+        accountId: ctx.AccountId,
+        conversationId,
+        messageId: overrides?.messageId ??
+            ctx.MessageSidFull ??
+            ctx.MessageSid ??
+            ctx.MessageSidFirst ??
+            ctx.MessageSidLast,
+        senderId: ctx.SenderId,
+        senderName: ctx.SenderName,
+        senderUsername: ctx.SenderUsername,
+        senderE164: ctx.SenderE164,
+        provider: ctx.Provider,
+        surface: ctx.Surface,
+        threadId: ctx.MessageThreadId,
+        mediaPath: ctx.MediaPath,
+        mediaType: ctx.MediaType,
+        originatingChannel: ctx.OriginatingChannel,
+        originatingTo: ctx.OriginatingTo,
+        guildId: ctx.GroupSpace,
+        channelName: ctx.GroupChannel,
+        isGroup,
+        groupId: isGroup ? conversationId : undefined,
+    };
+}
+export function buildCanonicalSentMessageHookContext(params) {
+    return {
+        to: params.to,
+        content: params.content,
+        success: params.success,
+        error: params.error,
+        channelId: params.channelId,
+        accountId: params.accountId,
+        conversationId: params.conversationId ?? params.to,
+        messageId: params.messageId,
+        isGroup: params.isGroup,
+        groupId: params.groupId,
+    };
+}
+export function toPluginMessageContext(canonical) {
+    return {
+        channelId: canonical.channelId,
+        accountId: canonical.accountId,
+        conversationId: canonical.conversationId,
+    };
+}
+export function toPluginMessageReceivedEvent(canonical) {
+    return {
+        from: canonical.from,
+        content: canonical.content,
+        timestamp: canonical.timestamp,
+        metadata: {
+            to: canonical.to,
+            provider: canonical.provider,
+            surface: canonical.surface,
+            threadId: canonical.threadId,
+            originatingChannel: canonical.originatingChannel,
+            originatingTo: canonical.originatingTo,
+            messageId: canonical.messageId,
+            senderId: canonical.senderId,
+            senderName: canonical.senderName,
+            senderUsername: canonical.senderUsername,
+            senderE164: canonical.senderE164,
+            guildId: canonical.guildId,
+            channelName: canonical.channelName,
+        },
+    };
+}
+export function toPluginMessageSentEvent(canonical) {
+    return {
+        to: canonical.to,
+        content: canonical.content,
+        success: canonical.success,
+        ...(canonical.error ? { error: canonical.error } : {}),
+    };
+}
+export function toInternalMessageReceivedContext(canonical) {
+    return {
+        from: canonical.from,
+        content: canonical.content,
+        timestamp: canonical.timestamp,
+        channelId: canonical.channelId,
+        accountId: canonical.accountId,
+        conversationId: canonical.conversationId,
+        messageId: canonical.messageId,
+        metadata: {
+            to: canonical.to,
+            provider: canonical.provider,
+            surface: canonical.surface,
+            threadId: canonical.threadId,
+            senderId: canonical.senderId,
+            senderName: canonical.senderName,
+            senderUsername: canonical.senderUsername,
+            senderE164: canonical.senderE164,
+            guildId: canonical.guildId,
+            channelName: canonical.channelName,
+        },
+    };
+}
+export function toInternalMessageTranscribedContext(canonical, cfg) {
+    return {
+        from: canonical.from,
+        to: canonical.to,
+        body: canonical.body,
+        bodyForAgent: canonical.bodyForAgent,
+        transcript: canonical.transcript ?? "",
+        timestamp: canonical.timestamp,
+        channelId: canonical.channelId,
+        conversationId: canonical.conversationId,
+        messageId: canonical.messageId,
+        senderId: canonical.senderId,
+        senderName: canonical.senderName,
+        senderUsername: canonical.senderUsername,
+        provider: canonical.provider,
+        surface: canonical.surface,
+        mediaPath: canonical.mediaPath,
+        mediaType: canonical.mediaType,
+        cfg,
+    };
+}
+export function toInternalMessagePreprocessedContext(canonical, cfg) {
+    return {
+        from: canonical.from,
+        to: canonical.to,
+        body: canonical.body,
+        bodyForAgent: canonical.bodyForAgent,
+        transcript: canonical.transcript,
+        timestamp: canonical.timestamp,
+        channelId: canonical.channelId,
+        conversationId: canonical.conversationId,
+        messageId: canonical.messageId,
+        senderId: canonical.senderId,
+        senderName: canonical.senderName,
+        senderUsername: canonical.senderUsername,
+        provider: canonical.provider,
+        surface: canonical.surface,
+        mediaPath: canonical.mediaPath,
+        mediaType: canonical.mediaType,
+        isGroup: canonical.isGroup,
+        groupId: canonical.groupId,
+        cfg,
+    };
+}
+export function toInternalMessageSentContext(canonical) {
+    return {
+        to: canonical.to,
+        content: canonical.content,
+        success: canonical.success,
+        ...(canonical.error ? { error: canonical.error } : {}),
+        channelId: canonical.channelId,
+        accountId: canonical.accountId,
+        conversationId: canonical.conversationId,
+        messageId: canonical.messageId,
+        ...(canonical.isGroup != null ? { isGroup: canonical.isGroup } : {}),
+        ...(canonical.groupId ? { groupId: canonical.groupId } : {}),
+    };
+}

package/dist/infra/abort-signal.js

@@ -0,0 +1,12 @@
+export async function waitForAbortSignal(signal) {
+    if (!signal || signal.aborted) {
+        return;
+    }
+    await new Promise((resolve) => {
+        const onAbort = () => {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}

package/dist/infra/boundary-file-read.js

@@ -0,0 +1,118 @@
+import fs from "node:fs";
+import path from "node:path";
+import { resolveBoundaryPath, resolveBoundaryPathSync, } from "./boundary-path.js";
+import { openVerifiedFileSync, } from "./safe-open-sync.js";
+export function canUseBoundaryFileOpen(ioFs) {
+    return (typeof ioFs.openSync === "function" &&
+        typeof ioFs.closeSync === "function" &&
+        typeof ioFs.fstatSync === "function" &&
+        typeof ioFs.lstatSync === "function" &&
+        typeof ioFs.realpathSync === "function" &&
+        typeof ioFs.readFileSync === "function" &&
+        typeof ioFs.constants === "object" &&
+        ioFs.constants !== null);
+}
+export function openBoundaryFileSync(params) {
+    const ioFs = params.ioFs ?? fs;
+    const resolved = resolveBoundaryFilePathGeneric({
+        absolutePath: params.absolutePath,
+        resolve: (absolutePath) => resolveBoundaryPathSync({
+            absolutePath,
+            rootPath: params.rootPath,
+            rootCanonicalPath: params.rootRealPath,
+            boundaryLabel: params.boundaryLabel,
+            skipLexicalRootCheck: params.skipLexicalRootCheck,
+        }),
+    });
+    if (resolved instanceof Promise) {
+        return toBoundaryValidationError(new Error("Unexpected async boundary resolution"));
+    }
+    return finalizeBoundaryFileOpen({
+        resolved,
+        maxBytes: params.maxBytes,
+        rejectHardlinks: params.rejectHardlinks,
+        allowedType: params.allowedType,
+        ioFs,
+    });
+}
+function openBoundaryFileResolved(params) {
+    const opened = openVerifiedFileSync({
+        filePath: params.absolutePath,
+        resolvedPath: params.resolvedPath,
+        rejectHardlinks: params.rejectHardlinks ?? true,
+        maxBytes: params.maxBytes,
+        allowedType: params.allowedType,
+        ioFs: params.ioFs,
+    });
+    if (!opened.ok) {
+        return opened;
+    }
+    return {
+        ok: true,
+        path: opened.path,
+        fd: opened.fd,
+        stat: opened.stat,
+        rootRealPath: params.rootRealPath,
+    };
+}
+function finalizeBoundaryFileOpen(params) {
+    if ("ok" in params.resolved) {
+        return params.resolved;
+    }
+    return openBoundaryFileResolved({
+        absolutePath: params.resolved.absolutePath,
+        resolvedPath: params.resolved.resolvedPath,
+        rootRealPath: params.resolved.rootRealPath,
+        maxBytes: params.maxBytes,
+        rejectHardlinks: params.rejectHardlinks,
+        allowedType: params.allowedType,
+        ioFs: params.ioFs,
+    });
+}
+export async function openBoundaryFile(params) {
+    const ioFs = params.ioFs ?? fs;
+    const maybeResolved = resolveBoundaryFilePathGeneric({
+        absolutePath: params.absolutePath,
+        resolve: (absolutePath) => resolveBoundaryPath({
+            absolutePath,
+            rootPath: params.rootPath,
+            rootCanonicalPath: params.rootRealPath,
+            boundaryLabel: params.boundaryLabel,
+            policy: params.aliasPolicy,
+            skipLexicalRootCheck: params.skipLexicalRootCheck,
+        }),
+    });
+    const resolved = maybeResolved instanceof Promise ? await maybeResolved : maybeResolved;
+    return finalizeBoundaryFileOpen({
+        resolved,
+        maxBytes: params.maxBytes,
+        rejectHardlinks: params.rejectHardlinks,
+        allowedType: params.allowedType,
+        ioFs,
+    });
+}
+function toBoundaryValidationError(error) {
+    return { ok: false, reason: "validation", error };
+}
+function mapResolvedBoundaryPath(absolutePath, resolved) {
+    return {
+        absolutePath,
+        resolvedPath: resolved.canonicalPath,
+        rootRealPath: resolved.rootCanonicalPath,
+    };
+}
+function resolveBoundaryFilePathGeneric(params) {
+    const absolutePath = path.resolve(params.absolutePath);
+    try {
+        const resolved = params.resolve(absolutePath);
+        if (resolved instanceof Promise) {
+            return resolved
+                .then((value) => mapResolvedBoundaryPath(absolutePath, value))
+                .catch((error) => toBoundaryValidationError(error));
+        }
+        return mapResolvedBoundaryPath(absolutePath, resolved);
+    }
+    catch (error) {
+        return toBoundaryValidationError(error);
+    }
+}