@poolzin/pool-bot 2026.2.25 → 2026.2.26

package/dist/hooks/workspace.js

@@ -1,17 +1,21 @@
 import fs from "node:fs";
 import path from "node:path";
-import { LEGACY_MANIFEST_KEY } from "../compat/legacy-names.js";
+import { MANIFEST_KEY } from "../compat/legacy-names.js";
+import { createSubsystemLogger } from "../logging/subsystem.js";
+import { isPathInsideWithRealpath } from "../security/scan-paths.js";
 import { CONFIG_DIR, resolveUserPath } from "../utils.js";
 import { resolveBundledHooksDir } from "./bundled-dir.js";
 import { shouldIncludeHook } from "./config.js";
 import { parseFrontmatter, resolvePoolbotMetadata, resolveHookInvocationPolicy, } from "./frontmatter.js";
+const log = createSubsystemLogger("hooks/workspace");
 function filterHookEntries(entries, config, eligibility) {
     return entries.filter((entry) => shouldIncludeHook({ entry, config, eligibility }));
 }
 function readHookPackageManifest(dir) {
     const manifestPath = path.join(dir, "package.json");
-    if (!fs.existsSync(manifestPath))
+    if (!fs.existsSync(manifestPath)) {
         return null;
+    }
     try {
         const raw = fs.readFileSync(manifestPath, "utf-8");
         return JSON.parse(raw);
@@ -21,15 +25,27 @@ function readHookPackageManifest(dir) {
     }
 }
 function resolvePackageHooks(manifest) {
-    const raw = manifest.poolbot?.hooks ?? manifest[LEGACY_MANIFEST_KEY]?.hooks;
-    if (!Array.isArray(raw))
+    const raw = manifest[MANIFEST_KEY]?.hooks;
+    if (!Array.isArray(raw)) {
         return [];
+    }
     return raw.map((entry) => (typeof entry === "string" ? entry.trim() : "")).filter(Boolean);
 }
+function resolveContainedDir(baseDir, targetDir) {
+    const base = path.resolve(baseDir);
+    const resolved = path.resolve(baseDir, targetDir);
+    if (!isPathInsideWithRealpath(base, resolved, {
+        requireRealpath: true,
+    })) {
+        return null;
+    }
+    return resolved;
+}
 function loadHookFromDir(params) {
     const hookMdPath = path.join(params.hookDir, "HOOK.md");
-    if (!fs.existsSync(hookMdPath))
+    if (!fs.existsSync(hookMdPath)) {
         return null;
+    }
     try {
         const content = fs.readFileSync(hookMdPath, "utf-8");
         const frontmatter = parseFrontmatter(content);
@@ -45,7 +61,7 @@ function loadHookFromDir(params) {
             }
         }
         if (!handlerPath) {
-            console.warn(`[hooks] Hook "${name}" has HOOK.md but no handler file in ${params.hookDir}`);
+            log.warn(`Hook "${name}" has HOOK.md but no handler file in ${params.hookDir}`);
             return null;
         }
         return {
@@ -59,7 +75,8 @@ function loadHookFromDir(params) {
         };
     }
     catch (err) {
-        console.warn(`[hooks] Failed to load hook from ${params.hookDir}:`, err);
+        const message = err instanceof Error ? (err.stack ?? err.message) : String(err);
+        log.warn(`Failed to load hook from ${params.hookDir}: ${message}`);
         return null;
     }
 }
@@ -68,30 +85,38 @@ function loadHookFromDir(params) {
  */
 function loadHooksFromDir(params) {
     const { dir, source, pluginId } = params;
-    if (!fs.existsSync(dir))
+    if (!fs.existsSync(dir)) {
         return [];
+    }
     const stat = fs.statSync(dir);
-    if (!stat.isDirectory())
+    if (!stat.isDirectory()) {
         return [];
+    }
     const hooks = [];
     const entries = fs.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-        if (!entry.isDirectory())
+        if (!entry.isDirectory()) {
             continue;
+        }
         const hookDir = path.join(dir, entry.name);
         const manifest = readHookPackageManifest(hookDir);
         const packageHooks = manifest ? resolvePackageHooks(manifest) : [];
         if (packageHooks.length > 0) {
             for (const hookPath of packageHooks) {
-                const resolvedHookDir = path.resolve(hookDir, hookPath);
+                const resolvedHookDir = resolveContainedDir(hookDir, hookPath);
+                if (!resolvedHookDir) {
+                    log.warn(`Ignoring out-of-package hook path "${hookPath}" in ${hookDir} (must be within package directory)`);
+                    continue;
+                }
                 const hook = loadHookFromDir({
                     hookDir: resolvedHookDir,
                     source,
                     pluginId,
                     nameHint: path.basename(resolvedHookDir),
                 });
-                if (hook)
+                if (hook) {
                     hooks.push(hook);
+                }
             }
             continue;
         }
@@ -101,8 +126,9 @@ function loadHooksFromDir(params) {
             pluginId,
             nameHint: entry.name,
         });
-        if (hook)
+        if (hook) {
             hooks.push(hook);
+        }
     }
     return hooks;
 }
@@ -165,14 +191,18 @@ function loadHookEntries(workspaceDir, opts) {
     });
     const merged = new Map();
     // Precedence: extra < bundled < managed < workspace (workspace wins)
-    for (const hook of extraHooks)
+    for (const hook of extraHooks) {
         merged.set(hook.name, hook);
-    for (const hook of bundledHooks)
+    }
+    for (const hook of bundledHooks) {
         merged.set(hook.name, hook);
-    for (const hook of managedHooks)
+    }
+    for (const hook of managedHooks) {
         merged.set(hook.name, hook);
-    for (const hook of workspaceHooks)
+    }
+    for (const hook of workspaceHooks) {
         merged.set(hook.name, hook);
+    }
     return Array.from(merged.values()).map((hook) => {
         let frontmatter = {};
         try {

package/dist/imessage/accounts.js

@@ -1,26 +1,13 @@
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "../routing/session-key.js";
-function listConfiguredAccountIds(cfg) {
-    const accounts = cfg.channels?.imessage?.accounts;
-    if (!accounts || typeof accounts !== "object")
-        return [];
-    return Object.keys(accounts).filter(Boolean);
-}
-export function listIMessageAccountIds(cfg) {
-    const ids = listConfiguredAccountIds(cfg);
-    if (ids.length === 0)
-        return [DEFAULT_ACCOUNT_ID];
-    return ids.sort((a, b) => a.localeCompare(b));
-}
-export function resolveDefaultIMessageAccountId(cfg) {
-    const ids = listIMessageAccountIds(cfg);
-    if (ids.includes(DEFAULT_ACCOUNT_ID))
-        return DEFAULT_ACCOUNT_ID;
-    return ids[0] ?? DEFAULT_ACCOUNT_ID;
-}
+import { createAccountListHelpers } from "../channels/plugins/account-helpers.js";
+import { normalizeAccountId } from "../routing/session-key.js";
+const { listAccountIds, resolveDefaultAccountId } = createAccountListHelpers("imessage");
+export const listIMessageAccountIds = listAccountIds;
+export const resolveDefaultIMessageAccountId = resolveDefaultAccountId;
 function resolveAccountConfig(cfg, accountId) {
     const accounts = cfg.channels?.imessage?.accounts;
-    if (!accounts || typeof accounts !== "object")
+    if (!accounts || typeof accounts !== "object") {
         return undefined;
+    }
     return accounts[accountId];
 }
 function mergeIMessageAccountConfig(cfg, accountId) {
@@ -43,6 +30,8 @@ export function resolveIMessageAccount(params) {
         merged.dmPolicy ||
         merged.groupPolicy ||
         typeof merged.includeAttachments === "boolean" ||
+        (merged.attachmentRoots && merged.attachmentRoots.length > 0) ||
+        (merged.remoteAttachmentRoots && merged.remoteAttachmentRoots.length > 0) ||
         typeof merged.mediaMaxMb === "number" ||
         typeof merged.textChunkLimit === "number" ||
         (merged.groups && Object.keys(merged.groups).length > 0));

package/dist/imessage/monitor/inbound-processing.js

@@ -63,7 +63,8 @@ export function resolveIMessageInboundDecision(params) {
         return { kind: "drop", reason: "group without chat_id" };
     }
     const groupId = isGroup ? groupIdCandidate : undefined;
-    const effectiveDmAllowFrom = Array.from(new Set([...params.allowFrom, ...params.storeAllowFrom]))
+    const storeAllowFrom = params.dmPolicy === "allowlist" ? [] : params.storeAllowFrom;
+    const effectiveDmAllowFrom = Array.from(new Set([...params.allowFrom, ...storeAllowFrom]))
         .map((v) => String(v).trim())
         .filter(Boolean);
     // Keep DM pairing-store authorization scoped to DMs; group access must come from explicit group allowlist config.

package/dist/infra/archive.js

@@ -1,11 +1,20 @@
-import { createWriteStream } from "node:fs";
+import { constants as fsConstants } from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import JSZip from "jszip";
 import * as tar from "tar";
-import { resolveSafeBaseDir } from "./path-safety.js";
+import { resolveArchiveOutputPath, stripArchivePath, validateArchiveEntryPath, } from "./archive-path.js";
+import { isNotFoundPathError, isPathInside, isSymlinkOpenError } from "./path-guards.js";
+export class ArchiveSecurityError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+        this.name = "ArchiveSecurityError";
+    }
+}
 /** @internal */
 export const DEFAULT_MAX_ARCHIVE_BYTES_ZIP = 256 * 1024 * 1024;
 /** @internal */
@@ -18,7 +27,12 @@ const ERROR_ARCHIVE_SIZE_EXCEEDS_LIMIT = "archive size exceeds limit";
 const ERROR_ARCHIVE_ENTRY_COUNT_EXCEEDS_LIMIT = "archive entry count exceeds limit";
 const ERROR_ARCHIVE_ENTRY_EXTRACTED_SIZE_EXCEEDS_LIMIT = "archive entry extracted size exceeds limit";
 const ERROR_ARCHIVE_EXTRACTED_SIZE_EXCEEDS_LIMIT = "archive extracted size exceeds limit";
+const ERROR_ARCHIVE_ENTRY_TRAVERSES_SYMLINK = "archive entry traverses symlink in destination";
 const TAR_SUFFIXES = [".tgz", ".tar.gz", ".tar"];
+const OPEN_WRITE_FLAGS = fsConstants.O_WRONLY |
+    fsConstants.O_CREAT |
+    fsConstants.O_TRUNC |
+    (process.platform !== "win32" && "O_NOFOLLOW" in fsConstants ? fsConstants.O_NOFOLLOW : 0);
 export function resolveArchiveKind(filePath) {
     const lower = filePath.toLowerCase();
     if (lower.endsWith(".zip")) {
@@ -67,53 +81,6 @@ export async function withTimeout(promise, timeoutMs, label) {
         }
     }
 }
-// Path hygiene.
-function normalizeArchivePath(raw) {
-    // Archives may contain Windows separators; treat them as separators.
-    return raw.replaceAll("\\", "/");
-}
-function isWindowsDrivePath(p) {
-    return /^[a-zA-Z]:[\\/]/.test(p);
-}
-function validateArchiveEntryPath(entryPath) {
-    if (!entryPath || entryPath === "." || entryPath === "./") {
-        return;
-    }
-    if (isWindowsDrivePath(entryPath)) {
-        throw new Error(`archive entry uses a drive path: ${entryPath}`);
-    }
-    const normalized = path.posix.normalize(normalizeArchivePath(entryPath));
-    if (normalized === ".." || normalized.startsWith("../")) {
-        throw new Error(`archive entry escapes destination: ${entryPath}`);
-    }
-    if (path.posix.isAbsolute(normalized) || normalized.startsWith("//")) {
-        throw new Error(`archive entry is absolute: ${entryPath}`);
-    }
-}
-function stripArchivePath(entryPath, stripComponents) {
-    const raw = normalizeArchivePath(entryPath);
-    if (!raw || raw === "." || raw === "./") {
-        return null;
-    }
-    // Important: mimic tar --strip-components semantics (raw segments before
-    // normalization) so strip-induced escapes like "a/../b" are not hidden.
-    const parts = raw.split("/").filter((part) => part.length > 0 && part !== ".");
-    const strip = Math.max(0, Math.floor(stripComponents));
-    const stripped = strip === 0 ? parts.join("/") : parts.slice(strip).join("/");
-    const result = path.posix.normalize(stripped);
-    if (!result || result === "." || result === "./") {
-        return null;
-    }
-    return result;
-}
-function resolveCheckedOutPath(destDir, relPath, original) {
-    const safeBase = resolveSafeBaseDir(destDir);
-    const outPath = path.resolve(destDir, relPath);
-    if (!outPath.startsWith(safeBase)) {
-        throw new Error(`archive entry escapes destination: ${original}`);
-    }
-    return outPath;
-}
 function clampLimit(value) {
     if (typeof value !== "number" || !Number.isFinite(value)) {
         return undefined;
@@ -181,6 +148,80 @@ function createExtractBudgetTransform(params) {
         },
     });
 }
+function symlinkTraversalError(originalPath) {
+    return new ArchiveSecurityError("destination-symlink-traversal", `${ERROR_ARCHIVE_ENTRY_TRAVERSES_SYMLINK}: ${originalPath}`);
+}
+async function assertDestinationDirReady(destDir) {
+    const stat = await fs.lstat(destDir);
+    if (stat.isSymbolicLink()) {
+        throw new ArchiveSecurityError("destination-symlink", "archive destination is a symlink");
+    }
+    if (!stat.isDirectory()) {
+        throw new ArchiveSecurityError("destination-not-directory", "archive destination is not a directory");
+    }
+    return await fs.realpath(destDir);
+}
+async function assertNoSymlinkTraversal(params) {
+    const parts = params.relPath.split("/").filter(Boolean);
+    let current = path.resolve(params.rootDir);
+    for (const part of parts) {
+        current = path.join(current, part);
+        let stat;
+        try {
+            stat = await fs.lstat(current);
+        }
+        catch (err) {
+            if (isNotFoundPathError(err)) {
+                continue;
+            }
+            throw err;
+        }
+        if (stat.isSymbolicLink()) {
+            throw symlinkTraversalError(params.originalPath);
+        }
+    }
+}
+async function assertResolvedInsideDestination(params) {
+    let resolved;
+    try {
+        resolved = await fs.realpath(params.targetPath);
+    }
+    catch (err) {
+        if (isNotFoundPathError(err)) {
+            return;
+        }
+        throw err;
+    }
+    if (!isPathInside(params.destinationRealDir, resolved)) {
+        throw symlinkTraversalError(params.originalPath);
+    }
+}
+async function openZipOutputFile(outPath, originalPath) {
+    try {
+        return await fs.open(outPath, OPEN_WRITE_FLAGS, 0o666);
+    }
+    catch (err) {
+        if (isSymlinkOpenError(err)) {
+            throw symlinkTraversalError(originalPath);
+        }
+        throw err;
+    }
+}
+async function cleanupPartialRegularFile(filePath) {
+    let stat;
+    try {
+        stat = await fs.lstat(filePath);
+    }
+    catch (err) {
+        if (isNotFoundPathError(err)) {
+            return;
+        }
+        throw err;
+    }
+    if (stat.isFile()) {
+        await fs.unlink(filePath).catch(() => undefined);
+    }
+}
 async function readZipEntryStream(entry) {
     if (typeof entry.nodeStream === "function") {
         return entry.nodeStream();
@@ -189,8 +230,68 @@ async function readZipEntryStream(entry) {
     const buf = await entry.async("nodebuffer");
     return Readable.from(buf);
 }
+function resolveZipOutputPath(params) {
+    validateArchiveEntryPath(params.entryPath);
+    const relPath = stripArchivePath(params.entryPath, params.strip);
+    if (!relPath) {
+        return null;
+    }
+    validateArchiveEntryPath(relPath);
+    return {
+        relPath,
+        outPath: resolveArchiveOutputPath({
+            rootDir: params.destinationDir,
+            relPath,
+            originalPath: params.entryPath,
+        }),
+    };
+}
+async function prepareZipOutputPath(params) {
+    await assertNoSymlinkTraversal({
+        rootDir: params.destinationDir,
+        relPath: params.relPath,
+        originalPath: params.originalPath,
+    });
+    if (params.isDirectory) {
+        await fs.mkdir(params.outPath, { recursive: true });
+        await assertResolvedInsideDestination({
+            destinationRealDir: params.destinationRealDir,
+            targetPath: params.outPath,
+            originalPath: params.originalPath,
+        });
+        return;
+    }
+    const parentDir = path.dirname(params.outPath);
+    await fs.mkdir(parentDir, { recursive: true });
+    await assertResolvedInsideDestination({
+        destinationRealDir: params.destinationRealDir,
+        targetPath: parentDir,
+        originalPath: params.originalPath,
+    });
+}
+async function writeZipFileEntry(params) {
+    const handle = await openZipOutputFile(params.outPath, params.entry.name);
+    params.budget.startEntry();
+    const readable = await readZipEntryStream(params.entry);
+    const writable = handle.createWriteStream();
+    try {
+        await pipeline(readable, createExtractBudgetTransform({ onChunkBytes: params.budget.addBytes }), writable);
+    }
+    catch (err) {
+        await cleanupPartialRegularFile(params.outPath).catch(() => undefined);
+        throw err;
+    }
+    // Best-effort permission restore for zip entries created on unix.
+    if (typeof params.entry.unixPermissions === "number") {
+        const mode = params.entry.unixPermissions & 0o777;
+        if (mode !== 0) {
+            await fs.chmod(params.outPath, mode).catch(() => undefined);
+        }
+    }
+}
 async function extractZip(params) {
     const limits = resolveExtractLimits(params.limits);
+    const destinationRealDir = await assertDestinationDirReady(params.destDir);
     const stat = await fs.stat(params.archivePath);
     if (stat.size > limits.maxArchiveBytes) {
         throw new Error(ERROR_ARCHIVE_SIZE_EXCEEDS_LIMIT);
@@ -202,34 +303,30 @@ async function extractZip(params) {
     assertArchiveEntryCountWithinLimit(entries.length, limits);
     const budget = createByteBudgetTracker(limits);
     for (const entry of entries) {
-        validateArchiveEntryPath(entry.name);
-        const relPath = stripArchivePath(entry.name, strip);
-        if (!relPath) {
+        const output = resolveZipOutputPath({
+            entryPath: entry.name,
+            strip,
+            destinationDir: params.destDir,
+        });
+        if (!output) {
             continue;
         }
-        validateArchiveEntryPath(relPath);
-        const outPath = resolveCheckedOutPath(params.destDir, relPath, entry.name);
+        await prepareZipOutputPath({
+            destinationDir: params.destDir,
+            destinationRealDir,
+            relPath: output.relPath,
+            outPath: output.outPath,
+            originalPath: entry.name,
+            isDirectory: entry.dir,
+        });
         if (entry.dir) {
-            await fs.mkdir(outPath, { recursive: true });
             continue;
         }
-        await fs.mkdir(path.dirname(outPath), { recursive: true });
-        budget.startEntry();
-        const readable = await readZipEntryStream(entry);
-        try {
-            await pipeline(readable, createExtractBudgetTransform({ onChunkBytes: budget.addBytes }), createWriteStream(outPath));
-        }
-        catch (err) {
-            await fs.unlink(outPath).catch(() => undefined);
-            throw err;
-        }
-        // Best-effort permission restore for zip entries created on unix.
-        if (typeof entry.unixPermissions === "number") {
-            const mode = entry.unixPermissions & 0o777;
-            if (mode !== 0) {
-                await fs.chmod(outPath, mode).catch(() => undefined);
-            }
-        }
+        await writeZipFileEntry({
+            entry,
+            outPath: output.outPath,
+            budget,
+        });
     }
 }
 function readTarEntryInfo(entry) {
@@ -275,7 +372,11 @@ export async function extractArchive(params) {
                         return;
                     }
                     validateArchiveEntryPath(relPath);
-                    resolveCheckedOutPath(params.destDir, relPath, info.path);
+                    resolveArchiveOutputPath({
+                        rootDir: params.destDir,
+                        relPath,
+                        originalPath: info.path,
+                    });
                     if (info.type === "SymbolicLink" ||
                         info.type === "Link" ||
                         info.type === "BlockDevice" ||

package/dist/infra/control-ui-assets.js

@@ -11,7 +11,10 @@ export function resolveControlUiDistIndexPathForRoot(root) {
 export async function resolveControlUiDistIndexHealth(opts = {}) {
     const indexPath = opts.root
         ? resolveControlUiDistIndexPathForRoot(opts.root)
-        : await resolveControlUiDistIndexPath(opts.argv1 ?? process.argv[1]);
+        : await resolveControlUiDistIndexPath({
+            argv1: opts.argv1 ?? process.argv[1],
+            moduleUrl: opts.moduleUrl,
+        });
     return {
         indexPath,
         exists: Boolean(indexPath && fs.existsSync(indexPath)),
@@ -44,7 +47,9 @@ export function resolveControlUiRepoRoot(argv1 = process.argv[1]) {
     }
     return null;
 }
-export async function resolveControlUiDistIndexPath(argv1 = process.argv[1]) {
+export async function resolveControlUiDistIndexPath(argv1OrOpts) {
+    const argv1 = typeof argv1OrOpts === "string" ? argv1OrOpts : (argv1OrOpts?.argv1 ?? process.argv[1]);
+    const moduleUrl = typeof argv1OrOpts === "object" ? argv1OrOpts?.moduleUrl : undefined;
     if (!argv1) {
         return null;
     }
@@ -54,7 +59,7 @@ export async function resolveControlUiDistIndexPath(argv1 = process.argv[1]) {
     if (path.basename(distDir) === "dist") {
         return path.join(distDir, "control-ui", "index.html");
     }
-    const packageRoot = await resolvePoolBotPackageRoot({ argv1: normalized });
+    const packageRoot = await resolvePoolBotPackageRoot({ argv1: normalized, moduleUrl });
     if (packageRoot) {
         return path.join(packageRoot, "dist", "control-ui", "index.html");
     }
@@ -64,16 +69,19 @@ export async function resolveControlUiDistIndexPath(argv1 = process.argv[1]) {
     for (let i = 0; i < 8; i++) {
         const pkgJsonPath = path.join(dir, "package.json");
         const indexPath = path.join(dir, "dist", "control-ui", "index.html");
-        if (fs.existsSync(pkgJsonPath) && fs.existsSync(indexPath)) {
+        if (fs.existsSync(pkgJsonPath)) {
             try {
                 const raw = fs.readFileSync(pkgJsonPath, "utf-8");
                 const parsed = JSON.parse(raw);
                 if (parsed.name === "poolbot") {
-                    return indexPath;
+                    return fs.existsSync(indexPath) ? indexPath : null;
                 }
+                // Stop at the first package boundary to avoid resolving through unrelated ancestors.
+                return null;
             }
             catch {
-                // Invalid package.json, continue searching
+                // Invalid package.json at package boundary; abort fallback resolution.
+                return null;
             }
         }
         const parent = path.dirname(dir);