@organizaone/o1-code 0.11.3 → 0.12.0

package/chunks/chunk-WBPIFM2X.js

@@ -0,0 +1,2008 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  atomicWriteFile
+} from "./chunk-EPJAMNLS.js";
+import {
+  BaseTokenStorage
+} from "./chunk-7TK6OY2J.js";
+import {
+  Storage
+} from "./chunk-S3HSUBBN.js";
+import {
+  init_esbuild_shims
+} from "./chunk-S2467S6L.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/providers/o1-connect/session.ts
+init_esbuild_shims();
+
+// packages/core/vendor/o1-connect/lib.mjs
+init_esbuild_shims();
+import { createHash } from "node:crypto";
+import tls3 from "node:tls";
+import { randomBytes as randomBytes2 } from "node:crypto";
+import http3 from "node:http";
+import https2 from "node:https";
+import { isIP as isIP2 } from "node:net";
+import { Duplex as Duplex2 } from "node:stream";
+import tls2 from "node:tls";
+import http from "node:http";
+import { createHash as createHash2, randomBytes } from "node:crypto";
+import http2 from "node:http";
+import https from "node:https";
+import { isIP } from "node:net";
+import { Duplex } from "node:stream";
+import tls from "node:tls";
+import { createHash as createHash3, randomBytes as randomBytes3, timingSafeEqual } from "node:crypto";
+import http5 from "node:http";
+import http4 from "node:http";
+import http6 from "node:http";
+import tls4 from "node:tls";
+var TUNNEL_PATH = "/tunnel";
+var TUNNEL_PINS_PATH = "/tunnel/pins";
+var TUNNEL_PROTOCOL = "o1gw-tunnel.v1";
+var TUNNEL_SERVERNAME = "o1gw-tunnel";
+var CODE_PREFIX = "o1gw1.";
+var PIN = /^sha256\/[A-Za-z0-9+/]{43}=$/;
+var TOKEN = /^[0-9a-f]{64}$/;
+var DEVICE = /^[a-z0-9][a-z0-9_-]{0,31}$/i;
+var MAX_PINS = 4;
+var MAX_HOSTS = 4;
+var ConnectionCodeError = class extends Error {
+  static {
+    __name(this, "ConnectionCodeError");
+  }
+};
+function pinOfSpki(spkiDer) {
+  return `sha256/${createHash("sha256").update(spkiDer).digest("base64")}`;
+}
+__name(pinOfSpki, "pinOfSpki");
+function isPin(s) {
+  return PIN.test(s);
+}
+__name(isPin, "isPin");
+function fingerprint(pin) {
+  if (!isPin(pin)) throw new ConnectionCodeError("not a pin");
+  const hex = Buffer.from(pin.slice("sha256/".length), "base64").toString("hex").toUpperCase();
+  return (hex.match(/.{4}/g) ?? []).join("-");
+}
+__name(fingerprint, "fingerprint");
+function sniOfPin(pin) {
+  if (!isPin(pin)) throw new ConnectionCodeError("not a pin");
+  return `k-${Buffer.from(pin.slice("sha256/".length), "base64").toString("hex").slice(0, 20)}.o1gw.invalid`;
+}
+__name(sniOfPin, "sniOfPin");
+function isLoopbackHost(hostname2) {
+  return hostname2 === "127.0.0.1" || hostname2 === "localhost" || hostname2 === "[::1]";
+}
+__name(isLoopbackHost, "isLoopbackHost");
+function originOf(value, what) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new ConnectionCodeError(`the proxy ${what} is not a URL`);
+  }
+  if (!(url.protocol === "https:" || url.protocol === "http:" && isLoopbackHost(url.hostname))) {
+    throw new ConnectionCodeError(`the proxy ${what} must be https`);
+  }
+  if (url.pathname !== "/" || url.search || url.hash || url.username || url.password) {
+    throw new ConnectionCodeError(`the proxy ${what} must be the proxy's base URL`);
+  }
+  return url.origin;
+}
+__name(originOf, "originOf");
+function validateCode(c) {
+  if (!c || typeof c !== "object") throw new ConnectionCodeError("the code does not hold a connection");
+  const o = c;
+  const url = originOf(String(o.url), "URL");
+  if (typeof o.device !== "string" || !DEVICE.test(o.device)) throw new ConnectionCodeError("the device name is not valid");
+  if (!Array.isArray(o.pins) || o.pins.length === 0 || o.pins.length > MAX_PINS || !o.pins.every((p) => typeof p === "string" && isPin(p))) {
+    throw new ConnectionCodeError("the pin list is not valid");
+  }
+  if (typeof o.token !== "string" || !TOKEN.test(o.token)) throw new ConnectionCodeError("the device token is not valid");
+  let urls;
+  if (o.urls !== void 0) {
+    if (!Array.isArray(o.urls) || o.urls.length === 0 || o.urls.some((u) => typeof u !== "string")) throw new ConnectionCodeError("the failover host list is not valid");
+    urls = o.urls.map((u, i) => originOf(u, `failover host ${i + 1}`));
+    const all = [url, ...urls];
+    if (new Set(all).size !== all.length) throw new ConnectionCodeError("the failover host list repeats a host");
+    if (all.length > MAX_HOSTS) throw new ConnectionCodeError(`the code names more than ${MAX_HOSTS} hosts`);
+  }
+  return { url, ...urls === void 0 ? {} : { urls }, device: o.device, pins: [...o.pins], token: o.token };
+}
+__name(validateCode, "validateCode");
+function decodeConnectionCode(s) {
+  const text = s.trim();
+  if (!text.startsWith(CODE_PREFIX)) throw new ConnectionCodeError("this is not an o1-connect code (it starts with o1gw1.)");
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer.from(text.slice(CODE_PREFIX.length), "base64url").toString("utf8"));
+  } catch {
+    throw new ConnectionCodeError("the code is damaged: copy it again from the console");
+  }
+  return validateCode(parsed);
+}
+__name(decodeConnectionCode, "decodeConnectionCode");
+var seen = /* @__PURE__ */ new WeakMap();
+function peerCertificate(socket) {
+  const kept = seen.get(socket);
+  if (kept) return kept;
+  const cert = socket.getPeerX509Certificate();
+  if (cert) seen.set(socket, cert);
+  return cert;
+}
+__name(peerCertificate, "peerCertificate");
+var POLL_PATH = "/tunnel/poll";
+var POLL_VERSION = 1;
+var SESSION_BYTES = 32;
+var MAX_UP = 256 * 1024;
+var MAX_DOWN = 1024 * 1024;
+var POLL_WAIT_MS = 2e4;
+var TUNNEL_BUSY = "tunnel_busy";
+var REQUEST_HEAD = 1 + SESSION_BYTES + 8 + 8 + 1;
+var RESPONSE_HEAD = 1 + SESSION_BYTES + 8 + 1;
+var FLAG_CLOSE = 1;
+var FLAG_POLL = 2;
+var FLAG_OPEN = 4;
+var FLAG_CLOSED = 1;
+var PollFormatError = class extends Error {
+  static {
+    __name(this, "PollFormatError");
+  }
+};
+var ZERO_SESSION = Buffer.alloc(SESSION_BYTES);
+function sessionOf(id) {
+  if (id.length !== SESSION_BYTES) throw new PollFormatError("the session id must be 32 bytes");
+  return id;
+}
+__name(sessionOf, "sessionOf");
+function requestSession(id) {
+  if (sessionOf(id).equals(ZERO_SESSION)) throw new PollFormatError("the session id must not be all zero");
+  return id;
+}
+__name(requestSession, "requestSession");
+function toU64(n, what) {
+  if (!Number.isSafeInteger(n) || n < 0) throw new PollFormatError(`${what} is out of range`);
+  return BigInt(n);
+}
+__name(toU64, "toU64");
+function fromU64(b, at, what) {
+  const v = b.readBigUInt64BE(at);
+  if (v > BigInt(Number.MAX_SAFE_INTEGER)) throw new PollFormatError(`${what} is out of range`);
+  return Number(v);
+}
+__name(fromU64, "fromU64");
+function encodeRequest(r) {
+  if (r.data.length > MAX_UP) throw new PollFormatError("the request carries too much data");
+  const head = Buffer.alloc(REQUEST_HEAD);
+  head[0] = POLL_VERSION;
+  requestSession(r.session).copy(head, 1);
+  head.writeBigUInt64BE(toU64(r.upOffset, "upOffset"), 33);
+  head.writeBigUInt64BE(toU64(r.ack, "ack"), 41);
+  head[49] = (r.close ? FLAG_CLOSE : 0) | (r.poll ? FLAG_POLL : 0) | (r.open ? FLAG_OPEN : 0);
+  return Buffer.concat([head, r.data]);
+}
+__name(encodeRequest, "encodeRequest");
+function decodeResponse(b) {
+  if (b.length < RESPONSE_HEAD) throw new PollFormatError("the answer is too short");
+  if (b[0] !== POLL_VERSION) throw new PollFormatError("the answer is not a tunnel's");
+  if (b.length - RESPONSE_HEAD > MAX_DOWN) throw new PollFormatError("the answer carries too much data");
+  return {
+    session: Buffer.from(b.subarray(1, 33)),
+    downOffset: fromU64(b, 33, "downOffset"),
+    closed: (b[41] & FLAG_CLOSED) !== 0,
+    data: Buffer.from(b.subarray(RESPONSE_HEAD))
+  };
+}
+__name(decodeResponse, "decodeResponse");
+var LOOPBACK = /^(localhost|127(?:\.\d{1,3}){3}|::1)$/i;
+function bypassed(host, list) {
+  return list.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean).some((entry) => entry === "*" || entry === host || entry.startsWith(".") && host.endsWith(entry));
+}
+__name(bypassed, "bypassed");
+function proxyFor(target, env = process.env) {
+  const host = target.hostname.replace(/^\[|\]$/g, "").toLowerCase();
+  if (LOOPBACK.test(host)) return null;
+  const raw = (env.HTTPS_PROXY || env.https_proxy || "").trim();
+  if (!raw) return null;
+  if (bypassed(host, env.NO_PROXY || env.no_proxy || "")) return null;
+  let url;
+  try {
+    url = new URL(raw.includes("://") ? raw : `http://${raw}`);
+  } catch {
+    throw new Error("HTTPS_PROXY is not a valid URL");
+  }
+  if (url.protocol !== "http:") throw new Error("HTTPS_PROXY must be an http:// proxy URL");
+  const user = decodeURIComponent(url.username);
+  const pass = decodeURIComponent(url.password);
+  return {
+    host: url.hostname.replace(/^\[|\]$/g, ""),
+    port: Number(url.port || 80),
+    ...user || pass ? { authorization: `Basic ${Buffer.from(`${user}:${pass}`).toString("base64")}` } : {}
+  };
+}
+__name(proxyFor, "proxyFor");
+var ProxyRefusedError = class extends Error {
+  static {
+    __name(this, "ProxyRefusedError");
+  }
+  constructor(status) {
+    super(status === 407 ? "the network's proxy needs credentials (HTTP 407): put them in HTTPS_PROXY as http://user:password@host:port" : `the network's proxy refused the connection (HTTP ${status})`);
+    this.status = status;
+  }
+  status;
+};
+function connectVia(route, host, port) {
+  const authority = host.includes(":") ? `[${host}]:${port}` : `${host}:${port}`;
+  const req = http.request({
+    host: route.host,
+    port: route.port,
+    method: "CONNECT",
+    path: authority,
+    agent: false,
+    headers: { Host: authority, ...route.authorization ? { "Proxy-Authorization": route.authorization } : {} }
+  });
+  const socket = new Promise((resolve, reject) => {
+    req.on("connect", (res, sock, head) => {
+      if (res.statusCode !== 200) {
+        sock.destroy();
+        reject(new ProxyRefusedError(res.statusCode ?? 0));
+        return;
+      }
+      if (head.length) sock.unshift(head);
+      resolve(sock);
+    });
+    req.on("response", (res) => {
+      res.resume();
+      reject(new ProxyRefusedError(res.statusCode ?? 0));
+    });
+    req.on("error", reject);
+  });
+  req.end();
+  return { socket, abort: /* @__PURE__ */ __name(() => req.destroy(), "abort") };
+}
+__name(connectVia, "connectVia");
+var OP = { cont: 0, text: 1, binary: 2, close: 8, ping: 9, pong: 10 };
+var WsProtocolError = class extends Error {
+  static {
+    __name(this, "WsProtocolError");
+  }
+};
+function encodeFrame(opcode, payload, mask, fin = true) {
+  const n = payload.length;
+  const b0 = (fin ? 128 : 0) | opcode;
+  const m = mask ? 128 : 0;
+  let head;
+  if (n < 126) head = Buffer.from([b0, m | n]);
+  else if (n < 65536) head = Buffer.from([b0, m | 126, n >> 8, n & 255]);
+  else {
+    head = Buffer.alloc(10);
+    head[0] = b0;
+    head[1] = m | 127;
+    head.writeBigUInt64BE(BigInt(n), 2);
+  }
+  if (!mask) return Buffer.concat([head, payload]);
+  const body = Buffer.from(payload);
+  for (let i = 0; i < body.length; i++) body[i] ^= mask[i & 3];
+  return Buffer.concat([head, mask, body]);
+}
+__name(encodeFrame, "encodeFrame");
+var FrameParser = class {
+  static {
+    __name(this, "FrameParser");
+  }
+  constructor(maxPayload = 16 * 1024 * 1024) {
+    this.maxPayload = maxPayload;
+  }
+  maxPayload;
+  buf = Buffer.alloc(0);
+  push(chunk) {
+    this.buf = this.buf.length ? Buffer.concat([this.buf, chunk]) : chunk;
+    const out = [];
+    for (; ; ) {
+      if (this.buf.length < 2) return out;
+      const b0 = this.buf[0];
+      const b1 = this.buf[1];
+      if (b0 & 112) throw new WsProtocolError("reserved bits set");
+      if (b1 & 128) throw new WsProtocolError("a server frame must not be masked");
+      const opcode = b0 & 15;
+      const fin = (b0 & 128) !== 0;
+      let n = b1 & 127;
+      let off = 2;
+      if (n === 126) {
+        if (this.buf.length < 4) return out;
+        n = this.buf.readUInt16BE(2);
+        off = 4;
+      } else if (n === 127) {
+        if (this.buf.length < 10) return out;
+        const big = this.buf.readBigUInt64BE(2);
+        if (big > BigInt(this.maxPayload)) throw new WsProtocolError("frame too large");
+        n = Number(big);
+        off = 10;
+      }
+      if (n > this.maxPayload) throw new WsProtocolError("frame too large");
+      if (opcode >= 8 && (n > 125 || !fin)) throw new WsProtocolError("bad control frame");
+      if (this.buf.length < off + n) return out;
+      out.push({ fin, opcode, payload: this.buf.subarray(off, off + n) });
+      this.buf = this.buf.subarray(off + n);
+    }
+  }
+};
+var TunnelBlockedError = class extends Error {
+  static {
+    __name(this, "TunnelBlockedError");
+  }
+  constructor(status, detail) {
+    super(detail ? `tunnel blocked: ${detail}` : `tunnel blocked (HTTP ${status})`);
+    this.status = status;
+  }
+  status;
+};
+var GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+function defaultCa() {
+  const get = tls.getCACertificates;
+  if (!get) return void 0;
+  try {
+    return [...get("default"), ...get("system")];
+  } catch {
+    return void 0;
+  }
+}
+__name(defaultCa, "defaultCa");
+function openWebSocket(url, opts) {
+  const secure = url.protocol === "https:";
+  const key = randomBytes(16).toString("base64");
+  const hostname2 = url.hostname.replace(/^\[|\]$/g, "");
+  const port = Number(url.port || (secure ? 443 : 80));
+  return new Promise((resolve, reject) => {
+    let done = false;
+    let req;
+    const connecting = {};
+    const settle = /* @__PURE__ */ __name((err, value) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      if (err) reject(err);
+      else resolve(value);
+    }, "settle");
+    const timer = setTimeout(() => {
+      connecting.abort?.();
+      req?.destroy();
+      settle(new Error("tunnel connect timeout"));
+    }, opts.timeoutMs ?? 15e3);
+    timer.unref();
+    const common = {
+      host: hostname2,
+      port,
+      path: url.pathname,
+      method: "GET",
+      headers: {
+        Host: url.host,
+        Connection: "Upgrade",
+        Upgrade: "websocket",
+        "Sec-WebSocket-Version": "13",
+        "Sec-WebSocket-Key": key,
+        "Sec-WebSocket-Protocol": opts.protocol,
+        ...opts.userAgent ? { "User-Agent": opts.userAgent } : {}
+      }
+    };
+    const outerTls = { ...isIP(hostname2) ? {} : { servername: hostname2 }, rejectUnauthorized: false, ca: opts.ca ?? defaultCa() };
+    const upgrade = /* @__PURE__ */ __name((tunnelled) => {
+      if (done) {
+        tunnelled?.destroy();
+        return;
+      }
+      const r = tunnelled ? http2.request({ ...common, createConnection: /* @__PURE__ */ __name(() => secure ? tls.connect({ ...outerTls, socket: tunnelled }) : tunnelled, "createConnection") }) : secure ? https.request({ ...common, ...outerTls, agent: false }) : http2.request({ ...common, agent: false });
+      req = r;
+      r.on("response", (res) => {
+        res.resume();
+        settle(new TunnelBlockedError(res.statusCode ?? 0));
+      });
+      r.on("error", (err) => settle(err));
+      r.on("upgrade", (res, sock, head) => {
+        const accept = createHash2("sha1").update(key + GUID).digest("base64");
+        if (done || res.headers["sec-websocket-accept"] !== accept || res.headers["sec-websocket-protocol"] !== opts.protocol) {
+          sock.destroy();
+          settle(new TunnelBlockedError(101));
+          return;
+        }
+        const tlsSock = sock;
+        const outer = !secure ? "plain" : tlsSock.authorized ? "verified" : "intercepted";
+        const outerError = secure && !tlsSock.authorized && tlsSock.authorizationError ? String(tlsSock.authorizationError) : void 0;
+        settle(null, { stream: wrap(sock, head, opts.pingMs ?? 3e4), outer, ...outerError ? { outerError } : {} });
+      });
+      r.end();
+    }, "upgrade");
+    let route;
+    try {
+      route = proxyFor(url, opts.env ?? process.env);
+    } catch (err) {
+      settle(err);
+      return;
+    }
+    if (!route) {
+      upgrade();
+      return;
+    }
+    const via = connectVia(route, hostname2, port);
+    connecting.abort = via.abort;
+    via.socket.then(upgrade, (err) => settle(err instanceof ProxyRefusedError ? new TunnelBlockedError(err.status, err.message) : err));
+  });
+}
+__name(openWebSocket, "openWebSocket");
+function wrap(sock, head, pingMs) {
+  const parser = new FrameParser();
+  let closeSent = false;
+  const send2 = /* @__PURE__ */ __name((opcode, payload, cb) => {
+    sock.write(encodeFrame(opcode, payload, randomBytes(4)), cb);
+  }, "send2");
+  const duplex = new Duplex({
+    read() {
+      sock.resume();
+    },
+    write(chunk, _enc, cb) {
+      send2(OP.binary, chunk, cb);
+    },
+    final(cb) {
+      if (!closeSent) {
+        closeSent = true;
+        send2(OP.close, Buffer.from([3, 232]));
+      }
+      sock.end();
+      cb();
+    },
+    destroy(err, cb) {
+      clearInterval(pinger);
+      sock.destroy();
+      cb(err);
+    }
+  });
+  const failFrame = /* @__PURE__ */ __name((err) => {
+    setImmediate(() => duplex.destroy(err));
+  }, "failFrame");
+  const onData = /* @__PURE__ */ __name((chunk) => {
+    let frames;
+    try {
+      frames = parser.push(chunk);
+    } catch (err) {
+      failFrame(err instanceof WsProtocolError ? err : new WsProtocolError(String(err)));
+      return;
+    }
+    for (const f of frames) {
+      if (f.opcode === OP.binary || f.opcode === OP.cont) {
+        if (!duplex.push(Buffer.from(f.payload))) sock.pause();
+      } else if (f.opcode === OP.ping) {
+        send2(OP.pong, Buffer.from(f.payload));
+      } else if (f.opcode === OP.close) {
+        if (!closeSent) {
+          closeSent = true;
+          send2(OP.close, Buffer.from(f.payload.subarray(0, 2)));
+        }
+        duplex.push(null);
+        sock.end();
+      } else if (f.opcode === OP.text) {
+        failFrame(new WsProtocolError("text frame on a binary tunnel"));
+      }
+    }
+  }, "onData");
+  sock.on("data", onData);
+  sock.on("end", () => duplex.push(null));
+  sock.on("error", (err) => duplex.destroy(err));
+  sock.on("close", () => {
+    clearInterval(pinger);
+    if (!duplex.destroyed) duplex.destroy();
+  });
+  const pinger = setInterval(() => send2(OP.ping, Buffer.alloc(0)), pingMs);
+  pinger.unref();
+  if (head.length) onData(head);
+  return duplex;
+}
+__name(wrap, "wrap");
+var SessionGoneError = class extends Error {
+  static {
+    __name(this, "SessionGoneError");
+  }
+  constructor() {
+    super("tunnel session gone");
+  }
+};
+var EMPTY = Buffer.alloc(0);
+var MAX_ANSWER = RESPONSE_HEAD + MAX_DOWN;
+var FATAL_STATUS = /* @__PURE__ */ new Set([400, 403, 429]);
+var delay = /* @__PURE__ */ __name((ms) => new Promise((r) => setTimeout(r, ms)), "delay");
+function isBusy(r) {
+  if (r.status !== 503 || r.body.length > 4096) return false;
+  try {
+    return JSON.parse(r.body.toString("utf8")).error?.type === TUNNEL_BUSY;
+  } catch {
+    return false;
+  }
+}
+__name(isBusy, "isBusy");
+function settings(o) {
+  return { timeoutMs: o.timeoutMs ?? 15e3, waitMs: o.waitMs ?? POLL_WAIT_MS, retryForMs: o.retryForMs ?? 3e4, busyForMs: o.busyForMs ?? 3e5, coalesceMs: o.coalesceMs ?? 5 };
+}
+__name(settings, "settings");
+function makeExchanger(base, o) {
+  const secure = base.protocol === "https:";
+  const hostname2 = base.hostname.replace(/^\[|\]$/g, "");
+  const port = Number(base.port || (secure ? 443 : 80));
+  const outerTls = { ...isIP2(hostname2) ? {} : { servername: hostname2 }, rejectUnauthorized: false, ca: o.ca ?? defaultCa() };
+  const route = proxyFor(base, o.env ?? process.env);
+  const connectMs = o.timeoutMs ?? 15e3;
+  const agent = secure ? new https2.Agent({ keepAlive: true, maxSockets: 2, ...outerTls }) : new http3.Agent({ keepAlive: true, maxSockets: 2 });
+  if (route) {
+    agent.createConnection = (_opts, cb) => {
+      const via = connectVia(route, hostname2, port);
+      let settled = false;
+      const once = /* @__PURE__ */ __name((err, sock) => {
+        if (settled) {
+          sock?.destroy();
+          return;
+        }
+        settled = true;
+        clearTimeout(timer);
+        cb(err, sock);
+      }, "once");
+      const timer = setTimeout(() => {
+        once(new Error("tunnel connect timeout"));
+        via.abort();
+      }, connectMs);
+      via.socket.then(
+        (sock) => once(null, secure ? tls2.connect({ ...outerTls, socket: sock }) : sock),
+        (err) => once(err instanceof ProxyRefusedError ? new TunnelBlockedError(err.status, err.message) : err)
+      );
+      return void 0;
+    };
+  }
+  const post = /* @__PURE__ */ __name((body, timeoutMs) => new Promise((resolve, reject) => {
+    const req = (secure ? https2 : http3).request({
+      host: hostname2,
+      port,
+      path: POLL_PATH,
+      method: "POST",
+      agent,
+      ...secure ? outerTls : {},
+      headers: {
+        Host: base.host,
+        "Content-Type": "application/octet-stream",
+        "Content-Length": String(body.length),
+        ...o.userAgent ? { "User-Agent": o.userAgent } : {}
+      }
+    }, (res) => {
+      const sock = res.socket;
+      const outer = !secure ? "plain" : sock?.authorized ? "verified" : "intercepted";
+      const outerError = secure && !sock?.authorized && sock?.authorizationError ? String(sock.authorizationError) : void 0;
+      const chunks = [];
+      let size = 0;
+      res.on("data", (c) => {
+        size += c.length;
+        if (size > MAX_ANSWER) {
+          req.destroy(new Error("tunnel answer too large"));
+          return;
+        }
+        chunks.push(c);
+      });
+      res.on("end", () => resolve({ status: res.statusCode ?? 0, body: Buffer.concat(chunks), outer, ...outerError ? { outerError } : {} }));
+      res.on("error", reject);
+    });
+    req.setTimeout(timeoutMs, () => req.destroy(new Error("tunnel exchange timeout")));
+    req.on("error", reject);
+    req.end(body);
+  }), "post");
+  return { post, destroy: /* @__PURE__ */ __name(() => agent.destroy(), "destroy") };
+}
+__name(makeExchanger, "makeExchanger");
+var PollStream = class {
+  static {
+    __name(this, "PollStream");
+  }
+  constructor(ex, session, opts) {
+    this.ex = ex;
+    this.session = session;
+    this.o = settings(opts);
+    this.duplex = new Duplex2({
+      read: /* @__PURE__ */ __name(() => void 0, "read"),
+      write: /* @__PURE__ */ __name((chunk, _enc, cb) => {
+        this.pending.push(Buffer.from(chunk));
+        this.pendingSize += chunk.length;
+        if (this.pendingSize > MAX_UP) this.held.push(() => cb());
+        else cb();
+        this.kickUp();
+      }, "write"),
+      final: /* @__PURE__ */ __name((cb) => {
+        this.finishing = true;
+        this.kickUp();
+        cb();
+      }, "final"),
+      destroy: /* @__PURE__ */ __name((err, cb) => {
+        this.shutdown(true);
+        cb(err);
+      }, "destroy")
+    });
+    void this.downLoop();
+  }
+  ex;
+  session;
+  duplex;
+  o;
+  /** Upstream bytes the proxy has confirmed. */
+  sent = 0;
+  /** Downstream bytes received. */
+  received = 0;
+  pending = [];
+  pendingSize = 0;
+  held = [];
+  upRunning = false;
+  finishing = false;
+  closed = false;
+  kickUp() {
+    if (!this.upRunning && !this.closed) void this.upLoop();
+  }
+  async upLoop() {
+    this.upRunning = true;
+    try {
+      await delay(this.o.coalesceMs);
+      while (!this.closed && this.pendingSize > 0) {
+        const data = this.takePending();
+        await this.exchange({ session: this.session, upOffset: this.sent, ack: this.received, close: false, poll: false, open: false, data }, this.o.timeoutMs);
+        this.sent += data.length;
+        while (this.held.length > 0 && this.pendingSize <= MAX_UP) this.held.shift()();
+      }
+      if (this.finishing && !this.closed && this.pendingSize === 0) this.shutdown(true);
+    } catch (err) {
+      this.fail(err);
+    } finally {
+      this.upRunning = false;
+    }
+    if (!this.closed && this.pendingSize > 0) this.kickUp();
+  }
+  takePending() {
+    const all = Buffer.concat(this.pending);
+    const data = all.subarray(0, MAX_UP);
+    const rest = all.subarray(MAX_UP);
+    this.pending = rest.length > 0 ? [rest] : [];
+    this.pendingSize = rest.length;
+    return data;
+  }
+  async downLoop() {
+    try {
+      while (!this.closed) {
+        const r = await this.exchange({ session: this.session, upOffset: this.sent, ack: this.received, close: false, poll: true, open: false, data: EMPTY }, this.o.waitMs + this.o.timeoutMs);
+        if (this.closed) return;
+        if (r.downOffset > this.received) throw new Error("tunnel stream out of order");
+        const skip = this.received - r.downOffset;
+        if (skip < r.data.length) {
+          const fresh = Buffer.from(r.data.subarray(skip));
+          this.received += fresh.length;
+          this.duplex.push(fresh);
+        }
+        if (r.closed) {
+          this.duplex.push(null);
+          this.shutdown(true);
+          return;
+        }
+      }
+    } catch (err) {
+      this.fail(err);
+    }
+  }
+  async exchange(req, timeoutMs) {
+    const body = encodeRequest(req);
+    let firstFailure = 0;
+    let firstBusy = 0;
+    let wait = 250;
+    for (; ; ) {
+      if (this.closed) throw new Error("tunnel closed");
+      let failure;
+      let busy = false;
+      try {
+        const r = await this.ex.post(body, timeoutMs);
+        if (r.status === 200) return decodeResponse(r.body);
+        if (r.status === 404) throw new SessionGoneError();
+        failure = new TunnelBlockedError(r.status);
+        if (FATAL_STATUS.has(r.status)) throw failure;
+        busy = isBusy(r);
+      } catch (err) {
+        if (err instanceof SessionGoneError || err instanceof PollFormatError) throw err;
+        if (err instanceof TunnelBlockedError && FATAL_STATUS.has(err.status)) throw err;
+        failure = err;
+      }
+      if (busy) {
+        const t2 = Date.now();
+        if (firstBusy === 0) firstBusy = t2;
+        if (t2 - firstBusy >= this.o.busyForMs) throw failure;
+        firstFailure = 0;
+        await delay(Math.min(wait, 1e3));
+        wait = Math.min(wait * 2, 4e3);
+        continue;
+      }
+      const t = Date.now();
+      if (firstFailure === 0) firstFailure = t;
+      if (t - firstFailure >= this.o.retryForMs) throw failure;
+      await delay(wait);
+      wait = Math.min(wait * 2, 4e3);
+    }
+  }
+  fail(err) {
+    if (this.closed) return;
+    this.closed = true;
+    this.ex.destroy();
+    this.duplex.destroy(err);
+  }
+  shutdown(sendClose) {
+    if (this.closed) return;
+    this.closed = true;
+    if (sendClose) {
+      const bye = encodeRequest({ session: this.session, upOffset: this.sent, ack: this.received, close: true, poll: false, open: false, data: EMPTY });
+      this.ex.post(bye, 5e3).catch(() => void 0).finally(() => this.ex.destroy());
+    } else {
+      this.ex.destroy();
+    }
+    if (!this.duplex.destroyed) this.duplex.destroy();
+  }
+};
+async function openPollStream(base, opts = {}) {
+  const ex = makeExchanger(base, opts);
+  const session = randomBytes2(SESSION_BYTES);
+  const open2 = encodeRequest({ session, upOffset: 0, ack: 0, close: false, poll: false, open: true, data: EMPTY });
+  const o = settings(opts);
+  let first;
+  let firstFailure = 0;
+  let wait = 100;
+  while (first === void 0) {
+    try {
+      first = await ex.post(open2, o.timeoutMs);
+    } catch (err) {
+      const t = Date.now();
+      if (firstFailure === 0) firstFailure = t;
+      if (err.code !== "ECONNRESET" || t - firstFailure >= o.retryForMs) {
+        ex.destroy();
+        throw err;
+      }
+      await delay(wait);
+      wait = Math.min(wait * 2, 4e3);
+    }
+  }
+  if (first.status !== 200) {
+    ex.destroy();
+    throw new TunnelBlockedError(first.status);
+  }
+  let answered;
+  try {
+    answered = decodeResponse(first.body).session;
+  } catch {
+  }
+  if (!answered?.equals(session)) {
+    ex.destroy();
+    throw new TunnelBlockedError(200, "the answer is not the tunnel's (a filter's page?)");
+  }
+  const stream = new PollStream(ex, session, opts).duplex;
+  return { stream, outer: first.outer, ...first.outerError ? { outerError: first.outerError } : {} };
+}
+__name(openPollStream, "openPollStream");
+var IdentityMismatchError = class extends Error {
+  static {
+    __name(this, "IdentityMismatchError");
+  }
+  constructor(received) {
+    super("tunnel identity mismatch");
+    this.received = received;
+  }
+  received;
+};
+async function connectInner(base, pins, opts = {}) {
+  const outerOpts = { timeoutMs: opts.timeoutMs, ca: opts.ca, userAgent: opts.userAgent, env: opts.env };
+  const ws = opts.transport === "post" ? await openPollStream(base, outerOpts) : await openWebSocket(new URL(TUNNEL_PATH, base), { protocol: TUNNEL_PROTOCOL, ...outerOpts });
+  opts.onOuter?.({ outer: ws.outer, ...ws.outerError ? { outerError: ws.outerError } : {} });
+  const preferred = pins.at(-1);
+  const servername = preferred && isPin(preferred) ? sniOfPin(preferred) : TUNNEL_SERVERNAME;
+  const socket = tls3.connect({ socket: ws.stream, servername, minVersion: "TLSv1.3", rejectUnauthorized: false, ALPNProtocols: ["http/1.1"] });
+  ws.stream.on("close", () => socket.destroy());
+  ws.stream.on("end", () => socket.destroy());
+  ws.stream.on("error", () => socket.destroy());
+  socket.on("close", () => ws.stream.destroy());
+  try {
+    await new Promise((resolve, reject) => {
+      let settled = false;
+      const finish = /* @__PURE__ */ __name((err) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        socket.off("close", onClose);
+        socket.off("secureConnect", onSecure);
+        if (err === null) {
+          socket.off("error", onError);
+          resolve();
+          return;
+        }
+        socket.once("close", () => socket.off("error", onError));
+        reject(err);
+      }, "finish");
+      const onError = /* @__PURE__ */ __name((err) => finish(err), "onError");
+      const onClose = /* @__PURE__ */ __name(() => finish(new Error("tunnel closed during handshake")), "onClose");
+      const onSecure = /* @__PURE__ */ __name(() => finish(null), "onSecure");
+      const timer = setTimeout(() => finish(new Error("tunnel handshake timeout")), opts.timeoutMs ?? 15e3);
+      timer.unref();
+      socket.on("error", onError);
+      socket.on("close", onClose);
+      socket.on("secureConnect", onSecure);
+    });
+  } catch (err) {
+    socket.destroy();
+    throw err;
+  }
+  socket.on("error", () => socket.destroy());
+  const peer = peerCertificate(socket);
+  const received = peer ? pinOfSpki(peer.publicKey.export({ type: "spki", format: "der" })) : "none";
+  if (!pins.includes(received)) {
+    socket.destroy();
+    throw new IdentityMismatchError(received);
+  }
+  return socket;
+}
+__name(connectInner, "connectInner");
+var TUNNEL_AGENT_MAX_SOCKETS = 4;
+function canSwitch(err) {
+  if (err instanceof IdentityMismatchError || err instanceof BackoffError) return false;
+  if (err instanceof TunnelBlockedError && (err.status === 429 || err.status === 503)) return false;
+  return true;
+}
+__name(canSwitch, "canSwitch");
+function reasonOf(err) {
+  if (err instanceof TunnelBlockedError) return err.status === 101 || err.status === 200 ? err.message : `HTTP ${err.status}`;
+  return err instanceof Error ? err.message : String(err);
+}
+__name(reasonOf, "reasonOf");
+var BackoffError = class extends Error {
+  static {
+    __name(this, "BackoffError");
+  }
+  constructor(waitMs) {
+    super("tunnel identity mismatch - waiting before retry");
+    this.waitMs = waitMs;
+  }
+  waitMs;
+};
+var baseAddRequest = http4.Agent.prototype.addRequest;
+var TunnelAgent = class extends http4.Agent {
+  static {
+    __name(this, "TunnelAgent");
+  }
+  constructor(target, backoff, events = {}) {
+    super({ keepAlive: true, maxSockets: TUNNEL_AGENT_MAX_SOCKETS, maxFreeSockets: TUNNEL_AGENT_MAX_SOCKETS });
+    this.target = target;
+    this.backoff = backoff;
+    this.events = events;
+    this.mode = target.transport ?? "auto";
+    this.using = this.mode === "post" ? "post" : "ws";
+    this.connect = target.connect ?? connectInner;
+    this.pins = [...target.pins];
+    this.targets = [target.url, ...target.urls ?? []];
+    this.on("free", () => this.drain());
+  }
+  target;
+  backoff;
+  events;
+  /** Tunnels being opened: not yet in `sockets`, where Node would count them. */
+  opening = 0;
+  /** Requests waiting for a tunnel, in arrival order. */
+  waiting = [];
+  using;
+  mode;
+  connect;
+  pins;
+  /** Every host the code names, first one first; `preferred` indexes it. */
+  targets;
+  preferred = 0;
+  /** Destroyed: no tunnel is opened any more, and one still opening is closed when it arrives. */
+  closed = false;
+  /**
+   * The pins new tunnels are checked against (and the newest one asked for),
+   * from now on: what pin-sync learned through a pinned tunnel. Tunnels
+   * already open keep going.
+   */
+  setPins(pins) {
+    this.pins = [...pins];
+  }
+  get transport() {
+    return this.using;
+  }
+  live() {
+    let n = this.opening;
+    for (const list of Object.values(this.sockets)) n += list?.length ?? 0;
+    for (const list of Object.values(this.freeSockets)) n += list?.length ?? 0;
+    return n;
+  }
+  hasFree() {
+    return Object.values(this.freeSockets).some((list) => list?.some((s) => !s.destroyed));
+  }
+  canServe() {
+    return this.hasFree() || this.live() < TUNNEL_AGENT_MAX_SOCKETS;
+  }
+  /** Called by http.ClientRequest for every request; not in @types/node. */
+  addRequest(req, options) {
+    if (!this.canServe()) {
+      this.waiting.push({ req, options });
+      req.once("close", () => {
+        const i = this.waiting.findIndex((w) => w.req === req);
+        if (i >= 0) this.waiting.splice(i, 1);
+      });
+      return;
+    }
+    baseAddRequest.call(this, req, options);
+  }
+  drain() {
+    while (this.waiting.length > 0 && this.canServe()) {
+      const next = this.waiting.shift();
+      if (next.req.destroyed) continue;
+      baseAddRequest.call(this, next.req, next.options);
+    }
+  }
+  /** Whether destroy() ran: the agent opens nothing any more. */
+  get destroyed() {
+    return this.closed;
+  }
+  destroy() {
+    this.closed = true;
+    for (const { req } of this.waiting.splice(0)) {
+      const err = new Error("tunnel agent closed");
+      req.destroy(err);
+      process.nextTick(() => req.emit("error", err));
+    }
+    super.destroy();
+  }
+  // Node calls this with a callback for asynchronous sockets; returning nothing
+  // tells it to wait for the callback.
+  createConnection(_options, callback) {
+    const done = callback ?? (() => void 0);
+    if (this.closed) {
+      done(new Error("tunnel agent closed"), void 0);
+      return void 0;
+    }
+    const wait = this.backoff.blockedMs();
+    if (wait > 0) {
+      done(new BackoffError(wait), void 0);
+      return void 0;
+    }
+    this.opening += 1;
+    const dial = /* @__PURE__ */ __name((host, transport) => this.connect(this.targets[host], this.pins, { ca: this.target.ca, userAgent: this.target.userAgent, env: this.target.env, transport, onOuter: /* @__PURE__ */ __name((i) => this.events.onOuter?.(i), "onOuter") }), "dial");
+    const hosts = this.targets.map((_, i) => (this.preferred + i) % this.targets.length);
+    const transports = this.mode === "auto" ? this.using === "ws" ? ["ws", "post"] : ["post"] : [this.using === "post" ? "post" : "ws"];
+    const chain = transports.flatMap((transport) => hosts.map((host) => ({ host, transport })));
+    let firstErr = null;
+    const run = /* @__PURE__ */ __name((i) => {
+      const at = chain[i];
+      return dial(at.host, at.transport).then(
+        (socket) => {
+          if (this.preferred !== at.host) this.preferred = at.host;
+          if (this.mode === "auto" && this.using !== "post" && at.transport === "post") {
+            this.using = "post";
+            this.events.onTransport?.("post", firstErr === null ? null : `websocket blocked: ${reasonOf(firstErr)}`);
+          }
+          return socket;
+        },
+        (err) => {
+          if (!(err instanceof Error)) throw err;
+          if (firstErr === null) firstErr = err;
+          if (i + 1 < chain.length && canSwitch(err)) return run(i + 1);
+          throw err instanceof IdentityMismatchError ? err : firstErr;
+        }
+      );
+    }, "run");
+    run(0).then(
+      (socket) => {
+        this.opening -= 1;
+        if (this.closed) {
+          socket.destroy();
+          done(new Error("tunnel agent closed"), void 0);
+          return;
+        }
+        this.backoff.success();
+        this.events.onConnected?.();
+        socket.once("close", () => process.nextTick(() => this.drain()));
+        done(null, socket);
+      },
+      (err) => {
+        this.opening -= 1;
+        if (err instanceof IdentityMismatchError) {
+          this.backoff.failure();
+          this.events.onMismatch?.(err.received);
+        }
+        done(err, void 0);
+        this.drain();
+      }
+    );
+    return void 0;
+  }
+};
+function newLocalKey() {
+  return `o1gwl_${randomBytes3(32).toString("base64url")}`;
+}
+__name(newLocalKey, "newLocalKey");
+function hashLocalKey(key) {
+  return createHash3("sha256").update(key, "utf8").digest("hex");
+}
+__name(hashLocalKey, "hashLocalKey");
+var HOP = /* @__PURE__ */ new Set(["connection", "keep-alive", "proxy-authorization", "proxy-connection", "te", "trailer", "transfer-encoding", "upgrade", "host", "authorization", "x-api-key"]);
+var LOOPBACK2 = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "[::1]"]);
+function send(res, status, message) {
+  const body = JSON.stringify({ type: "error", error: { type: "tunnel_error", message } });
+  res.writeHead(status, { "content-type": "application/json", "content-length": Buffer.byteLength(body) }).end(body);
+}
+__name(send, "send");
+function keyOf(req) {
+  const bearer = /^Bearer\s+(.+)$/i.exec(String(req.headers.authorization ?? "").trim());
+  if (bearer) return bearer[1].trim();
+  const k = req.headers["x-api-key"];
+  return typeof k === "string" && k.trim() ? k.trim() : void 0;
+}
+__name(keyOf, "keyOf");
+function sameHash(a, b) {
+  const x = Buffer.from(a, "hex");
+  const y = Buffer.from(b, "hex");
+  return x.length === y.length && x.length > 0 && timingSafeEqual(x, y);
+}
+__name(sameHash, "sameHash");
+var REPLAY_MAX_BYTES = 10 * 1024 * 1024;
+function deadTunnel(err, reusedSocket) {
+  if (err instanceof SessionGoneError) return true;
+  const code = err?.code;
+  return reusedSocket && (code === "ECONNRESET" || code === "EPIPE");
+}
+__name(deadTunnel, "deadTunnel");
+function describeError(err) {
+  if (err instanceof BackoffError) return `tunnel identity mismatch - waiting before retry (${Math.ceil(err.waitMs / 6e4)} min)`;
+  if (err instanceof IdentityMismatchError) return "tunnel identity mismatch";
+  if (err instanceof TunnelBlockedError) return err.message;
+  return "tunnel unavailable";
+}
+__name(describeError, "describeError");
+function startLocalServer(o) {
+  const server = http5.createServer((req, res) => {
+    const started = Date.now();
+    const route = (req.url ?? "/").split("?")[0].slice(0, 200);
+    const hostname2 = String(req.headers.host ?? "").toLowerCase().replace(/:\d+$/, "");
+    if (!LOOPBACK2.has(hostname2)) return send(res, 403, "this endpoint answers on 127.0.0.1 only");
+    if (req.headers.origin !== void 0) return send(res, 403, "browser requests are not accepted");
+    const key = keyOf(req);
+    if (!key || !sameHash(hashLocalKey(key), o.localKeyHash)) return send(res, 401, "invalid or missing local key");
+    const headers = {};
+    for (const [name, value] of Object.entries(req.headers)) if (!HOP.has(name) && value !== void 0) headers[name] = value;
+    headers.host = o.target.host;
+    headers.authorization = `Bearer ${o.deviceToken}`;
+    let kept = [];
+    let keptBytes = 0;
+    req.on("data", (c) => {
+      if (!kept) return;
+      keptBytes += c.length;
+      if (keptBytes > REPLAY_MAX_BYTES) kept = null;
+      else kept.push(c);
+    });
+    let upstream;
+    const forward = /* @__PURE__ */ __name((replay) => {
+      const via = replay ? { createConnection: /* @__PURE__ */ __name((opts, cb) => o.agent.createConnection(opts, cb), "createConnection") } : { agent: o.agent };
+      const current = http5.request({ ...via, method: req.method, path: req.url, headers, setHost: false }, (up) => {
+        const out = {};
+        for (const [name, value] of Object.entries(up.headers)) if (!HOP.has(name) && value !== void 0) out[name] = value;
+        res.writeHead(up.statusCode ?? 502, out);
+        up.pipe(res);
+        up.on("error", () => res.destroy());
+        up.on("end", () => o.log?.(`${req.method} ${route} status=${up.statusCode} total=${Date.now() - started}ms`));
+      });
+      upstream = current;
+      current.on("error", (err) => {
+        if (!replay && !res.headersSent && kept && deadTunnel(err, current.reusedSocket)) {
+          o.log?.(`${req.method} ${route} retry: the tunnel was gone`);
+          const again = /* @__PURE__ */ __name(() => {
+            if (kept && !res.destroyed) forward(true);
+            else if (!res.destroyed) send(res, 502, describeError(err));
+          }, "again");
+          if (req.readableEnded) again();
+          else {
+            req.once("end", again);
+            req.resume();
+          }
+          return;
+        }
+        o.log?.(`${req.method} ${route} failed: ${describeError(err)}`);
+        if (res.headersSent) res.destroy();
+        else if (err instanceof TunnelBlockedError && err.status === 429) send(res, 429, "Too many attempts");
+        else send(res, 502, describeError(err));
+      });
+      if (replay) current.end(Buffer.concat(kept ?? []));
+      else req.pipe(current);
+    }, "forward");
+    forward(false);
+    res.on("close", () => {
+      if (!res.writableFinished) upstream.destroy();
+    });
+    req.on("error", () => upstream.destroy());
+  });
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(o.port, "127.0.0.1", () => {
+      server.off("error", reject);
+      resolve(server);
+    });
+  });
+}
+__name(startLocalServer, "startLocalServer");
+var IdentityBackoff = class {
+  static {
+    __name(this, "IdentityBackoff");
+  }
+  constructor(now = Date.now, baseMs = 6e4, maxMs = 60 * 6e4) {
+    this.now = now;
+    this.baseMs = baseMs;
+    this.maxMs = maxMs;
+  }
+  now;
+  baseMs;
+  maxMs;
+  failures = 0;
+  until = 0;
+  count = 0;
+  since = null;
+  blockedMs() {
+    return Math.max(0, this.until - this.now());
+  }
+  failure() {
+    const t = this.now();
+    this.count += 1;
+    this.since ??= t;
+    this.until = t + Math.min(this.baseMs * 2 ** this.failures, this.maxMs);
+    this.failures += 1;
+  }
+  success() {
+    this.failures = 0;
+    this.until = 0;
+    this.count = 0;
+    this.since = null;
+  }
+  snapshot() {
+    return { mismatches: this.count, since: this.since, waitMs: this.blockedMs() };
+  }
+};
+function mergePins(own, listed, via) {
+  const unchanged = { pins: [...own], added: [], dropped: [] };
+  if (via === null || !own.includes(via)) return unchanged;
+  if (!Array.isArray(listed) || listed.length === 0 || listed.length > MAX_PINS || !listed.every((p) => typeof p === "string" && isPin(p))) return unchanged;
+  const list = [...new Set(listed)];
+  const added = list.filter((p) => !own.includes(p));
+  if (list.includes(via)) {
+    return { pins: list, added, dropped: own.filter((p) => !list.includes(p)) };
+  }
+  const room = Math.max(0, MAX_PINS - own.length);
+  const learned = room > 0 ? added.slice(-room) : [];
+  return { pins: [...own, ...learned], added: learned, dropped: [] };
+}
+__name(mergePins, "mergePins");
+function pinOfSocket(socket) {
+  if (!(socket instanceof tls4.TLSSocket)) return null;
+  const peer = peerCertificate(socket);
+  return peer ? pinOfSpki(peer.publicKey.export({ type: "spki", format: "der" })) : null;
+}
+__name(pinOfSocket, "pinOfSocket");
+var MAX_BODY = 16 * 1024;
+var short = /* @__PURE__ */ __name((pin) => fingerprint(pin).slice(0, 19), "short");
+var PinSync = class {
+  static {
+    __name(this, "PinSync");
+  }
+  constructor(o) {
+    this.o = o;
+    this.current = [...o.pins];
+  }
+  o;
+  current;
+  last = Number.NEGATIVE_INFINITY;
+  running = null;
+  /** The pins in memory are not on disk yet (a save failed). */
+  unsaved = false;
+  /** config.bin belongs to another configuration now: nothing more is saved by this run. */
+  saveStopped = false;
+  get pins() {
+    return [...this.current];
+  }
+  /** Asks the proxy now; one request at a time. */
+  syncNow() {
+    this.running ??= this.run().finally(() => {
+      this.running = null;
+    });
+    return this.running;
+  }
+  /** Asks when the last try is older than the interval; failures are logged, never thrown. */
+  maybeSync() {
+    const now = (this.o.now ?? Date.now)();
+    if (this.running || now - this.last < (this.o.intervalMs ?? 36e5)) return;
+    this.last = now;
+    this.syncNow().catch((err) => this.o.log?.(`pin check failed: ${err instanceof Error ? err.message : String(err)}`));
+  }
+  async run() {
+    this.last = (this.o.now ?? Date.now)();
+    const { listed, via } = await this.fetch();
+    const merged = mergePins(this.current, listed, via);
+    const changed = merged.pins.length !== this.current.length || merged.pins.some((p, i) => p !== this.current[i]);
+    if (changed) {
+      this.current = merged.pins;
+      this.o.onChange?.(this.pins);
+      this.o.log?.(`proxy keys updated through the pinned tunnel: ${merged.added.map((p) => `+${short(p)}`).concat(merged.dropped.map((p) => `-${short(p)}`)).join(" ")}`);
+    }
+    if ((changed || this.unsaved) && !this.saveStopped) {
+      try {
+        if (await this.o.save(this.pins) === false) {
+          this.saveStopped = true;
+          this.o.log?.(this.o.stoppedLine ?? "config.bin now holds another configuration (setup ran since): the proxy keys learned by this run are no longer saved");
+        }
+        this.unsaved = false;
+      } catch (err) {
+        this.unsaved = true;
+        this.o.log?.(`could not save the proxy keys (tried again at the next check): ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    return { ...merged, via };
+  }
+  fetch() {
+    const { target } = this.o;
+    return new Promise((resolve, reject) => {
+      const req = http6.request({
+        host: target.hostname,
+        port: target.port,
+        method: "GET",
+        path: TUNNEL_PINS_PATH,
+        agent: this.o.agent,
+        setHost: false,
+        headers: { host: target.host, authorization: `Bearer ${this.o.deviceToken}`, accept: "application/json" }
+      }, (res) => {
+        const via = pinOfSocket(res.socket);
+        const chunks = [];
+        let size = 0;
+        res.on("data", (c) => {
+          size += c.length;
+          if (size > MAX_BODY) req.destroy(new Error("pin list too large"));
+          else chunks.push(c);
+        });
+        res.on("error", reject);
+        res.on("end", () => {
+          if (res.statusCode !== 200) return reject(new Error(`the proxy answered ${res.statusCode ?? 0} for its pins`));
+          try {
+            resolve({ listed: JSON.parse(Buffer.concat(chunks).toString("utf8")).pins, via });
+          } catch {
+            reject(new Error("the proxy's pin list is not JSON"));
+          }
+        });
+      });
+      req.setTimeout(this.o.timeoutMs ?? 3e4, () => req.destroy(new Error("pin check timeout")));
+      req.on("error", reject);
+      req.end();
+    });
+  }
+};
+async function startTunnelSession(o) {
+  const target = new URL(o.url);
+  const failover = (o.urls ?? []).map((u) => new URL(u));
+  const backoff = o.backoff ?? new IdentityBackoff();
+  const agent = new TunnelAgent({ url: target, urls: failover, pins: o.pins, userAgent: o.userAgent, transport: o.transport }, backoff, {
+    onOuter: o.onOuter,
+    onConnected: /* @__PURE__ */ __name(() => {
+      setImmediate(() => {
+        if (!agent.destroyed) pinSync.maybeSync();
+      });
+      o.onConnected?.();
+    }, "onConnected"),
+    onMismatch: o.onMismatch,
+    onTransport: o.onTransport
+  });
+  const pinSync = new PinSync({
+    agent,
+    target,
+    deviceToken: o.deviceToken,
+    pins: o.pins,
+    log: o.log,
+    onChange: /* @__PURE__ */ __name((pins) => agent.setPins(pins), "onChange"),
+    save: o.savePins,
+    stoppedLine: o.savePinsStoppedLine
+  });
+  let server;
+  try {
+    server = await startLocalServer({ port: o.port, localKeyHash: o.localKeyHash, deviceToken: o.deviceToken, target, agent, log: o.log });
+  } catch (err) {
+    agent.destroy();
+    throw err;
+  }
+  let closing = null;
+  const close = /* @__PURE__ */ __name(() => {
+    closing ??= new Promise((resolve) => {
+      agent.destroy();
+      server.close(() => resolve());
+      server.closeIdleConnections();
+      setImmediate(() => server.closeAllConnections());
+    });
+    return closing;
+  }, "close");
+  return { agent, pinSync, server, target, port: server.address().port, close };
+}
+__name(startTunnelSession, "startTunnelSession");
+var VERSION = true ? "9.4.0" : "dev";
+var O1ConnectError = class extends Error {
+  static {
+    __name(this, "O1ConnectError");
+  }
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "O1ConnectError";
+    this.code = code;
+  }
+};
+var DEFAULT_NAME = "aipp-connect";
+var TRANSPORTS = ["auto", "websocket", "post"];
+function entryName(name) {
+  if (name === void 0) return DEFAULT_NAME;
+  if (typeof name !== "string" || name.trim() === "") throw new TypeError("name must be a non-empty string");
+  return name;
+}
+__name(entryName, "entryName");
+function checkStore(store) {
+  const s = store;
+  if (!s || typeof s.get !== "function" || typeof s.set !== "function" || typeof s.delete !== "function") {
+    throw new TypeError("store must implement get, set and delete");
+  }
+  return s;
+}
+__name(checkStore, "checkStore");
+var entryLocks = /* @__PURE__ */ new WeakMap();
+function withEntry(store, name, fn) {
+  let byName = entryLocks.get(store);
+  if (!byName) {
+    byName = /* @__PURE__ */ new Map();
+    entryLocks.set(store, byName);
+  }
+  const map = byName;
+  const run = (map.get(name) ?? Promise.resolve()).then(fn);
+  const tail = run.then(() => void 0, () => void 0);
+  map.set(name, tail);
+  void tail.then(() => {
+    if (map.get(name) === tail) map.delete(name);
+  });
+  return run;
+}
+__name(withEntry, "withEntry");
+async function viaStore(what, call) {
+  try {
+    return await call();
+  } catch (err) {
+    throw new O1ConnectError("store_failed", `the secret store failed to ${what}`, { cause: err });
+  }
+}
+__name(viaStore, "viaStore");
+function parseSaved(raw) {
+  let o;
+  try {
+    o = JSON.parse(String(raw));
+  } catch {
+    throw new O1ConnectError("invalid_config", "the saved configuration is not JSON: run setup again");
+  }
+  if (!o || typeof o !== "object" || o.v !== 1) throw new O1ConnectError("invalid_config", "the saved configuration is not one this library knows: run setup again");
+  let code;
+  try {
+    code = validateCode(o);
+  } catch (err) {
+    throw new O1ConnectError("invalid_config", `the saved configuration is not valid (${err instanceof Error ? err.message : String(err)}): run setup again`);
+  }
+  const transport = o.transport ?? "auto";
+  if (!TRANSPORTS.includes(transport)) throw new O1ConnectError("invalid_config", "the saved transport is not auto, websocket or post: run setup again");
+  return { v: 1, ...code, transport };
+}
+__name(parseSaved, "parseSaved");
+async function setup(code, opts) {
+  const store = checkStore(opts?.store);
+  if (typeof opts.onFingerprint !== "function") throw new TypeError("onFingerprint is required: every key's fingerprint must be confirmed by the user");
+  const name = entryName(opts.name);
+  const transport = opts.transport ?? "auto";
+  if (!TRANSPORTS.includes(transport)) throw new TypeError("transport must be auto, websocket or post");
+  let decoded;
+  try {
+    decoded = decodeConnectionCode(String(code ?? ""));
+  } catch (err) {
+    throw new O1ConnectError("invalid_code", err instanceof ConnectionCodeError ? err.message : "the connection code is not valid");
+  }
+  const fingerprints = decoded.pins.map((p) => fingerprint(p));
+  const info = { device: decoded.device, url: decoded.url, ...decoded.urls ? { urls: [...decoded.urls] } : {} };
+  if (await opts.onFingerprint([...fingerprints], { ...info }) !== true) {
+    throw new O1ConnectError("fingerprint_rejected", "the proxy keys were not confirmed: nothing was saved");
+  }
+  const saved = { v: 1, ...decoded, transport };
+  await withEntry(store, name, () => viaStore("save the configuration", () => store.set(name, JSON.stringify(saved))));
+  return { ...info, fingerprints };
+}
+__name(setup, "setup");
+async function open(opts) {
+  const store = checkStore(opts?.store);
+  const name = entryName(opts.name);
+  const port = opts.port ?? 0;
+  if (!Number.isInteger(port) || port < 0 || port > 65535) throw new TypeError("port must be an integer from 0 to 65535");
+  const raw = await viaStore("read the configuration", () => store.get(name));
+  if (raw === null || raw === void 0) throw new O1ConnectError("not_set_up", "no o1-connect configuration in the store: run setup with a connection code");
+  const cfg = parseSaved(raw);
+  const log = opts.log ? (line) => {
+    try {
+      opts.log(line);
+    } catch {
+    }
+  } : void 0;
+  const apiKey = newLocalKey();
+  let session;
+  try {
+    session = await startTunnelSession({
+      url: cfg.url,
+      urls: cfg.urls,
+      pins: cfg.pins,
+      deviceToken: cfg.token,
+      transport: cfg.transport,
+      port,
+      localKeyHash: hashLocalKey(apiKey),
+      // Only when the app asks (like the CLI's identify): absent, nothing about the client goes on the wire.
+      userAgent: opts.identify === true ? `o1-connect-lib/${VERSION}` : void 0,
+      log,
+      onMismatch: /* @__PURE__ */ __name((received) => {
+        log?.(`TUNNEL IDENTITY MISMATCH: received ${received}; possible interception`);
+        try {
+          opts.onMismatch?.(received);
+        } catch {
+        }
+      }, "onMismatch"),
+      onTransport: /* @__PURE__ */ __name((t, reason) => log?.(`${reason ?? "transport"}, using ${t}`), "onTransport"),
+      // Pins learned during a key rotation: saved only while the store still holds this
+      // configuration (same proxy, device and token), under the entry's lock; false (never
+      // tried again by this connection) once setup replaced it or forget deleted it.
+      savePinsStoppedLine: "the store now holds another configuration, or none (setup or forget ran since): the proxy keys learned by this connection are no longer saved",
+      savePins: /* @__PURE__ */ __name((pins) => withEntry(store, name, async () => {
+        const raw2 = await viaStore("read the configuration", () => store.get(name));
+        if (raw2 === null || raw2 === void 0) return false;
+        let current;
+        try {
+          current = parseSaved(raw2);
+        } catch {
+          return false;
+        }
+        if (current.url !== cfg.url || current.device !== cfg.device || current.token !== cfg.token) return false;
+        await viaStore("save the configuration", () => store.set(name, JSON.stringify({ ...current, pins })));
+        return true;
+      }), "savePins")
+    });
+  } catch (err) {
+    const code = err.code;
+    if (code === "EADDRINUSE") throw new O1ConnectError("port_in_use", `port ${port} is in use`);
+    if (code === "EACCES" || code === "EADDRNOTAVAIL") throw new O1ConnectError("port_unavailable", `cannot listen on 127.0.0.1:${port} (${code})`, { cause: err });
+    throw err;
+  }
+  if (opts.check !== false) {
+    try {
+      await session.pinSync.syncNow();
+    } catch (err) {
+      await session.close();
+      if (err instanceof IdentityMismatchError || err instanceof BackoffError) {
+        throw new O1ConnectError("identity_mismatch", "the proxy presented a key that is not pinned: possible interception (nothing was sent)");
+      }
+      throw new O1ConnectError("tunnel_unavailable", `the tunnel did not answer: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  const baseUrl = `http://127.0.0.1:${session.port}`;
+  log?.(`o1-connect library ${VERSION} for ${cfg.device} listening on ${baseUrl} (transport ${cfg.transport})`);
+  return { baseUrl, openaiBaseUrl: `${baseUrl}/v1`, apiKey, port: session.port, device: cfg.device, close: session.close };
+}
+__name(open, "open");
+async function forget(opts) {
+  const store = checkStore(opts?.store);
+  const name = entryName(opts.name);
+  await withEntry(store, name, () => viaStore("delete the configuration", () => store.delete(name)));
+}
+__name(forget, "forget");
+
+// packages/core/src/mcp/token-storage/file-token-storage.ts
+init_esbuild_shims();
+import { promises as fs } from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import * as crypto from "node:crypto";
+var UnreadableSecretFileError = class extends Error {
+  static {
+    __name(this, "UnreadableSecretFileError");
+  }
+  filePath;
+  constructor(filePath, options) {
+    super(
+      `${filePath} cannot be decrypted on this machine: it was saved under another host name or user, or it is damaged`,
+      options
+    );
+    this.name = "UnreadableSecretFileError";
+    this.filePath = filePath;
+  }
+};
+function isUnreadableSecretFileError(error) {
+  return error instanceof UnreadableSecretFileError;
+}
+__name(isUnreadableSecretFileError, "isUnreadableSecretFileError");
+function backupStamp(date) {
+  const pad = /* @__PURE__ */ __name((n) => String(n).padStart(2, "0"), "pad");
+  return `${date.getFullYear()}${pad(date.getMonth() + 1)}${pad(date.getDate())}-${pad(date.getHours())}${pad(date.getMinutes())}${pad(date.getSeconds())}`;
+}
+__name(backupStamp, "backupStamp");
+async function setAsideUnreadableSecretFile(filePath, now = /* @__PURE__ */ new Date()) {
+  const backupPath = `${filePath}.unreadable-${backupStamp(now)}.bak`;
+  await fs.rename(filePath, backupPath);
+  return backupPath;
+}
+__name(setAsideUnreadableSecretFile, "setAsideUnreadableSecretFile");
+var FileTokenStorage = class extends BaseTokenStorage {
+  static {
+    __name(this, "FileTokenStorage");
+  }
+  tokenFilePath;
+  secretFilePath;
+  encryptionKey;
+  constructor(serviceName) {
+    super(serviceName);
+    const configDir = Storage.getGlobalO1CodeDir();
+    this.tokenFilePath = path.join(configDir, "mcp-oauth-tokens-v2.json");
+    this.secretFilePath = path.join(configDir, "extension-secrets-v1.json");
+    this.encryptionKey = this.deriveEncryptionKey();
+  }
+  deriveEncryptionKey() {
+    const salt = `${os.hostname()}-${os.userInfo().username}-o1-code`;
+    return crypto.scryptSync("o1-code-oauth", salt, 32);
+  }
+  encrypt(text) {
+    const iv = crypto.randomBytes(16);
+    const cipher = crypto.createCipheriv("aes-256-gcm", this.encryptionKey, iv);
+    let encrypted = cipher.update(text, "utf8", "hex");
+    encrypted += cipher.final("hex");
+    const authTag = cipher.getAuthTag();
+    return iv.toString("hex") + ":" + authTag.toString("hex") + ":" + encrypted;
+  }
+  decrypt(encryptedData) {
+    const parts = encryptedData.split(":");
+    if (parts.length !== 3) {
+      throw new Error("Invalid encrypted data format");
+    }
+    const iv = Buffer.from(parts[0], "hex");
+    const authTag = Buffer.from(parts[1], "hex");
+    const encrypted = parts[2];
+    const decipher = crypto.createDecipheriv(
+      "aes-256-gcm",
+      this.encryptionKey,
+      iv
+    );
+    decipher.setAuthTag(authTag);
+    let decrypted = decipher.update(encrypted, "hex", "utf8");
+    decrypted += decipher.final("utf8");
+    return decrypted;
+  }
+  async ensureDirectoryExists() {
+    const dir = path.dirname(this.tokenFilePath);
+    await fs.mkdir(dir, { recursive: true, mode: 448 });
+  }
+  async loadTokens(allowMissing = false) {
+    try {
+      const data = await fs.readFile(this.tokenFilePath, "utf-8");
+      const decrypted = this.decrypt(data);
+      const tokens = JSON.parse(decrypted);
+      return new Map(Object.entries(tokens));
+    } catch (error) {
+      const err = error;
+      if (err.code === "ENOENT") {
+        if (allowMissing) {
+          return /* @__PURE__ */ new Map();
+        }
+        throw new Error("Token file does not exist");
+      }
+      if (err.message?.includes("Invalid encrypted data format") || err.message?.includes(
+        "Unsupported state or unable to authenticate data"
+      )) {
+        throw new Error("Token file corrupted");
+      }
+      throw error;
+    }
+  }
+  async saveTokens(tokens) {
+    await this.ensureDirectoryExists();
+    const data = Object.fromEntries(tokens);
+    const json = JSON.stringify(data, null, 2);
+    const encrypted = this.encrypt(json);
+    await atomicWriteFile(this.tokenFilePath, encrypted, {
+      mode: 384,
+      forceMode: true,
+      noFollow: true
+    });
+  }
+  async getCredentials(serverName) {
+    const tokens = await this.loadTokens();
+    const credentials = tokens.get(serverName);
+    if (!credentials) {
+      return null;
+    }
+    if (this.isTokenExpired(credentials)) {
+      return null;
+    }
+    return credentials;
+  }
+  async setCredentials(credentials) {
+    this.validateCredentials(credentials);
+    const tokens = await this.loadTokens(true);
+    const updatedCredentials = {
+      ...credentials,
+      updatedAt: Date.now()
+    };
+    tokens.set(credentials.serverName, updatedCredentials);
+    await this.saveTokens(tokens);
+  }
+  async deleteCredentials(serverName) {
+    const tokens = await this.loadTokens();
+    if (!tokens.has(serverName)) {
+      throw new Error(`No credentials found for ${serverName}`);
+    }
+    tokens.delete(serverName);
+    if (tokens.size === 0) {
+      try {
+        await fs.unlink(this.tokenFilePath);
+      } catch (error) {
+        const err = error;
+        if (err.code !== "ENOENT") {
+          throw error;
+        }
+      }
+    } else {
+      await this.saveTokens(tokens);
+    }
+  }
+  async listServers() {
+    const tokens = await this.loadTokens();
+    return Array.from(tokens.keys());
+  }
+  async getAllCredentials() {
+    const tokens = await this.loadTokens();
+    const result = /* @__PURE__ */ new Map();
+    for (const [serverName, credentials] of tokens) {
+      if (!this.isTokenExpired(credentials)) {
+        result.set(serverName, credentials);
+      }
+    }
+    return result;
+  }
+  async clearAll() {
+    try {
+      await fs.unlink(this.tokenFilePath);
+    } catch (error) {
+      const err = error;
+      if (err.code !== "ENOENT") {
+        throw error;
+      }
+    }
+  }
+  async loadSecrets() {
+    let data;
+    try {
+      data = await fs.readFile(this.secretFilePath, "utf-8");
+    } catch (error) {
+      const err = error;
+      if (err.code === "ENOENT") {
+        return {};
+      }
+      throw error;
+    }
+    try {
+      return JSON.parse(this.decrypt(data));
+    } catch (error) {
+      throw new UnreadableSecretFileError(this.secretFilePath, {
+        cause: error
+      });
+    }
+  }
+  async saveSecrets(secrets) {
+    await this.ensureDirectoryExists();
+    const encrypted = this.encrypt(JSON.stringify(secrets));
+    await atomicWriteFile(this.secretFilePath, encrypted, {
+      mode: 384,
+      forceMode: true,
+      noFollow: true
+    });
+  }
+  // The encrypted file is always usable, so the file backend is always available.
+  async isAvailable() {
+    return true;
+  }
+  async setSecret(key, value) {
+    const secrets = await this.loadSecrets();
+    (secrets[this.serviceName] ??= {})[key] = value;
+    await this.saveSecrets(secrets);
+  }
+  async getSecret(key) {
+    const secrets = await this.loadSecrets();
+    return secrets[this.serviceName]?.[key] ?? null;
+  }
+  // Idempotent: deleting a missing secret is a no-op (the keychain backend
+  // throws, but extension-settings callers do not depend on that signal).
+  async deleteSecret(key) {
+    const secrets = await this.loadSecrets();
+    const bucket = secrets[this.serviceName];
+    if (!bucket || !(key in bucket)) {
+      return;
+    }
+    delete bucket[key];
+    if (Object.keys(bucket).length === 0) {
+      delete secrets[this.serviceName];
+    }
+    await this.saveSecrets(secrets);
+  }
+  async listSecrets() {
+    const secrets = await this.loadSecrets();
+    return Object.keys(secrets[this.serviceName] ?? {});
+  }
+};
+
+// packages/core/src/providers/o1-connect/store.ts
+init_esbuild_shims();
+
+// packages/core/src/mcp/token-storage/hybrid-token-storage.ts
+init_esbuild_shims();
+
+// packages/core/src/mcp/token-storage/types.ts
+init_esbuild_shims();
+var TokenStorageType = /* @__PURE__ */ ((TokenStorageType2) => {
+  TokenStorageType2["KEYCHAIN"] = "keychain";
+  TokenStorageType2["ENCRYPTED_FILE"] = "encrypted_file";
+  return TokenStorageType2;
+})(TokenStorageType || {});
+
+// packages/core/src/mcp/token-storage/hybrid-token-storage.ts
+var FORCE_FILE_STORAGE_ENV_VAR = "O1CODE_FORCE_FILE_STORAGE";
+var HybridTokenStorage = class extends BaseTokenStorage {
+  static {
+    __name(this, "HybridTokenStorage");
+  }
+  storage = null;
+  storageType = null;
+  storageInitPromise = null;
+  constructor(serviceName) {
+    super(serviceName);
+  }
+  async initializeStorage() {
+    const forceFileStorage = process.env[FORCE_FILE_STORAGE_ENV_VAR] === "true";
+    if (!forceFileStorage) {
+      try {
+        const { KeychainTokenStorage } = await import("./keychain-token-storage-SJOKJDWV.js");
+        const keychainStorage = new KeychainTokenStorage(this.serviceName);
+        const isAvailable = await keychainStorage.isAvailable();
+        if (isAvailable) {
+          this.storage = keychainStorage;
+          this.storageType = "keychain" /* KEYCHAIN */;
+          return this.storage;
+        }
+      } catch (_e) {
+      }
+    }
+    this.storage = new FileTokenStorage(this.serviceName);
+    this.storageType = "encrypted_file" /* ENCRYPTED_FILE */;
+    return this.storage;
+  }
+  async getStorage() {
+    if (this.storage !== null) {
+      return this.storage;
+    }
+    if (!this.storageInitPromise) {
+      this.storageInitPromise = this.initializeStorage();
+    }
+    return await this.storageInitPromise;
+  }
+  async getCredentials(serverName) {
+    const storage = await this.getStorage();
+    return storage.getCredentials(serverName);
+  }
+  async setCredentials(credentials) {
+    const storage = await this.getStorage();
+    await storage.setCredentials(credentials);
+  }
+  async deleteCredentials(serverName) {
+    const storage = await this.getStorage();
+    await storage.deleteCredentials(serverName);
+  }
+  async listServers() {
+    const storage = await this.getStorage();
+    return storage.listServers();
+  }
+  async getAllCredentials() {
+    const storage = await this.getStorage();
+    return storage.getAllCredentials();
+  }
+  async clearAll() {
+    const storage = await this.getStorage();
+    await storage.clearAll();
+  }
+  async getStorageType() {
+    await this.getStorage();
+    return this.storageType;
+  }
+  // Secret API — delegates to whichever backend is active (keychain when
+  // available, otherwise the encrypted file). This is what lets sensitive
+  // extension settings degrade gracefully to file storage without a keychain.
+  async isAvailable() {
+    const storage = await this.getStorage();
+    return storage.isAvailable();
+  }
+  async setSecret(key, value) {
+    const storage = await this.getStorage();
+    await storage.setSecret(key, value);
+  }
+  async getSecret(key) {
+    const storage = await this.getStorage();
+    return storage.getSecret(key);
+  }
+  async deleteSecret(key) {
+    const storage = await this.getStorage();
+    await storage.deleteSecret(key);
+  }
+  async listSecrets() {
+    const storage = await this.getStorage();
+    return storage.listSecrets();
+  }
+};
+
+// packages/core/src/providers/o1-connect/store.ts
+var O1_CONNECT_SERVICE_NAME = "o1-code-organizaone";
+function createO1ConnectStore(storage = new HybridTokenStorage(O1_CONNECT_SERVICE_NAME)) {
+  return {
+    async get(name) {
+      return storage.getSecret(name);
+    },
+    async set(name, value) {
+      await storage.setSecret(name, value);
+    },
+    async delete(name) {
+      await storage.deleteSecret(name);
+    }
+  };
+}
+__name(createO1ConnectStore, "createO1ConnectStore");
+
+// packages/core/src/providers/o1-connect/session.ts
+async function setupO1Connect(code, options) {
+  return setup(code.trim(), {
+    store: options.store ?? createO1ConnectStore(),
+    onFingerprint: options.onFingerprint,
+    ...options.transport ? { transport: options.transport } : {}
+  });
+}
+__name(setupO1Connect, "setupO1Connect");
+async function openO1Connect(options = {}) {
+  let connection;
+  try {
+    connection = await open({
+      store: options.store ?? createO1ConnectStore(),
+      ...options.log ? { log: options.log } : {}
+    });
+  } catch (error) {
+    if (isO1ConnectError(error) && error.code === "store_failed" && isUnreadableSecretFileError(error.cause)) {
+      throw new O1ConnectError(
+        "store_failed",
+        describeO1ConnectError(error).message,
+        { cause: error.cause }
+      );
+    }
+    throw error;
+  }
+  return {
+    baseUrl: connection.baseUrl,
+    openaiBaseUrl: connection.openaiBaseUrl,
+    apiKey: connection.apiKey,
+    device: connection.device,
+    close: /* @__PURE__ */ __name(() => connection.close(), "close")
+  };
+}
+__name(openO1Connect, "openO1Connect");
+async function forgetO1Connect(options = {}) {
+  await forget({ store: options.store ?? createO1ConnectStore() });
+}
+__name(forgetO1Connect, "forgetO1Connect");
+async function setAsideUnreadableSecretStore(filePath) {
+  return setAsideUnreadableSecretFile(filePath);
+}
+__name(setAsideUnreadableSecretStore, "setAsideUnreadableSecretStore");
+function o1ConnectBaseUrlFor(session, authType) {
+  return authType === "openai" /* USE_OPENAI */ || authType === "openai-responses" /* USE_OPENAI_RESPONSES */ ? session.openaiBaseUrl : session.baseUrl;
+}
+__name(o1ConnectBaseUrlFor, "o1ConnectBaseUrlFor");
+function isO1ConnectError(error) {
+  return error instanceof O1ConnectError;
+}
+__name(isO1ConnectError, "isO1ConnectError");
+function describeO1ConnectError(error) {
+  if (isO1ConnectError(error) && error.code === "store_failed" && isUnreadableSecretFileError(error.cause)) {
+    return {
+      message: `The secret store at ${error.cause.filePath} cannot be decrypted on this machine: it was saved under another host name or user, or it is damaged. Setting up the connection code again offers to keep it as a .bak and start a new one.`,
+      forgetAndSetUpAgain: false,
+      unreadableSecretFile: error.cause.filePath
+    };
+  }
+  if (!isO1ConnectError(error)) {
+    return {
+      message: error instanceof Error ? error.message : String(error),
+      forgetAndSetUpAgain: false
+    };
+  }
+  switch (error.code) {
+    case "invalid_code":
+      return {
+        message: "That is not an o1-gateway connection code (it starts with o1gw1.), or it is damaged. Paste it again.",
+        forgetAndSetUpAgain: false
+      };
+    case "fingerprint_rejected":
+      return {
+        message: "Nothing was saved: the fingerprints were not confirmed.",
+        forgetAndSetUpAgain: false
+      };
+    case "not_set_up":
+      return {
+        message: "No o1-gateway connection is saved on this machine. Paste a connection code to set one up.",
+        forgetAndSetUpAgain: false
+      };
+    case "invalid_config":
+      return {
+        message: "The saved o1-gateway connection is not one this version can read. Paste a connection code to set it up again.",
+        forgetAndSetUpAgain: true
+      };
+    case "store_failed":
+      return {
+        message: `The secret store refused the connection (${error.cause instanceof Error ? error.cause.message : "locked or unavailable"}).`,
+        forgetAndSetUpAgain: false
+      };
+    case "identity_mismatch":
+      return {
+        message: "The proxy's key is not the one you pinned: this network may be intercepting the connection. Nothing was sent. Do not use a direct connection on this network.",
+        forgetAndSetUpAgain: false
+      };
+    case "tunnel_unavailable":
+      return {
+        message: "The tunnel to o1-gateway could not be opened (network, proxy, or a device that may not tunnel). Try again later; if it persists, paste a new connection code.",
+        forgetAndSetUpAgain: false
+      };
+    case "port_in_use":
+    case "port_unavailable":
+      return {
+        message: `No loopback port could be opened for the tunnel: ${error.message}`,
+        forgetAndSetUpAgain: false
+      };
+    default:
+      return { message: error.message, forgetAndSetUpAgain: false };
+  }
+}
+__name(describeO1ConnectError, "describeO1ConnectError");
+
+export {
+  O1ConnectError,
+  FileTokenStorage,
+  TokenStorageType,
+  HybridTokenStorage,
+  setupO1Connect,
+  openO1Connect,
+  forgetO1Connect,
+  setAsideUnreadableSecretStore,
+  o1ConnectBaseUrlFor,
+  isO1ConnectError,
+  describeO1ConnectError
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2026 o1-code contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */