@poolzin/pool-bot 2026.3.25 → 2026.3.26

package/dist/auto-reply/auto-reply/reply/session-updates.js

@@ -0,0 +1,233 @@
+import crypto from "node:crypto";
+import { resolveUserTimezone } from "../../agents/date-time.js";
+import { buildWorkspaceSkillSnapshot } from "../../agents/skills.js";
+import { ensureSkillsWatcher, getSkillsSnapshotVersion } from "../../agents/skills/refresh.js";
+import { updateSessionStore } from "../../config/sessions.js";
+import { buildChannelSummary } from "../../infra/channel-summary.js";
+import { getRemoteSkillEligibility } from "../../infra/skills-remote.js";
+import { drainSystemEventEntries } from "../../infra/system-events.js";
+export async function prependSystemEvents(params) {
+    const compactSystemEvent = (line) => {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return null;
+        const lower = trimmed.toLowerCase();
+        if (lower.includes("reason periodic"))
+            return null;
+        // Filter out the actual heartbeat prompt, but not cron jobs that mention "heartbeat"
+        // The heartbeat prompt starts with "Read HEARTBEAT.md" - cron payloads won't match this
+        if (lower.startsWith("read heartbeat.md"))
+            return null;
+        // Also filter heartbeat poll/wake noise
+        if (lower.includes("heartbeat poll") || lower.includes("heartbeat wake"))
+            return null;
+        if (trimmed.startsWith("Node:")) {
+            return trimmed.replace(/ · last input [^·]+/i, "").trim();
+        }
+        return trimmed;
+    };
+    const resolveExplicitTimezone = (value) => {
+        try {
+            new Intl.DateTimeFormat("en-US", { timeZone: value }).format(new Date());
+            return value;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const resolveSystemEventTimezone = (cfg) => {
+        const raw = cfg.agents?.defaults?.envelopeTimezone?.trim();
+        if (!raw)
+            return { mode: "local" };
+        const lowered = raw.toLowerCase();
+        if (lowered === "utc" || lowered === "gmt")
+            return { mode: "utc" };
+        if (lowered === "local" || lowered === "host")
+            return { mode: "local" };
+        if (lowered === "user") {
+            return {
+                mode: "iana",
+                timeZone: resolveUserTimezone(cfg.agents?.defaults?.userTimezone),
+            };
+        }
+        const explicit = resolveExplicitTimezone(raw);
+        return explicit ? { mode: "iana", timeZone: explicit } : { mode: "local" };
+    };
+    const formatUtcTimestamp = (date) => {
+        const yyyy = String(date.getUTCFullYear()).padStart(4, "0");
+        const mm = String(date.getUTCMonth() + 1).padStart(2, "0");
+        const dd = String(date.getUTCDate()).padStart(2, "0");
+        const hh = String(date.getUTCHours()).padStart(2, "0");
+        const min = String(date.getUTCMinutes()).padStart(2, "0");
+        const sec = String(date.getUTCSeconds()).padStart(2, "0");
+        return `${yyyy}-${mm}-${dd}T${hh}:${min}:${sec}Z`;
+    };
+    const formatZonedTimestamp = (date, timeZone) => {
+        const parts = new Intl.DateTimeFormat("en-US", {
+            timeZone,
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+            second: "2-digit",
+            hourCycle: "h23",
+            timeZoneName: "short",
+        }).formatToParts(date);
+        const pick = (type) => parts.find((part) => part.type === type)?.value;
+        const yyyy = pick("year");
+        const mm = pick("month");
+        const dd = pick("day");
+        const hh = pick("hour");
+        const min = pick("minute");
+        const sec = pick("second");
+        const tz = [...parts]
+            .reverse()
+            .find((part) => part.type === "timeZoneName")
+            ?.value?.trim();
+        if (!yyyy || !mm || !dd || !hh || !min || !sec)
+            return undefined;
+        return `${yyyy}-${mm}-${dd} ${hh}:${min}:${sec}${tz ? ` ${tz}` : ""}`;
+    };
+    const formatSystemEventTimestamp = (ts, cfg) => {
+        const date = new Date(ts);
+        if (Number.isNaN(date.getTime()))
+            return "unknown-time";
+        const zone = resolveSystemEventTimezone(cfg);
+        if (zone.mode === "utc")
+            return formatUtcTimestamp(date);
+        if (zone.mode === "local")
+            return formatZonedTimestamp(date) ?? "unknown-time";
+        return formatZonedTimestamp(date, zone.timeZone) ?? "unknown-time";
+    };
+    const systemLines = [];
+    const queued = drainSystemEventEntries(params.sessionKey);
+    systemLines.push(...queued
+        .map((event) => {
+        const compacted = compactSystemEvent(event.text);
+        if (!compacted)
+            return null;
+        return `[${formatSystemEventTimestamp(event.ts, params.cfg)}] ${compacted}`;
+    })
+        .filter((v) => Boolean(v)));
+    if (params.isMainSession && params.isNewSession) {
+        const summary = await buildChannelSummary(params.cfg);
+        if (summary.length > 0)
+            systemLines.unshift(...summary);
+    }
+    if (systemLines.length === 0)
+        return params.prefixedBodyBase;
+    const block = systemLines.map((l) => `System: ${l}`).join("\n");
+    return `${block}\n\n${params.prefixedBodyBase}`;
+}
+export async function ensureSkillSnapshot(params) {
+    const { sessionEntry, sessionStore, sessionKey, storePath, sessionId, isFirstTurnInSession, workspaceDir, cfg, skillFilter, } = params;
+    let nextEntry = sessionEntry;
+    let systemSent = sessionEntry?.systemSent ?? false;
+    const remoteEligibility = getRemoteSkillEligibility();
+    const snapshotVersion = getSkillsSnapshotVersion(workspaceDir);
+    ensureSkillsWatcher({ workspaceDir, config: cfg });
+    const shouldRefreshSnapshot = snapshotVersion > 0 && (nextEntry?.skillsSnapshot?.version ?? 0) < snapshotVersion;
+    if (isFirstTurnInSession && sessionStore && sessionKey) {
+        const current = nextEntry ??
+            sessionStore[sessionKey] ?? {
+            sessionId: sessionId ?? crypto.randomUUID(),
+            updatedAt: Date.now(),
+        };
+        const skillSnapshot = isFirstTurnInSession || !current.skillsSnapshot || shouldRefreshSnapshot
+            ? buildWorkspaceSkillSnapshot(workspaceDir, {
+                config: cfg,
+                skillFilter,
+                eligibility: { remote: remoteEligibility },
+                snapshotVersion,
+            })
+            : current.skillsSnapshot;
+        nextEntry = {
+            ...current,
+            sessionId: sessionId ?? current.sessionId ?? crypto.randomUUID(),
+            updatedAt: Date.now(),
+            systemSent: true,
+            skillsSnapshot: skillSnapshot,
+        };
+        sessionStore[sessionKey] = { ...sessionStore[sessionKey], ...nextEntry };
+        if (storePath) {
+            await updateSessionStore(storePath, (store) => {
+                store[sessionKey] = { ...store[sessionKey], ...nextEntry };
+            });
+        }
+        systemSent = true;
+    }
+    const skillsSnapshot = shouldRefreshSnapshot
+        ? buildWorkspaceSkillSnapshot(workspaceDir, {
+            config: cfg,
+            skillFilter,
+            eligibility: { remote: remoteEligibility },
+            snapshotVersion,
+        })
+        : (nextEntry?.skillsSnapshot ??
+            (isFirstTurnInSession
+                ? undefined
+                : buildWorkspaceSkillSnapshot(workspaceDir, {
+                    config: cfg,
+                    skillFilter,
+                    eligibility: { remote: remoteEligibility },
+                    snapshotVersion,
+                })));
+    if (skillsSnapshot &&
+        sessionStore &&
+        sessionKey &&
+        !isFirstTurnInSession &&
+        (!nextEntry?.skillsSnapshot || shouldRefreshSnapshot)) {
+        const current = nextEntry ?? {
+            sessionId: sessionId ?? crypto.randomUUID(),
+            updatedAt: Date.now(),
+        };
+        nextEntry = {
+            ...current,
+            sessionId: sessionId ?? current.sessionId ?? crypto.randomUUID(),
+            updatedAt: Date.now(),
+            skillsSnapshot,
+        };
+        sessionStore[sessionKey] = { ...sessionStore[sessionKey], ...nextEntry };
+        if (storePath) {
+            await updateSessionStore(storePath, (store) => {
+                store[sessionKey] = { ...store[sessionKey], ...nextEntry };
+            });
+        }
+    }
+    return { sessionEntry: nextEntry, skillsSnapshot, systemSent };
+}
+export async function incrementCompactionCount(params) {
+    const { sessionEntry, sessionStore, sessionKey, storePath, now = Date.now(), tokensAfter, } = params;
+    if (!sessionStore || !sessionKey)
+        return undefined;
+    const entry = sessionStore[sessionKey] ?? sessionEntry;
+    if (!entry)
+        return undefined;
+    const nextCount = (entry.compactionCount ?? 0) + 1;
+    // Build update payload with compaction count and optionally updated token counts
+    const updates = {
+        compactionCount: nextCount,
+        updatedAt: now,
+    };
+    // If tokensAfter is provided, update the cached token counts to reflect post-compaction state
+    if (tokensAfter != null && tokensAfter > 0) {
+        updates.totalTokens = tokensAfter;
+        // Clear input/output breakdown since we only have the total estimate after compaction
+        updates.inputTokens = undefined;
+        updates.outputTokens = undefined;
+    }
+    sessionStore[sessionKey] = {
+        ...entry,
+        ...updates,
+    };
+    if (storePath) {
+        await updateSessionStore(storePath, (store) => {
+            store[sessionKey] = {
+                ...store[sessionKey],
+                ...updates,
+            };
+        });
+    }
+    return nextCount;
+}

package/dist/auto-reply/auto-reply/reply/stage-sandbox-media.js

@@ -0,0 +1,146 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { ensureSandboxWorkspaceForSession } from "../../agents/sandbox.js";
+import { logVerbose } from "../../globals.js";
+import { CONFIG_DIR } from "../../utils.js";
+export async function stageSandboxMedia(params) {
+    const { ctx, sessionCtx, cfg, sessionKey, workspaceDir } = params;
+    const hasPathsArray = Array.isArray(ctx.MediaPaths) && ctx.MediaPaths.length > 0;
+    const pathsFromArray = Array.isArray(ctx.MediaPaths) ? ctx.MediaPaths : undefined;
+    const rawPaths = pathsFromArray && pathsFromArray.length > 0
+        ? pathsFromArray
+        : ctx.MediaPath?.trim()
+            ? [ctx.MediaPath.trim()]
+            : [];
+    if (rawPaths.length === 0 || !sessionKey)
+        return;
+    const sandbox = await ensureSandboxWorkspaceForSession({
+        config: cfg,
+        sessionKey,
+        workspaceDir,
+    });
+    // For remote attachments without sandbox, use ~/.poolbot/media (not agent workspace for privacy)
+    const remoteMediaCacheDir = ctx.MediaRemoteHost
+        ? path.join(CONFIG_DIR, "media", "remote-cache", sessionKey)
+        : null;
+    const effectiveWorkspaceDir = sandbox?.workspaceDir ?? remoteMediaCacheDir;
+    if (!effectiveWorkspaceDir)
+        return;
+    const resolveAbsolutePath = (value) => {
+        let resolved = value.trim();
+        if (!resolved)
+            return null;
+        if (resolved.startsWith("file://")) {
+            try {
+                resolved = fileURLToPath(resolved);
+            }
+            catch {
+                return null;
+            }
+        }
+        if (!path.isAbsolute(resolved))
+            return null;
+        return resolved;
+    };
+    try {
+        // For sandbox: <workspace>/media/inbound, for remote cache: use dir directly
+        const destDir = sandbox
+            ? path.join(effectiveWorkspaceDir, "media", "inbound")
+            : effectiveWorkspaceDir;
+        await fs.mkdir(destDir, { recursive: true });
+        const usedNames = new Set();
+        const staged = new Map(); // absolute source -> relative sandbox path
+        for (const raw of rawPaths) {
+            const source = resolveAbsolutePath(raw);
+            if (!source)
+                continue;
+            if (staged.has(source))
+                continue;
+            const baseName = path.basename(source);
+            if (!baseName)
+                continue;
+            const parsed = path.parse(baseName);
+            let fileName = baseName;
+            let suffix = 1;
+            while (usedNames.has(fileName)) {
+                fileName = `${parsed.name}-${suffix}${parsed.ext}`;
+                suffix += 1;
+            }
+            usedNames.add(fileName);
+            const dest = path.join(destDir, fileName);
+            if (ctx.MediaRemoteHost) {
+                // Always use SCP when remote host is configured - local paths refer to remote machine
+                await scpFile(ctx.MediaRemoteHost, source, dest);
+            }
+            else {
+                await fs.copyFile(source, dest);
+            }
+            // For sandbox use relative path, for remote cache use absolute path
+            const stagedPath = sandbox ? path.posix.join("media", "inbound", fileName) : dest;
+            staged.set(source, stagedPath);
+        }
+        const rewriteIfStaged = (value) => {
+            const raw = value?.trim();
+            if (!raw)
+                return value;
+            const abs = resolveAbsolutePath(raw);
+            if (!abs)
+                return value;
+            const mapped = staged.get(abs);
+            return mapped ?? value;
+        };
+        const nextMediaPaths = hasPathsArray ? rawPaths.map((p) => rewriteIfStaged(p) ?? p) : undefined;
+        if (nextMediaPaths) {
+            ctx.MediaPaths = nextMediaPaths;
+            sessionCtx.MediaPaths = nextMediaPaths;
+            ctx.MediaPath = nextMediaPaths[0];
+            sessionCtx.MediaPath = nextMediaPaths[0];
+        }
+        else {
+            const rewritten = rewriteIfStaged(ctx.MediaPath);
+            if (rewritten && rewritten !== ctx.MediaPath) {
+                ctx.MediaPath = rewritten;
+                sessionCtx.MediaPath = rewritten;
+            }
+        }
+        if (Array.isArray(ctx.MediaUrls) && ctx.MediaUrls.length > 0) {
+            const nextUrls = ctx.MediaUrls.map((u) => rewriteIfStaged(u) ?? u);
+            ctx.MediaUrls = nextUrls;
+            sessionCtx.MediaUrls = nextUrls;
+        }
+        const rewrittenUrl = rewriteIfStaged(ctx.MediaUrl);
+        if (rewrittenUrl && rewrittenUrl !== ctx.MediaUrl) {
+            ctx.MediaUrl = rewrittenUrl;
+            sessionCtx.MediaUrl = rewrittenUrl;
+        }
+    }
+    catch (err) {
+        logVerbose(`Failed to stage inbound media for sandbox: ${String(err)}`);
+    }
+}
+async function scpFile(remoteHost, remotePath, localPath) {
+    return new Promise((resolve, reject) => {
+        const child = spawn("/usr/bin/scp", [
+            "-o",
+            "BatchMode=yes",
+            "-o",
+            "StrictHostKeyChecking=accept-new",
+            `${remoteHost}:${remotePath}`,
+            localPath,
+        ], { stdio: ["ignore", "ignore", "pipe"] });
+        let stderr = "";
+        child.stderr?.setEncoding("utf8");
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.once("error", reject);
+        child.once("exit", (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`scp failed (${code}): ${stderr.trim()}`));
+        });
+    });
+}

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "2026.3.25",
-  "commit": "c9d04aa2bcb820ac58ff49c59285704e2ed6ed75",
-  "builtAt": "2026-03-16T21:28:12.661Z"
+  "version": "2026.3.26",
+  "commit": "eee66000dac39be6214625d1cf9dc6e254077e7c",
+  "builtAt": "2026-03-18T11:37:07.663Z"
 }

package/dist/canvas-host/a2ui/.bundle.hash

@@ -1 +1 @@
-6b0df478e4e17402a1fa00508f807742d68a3f83cd0ed0a2fa35847745519125
+stub