@botconnector/bccli 0.4.17 → 0.5.0-rc.4

package/dist/serve-HUQNVOSP.js

@@ -1,532 +0,0 @@
-#!/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-XP5MTJN2.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

@@ -1,37 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,47 +0,0 @@
-/** 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

@@ -1,12 +0,0 @@
-#!/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

@@ -1,33 +0,0 @@
-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;