@poolzin/pool-bot 2026.3.25 → 2026.3.26

package/dist/imessage/channel.js

@@ -0,0 +1,253 @@
+import { buildAccountScopedDmSecurityPolicy, collectAllowlistProviderRestrictSendersWarnings, } from "openclaw/plugin-sdk/compat";
+import { applyAccountNameToChannelSection, buildChannelConfigSchema, collectStatusIssuesFromLastError, DEFAULT_ACCOUNT_ID, deleteAccountFromConfigSection, formatTrimmedAllowFromEntries, getChatChannelMeta, imessageOnboardingAdapter, IMessageConfigSchema, listIMessageAccountIds, looksLikeIMessageTargetId, migrateBaseNameToDefaultAccount, normalizeAccountId, normalizeIMessageMessagingTarget, PAIRING_APPROVED_MESSAGE, resolveChannelMediaMaxBytes, resolveDefaultIMessageAccountId, resolveIMessageAccount, resolveIMessageConfigAllowFrom, resolveIMessageConfigDefaultTo, resolveIMessageGroupRequireMention, resolveIMessageGroupToolPolicy, setAccountEnabledInConfigSection, } from "openclaw/plugin-sdk/imessage";
+import { resolveOutboundSendDep } from "../../../src/infra/outbound/send-deps.js";
+import { buildPassiveProbedChannelStatusSummary } from "../../shared/channel-status-summary.js";
+import { getIMessageRuntime } from "./runtime.js";
+const meta = getChatChannelMeta("imessage");
+function buildIMessageSetupPatch(input) {
+    return {
+        ...(input.cliPath ? { cliPath: input.cliPath } : {}),
+        ...(input.dbPath ? { dbPath: input.dbPath } : {}),
+        ...(input.service ? { service: input.service } : {}),
+        ...(input.region ? { region: input.region } : {}),
+    };
+}
+async function sendIMessageOutbound(params) {
+    const send = resolveOutboundSendDep(params.deps, "imessage") ??
+        getIMessageRuntime().channel.imessage.sendMessageIMessage;
+    const maxBytes = resolveChannelMediaMaxBytes({
+        cfg: params.cfg,
+        resolveChannelLimitMb: ({ cfg, accountId }) => cfg.channels?.imessage?.accounts?.[accountId]?.mediaMaxMb ??
+            cfg.channels?.imessage?.mediaMaxMb,
+        accountId: params.accountId,
+    });
+    return await send(params.to, params.text, {
+        config: params.cfg,
+        ...(params.mediaUrl ? { mediaUrl: params.mediaUrl } : {}),
+        ...(params.mediaLocalRoots?.length ? { mediaLocalRoots: params.mediaLocalRoots } : {}),
+        maxBytes,
+        accountId: params.accountId ?? undefined,
+        replyToId: params.replyToId ?? undefined,
+    });
+}
+export const imessagePlugin = {
+    id: "imessage",
+    meta: {
+        ...meta,
+        aliases: ["imsg"],
+        showConfigured: false,
+    },
+    onboarding: imessageOnboardingAdapter,
+    pairing: {
+        idLabel: "imessageSenderId",
+        notifyApproval: async ({ id }) => {
+            await getIMessageRuntime().channel.imessage.sendMessageIMessage(id, PAIRING_APPROVED_MESSAGE);
+        },
+    },
+    capabilities: {
+        chatTypes: ["direct", "group"],
+        media: true,
+    },
+    reload: { configPrefixes: ["channels.imessage"] },
+    configSchema: buildChannelConfigSchema(IMessageConfigSchema),
+    config: {
+        listAccountIds: (cfg) => listIMessageAccountIds(cfg),
+        resolveAccount: (cfg, accountId) => resolveIMessageAccount({ cfg, accountId }),
+        defaultAccountId: (cfg) => resolveDefaultIMessageAccountId(cfg),
+        setAccountEnabled: ({ cfg, accountId, enabled }) => setAccountEnabledInConfigSection({
+            cfg,
+            sectionKey: "imessage",
+            accountId,
+            enabled,
+            allowTopLevel: true,
+        }),
+        deleteAccount: ({ cfg, accountId }) => deleteAccountFromConfigSection({
+            cfg,
+            sectionKey: "imessage",
+            accountId,
+            clearBaseFields: ["cliPath", "dbPath", "service", "region", "name"],
+        }),
+        isConfigured: (account) => account.configured,
+        describeAccount: (account) => ({
+            accountId: account.accountId,
+            name: account.name,
+            enabled: account.enabled,
+            configured: account.configured,
+        }),
+        resolveAllowFrom: ({ cfg, accountId }) => resolveIMessageConfigAllowFrom({ cfg, accountId }),
+        formatAllowFrom: ({ allowFrom }) => formatTrimmedAllowFromEntries(allowFrom),
+        resolveDefaultTo: ({ cfg, accountId }) => resolveIMessageConfigDefaultTo({ cfg, accountId }),
+    },
+    security: {
+        resolveDmPolicy: ({ cfg, accountId, account }) => {
+            return buildAccountScopedDmSecurityPolicy({
+                cfg,
+                channelKey: "imessage",
+                accountId,
+                fallbackAccountId: account.accountId ?? DEFAULT_ACCOUNT_ID,
+                policy: account.config.dmPolicy,
+                allowFrom: account.config.allowFrom ?? [],
+                policyPathSuffix: "dmPolicy",
+            });
+        },
+        collectWarnings: ({ account, cfg }) => {
+            return collectAllowlistProviderRestrictSendersWarnings({
+                cfg,
+                providerConfigPresent: cfg.channels?.imessage !== undefined,
+                configuredGroupPolicy: account.config.groupPolicy,
+                surface: "iMessage groups",
+                openScope: "any member",
+                groupPolicyPath: "channels.imessage.groupPolicy",
+                groupAllowFromPath: "channels.imessage.groupAllowFrom",
+                mentionGated: false,
+            });
+        },
+    },
+    groups: {
+        resolveRequireMention: resolveIMessageGroupRequireMention,
+        resolveToolPolicy: resolveIMessageGroupToolPolicy,
+    },
+    messaging: {
+        normalizeTarget: normalizeIMessageMessagingTarget,
+        targetResolver: {
+            looksLikeId: looksLikeIMessageTargetId,
+            hint: "<handle|chat_id:ID>",
+        },
+    },
+    setup: {
+        resolveAccountId: ({ accountId }) => normalizeAccountId(accountId),
+        applyAccountName: ({ cfg, accountId, name }) => applyAccountNameToChannelSection({
+            cfg,
+            channelKey: "imessage",
+            accountId,
+            name,
+        }),
+        applyAccountConfig: ({ cfg, accountId, input }) => {
+            const namedConfig = applyAccountNameToChannelSection({
+                cfg,
+                channelKey: "imessage",
+                accountId,
+                name: input.name,
+            });
+            const next = (accountId !== DEFAULT_ACCOUNT_ID
+                ? migrateBaseNameToDefaultAccount({
+                    cfg: namedConfig,
+                    channelKey: "imessage",
+                })
+                : namedConfig);
+            if (accountId === DEFAULT_ACCOUNT_ID) {
+                return {
+                    ...next,
+                    channels: {
+                        ...next.channels,
+                        imessage: {
+                            ...next.channels?.imessage,
+                            enabled: true,
+                            ...buildIMessageSetupPatch(input),
+                        },
+                    },
+                };
+            }
+            return {
+                ...next,
+                channels: {
+                    ...next.channels,
+                    imessage: {
+                        ...next.channels?.imessage,
+                        enabled: true,
+                        accounts: {
+                            ...next.channels?.imessage?.accounts,
+                            [accountId]: {
+                                ...next.channels?.imessage?.accounts?.[accountId],
+                                enabled: true,
+                                ...buildIMessageSetupPatch(input),
+                            },
+                        },
+                    },
+                },
+            };
+        },
+    },
+    outbound: {
+        deliveryMode: "direct",
+        chunker: (text, limit) => getIMessageRuntime().channel.text.chunkText(text, limit),
+        chunkerMode: "text",
+        textChunkLimit: 4000,
+        sendText: async ({ cfg, to, text, accountId, deps, replyToId }) => {
+            const result = await sendIMessageOutbound({
+                cfg,
+                to,
+                text,
+                accountId: accountId ?? undefined,
+                deps,
+                replyToId: replyToId ?? undefined,
+            });
+            return { channel: "imessage", ...result };
+        },
+        sendMedia: async ({ cfg, to, text, mediaUrl, mediaLocalRoots, accountId, deps, replyToId }) => {
+            const result = await sendIMessageOutbound({
+                cfg,
+                to,
+                text,
+                mediaUrl,
+                mediaLocalRoots,
+                accountId: accountId ?? undefined,
+                deps,
+                replyToId: replyToId ?? undefined,
+            });
+            return { channel: "imessage", ...result };
+        },
+    },
+    status: {
+        defaultRuntime: {
+            accountId: DEFAULT_ACCOUNT_ID,
+            running: false,
+            lastStartAt: null,
+            lastStopAt: null,
+            lastError: null,
+            cliPath: null,
+            dbPath: null,
+        },
+        collectStatusIssues: (accounts) => collectStatusIssuesFromLastError("imessage", accounts),
+        buildChannelSummary: ({ snapshot }) => buildPassiveProbedChannelStatusSummary(snapshot, {
+            cliPath: snapshot.cliPath ?? null,
+            dbPath: snapshot.dbPath ?? null,
+        }),
+        probeAccount: async ({ timeoutMs }) => getIMessageRuntime().channel.imessage.probeIMessage(timeoutMs),
+        buildAccountSnapshot: ({ account, runtime, probe }) => ({
+            accountId: account.accountId,
+            name: account.name,
+            enabled: account.enabled,
+            configured: account.configured,
+            running: runtime?.running ?? false,
+            lastStartAt: runtime?.lastStartAt ?? null,
+            lastStopAt: runtime?.lastStopAt ?? null,
+            lastError: runtime?.lastError ?? null,
+            cliPath: runtime?.cliPath ?? account.config.cliPath ?? null,
+            dbPath: runtime?.dbPath ?? account.config.dbPath ?? null,
+            probe,
+            lastInboundAt: runtime?.lastInboundAt ?? null,
+            lastOutboundAt: runtime?.lastOutboundAt ?? null,
+        }),
+        resolveAccountState: ({ enabled }) => (enabled ? "enabled" : "disabled"),
+    },
+    gateway: {
+        startAccount: async (ctx) => {
+            const account = ctx.account;
+            const cliPath = account.config.cliPath?.trim() || "imsg";
+            const dbPath = account.config.dbPath?.trim();
+            ctx.setStatus({
+                accountId: account.accountId,
+                cliPath,
+                dbPath: dbPath ?? null,
+            });
+            ctx.log?.info(`[${account.accountId}] starting provider (${cliPath}${dbPath ? ` db=${dbPath}` : ""})`);
+            return getIMessageRuntime().channel.imessage.monitorIMessageProvider({
+                accountId: account.accountId,
+                config: ctx.cfg,
+                runtime: ctx.runtime,
+                abortSignal: ctx.abortSignal,
+            });
+        },
+    },
+};

package/dist/imessage/monitor/echo-cache.js

@@ -0,0 +1,70 @@
+// Keep the text fallback short so repeated user replies like "ok" are not
+// suppressed for long; delayed reflections should match the stronger message-id key.
+const SENT_MESSAGE_TEXT_TTL_MS = 5_000;
+const SENT_MESSAGE_ID_TTL_MS = 60_000;
+function normalizeEchoTextKey(text) {
+    if (!text) {
+        return null;
+    }
+    const normalized = text.replace(/\r\n?/g, "\n").trim();
+    return normalized ? normalized : null;
+}
+function normalizeEchoMessageIdKey(messageId) {
+    if (!messageId) {
+        return null;
+    }
+    const normalized = messageId.trim();
+    if (!normalized || normalized === "ok" || normalized === "unknown") {
+        return null;
+    }
+    return normalized;
+}
+class DefaultSentMessageCache {
+    textCache = new Map();
+    messageIdCache = new Map();
+    remember(scope, lookup) {
+        const textKey = normalizeEchoTextKey(lookup.text);
+        if (textKey) {
+            this.textCache.set(`${scope}:${textKey}`, Date.now());
+        }
+        const messageIdKey = normalizeEchoMessageIdKey(lookup.messageId);
+        if (messageIdKey) {
+            this.messageIdCache.set(`${scope}:${messageIdKey}`, Date.now());
+        }
+        this.cleanup();
+    }
+    has(scope, lookup) {
+        this.cleanup();
+        const messageIdKey = normalizeEchoMessageIdKey(lookup.messageId);
+        if (messageIdKey) {
+            const idTimestamp = this.messageIdCache.get(`${scope}:${messageIdKey}`);
+            if (idTimestamp && Date.now() - idTimestamp <= SENT_MESSAGE_ID_TTL_MS) {
+                return true;
+            }
+        }
+        const textKey = normalizeEchoTextKey(lookup.text);
+        if (textKey) {
+            const textTimestamp = this.textCache.get(`${scope}:${textKey}`);
+            if (textTimestamp && Date.now() - textTimestamp <= SENT_MESSAGE_TEXT_TTL_MS) {
+                return true;
+            }
+        }
+        return false;
+    }
+    cleanup() {
+        const now = Date.now();
+        for (const [key, timestamp] of this.textCache.entries()) {
+            if (now - timestamp > SENT_MESSAGE_TEXT_TTL_MS) {
+                this.textCache.delete(key);
+            }
+        }
+        for (const [key, timestamp] of this.messageIdCache.entries()) {
+            if (now - timestamp > SENT_MESSAGE_ID_TTL_MS) {
+                this.messageIdCache.delete(key);
+            }
+        }
+    }
+}
+export function createSentMessageCache() {
+    return new DefaultSentMessageCache();
+}

package/dist/imessage/monitor/loop-rate-limiter.js

@@ -0,0 +1,51 @@
+/**
+ * Per-conversation rate limiter that detects rapid-fire identical echo
+ * patterns and suppresses them before they amplify into queue overflow.
+ */
+const DEFAULT_WINDOW_MS = 60_000;
+const DEFAULT_MAX_HITS = 5;
+const CLEANUP_INTERVAL_MS = 120_000;
+export function createLoopRateLimiter(opts) {
+    const windowMs = opts?.windowMs ?? DEFAULT_WINDOW_MS;
+    const maxHits = opts?.maxHits ?? DEFAULT_MAX_HITS;
+    const conversations = new Map();
+    let lastCleanup = Date.now();
+    function cleanup() {
+        const now = Date.now();
+        if (now - lastCleanup < CLEANUP_INTERVAL_MS) {
+            return;
+        }
+        lastCleanup = now;
+        for (const [key, win] of conversations.entries()) {
+            const recent = win.timestamps.filter((ts) => now - ts <= windowMs);
+            if (recent.length === 0) {
+                conversations.delete(key);
+            }
+            else {
+                win.timestamps = recent;
+            }
+        }
+    }
+    return {
+        record(conversationKey) {
+            cleanup();
+            let win = conversations.get(conversationKey);
+            if (!win) {
+                win = { timestamps: [] };
+                conversations.set(conversationKey, win);
+            }
+            win.timestamps.push(Date.now());
+        },
+        isRateLimited(conversationKey) {
+            cleanup();
+            const win = conversations.get(conversationKey);
+            if (!win) {
+                return false;
+            }
+            const now = Date.now();
+            const recent = win.timestamps.filter((ts) => now - ts <= windowMs);
+            win.timestamps = recent;
+            return recent.length >= maxHits;
+        },
+    };
+}

package/dist/imessage/monitor/reflection-guard.js

@@ -0,0 +1,50 @@
+/**
+ * Detects inbound messages that are reflections of assistant-originated content.
+ * These patterns indicate internal metadata leaked into a channel and then
+ * bounced back as a new inbound message — creating an echo loop.
+ */
+import { findCodeRegions, isInsideCode } from "../../../../src/shared/text/code-regions.js";
+const INTERNAL_SEPARATOR_RE = /(?:#\+){2,}#?/;
+const ASSISTANT_ROLE_MARKER_RE = /\bassistant\s+to\s*=\s*\w+/i;
+// Require closing `>` to avoid false-positives on phrases like "<thought experiment>".
+const THINKING_TAG_RE = /<\s*\/?\s*(?:think(?:ing)?|thought|antthinking)\b[^<>]*>/i;
+const RELEVANT_MEMORIES_TAG_RE = /<\s*\/?\s*relevant[-_]memories\b[^<>]*>/i;
+// Require closing `>` to avoid false-positives on phrases like "<final answer>".
+const FINAL_TAG_RE = /<\s*\/?\s*final\b[^<>]*>/i;
+const REFLECTION_PATTERNS = [
+    { re: INTERNAL_SEPARATOR_RE, label: "internal-separator" },
+    { re: ASSISTANT_ROLE_MARKER_RE, label: "assistant-role-marker" },
+    { re: THINKING_TAG_RE, label: "thinking-tag" },
+    { re: RELEVANT_MEMORIES_TAG_RE, label: "relevant-memories-tag" },
+    { re: FINAL_TAG_RE, label: "final-tag" },
+];
+function hasMatchOutsideCode(text, re) {
+    const codeRegions = findCodeRegions(text);
+    const globalRe = new RegExp(re.source, re.flags.includes("g") ? re.flags : `${re.flags}g`);
+    for (const match of text.matchAll(globalRe)) {
+        const start = match.index ?? -1;
+        if (start >= 0 && !isInsideCode(start, codeRegions)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Check whether an inbound message appears to be a reflection of
+ * assistant-originated content. Returns matched pattern labels for telemetry.
+ */
+export function detectReflectedContent(text) {
+    if (!text) {
+        return { isReflection: false, matchedLabels: [] };
+    }
+    const matchedLabels = [];
+    for (const { re, label } of REFLECTION_PATTERNS) {
+        if (hasMatchOutsideCode(text, re)) {
+            matchedLabels.push(label);
+        }
+    }
+    return {
+        isReflection: matchedLabels.length > 0,
+        matchedLabels,
+    };
+}

package/dist/imessage/monitor/sanitize-outbound.js

@@ -0,0 +1,25 @@
+import { stripAssistantInternalScaffolding } from "../../../../src/shared/text/assistant-visible-text.js";
+/**
+ * Patterns that indicate assistant-internal metadata leaked into text.
+ * These must never reach a user-facing channel.
+ */
+const INTERNAL_SEPARATOR_RE = /(?:#\+){2,}#?/g;
+const ASSISTANT_ROLE_MARKER_RE = /\bassistant\s+to\s*=\s*\w+/gi;
+const ROLE_TURN_MARKER_RE = /\b(?:user|system|assistant)\s*:\s*$/gm;
+/**
+ * Strip all assistant-internal scaffolding from outbound text before delivery.
+ * Applies reasoning/thinking tag removal, memory tag removal, and
+ * model-specific internal separator stripping.
+ */
+export function sanitizeOutboundText(text) {
+    if (!text) {
+        return text;
+    }
+    let cleaned = stripAssistantInternalScaffolding(text);
+    cleaned = cleaned.replace(INTERNAL_SEPARATOR_RE, "");
+    cleaned = cleaned.replace(ASSISTANT_ROLE_MARKER_RE, "");
+    cleaned = cleaned.replace(ROLE_TURN_MARKER_RE, "");
+    // Collapse excessive blank lines left after stripping.
+    cleaned = cleaned.replace(/\n{3,}/g, "\n\n").trim();
+    return cleaned;
+}

package/dist/imessage/monitor/self-chat-cache.js

@@ -0,0 +1,75 @@
+import { createHash } from "node:crypto";
+import { formatIMessageChatTarget } from "../targets.js";
+const SELF_CHAT_TTL_MS = 10_000;
+const MAX_SELF_CHAT_CACHE_ENTRIES = 512;
+const CLEANUP_MIN_INTERVAL_MS = 1_000;
+function normalizeText(text) {
+    if (!text) {
+        return null;
+    }
+    const normalized = text.replace(/\r\n?/g, "\n").trim();
+    return normalized ? normalized : null;
+}
+function isUsableTimestamp(createdAt) {
+    return typeof createdAt === "number" && Number.isFinite(createdAt);
+}
+function digestText(text) {
+    return createHash("sha256").update(text).digest("hex");
+}
+function buildScope(parts) {
+    if (!parts.isGroup) {
+        return `${parts.accountId}:imessage:${parts.sender}`;
+    }
+    const chatTarget = formatIMessageChatTarget(parts.chatId) || "chat_id:unknown";
+    return `${parts.accountId}:${chatTarget}:imessage:${parts.sender}`;
+}
+class DefaultSelfChatCache {
+    cache = new Map();
+    lastCleanupAt = 0;
+    buildKey(lookup) {
+        const text = normalizeText(lookup.text);
+        if (!text || !isUsableTimestamp(lookup.createdAt)) {
+            return null;
+        }
+        return `${buildScope(lookup)}:${lookup.createdAt}:${digestText(text)}`;
+    }
+    remember(lookup) {
+        const key = this.buildKey(lookup);
+        if (!key) {
+            return;
+        }
+        this.cache.set(key, Date.now());
+        this.maybeCleanup();
+    }
+    has(lookup) {
+        this.maybeCleanup();
+        const key = this.buildKey(lookup);
+        if (!key) {
+            return false;
+        }
+        const timestamp = this.cache.get(key);
+        return typeof timestamp === "number" && Date.now() - timestamp <= SELF_CHAT_TTL_MS;
+    }
+    maybeCleanup() {
+        const now = Date.now();
+        if (now - this.lastCleanupAt < CLEANUP_MIN_INTERVAL_MS) {
+            return;
+        }
+        this.lastCleanupAt = now;
+        for (const [key, timestamp] of this.cache.entries()) {
+            if (now - timestamp > SELF_CHAT_TTL_MS) {
+                this.cache.delete(key);
+            }
+        }
+        while (this.cache.size > MAX_SELF_CHAT_CACHE_ENTRIES) {
+            const oldestKey = this.cache.keys().next().value;
+            if (typeof oldestKey !== "string") {
+                break;
+            }
+            this.cache.delete(oldestKey);
+        }
+    }
+}
+export function createSelfChatCache() {
+    return new DefaultSelfChatCache();
+}

package/dist/imessage/runtime.js

@@ -0,0 +1,3 @@
+import { createPluginRuntimeStore } from "openclaw/plugin-sdk/compat";
+const { setRuntime: setIMessageRuntime, getRuntime: getIMessageRuntime } = createPluginRuntimeStore("iMessage runtime not initialized");
+export { getIMessageRuntime, setIMessageRuntime };

package/dist/infra/exec-approval-reply.js

@@ -0,0 +1,7 @@
+/**
+ * Stub for exec-approval-reply
+ * TODO: Implement proper exec approval reply
+ */
+export function formatExecApprovalReply(_params) {
+    return "Exec approval reply not implemented";
+}

package/dist/infra/tmp-openclaw-dir.js

@@ -0,0 +1,84 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export const POSIX_POOLBOT_TMP_DIR = "/tmp/poolbot";
+function isNodeErrorWithCode(err, code) {
+    return (typeof err === "object" &&
+        err !== null &&
+        "code" in err &&
+        err.code === code);
+}
+export function resolvePreferredPoolBotTmpDir(options = {}) {
+    const accessSync = options.accessSync ?? fs.accessSync;
+    const lstatSync = options.lstatSync ?? fs.lstatSync;
+    const mkdirSync = options.mkdirSync ?? fs.mkdirSync;
+    const getuid = options.getuid ??
+        (() => {
+            try {
+                return typeof process.getuid === "function" ? process.getuid() : undefined;
+            }
+            catch {
+                return undefined;
+            }
+        });
+    const tmpdir = options.tmpdir ?? os.tmpdir;
+    const uid = getuid();
+    const isSecureDirForUser = (st) => {
+        if (uid === undefined) {
+            return true;
+        }
+        if (typeof st.uid === "number" && st.uid !== uid) {
+            return false;
+        }
+        // Avoid group/other writable dirs when running on multi-user hosts.
+        if (typeof st.mode === "number" && (st.mode & 0o022) !== 0) {
+            return false;
+        }
+        return true;
+    };
+    const fallback = () => {
+        const base = tmpdir();
+        const suffix = uid === undefined ? "poolbot" : `poolbot-${uid}`;
+        return path.join(base, suffix);
+    };
+    const isTrustedPreferredDir = (st) => {
+        return st.isDirectory() && !st.isSymbolicLink() && isSecureDirForUser(st);
+    };
+    const resolvePreferredState = (requireWritableAccess) => {
+        try {
+            const preferred = lstatSync(POSIX_POOLBOT_TMP_DIR);
+            if (!isTrustedPreferredDir(preferred)) {
+                return "invalid";
+            }
+            if (requireWritableAccess) {
+                accessSync(POSIX_POOLBOT_TMP_DIR, fs.constants.W_OK | fs.constants.X_OK);
+            }
+            return "available";
+        }
+        catch (err) {
+            if (isNodeErrorWithCode(err, "ENOENT")) {
+                return "missing";
+            }
+            return "invalid";
+        }
+    };
+    const existingPreferredState = resolvePreferredState(true);
+    if (existingPreferredState === "available") {
+        return POSIX_POOLBOT_TMP_DIR;
+    }
+    if (existingPreferredState === "invalid") {
+        return fallback();
+    }
+    try {
+        accessSync("/tmp", fs.constants.W_OK | fs.constants.X_OK);
+        // Create with a safe default; subsequent callers expect it exists.
+        mkdirSync(POSIX_POOLBOT_TMP_DIR, { recursive: true, mode: 0o700 });
+        if (resolvePreferredState(true) !== "available") {
+            return fallback();
+        }
+        return POSIX_POOLBOT_TMP_DIR;
+    }
+    catch {
+        return fallback();
+    }
+}

package/dist/pairing/pairing-challenge.js

@@ -0,0 +1,15 @@
+/**
+ * Pairing challenge utilities for channel authorization.
+ */
+function generateRandomCode() {
+    // Generate a 6-digit random code using Math.random
+    return Math.floor(100000 + Math.random() * 900000).toString();
+}
+export async function issuePairingChallenge(_params) {
+    const code = generateRandomCode();
+    const expiresAt = new Date(Date.now() + 10 * 60 * 1000); // 10 minutes
+    return {
+        code,
+        expiresAt,
+    };
+}

package/dist/plugin-sdk/account-id.d.ts

@@ -0,0 +1 @@
+export { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "../routing/session-key.js";

package/dist/plugin-sdk/agent-media-payload.d.ts

@@ -0,0 +1,12 @@
+export type AgentMediaPayload = {
+    MediaPath?: string;
+    MediaType?: string;
+    MediaUrl?: string;
+    MediaPaths?: string[];
+    MediaUrls?: string[];
+    MediaTypes?: string[];
+};
+export declare function buildAgentMediaPayload(mediaList: Array<{
+    path: string;
+    contentType?: string | null;
+}>): AgentMediaPayload;

package/dist/plugin-sdk/allow-from.d.ts

@@ -0,0 +1,27 @@
+export declare function formatAllowFromLowercase(params: {
+    allowFrom: Array<string | number>;
+    stripPrefixRe?: RegExp;
+}): string[];
+type ParsedChatAllowTarget = {
+    kind: "chat_id";
+    chatId: number;
+} | {
+    kind: "chat_guid";
+    chatGuid: string;
+} | {
+    kind: "chat_identifier";
+    chatIdentifier: string;
+} | {
+    kind: "handle";
+    handle: string;
+};
+export declare function isAllowedParsedChatSender<TParsed extends ParsedChatAllowTarget>(params: {
+    allowFrom: Array<string | number>;
+    sender: string;
+    chatId?: number | null;
+    chatGuid?: string | null;
+    chatIdentifier?: string | null;
+    normalizeSender: (sender: string) => string;
+    parseAllowTarget: (entry: string) => TParsed;
+}): boolean;
+export {};