@poolzin/pool-bot 2026.2.25 → 2026.2.26

package/dist/infra/shell-env.js

@@ -1,26 +1,100 @@
 import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
 import { isTruthyEnvValue } from "./env.js";
 const DEFAULT_TIMEOUT_MS = 15_000;
 const DEFAULT_MAX_BUFFER_BYTES = 2 * 1024 * 1024;
+const DEFAULT_SHELL = "/bin/sh";
+const TRUSTED_SHELL_PREFIXES = [
+    "/bin/",
+    "/usr/bin/",
+    "/usr/local/bin/",
+    "/opt/homebrew/bin/",
+    "/run/current-system/sw/bin/",
+];
 let lastAppliedKeys = [];
 let cachedShellPath;
+let cachedEtcShells;
+function resolveTimeoutMs(timeoutMs) {
+    if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs)) {
+        return DEFAULT_TIMEOUT_MS;
+    }
+    return Math.max(0, timeoutMs);
+}
+function readEtcShells() {
+    if (cachedEtcShells !== undefined) {
+        return cachedEtcShells;
+    }
+    try {
+        const raw = fs.readFileSync("/etc/shells", "utf8");
+        const entries = raw
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0 && !line.startsWith("#") && path.isAbsolute(line));
+        cachedEtcShells = new Set(entries);
+    }
+    catch {
+        cachedEtcShells = null;
+    }
+    return cachedEtcShells;
+}
+function isTrustedShellPath(shell) {
+    if (!path.isAbsolute(shell)) {
+        return false;
+    }
+    const normalized = path.normalize(shell);
+    if (normalized !== shell) {
+        return false;
+    }
+    // Primary trust anchor: shell registered in /etc/shells.
+    const registeredShells = readEtcShells();
+    if (registeredShells?.has(shell)) {
+        return true;
+    }
+    // Fallback for environments where /etc/shells is incomplete/unavailable.
+    if (!TRUSTED_SHELL_PREFIXES.some((prefix) => shell.startsWith(prefix))) {
+        return false;
+    }
+    try {
+        fs.accessSync(shell, fs.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function resolveShell(env) {
     const shell = env.SHELL?.trim();
-    return shell && shell.length > 0 ? shell : "/bin/sh";
+    if (shell && isTrustedShellPath(shell)) {
+        return shell;
+    }
+    return DEFAULT_SHELL;
+}
+function execLoginShellEnvZero(params) {
+    return params.exec(params.shell, ["-l", "-c", "env -0"], {
+        encoding: "buffer",
+        timeout: params.timeoutMs,
+        maxBuffer: DEFAULT_MAX_BUFFER_BYTES,
+        env: params.env,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
 }
 function parseShellEnv(stdout) {
     const shellEnv = new Map();
     const parts = stdout.toString("utf8").split("\0");
     for (const part of parts) {
-        if (!part)
+        if (!part) {
             continue;
+        }
         const eq = part.indexOf("=");
-        if (eq <= 0)
+        if (eq <= 0) {
             continue;
+        }
         const key = part.slice(0, eq);
         const value = part.slice(eq + 1);
-        if (!key)
+        if (!key) {
             continue;
+        }
         shellEnv.set(key, value);
     }
     return shellEnv;
@@ -37,19 +111,11 @@ export function loadShellEnvFallback(opts) {
         lastAppliedKeys = [];
         return { ok: true, applied: [], skippedReason: "already-has-keys" };
     }
-    const timeoutMs = typeof opts.timeoutMs === "number" && Number.isFinite(opts.timeoutMs)
-        ? Math.max(0, opts.timeoutMs)
-        : DEFAULT_TIMEOUT_MS;
+    const timeoutMs = resolveTimeoutMs(opts.timeoutMs);
     const shell = resolveShell(opts.env);
     let stdout;
     try {
-        stdout = exec(shell, ["-l", "-c", "env -0"], {
-            encoding: "buffer",
-            timeout: timeoutMs,
-            maxBuffer: DEFAULT_MAX_BUFFER_BYTES,
-            env: opts.env,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
+        stdout = execLoginShellEnvZero({ shell, env: opts.env, exec, timeoutMs });
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -60,11 +126,13 @@ export function loadShellEnvFallback(opts) {
     const shellEnv = parseShellEnv(stdout);
     const applied = [];
     for (const key of opts.expectedKeys) {
-        if (opts.env[key]?.trim())
+        if (opts.env[key]?.trim()) {
             continue;
+        }
         const value = shellEnv.get(key);
-        if (!value?.trim())
+        if (!value?.trim()) {
             continue;
+        }
         opts.env[key] = value;
         applied.push(key);
     }
@@ -72,42 +140,37 @@ export function loadShellEnvFallback(opts) {
     return { ok: true, applied };
 }
 export function shouldEnableShellEnvFallback(env) {
-    return (isTruthyEnvValue(env.POOLBOT_LOAD_SHELL_ENV) || isTruthyEnvValue(env.CLAWDBOT_LOAD_SHELL_ENV));
+    return isTruthyEnvValue(env.POOLBOT_LOAD_SHELL_ENV);
 }
 export function shouldDeferShellEnvFallback(env) {
-    return (isTruthyEnvValue(env.POOLBOT_DEFER_SHELL_ENV_FALLBACK) ||
-        isTruthyEnvValue(env.CLAWDBOT_DEFER_SHELL_ENV_FALLBACK));
+    return isTruthyEnvValue(env.POOLBOT_DEFER_SHELL_ENV_FALLBACK);
 }
 export function resolveShellEnvFallbackTimeoutMs(env) {
-    const raw = env.POOLBOT_SHELL_ENV_TIMEOUT_MS?.trim() || env.CLAWDBOT_SHELL_ENV_TIMEOUT_MS?.trim();
-    if (!raw)
+    const raw = env.POOLBOT_SHELL_ENV_TIMEOUT_MS?.trim();
+    if (!raw) {
         return DEFAULT_TIMEOUT_MS;
+    }
     const parsed = Number.parseInt(raw, 10);
-    if (!Number.isFinite(parsed))
+    if (!Number.isFinite(parsed)) {
         return DEFAULT_TIMEOUT_MS;
+    }
     return Math.max(0, parsed);
 }
 export function getShellPathFromLoginShell(opts) {
-    if (cachedShellPath !== undefined)
+    if (cachedShellPath !== undefined) {
         return cachedShellPath;
-    if (process.platform === "win32") {
+    }
+    const platform = opts.platform ?? process.platform;
+    if (platform === "win32") {
         cachedShellPath = null;
         return cachedShellPath;
     }
     const exec = opts.exec ?? execFileSync;
-    const timeoutMs = typeof opts.timeoutMs === "number" && Number.isFinite(opts.timeoutMs)
-        ? Math.max(0, opts.timeoutMs)
-        : DEFAULT_TIMEOUT_MS;
+    const timeoutMs = resolveTimeoutMs(opts.timeoutMs);
     const shell = resolveShell(opts.env);
     let stdout;
     try {
-        stdout = exec(shell, ["-l", "-c", "env -0"], {
-            encoding: "buffer",
-            timeout: timeoutMs,
-            maxBuffer: DEFAULT_MAX_BUFFER_BYTES,
-            env: opts.env,
-            stdio: ["ignore", "pipe", "pipe"],
-        });
+        stdout = execLoginShellEnvZero({ shell, env: opts.env, exec, timeoutMs });
     }
     catch {
         cachedShellPath = null;
@@ -120,6 +183,7 @@ export function getShellPathFromLoginShell(opts) {
 }
 export function resetShellPathCacheForTests() {
     cachedShellPath = undefined;
+    cachedEtcShells = undefined;
 }
 export function getShellEnvAppliedKeys() {
     return [...lastAppliedKeys];

package/dist/infra/ssh-config.js

@@ -1,10 +1,12 @@
 import { spawn } from "node:child_process";
 function parsePort(value) {
-    if (!value)
+    if (!value) {
         return undefined;
+    }
     const parsed = Number.parseInt(value, 10);
-    if (!Number.isFinite(parsed) || parsed <= 0)
+    if (!Number.isFinite(parsed) || parsed <= 0) {
         return undefined;
+    }
     return parsed;
 }
 export function parseSshConfigOutput(output) {
@@ -12,12 +14,14 @@ export function parseSshConfigOutput(output) {
     const lines = output.split("\n");
     for (const raw of lines) {
         const line = raw.trim();
-        if (!line)
+        if (!line) {
             continue;
+        }
         const [key, ...rest] = line.split(/\s+/);
         const value = rest.join(" ").trim();
-        if (!key || !value)
+        if (!key || !value) {
             continue;
+        }
         switch (key) {
             case "user":
                 result.user = value;
@@ -29,8 +33,9 @@ export function parseSshConfigOutput(output) {
                 result.port = parsePort(value);
                 break;
             case "identityfile":
-                if (value !== "none")
+                if (value !== "none") {
                     result.identityFiles.push(value);
+                }
                 break;
             default:
                 break;
@@ -48,7 +53,8 @@ export async function resolveSshConfig(target, opts = {}) {
         args.push("-i", opts.identity.trim());
     }
     const userHost = target.user ? `${target.user}@${target.host}` : target.host;
-    args.push(userHost);
+    // Use "--" so userHost can't be parsed as an ssh option.
+    args.push("--", userHost);
     return await new Promise((resolve) => {
         const child = spawn(sshPath, args, {
             stdio: ["ignore", "pipe", "ignore"],

package/dist/infra/system-run-command.js

@@ -45,8 +45,12 @@ export function extractShellCommandFromArgv(argv) {
         if (idx === -1) {
             return null;
         }
-        const cmd = argv[idx + 1];
-        return typeof cmd === "string" ? cmd : null;
+        const tail = argv.slice(idx + 1).map((item) => String(item));
+        if (tail.length === 0) {
+            return null;
+        }
+        const cmd = tail.join(" ").trim();
+        return cmd.length > 0 ? cmd : null;
     }
     return null;
 }
@@ -55,7 +59,7 @@ export function validateSystemRunCommandConsistency(params) {
         ? params.rawCommand.trim()
         : null;
     const shellCommand = extractShellCommandFromArgv(params.argv);
-    const inferred = shellCommand ? shellCommand.trim() : formatExecCommand(params.argv);
+    const inferred = shellCommand !== null ? shellCommand.trim() : formatExecCommand(params.argv);
     if (raw && raw !== inferred) {
         return {
             ok: false,
@@ -72,7 +76,48 @@ export function validateSystemRunCommandConsistency(params) {
         // Only treat this as a shell command when argv is a recognized shell wrapper.
         // For direct argv execution, rawCommand is purely display/approval text and
         // must match the formatted argv.
-        shellCommand: shellCommand ? (raw ?? shellCommand) : null,
+        shellCommand: shellCommand !== null ? (raw ?? shellCommand) : null,
         cmdText: raw ?? shellCommand ?? inferred,
     };
 }
+export function resolveSystemRunCommand(params) {
+    const raw = typeof params.rawCommand === "string" && params.rawCommand.trim().length > 0
+        ? params.rawCommand.trim()
+        : null;
+    const command = Array.isArray(params.command) ? params.command : [];
+    if (command.length === 0) {
+        if (raw) {
+            return {
+                ok: false,
+                message: "rawCommand requires params.command",
+                details: { code: "MISSING_COMMAND" },
+            };
+        }
+        return {
+            ok: true,
+            argv: [],
+            rawCommand: null,
+            shellCommand: null,
+            cmdText: "",
+        };
+    }
+    const argv = command.map((v) => String(v));
+    const validation = validateSystemRunCommandConsistency({
+        argv,
+        rawCommand: raw,
+    });
+    if (!validation.ok) {
+        return {
+            ok: false,
+            message: validation.message,
+            details: validation.details ?? { code: "RAW_COMMAND_MISMATCH" },
+        };
+    }
+    return {
+        ok: true,
+        argv,
+        rawCommand: raw,
+        shellCommand: validation.shellCommand,
+        cmdText: validation.cmdText,
+    };
+}

package/dist/infra/update-channels.js

@@ -2,18 +2,22 @@ export const DEFAULT_PACKAGE_CHANNEL = "stable";
 export const DEFAULT_GIT_CHANNEL = "dev";
 export const DEV_BRANCH = "main";
 export function normalizeUpdateChannel(value) {
-    if (!value)
+    if (!value) {
         return null;
+    }
     const normalized = value.trim().toLowerCase();
-    if (normalized === "stable" || normalized === "beta" || normalized === "dev")
+    if (normalized === "stable" || normalized === "beta" || normalized === "dev") {
         return normalized;
+    }
     return null;
 }
 export function channelToNpmTag(channel) {
-    if (channel === "beta")
+    if (channel === "beta") {
         return "beta";
-    if (channel === "dev")
+    }
+    if (channel === "dev") {
         return "dev";
+    }
     return "latest";
 }
 export function isBetaTag(tag) {
@@ -43,8 +47,9 @@ export function resolveEffectiveUpdateChannel(params) {
     return { channel: DEFAULT_PACKAGE_CHANNEL, source: "default" };
 }
 export function formatUpdateChannelLabel(params) {
-    if (params.source === "config")
+    if (params.source === "config") {
         return `${params.channel} (config)`;
+    }
     if (params.source === "git-tag") {
         return params.gitTag ? `${params.channel} (${params.gitTag})` : `${params.channel} (tag)`;
     }

package/dist/line/accounts.js

@@ -1,8 +1,10 @@
 import fs from "node:fs";
-export const DEFAULT_ACCOUNT_ID = "default";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId as normalizeSharedAccountId, } from "../routing/account-id.js";
+export { DEFAULT_ACCOUNT_ID } from "../routing/account-id.js";
 function readFileIfExists(filePath) {
-    if (!filePath)
+    if (!filePath) {
         return undefined;
+    }
     try {
         return fs.readFileSync(filePath, "utf-8").trim();
     }
@@ -122,9 +124,5 @@ export function resolveDefaultLineAccountId(cfg) {
     return ids[0] ?? DEFAULT_ACCOUNT_ID;
 }
 export function normalizeAccountId(accountId) {
-    const trimmed = accountId?.trim().toLowerCase();
-    if (!trimmed || trimmed === "default") {
-        return DEFAULT_ACCOUNT_ID;
-    }
-    return trimmed;
+    return normalizeSharedAccountId(accountId);
 }

package/dist/line/bot-access.js

@@ -1,9 +1,12 @@
+import { firstDefined, isSenderIdAllowed, mergeAllowFromSources } from "../channels/allow-from.js";
 function normalizeAllowEntry(value) {
     const trimmed = String(value).trim();
-    if (!trimmed)
+    if (!trimmed) {
         return "";
-    if (trimmed === "*")
+    }
+    if (trimmed === "*") {
         return "*";
+    }
     return trimmed.replace(/^line:(?:user:)?/i, "");
 }
 export const normalizeAllowFrom = (list) => {
@@ -15,24 +18,9 @@ export const normalizeAllowFrom = (list) => {
         hasEntries: entries.length > 0,
     };
 };
-export const normalizeAllowFromWithStore = (params) => {
-    const combined = [...(params.allowFrom ?? []), ...(params.storeAllowFrom ?? [])];
-    return normalizeAllowFrom(combined);
-};
-export const firstDefined = (...values) => {
-    for (const value of values) {
-        if (typeof value !== "undefined")
-            return value;
-    }
-    return undefined;
-};
+export const normalizeAllowFromWithStore = (params) => normalizeAllowFrom(mergeAllowFromSources(params));
 export const isSenderAllowed = (params) => {
     const { allow, senderId } = params;
-    if (!allow.hasEntries)
-        return false;
-    if (allow.hasWildcard)
-        return true;
-    if (!senderId)
-        return false;
-    return allow.entries.includes(senderId);
+    return isSenderIdAllowed(allow, senderId, false);
 };
+export { firstDefined };

package/dist/line/bot-handlers.js

@@ -77,10 +77,12 @@ async function shouldProcessLineEvent(event, context) {
     const { cfg, account } = context;
     const { userId, groupId, roomId, isGroup } = getSourceInfo(event.source);
     const senderId = userId ?? "";
+    const dmPolicy = account.config.dmPolicy ?? "pairing";
     const storeAllowFrom = await readChannelAllowFromStore("line").catch(() => []);
     const effectiveDmAllow = normalizeAllowFromWithStore({
         allowFrom: account.config.allowFrom,
         storeAllowFrom,
+        dmPolicy,
     });
     const groupConfig = resolveLineGroupConfig({ config: account.config, groupId, roomId });
     const groupAllowOverride = groupConfig?.allowFrom;
@@ -91,8 +93,8 @@ async function shouldProcessLineEvent(event, context) {
     const effectiveGroupAllow = normalizeAllowFromWithStore({
         allowFrom: groupAllowFrom,
         storeAllowFrom,
+        dmPolicy,
     });
-    const dmPolicy = account.config.dmPolicy ?? "pairing";
     const defaultGroupPolicy = cfg.channels?.defaults?.groupPolicy;
     const groupPolicy = account.config.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
     if (isGroup) {

package/dist/link-understanding/detect.js

@@ -1,3 +1,4 @@
+import { isBlockedHostnameOrIp } from "../infra/net/ssrf.js";
 import { DEFAULT_MAX_LINKS } from "./defaults.js";
 // Remove markdown link syntax so only bare URLs are considered.
 const MARKDOWN_LINK_RE = /\[[^\]]*]\((https?:\/\/\S+?)\)/gi;
@@ -14,10 +15,12 @@ function resolveMaxLinks(value) {
 function isAllowedUrl(raw) {
     try {
         const parsed = new URL(raw);
-        if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+        if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
             return false;
-        if (parsed.hostname === "127.0.0.1")
+        }
+        if (isBlockedHostnameOrIp(parsed.hostname)) {
             return false;
+        }
         return true;
     }
     catch {
@@ -26,24 +29,29 @@ function isAllowedUrl(raw) {
 }
 export function extractLinksFromMessage(message, opts) {
     const source = message?.trim();
-    if (!source)
+    if (!source) {
         return [];
+    }
     const maxLinks = resolveMaxLinks(opts?.maxLinks);
     const sanitized = stripMarkdownLinks(source);
     const seen = new Set();
     const results = [];
     for (const match of sanitized.matchAll(BARE_LINK_RE)) {
         const raw = match[0]?.trim();
-        if (!raw)
+        if (!raw) {
             continue;
-        if (!isAllowedUrl(raw))
+        }
+        if (!isAllowedUrl(raw)) {
             continue;
-        if (seen.has(raw))
+        }
+        if (seen.has(raw)) {
             continue;
+        }
         seen.add(raw);
         results.push(raw);
-        if (results.length >= maxLinks)
+        if (results.length >= maxLinks) {
             break;
+        }
     }
     return results;
 }

package/dist/media/constants.js

@@ -3,18 +3,27 @@ export const MAX_AUDIO_BYTES = 16 * 1024 * 1024; // 16MB
 export const MAX_VIDEO_BYTES = 16 * 1024 * 1024; // 16MB
 export const MAX_DOCUMENT_BYTES = 100 * 1024 * 1024; // 100MB
 export function mediaKindFromMime(mime) {
-    if (!mime)
+    if (!mime) {
         return "unknown";
-    if (mime.startsWith("image/"))
+    }
+    if (mime.startsWith("image/")) {
         return "image";
-    if (mime.startsWith("audio/"))
+    }
+    if (mime.startsWith("audio/")) {
         return "audio";
-    if (mime.startsWith("video/"))
+    }
+    if (mime.startsWith("video/")) {
         return "video";
-    if (mime === "application/pdf")
+    }
+    if (mime === "application/pdf") {
         return "document";
-    if (mime.startsWith("application/"))
+    }
+    if (mime.startsWith("text/")) {
+        return "document";
+    }
+    if (mime.startsWith("application/")) {
         return "document";
+    }
     return "unknown";
 }
 export function maxBytesForKind(kind) {

package/dist/media/image-ops.js

@@ -2,6 +2,13 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { runExec } from "../process/exec.js";
+export const IMAGE_REDUCE_QUALITY_STEPS = [85, 75, 65, 55, 45, 35];
+export function buildImageResizeSideGrid(maxSide, sideStart) {
+    return [sideStart, 1800, 1600, 1400, 1200, 1000, 800]
+        .map((value) => Math.min(maxSide, value))
+        .filter((value, idx, arr) => value > 0 && arr.indexOf(value) === idx)
+        .toSorted((a, b) => b - a);
+}
 function isBun() {
     return typeof process.versions.bun === "string";
 }

package/dist/media/local-roots.js

@@ -1,11 +1,12 @@
-import os from "node:os";
 import path from "node:path";
+import { resolvePreferredPoolbotTmpDir } from "../infra/tmp-poolbot-dir.js";
 import { resolveAgentWorkspaceDir } from "../agents/agent-scope.js";
 import { resolveStateDir } from "../config/paths.js";
 function buildMediaLocalRoots(stateDir) {
     const resolvedStateDir = path.resolve(stateDir);
+    const preferredTmpDir = resolvePreferredPoolbotTmpDir();
     return [
-        os.tmpdir(),
+        preferredTmpDir,
         path.join(resolvedStateDir, "media"),
         path.join(resolvedStateDir, "agents"),
         path.join(resolvedStateDir, "workspace"),

package/dist/media-understanding/apply.js

@@ -315,7 +315,10 @@ async function extractFileBlocks(params) {
         }
         const utf16Charset = resolveUtf16Charset(bufferResult?.buffer);
         const textSample = decodeTextSample(bufferResult?.buffer);
-        const textLike = Boolean(utf16Charset) || looksLikeUtf8Text(bufferResult?.buffer);
+        // Do not coerce real PDFs into text/plain via printable-byte heuristics.
+        // PDFs have a dedicated extraction path in extractFileContentFromSource.
+        const allowTextHeuristic = normalizedRawMime !== "application/pdf";
+        const textLike = allowTextHeuristic && (Boolean(utf16Charset) || looksLikeUtf8Text(bufferResult?.buffer));
         const guessedDelimited = textLike ? guessDelimitedMime(textSample) : undefined;
         const textHint = forcedTextMimeResolved ?? guessedDelimited ?? (textLike ? "text/plain" : undefined);
         const mimeType = sanitizeMimeType(textHint ?? normalizeMimeType(rawMime));

package/dist/media-understanding/concurrency.js

@@ -1,26 +1,14 @@
 import { logVerbose, shouldLogVerbose } from "../globals.js";
+import { runTasksWithConcurrency } from "../utils/run-with-concurrency.js";
 export async function runWithConcurrency(tasks, limit) {
-    if (tasks.length === 0)
-        return [];
-    const resolvedLimit = Math.max(1, Math.min(limit, tasks.length));
-    const results = Array.from({ length: tasks.length });
-    let next = 0;
-    const workers = Array.from({ length: resolvedLimit }, async () => {
-        while (true) {
-            const index = next;
-            next += 1;
-            if (index >= tasks.length)
-                return;
-            try {
-                results[index] = await tasks[index]();
+    const { results } = await runTasksWithConcurrency({
+        tasks,
+        limit,
+        onTaskError(err) {
+            if (shouldLogVerbose()) {
+                logVerbose(`Media understanding task failed: ${String(err)}`);
             }
-            catch (err) {
-                if (shouldLogVerbose()) {
-                    logVerbose(`Media understanding task failed: ${String(err)}`);
-                }
-            }
-        }
+        },
     });
-    await Promise.allSettled(workers);
     return results;
 }