@poolzin/pool-bot 2026.2.23 → 2026.2.25

package/dist/infra/restart.js

@@ -1,15 +1,109 @@
 import { spawnSync } from "node:child_process";
 import { resolveGatewayLaunchAgentLabel, resolveGatewaySystemdServiceName, } from "../daemon/constants.js";
+import { createSubsystemLogger } from "../logging/subsystem.js";
 const SPAWN_TIMEOUT_MS = 2000;
 const SIGUSR1_AUTH_GRACE_MS = 5000;
+const DEFAULT_DEFERRAL_POLL_MS = 500;
+const DEFAULT_DEFERRAL_MAX_WAIT_MS = 30_000;
+const RESTART_COOLDOWN_MS = 30_000;
+const restartLog = createSubsystemLogger("restart");
 let sigusr1AuthorizedCount = 0;
 let sigusr1AuthorizedUntil = 0;
 let sigusr1ExternalAllowed = false;
+let preRestartCheck = null;
+let restartCycleToken = 0;
+let emittedRestartToken = 0;
+let consumedRestartToken = 0;
+let lastRestartEmittedAt = 0;
+let pendingRestartTimer = null;
+let pendingRestartDueAt = 0;
+let pendingRestartReason;
+function hasUnconsumedRestartSignal() {
+    return emittedRestartToken > consumedRestartToken;
+}
+function clearPendingScheduledRestart() {
+    if (pendingRestartTimer) {
+        clearTimeout(pendingRestartTimer);
+    }
+    pendingRestartTimer = null;
+    pendingRestartDueAt = 0;
+    pendingRestartReason = undefined;
+}
+function summarizeChangedPaths(paths, maxPaths = 6) {
+    if (!Array.isArray(paths) || paths.length === 0) {
+        return null;
+    }
+    if (paths.length <= maxPaths) {
+        return paths.join(",");
+    }
+    const head = paths.slice(0, maxPaths).join(",");
+    return `${head},+${paths.length - maxPaths} more`;
+}
+function formatRestartAudit(audit) {
+    const actor = typeof audit?.actor === "string" && audit.actor.trim() ? audit.actor.trim() : null;
+    const deviceId = typeof audit?.deviceId === "string" && audit.deviceId.trim() ? audit.deviceId.trim() : null;
+    const clientIp = typeof audit?.clientIp === "string" && audit.clientIp.trim() ? audit.clientIp.trim() : null;
+    const changed = summarizeChangedPaths(audit?.changedPaths);
+    const fields = [];
+    if (actor) {
+        fields.push(`actor=${actor}`);
+    }
+    if (deviceId) {
+        fields.push(`device=${deviceId}`);
+    }
+    if (clientIp) {
+        fields.push(`ip=${clientIp}`);
+    }
+    if (changed) {
+        fields.push(`changedPaths=${changed}`);
+    }
+    return fields.length > 0 ? fields.join(" ") : "actor=<unknown>";
+}
+/**
+ * Register a callback that scheduleGatewaySigusr1Restart checks before emitting SIGUSR1.
+ * The callback should return the number of pending items (0 = safe to restart).
+ */
+export function setPreRestartDeferralCheck(fn) {
+    preRestartCheck = fn;
+}
+/**
+ * Emit an authorized SIGUSR1 gateway restart, guarded against duplicate emissions.
+ * Returns true if SIGUSR1 was emitted, false if a restart was already emitted.
+ * Both scheduleGatewaySigusr1Restart and the config watcher should use this
+ * to ensure only one restart fires.
+ */
+export function emitGatewayRestart() {
+    if (hasUnconsumedRestartSignal()) {
+        clearPendingScheduledRestart();
+        return false;
+    }
+    clearPendingScheduledRestart();
+    const cycleToken = ++restartCycleToken;
+    emittedRestartToken = cycleToken;
+    authorizeGatewaySigusr1Restart();
+    try {
+        if (process.listenerCount("SIGUSR1") > 0) {
+            process.emit("SIGUSR1");
+        }
+        else {
+            process.kill(process.pid, "SIGUSR1");
+        }
+    }
+    catch {
+        // Roll back the cycle marker so future restart requests can still proceed.
+        emittedRestartToken = consumedRestartToken;
+        return false;
+    }
+    lastRestartEmittedAt = Date.now();
+    return true;
+}
 function resetSigusr1AuthorizationIfExpired(now = Date.now()) {
-    if (sigusr1AuthorizedCount <= 0)
+    if (sigusr1AuthorizedCount <= 0) {
         return;
-    if (now <= sigusr1AuthorizedUntil)
+    }
+    if (now <= sigusr1AuthorizedUntil) {
         return;
+    }
     sigusr1AuthorizedCount = 0;
     sigusr1AuthorizedUntil = 0;
 }
@@ -19,7 +113,7 @@ export function setGatewaySigusr1RestartPolicy(opts) {
 export function isGatewaySigusr1RestartExternallyAllowed() {
     return sigusr1ExternalAllowed;
 }
-export function authorizeGatewaySigusr1Restart(delayMs = 0) {
+function authorizeGatewaySigusr1Restart(delayMs = 0) {
     const delay = Math.max(0, Math.floor(delayMs));
     const expiresAt = Date.now() + delay + SIGUSR1_AUTH_GRACE_MS;
     sigusr1AuthorizedCount += 1;
@@ -29,24 +123,87 @@ export function authorizeGatewaySigusr1Restart(delayMs = 0) {
 }
 export function consumeGatewaySigusr1RestartAuthorization() {
     resetSigusr1AuthorizationIfExpired();
-    if (sigusr1AuthorizedCount <= 0)
+    if (sigusr1AuthorizedCount <= 0) {
         return false;
+    }
     sigusr1AuthorizedCount -= 1;
     if (sigusr1AuthorizedCount <= 0) {
         sigusr1AuthorizedUntil = 0;
     }
     return true;
 }
+/**
+ * Mark the currently emitted SIGUSR1 restart cycle as consumed by the run loop.
+ * This explicitly advances the cycle state instead of resetting emit guards inside
+ * consumeGatewaySigusr1RestartAuthorization().
+ */
+export function markGatewaySigusr1RestartHandled() {
+    if (hasUnconsumedRestartSignal()) {
+        consumedRestartToken = emittedRestartToken;
+    }
+}
+/**
+ * Poll pending work until it drains (or times out), then emit one restart signal.
+ * Shared by both the direct RPC restart path and the config watcher path.
+ */
+export function deferGatewayRestartUntilIdle(opts) {
+    const pollMsRaw = opts.pollMs ?? DEFAULT_DEFERRAL_POLL_MS;
+    const pollMs = Math.max(10, Math.floor(pollMsRaw));
+    const maxWaitMsRaw = opts.maxWaitMs ?? DEFAULT_DEFERRAL_MAX_WAIT_MS;
+    const maxWaitMs = Math.max(pollMs, Math.floor(maxWaitMsRaw));
+    let pending;
+    try {
+        pending = opts.getPendingCount();
+    }
+    catch (err) {
+        opts.hooks?.onCheckError?.(err);
+        emitGatewayRestart();
+        return;
+    }
+    if (pending <= 0) {
+        opts.hooks?.onReady?.();
+        emitGatewayRestart();
+        return;
+    }
+    opts.hooks?.onDeferring?.(pending);
+    const startedAt = Date.now();
+    const poll = setInterval(() => {
+        let current;
+        try {
+            current = opts.getPendingCount();
+        }
+        catch (err) {
+            clearInterval(poll);
+            opts.hooks?.onCheckError?.(err);
+            emitGatewayRestart();
+            return;
+        }
+        if (current <= 0) {
+            clearInterval(poll);
+            opts.hooks?.onReady?.();
+            emitGatewayRestart();
+            return;
+        }
+        const elapsedMs = Date.now() - startedAt;
+        if (elapsedMs >= maxWaitMs) {
+            clearInterval(poll);
+            opts.hooks?.onTimeout?.(current, elapsedMs);
+            emitGatewayRestart();
+        }
+    }, pollMs);
+}
 function formatSpawnDetail(result) {
     const clean = (value) => {
         const text = typeof value === "string" ? value : value ? value.toString() : "";
         return text.replace(/\s+/g, " ").trim();
     };
     if (result.error) {
-        if (result.error instanceof Error)
+        if (result.error instanceof Error) {
             return result.error.message;
-        if (typeof result.error === "string")
+        }
+        if (typeof result.error === "string") {
             return result.error;
+        }
         try {
             return JSON.stringify(result.error);
         }
@@ -55,13 +212,16 @@ function formatSpawnDetail(result) {
         }
     }
     const stderr = clean(result.stderr);
-    if (stderr)
+    if (stderr) {
         return stderr;
+    }
     const stdout = clean(result.stdout);
-    if (stdout)
+    if (stdout) {
         return stdout;
-    if (typeof result.status === "number")
+    }
+    if (typeof result.status === "number") {
         return `exit ${result.status}`;
+    }
     return "unknown error";
 }
 function normalizeSystemdUnit(raw, profile) {
@@ -138,29 +298,66 @@ export function scheduleGatewaySigusr1Restart(opts) {
     const reason = typeof opts?.reason === "string" && opts.reason.trim()
         ? opts.reason.trim().slice(0, 200)
         : undefined;
-    authorizeGatewaySigusr1Restart(delayMs);
-    const pid = process.pid;
-    const hasListener = process.listenerCount("SIGUSR1") > 0;
-    setTimeout(() => {
-        try {
-            if (hasListener) {
-                process.emit("SIGUSR1");
-            }
-            else {
-                process.kill(pid, "SIGUSR1");
-            }
+    const mode = process.listenerCount("SIGUSR1") > 0 ? "emit" : "signal";
+    const nowMs = Date.now();
+    const cooldownMsApplied = Math.max(0, lastRestartEmittedAt + RESTART_COOLDOWN_MS - nowMs);
+    const requestedDueAt = nowMs + delayMs + cooldownMsApplied;
+    if (hasUnconsumedRestartSignal()) {
+        restartLog.warn(`restart request coalesced (already in-flight) reason=${reason ?? "unspecified"} ${formatRestartAudit(opts?.audit)}`);
+        return {
+            ok: true,
+            pid: process.pid,
+            signal: "SIGUSR1",
+            delayMs: 0,
+            reason,
+            mode,
+            coalesced: true,
+            cooldownMsApplied,
+        };
+    }
+    if (pendingRestartTimer) {
+        const remainingMs = Math.max(0, pendingRestartDueAt - nowMs);
+        const shouldPullEarlier = requestedDueAt < pendingRestartDueAt;
+        if (shouldPullEarlier) {
+            restartLog.warn(`restart request rescheduled earlier reason=${reason ?? "unspecified"} pendingReason=${pendingRestartReason ?? "unspecified"} oldDelayMs=${remainingMs} newDelayMs=${Math.max(0, requestedDueAt - nowMs)} ${formatRestartAudit(opts?.audit)}`);
+            clearPendingScheduledRestart();
         }
-        catch {
-            /* ignore */
+        else {
+            restartLog.warn(`restart request coalesced (already scheduled) reason=${reason ?? "unspecified"} pendingReason=${pendingRestartReason ?? "unspecified"} delayMs=${remainingMs} ${formatRestartAudit(opts?.audit)}`);
+            return {
+                ok: true,
+                pid: process.pid,
+                signal: "SIGUSR1",
+                delayMs: remainingMs,
+                reason,
+                mode,
+                coalesced: true,
+                cooldownMsApplied,
+            };
+        }
+    }
+    pendingRestartDueAt = requestedDueAt;
+    pendingRestartReason = reason;
+    pendingRestartTimer = setTimeout(() => {
+        pendingRestartTimer = null;
+        pendingRestartDueAt = 0;
+        pendingRestartReason = undefined;
+        const pendingCheck = preRestartCheck;
+        if (!pendingCheck) {
+            emitGatewayRestart();
+            return;
         }
-    }, delayMs);
+        deferGatewayRestartUntilIdle({ getPendingCount: pendingCheck });
+    }, Math.max(0, requestedDueAt - nowMs));
     return {
         ok: true,
-        pid,
+        pid: process.pid,
         signal: "SIGUSR1",
-        delayMs,
+        delayMs: Math.max(0, requestedDueAt - nowMs),
         reason,
-        mode: hasListener ? "emit" : "signal",
+        mode,
+        coalesced: false,
+        cooldownMsApplied,
     };
 }
 export const __testing = {
@@ -168,5 +365,11 @@ export const __testing = {
         sigusr1AuthorizedCount = 0;
         sigusr1AuthorizedUntil = 0;
         sigusr1ExternalAllowed = false;
+        preRestartCheck = null;
+        restartCycleToken = 0;
+        emittedRestartToken = 0;
+        consumedRestartToken = 0;
+        lastRestartEmittedAt = 0;
+        clearPendingScheduledRestart();
     },
 };

package/dist/infra/scp-host.js

@@ -0,0 +1,54 @@
+const SSH_TOKEN = /^[A-Za-z0-9._-]+$/;
+const BRACKETED_IPV6 = /^\[[0-9A-Fa-f:.%]+\]$/;
+const WHITESPACE = /\s/;
+function hasControlOrWhitespace(value) {
+    for (const char of value) {
+        const code = char.charCodeAt(0);
+        if (code <= 0x1f || code === 0x7f || WHITESPACE.test(char)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function normalizeScpRemoteHost(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    if (hasControlOrWhitespace(trimmed)) {
+        return undefined;
+    }
+    if (trimmed.startsWith("-") || trimmed.includes("/") || trimmed.includes("\\")) {
+        return undefined;
+    }
+    const firstAt = trimmed.indexOf("@");
+    const lastAt = trimmed.lastIndexOf("@");
+    let user;
+    let host = trimmed;
+    if (firstAt !== -1) {
+        if (firstAt !== lastAt || firstAt === 0 || firstAt === trimmed.length - 1) {
+            return undefined;
+        }
+        user = trimmed.slice(0, firstAt);
+        host = trimmed.slice(firstAt + 1);
+        if (!SSH_TOKEN.test(user)) {
+            return undefined;
+        }
+    }
+    if (!host || host.startsWith("-") || host.includes("@")) {
+        return undefined;
+    }
+    if (host.includes(":") && !BRACKETED_IPV6.test(host)) {
+        return undefined;
+    }
+    if (!SSH_TOKEN.test(host) && !BRACKETED_IPV6.test(host)) {
+        return undefined;
+    }
+    return user ? `${user}@${host}` : host;
+}
+export function isSafeScpRemoteHost(value) {
+    return normalizeScpRemoteHost(value) !== undefined;
+}

package/dist/infra/update-startup.js

@@ -1,18 +1,27 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import { formatCliCommand } from "../cli/command-format.js";
 import { resolveStateDir } from "../config/paths.js";
+import { VERSION } from "../version.js";
 import { resolvePoolBotPackageRoot } from "./poolbot-root.js";
-import { compareSemverStrings, resolveNpmChannelTag, checkUpdateStatus } from "./update-check.js";
 import { normalizeUpdateChannel, DEFAULT_PACKAGE_CHANNEL } from "./update-channels.js";
-import { VERSION } from "../version.js";
-import { formatCliCommand } from "../cli/command-format.js";
+import { compareSemverStrings, resolveNpmChannelTag, checkUpdateStatus } from "./update-check.js";
+let updateAvailableCache = null;
+export function getUpdateAvailable() {
+    return updateAvailableCache;
+}
+export function resetUpdateAvailableStateForTest() {
+    updateAvailableCache = null;
+}
 const UPDATE_CHECK_FILENAME = "update-check.json";
 const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
 function shouldSkipCheck(allowInTests) {
-    if (allowInTests)
+    if (allowInTests) {
         return false;
-    if (process.env.VITEST || process.env.NODE_ENV === "test")
+    }
+    if (process.env.VITEST || process.env.NODE_ENV === "test") {
         return true;
+    }
     return false;
 }
 async function readState(statePath) {
@@ -29,20 +38,63 @@ async function writeState(statePath, state) {
     await fs.mkdir(path.dirname(statePath), { recursive: true });
     await fs.writeFile(statePath, JSON.stringify(state, null, 2), "utf-8");
 }
+function sameUpdateAvailable(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (!a || !b) {
+        return false;
+    }
+    return (a.currentVersion === b.currentVersion &&
+        a.latestVersion === b.latestVersion &&
+        a.channel === b.channel);
+}
+function setUpdateAvailableCache(params) {
+    if (sameUpdateAvailable(updateAvailableCache, params.next)) {
+        return;
+    }
+    updateAvailableCache = params.next;
+    params.onUpdateAvailableChange?.(params.next);
+}
+function resolvePersistedUpdateAvailable(state) {
+    const latestVersion = state.lastAvailableVersion?.trim();
+    if (!latestVersion) {
+        return null;
+    }
+    const cmp = compareSemverStrings(VERSION, latestVersion);
+    if (cmp == null || cmp >= 0) {
+        return null;
+    }
+    const channel = state.lastAvailableTag?.trim() || DEFAULT_PACKAGE_CHANNEL;
+    return {
+        currentVersion: VERSION,
+        latestVersion,
+        channel,
+    };
+}
 export async function runGatewayUpdateCheck(params) {
-    if (shouldSkipCheck(Boolean(params.allowInTests)))
+    if (shouldSkipCheck(Boolean(params.allowInTests))) {
         return;
-    if (params.isNixMode)
+    }
+    if (params.isNixMode) {
         return;
-    if (params.cfg.update?.checkOnStart === false)
+    }
+    if (params.cfg.update?.checkOnStart === false) {
         return;
+    }
     const statePath = path.join(resolveStateDir(), UPDATE_CHECK_FILENAME);
     const state = await readState(statePath);
     const now = Date.now();
     const lastCheckedAt = state.lastCheckedAt ? Date.parse(state.lastCheckedAt) : null;
+    const persistedAvailable = resolvePersistedUpdateAvailable(state);
+    setUpdateAvailableCache({
+        next: persistedAvailable,
+        onUpdateAvailableChange: params.onUpdateAvailableChange,
+    });
     if (lastCheckedAt && Number.isFinite(lastCheckedAt)) {
-        if (now - lastCheckedAt < UPDATE_CHECK_INTERVAL_MS)
+        if (now - lastCheckedAt < UPDATE_CHECK_INTERVAL_MS) {
             return;
+        }
     }
     const root = await resolvePoolBotPackageRoot({
         moduleUrl: import.meta.url,
@@ -60,6 +112,12 @@ export async function runGatewayUpdateCheck(params) {
         lastCheckedAt: new Date(now).toISOString(),
     };
     if (status.installKind !== "package") {
+        delete nextState.lastAvailableVersion;
+        delete nextState.lastAvailableTag;
+        setUpdateAvailableCache({
+            next: null,
+            onUpdateAvailableChange: params.onUpdateAvailableChange,
+        });
         await writeState(statePath, nextState);
         return;
     }
@@ -72,6 +130,17 @@ export async function runGatewayUpdateCheck(params) {
     }
     const cmp = compareSemverStrings(VERSION, resolved.version);
     if (cmp != null && cmp < 0) {
+        const nextAvailable = {
+            currentVersion: VERSION,
+            latestVersion: resolved.version,
+            channel: tag,
+        };
+        setUpdateAvailableCache({
+            next: nextAvailable,
+            onUpdateAvailableChange: params.onUpdateAvailableChange,
+        });
+        nextState.lastAvailableVersion = resolved.version;
+        nextState.lastAvailableTag = tag;
         const shouldNotify = state.lastNotifiedVersion !== resolved.version || state.lastNotifiedTag !== tag;
         if (shouldNotify) {
             params.log.info(`update available (${tag}): v${resolved.version} (current v${VERSION}). Run: ${formatCliCommand("poolbot update")}`);
@@ -79,6 +148,14 @@ export async function runGatewayUpdateCheck(params) {
             nextState.lastNotifiedTag = tag;
         }
     }
+    else {
+        delete nextState.lastAvailableVersion;
+        delete nextState.lastAvailableTag;
+        setUpdateAvailableCache({
+            next: null,
+            onUpdateAvailableChange: params.onUpdateAvailableChange,
+        });
+    }
     await writeState(statePath, nextState);
 }
 export function scheduleGatewayUpdateCheck(params) {

package/dist/media/inbound-path-policy.js

@@ -0,0 +1,114 @@
+import path from "node:path";
+const WILDCARD_SEGMENT = "*";
+const WINDOWS_DRIVE_ABS_RE = /^[A-Za-z]:\//;
+const WINDOWS_DRIVE_ROOT_RE = /^[A-Za-z]:$/;
+export const DEFAULT_IMESSAGE_ATTACHMENT_ROOTS = ["/Users/*/Library/Messages/Attachments"];
+function normalizePosixAbsolutePath(value) {
+    const trimmed = value.trim();
+    if (!trimmed || trimmed.includes("\0")) {
+        return undefined;
+    }
+    const normalized = path.posix.normalize(trimmed.replaceAll("\\", "/"));
+    const isAbsolute = normalized.startsWith("/") || WINDOWS_DRIVE_ABS_RE.test(normalized);
+    if (!isAbsolute || normalized === "/") {
+        return undefined;
+    }
+    const withoutTrailingSlash = normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+    if (WINDOWS_DRIVE_ROOT_RE.test(withoutTrailingSlash)) {
+        return undefined;
+    }
+    return withoutTrailingSlash;
+}
+function splitPathSegments(value) {
+    return value.split("/").filter(Boolean);
+}
+function matchesRootPattern(params) {
+    const candidateSegments = splitPathSegments(params.candidatePath);
+    const rootSegments = splitPathSegments(params.rootPattern);
+    if (candidateSegments.length < rootSegments.length) {
+        return false;
+    }
+    for (let idx = 0; idx < rootSegments.length; idx += 1) {
+        const expected = rootSegments[idx];
+        const actual = candidateSegments[idx];
+        if (expected === WILDCARD_SEGMENT) {
+            continue;
+        }
+        if (expected !== actual) {
+            return false;
+        }
+    }
+    return true;
+}
+export function isValidInboundPathRootPattern(value) {
+    const normalized = normalizePosixAbsolutePath(value);
+    if (!normalized) {
+        return false;
+    }
+    const segments = splitPathSegments(normalized);
+    if (segments.length === 0) {
+        return false;
+    }
+    return segments.every((segment) => segment === WILDCARD_SEGMENT || !segment.includes("*"));
+}
+export function normalizeInboundPathRoots(roots) {
+    const normalized = [];
+    const seen = new Set();
+    for (const root of roots ?? []) {
+        if (typeof root !== "string") {
+            continue;
+        }
+        if (!isValidInboundPathRootPattern(root)) {
+            continue;
+        }
+        const candidate = normalizePosixAbsolutePath(root);
+        if (!candidate || seen.has(candidate)) {
+            continue;
+        }
+        seen.add(candidate);
+        normalized.push(candidate);
+    }
+    return normalized;
+}
+export function mergeInboundPathRoots(...rootsLists) {
+    const merged = [];
+    const seen = new Set();
+    for (const roots of rootsLists) {
+        const normalized = normalizeInboundPathRoots(roots);
+        for (const root of normalized) {
+            if (seen.has(root)) {
+                continue;
+            }
+            seen.add(root);
+            merged.push(root);
+        }
+    }
+    return merged;
+}
+export function isInboundPathAllowed(params) {
+    const candidatePath = normalizePosixAbsolutePath(params.filePath);
+    if (!candidatePath) {
+        return false;
+    }
+    const roots = normalizeInboundPathRoots(params.roots);
+    const effectiveRoots = roots.length > 0 ? roots : normalizeInboundPathRoots(params.fallbackRoots ?? undefined);
+    if (effectiveRoots.length === 0) {
+        return false;
+    }
+    return effectiveRoots.some((rootPattern) => matchesRootPattern({ candidatePath, rootPattern }));
+}
+function resolveIMessageAccountConfig(params) {
+    const accountId = params.accountId?.trim();
+    if (!accountId) {
+        return undefined;
+    }
+    return params.cfg.channels?.imessage?.accounts?.[accountId];
+}
+export function resolveIMessageAttachmentRoots(params) {
+    const accountConfig = resolveIMessageAccountConfig(params);
+    return mergeInboundPathRoots(accountConfig?.attachmentRoots, params.cfg.channels?.imessage?.attachmentRoots, DEFAULT_IMESSAGE_ATTACHMENT_ROOTS);
+}
+export function resolveIMessageRemoteAttachmentRoots(params) {
+    const accountConfig = resolveIMessageAccountConfig(params);
+    return mergeInboundPathRoots(accountConfig?.remoteAttachmentRoots, params.cfg.channels?.imessage?.remoteAttachmentRoots, accountConfig?.attachmentRoots, params.cfg.channels?.imessage?.attachmentRoots, DEFAULT_IMESSAGE_ATTACHMENT_ROOTS);
+}

package/dist/media/input-files.js

@@ -62,6 +62,22 @@ export function normalizeMimeList(values, fallback) {
     const input = values && values.length > 0 ? values : fallback;
     return new Set(input.map((value) => normalizeMimeType(value)).filter(Boolean));
 }
+export function resolveInputFileLimits(config) {
+    return {
+        allowUrl: config?.allowUrl ?? true,
+        allowedMimes: normalizeMimeList(config?.allowedMimes, DEFAULT_INPUT_FILE_MIMES),
+        maxBytes: config?.maxBytes ?? DEFAULT_INPUT_FILE_MAX_BYTES,
+        maxChars: config?.maxChars ?? DEFAULT_INPUT_FILE_MAX_CHARS,
+        maxRedirects: config?.maxRedirects ?? DEFAULT_INPUT_MAX_REDIRECTS,
+        timeoutMs: config?.timeoutMs ?? DEFAULT_INPUT_TIMEOUT_MS,
+        urlAllowlist: config?.urlAllowlist,
+        pdf: {
+            maxPages: config?.pdf?.maxPages ?? DEFAULT_INPUT_PDF_MAX_PAGES,
+            maxPixels: config?.pdf?.maxPixels ?? DEFAULT_INPUT_PDF_MAX_PIXELS,
+            minTextChars: config?.pdf?.minTextChars ?? DEFAULT_INPUT_PDF_MIN_TEXT_CHARS,
+        },
+    };
+}
 export async function fetchWithGuard(params) {
     let currentUrl = params.url;
     let redirectCount = 0;

package/dist/memory/test-manager.js

@@ -0,0 +1,8 @@
+import { getMemorySearchManager } from "./index.js";
+export async function createMemoryManagerOrThrow(cfg, agentId = "main") {
+    const result = await getMemorySearchManager({ cfg, agentId });
+    if (!result.manager) {
+        throw new Error("manager missing");
+    }
+    return result.manager;
+}