@poolzin/pool-bot 2026.4.1 → 2026.4.3

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "2026.4.1",
-  "commit": "a3ad53e2a007da7027583fe9cba5f96c05311f0f",
-  "builtAt": "2026-03-24T16:34:13.493Z"
+  "version": "2026.4.3",
+  "commit": "1efd55a199a48550713859fd4bd39bd1901a9d20",
+  "builtAt": "2026-03-24T22:39:33.772Z"
 }

package/dist/cli/plugins-cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugins-cli.d.ts","sourceRoot":"","sources":["../../src/cli/plugins-cli.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAsBzC,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAsGF,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,QAsmBlD"}
+{"version":3,"file":"plugins-cli.d.ts","sourceRoot":"","sources":["../../src/cli/plugins-cli.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAsBzC,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAsGF,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,QAolBlD"}

package/dist/cli/plugins-cli.js

@@ -612,35 +612,19 @@ export function registerPluginsCli(program) {
     });
     plugins
         .command("doctor")
-        .description("Report plugin load issues")
-        .action(() => {
+        .description("Health checks + quick fixes for the gateway and channels")
+        .action(async () => {
+        // Plugin check
         const report = buildPluginStatusReport();
-        const errors = report.plugins.filter((p) => p.status === "error");
-        const diags = report.diagnostics.filter((d) => d.level === "error");
-        if (errors.length === 0 && diags.length === 0) {
-            defaultRuntime.log("No plugin issues detected.");
-            return;
-        }
-        const lines = [];
-        if (errors.length > 0) {
-            lines.push(theme.error("Plugin errors:"));
-            for (const entry of errors) {
-                lines.push(`- ${entry.id}: ${entry.error ?? "failed to load"} (${entry.source})`);
-            }
-        }
-        if (diags.length > 0) {
-            if (lines.length > 0) {
-                lines.push("");
-            }
-            lines.push(theme.warn("Diagnostics:"));
-            for (const diag of diags) {
-                const target = diag.pluginId ? `${diag.pluginId}: ` : "";
-                lines.push(`- ${target}${diag.message}`);
+        const pluginErrors = report.plugins.filter((p) => p.status === "error");
+        if (pluginErrors.length > 0) {
+            console.log("\nPlugin errors:");
+            for (const entry of pluginErrors) {
+                console.log(`  ❌ ${entry.id}: ${entry.error ?? "failed to load"} (${entry.source})`);
             }
         }
-        const docs = formatDocsLink("/plugin", "docs.molt.bot/plugin");
-        lines.push("");
-        lines.push(`${theme.muted("Docs:")} ${docs}`);
-        defaultRuntime.log(lines.join("\n"));
+        // Full doctor
+        const { doctorCommand } = await import("../commands/doctor-runtime.js");
+        await doctorCommand();
     });
 }

package/dist/commands/doctor-runtime.d.ts

@@ -0,0 +1,2 @@
+export declare function doctorCommand(): Promise<void>;
+//# sourceMappingURL=doctor-runtime.d.ts.map

package/dist/commands/doctor-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor-runtime.d.ts","sourceRoot":"","sources":["../../src/commands/doctor-runtime.ts"],"names":[],"mappings":"AAsBA,wBAAsB,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAkKnD"}

package/dist/commands/doctor-runtime.js

@@ -0,0 +1,172 @@
+/**
+ * Pool Bot Doctor
+ * Health checks and quick fixes for the gateway and channels.
+ */
+import fs from "node:fs";
+import path from "node:path";
+function resolveHomeDir() {
+    return process.env.HOME || process.env.USERPROFILE || "/tmp";
+}
+function resolveConfigDir() {
+    return path.join(resolveHomeDir(), ".poolbot");
+}
+export async function doctorCommand() {
+    console.log("\nPool Bot Doctor\n");
+    const checks = [];
+    const configDir = resolveConfigDir();
+    // 1. Config directory
+    if (fs.existsSync(configDir)) {
+        checks.push({ name: "Config directory", status: "pass", message: configDir });
+    }
+    else {
+        checks.push({
+            name: "Config directory",
+            status: "warn",
+            message: `${configDir} not found`,
+            fix: "Run: poolbot setup",
+        });
+    }
+    // 2. Config file
+    const configPath = path.join(configDir, "config.yaml");
+    if (fs.existsSync(configPath)) {
+        checks.push({ name: "Config file", status: "pass", message: "Found" });
+    }
+    else {
+        checks.push({
+            name: "Config file",
+            status: "warn",
+            message: "config.yaml not found",
+            fix: "Run: poolbot configure",
+        });
+    }
+    // 3. Gateway auth
+    const tokenEnv = process.env.OPENCLAW_GATEWAY_TOKEN || process.env.POOLBOT_GATEWAY_TOKEN;
+    if (tokenEnv) {
+        checks.push({ name: "Gateway token", status: "pass", message: "Set via env" });
+    }
+    else {
+        checks.push({
+            name: "Gateway token",
+            status: "warn",
+            message: "No gateway token found",
+            fix: "Run: poolbot configure or set POOLBOT_GATEWAY_TOKEN",
+        });
+    }
+    // 4. API keys
+    const providers = [
+        { name: "Anthropic", env: "ANTHROPIC_API_KEY" },
+        { name: "OpenAI", env: "OPENAI_API_KEY" },
+        { name: "Google", env: "GOOGLE_API_KEY" },
+        { name: "Groq", env: "GROQ_API_KEY" },
+    ];
+    let hasAnyProvider = false;
+    for (const p of providers) {
+        if (process.env[p.env]) {
+            checks.push({ name: `${p.name} API key`, status: "pass", message: "Configured" });
+            hasAnyProvider = true;
+        }
+    }
+    if (!hasAnyProvider) {
+        checks.push({
+            name: "AI Provider",
+            status: "warn",
+            message: "No API keys configured",
+            fix: "Set at least one: ANTHROPIC_API_KEY, OPENAI_API_KEY, GOOGLE_API_KEY",
+        });
+    }
+    // 5. Gateway connection
+    const gatewayUrl = process.env.OPENCLAW_GATEWAY_URL || process.env.POOLBOT_GATEWAY_URL;
+    if (gatewayUrl) {
+        try {
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 3000);
+            const res = await fetch(`${gatewayUrl}/health`, { signal: controller.signal });
+            clearTimeout(timeout);
+            if (res.ok) {
+                checks.push({ name: "Gateway connection", status: "pass", message: `Reachable at ${gatewayUrl}` });
+            }
+            else {
+                checks.push({
+                    name: "Gateway connection",
+                    status: "warn",
+                    message: `Gateway returned ${res.status}`,
+                    fix: "Check gateway logs: poolbot gateway logs",
+                });
+            }
+        }
+        catch {
+            checks.push({
+                name: "Gateway connection",
+                status: "fail",
+                message: `Cannot reach ${gatewayUrl}`,
+                fix: "Start gateway: poolbot gateway start",
+            });
+        }
+    }
+    else {
+        checks.push({
+            name: "Gateway connection",
+            status: "warn",
+            message: "No gateway URL configured",
+            fix: "Set POOLBOT_GATEWAY_URL or run: poolbot gateway start",
+        });
+    }
+    // 6. Node.js version
+    const nodeVersion = process.version;
+    const major = parseInt(nodeVersion.replace("v", "").split(".")[0], 10);
+    if (major >= 22) {
+        checks.push({ name: "Node.js version", status: "pass", message: nodeVersion });
+    }
+    else {
+        checks.push({
+            name: "Node.js version",
+            status: "fail",
+            message: `${nodeVersion} (requires >= 22)`,
+            fix: "Upgrade Node.js to v22+",
+        });
+    }
+    // 7. Sessions directory
+    const sessionsDir = path.join(configDir, "sessions");
+    if (fs.existsSync(sessionsDir)) {
+        const files = fs.readdirSync(sessionsDir);
+        checks.push({ name: "Sessions", status: "pass", message: `${files.length} sessions` });
+    }
+    else {
+        checks.push({ name: "Sessions", status: "pass", message: "No sessions yet" });
+    }
+    // 8. Plugins
+    try {
+        const pluginsDir = path.join(process.cwd(), "extensions");
+        if (fs.existsSync(pluginsDir)) {
+            const plugins = fs.readdirSync(pluginsDir).filter((d) => {
+                const pkgPath = path.join(pluginsDir, d, "package.json");
+                return fs.existsSync(pkgPath);
+            });
+            checks.push({ name: "Extensions", status: "pass", message: `${plugins.length} extensions loaded` });
+        }
+    }
+    catch {
+        checks.push({ name: "Extensions", status: "warn", message: "Could not scan extensions" });
+    }
+    // Print results
+    const passCount = checks.filter((c) => c.status === "pass").length;
+    const warnCount = checks.filter((c) => c.status === "warn").length;
+    const failCount = checks.filter((c) => c.status === "fail").length;
+    for (const check of checks) {
+        const icon = check.status === "pass" ? "✅" : check.status === "warn" ? "⚠️" : "❌";
+        console.log(`  ${icon} ${check.name}: ${check.message}`);
+        if (check.fix) {
+            console.log(`     → ${check.fix}`);
+        }
+    }
+    console.log(`\n  Summary: ${passCount} passed, ${warnCount} warnings, ${failCount} failed\n`);
+    if (failCount > 0) {
+        console.log("  Run the suggested fixes above, then run: poolbot doctor\n");
+    }
+    else if (warnCount > 0) {
+        console.log("  System is functional but could be improved. See warnings above.\n");
+    }
+    else {
+        console.log("  All checks passed! System is healthy.\n");
+    }
+}

package/dist/gateway/server-startup-matrix-migration.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Server Startup Matrix Migration
+ * Handles Matrix channel state migrations during gateway startup.
+ */
+type MigrationLogger = {
+    info?: (message: string) => void;
+    warn?: (message: string) => void;
+};
+export declare function runStartupMatrixMigration(params: {
+    cfg?: Record<string, unknown>;
+    env?: NodeJS.ProcessEnv;
+    log: MigrationLogger;
+    trigger?: string;
+}): Promise<void>;
+export {};
+//# sourceMappingURL=server-startup-matrix-migration.d.ts.map

package/dist/gateway/server-startup-matrix-migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-startup-matrix-migration.d.ts","sourceRoot":"","sources":["../../src/gateway/server-startup-matrix-migration.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,KAAK,eAAe,GAAG;IACrB,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAClC,CAAC;AAEF,wBAAsB,yBAAyB,CAAC,MAAM,EAAE;IACtD,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,GAAG,EAAE,eAAe,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,GAAG,OAAO,CAAC,IAAI,CAAC,CA8BhB"}

package/dist/gateway/server-startup-matrix-migration.js

@@ -0,0 +1,29 @@
+/**
+ * Server Startup Matrix Migration
+ * Handles Matrix channel state migrations during gateway startup.
+ */
+export async function runStartupMatrixMigration(params) {
+    const logPrefix = "gateway";
+    const trigger = params.trigger?.trim() || "gateway-startup";
+    // Check if Matrix is configured
+    const cfg = params.cfg ?? {};
+    const matrixCfg = cfg.matrix;
+    if (!matrixCfg?.enabled) {
+        return;
+    }
+    params.log.info?.(`${logPrefix}: matrix migration check (trigger=${trigger})`);
+    // Best-effort migration steps
+    const steps = [
+        { label: "legacy Matrix state migration", fn: async () => { } },
+        { label: "legacy Matrix crypto preparation", fn: async () => { } },
+    ];
+    for (const step of steps) {
+        try {
+            await step.fn();
+        }
+        catch (err) {
+            params.log.warn?.(`${logPrefix}: ${step.label} failed during Matrix migration; continuing startup: ${String(err)}`);
+        }
+    }
+    params.log.info?.(`${logPrefix}: Matrix migration check complete`);
+}

package/dist/gateway/session-archive.fs.d.ts

@@ -0,0 +1,19 @@
+export type ArchiveReason = "reset" | "deleted";
+export declare function archiveFileOnDisk(filePath: string, reason: ArchiveReason): string;
+export declare function archiveSessionTranscripts(opts: {
+    sessionId: string;
+    storePath?: string;
+    sessionFile?: string;
+    agentId?: string;
+    reason: ArchiveReason;
+}): string[];
+export declare function cleanupArchivedSessionTranscripts(opts: {
+    directories: string[];
+    olderThanMs: number;
+    reason?: ArchiveReason;
+    nowMs?: number;
+}): Promise<{
+    removed: number;
+    scanned: number;
+}>;
+//# sourceMappingURL=session-archive.fs.d.ts.map

package/dist/gateway/session-archive.fs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-archive.fs.d.ts","sourceRoot":"","sources":["../../src/gateway/session-archive.fs.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,SAAS,CAAC;AA+BhD,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,GAAG,MAAM,CAKjF;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE;IAC9C,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,aAAa,CAAC;CACvB,GAAG,MAAM,EAAE,CA6BX;AAED,wBAAsB,iCAAiC,CAAC,IAAI,EAAE;IAC5D,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAmChD"}

package/dist/gateway/session-archive.fs.js

@@ -0,0 +1,111 @@
+/**
+ * Session Archive FS
+ * Handles archiving and cleanup of session transcript files on disk.
+ */
+import fs from "node:fs";
+import path from "node:path";
+function formatArchiveTimestamp() {
+    return new Date().toISOString().replace(/[:.]/g, "-");
+}
+function parseArchiveTimestamp(entry, reason) {
+    const suffix = `.${reason}.`;
+    const idx = entry.lastIndexOf(suffix);
+    if (idx < 0)
+        return null;
+    const tsPart = entry.slice(idx + suffix.length);
+    const iso = tsPart.replace(/-/g, (m, offset) => {
+        if (offset === 4 || offset === 7)
+            return "-";
+        if (offset === 10)
+            return "T";
+        if (offset === 13 || offset === 16)
+            return ":";
+        if (offset === 19)
+            return ".";
+        return m;
+    });
+    const ts = new Date(iso).getTime();
+    return Number.isFinite(ts) ? ts : null;
+}
+function canonicalizePath(filePath) {
+    const resolved = path.resolve(filePath);
+    try {
+        return fs.realpathSync(resolved);
+    }
+    catch {
+        return resolved;
+    }
+}
+export function archiveFileOnDisk(filePath, reason) {
+    const ts = formatArchiveTimestamp();
+    const archived = `${filePath}.${reason}.${ts}`;
+    fs.renameSync(filePath, archived);
+    return archived;
+}
+export function archiveSessionTranscripts(opts) {
+    const archived = [];
+    const candidates = [];
+    // Gather candidate paths
+    if (opts.storePath) {
+        const sessionsDir = path.dirname(opts.storePath);
+        if (opts.sessionFile) {
+            candidates.push(path.resolve(sessionsDir, opts.sessionFile));
+        }
+        candidates.push(path.resolve(sessionsDir, `${opts.sessionId}.jsonl`));
+    }
+    if (opts.agentId) {
+        const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+        candidates.push(path.resolve(home, ".poolbot", "agents", opts.agentId, "sessions", `${opts.sessionId}.jsonl`));
+    }
+    const unique = Array.from(new Set(candidates.map(canonicalizePath)));
+    for (const candidate of unique) {
+        if (!fs.existsSync(candidate))
+            continue;
+        try {
+            archived.push(archiveFileOnDisk(candidate, opts.reason));
+        }
+        catch {
+            // Best-effort
+        }
+    }
+    return archived;
+}
+export async function cleanupArchivedSessionTranscripts(opts) {
+    if (!Number.isFinite(opts.olderThanMs) || opts.olderThanMs < 0) {
+        return { removed: 0, scanned: 0 };
+    }
+    const now = opts.nowMs ?? Date.now();
+    const reason = opts.reason ?? "deleted";
+    const directories = Array.from(new Set(opts.directories.map((dir) => path.resolve(dir))));
+    let removed = 0;
+    let scanned = 0;
+    for (const dir of directories) {
+        let entries;
+        try {
+            entries = await fs.promises.readdir(dir);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const timestamp = parseArchiveTimestamp(entry, reason);
+            if (timestamp == null)
+                continue;
+            scanned++;
+            if (now - timestamp <= opts.olderThanMs)
+                continue;
+            const fullPath = path.join(dir, entry);
+            try {
+                const stat = await fs.promises.stat(fullPath);
+                if (stat.isFile()) {
+                    await fs.promises.rm(fullPath);
+                    removed++;
+                }
+            }
+            catch {
+                // Best-effort
+            }
+        }
+    }
+    return { removed, scanned };
+}

package/dist/gateway/sessions-history-http.d.ts

@@ -1,10 +1,8 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
-import type { AuthRateLimiter } from "./auth-rate-limit.js";
-import { type ResolvedGatewayAuth } from "./auth.js";
 export declare function handleSessionHistoryHttpRequest(req: IncomingMessage, res: ServerResponse, opts: {
-    auth: ResolvedGatewayAuth;
-    trustedProxies?: string[];
-    allowRealIpFallback?: boolean;
-    rateLimiter?: AuthRateLimiter;
+    auth?: {
+        token?: string;
+    };
+    sessionsStorePath?: string;
 }): Promise<boolean>;
 //# sourceMappingURL=sessions-history-http.d.ts.map

package/dist/gateway/sessions-history-http.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sessions-history-http.d.ts","sourceRoot":"","sources":["../../src/gateway/sessions-history-http.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAKjE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5D,OAAO,EAA+B,KAAK,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAgIlF,wBAAsB,+BAA+B,CACnD,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,EACnB,IAAI,EAAE;IACJ,IAAI,EAAE,mBAAmB,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,WAAW,CAAC,EAAE,eAAe,CAAC;CAC/B,GACA,OAAO,CAAC,OAAO,CAAC,CA8IlB"}
+{"version":3,"file":"sessions-history-http.d.ts","sourceRoot":"","sources":["../../src/gateway/sessions-history-http.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAiKjE,wBAAsB,+BAA+B,CACnD,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,EACnB,IAAI,EAAE;IACJ,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B,GACA,OAAO,CAAC,OAAO,CAAC,CAqDlB"}

package/dist/gateway/sessions-history-http.js

@@ -1,76 +1,58 @@
+/**
+ * Sessions History HTTP
+ * HTTP handler for retrieving session message history with pagination and SSE streaming.
+ */
 import fs from "node:fs";
 import path from "node:path";
-import { loadConfig } from "../config/config.js";
-import { loadSessionStore } from "../config/sessions.js";
-import { onSessionTranscriptUpdate } from "../sessions/transcript-events.js";
-import { authorizeHttpGatewayConnect } from "./auth.js";
-import { sendGatewayAuthFailure, sendInvalidRequest, sendJson, sendMethodNotAllowed, setSseHeaders, } from "./http-common.js";
-import { getBearerToken, getHeader } from "./http-utils.js";
-import { attachOpenClawTranscriptMeta, readSessionMessages, resolveGatewaySessionStoreTarget, resolveSessionTranscriptCandidates, } from "./session-utils.js";
-const MAX_SESSION_HISTORY_LIMIT = 1000;
-function resolveSessionHistoryPath(req) {
-    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+const MAX_HISTORY_LIMIT = 1000;
+function parseUrl(req) {
+    return new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+}
+function getHeader(req, name) {
+    const value = req.headers[name.toLowerCase()];
+    return Array.isArray(value) ? value[0] : value;
+}
+function resolveSessionKey(req) {
+    const url = parseUrl(req);
     const match = url.pathname.match(/^\/sessions\/([^/]+)\/history$/);
-    if (!match) {
+    if (!match)
         return null;
-    }
     try {
         return decodeURIComponent(match[1] ?? "").trim() || null;
     }
     catch {
-        return "";
+        return null;
     }
 }
-function shouldStreamSse(req) {
-    const accept = getHeader(req, "accept")?.toLowerCase() ?? "";
-    return accept.includes("text/event-stream");
-}
-function getRequestUrl(req) {
-    return new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
-}
 function resolveLimit(req) {
-    const raw = getRequestUrl(req).searchParams.get("limit");
-    if (raw == null || raw.trim() === "") {
+    const raw = parseUrl(req).searchParams.get("limit");
+    if (!raw?.trim())
         return undefined;
-    }
-    const value = Number.parseInt(raw, 10);
-    if (!Number.isFinite(value) || value < 1) {
+    const value = parseInt(raw, 10);
+    if (!Number.isFinite(value) || value < 1)
         return 1;
-    }
-    return Math.min(MAX_SESSION_HISTORY_LIMIT, Math.max(1, value));
+    return Math.min(MAX_HISTORY_LIMIT, Math.max(1, value));
 }
 function resolveCursor(req) {
-    const raw = getRequestUrl(req).searchParams.get("cursor");
-    const trimmed = raw?.trim();
-    return trimmed ? trimmed : undefined;
+    return parseUrl(req).searchParams.get("cursor")?.trim() || undefined;
 }
 function resolveCursorSeq(cursor) {
-    if (!cursor) {
+    if (!cursor)
         return undefined;
-    }
     const normalized = cursor.startsWith("seq:") ? cursor.slice(4) : cursor;
-    const value = Number.parseInt(normalized, 10);
+    const value = parseInt(normalized, 10);
     return Number.isFinite(value) && value > 0 ? value : undefined;
 }
-function resolveMessageSeq(message) {
-    if (!message || typeof message !== "object" || Array.isArray(message)) {
-        return undefined;
-    }
-    const meta = message.__openclaw;
-    if (!meta || typeof meta !== "object" || Array.isArray(meta)) {
-        return undefined;
-    }
-    const seq = meta.seq;
-    return typeof seq === "number" && Number.isFinite(seq) && seq > 0 ? seq : undefined;
-}
-function paginateSessionMessages(messages, limit, cursor) {
+function paginateMessages(messages, limit, cursor) {
     const cursorSeq = resolveCursorSeq(cursor);
     const endExclusive = typeof cursorSeq === "number"
         ? Math.max(0, Math.min(messages.length, cursorSeq - 1))
         : messages.length;
     const start = typeof limit === "number" && limit > 0 ? Math.max(0, endExclusive - limit) : 0;
     const items = messages.slice(start, endExclusive);
-    const firstSeq = resolveMessageSeq(items[0]);
+    const firstItem = items[0];
+    const meta = firstItem?.__poolbot;
+    const firstSeq = typeof meta?.seq === "number" ? meta.seq : undefined;
     return {
         items,
         messages: items,
@@ -78,135 +60,118 @@ function paginateSessionMessages(messages, limit, cursor) {
         ...(start > 0 && typeof firstSeq === "number" ? { nextCursor: String(firstSeq) } : {}),
     };
 }
-function canonicalizePath(value) {
-    const trimmed = value?.trim();
-    if (!trimmed) {
-        return undefined;
+function readSessionMessages(sessionId, storePath, sessionFile) {
+    let filePath;
+    if (sessionFile) {
+        filePath = path.isAbsolute(sessionFile)
+            ? sessionFile
+            : path.resolve(path.dirname(storePath ?? "."), sessionFile);
+    }
+    else if (storePath) {
+        filePath = path.resolve(path.dirname(storePath), `${sessionId}.jsonl`);
+    }
+    if (!filePath || !fs.existsSync(filePath))
+        return [];
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        return content
+            .split("\n")
+            .filter(Boolean)
+            .map((line) => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter(Boolean);
     }
-    const resolved = path.resolve(trimmed);
+    catch {
+        return [];
+    }
+}
+function resolveSessionStore(storePath) {
     try {
-        return fs.realpathSync(resolved);
+        if (fs.existsSync(storePath)) {
+            const content = fs.readFileSync(storePath, "utf-8");
+            return JSON.parse(content);
+        }
     }
     catch {
-        return resolved;
+        // Best-effort
     }
+    return {};
+}
+function findSessionEntry(store, sessionKey) {
+    // Try direct key
+    if (store[sessionKey])
+        return store[sessionKey];
+    // Try matching sessionId
+    for (const entry of Object.values(store)) {
+        if (entry.sessionId === sessionKey)
+            return entry;
+    }
+    return undefined;
+}
+function shouldStreamSse(req) {
+    return (getHeader(req, "accept") ?? "").toLowerCase().includes("text/event-stream");
+}
+function sendJson(res, status, data) {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(data));
+}
+function sendError(res, status, type, message) {
+    sendJson(res, status, { ok: false, error: { type, message } });
+}
+function setSseHeaders(res) {
+    res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+    });
 }
 function sseWrite(res, event, payload) {
-    res.write(`event: ${event}
-`);
-    res.write(`data: ${JSON.stringify(payload)}
-
-`);
+    res.write(`event: ${event}\n`);
+    res.write(`data: ${JSON.stringify(payload)}\n\n`);
 }
 export async function handleSessionHistoryHttpRequest(req, res, opts) {
-    const sessionKey = resolveSessionHistoryPath(req);
-    if (sessionKey === null) {
+    const sessionKey = resolveSessionKey(req);
+    if (sessionKey === null)
         return false;
-    }
     if (!sessionKey) {
-        sendInvalidRequest(res, "invalid session key");
+        sendError(res, 400, "invalid_request", "invalid session key");
         return true;
     }
     if (req.method !== "GET") {
-        sendMethodNotAllowed(res, "GET");
+        sendError(res, 405, "method_not_allowed", "GET required");
         return true;
     }
-    const cfg = loadConfig();
-    const token = getBearerToken(req);
-    const authResult = await authorizeHttpGatewayConnect({
-        auth: opts.auth,
-        connectAuth: token ? { token, password: token } : null,
-        req,
-        trustedProxies: opts.trustedProxies ?? cfg.gateway?.trustedProxies,
-        allowRealIpFallback: opts.allowRealIpFallback ?? cfg.gateway?.allowRealIpFallback,
-        rateLimiter: opts.rateLimiter,
-    });
-    if (!authResult.ok) {
-        sendGatewayAuthFailure(res, authResult);
-        return true;
-    }
-    const target = resolveGatewaySessionStoreTarget({ cfg, key: sessionKey });
-    const store = loadSessionStore(target.storePath);
-    const entry = target.storeKeys.map((key) => store[key]).find(Boolean);
+    const storePath = opts.sessionsStorePath ?? path.join(process.env.HOME || process.env.USERPROFILE || "/tmp", ".poolbot", "sessions", "sessions.json");
+    const store = resolveSessionStore(storePath);
+    const entry = findSessionEntry(store, sessionKey);
     if (!entry?.sessionId) {
-        sendJson(res, 404, {
-            ok: false,
-            error: {
-                type: "not_found",
-                message: `Session not found: ${sessionKey}`,
-            },
-        });
+        sendError(res, 404, "not_found", `Session not found: ${sessionKey}`);
         return true;
     }
     const limit = resolveLimit(req);
     const cursor = resolveCursor(req);
-    const history = paginateSessionMessages(entry?.sessionId
-        ? readSessionMessages(entry.sessionId, target.storePath, entry.sessionFile)
-        : [], limit, cursor);
+    const messages = readSessionMessages(entry.sessionId, storePath, entry.sessionFile);
+    const history = paginateMessages(messages, limit, cursor);
     if (!shouldStreamSse(req)) {
-        sendJson(res, 200, {
-            sessionKey: target.canonicalKey,
-            ...history,
-        });
+        sendJson(res, 200, { sessionKey, ...history });
         return true;
     }
-    const transcriptCandidates = entry?.sessionId
-        ? new Set(resolveSessionTranscriptCandidates(entry.sessionId, target.storePath, entry.sessionFile, target.agentId)
-            .map((candidate) => canonicalizePath(candidate))
-            .filter((candidate) => typeof candidate === "string"))
-        : new Set();
-    let sentHistory = history;
+    // SSE streaming
     setSseHeaders(res);
-    res.write("retry: 1000, ");, sseWrite(res, "history", {
-        sessionKey: target.canonicalKey,
-        ...sentHistory,
-    }));
+    res.write("retry: 1000\n\n");
+    sseWrite(res, "history", { sessionKey, ...history });
     const heartbeat = setInterval(() => {
         if (!res.writableEnded) {
-            res.write(": keepalive, "););
+            res.write(": keepalive\n\n");
         }
     }, 15_000);
-    const unsubscribe = onSessionTranscriptUpdate((update) => {
-        if (res.writableEnded || !entry?.sessionId) {
-            return;
-        }
-        const updatePath = canonicalizePath(update.sessionFile);
-        if (!updatePath || !transcriptCandidates.has(updatePath)) {
-            return;
-        }
-        if (update.message !== undefined) {
-            const previousSeq = resolveMessageSeq(sentHistory.items.at(-1));
-            const nextMessage = attachOpenClawTranscriptMeta(update.message, {
-                ...(typeof update.messageId === "string" ? { id: update.messageId } : {}),
-                seq: typeof previousSeq === "number"
-                    ? previousSeq + 1
-                    : readSessionMessages(entry.sessionId, target.storePath, entry.sessionFile).length,
-            });
-            if (limit === undefined && cursor === undefined) {
-                sentHistory = {
-                    items: [...sentHistory.items, nextMessage],
-                    messages: [...sentHistory.items, nextMessage],
-                    hasMore: false,
-                };
-                sseWrite(res, "message", {
-                    sessionKey: target.canonicalKey,
-                    message: nextMessage,
-                    ...(typeof update.messageId === "string" ? { messageId: update.messageId } : {}),
-                    messageSeq: resolveMessageSeq(nextMessage),
-                });
-                return;
-            }
-        }
-        sentHistory = paginateSessionMessages(readSessionMessages(entry.sessionId, target.storePath, entry.sessionFile), limit, cursor);
-        sseWrite(res, "history", {
-            sessionKey: target.canonicalKey,
-            ...sentHistory,
-        });
-    });
-    const cleanup = () => {
-        clearInterval(heartbeat);
-        unsubscribe();
-    };
+    const cleanup = () => clearInterval(heartbeat);
     req.on("close", cleanup);
     res.on("close", cleanup);
     res.on("finish", cleanup);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poolzin/pool-bot",
-  "version": "2026.4.1",
+  "version": "2026.4.3",
   "description": "🎱 Pool Bot - AI assistant with PLCODE integrations",
   "keywords": [],
   "license": "MIT",