@poolzin/pool-bot 2026.2.24 → 2026.2.26

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-path.js

@@ -0,0 +1,49 @@
+import path from "node:path";
+import { resolveSafeBaseDir } from "./path-safety.js";
+export function isWindowsDrivePath(value) {
+    return /^[a-zA-Z]:[\\/]/.test(value);
+}
+export function normalizeArchiveEntryPath(raw) {
+    return raw.replaceAll("\\", "/");
+}
+export function validateArchiveEntryPath(entryPath, params) {
+    if (!entryPath || entryPath === "." || entryPath === "./") {
+        return;
+    }
+    if (isWindowsDrivePath(entryPath)) {
+        throw new Error(`archive entry uses a drive path: ${entryPath}`);
+    }
+    const normalized = path.posix.normalize(normalizeArchiveEntryPath(entryPath));
+    const escapeLabel = params?.escapeLabel ?? "destination";
+    if (normalized === ".." || normalized.startsWith("../")) {
+        throw new Error(`archive entry escapes ${escapeLabel}: ${entryPath}`);
+    }
+    if (path.posix.isAbsolute(normalized) || normalized.startsWith("//")) {
+        throw new Error(`archive entry is absolute: ${entryPath}`);
+    }
+}
+export function stripArchivePath(entryPath, stripComponents) {
+    const raw = normalizeArchiveEntryPath(entryPath);
+    if (!raw || raw === "." || raw === "./") {
+        return null;
+    }
+    // Mimic tar --strip-components semantics (raw segments before normalization)
+    // so strip-induced escapes like "a/../b" are visible to validators.
+    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;
+}
+export function resolveArchiveOutputPath(params) {
+    const safeBase = resolveSafeBaseDir(params.rootDir);
+    const outPath = path.resolve(params.rootDir, params.relPath);
+    const escapeLabel = params.escapeLabel ?? "destination";
+    if (!outPath.startsWith(safeBase)) {
+        throw new Error(`archive entry escapes ${escapeLabel}: ${params.originalPath}`);
+    }
+    return outPath;
+}

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);