@poolzin/pool-bot 2026.2.6 → 2026.2.8

package/dist/process/command-queue.js

@@ -1,26 +1,48 @@
 import { diagnosticLogger as diag, logLaneDequeue, logLaneEnqueue } from "../logging/diagnostic.js";
+/**
+ * Dedicated error type thrown when a queued command is rejected because
+ * its lane was cleared.  Callers that fire-and-forget enqueued tasks can
+ * catch (or ignore) this specific type to avoid unhandled-rejection noise.
+ */
+export class CommandLaneClearedError extends Error {
+    constructor(lane) {
+        super(lane ? `Command lane "${lane}" cleared` : "Command lane cleared");
+        this.name = "CommandLaneClearedError";
+    }
+}
 const lanes = new Map();
+let nextTaskId = 1;
 function getLaneState(lane) {
     const existing = lanes.get(lane);
-    if (existing)
+    if (existing) {
         return existing;
+    }
     const created = {
         lane,
         queue: [],
-        active: 0,
+        activeTaskIds: new Set(),
         maxConcurrent: 1,
         draining: false,
+        generation: 0,
     };
     lanes.set(lane, created);
     return created;
 }
+function completeTask(state, taskId, taskGeneration) {
+    if (taskGeneration !== state.generation) {
+        return false;
+    }
+    state.activeTaskIds.delete(taskId);
+    return true;
+}
 function drainLane(lane) {
     const state = getLaneState(lane);
-    if (state.draining)
+    if (state.draining) {
         return;
+    }
     state.draining = true;
     const pump = () => {
-        while (state.active < state.maxConcurrent && state.queue.length > 0) {
+        while (state.activeTaskIds.size < state.maxConcurrent && state.queue.length > 0) {
             const entry = state.queue.shift();
             const waitedMs = Date.now() - entry.enqueuedAt;
             if (waitedMs >= entry.warnAfterMs) {
@@ -28,23 +50,29 @@ function drainLane(lane) {
                 diag.warn(`lane wait exceeded: lane=${lane} waitedMs=${waitedMs} queueAhead=${state.queue.length}`);
             }
             logLaneDequeue(lane, waitedMs, state.queue.length);
-            state.active += 1;
+            const taskId = nextTaskId++;
+            const taskGeneration = state.generation;
+            state.activeTaskIds.add(taskId);
             void (async () => {
                 const startTime = Date.now();
                 try {
                     const result = await entry.task();
-                    state.active -= 1;
-                    diag.debug(`lane task done: lane=${lane} durationMs=${Date.now() - startTime} active=${state.active} queued=${state.queue.length}`);
-                    pump();
+                    const completedCurrentGeneration = completeTask(state, taskId, taskGeneration);
+                    if (completedCurrentGeneration) {
+                        diag.debug(`lane task done: lane=${lane} durationMs=${Date.now() - startTime} active=${state.activeTaskIds.size} queued=${state.queue.length}`);
+                        pump();
+                    }
                     entry.resolve(result);
                 }
                 catch (err) {
-                    state.active -= 1;
+                    const completedCurrentGeneration = completeTask(state, taskId, taskGeneration);
                     const isProbeLane = lane.startsWith("auth-probe:") || lane.startsWith("session:probe-");
                     if (!isProbeLane) {
                         diag.error(`lane task error: lane=${lane} durationMs=${Date.now() - startTime} error="${String(err)}"`);
                     }
-                    pump();
+                    if (completedCurrentGeneration) {
+                        pump();
+                    }
                     entry.reject(err);
                 }
             })();
@@ -72,7 +100,7 @@ export function enqueueCommandInLane(lane, task, opts) {
             warnAfterMs,
             onWait: opts?.onWait,
         });
-        logLaneEnqueue(cleaned, state.queue.length + state.active);
+        logLaneEnqueue(cleaned, state.queue.length + state.activeTaskIds.size);
         drainLane(cleaned);
     });
 }
@@ -82,23 +110,117 @@ export function enqueueCommand(task, opts) {
 export function getQueueSize(lane = "main" /* CommandLane.Main */) {
     const resolved = lane.trim() || "main" /* CommandLane.Main */;
     const state = lanes.get(resolved);
-    if (!state)
+    if (!state) {
         return 0;
-    return state.queue.length + state.active;
+    }
+    return state.queue.length + state.activeTaskIds.size;
 }
 export function getTotalQueueSize() {
     let total = 0;
     for (const s of lanes.values()) {
-        total += s.queue.length + s.active;
+        total += s.queue.length + s.activeTaskIds.size;
     }
     return total;
 }
 export function clearCommandLane(lane = "main" /* CommandLane.Main */) {
     const cleaned = lane.trim() || "main" /* CommandLane.Main */;
     const state = lanes.get(cleaned);
-    if (!state)
+    if (!state) {
         return 0;
+    }
     const removed = state.queue.length;
-    state.queue.length = 0;
+    const pending = state.queue.splice(0);
+    for (const entry of pending) {
+        entry.reject(new CommandLaneClearedError(cleaned));
+    }
     return removed;
 }
+/**
+ * Reset all lane runtime state to idle. Used after SIGUSR1 in-process
+ * restarts where interrupted tasks' finally blocks may not run, leaving
+ * stale active task IDs that permanently block new work from draining.
+ *
+ * Bumps lane generation and clears execution counters so stale completions
+ * from old in-flight tasks are ignored. Queued entries are intentionally
+ * preserved — they represent pending user work that should still execute
+ * after restart.
+ *
+ * After resetting, drains any lanes that still have queued entries so
+ * preserved work is pumped immediately rather than waiting for a future
+ * `enqueueCommandInLane()` call (which may never come).
+ */
+export function resetAllLanes() {
+    const lanesToDrain = [];
+    for (const state of lanes.values()) {
+        state.generation += 1;
+        state.activeTaskIds.clear();
+        state.draining = false;
+        if (state.queue.length > 0) {
+            lanesToDrain.push(state.lane);
+        }
+    }
+    // Drain after the full reset pass so all lanes are in a clean state first.
+    for (const lane of lanesToDrain) {
+        drainLane(lane);
+    }
+}
+/**
+ * Returns the total number of actively executing tasks across all lanes
+ * (excludes queued-but-not-started entries).
+ */
+export function getActiveTaskCount() {
+    let total = 0;
+    for (const s of lanes.values()) {
+        total += s.activeTaskIds.size;
+    }
+    return total;
+}
+/**
+ * Wait for all currently active tasks across all lanes to finish.
+ * Polls at a short interval; resolves when no tasks are active or
+ * when `timeoutMs` elapses (whichever comes first).
+ *
+ * New tasks enqueued after this call are ignored — only tasks that are
+ * already executing are waited on.
+ */
+export function waitForActiveTasks(timeoutMs) {
+    // Keep shutdown/drain checks responsive without busy looping.
+    const POLL_INTERVAL_MS = 50;
+    const deadline = Date.now() + timeoutMs;
+    const activeAtStart = new Set();
+    for (const state of lanes.values()) {
+        for (const taskId of state.activeTaskIds) {
+            activeAtStart.add(taskId);
+        }
+    }
+    return new Promise((resolve) => {
+        const check = () => {
+            if (activeAtStart.size === 0) {
+                resolve({ drained: true });
+                return;
+            }
+            let hasPending = false;
+            for (const state of lanes.values()) {
+                for (const taskId of state.activeTaskIds) {
+                    if (activeAtStart.has(taskId)) {
+                        hasPending = true;
+                        break;
+                    }
+                }
+                if (hasPending) {
+                    break;
+                }
+            }
+            if (!hasPending) {
+                resolve({ drained: true });
+                return;
+            }
+            if (Date.now() >= deadline) {
+                resolve({ drained: false });
+                return;
+            }
+            setTimeout(check, POLL_INTERVAL_MS);
+        };
+        check();
+    });
+}

package/dist/process/restart-recovery.js

@@ -0,0 +1,16 @@
+/**
+ * Returns an iteration hook for in-process restart loops.
+ * The first call is considered initial startup and does nothing.
+ * Each subsequent call represents a restart iteration and invokes `onRestart`.
+ */
+export function createRestartIterationHook(onRestart) {
+    let isFirstIteration = true;
+    return () => {
+        if (isFirstIteration) {
+            isFirstIteration = false;
+            return false;
+        }
+        onRestart();
+        return true;
+    };
+}

package/dist/security/dangerous-tools.js

@@ -0,0 +1,34 @@
+// Shared tool-risk constants.
+// Keep these centralized so gateway HTTP restrictions, security audits, and ACP prompts don't drift.
+/**
+ * Tools denied via Gateway HTTP `POST /tools/invoke` by default.
+ * These are high-risk because they enable session orchestration, control-plane actions,
+ * or interactive flows that don't make sense over a non-interactive HTTP surface.
+ */
+export const DEFAULT_GATEWAY_HTTP_TOOL_DENY = [
+    // Session orchestration — spawning agents remotely is RCE
+    "sessions_spawn",
+    // Cross-session injection — message injection across sessions
+    "sessions_send",
+    // Gateway control plane — prevents gateway reconfiguration via HTTP
+    "gateway",
+    // Interactive setup — requires terminal QR scan, hangs on HTTP
+    "whatsapp_login",
+];
+/**
+ * ACP tools that should always require explicit user approval.
+ * ACP is an automation surface; we never want "silent yes" for mutating/execution tools.
+ */
+export const DANGEROUS_ACP_TOOL_NAMES = [
+    "exec",
+    "spawn",
+    "shell",
+    "sessions_spawn",
+    "sessions_send",
+    "gateway",
+    "fs_write",
+    "fs_delete",
+    "fs_move",
+    "apply_patch",
+];
+export const DANGEROUS_ACP_TOOLS = new Set(DANGEROUS_ACP_TOOL_NAMES);

package/dist/security/secret-equal.js

@@ -0,0 +1,12 @@
+import { timingSafeEqual } from "node:crypto";
+export function safeEqualSecret(provided, expected) {
+    if (typeof provided !== "string" || typeof expected !== "string") {
+        return false;
+    }
+    const providedBuffer = Buffer.from(provided);
+    const expectedBuffer = Buffer.from(expected);
+    if (providedBuffer.length !== expectedBuffer.length) {
+        return false;
+    }
+    return timingSafeEqual(providedBuffer, expectedBuffer);
+}

package/dist/tui/components/filterable-select-list.js

@@ -1,4 +1,4 @@
-import { Input, matchesKey, SelectList, getEditorKeybindings, } from "@mariozechner/pi-tui";
+import { Input, matchesKey, SelectList, getEditorKeybindings, truncateToWidth, } from "@mariozechner/pi-tui";
 import chalk from "chalk";
 import { fuzzyFilterLower, prepareSearchItems } from "./fuzzy-filter.js";
 /**
@@ -46,7 +46,10 @@ export class FilterableSelectList {
         // Select list
         const listLines = this.selectList.render(width);
         lines.push(...listLines);
-        return lines;
+        // Defensive truncation: ensure no line exceeds the target width after
+        // all ANSI formatting. Prevents pi-tui compositeLineAt crash on
+        // ANSI-heavy backgrounds ("Rendered line N exceeds terminal width").
+        return lines.map((line) => truncateToWidth(line, width));
     }
     handleInput(keyData) {
         const allowVimNav = !this.filterText.trim();

package/dist/tui/components/searchable-select-list.js

@@ -149,7 +149,12 @@ export class SearchableSelectList {
             const scrollInfo = `${this.selectedIndex + 1}/${this.filteredItems.length}`;
             lines.push(this.theme.scrollInfo(`  ${scrollInfo}`));
         }
-        return lines;
+        // Defensive truncation: ensure no line exceeds the target width after
+        // all ANSI formatting has been applied. pi-tui's compositeLineAt can
+        // miscalculate visible widths on ANSI-heavy lines, causing a crash
+        // ("Rendered line N exceeds terminal width"). Truncating here is a
+        // safe final guard that prevents the crash.
+        return lines.map((line) => truncateToWidth(line, width));
     }
     renderItemLine(item, isSelected, width, query) {
         const prefix = isSelected ? "→ " : "  ";

package/dist/tui/tui-command-handlers.js

@@ -1,3 +1,4 @@
+import { truncateToWidth } from "@mariozechner/pi-tui";
 import { formatThinkingLevels, normalizeUsageDisplay, resolveResponseUsageMode, } from "../auto-reply/thinking.js";
 import { normalizeAgentId } from "../routing/session-key.js";
 import { formatRelativeTime } from "../utils/time-format.js";
@@ -10,6 +11,10 @@ export function createCommandHandlers(context) {
         state.currentAgentId = normalizeAgentId(id);
         await setSession("");
     };
+    // Maximum visible width for overlay item strings. The overlay has its own
+    // padding/chrome (~4 chars). We subtract a generous margin so that even
+    // after ANSI formatting, lines stay within terminal bounds.
+    const overlayItemWidth = () => Math.max(30, (tui.terminal.columns ?? 80) - 6);
     const openModelSelector = async () => {
         try {
             const models = await client.listModels();
@@ -18,10 +23,11 @@ export function createCommandHandlers(context) {
                 tui.requestRender();
                 return;
             }
+            const maxW = overlayItemWidth();
             const items = models.map((model) => ({
                 value: `${model.provider}/${model.id}`,
-                label: `${model.provider}/${model.id}`,
-                description: model.name && model.name !== model.id ? model.name : "",
+                label: truncateToWidth(`${model.provider}/${model.id}`, maxW),
+                description: model.name && model.name !== model.id ? truncateToWidth(model.name, maxW) : "",
             }));
             const selector = createSearchableSelectList(items, 9);
             selector.onSelect = (item) => {
@@ -60,9 +66,10 @@ export function createCommandHandlers(context) {
             tui.requestRender();
             return;
         }
+        const maxW = overlayItemWidth();
         const items = state.agents.map((agent) => ({
             value: agent.id,
-            label: agent.name ? `${agent.id} (${agent.name})` : agent.id,
+            label: truncateToWidth(agent.name ? `${agent.id} (${agent.name})` : agent.id, maxW),
             description: agent.id === state.agentDefaultId ? "default" : "",
         }));
         const selector = createSearchableSelectList(items, 9);
@@ -89,6 +96,7 @@ export function createCommandHandlers(context) {
                 includeLastMessage: true,
                 agentId: state.currentAgentId,
             });
+            const maxW = overlayItemWidth();
             const items = result.sessions.map((session) => {
                 const title = session.derivedTitle ?? session.displayName;
                 const formattedKey = formatSessionKey(session.key);
@@ -100,8 +108,8 @@ export function createCommandHandlers(context) {
                 const description = timePart && preview ? `${timePart} · ${preview}` : (preview ?? timePart);
                 return {
                     value: session.key,
-                    label,
-                    description,
+                    label: truncateToWidth(label, maxW),
+                    description: truncateToWidth(description, maxW),
                     searchText: [
                         session.displayName,
                         session.label,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poolzin/pool-bot",
-  "version": "2026.2.6",
+  "version": "2026.2.8",
   "description": "🎱 Pool Bot - AI assistant with PLCODE integrations",
   "keywords": [],
   "license": "MIT",
@@ -110,10 +110,10 @@
     "@larksuiteoapi/node-sdk": "^1.58.0",
     "@line/bot-sdk": "^10.6.0",
     "@lydell/node-pty": "1.2.0-beta.3",
-    "@mariozechner/pi-agent-core": "0.52.9",
-    "@mariozechner/pi-ai": "0.52.9",
-    "@mariozechner/pi-coding-agent": "0.52.9",
-    "@mariozechner/pi-tui": "0.52.9",
+    "@mariozechner/pi-agent-core": "0.52.12",
+    "@mariozechner/pi-ai": "0.52.12",
+    "@mariozechner/pi-coding-agent": "0.52.12",
+    "@mariozechner/pi-tui": "0.52.12",
     "@mozilla/readability": "^0.6.0",
     "@sinclair/typebox": "0.34.48",
     "@slack/bolt": "^4.6.0",