@poolzin/pool-bot 2026.3.25 → 2026.3.27

package/dist/auto-reply/auto-reply/reply/commands-setunset-standard.js

@@ -0,0 +1,13 @@
+import { parseSlashCommandWithSetUnset } from "./commands-setunset.js";
+export function parseStandardSetUnsetSlashCommand(params) {
+    return parseSlashCommandWithSetUnset({
+        raw: params.raw,
+        slash: params.slash,
+        invalidMessage: params.invalidMessage,
+        usageMessage: params.usageMessage,
+        onKnownAction: params.onKnownAction,
+        onSet: params.onSet ?? ((path, value) => ({ action: "set", path, value })),
+        onUnset: params.onUnset ?? ((path) => ({ action: "unset", path })),
+        onError: params.onError ?? ((message) => ({ action: "error", message })),
+    });
+}

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

@@ -0,0 +1,73 @@
+import { parseSlashCommandOrNull } from "./commands-slash-parse.js";
+import { parseConfigValue } from "./config-value.js";
+export function parseSetUnsetCommand(params) {
+    const action = params.action;
+    const args = params.args.trim();
+    if (action === "unset") {
+        if (!args) {
+            return { kind: "error", message: `Usage: ${params.slash} unset path` };
+        }
+        return { kind: "unset", path: args };
+    }
+    if (!args) {
+        return { kind: "error", message: `Usage: ${params.slash} set path=value` };
+    }
+    const eqIndex = args.indexOf("=");
+    if (eqIndex <= 0) {
+        return { kind: "error", message: `Usage: ${params.slash} set path=value` };
+    }
+    const path = args.slice(0, eqIndex).trim();
+    const rawValue = args.slice(eqIndex + 1);
+    if (!path) {
+        return { kind: "error", message: `Usage: ${params.slash} set path=value` };
+    }
+    const parsed = parseConfigValue(rawValue);
+    if (parsed.error) {
+        return { kind: "error", message: parsed.error };
+    }
+    return { kind: "set", path, value: parsed.value };
+}
+export function parseSetUnsetCommandAction(params) {
+    if (params.action !== "set" && params.action !== "unset") {
+        return null;
+    }
+    const parsed = parseSetUnsetCommand({
+        slash: params.slash,
+        action: params.action,
+        args: params.args,
+    });
+    if (parsed.kind === "error") {
+        return params.onError(parsed.message);
+    }
+    return parsed.kind === "set"
+        ? params.onSet(parsed.path, parsed.value)
+        : params.onUnset(parsed.path);
+}
+export function parseSlashCommandWithSetUnset(params) {
+    const parsed = parseSlashCommandOrNull(params.raw, params.slash, {
+        invalidMessage: params.invalidMessage,
+    });
+    if (!parsed) {
+        return null;
+    }
+    if (!parsed.ok) {
+        return params.onError(parsed.message);
+    }
+    const { action, args } = parsed;
+    const setUnset = parseSetUnsetCommandAction({
+        slash: params.slash,
+        action,
+        args,
+        onSet: params.onSet,
+        onUnset: params.onUnset,
+        onError: params.onError,
+    });
+    if (setUnset) {
+        return setUnset;
+    }
+    const knownAction = params.onKnownAction(action, args);
+    if (knownAction) {
+        return knownAction;
+    }
+    return params.onError(params.usageMessage);
+}

package/dist/auto-reply/auto-reply/reply/commands-slash-parse.js

@@ -0,0 +1,31 @@
+export function parseSlashCommandActionArgs(raw, slash) {
+    const trimmed = raw.trim();
+    const slashLower = slash.toLowerCase();
+    if (!trimmed.toLowerCase().startsWith(slashLower)) {
+        return { kind: "no-match" };
+    }
+    const rest = trimmed.slice(slash.length).trim();
+    if (!rest) {
+        return { kind: "empty" };
+    }
+    const match = rest.match(/^(\S+)(?:\s+([\s\S]+))?$/);
+    if (!match) {
+        return { kind: "invalid" };
+    }
+    const action = match[1]?.toLowerCase() ?? "";
+    const args = (match[2] ?? "").trim();
+    return { kind: "parsed", action, args };
+}
+export function parseSlashCommandOrNull(raw, slash, opts) {
+    const parsed = parseSlashCommandActionArgs(raw, slash);
+    if (parsed.kind === "no-match") {
+        return null;
+    }
+    if (parsed.kind === "invalid") {
+        return { ok: false, message: opts.invalidMessage };
+    }
+    if (parsed.kind === "empty") {
+        return { ok: true, action: opts.defaultAction ?? "show", args: "" };
+    }
+    return { ok: true, action: parsed.action, args: parsed.args };
+}

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

@@ -0,0 +1,178 @@
+import { resolveAgentDir, resolveDefaultAgentId, resolveSessionAgentId, } from "../../agents/agent-scope.js";
+import { listSubagentRunsForRequester } from "../../agents/subagent-registry.js";
+import { ensureAuthProfileStore, resolveAuthProfileDisplayLabel, resolveAuthProfileOrder, } from "../../agents/auth-profiles.js";
+import { getCustomProviderApiKey, resolveEnvApiKey } from "../../agents/model-auth.js";
+import { resolveInternalSessionKey, resolveMainSessionAlias, } from "../../agents/tools/sessions-helpers.js";
+import { normalizeProviderId } from "../../agents/model-selection.js";
+import { logVerbose } from "../../globals.js";
+import { formatUsageWindowSummary, loadProviderUsageSummary, resolveUsageProviderId, } from "../../infra/provider-usage.js";
+import { normalizeGroupActivation } from "../group-activation.js";
+import { buildStatusMessage } from "../status.js";
+import { getFollowupQueueDepth, resolveQueueSettings } from "./queue.js";
+import { resolveSubagentLabel } from "./subagents-utils.js";
+function formatApiKeySnippet(apiKey) {
+    const compact = apiKey.replace(/\s+/g, "");
+    if (!compact)
+        return "unknown";
+    const edge = compact.length >= 12 ? 6 : 4;
+    const head = compact.slice(0, edge);
+    const tail = compact.slice(-edge);
+    return `${head}…${tail}`;
+}
+function resolveModelAuthLabel(provider, cfg, sessionEntry, agentDir) {
+    const resolved = provider?.trim();
+    if (!resolved)
+        return undefined;
+    const providerKey = normalizeProviderId(resolved);
+    const store = ensureAuthProfileStore(agentDir, {
+        allowKeychainPrompt: false,
+    });
+    const profileOverride = sessionEntry?.authProfileOverride?.trim();
+    const order = resolveAuthProfileOrder({
+        cfg,
+        store,
+        provider: providerKey,
+        preferredProfile: profileOverride,
+    });
+    const candidates = [profileOverride, ...order].filter(Boolean);
+    for (const profileId of candidates) {
+        const profile = store.profiles[profileId];
+        if (!profile || normalizeProviderId(profile.provider) !== providerKey) {
+            continue;
+        }
+        const label = resolveAuthProfileDisplayLabel({ cfg, store, profileId });
+        if (profile.type === "oauth") {
+            return `oauth${label ? ` (${label})` : ""}`;
+        }
+        if (profile.type === "token") {
+            const snippet = formatApiKeySnippet(profile.token);
+            return `token ${snippet}${label ? ` (${label})` : ""}`;
+        }
+        const snippet = formatApiKeySnippet(profile.key);
+        return `api-key ${snippet}${label ? ` (${label})` : ""}`;
+    }
+    const envKey = resolveEnvApiKey(providerKey);
+    if (envKey?.apiKey) {
+        if (envKey.source.includes("OAUTH_TOKEN")) {
+            return `oauth (${envKey.source})`;
+        }
+        return `api-key ${formatApiKeySnippet(envKey.apiKey)} (${envKey.source})`;
+    }
+    const customKey = getCustomProviderApiKey(cfg, providerKey);
+    if (customKey) {
+        return `api-key ${formatApiKeySnippet(customKey)} (models.json)`;
+    }
+    return "unknown";
+}
+export async function buildStatusReply(params) {
+    const { cfg, command, sessionEntry, sessionKey, sessionScope, provider, model, contextTokens, resolvedThinkLevel, resolvedVerboseLevel, resolvedReasoningLevel, resolvedElevatedLevel, resolveDefaultThinkingLevel, isGroup, defaultGroupActivation, } = params;
+    if (!command.isAuthorizedSender) {
+        logVerbose(`Ignoring /status from unauthorized sender: ${command.senderId || "<unknown>"}`);
+        return undefined;
+    }
+    const statusAgentId = sessionKey
+        ? resolveSessionAgentId({ sessionKey, config: cfg })
+        : resolveDefaultAgentId(cfg);
+    const statusAgentDir = resolveAgentDir(cfg, statusAgentId);
+    const currentUsageProvider = (() => {
+        try {
+            return resolveUsageProviderId(provider);
+        }
+        catch {
+            return undefined;
+        }
+    })();
+    let usageLine = null;
+    if (currentUsageProvider) {
+        try {
+            const usageSummary = await loadProviderUsageSummary({
+                timeoutMs: 3500,
+                providers: [currentUsageProvider],
+                agentDir: statusAgentDir,
+            });
+            const usageEntry = usageSummary.providers[0];
+            if (usageEntry && !usageEntry.error && usageEntry.windows.length > 0) {
+                const summaryLine = formatUsageWindowSummary(usageEntry, {
+                    now: Date.now(),
+                    maxWindows: 2,
+                    includeResets: true,
+                });
+                if (summaryLine)
+                    usageLine = `📊 Usage: ${summaryLine}`;
+            }
+        }
+        catch {
+            usageLine = null;
+        }
+    }
+    const queueSettings = resolveQueueSettings({
+        cfg,
+        channel: command.channel,
+        sessionEntry,
+    });
+    const queueKey = sessionKey ?? sessionEntry?.sessionId;
+    const queueDepth = queueKey ? getFollowupQueueDepth(queueKey) : 0;
+    const queueOverrides = Boolean(sessionEntry?.queueDebounceMs ?? sessionEntry?.queueCap ?? sessionEntry?.queueDrop);
+    let subagentsLine;
+    if (sessionKey) {
+        const { mainKey, alias } = resolveMainSessionAlias(cfg);
+        const requesterKey = resolveInternalSessionKey({ key: sessionKey, alias, mainKey });
+        const runs = listSubagentRunsForRequester(requesterKey);
+        const verboseEnabled = resolvedVerboseLevel && resolvedVerboseLevel !== "off";
+        if (runs.length > 0) {
+            const active = runs.filter((entry) => !entry.endedAt);
+            const done = runs.length - active.length;
+            if (verboseEnabled) {
+                const labels = active
+                    .map((entry) => resolveSubagentLabel(entry, ""))
+                    .filter(Boolean)
+                    .slice(0, 3);
+                const labelText = labels.length ? ` (${labels.join(", ")})` : "";
+                subagentsLine = `🤖 Subagents: ${active.length} active${labelText} · ${done} done`;
+            }
+            else if (active.length > 0) {
+                subagentsLine = `🤖 Subagents: ${active.length} active`;
+            }
+        }
+    }
+    const groupActivation = isGroup
+        ? (normalizeGroupActivation(sessionEntry?.groupActivation) ?? defaultGroupActivation())
+        : undefined;
+    const agentDefaults = cfg.agents?.defaults ?? {};
+    const statusText = buildStatusMessage({
+        config: cfg,
+        agent: {
+            ...agentDefaults,
+            model: {
+                ...agentDefaults.model,
+                primary: `${provider}/${model}`,
+            },
+            contextTokens,
+            thinkingDefault: agentDefaults.thinkingDefault,
+            verboseDefault: agentDefaults.verboseDefault,
+            elevatedDefault: agentDefaults.elevatedDefault,
+        },
+        sessionEntry,
+        sessionKey,
+        sessionScope,
+        groupActivation,
+        resolvedThink: resolvedThinkLevel ?? (await resolveDefaultThinkingLevel()),
+        resolvedVerbose: resolvedVerboseLevel,
+        resolvedReasoning: resolvedReasoningLevel,
+        resolvedElevated: resolvedElevatedLevel,
+        modelAuth: resolveModelAuthLabel(provider, cfg, sessionEntry, statusAgentDir),
+        usageLine: usageLine ?? undefined,
+        queue: {
+            mode: queueSettings.mode,
+            depth: queueDepth,
+            debounceMs: queueSettings.debounceMs,
+            cap: queueSettings.cap,
+            dropPolicy: queueSettings.dropPolicy,
+            showDetails: queueOverrides,
+        },
+        subagentsLine,
+        mediaDecisions: params.mediaDecisions,
+        includeTranscriptUsage: false,
+    });
+    return { text: statusText };
+}

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

@@ -0,0 +1,73 @@
+import { listSubagentRunsForRequester } from "../../agents/subagent-registry.js";
+import { logVerbose } from "../../globals.js";
+import { handleSubagentsAgentsAction } from "./commands-subagents/action-agents.js";
+import { handleSubagentsFocusAction } from "./commands-subagents/action-focus.js";
+import { handleSubagentsHelpAction } from "./commands-subagents/action-help.js";
+import { handleSubagentsInfoAction } from "./commands-subagents/action-info.js";
+import { handleSubagentsKillAction } from "./commands-subagents/action-kill.js";
+import { handleSubagentsListAction } from "./commands-subagents/action-list.js";
+import { handleSubagentsLogAction } from "./commands-subagents/action-log.js";
+import { handleSubagentsSendAction } from "./commands-subagents/action-send.js";
+import { handleSubagentsSpawnAction } from "./commands-subagents/action-spawn.js";
+import { handleSubagentsUnfocusAction } from "./commands-subagents/action-unfocus.js";
+import { extractMessageText, resolveHandledPrefix, resolveRequesterSessionKey, resolveSubagentsAction, stopWithText, } from "./commands-subagents/shared.js";
+export { extractMessageText };
+export const handleSubagentsCommand = async (params, allowTextCommands) => {
+    if (!allowTextCommands) {
+        return null;
+    }
+    const normalized = params.command.commandBodyNormalized;
+    const handledPrefix = resolveHandledPrefix(normalized);
+    if (!handledPrefix) {
+        return null;
+    }
+    if (!params.command.isAuthorizedSender) {
+        logVerbose(`Ignoring ${handledPrefix} from unauthorized sender: ${params.command.senderId || "<unknown>"}`);
+        return { shouldContinue: false };
+    }
+    const rest = normalized.slice(handledPrefix.length).trim();
+    const restTokens = rest.split(/\s+/).filter(Boolean);
+    const action = resolveSubagentsAction({ handledPrefix, restTokens });
+    if (!action) {
+        return handleSubagentsHelpAction();
+    }
+    const requesterKey = resolveRequesterSessionKey(params, {
+        preferCommandTarget: action === "spawn",
+    });
+    if (!requesterKey) {
+        return stopWithText("⚠️ Missing session key.");
+    }
+    const ctx = {
+        params,
+        handledPrefix,
+        requesterKey,
+        runs: listSubagentRunsForRequester(requesterKey),
+        restTokens,
+    };
+    switch (action) {
+        case "help":
+            return handleSubagentsHelpAction();
+        case "agents":
+            return handleSubagentsAgentsAction(ctx);
+        case "focus":
+            return await handleSubagentsFocusAction(ctx);
+        case "unfocus":
+            return handleSubagentsUnfocusAction(ctx);
+        case "list":
+            return handleSubagentsListAction(ctx);
+        case "kill":
+            return await handleSubagentsKillAction(ctx);
+        case "info":
+            return handleSubagentsInfoAction(ctx);
+        case "log":
+            return await handleSubagentsLogAction(ctx);
+        case "send":
+            return await handleSubagentsSendAction(ctx, false);
+        case "steer":
+            return await handleSubagentsSendAction(ctx, true);
+        case "spawn":
+            return await handleSubagentsSpawnAction(ctx);
+        default:
+            return handleSubagentsHelpAction();
+    }
+};

package/dist/auto-reply/auto-reply/reply/commands-system-prompt.js

@@ -0,0 +1,117 @@
+import { resolveSessionAgentIds } from "../../agents/agent-scope.js";
+import { resolveBootstrapContextForRun } from "../../agents/bootstrap-files.js";
+import { resolveDefaultModelForAgent } from "../../agents/model-selection.js";
+import { createPoolbotCodingTools } from "../../agents/pi-tools.js";
+import { resolveSandboxRuntimeStatus } from "../../agents/sandbox.js";
+import { buildWorkspaceSkillSnapshot } from "../../agents/skills.js";
+import { getSkillsSnapshotVersion } from "../../agents/skills/refresh.js";
+import { buildSystemPromptParams } from "../../agents/system-prompt-params.js";
+import { buildAgentSystemPrompt } from "../../agents/system-prompt.js";
+import { buildToolSummaryMap } from "../../agents/tool-summaries.js";
+import { getRemoteSkillEligibility } from "../../infra/skills-remote.js";
+import { buildTtsSystemPromptHint } from "../../tts/tts.js";
+export async function resolveCommandsSystemPromptBundle(params) {
+    const workspaceDir = params.workspaceDir;
+    const { bootstrapFiles, contextFiles: injectedFiles } = await resolveBootstrapContextForRun({
+        workspaceDir,
+        config: params.cfg,
+        sessionKey: params.sessionKey,
+        sessionId: params.sessionEntry?.sessionId,
+    });
+    const skillsSnapshot = (() => {
+        try {
+            return buildWorkspaceSkillSnapshot(workspaceDir, {
+                config: params.cfg,
+                eligibility: { remote: getRemoteSkillEligibility() },
+                snapshotVersion: getSkillsSnapshotVersion(workspaceDir),
+            });
+        }
+        catch {
+            return { prompt: "", skills: [], resolvedSkills: [] };
+        }
+    })();
+    const skillsPrompt = skillsSnapshot.prompt ?? "";
+    const sandboxRuntime = resolveSandboxRuntimeStatus({
+        cfg: params.cfg,
+        sessionKey: params.ctx.SessionKey ?? params.sessionKey,
+    });
+    const tools = (() => {
+        try {
+            return createPoolbotCodingTools({
+                config: params.cfg,
+                workspaceDir,
+                sessionKey: params.sessionKey,
+                messageProvider: params.command.channel,
+                groupId: params.sessionEntry?.groupId ?? undefined,
+                groupChannel: params.sessionEntry?.groupChannel ?? undefined,
+                groupSpace: params.sessionEntry?.space ?? undefined,
+                spawnedBy: params.sessionEntry?.spawnedBy ?? undefined,
+                senderIsOwner: params.command.senderIsOwner,
+                modelProvider: params.provider,
+                modelId: params.model,
+            });
+        }
+        catch {
+            return [];
+        }
+    })();
+    const toolSummaries = buildToolSummaryMap(tools);
+    const toolNames = tools.map((t) => t.name);
+    const { sessionAgentId } = resolveSessionAgentIds({
+        sessionKey: params.sessionKey,
+        config: params.cfg,
+    });
+    const defaultModelRef = resolveDefaultModelForAgent({
+        cfg: params.cfg,
+        agentId: sessionAgentId,
+    });
+    const defaultModelLabel = `${defaultModelRef.provider}/${defaultModelRef.model}`;
+    const { runtimeInfo, userTimezone, userTime, userTimeFormat } = buildSystemPromptParams({
+        config: params.cfg,
+        agentId: sessionAgentId,
+        workspaceDir,
+        cwd: process.cwd(),
+        runtime: {
+            host: "unknown",
+            os: "unknown",
+            arch: "unknown",
+            node: process.version,
+            model: `${params.provider}/${params.model}`,
+            defaultModel: defaultModelLabel,
+        },
+    });
+    const sandboxInfo = sandboxRuntime.sandboxed
+        ? {
+            enabled: true,
+            workspaceDir,
+            workspaceAccess: "rw",
+            elevated: {
+                allowed: params.elevated.allowed,
+                defaultLevel: (params.resolvedElevatedLevel ?? "off"),
+            },
+        }
+        : { enabled: false };
+    const ttsHint = params.cfg ? buildTtsSystemPromptHint(params.cfg) : undefined;
+    const systemPrompt = buildAgentSystemPrompt({
+        workspaceDir,
+        defaultThinkLevel: params.resolvedThinkLevel,
+        reasoningLevel: params.resolvedReasoningLevel,
+        extraSystemPrompt: undefined,
+        ownerNumbers: undefined,
+        reasoningTagHint: false,
+        toolNames,
+        toolSummaries,
+        modelAliasLines: [],
+        userTimezone,
+        userTime,
+        userTimeFormat,
+        contextFiles: injectedFiles,
+        skillsPrompt,
+        heartbeatPrompt: undefined,
+        ttsHint,
+        runtimeInfo,
+        sandboxInfo,
+        memoryCitationsMode: params.cfg?.memory?.citations,
+    });
+    return { systemPrompt, tools, skillsPrompt, bootstrapFiles, injectedFiles, sandboxRuntime };
+}