@botconnector/bccli 0.4.0-beta.5 → 0.4.0-beta.51

package/dist/serve-6KX4MXHC.js

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+import {
+  createFetchTool,
+  createWebSearchTool,
+  isPrivateHost
+} from "./chunk-DP7EBW53.js";
+import "./chunk-PSO7R5AD.js";
+import {
+  loadConfig,
+  readCredentials
+} from "./chunk-NDEJUL44.js";
+import {
+  t
+} from "./chunk-XLC6T4SX.js";
+
+// src/mcpServer/serve.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/mcpServer/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+var CATALOG_URL = "https://botconnector.id/data/cloud-models.json";
+var PRICING_URL = "https://botconnector.id/data/payg-pricing.json";
+var CACHE_TTL_MS = 60 * 6e4;
+var ctxLabel = (context) => {
+  if (!context || !Number.isFinite(context)) return "?";
+  return context >= 1e3 ? `${Math.round(context / 1e3)}k` : String(context);
+};
+var usd = (v) => typeof v === "number" ? `$${v}` : "?";
+function createMcpServer(deps) {
+  const server = new McpServer({ name: "botconnector", version: "0.1.0" });
+  const fetchFn = deps.fetchFn ?? fetch;
+  const now = deps.now ?? Date.now;
+  let cache;
+  const searchTool = createWebSearchTool({
+    botconnector: () => deps.apiKey ? { baseURL: deps.baseUrl, apiKey: deps.apiKey } : void 0,
+    keenableURL: deps.keenableURL
+  });
+  const pageTool = createFetchTool(deps.fetchTool);
+  const toolCtx = () => ({
+    cwd: ".",
+    signal: AbortSignal.timeout(3e4),
+    readFiles: /* @__PURE__ */ new Set()
+  });
+  server.registerTool(
+    "bc_models",
+    {
+      description: "List BotConnector cloud models with context window and pay-as-you-go price (USD per 1M tokens).",
+      inputSchema: {},
+      annotations: { readOnlyHint: true }
+    },
+    async () => {
+      if (cache && now() - cache.at < CACHE_TTL_MS) {
+        return { content: [{ type: "text", text: cache.text }] };
+      }
+      const [catalogRes, pricingRes] = await Promise.all([fetchFn(CATALOG_URL), fetchFn(PRICING_URL)]);
+      if (!catalogRes.ok) throw new Error(`catalog HTTP ${catalogRes.status}`);
+      const catalog = await catalogRes.json();
+      const pricing = pricingRes.ok ? await pricingRes.json() : { tokenRates: [] };
+      const rates = new Map((pricing.tokenRates ?? []).map((r) => [r.id, r]));
+      const lines = (catalog.models ?? []).map((m) => {
+        const tier = rates.get(m.id)?.tiers?.[0];
+        const price = tier ? `in ${usd(tier.inputPerMTokensUsd)}/M out ${usd(tier.outputPerMTokensUsd)}/M` : "price n/a";
+        const access = m.access ? ` \xB7 ${m.access}` : "";
+        return `${m.id} \xB7 ctx ${ctxLabel(m.context)} \xB7 ${price}${access}`;
+      });
+      const text = lines.length ? lines.join("\n") : "No models in the catalog.";
+      cache = { at: now(), text };
+      return { content: [{ type: "text", text }] };
+    }
+  );
+  server.registerTool(
+    "bc_search",
+    {
+      description: "Search the web and return ranked results (title, url, snippet). Use it to discover pages, then bc_fetch to read one.",
+      inputSchema: {
+        query: z.string().min(1).max(500).describe("Search query"),
+        max_results: z.number().int().min(1).max(8).optional().describe("Number of results (default 6)")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ query, max_results }) => {
+      const r = await searchTool.run({ query, max_results }, toolCtx());
+      return { content: [{ type: "text", text: r.output }], ...r.isError ? { isError: true } : {} };
+    }
+  );
+  server.registerTool(
+    "bc_fetch",
+    {
+      description: "Fetch a URL and return its text content (HTML tags stripped).",
+      inputSchema: { url: z.string().min(1).describe("Absolute http(s) URL") },
+      annotations: { readOnlyHint: true }
+    },
+    async ({ url }) => {
+      if (!/^https?:\/\//i.test(url)) {
+        return { content: [{ type: "text", text: "URL must start with http:// or https://" }], isError: true };
+      }
+      let host;
+      try {
+        host = new URL(url).hostname;
+      } catch {
+        return { content: [{ type: "text", text: "Invalid URL." }], isError: true };
+      }
+      if (isPrivateHost(host)) {
+        return {
+          content: [{ type: "text", text: `Blocked: ${host} is a private host. bc_fetch only fetches public URLs.` }],
+          isError: true
+        };
+      }
+      const r = await pageTool.run({ url }, toolCtx());
+      return { content: [{ type: "text", text: r.output }], ...r.isError ? { isError: true } : {} };
+    }
+  );
+  server.registerTool(
+    "bc_chat",
+    {
+      description: "Send a prompt to a BotConnector model and get the reply. Returns the answer plus token usage. The model pays from the same API key.",
+      inputSchema: {
+        prompt: z.string().min(1).max(1e5).describe("The user message"),
+        model: z.string().optional().describe("Model id (default: the configured model)"),
+        max_tokens: z.number().int().min(1).max(4096).optional().describe("Reply budget (default 1024, max 4096)")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false }
+    },
+    async ({ prompt, model, max_tokens }) => {
+      const res = await fetchFn(`${deps.baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: { "content-type": "application/json", authorization: `Bearer ${deps.apiKey}` },
+        body: JSON.stringify({
+          model: model ?? deps.defaultModel,
+          messages: [{ role: "user", content: prompt }],
+          max_tokens: max_tokens ?? 1024,
+          stream: false
+        }),
+        signal: AbortSignal.timeout(3e4)
+      });
+      const body = await res.json().catch(() => ({}));
+      if (!res.ok) {
+        const message = body.error?.message ?? `HTTP ${res.status}`;
+        return { content: [{ type: "text", text: `bc_chat failed: ${message}` }], isError: true };
+      }
+      const reply = body.choices?.[0]?.message?.content ?? "";
+      const usage = body.usage ? `
+
+[usage: ${body.usage.prompt_tokens ?? 0} in / ${body.usage.completion_tokens ?? 0} out]` : "";
+      return { content: [{ type: "text", text: reply + usage }] };
+    }
+  );
+  return server;
+}
+
+// src/mcpServer/serve.ts
+var DEFAULT_BASE = "https://api.botconnector.id/v1";
+var FALLBACK_MODEL = "glm-5.3-flash";
+async function runMcpServe(args, deps) {
+  const apiKey = readCredentials(deps.env)["bc-cloud"] || deps.env.BOTCONNECTOR_API_KEY;
+  if (!apiKey) {
+    deps.err(t("No BotConnector API key yet. Run bccli login bc-cloud first."));
+    return 1;
+  }
+  const config = loadConfig(deps.cwd, deps.env);
+  const providerBase = config.providers["bc-cloud"]?.baseURL ?? DEFAULT_BASE;
+  const baseUrl = (args.baseUrl ?? providerBase).replace(/\/+$/, "");
+  const defaultModel = config.model.startsWith("bc-cloud/") ? config.model.slice("bc-cloud/".length) : FALLBACK_MODEL;
+  const server = createMcpServer({ baseUrl, apiKey, defaultModel, fetchFn: deps.fetch });
+  await server.connect(deps.transport ?? new StdioServerTransport());
+  deps.err(`mcp serve: 4 tools, base=${baseUrl}`);
+  if (deps.transport) return 0;
+  await new Promise((resolve) => {
+    const stdin = process.stdin;
+    stdin.on("end", () => resolve());
+    stdin.on("close", () => resolve());
+  });
+  return 0;
+}
+export {
+  runMcpServe
+};

package/dist/serve-YSUJD57D.js

@@ -0,0 +1,515 @@
+#!/usr/bin/env node
+import {
+  createRuntime
+} from "./chunk-KIZC5XV4.js";
+import "./chunk-QZKLZELZ.js";
+import "./chunk-YIYX3FFS.js";
+import "./chunk-DP7EBW53.js";
+import "./chunk-PSO7R5AD.js";
+import {
+  VERSION
+} from "./chunk-VU5HNQHX.js";
+import {
+  LOOPBACK_BIND,
+  MAX_FRAME_BYTES,
+  bearerOk,
+  parseCliArgs,
+  parseClientFrame,
+  randomToken,
+  trustFence
+} from "./chunk-FTFVW7XD.js";
+import "./chunk-GAFJEQTJ.js";
+import "./chunk-N7KP6RNP.js";
+import {
+  listAllModels
+} from "./chunk-QXOV4DUZ.js";
+import "./chunk-2QYHSESB.js";
+import "./chunk-7F3IWBPQ.js";
+import {
+  Session
+} from "./chunk-F6ACN47V.js";
+import "./chunk-R4BJBTWC.js";
+import "./chunk-SNKVS26H.js";
+import "./chunk-H73FO5YK.js";
+import {
+  bccliHome,
+  loadConfig
+} from "./chunk-NDEJUL44.js";
+import "./chunk-XLC6T4SX.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;
+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));
+}
+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;
+          }
+          broadcast(s, { type: "tool_result", tool: event.tool, output: event.output, isError: event.isError });
+          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");
+    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 {
+  startServe
+};

package/dist/session-F6MG3UCU.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import {
+  Session,
+  pruneSessions
+} from "./chunk-F6ACN47V.js";
+import "./chunk-R4BJBTWC.js";
+import "./chunk-SNKVS26H.js";
+import "./chunk-XLC6T4SX.js";
+export {
+  Session,
+  pruneSessions
+};