@poolzin/pool-bot 2026.3.25 → 2026.3.27

package/dist/auto-reply/auto-reply/reply/block-streaming.js

@@ -0,0 +1,91 @@
+import { getChannelDock } from "../../channels/dock.js";
+import { normalizeChannelId } from "../../channels/plugins/index.js";
+import { normalizeAccountId } from "../../routing/session-key.js";
+import { INTERNAL_MESSAGE_CHANNEL, listDeliverableMessageChannels, } from "../../utils/message-channel.js";
+import { resolveTextChunkLimit } from "../chunk.js";
+const DEFAULT_BLOCK_STREAM_MIN = 800;
+const DEFAULT_BLOCK_STREAM_MAX = 1200;
+const DEFAULT_BLOCK_STREAM_COALESCE_IDLE_MS = 1000;
+const getBlockChunkProviders = () => new Set([...listDeliverableMessageChannels(), INTERNAL_MESSAGE_CHANNEL]);
+function normalizeChunkProvider(provider) {
+    if (!provider)
+        return undefined;
+    const cleaned = provider.trim().toLowerCase();
+    return getBlockChunkProviders().has(cleaned)
+        ? cleaned
+        : undefined;
+}
+function resolveProviderBlockStreamingCoalesce(params) {
+    const { cfg, providerKey, accountId } = params;
+    if (!cfg || !providerKey)
+        return undefined;
+    const providerCfg = cfg[providerKey];
+    if (!providerCfg || typeof providerCfg !== "object")
+        return undefined;
+    const normalizedAccountId = normalizeAccountId(accountId);
+    const typed = providerCfg;
+    const accountCfg = typed.accounts?.[normalizedAccountId];
+    return accountCfg?.blockStreamingCoalesce ?? typed.blockStreamingCoalesce;
+}
+export function resolveBlockStreamingChunking(cfg, provider, accountId) {
+    const providerKey = normalizeChunkProvider(provider);
+    const providerId = providerKey ? normalizeChannelId(providerKey) : null;
+    const providerChunkLimit = providerId
+        ? getChannelDock(providerId)?.outbound?.textChunkLimit
+        : undefined;
+    const textLimit = resolveTextChunkLimit(cfg, providerKey, accountId, {
+        fallbackLimit: providerChunkLimit,
+    });
+    const chunkCfg = cfg?.agents?.defaults?.blockStreamingChunk;
+    // Note: chunkMode="newline" used to imply splitting on each newline, but outbound
+    // delivery now treats it as paragraph-aware chunking (only split on blank lines).
+    // Block streaming should follow the same rule, so we do NOT special-case newline
+    // mode here.
+    // (chunkMode no longer alters block streaming behavior)
+    const maxRequested = Math.max(1, Math.floor(chunkCfg?.maxChars ?? DEFAULT_BLOCK_STREAM_MAX));
+    const maxChars = Math.max(1, Math.min(maxRequested, textLimit));
+    const minFallback = DEFAULT_BLOCK_STREAM_MIN;
+    const minRequested = Math.max(1, Math.floor(chunkCfg?.minChars ?? minFallback));
+    const minChars = Math.min(minRequested, maxChars);
+    const breakPreference = chunkCfg?.breakPreference === "newline" || chunkCfg?.breakPreference === "sentence"
+        ? chunkCfg.breakPreference
+        : "paragraph";
+    return { minChars, maxChars, breakPreference };
+}
+export function resolveBlockStreamingCoalescing(cfg, provider, accountId, chunking) {
+    const providerKey = normalizeChunkProvider(provider);
+    // Note: chunkMode="newline" is paragraph-aware in outbound delivery (blank-line splits),
+    // so block streaming should not disable coalescing or flush per single newline.
+    const providerId = providerKey ? normalizeChannelId(providerKey) : null;
+    const providerChunkLimit = providerId
+        ? getChannelDock(providerId)?.outbound?.textChunkLimit
+        : undefined;
+    const textLimit = resolveTextChunkLimit(cfg, providerKey, accountId, {
+        fallbackLimit: providerChunkLimit,
+    });
+    const providerDefaults = providerId
+        ? getChannelDock(providerId)?.streaming?.blockStreamingCoalesceDefaults
+        : undefined;
+    const providerCfg = resolveProviderBlockStreamingCoalesce({
+        cfg,
+        providerKey,
+        accountId,
+    });
+    const coalesceCfg = providerCfg ?? cfg?.agents?.defaults?.blockStreamingCoalesce;
+    const minRequested = Math.max(1, Math.floor(coalesceCfg?.minChars ??
+        providerDefaults?.minChars ??
+        chunking?.minChars ??
+        DEFAULT_BLOCK_STREAM_MIN));
+    const maxRequested = Math.max(1, Math.floor(coalesceCfg?.maxChars ?? textLimit));
+    const maxChars = Math.max(1, Math.min(maxRequested, textLimit));
+    const minChars = Math.min(minRequested, maxChars);
+    const idleMs = Math.max(0, Math.floor(coalesceCfg?.idleMs ?? providerDefaults?.idleMs ?? DEFAULT_BLOCK_STREAM_COALESCE_IDLE_MS));
+    const preference = chunking?.breakPreference ?? "paragraph";
+    const joiner = preference === "sentence" ? " " : preference === "newline" ? "\n" : "\n\n";
+    return {
+        minChars,
+        maxChars,
+        idleMs,
+        joiner,
+    };
+}

package/dist/auto-reply/auto-reply/reply/commands-approve.js

@@ -0,0 +1,88 @@
+import { callGateway } from "../../gateway/call.js";
+import { GATEWAY_CLIENT_MODES, GATEWAY_CLIENT_NAMES } from "../../utils/message-channel.js";
+import { logVerbose } from "../../globals.js";
+const COMMAND = "/approve";
+const DECISION_ALIASES = {
+    allow: "allow-once",
+    once: "allow-once",
+    "allow-once": "allow-once",
+    allowonce: "allow-once",
+    always: "allow-always",
+    "allow-always": "allow-always",
+    allowalways: "allow-always",
+    deny: "deny",
+    reject: "deny",
+    block: "deny",
+};
+function parseApproveCommand(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed.toLowerCase().startsWith(COMMAND))
+        return null;
+    const rest = trimmed.slice(COMMAND.length).trim();
+    if (!rest) {
+        return { ok: false, error: "Usage: /approve <id> allow-once|allow-always|deny" };
+    }
+    const tokens = rest.split(/\s+/).filter(Boolean);
+    if (tokens.length < 2) {
+        return { ok: false, error: "Usage: /approve <id> allow-once|allow-always|deny" };
+    }
+    const first = tokens[0].toLowerCase();
+    const second = tokens[1].toLowerCase();
+    if (DECISION_ALIASES[first]) {
+        return {
+            ok: true,
+            decision: DECISION_ALIASES[first],
+            id: tokens.slice(1).join(" ").trim(),
+        };
+    }
+    if (DECISION_ALIASES[second]) {
+        return {
+            ok: true,
+            decision: DECISION_ALIASES[second],
+            id: tokens[0],
+        };
+    }
+    return { ok: false, error: "Usage: /approve <id> allow-once|allow-always|deny" };
+}
+function buildResolvedByLabel(params) {
+    const channel = params.command.channel;
+    const sender = params.command.senderId ?? "unknown";
+    return `${channel}:${sender}`;
+}
+export const handleApproveCommand = async (params, allowTextCommands) => {
+    if (!allowTextCommands)
+        return null;
+    const normalized = params.command.commandBodyNormalized;
+    const parsed = parseApproveCommand(normalized);
+    if (!parsed)
+        return null;
+    if (!params.command.isAuthorizedSender) {
+        logVerbose(`Ignoring /approve from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
+        return { shouldContinue: false };
+    }
+    if (!parsed.ok) {
+        return { shouldContinue: false, reply: { text: parsed.error } };
+    }
+    const resolvedBy = buildResolvedByLabel(params);
+    try {
+        await callGateway({
+            method: "exec.approval.resolve",
+            params: { id: parsed.id, decision: parsed.decision },
+            clientName: GATEWAY_CLIENT_NAMES.GATEWAY_CLIENT,
+            clientDisplayName: `Chat approval (${resolvedBy})`,
+            mode: GATEWAY_CLIENT_MODES.BACKEND,
+        });
+    }
+    catch (err) {
+        return {
+            shouldContinue: false,
+            reply: {
+                text: `❌ Failed to submit approval: ${String(err)}`,
+            },
+        };
+    }
+    return {
+        shouldContinue: false,
+        reply: { text: `✅ Exec approval ${parsed.decision} submitted for ${parsed.id}.` },
+    };
+};

package/dist/auto-reply/auto-reply/reply/commands-bash.js

@@ -0,0 +1,26 @@
+import { handleBashChatCommand } from "./bash-command.js";
+import { rejectUnauthorizedCommand } from "./command-gates.js";
+export const handleBashCommand = async (params, allowTextCommands) => {
+    if (!allowTextCommands) {
+        return null;
+    }
+    const { command } = params;
+    const bashSlashRequested = command.commandBodyNormalized === "/bash" || command.commandBodyNormalized.startsWith("/bash ");
+    const bashBangRequested = command.commandBodyNormalized.startsWith("!");
+    if (!bashSlashRequested && !(bashBangRequested && command.isAuthorizedSender)) {
+        return null;
+    }
+    const unauthorized = rejectUnauthorizedCommand(params, "/bash");
+    if (unauthorized) {
+        return unauthorized;
+    }
+    const reply = await handleBashChatCommand({
+        ctx: params.ctx,
+        cfg: params.cfg,
+        agentId: params.agentId,
+        sessionKey: params.sessionKey,
+        isGroup: params.isGroup,
+        elevated: params.elevated,
+    });
+    return { shouldContinue: false, reply };
+};

package/dist/auto-reply/auto-reply/reply/commands-compact.js

@@ -0,0 +1,107 @@
+import { abortEmbeddedPiRun, compactEmbeddedPiSession, isEmbeddedPiRunActive, waitForEmbeddedPiRunEnd, } from "../../agents/pi-embedded.js";
+import { resolveSessionFilePath } from "../../config/sessions.js";
+import { logVerbose } from "../../globals.js";
+import { enqueueSystemEvent } from "../../infra/system-events.js";
+import { formatContextUsageShort, formatTokenCount } from "../status.js";
+import { stripMentions, stripStructuralPrefixes } from "./mentions.js";
+import { incrementCompactionCount } from "./session-updates.js";
+function extractCompactInstructions(params) {
+    const raw = stripStructuralPrefixes(params.rawBody ?? "");
+    const stripped = params.isGroup
+        ? stripMentions(raw, params.ctx, params.cfg, params.agentId)
+        : raw;
+    const trimmed = stripped.trim();
+    if (!trimmed)
+        return undefined;
+    const lowered = trimmed.toLowerCase();
+    const prefix = lowered.startsWith("/compact") ? "/compact" : null;
+    if (!prefix)
+        return undefined;
+    let rest = trimmed.slice(prefix.length).trimStart();
+    if (rest.startsWith(":"))
+        rest = rest.slice(1).trimStart();
+    return rest.length ? rest : undefined;
+}
+export const handleCompactCommand = async (params) => {
+    const compactRequested = params.command.commandBodyNormalized === "/compact" ||
+        params.command.commandBodyNormalized.startsWith("/compact ");
+    if (!compactRequested)
+        return null;
+    if (!params.command.isAuthorizedSender) {
+        logVerbose(`Ignoring /compact from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
+        return { shouldContinue: false };
+    }
+    if (!params.sessionEntry?.sessionId) {
+        return {
+            shouldContinue: false,
+            reply: { text: "⚙️ Compaction unavailable (missing session id)." },
+        };
+    }
+    const sessionId = params.sessionEntry.sessionId;
+    if (isEmbeddedPiRunActive(sessionId)) {
+        abortEmbeddedPiRun(sessionId);
+        await waitForEmbeddedPiRunEnd(sessionId, 15_000);
+    }
+    const customInstructions = extractCompactInstructions({
+        rawBody: params.ctx.CommandBody ?? params.ctx.RawBody ?? params.ctx.Body,
+        ctx: params.ctx,
+        cfg: params.cfg,
+        agentId: params.agentId,
+        isGroup: params.isGroup,
+    });
+    const result = await compactEmbeddedPiSession({
+        sessionId,
+        sessionKey: params.sessionKey,
+        messageChannel: params.command.channel,
+        groupId: params.sessionEntry.groupId,
+        groupChannel: params.sessionEntry.groupChannel,
+        groupSpace: params.sessionEntry.space,
+        spawnedBy: params.sessionEntry.spawnedBy,
+        sessionFile: resolveSessionFilePath(sessionId, params.sessionEntry),
+        workspaceDir: params.workspaceDir,
+        config: params.cfg,
+        skillsSnapshot: params.sessionEntry.skillsSnapshot,
+        provider: params.provider,
+        model: params.model,
+        thinkLevel: params.resolvedThinkLevel ?? (await params.resolveDefaultThinkingLevel()),
+        bashElevated: {
+            enabled: false,
+            allowed: false,
+            defaultLevel: "off",
+        },
+        customInstructions,
+        senderIsOwner: params.command.senderIsOwner,
+        ownerNumbers: params.command.ownerList.length > 0 ? params.command.ownerList : undefined,
+    });
+    const compactLabel = result.ok
+        ? result.compacted
+            ? result.result?.tokensBefore != null && result.result?.tokensAfter != null
+                ? `Compacted (${formatTokenCount(result.result.tokensBefore)} → ${formatTokenCount(result.result.tokensAfter)})`
+                : result.result?.tokensBefore
+                    ? `Compacted (${formatTokenCount(result.result.tokensBefore)} before)`
+                    : "Compacted"
+            : "Compaction skipped"
+        : "Compaction failed";
+    if (result.ok && result.compacted) {
+        await incrementCompactionCount({
+            sessionEntry: params.sessionEntry,
+            sessionStore: params.sessionStore,
+            sessionKey: params.sessionKey,
+            storePath: params.storePath,
+            // Update token counts after compaction
+            tokensAfter: result.result?.tokensAfter,
+        });
+    }
+    // Use the post-compaction token count for context summary if available
+    const tokensAfterCompaction = result.result?.tokensAfter;
+    const totalTokens = tokensAfterCompaction ??
+        params.sessionEntry.totalTokens ??
+        (params.sessionEntry.inputTokens ?? 0) + (params.sessionEntry.outputTokens ?? 0);
+    const contextSummary = formatContextUsageShort(totalTokens > 0 ? totalTokens : null, params.contextTokens ?? params.sessionEntry.contextTokens ?? null);
+    const reason = result.reason?.trim();
+    const line = reason
+        ? `${compactLabel}: ${reason} • ${contextSummary}`
+        : `${compactLabel} • ${contextSummary}`;
+    enqueueSystemEvent(line, { sessionKey: params.sessionKey });
+    return { shouldContinue: false, reply: { text: `⚙️ ${line}` } };
+};

package/dist/auto-reply/auto-reply/reply/commands-config.js

@@ -0,0 +1,241 @@
+import { resolveChannelConfigWrites } from "../../channels/plugins/config-writes.js";
+import { normalizeChannelId } from "../../channels/registry.js";
+import { getConfigValueAtPath, parseConfigPath, setConfigValueAtPath, unsetConfigValueAtPath, } from "../../config/config-paths.js";
+import { readConfigFileSnapshot, validateConfigObjectWithPlugins, writeConfigFile, } from "../../config/config.js";
+import { getConfigOverrides, resetConfigOverrides, setConfigOverride, unsetConfigOverride, } from "../../config/runtime-overrides.js";
+import { rejectUnauthorizedCommand, requireCommandFlagEnabled } from "./command-gates.js";
+import { parseConfigCommand } from "./config-commands.js";
+import { parseDebugCommand } from "./debug-commands.js";
+export const handleConfigCommand = async (params, allowTextCommands) => {
+    if (!allowTextCommands) {
+        return null;
+    }
+    const configCommand = parseConfigCommand(params.command.commandBodyNormalized);
+    if (!configCommand) {
+        return null;
+    }
+    const unauthorized = rejectUnauthorizedCommand(params, "/config");
+    if (unauthorized) {
+        return unauthorized;
+    }
+    const disabled = requireCommandFlagEnabled(params.cfg, {
+        label: "/config",
+        configKey: "config",
+    });
+    if (disabled) {
+        return disabled;
+    }
+    if (configCommand.action === "error") {
+        return {
+            shouldContinue: false,
+            reply: { text: `⚠️ ${configCommand.message}` },
+        };
+    }
+    if (configCommand.action === "set" || configCommand.action === "unset") {
+        const channelId = params.command.channelId ?? normalizeChannelId(params.command.channel);
+        const allowWrites = resolveChannelConfigWrites({
+            cfg: params.cfg,
+            channelId,
+            accountId: params.ctx.AccountId,
+        });
+        if (!allowWrites) {
+            const channelLabel = channelId ?? "this channel";
+            const hint = channelId
+                ? `channels.${channelId}.configWrites=true`
+                : "channels.<channel>.configWrites=true";
+            return {
+                shouldContinue: false,
+                reply: {
+                    text: `⚠️ Config writes are disabled for ${channelLabel}. Set ${hint} to enable.`,
+                },
+            };
+        }
+    }
+    const snapshot = await readConfigFileSnapshot();
+    if (!snapshot.valid || !snapshot.parsed || typeof snapshot.parsed !== "object") {
+        return {
+            shouldContinue: false,
+            reply: {
+                text: "⚠️ Config file is invalid; fix it before using /config.",
+            },
+        };
+    }
+    const parsedBase = structuredClone(snapshot.parsed);
+    if (configCommand.action === "show") {
+        const pathRaw = configCommand.path?.trim();
+        if (pathRaw) {
+            const parsedPath = parseConfigPath(pathRaw);
+            if (!parsedPath.ok || !parsedPath.path) {
+                return {
+                    shouldContinue: false,
+                    reply: { text: `⚠️ ${parsedPath.error ?? "Invalid path."}` },
+                };
+            }
+            const value = getConfigValueAtPath(parsedBase, parsedPath.path);
+            const rendered = JSON.stringify(value ?? null, null, 2);
+            return {
+                shouldContinue: false,
+                reply: {
+                    text: `⚙️ Config ${pathRaw}:\n\`\`\`json\n${rendered}\n\`\`\``,
+                },
+            };
+        }
+        const json = JSON.stringify(parsedBase, null, 2);
+        return {
+            shouldContinue: false,
+            reply: { text: `⚙️ Config (raw):\n\`\`\`json\n${json}\n\`\`\`` },
+        };
+    }
+    if (configCommand.action === "unset") {
+        const parsedPath = parseConfigPath(configCommand.path);
+        if (!parsedPath.ok || !parsedPath.path) {
+            return {
+                shouldContinue: false,
+                reply: { text: `⚠️ ${parsedPath.error ?? "Invalid path."}` },
+            };
+        }
+        const removed = unsetConfigValueAtPath(parsedBase, parsedPath.path);
+        if (!removed) {
+            return {
+                shouldContinue: false,
+                reply: { text: `⚙️ No config value found for ${configCommand.path}.` },
+            };
+        }
+        const validated = validateConfigObjectWithPlugins(parsedBase);
+        if (!validated.ok) {
+            const issue = validated.issues[0];
+            return {
+                shouldContinue: false,
+                reply: {
+                    text: `⚠️ Config invalid after unset (${issue.path}: ${issue.message}).`,
+                },
+            };
+        }
+        await writeConfigFile(validated.config);
+        return {
+            shouldContinue: false,
+            reply: { text: `⚙️ Config updated: ${configCommand.path} removed.` },
+        };
+    }
+    if (configCommand.action === "set") {
+        const parsedPath = parseConfigPath(configCommand.path);
+        if (!parsedPath.ok || !parsedPath.path) {
+            return {
+                shouldContinue: false,
+                reply: { text: `⚠️ ${parsedPath.error ?? "Invalid path."}` },
+            };
+        }
+        setConfigValueAtPath(parsedBase, parsedPath.path, configCommand.value);
+        const validated = validateConfigObjectWithPlugins(parsedBase);
+        if (!validated.ok) {
+            const issue = validated.issues[0];
+            return {
+                shouldContinue: false,
+                reply: {
+                    text: `⚠️ Config invalid after set (${issue.path}: ${issue.message}).`,
+                },
+            };
+        }
+        await writeConfigFile(validated.config);
+        const valueLabel = typeof configCommand.value === "string"
+            ? `"${configCommand.value}"`
+            : JSON.stringify(configCommand.value);
+        return {
+            shouldContinue: false,
+            reply: {
+                text: `⚙️ Config updated: ${configCommand.path}=${valueLabel ?? "null"}`,
+            },
+        };
+    }
+    return null;
+};
+export const handleDebugCommand = async (params, allowTextCommands) => {
+    if (!allowTextCommands) {
+        return null;
+    }
+    const debugCommand = parseDebugCommand(params.command.commandBodyNormalized);
+    if (!debugCommand) {
+        return null;
+    }
+    const unauthorized = rejectUnauthorizedCommand(params, "/debug");
+    if (unauthorized) {
+        return unauthorized;
+    }
+    const disabled = requireCommandFlagEnabled(params.cfg, {
+        label: "/debug",
+        configKey: "debug",
+    });
+    if (disabled) {
+        return disabled;
+    }
+    if (debugCommand.action === "error") {
+        return {
+            shouldContinue: false,
+            reply: { text: `⚠️ ${debugCommand.message}` },
+        };
+    }
+    if (debugCommand.action === "show") {
+        const overrides = getConfigOverrides();
+        const hasOverrides = Object.keys(overrides).length > 0;
+        if (!hasOverrides) {
+            return {
+                shouldContinue: false,
+                reply: { text: "⚙️ Debug overrides: (none)" },
+            };
+        }
+        const json = JSON.stringify(overrides, null, 2);
+        return {
+            shouldContinue: false,
+            reply: {
+                text: `⚙️ Debug overrides (memory-only):\n\`\`\`json\n${json}\n\`\`\``,
+            },
+        };
+    }
+    if (debugCommand.action === "reset") {
+        resetConfigOverrides();
+        return {
+            shouldContinue: false,
+            reply: { text: "⚙️ Debug overrides cleared; using config on disk." },
+        };
+    }
+    if (debugCommand.action === "unset") {
+        const result = unsetConfigOverride(debugCommand.path);
+        if (!result.ok) {
+            return {
+                shouldContinue: false,
+                reply: { text: `⚠️ ${result.error ?? "Invalid path."}` },
+            };
+        }
+        if (!result.removed) {
+            return {
+                shouldContinue: false,
+                reply: {
+                    text: `⚙️ No debug override found for ${debugCommand.path}.`,
+                },
+            };
+        }
+        return {
+            shouldContinue: false,
+            reply: { text: `⚙️ Debug override removed for ${debugCommand.path}.` },
+        };
+    }
+    if (debugCommand.action === "set") {
+        const result = setConfigOverride(debugCommand.path, debugCommand.value);
+        if (!result.ok) {
+            return {
+                shouldContinue: false,
+                reply: { text: `⚠️ ${result.error ?? "Invalid override."}` },
+            };
+        }
+        const valueLabel = typeof debugCommand.value === "string"
+            ? `"${debugCommand.value}"`
+            : JSON.stringify(debugCommand.value);
+        return {
+            shouldContinue: false,
+            reply: {
+                text: `⚙️ Debug override set: ${debugCommand.path}=${valueLabel ?? "null"}`,
+            },
+        };
+    }
+    return null;
+};