@poolzin/pool-bot 2026.2.24 → 2026.2.26

package/dist/agents/tool-display-common.js

@@ -411,20 +411,24 @@ function scanTopLevelChars(command, visit) {
         }
     }
 }
-function firstTopLevelStage(command) {
-    let splitIndex = -1;
+function splitTopLevelStages(command) {
+    const parts = [];
+    let start = 0;
     scanTopLevelChars(command, (char, index) => {
         if (char === ";") {
-            splitIndex = index;
-            return false;
+            parts.push(command.slice(start, index));
+            start = index + 1;
+            return true;
         }
         if ((char === "&" || char === "|") && command[index + 1] === char) {
-            splitIndex = index;
-            return false;
+            parts.push(command.slice(start, index));
+            start = index + 2;
+            return true;
         }
         return true;
     });
-    return splitIndex >= 0 ? command.slice(0, splitIndex) : command;
+    parts.push(command.slice(start));
+    return parts.map((part) => part.trim()).filter((part) => part.length > 0);
 }
 function splitTopLevelPipes(command) {
     const parts = [];
@@ -439,31 +443,66 @@ function splitTopLevelPipes(command) {
     parts.push(command.slice(start));
     return parts.map((part) => part.trim()).filter((part) => part.length > 0);
 }
+function parseChdirTarget(head) {
+    const words = splitShellWords(head, 3);
+    const bin = binaryName(words[0]);
+    if (bin === "cd" || bin === "pushd") {
+        return words[1] || undefined;
+    }
+    return undefined;
+}
+function isChdirCommand(head) {
+    const bin = binaryName(splitShellWords(head, 2)[0]);
+    return bin === "cd" || bin === "pushd" || bin === "popd";
+}
+function isPopdCommand(head) {
+    return binaryName(splitShellWords(head, 2)[0]) === "popd";
+}
 function stripShellPreamble(command) {
     let rest = command.trim();
+    let chdirPath;
     for (let i = 0; i < 4; i += 1) {
-        const andIndex = rest.indexOf("&&");
-        const semicolonIndex = rest.indexOf(";");
-        const newlineIndex = rest.indexOf("\n");
-        const candidates = [
-            { index: andIndex, length: 2 },
-            { index: semicolonIndex, length: 1 },
-            { index: newlineIndex, length: 1 },
-        ]
-            .filter((candidate) => candidate.index >= 0)
-            .toSorted((a, b) => a.index - b.index);
-        const first = candidates[0];
+        // Find the first top-level separator (&&, ||, ;, \n) respecting quotes/escaping.
+        let first;
+        scanTopLevelChars(rest, (char, idx) => {
+            if (char === "&" && rest[idx + 1] === "&") {
+                first = { index: idx, length: 2 };
+                return false;
+            }
+            if (char === "|" && rest[idx + 1] === "|") {
+                first = { index: idx, length: 2, isOr: true };
+                return false;
+            }
+            if (char === ";" || char === "\n") {
+                first = { index: idx, length: 1 };
+                return false;
+            }
+        });
         const head = (first ? rest.slice(0, first.index) : rest).trim();
-        const isPreamble = head.startsWith("set ") || head.startsWith("export ") || head.startsWith("unset ");
+        // cd/pushd/popd is preamble when followed by && / ; / \n, or when we already
+        // stripped at least one preamble segment (handles chained cd's like `cd /tmp && cd /app`).
+        // NOT for || — `cd /app || npm install` means npm runs when cd *fails*, so (in /app) is wrong.
+        const isChdir = (first ? !first.isOr : i > 0) && isChdirCommand(head);
+        const isPreamble = head.startsWith("set ") || head.startsWith("export ") || head.startsWith("unset ") || isChdir;
         if (!isPreamble) {
             break;
         }
+        if (isChdir) {
+            // popd returns to the previous directory, so inferred cwd from earlier
+            // preamble steps is no longer reliable.
+            if (isPopdCommand(head)) {
+                chdirPath = undefined;
+            }
+            else {
+                chdirPath = parseChdirTarget(head) ?? chdirPath;
+            }
+        }
         rest = first ? rest.slice(first.index + first.length).trimStart() : "";
         if (!rest) {
             break;
         }
     }
-    return rest.trim();
+    return { command: rest.trim(), chdirPath };
 }
 function summarizeKnownExec(words) {
     if (words.length === 0) {
@@ -696,12 +735,7 @@ function summarizeKnownExec(words) {
     }
     return /^[A-Za-z0-9._/-]+$/.test(arg) ? `run ${bin} ${arg}` : `run ${bin}`;
 }
-function summarizeExecCommand(command) {
-    const cleaned = stripShellPreamble(command);
-    const stage = firstTopLevelStage(cleaned).trim();
-    if (!stage) {
-        return cleaned ? summarizeKnownExec(trimLeadingEnv(splitShellWords(cleaned))) : undefined;
-    }
+function summarizePipeline(stage) {
     const pipeline = splitTopLevelPipes(stage);
     if (pipeline.length > 1) {
         const first = summarizeKnownExec(trimLeadingEnv(splitShellWords(pipeline[0])));
@@ -711,6 +745,92 @@ function summarizeExecCommand(command) {
     }
     return summarizeKnownExec(trimLeadingEnv(splitShellWords(stage)));
 }
+function summarizeExecCommand(command) {
+    const { command: cleaned, chdirPath } = stripShellPreamble(command);
+    if (!cleaned) {
+        // All segments were preamble (e.g. `cd /tmp && cd /app`) — preserve chdirPath for context.
+        return chdirPath ? { text: "", chdirPath } : undefined;
+    }
+    const stages = splitTopLevelStages(cleaned);
+    if (stages.length === 0) {
+        return undefined;
+    }
+    const summaries = stages.map((stage) => summarizePipeline(stage));
+    const text = summaries.length === 1 ? summaries[0] : summaries.join(" → ");
+    const allGeneric = summaries.every((s) => isGenericSummary(s));
+    return { text, chdirPath, allGeneric };
+}
+/** Known summarizer prefixes that indicate a recognized command with useful context. */
+const KNOWN_SUMMARY_PREFIXES = [
+    "check git",
+    "view git",
+    "show git",
+    "list git",
+    "switch git",
+    "create git",
+    "pull git",
+    "push git",
+    "fetch git",
+    "merge git",
+    "rebase git",
+    "stage git",
+    "restore git",
+    "reset git",
+    "stash git",
+    "search ",
+    "find files",
+    "list files",
+    "show first",
+    "show last",
+    "print line",
+    "print text",
+    "copy ",
+    "move ",
+    "remove ",
+    "create folder",
+    "create file",
+    "fetch http",
+    "install dependencies",
+    "run tests",
+    "run build",
+    "start app",
+    "run lint",
+    "run poolbot",
+    "run node script",
+    "run node ",
+    "run python",
+    "run ruby",
+    "run php",
+    "run sed",
+    "run git ",
+    "run npm ",
+    "run pnpm ",
+    "run yarn ",
+    "run bun ",
+    "check js syntax",
+];
+/** True when the summary is generic and the raw command would be more informative. */
+function isGenericSummary(summary) {
+    if (summary === "run command") {
+        return true;
+    }
+    // "run <binary>" or "run <binary> <arg>" without useful context
+    if (summary.startsWith("run ")) {
+        return !KNOWN_SUMMARY_PREFIXES.some((prefix) => summary.startsWith(prefix));
+    }
+    return false;
+}
+/** Compact the raw command for display: collapse whitespace, trim long strings. */
+function compactRawCommand(raw, maxLength = 120) {
+    const oneLine = raw
+        .replace(/\s*\n\s*/g, " ")
+        .replace(/\s{2,}/g, " ")
+        .trim();
+    if (oneLine.length <= maxLength) {
+        return oneLine;
+    }
+    return `${oneLine.slice(0, Math.max(0, maxLength - 1))}…`;
+}
 export function resolveExecDetail(args) {
     const record = asRecord(args);
     if (!record) {
@@ -721,14 +841,27 @@ export function resolveExecDetail(args) {
         return undefined;
     }
     const unwrapped = unwrapShellWrapper(raw);
-    const summary = summarizeExecCommand(unwrapped) ?? summarizeExecCommand(raw) ?? "run command";
+    const result = summarizeExecCommand(unwrapped) ?? summarizeExecCommand(raw);
+    const summary = result?.text || "run command";
     const cwdRaw = typeof record.workdir === "string"
         ? record.workdir
         : typeof record.cwd === "string"
             ? record.cwd
             : undefined;
-    const cwd = cwdRaw?.trim();
-    return cwd ? `${summary} (in ${cwd})` : summary;
+    // Explicit workdir takes priority; fall back to cd path extracted from the command.
+    const cwd = cwdRaw?.trim() || result?.chdirPath || undefined;
+    const compact = compactRawCommand(unwrapped);
+    // When ALL stages are generic (e.g. "run jj"), use the compact raw command instead.
+    // For mixed stages like "run cargo build → run tests", keep the summary since some parts are useful.
+    if (result?.allGeneric !== false && isGenericSummary(summary)) {
+        return cwd ? `${compact} (in ${cwd})` : compact;
+    }
+    const displaySummary = cwd ? `${summary} (in ${cwd})` : summary;
+    // Append the raw command when the summary differs meaningfully from the command itself.
+    if (compact && compact !== displaySummary && compact !== summary) {
+        return `${displaySummary}\n\n\`${compact}\``;
+    }
+    return displaySummary;
 }
 export function resolveActionSpec(spec, action) {
     if (!spec || !action) {

package/dist/agents/tool-images.js

@@ -1,5 +1,5 @@
 import { createSubsystemLogger } from "../logging/subsystem.js";
-import { getImageMetadata, resizeToJpeg } from "../media/image-ops.js";
+import { buildImageResizeSideGrid, getImageMetadata, IMAGE_REDUCE_QUALITY_STEPS, resizeToJpeg, } from "../media/image-ops.js";
 import { DEFAULT_IMAGE_MAX_BYTES, DEFAULT_IMAGE_MAX_DIMENSION_PX, } from "./image-sanitization.js";
 // Anthropic Messages API limitations (observed in Pool Bot sessions):
 // - Images over ~2000px per side can fail in multi-image requests.
@@ -49,6 +49,68 @@ function formatBytesShort(bytes) {
     }
     return `${(bytes / (1024 * 1024)).toFixed(2)}MB`;
 }
+function parseMediaPathFromText(text) {
+    for (const line of text.split(/\r?\n/u)) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("MEDIA:")) {
+            continue;
+        }
+        const raw = trimmed.slice("MEDIA:".length).trim();
+        if (!raw) {
+            continue;
+        }
+        const backtickWrapped = raw.match(/^`([^`]+)`$/u);
+        return (backtickWrapped?.[1] ?? raw).trim();
+    }
+    return undefined;
+}
+function fileNameFromPathLike(pathLike) {
+    const value = pathLike.trim();
+    if (!value) {
+        return undefined;
+    }
+    try {
+        const url = new URL(value);
+        const candidate = url.pathname.split("/").filter(Boolean).at(-1);
+        return candidate && candidate.length > 0 ? candidate : undefined;
+    }
+    catch {
+        // Not a URL; continue with path-like parsing.
+    }
+    const normalized = value.replaceAll("\\", "/");
+    const candidate = normalized.split("/").filter(Boolean).at(-1);
+    return candidate && candidate.length > 0 ? candidate : undefined;
+}
+function inferImageFileName(params) {
+    const rec = params.block;
+    const explicitKeys = ["fileName", "filename", "path", "url"];
+    for (const key of explicitKeys) {
+        const raw = rec[key];
+        if (typeof raw !== "string" || raw.trim().length === 0) {
+            continue;
+        }
+        const candidate = fileNameFromPathLike(raw);
+        if (candidate) {
+            return candidate;
+        }
+    }
+    if (typeof rec.name === "string" && rec.name.trim().length > 0) {
+        return rec.name.trim();
+    }
+    if (params.mediaPathHint) {
+        const candidate = fileNameFromPathLike(params.mediaPathHint);
+        if (candidate) {
+            return candidate;
+        }
+    }
+    if (typeof params.label === "string" && params.label.startsWith("read:")) {
+        const candidate = fileNameFromPathLike(params.label.slice("read:".length));
+        if (candidate) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
 async function resizeImageBase64IfNeeded(params) {
     const buf = Buffer.from(params.base64, "base64");
     const meta = await getImageMetadata(buf);
@@ -69,16 +131,12 @@ async function resizeImageBase64IfNeeded(params) {
             height,
         };
     }
-    const qualities = [85, 75, 65, 55, 45, 35];
     const maxDim = hasDimensions ? Math.max(width ?? 0, height ?? 0) : params.maxDimensionPx;
     const sideStart = maxDim > 0 ? Math.min(params.maxDimensionPx, maxDim) : params.maxDimensionPx;
-    const sideGrid = [sideStart, 1800, 1600, 1400, 1200, 1000, 800]
-        .filter((v) => v > 0 && v <= params.maxDimensionPx)
-        .filter((v, i, arr) => v > 0 && arr.indexOf(v) === i)
-        .toSorted((a, b) => b - a);
+    const sideGrid = buildImageResizeSideGrid(params.maxDimensionPx, sideStart);
     let smallest = null;
     for (const side of sideGrid) {
-        for (const quality of qualities) {
+        for (const quality of IMAGE_REDUCE_QUALITY_STEPS) {
             const out = await resizeToJpeg({
                 buffer: buf,
                 maxSide: side,
@@ -92,11 +150,15 @@ async function resizeImageBase64IfNeeded(params) {
                 const sourcePixels = typeof width === "number" && typeof height === "number"
                     ? `${width}x${height}px`
                     : "unknown";
+                const sourceWithFile = params.fileName
+                    ? `${params.fileName} ${sourcePixels}`
+                    : sourcePixels;
                 const byteReductionPct = buf.byteLength > 0
                     ? Number((((buf.byteLength - out.byteLength) / buf.byteLength) * 100).toFixed(1))
                     : 0;
-                log.info(`Image resized to fit limits: ${sourcePixels} ${formatBytesShort(buf.byteLength)} -> ${formatBytesShort(out.byteLength)} (-${byteReductionPct}%)`, {
+                log.info(`Image resized to fit limits: ${sourceWithFile} ${formatBytesShort(buf.byteLength)} -> ${formatBytesShort(out.byteLength)} (-${byteReductionPct}%)`, {
                     label: params.label,
+                    fileName: params.fileName,
                     sourceMimeType: params.mimeType,
                     sourceWidth: width,
                     sourceHeight: height,
@@ -125,8 +187,10 @@ async function resizeImageBase64IfNeeded(params) {
     const maxMb = (params.maxBytes / (1024 * 1024)).toFixed(0);
     const gotMb = (best.byteLength / (1024 * 1024)).toFixed(2);
     const sourcePixels = typeof width === "number" && typeof height === "number" ? `${width}x${height}px` : "unknown";
-    log.warn(`Image resize failed to fit limits: ${sourcePixels} best=${formatBytesShort(best.byteLength)} limit=${formatBytesShort(params.maxBytes)}`, {
+    const sourceWithFile = params.fileName ? `${params.fileName} ${sourcePixels}` : sourcePixels;
+    log.warn(`Image resize failed to fit limits: ${sourceWithFile} best=${formatBytesShort(best.byteLength)} limit=${formatBytesShort(params.maxBytes)}`, {
         label: params.label,
+        fileName: params.fileName,
         sourceMimeType: params.mimeType,
         sourceWidth: width,
         sourceHeight: height,
@@ -143,7 +207,14 @@ export async function sanitizeContentBlocksImages(blocks, label, opts = {}) {
     const maxDimensionPx = Math.max(opts.maxDimensionPx ?? MAX_IMAGE_DIMENSION_PX, 1);
     const maxBytes = Math.max(opts.maxBytes ?? MAX_IMAGE_BYTES, 1);
     const out = [];
+    let mediaPathHint;
     for (const block of blocks) {
+        if (isTextBlock(block)) {
+            const mediaPath = parseMediaPathFromText(block.text);
+            if (mediaPath) {
+                mediaPathHint = mediaPath;
+            }
+        }
         if (!isImageBlock(block)) {
             out.push(block);
             continue;
@@ -159,12 +230,14 @@ export async function sanitizeContentBlocksImages(blocks, label, opts = {}) {
         try {
             const inferredMimeType = inferMimeTypeFromBase64(data);
             const mimeType = inferredMimeType ?? block.mimeType;
+            const fileName = inferImageFileName({ block, label, mediaPathHint });
             const resized = await resizeImageBase64IfNeeded({
                 base64: data,
                 mimeType,
                 maxDimensionPx,
                 maxBytes,
                 label,
+                fileName,
             });
             out.push({
                 ...block,

package/dist/agents/tool-policy-shared.js

@@ -0,0 +1,108 @@
+const TOOL_NAME_ALIASES = {
+    bash: "exec",
+    "apply-patch": "apply_patch",
+};
+export const TOOL_GROUPS = {
+    // NOTE: Keep canonical (lowercase) tool names here.
+    "group:memory": ["memory_search", "memory_get"],
+    "group:web": ["web_search", "web_fetch"],
+    // Basic workspace/file tools
+    "group:fs": ["read", "write", "edit", "apply_patch"],
+    // Host/runtime execution tools
+    "group:runtime": ["exec", "process"],
+    // Session management tools
+    "group:sessions": [
+        "sessions_list",
+        "sessions_history",
+        "sessions_send",
+        "sessions_spawn",
+        "subagents",
+        "session_status",
+    ],
+    // UI helpers
+    "group:ui": ["browser", "canvas"],
+    // Automation + infra
+    "group:automation": ["cron", "gateway"],
+    // Messaging surface
+    "group:messaging": ["message"],
+    // Nodes + device tools
+    "group:nodes": ["nodes"],
+    // All Pool Bot native tools (excludes provider plugins).
+    "group:poolbot": [
+        "browser",
+        "canvas",
+        "nodes",
+        "cron",
+        "message",
+        "gateway",
+        "agents_list",
+        "sessions_list",
+        "sessions_history",
+        "sessions_send",
+        "sessions_spawn",
+        "subagents",
+        "session_status",
+        "memory_search",
+        "memory_get",
+        "web_search",
+        "web_fetch",
+        "image",
+    ],
+};
+const TOOL_PROFILES = {
+    minimal: {
+        allow: ["session_status"],
+    },
+    coding: {
+        allow: ["group:fs", "group:runtime", "group:sessions", "group:memory", "image"],
+    },
+    messaging: {
+        allow: [
+            "group:messaging",
+            "sessions_list",
+            "sessions_history",
+            "sessions_send",
+            "session_status",
+        ],
+    },
+    full: {},
+};
+export function normalizeToolName(name) {
+    const normalized = name.trim().toLowerCase();
+    return TOOL_NAME_ALIASES[normalized] ?? normalized;
+}
+export function normalizeToolList(list) {
+    if (!list) {
+        return [];
+    }
+    return list.map(normalizeToolName).filter(Boolean);
+}
+export function expandToolGroups(list) {
+    const normalized = normalizeToolList(list);
+    const expanded = [];
+    for (const value of normalized) {
+        const group = TOOL_GROUPS[value];
+        if (group) {
+            expanded.push(...group);
+            continue;
+        }
+        expanded.push(value);
+    }
+    return Array.from(new Set(expanded));
+}
+export function resolveToolProfilePolicy(profile) {
+    if (!profile) {
+        return undefined;
+    }
+    const resolved = TOOL_PROFILES[profile];
+    if (!resolved) {
+        return undefined;
+    }
+    if (!resolved.allow && !resolved.deny) {
+        return undefined;
+    }
+    return {
+        allow: resolved.allow ? [...resolved.allow] : undefined,
+        deny: resolved.deny ? [...resolved.deny] : undefined,
+    };
+}