@botconnector/bccli 0.5.0-rc.4 → 0.5.1

package/dist/serve-R2IHP26A.js

@@ -0,0 +1,532 @@
+#!/usr/bin/env node
+import {
+  createRuntime
+} from "./chunk-A3NBWIEQ.js";
+import "./chunk-OK2USAXX.js";
+import "./chunk-7U7CMKKI.js";
+import "./chunk-IF5RNXBI.js";
+import "./chunk-PSO7R5AD.js";
+import {
+  VERSION
+} from "./chunk-6YRTPXGY.js";
+import {
+  LOOPBACK_BIND,
+  MAX_FRAME_BYTES,
+  bearerOk,
+  parseCliArgs,
+  parseClientFrame,
+  randomToken,
+  trustFence
+} from "./chunk-M5T4AM4I.js";
+import "./chunk-YYTFJUO2.js";
+import "./chunk-RLSQAZBT.js";
+import {
+  listAllModels
+} from "./chunk-2IP5F3EK.js";
+import "./chunk-FY543EQW.js";
+import "./chunk-YGBTNDPK.js";
+import {
+  Session
+} from "./chunk-6LO6YRDY.js";
+import "./chunk-OCEQ2TRJ.js";
+import "./chunk-NGFWBVHD.js";
+import "./chunk-VPFCIUC6.js";
+import {
+  bccliHome,
+  loadConfig
+} from "./chunk-ZXWRLN7E.js";
+import "./chunk-IDZLHEVL.js";
+
+// src/serve.ts
+import { randomBytes } from "crypto";
+import { createServer } from "http";
+import { basename } from "path";
+import { WebSocket, WebSocketServer } from "ws";
+
+// src/serveHeartbeat.ts
+function createHeartbeat(intervalMs, ping, terminate) {
+  let awaitingPong = false;
+  let stopped = false;
+  let timer = null;
+  const tick = () => {
+    if (stopped) return;
+    if (awaitingPong) {
+      terminate();
+      timer = null;
+      return;
+    }
+    awaitingPong = true;
+    ping();
+    timer = setTimeout(tick, intervalMs);
+  };
+  return {
+    start() {
+      if (stopped || timer) return;
+      awaitingPong = true;
+      ping();
+      timer = setTimeout(tick, intervalMs);
+    },
+    pong() {
+      awaitingPong = false;
+    },
+    stop() {
+      stopped = true;
+      if (timer) clearTimeout(timer);
+      timer = null;
+    }
+  };
+}
+
+// src/serve.ts
+var MAX_BODY_BYTES = 1024 * 1024;
+var DISPLAY_MAX = 1e5;
+function json(res, status, value) {
+  const body = JSON.stringify(value);
+  res.writeHead(status, { "content-type": "application/json", "content-length": Buffer.byteLength(body) });
+  res.end(body);
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = "";
+    let size = 0;
+    let tooLarge = false;
+    req.on("data", (c) => {
+      size += c.length;
+      if (size > MAX_BODY_BYTES) tooLarge = true;
+      else body += c;
+    });
+    req.on("end", () => resolve(tooLarge ? null : body));
+    req.on("error", reject);
+  });
+}
+function sendFrame(ws, frame) {
+  if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify(frame));
+}
+function serveBanner(handle, opts = {}) {
+  const supplied = opts.token !== void 0 || (opts.env ?? process.env).BCCLI_SERVE_TOKEN !== void 0;
+  return `bccli serve ${handle.url}${supplied ? "" : ` \u2014 Authorization: Bearer ${handle.token}`}
+`;
+}
+async function startServe(opts = {}) {
+  const env = opts.env ?? process.env;
+  const cwd = opts.cwd ?? process.cwd();
+  const host = opts.host ?? "127.0.0.1";
+  if (!LOOPBACK_BIND.has(host)) throw new Error(`serve refuses non-loopback --host ${host} (loopback only)`);
+  const token = opts.token ?? env.BCCLI_SERVE_TOKEN ?? randomToken();
+  const home = bccliHome(env);
+  const sessions = /* @__PURE__ */ new Map();
+  const allSockets = /* @__PURE__ */ new Set();
+  const server = createServer((req, res) => {
+    void handleHttp(req, res);
+  });
+  const wss = new WebSocketServer({ noServer: true });
+  server.on("upgrade", (req, socket, head) => {
+    const address2 = server.address();
+    const port2 = typeof address2 === "object" && address2 ? address2.port : 0;
+    const reject = (status, reason) => {
+      socket.write(`HTTP/1.1 ${status} ${reason}\r
+Connection: close\r
+\r
+`);
+      socket.destroy();
+    };
+    const fence = trustFence(req.headers, port2);
+    if (fence) return reject(403, "Forbidden");
+    const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+    if (url.pathname !== "/v1/mux") return reject(404, "Not Found");
+    if (!bearerOk(req.headers.authorization, token)) return reject(401, "Unauthorized");
+    wss.handleUpgrade(req, socket, head, (ws) => wss.emit("connection", ws, req));
+  });
+  wss.on("connection", (ws) => {
+    allSockets.add(ws);
+    const heartbeat = createHeartbeat(opts.heartbeatMs ?? 2e3, () => ws.ping(), () => ws.terminate());
+    ws.on("pong", () => heartbeat.pong());
+    ws.on("close", () => heartbeat.stop());
+    heartbeat.start();
+    const connStreams = /* @__PURE__ */ new Map();
+    ws.on("close", () => {
+      allSockets.delete(ws);
+      for (const stream of connStreams.values()) stream.session.streams.delete(stream);
+      connStreams.clear();
+    });
+    ws.on("message", (data) => {
+      const rawFrame = String(data);
+      if (rawFrame.length > MAX_FRAME_BYTES) {
+        sendFrame(ws, { type: "error", streamId: "", message: "frame exceeds 256 KB" });
+        return;
+      }
+      const frame = parseClientFrame(rawFrame);
+      if ("error" in frame) {
+        sendFrame(ws, { type: "error", streamId: "", message: frame.error });
+        return;
+      }
+      if (frame.type === "cancel") {
+        const stream2 = connStreams.get(frame.streamId);
+        if (!stream2) return;
+        connStreams.delete(frame.streamId);
+        stream2.session.streams.delete(stream2);
+        sendFrame(ws, { type: "end", streamId: frame.streamId });
+        return;
+      }
+      if (connStreams.has(frame.streamId)) {
+        sendFrame(ws, { type: "error", streamId: frame.streamId, message: "duplicate open" });
+        return;
+      }
+      const match = frame.target.match(/^session:(.+)$/);
+      const sessionId = match ? decodeURIComponent(match[1]) : "";
+      const session = sessionId ? sessions.get(sessionId) ?? attachSession(sessionId, cwd) : void 0;
+      if (!session) {
+        sendFrame(ws, { type: "error", streamId: frame.streamId, message: `unknown target ${frame.target}` });
+        return;
+      }
+      const stream = { id: frame.streamId, ws, session };
+      connStreams.set(frame.streamId, stream);
+      session.streams.add(stream);
+      sendFrame(ws, { type: "item", streamId: frame.streamId, value: { type: "ready", sessionId: session.id, host: { home, version: VERSION } } });
+      for (const [requestId, p] of session.pending) {
+        sendFrame(ws, {
+          type: "item",
+          streamId: frame.streamId,
+          value: { type: "approval_request", requestId, tool: p.req.tool, kind: p.req.kind, target: p.req.target, preview: p.req.preview }
+        });
+      }
+    });
+  });
+  function broadcast(s, value) {
+    for (const stream of s.streams) sendFrame(stream.ws, { type: "item", streamId: stream.id, value });
+  }
+  async function handleHttp(req, res) {
+    const address2 = server.address();
+    const port2 = typeof address2 === "object" && address2 ? address2.port : 0;
+    const fence = trustFence(req.headers, port2);
+    if (fence) {
+      jsonError(res, 403, fence);
+      return;
+    }
+    const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+    if (url.pathname !== "/health" && !bearerOk(req.headers.authorization, token)) {
+      jsonError(res, 401, "missing or invalid bearer token");
+      return;
+    }
+    await route(req, res, url);
+  }
+  function jsonError(res, status, message) {
+    json(res, status, { error: { message } });
+  }
+  async function route(req, res, url) {
+    const method = req.method ?? "GET";
+    if (method === "GET" && url.pathname === "/health") {
+      json(res, 200, { ok: true, version: VERSION });
+      return;
+    }
+    if (method === "GET" && url.pathname === "/v1/models") {
+      try {
+        const groups = opts.provider ? [{ providerId: "injected", providerName: "injected", models: await opts.provider.listModels() }] : await listAllModels(loadConfig(cwd, env), env, { fetch: opts.fetch });
+        json(res, 200, groups);
+      } catch (error) {
+        jsonError(res, 500, error.message);
+      }
+      return;
+    }
+    if (url.pathname === "/v1/sessions" && method === "POST") {
+      const raw = await readBody(req);
+      if (raw === null) {
+        jsonError(res, 413, "request body exceeds 1 MB");
+        return;
+      }
+      let body = {};
+      if (raw) {
+        try {
+          body = JSON.parse(raw);
+        } catch {
+          jsonError(res, 400, "invalid JSON body");
+          return;
+        }
+      }
+      if (body.permissionMode !== void 0 && body.permissionMode !== "ask" && body.permissionMode !== "bypassPermissions") {
+        jsonError(res, 400, "permissionMode must be 'ask' or 'bypassPermissions'");
+        return;
+      }
+      try {
+        const s = openSession(body.cwd ?? cwd, body.permissionMode ?? "ask", body.model);
+        json(res, 201, { id: s.id, cwd: s.cwd, permissionMode: s.permissionMode });
+      } catch (error) {
+        jsonError(res, 500, error.message);
+      }
+      return;
+    }
+    if (url.pathname === "/v1/sessions" && method === "GET") {
+      const listCwd = url.searchParams.get("cwd") ?? cwd;
+      const byId = /* @__PURE__ */ new Map();
+      for (const { session, mtime, preview } of Session.list(home, listCwd)) {
+        const id = basename(session.file, ".jsonl");
+        byId.set(id, { id, mtime: mtime.toISOString(), preview });
+      }
+      for (const s of sessions.values()) {
+        if (s.cwd === listCwd && !byId.has(s.id)) {
+          byId.set(s.id, { id: s.id, mtime: (/* @__PURE__ */ new Date()).toISOString(), preview: "" });
+        }
+      }
+      json(res, 200, [...byId.values()]);
+      return;
+    }
+    const one = url.pathname.match(/^\/v1\/sessions\/([^/]+)$/);
+    if (one && method === "GET") {
+      const id = decodeURIComponent(one[1]);
+      const live = sessions.get(id);
+      if (live) {
+        json(res, 200, { id, cwd: live.cwd, permissionMode: live.permissionMode, messages: live.rt.agent.messages });
+        return;
+      }
+      const found = findSessionFile(id, url.searchParams.get("cwd") ?? cwd);
+      if (!found) {
+        jsonError(res, 404, `unknown session ${id}`);
+        return;
+      }
+      json(res, 200, { id, cwd: found.cwd, permissionMode: "ask", messages: found.session.load() });
+      return;
+    }
+    const messages = url.pathname.match(/^\/v1\/sessions\/([^/]+)\/messages$/);
+    if (messages && method === "POST") {
+      const raw = await readBody(req);
+      if (raw === null) {
+        jsonError(res, 413, "request body exceeds 1 MB");
+        return;
+      }
+      let body = {};
+      if (raw) {
+        try {
+          body = JSON.parse(raw);
+        } catch {
+          jsonError(res, 400, "invalid JSON body");
+          return;
+        }
+      }
+      const id = decodeURIComponent(messages[1]);
+      let s = sessions.get(id);
+      if (!s) s = attachSession(id, url.searchParams.get("cwd") ?? cwd);
+      if (!s) {
+        jsonError(res, 404, `unknown session ${id}`);
+        return;
+      }
+      if (typeof body.prompt !== "string" || body.prompt === "") {
+        jsonError(res, 400, "prompt must be a non-empty string");
+        return;
+      }
+      if (s.busy) {
+        jsonError(res, 409, `session ${id} is busy with turn ${s.busy.turnId}`);
+        return;
+      }
+      const turnId = randomBytes(6).toString("hex");
+      const controller = new AbortController();
+      s.busy = { turnId, controller };
+      void runTurn(s, body.prompt, controller);
+      json(res, 202, { turnId });
+      return;
+    }
+    const approvals = url.pathname.match(/^\/v1\/sessions\/([^/]+)\/approvals$/);
+    if (approvals && method === "POST") {
+      const raw = await readBody(req);
+      if (raw === null) {
+        jsonError(res, 413, "request body exceeds 1 MB");
+        return;
+      }
+      let body = {};
+      if (raw) {
+        try {
+          body = JSON.parse(raw);
+        } catch {
+          jsonError(res, 400, "invalid JSON body");
+          return;
+        }
+      }
+      const answers = ["yes", "no", "session", "all"];
+      if (typeof body.requestId !== "string" || !answers.includes(body.answer)) {
+        jsonError(res, 400, "requestId must be a string and answer one of 'yes'|'no'|'session'|'all'");
+        return;
+      }
+      const s = sessions.get(decodeURIComponent(approvals[1]));
+      if (!s) {
+        jsonError(res, 404, `unknown session ${decodeURIComponent(approvals[1])}`);
+        return;
+      }
+      const pending = s.pending.get(body.requestId);
+      if (!pending) {
+        jsonError(res, 404, `unknown or already answered requestId ${body.requestId}`);
+        return;
+      }
+      s.pending.delete(body.requestId);
+      pending.resolve(body.answer);
+      json(res, 200, { accepted: true });
+      return;
+    }
+    const cancel = url.pathname.match(/^\/v1\/sessions\/([^/]+)\/cancel$/);
+    if (cancel && method === "POST") {
+      const s = sessions.get(decodeURIComponent(cancel[1]));
+      if (!s) {
+        jsonError(res, 404, `unknown session ${decodeURIComponent(cancel[1])}`);
+        return;
+      }
+      if (s.busy) s.busy.controller.abort();
+      failPending(s);
+      json(res, 200, { cancelled: true });
+      return;
+    }
+    jsonError(res, 404, `no route ${method} ${url.pathname}`);
+  }
+  async function runTurn(s, prompt, controller) {
+    let text = "";
+    let stopReason = "done";
+    const toolCalls = [];
+    const byId = /* @__PURE__ */ new Map();
+    let usage = { inputTokens: 0, outputTokens: 0 };
+    const map = (event) => {
+      switch (event.type) {
+        case "text":
+          text += event.delta;
+          broadcast(s, { type: "text", delta: event.delta });
+          break;
+        case "textReplace":
+          text = event.text;
+          break;
+        case "thinking":
+          broadcast(s, { type: "thinking", delta: event.delta });
+          break;
+        case "toolStart": {
+          const call = { name: event.tool, target: event.target };
+          byId.set(event.id, call);
+          toolCalls.push(call);
+          broadcast(s, { type: "tool_use", tool: event.tool, target: event.target });
+          break;
+        }
+        case "toolEnd": {
+          const call = byId.get(event.id);
+          if (call) {
+            call.output = event.output;
+            call.isError = event.isError;
+          }
+          const item = {
+            type: "tool_result",
+            tool: event.tool,
+            output: event.output,
+            isError: event.isError
+          };
+          if (typeof event.display === "string") {
+            item.display = event.display.length > DISPLAY_MAX ? `${event.display.slice(0, DISPLAY_MAX)}
+[truncated]` : event.display;
+          }
+          broadcast(s, item);
+          break;
+        }
+        case "usage":
+          usage = { inputTokens: event.inputTokens, outputTokens: event.outputTokens };
+          broadcast(s, { type: "usage", ...usage });
+          break;
+        case "stepLimit":
+          stopReason = "stepLimit";
+          break;
+        case "budgetExceeded":
+          stopReason = "budgetExceeded";
+          break;
+        case "aborted":
+          stopReason = "aborted";
+          break;
+        case "error":
+          broadcast(s, { type: "error", message: event.message });
+          break;
+        default:
+          break;
+      }
+    };
+    s.rt.agent.onEvent = map;
+    try {
+      await s.rt.agent.run(prompt, controller.signal);
+    } catch {
+      stopReason = controller.signal.aborted ? "aborted" : stopReason;
+    } finally {
+      s.rt.agent.onEvent = () => {
+      };
+      s.busy = null;
+      failPending(s);
+      broadcast(s, { type: "result", text, toolCalls, usage, stopReason });
+    }
+  }
+  function findSessionFile(id, forCwd) {
+    const hit = Session.list(home, forCwd).find(({ session }) => basename(session.file, ".jsonl") === id);
+    return hit ? { session: hit.session, cwd: forCwd } : void 0;
+  }
+  function buildRuntime(forCwd, permissionMode, model) {
+    return createRuntime({
+      cwd: forCwd,
+      args: { ...parseCliArgs([]), allowAll: permissionMode === "bypassPermissions", model },
+      env,
+      provider: opts.provider,
+      fetch: opts.fetch
+    });
+  }
+  function openSession(forCwd, permissionMode, model) {
+    return registerSession(buildRuntime(forCwd, permissionMode, model), forCwd, permissionMode);
+  }
+  function attachSession(id, forCwd) {
+    const found = findSessionFile(id, forCwd);
+    if (!found) return void 0;
+    const rt = buildRuntime(found.cwd, "ask", found.session.lastModel());
+    rt.resume(found.session);
+    return registerSession(rt, found.cwd, "ask", id);
+  }
+  function registerSession(rt, forCwd, permissionMode, id) {
+    const sessionId = id ?? basename(rt.session.file, ".jsonl");
+    const s = {
+      id: sessionId,
+      cwd: forCwd,
+      rt,
+      permissionMode,
+      busy: null,
+      streams: /* @__PURE__ */ new Set(),
+      pending: /* @__PURE__ */ new Map()
+    };
+    if (permissionMode === "bypassPermissions") {
+      rt.agent.askPermission = async () => "yes";
+    } else {
+      rt.agent.askPermission = (req) => new Promise((resolve) => {
+        const requestId = randomBytes(6).toString("hex");
+        s.pending.set(requestId, { resolve, req });
+        broadcast(s, {
+          type: "approval_request",
+          requestId,
+          tool: req.tool,
+          kind: req.kind,
+          target: req.target,
+          preview: req.preview
+        });
+      });
+    }
+    sessions.set(sessionId, s);
+    return s;
+  }
+  function failPending(s) {
+    for (const [, p] of s.pending) p.resolve("no");
+    s.pending.clear();
+  }
+  await new Promise(
+    (resolve) => server.listen(opts.port ?? 8787, host === "localhost" ? "127.0.0.1" : host, resolve)
+  );
+  const address = server.address();
+  const port = typeof address === "object" && address ? address.port : 0;
+  return {
+    port,
+    token,
+    url: `http://127.0.0.1:${port}`,
+    close: () => new Promise((resolve) => {
+      for (const s of sessions.values()) failPending(s);
+      for (const ws of allSockets) ws.terminate();
+      allSockets.clear();
+      server.closeAllConnections();
+      server.close(() => resolve());
+    })
+  };
+}
+export {
+  serveBanner,
+  startServe
+};

package/dist/serve.d.ts

@@ -0,0 +1,37 @@
+import type { Provider } from './provider';
+export interface ServeOptions {
+    port?: number;
+    host?: string;
+    token?: string;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    provider?: Provider;
+    fetch?: typeof fetch;
+    heartbeatMs?: number;
+    err?: (s: string) => void;
+}
+export interface ServeHandle {
+    port: number;
+    token: string;
+    url: string;
+    close(): Promise<void>;
+}
+export type PermissionMode = 'ask' | 'bypassPermissions';
+/**
+ * One-line terminal banner for `bccli serve`. A token the user supplied (`--token` or
+ * `BCCLI_SERVE_TOKEN`) is left out so it cannot leak into logs; a token BCCLI generated
+ * itself must be printed or nobody could connect.
+ */
+export declare function serveBanner(handle: {
+    url: string;
+    token: string;
+}, opts?: {
+    token?: string;
+    env?: NodeJS.ProcessEnv;
+}): string;
+/**
+ * Starts the loopback session server (HTTP unary + WS mux at /v1/mux). Refuses
+ * non-loopback bind addresses; every request passes the DSH-style trust fence
+ * (403) and, except /health, the bearer-token check (401).
+ */
+export declare function startServe(opts?: ServeOptions): Promise<ServeHandle>;

package/dist/serveHeartbeat.d.ts

@@ -0,0 +1,14 @@
+export interface Heartbeat {
+    /** Sends the first ping and schedules the check loop. Idempotent until stop(). */
+    start(): void;
+    /** Marks the last ping as answered (ws 'pong' event). */
+    pong(): void;
+    /** Clears the timer; no further pings or terminations. */
+    stop(): void;
+}
+/**
+ * ws heartbeat with deadline: every interval a ping goes out; a ping left
+ * unanswered by the next tick terminates the socket (connection, not stream).
+ * Modeled on the DSH gateway's `websocketHeartbeatIntervalMs` behavior.
+ */
+export declare function createHeartbeat(intervalMs: number, ping: () => void, terminate: () => void): Heartbeat;

package/dist/serveProtocol.d.ts

@@ -0,0 +1,47 @@
+/** Wire frames of the /v1/mux WebSocket (subset of the DSH stream protocol). */
+export type ClientFrame = {
+    type: 'open';
+    streamId: string;
+    target: string;
+} | {
+    type: 'cancel';
+    streamId: string;
+};
+export type ServerFrame = {
+    type: 'item';
+    streamId: string;
+    value: unknown;
+} | {
+    type: 'end';
+    streamId: string;
+} | {
+    type: 'error';
+    streamId: string;
+    message: string;
+};
+/** Uplink frame size limit; oversized frames error their stream without closing the socket. */
+export declare const MAX_FRAME_BYTES = 262144;
+/**
+ * Parses one uplink mux frame. Malformed JSON, unknown types, an empty streamId,
+ * or an `open` without a target produce `{ error }` instead of throwing.
+ */
+export declare function parseClientFrame(raw: string): ClientFrame | {
+    error: string;
+};
+/** Addresses `bccli serve` is allowed to bind (loopback only; 0.0.0.0 is refused). */
+export declare const LOOPBACK_BIND: Set<string>;
+/**
+ * DSH-style trust fence: loopback Host with a port matching the listener, a
+ * same-machine Origin when attached, and no cross-site sec-fetch-site. Returns
+ * null when trusted, else the 403 reason. Never establishes identity — the
+ * bearer token does.
+ */
+export declare function trustFence(headers: {
+    host?: string;
+    origin?: string;
+    'sec-fetch-site'?: string;
+}, port: number): string | null;
+/** Timing-safe `Authorization: Bearer <token>` check. */
+export declare function bearerOk(header: string | undefined, token: string): boolean;
+/** Fresh 32-byte hex serve token. */
+export declare function randomToken(): string;

package/dist/session-YM36TGU7.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import {
+  Session,
+  pruneSessions
+} from "./chunk-6LO6YRDY.js";
+import "./chunk-OCEQ2TRJ.js";
+import "./chunk-NGFWBVHD.js";
+import "./chunk-IDZLHEVL.js";
+export {
+  Session,
+  pruneSessions
+};

package/dist/session.d.ts

@@ -0,0 +1,33 @@
+import { type ChatMessage, type Usage } from './provider';
+export declare class Session {
+    readonly file: string;
+    constructor(file: string);
+    get id(): string;
+    static create(home: string, cwd: string, now?: Date): Session;
+    static list(home: string, cwd: string): {
+        session: Session;
+        mtime: Date;
+        preview: string;
+    }[];
+    static latest(home: string, cwd: string): Session | undefined;
+    private write;
+    append(message: ChatMessage): void;
+    appendUsage(usage: Usage & {
+        model?: string;
+    }): void;
+    reset(): void;
+    private records;
+    /** What the model continues from: everything after the last reset (after a compaction that is the summary and the recent turns). */
+    load(): ChatMessage[];
+    /** Model of the most recent turn that recorded usage — serve attach continues a session with its own model. */
+    lastModel(): string | undefined;
+    /** Accumulated token usage since the last non-compaction reset. */
+    totalUsage(): Usage;
+    /**
+     * What the user sees on resume: the whole conversation. Compaction only shrinks what the model is sent, so
+     * its reset does not hide the older turns here. A real reset (/clear, rewind) still starts over, the
+     * synthetic summary pair is never shown, and the recent turns a compaction re-writes are not shown twice.
+     */
+    loadHistory(): ChatMessage[];
+}
+export declare function pruneSessions(home: string, now?: number, maxAgeDays?: number): number;