@launchsecure/launch-kit 0.0.34 → 0.0.35

package/dist/server/launch-bot-entry.js

@@ -0,0 +1,4078 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/max.js
+var max_default;
+var init_max = __esm({
+  "../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/max.js"() {
+    max_default = "ffffffff-ffff-ffff-ffff-ffffffffffff";
+  }
+});
+
+// ../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/nil.js
+var nil_default;
+var init_nil = __esm({
+  "../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/nil.js"() {
+    nil_default = "00000000-0000-0000-0000-000000000000";
+  }
+});
+
+// ../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/regex.js
+var regex_default;
+var init_regex = __esm({
+  "../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/regex.js"() {
+    regex_default = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;
+  }
+});
+
+// ../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/validate.js
+function validate(uuid) {
+  return typeof uuid === "string" && regex_default.test(uuid);
+}
+var validate_default;
+var init_validate = __esm({
+  "../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/validate.js"() {
+    init_regex();
+    validate_default = validate;
+  }
+});
+
+// ../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/parse.js
+function parse(uuid) {
+  if (!validate_default(uuid)) {
+    throw TypeError("Invalid UUID");
+  }
+  let v;
+  const arr = new Uint8Array(16);
+  arr[0] = (v = parseInt(uuid.slice(0, 8), 16)) >>> 24;
+  arr[1] = v >>> 16 & 255;
+  arr[2] = v >>> 8 & 255;
+  arr[3] = v & 255;
+  arr[4] = (v = parseInt(uuid.slice(9, 13), 16)) >>> 8;
+  arr[5] = v & 255;
+  arr[6] = (v = parseInt(uuid.slice(14, 18), 16)) >>> 8;
+  arr[7] = v & 255;
+  arr[8] = (v = parseInt(uuid.slice(19, 23), 16)) >>> 8;
+  arr[9] = v & 255;
+  arr[10] = (v = parseInt(uuid.slice(24, 36), 16)) / 1099511627776 & 255;
+  arr[11] = v / 4294967296 & 255;
+  arr[12] = v >>> 24 & 255;
+  arr[13] = v >>> 16 & 255;
+  arr[14] = v >>> 8 & 255;
+  arr[15] = v & 255;
+  return arr;
+}
+var parse_default;
+var init_parse = __esm({
+  "../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/parse.js"() {
+    init_validate();
+    parse_default = parse;
+  }
+});
+
+// ../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/stringify.js
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+function stringify(arr, offset = 0) {
+  const uuid = unsafeStringify(arr, offset);
+  if (!validate_default(uuid)) {
+    throw TypeError("Stringified UUID is invalid");
+  }
+  return uuid;
+}
+var byteToHex, stringify_default;
+var init_stringify = __esm({
+  "../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/stringify.js"() {
+    init_validate();
+    byteToHex = [];
+    for (let i = 0; i < 256; ++i) {
+      byteToHex.push((i + 256).toString(16).slice(1));
+    }
+    stringify_default = stringify;
+  }
+});
+
+// ../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/rng.js
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    import_node_crypto.default.randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+var import_node_crypto, rnds8Pool, poolPtr;
+var init_rng = __esm({
+  "../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/rng.js"() {
+    import_node_crypto = __toESM(require("node:crypto"));
+    rnds8Pool = new Uint8Array(256);
+    poolPtr = rnds8Pool.length;
+  }
+});
+
+// ../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/v1.js
+function v1(options, buf, offset) {
+  let i = buf && offset || 0;
+  const b = buf || new Array(16);
+  options = options || {};
+  let node = options.node;
+  let clockseq = options.clockseq;
+  if (!options._v6) {
+    if (!node) {
+      node = _nodeId;
+    }
+    if (clockseq == null) {
+      clockseq = _clockseq;
+    }
+  }
+  if (node == null || clockseq == null) {
+    const seedBytes = options.random || (options.rng || rng)();
+    if (node == null) {
+      node = [seedBytes[0], seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]];
+      if (!_nodeId && !options._v6) {
+        node[0] |= 1;
+        _nodeId = node;
+      }
+    }
+    if (clockseq == null) {
+      clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 16383;
+      if (_clockseq === void 0 && !options._v6) {
+        _clockseq = clockseq;
+      }
+    }
+  }
+  let msecs = options.msecs !== void 0 ? options.msecs : Date.now();
+  let nsecs = options.nsecs !== void 0 ? options.nsecs : _lastNSecs + 1;
+  const dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 1e4;
+  if (dt < 0 && options.clockseq === void 0) {
+    clockseq = clockseq + 1 & 16383;
+  }
+  if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === void 0) {
+    nsecs = 0;
+  }
+  if (nsecs >= 1e4) {
+    throw new Error("uuid.v1(): Can't create more than 10M uuids/sec");
+  }
+  _lastMSecs = msecs;
+  _lastNSecs = nsecs;
+  _clockseq = clockseq;
+  msecs += 122192928e5;
+  const tl = ((msecs & 268435455) * 1e4 + nsecs) % 4294967296;
+  b[i++] = tl >>> 24 & 255;
+  b[i++] = tl >>> 16 & 255;
+  b[i++] = tl >>> 8 & 255;
+  b[i++] = tl & 255;
+  const tmh = msecs / 4294967296 * 1e4 & 268435455;
+  b[i++] = tmh >>> 8 & 255;
+  b[i++] = tmh & 255;
+  b[i++] = tmh >>> 24 & 15 | 16;
+  b[i++] = tmh >>> 16 & 255;
+  b[i++] = clockseq >>> 8 | 128;
+  b[i++] = clockseq & 255;
+  for (let n = 0; n < 6; ++n) {
+    b[i + n] = node[n];
+  }
+  return buf || unsafeStringify(b);
+}
+var _nodeId, _clockseq, _lastMSecs, _lastNSecs, v1_default;
+var init_v1 = __esm({
+  "../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/v1.js"() {
+    init_rng();
+    init_stringify();
+    _lastMSecs = 0;
+    _lastNSecs = 0;
+    v1_default = v1;
+  }
+});
+
+// ../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/v1ToV6.js
+function v1ToV6(uuid) {
+  const v1Bytes = typeof uuid === "string" ? parse_default(uuid) : uuid;
+  const v6Bytes = _v1ToV6(v1Bytes);
+  return typeof uuid === "string" ? unsafeStringify(v6Bytes) : v6Bytes;
+}
+function _v1ToV6(v1Bytes, randomize = false) {
+  return Uint8Array.of((v1Bytes[6] & 15) << 4 | v1Bytes[7] >> 4 & 15, (v1Bytes[7] & 15) << 4 | (v1Bytes[4] & 240) >> 4, (v1Bytes[4] & 15) << 4 | (v1Bytes[5] & 240) >> 4, (v1Bytes[5] & 15) << 4 | (v1Bytes[0] & 240) >> 4, (v1Bytes[0] & 15) << 4 | (v1Bytes[1] & 240) >> 4, (v1Bytes[1] & 15) << 4 | (v1Bytes[2] & 240) >> 4, 96 | v1Bytes[2] & 15, v1Bytes[3], v1Bytes[8], v1Bytes[9], v1Bytes[10], v1Bytes[11], v1Bytes[12], v1Bytes[13], v1Bytes[14], v1Bytes[15]);
+}
+var init_v1ToV6 = __esm({
+  "../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/v1ToV6.js"() {
+    init_parse();
+    init_stringify();
+  }
+});
+
+// ../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/v35.js
+function stringToBytes(str) {
+  str = unescape(encodeURIComponent(str));
+  const bytes = [];
+  for (let i = 0; i < str.length; ++i) {
+    bytes.push(str.charCodeAt(i));
+  }
+  return bytes;
+}
+function v35(name, version2, hashfunc) {
+  function generateUUID(value, namespace, buf, offset) {
+    var _namespace;
+    if (typeof value === "string") {
+      value = stringToBytes(value);
+    }
+    if (typeof namespace === "string") {
+      namespace = parse_default(namespace);
+    }
+    if (((_namespace = namespace) === null || _namespace === void 0 ? void 0 : _namespace.length) !== 16) {
+      throw TypeError("Namespace must be array-like (16 iterable integer values, 0-255)");
+    }
+    let bytes = new Uint8Array(16 + value.length);
+    bytes.set(namespace);
+    bytes.set(value, namespace.length);
+    bytes = hashfunc(bytes);
+    bytes[6] = bytes[6] & 15 | version2;
+    bytes[8] = bytes[8] & 63 | 128;
+    if (buf) {
+      offset = offset || 0;
+      for (let i = 0; i < 16; ++i) {
+        buf[offset + i] = bytes[i];
+      }
+      return buf;
+    }
+    return unsafeStringify(bytes);
+  }
+  try {
+    generateUUID.name = name;
+  } catch (err) {
+  }
+  generateUUID.DNS = DNS;
+  generateUUID.URL = URL2;
+  return generateUUID;
+}
+var DNS, URL2;
+var init_v35 = __esm({
+  "../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/v35.js"() {
+    init_stringify();
+    init_parse();
+    DNS = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
+    URL2 = "6ba7b811-9dad-11d1-80b4-00c04fd430c8";
+  }
+});
+
+// ../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/md5.js
+function md5(bytes) {
+  if (Array.isArray(bytes)) {
+    bytes = Buffer.from(bytes);
+  } else if (typeof bytes === "string") {
+    bytes = Buffer.from(bytes, "utf8");
+  }
+  return import_node_crypto2.default.createHash("md5").update(bytes).digest();
+}
+var import_node_crypto2, md5_default;
+var init_md5 = __esm({
+  "../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/md5.js"() {
+    import_node_crypto2 = __toESM(require("node:crypto"));
+    md5_default = md5;
+  }
+});
+
+// ../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/v3.js
+var v3, v3_default;
+var init_v3 = __esm({
+  "../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/v3.js"() {
+    init_v35();
+    init_md5();
+    v3 = v35("v3", 48, md5_default);
+    v3_default = v3;
+  }
+});
+
+// ../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/native.js
+var import_node_crypto3, native_default;
+var init_native = __esm({
+  "../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/native.js"() {
+    import_node_crypto3 = __toESM(require("node:crypto"));
+    native_default = {
+      randomUUID: import_node_crypto3.default.randomUUID
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/v4.js
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random || (options.rng || rng)();
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default;
+var init_v4 = __esm({
+  "../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/v4.js"() {
+    init_native();
+    init_rng();
+    init_stringify();
+    v4_default = v4;
+  }
+});
+
+// ../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/sha1.js
+function sha1(bytes) {
+  if (Array.isArray(bytes)) {
+    bytes = Buffer.from(bytes);
+  } else if (typeof bytes === "string") {
+    bytes = Buffer.from(bytes, "utf8");
+  }
+  return import_node_crypto4.default.createHash("sha1").update(bytes).digest();
+}
+var import_node_crypto4, sha1_default;
+var init_sha1 = __esm({
+  "../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/sha1.js"() {
+    import_node_crypto4 = __toESM(require("node:crypto"));
+    sha1_default = sha1;
+  }
+});
+
+// ../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/v5.js
+var v5, v5_default;
+var init_v5 = __esm({
+  "../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/v5.js"() {
+    init_v35();
+    init_sha1();
+    v5 = v35("v5", 80, sha1_default);
+    v5_default = v5;
+  }
+});
+
+// ../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/v6.js
+function v6(options = {}, buf, offset = 0) {
+  let bytes = v1_default({
+    ...options,
+    _v6: true
+  }, new Uint8Array(16));
+  bytes = v1ToV6(bytes);
+  if (buf) {
+    for (let i = 0; i < 16; i++) {
+      buf[offset + i] = bytes[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(bytes);
+}
+var init_v6 = __esm({
+  "../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/v6.js"() {
+    init_stringify();
+    init_v1();
+    init_v1ToV6();
+  }
+});
+
+// ../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/v6ToV1.js
+function v6ToV1(uuid) {
+  const v6Bytes = typeof uuid === "string" ? parse_default(uuid) : uuid;
+  const v1Bytes = _v6ToV1(v6Bytes);
+  return typeof uuid === "string" ? unsafeStringify(v1Bytes) : v1Bytes;
+}
+function _v6ToV1(v6Bytes) {
+  return Uint8Array.of((v6Bytes[3] & 15) << 4 | v6Bytes[4] >> 4 & 15, (v6Bytes[4] & 15) << 4 | (v6Bytes[5] & 240) >> 4, (v6Bytes[5] & 15) << 4 | v6Bytes[6] & 15, v6Bytes[7], (v6Bytes[1] & 15) << 4 | (v6Bytes[2] & 240) >> 4, (v6Bytes[2] & 15) << 4 | (v6Bytes[3] & 240) >> 4, 16 | (v6Bytes[0] & 240) >> 4, (v6Bytes[0] & 15) << 4 | (v6Bytes[1] & 240) >> 4, v6Bytes[8], v6Bytes[9], v6Bytes[10], v6Bytes[11], v6Bytes[12], v6Bytes[13], v6Bytes[14], v6Bytes[15]);
+}
+var init_v6ToV1 = __esm({
+  "../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/v6ToV1.js"() {
+    init_parse();
+    init_stringify();
+  }
+});
+
+// ../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/v7.js
+function v7(options, buf, offset) {
+  options = options || {};
+  let i = buf && offset || 0;
+  const b = buf || new Uint8Array(16);
+  const rnds = options.random || (options.rng || rng)();
+  const msecs = options.msecs !== void 0 ? options.msecs : Date.now();
+  let seq = options.seq !== void 0 ? options.seq : null;
+  let seqHigh = _seqHigh;
+  let seqLow = _seqLow;
+  if (msecs > _msecs && options.msecs === void 0) {
+    _msecs = msecs;
+    if (seq !== null) {
+      seqHigh = null;
+      seqLow = null;
+    }
+  }
+  if (seq !== null) {
+    if (seq > 2147483647) {
+      seq = 2147483647;
+    }
+    seqHigh = seq >>> 19 & 4095;
+    seqLow = seq & 524287;
+  }
+  if (seqHigh === null || seqLow === null) {
+    seqHigh = rnds[6] & 127;
+    seqHigh = seqHigh << 8 | rnds[7];
+    seqLow = rnds[8] & 63;
+    seqLow = seqLow << 8 | rnds[9];
+    seqLow = seqLow << 5 | rnds[10] >>> 3;
+  }
+  if (msecs + 1e4 > _msecs && seq === null) {
+    if (++seqLow > 524287) {
+      seqLow = 0;
+      if (++seqHigh > 4095) {
+        seqHigh = 0;
+        _msecs++;
+      }
+    }
+  } else {
+    _msecs = msecs;
+  }
+  _seqHigh = seqHigh;
+  _seqLow = seqLow;
+  b[i++] = _msecs / 1099511627776 & 255;
+  b[i++] = _msecs / 4294967296 & 255;
+  b[i++] = _msecs / 16777216 & 255;
+  b[i++] = _msecs / 65536 & 255;
+  b[i++] = _msecs / 256 & 255;
+  b[i++] = _msecs & 255;
+  b[i++] = seqHigh >>> 4 & 15 | 112;
+  b[i++] = seqHigh & 255;
+  b[i++] = seqLow >>> 13 & 63 | 128;
+  b[i++] = seqLow >>> 5 & 255;
+  b[i++] = seqLow << 3 & 255 | rnds[10] & 7;
+  b[i++] = rnds[11];
+  b[i++] = rnds[12];
+  b[i++] = rnds[13];
+  b[i++] = rnds[14];
+  b[i++] = rnds[15];
+  return buf || unsafeStringify(b);
+}
+var _seqLow, _seqHigh, _msecs, v7_default;
+var init_v7 = __esm({
+  "../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/v7.js"() {
+    init_rng();
+    init_stringify();
+    _seqLow = null;
+    _seqHigh = null;
+    _msecs = 0;
+    v7_default = v7;
+  }
+});
+
+// ../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/version.js
+function version(uuid) {
+  if (!validate_default(uuid)) {
+    throw TypeError("Invalid UUID");
+  }
+  return parseInt(uuid.slice(14, 15), 16);
+}
+var version_default;
+var init_version = __esm({
+  "../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/version.js"() {
+    init_validate();
+    version_default = version;
+  }
+});
+
+// ../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/index.js
+var esm_node_exports = {};
+__export(esm_node_exports, {
+  MAX: () => max_default,
+  NIL: () => nil_default,
+  parse: () => parse_default,
+  stringify: () => stringify_default,
+  v1: () => v1_default,
+  v1ToV6: () => v1ToV6,
+  v3: () => v3_default,
+  v4: () => v4_default,
+  v5: () => v5_default,
+  v6: () => v6,
+  v6ToV1: () => v6ToV1,
+  v7: () => v7_default,
+  validate: () => validate_default,
+  version: () => version_default
+});
+var init_esm_node = __esm({
+  "../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-node/index.js"() {
+    init_max();
+    init_nil();
+    init_parse();
+    init_stringify();
+    init_v1();
+    init_v1ToV6();
+    init_v3();
+    init_v4();
+    init_v5();
+    init_v6();
+    init_v6ToV1();
+    init_v7();
+    init_validate();
+    init_version();
+  }
+});
+
+// ../claude-code-web/src/claude-bridge.js
+var require_claude_bridge = __commonJS({
+  "../claude-code-web/src/claude-bridge.js"(exports2, module2) {
+    "use strict";
+    var { spawn } = require("node-pty");
+    var path = require("path");
+    var fs = require("fs");
+    var ClaudeBridge = class {
+      constructor() {
+        this.sessions = /* @__PURE__ */ new Map();
+        this.claudeCommand = this.findClaudeCommand();
+      }
+      findClaudeCommand() {
+        const possibleCommands = [
+          "/home/ec2-user/.claude/local/claude",
+          "claude",
+          "claude-code",
+          path.join(process.env.HOME || "/", ".claude", "local", "claude"),
+          path.join(process.env.HOME || "/", ".local", "bin", "claude"),
+          "/usr/local/bin/claude",
+          "/usr/bin/claude"
+        ];
+        for (const cmd of possibleCommands) {
+          try {
+            if (fs.existsSync(cmd) || this.commandExists(cmd)) {
+              console.log(`Found Claude command at: ${cmd}`);
+              return cmd;
+            }
+          } catch (error) {
+            continue;
+          }
+        }
+        console.error('Claude command not found, using default "claude"');
+        return "claude";
+      }
+      commandExists(command) {
+        try {
+          require("child_process").execFileSync("which", [command], { stdio: "ignore" });
+          return true;
+        } catch (error) {
+          return false;
+        }
+      }
+      async startSession(sessionId, options = {}) {
+        if (this.sessions.has(sessionId)) {
+          throw new Error(`Session ${sessionId} already exists`);
+        }
+        const {
+          workingDir = process.cwd(),
+          dangerouslySkipPermissions = false,
+          permissionMode,
+          allowedTools,
+          disallowedTools,
+          appendSystemPrompt,
+          initialPrompt,
+          mcpConfig,
+          strictMcpConfig = false,
+          onOutput = () => {
+          },
+          onExit = () => {
+          },
+          onError = () => {
+          },
+          cols = 80,
+          rows = 24,
+          // When true, spawn `claude --resume <sessionId>` instead of starting a
+          // fresh session. The conversation history is read from the existing
+          // ~/.claude/projects/<flat-cwd>/<sessionId>.jsonl file. Mutually
+          // exclusive with the implicit --session-id flag added for fresh
+          // sessions (passing both would cause a CLI argument conflict).
+          resume = false
+        } = options;
+        try {
+          console.log(`Starting Claude session ${sessionId}`);
+          console.log(`Command: ${this.claudeCommand}`);
+          console.log(`Working directory: ${workingDir}`);
+          console.log(`Terminal size: ${cols}x${rows}`);
+          if (dangerouslySkipPermissions) {
+            console.log(`\u26A0\uFE0F WARNING: Skipping permissions with --dangerously-skip-permissions flag`);
+          }
+          if (appendSystemPrompt) {
+            console.log(`System prompt injected (${appendSystemPrompt.length} chars)`);
+          }
+          const args = [];
+          if (resume) {
+            args.push("--resume", sessionId);
+          } else {
+            args.push("--session-id", sessionId);
+          }
+          if (dangerouslySkipPermissions) args.push("--dangerously-skip-permissions");
+          if (permissionMode) args.push("--permission-mode", permissionMode);
+          if (Array.isArray(allowedTools) && allowedTools.length > 0) {
+            args.push("--allowedTools", allowedTools.join(","));
+          }
+          if (Array.isArray(disallowedTools) && disallowedTools.length > 0) {
+            args.push("--disallowedTools", disallowedTools.join(","));
+          }
+          if (mcpConfig) args.push("--mcp-config", mcpConfig);
+          if (strictMcpConfig) args.push("--strict-mcp-config");
+          if (appendSystemPrompt) args.push("--append-system-prompt", appendSystemPrompt);
+          if (initialPrompt) args.push(initialPrompt);
+          const claudeProcess = spawn(this.claudeCommand, args, {
+            cwd: workingDir,
+            env: {
+              ...process.env,
+              TERM: "xterm-256color",
+              FORCE_COLOR: "1",
+              COLORTERM: "truecolor"
+            },
+            cols,
+            rows,
+            name: "xterm-color"
+          });
+          const session = {
+            process: claudeProcess,
+            workingDir,
+            created: /* @__PURE__ */ new Date(),
+            active: true,
+            killTimeout: null
+          };
+          this.sessions.set(sessionId, session);
+          let trustPromptHandled = false;
+          let autoStartSent = !!initialPrompt;
+          let dataBuffer = "";
+          claudeProcess.onData((data) => {
+            if (process.env.DEBUG) {
+              console.log(`Session ${sessionId} output:`, data);
+            }
+            dataBuffer += data;
+            if (!trustPromptHandled && dataBuffer.includes("Do you trust the files in this folder?")) {
+              trustPromptHandled = true;
+              console.log(`Auto-accepting trust prompt for session ${sessionId}`);
+              setTimeout(() => {
+                claudeProcess.write("\r");
+                console.log(`Sent Enter to accept trust prompt for session ${sessionId}`);
+              }, 500);
+            }
+            if (!autoStartSent && appendSystemPrompt && dataBuffer.includes("\u276F")) {
+              autoStartSent = true;
+              console.log(`Auto-starting agent in session ${sessionId}`);
+              setTimeout(() => {
+                claudeProcess.write("Begin.\r");
+              }, 500);
+            }
+            if (dataBuffer.length > 1e4) {
+              dataBuffer = dataBuffer.slice(-5e3);
+            }
+            onOutput(data);
+          });
+          claudeProcess.onExit((exitCode, signal) => {
+            console.log(`Claude session ${sessionId} exited with code ${exitCode}, signal ${signal}`);
+            if (session.killTimeout) {
+              clearTimeout(session.killTimeout);
+              session.killTimeout = null;
+            }
+            session.active = false;
+            this.sessions.delete(sessionId);
+            onExit(exitCode, signal);
+          });
+          claudeProcess.on("error", (error) => {
+            console.error(`Claude session ${sessionId} error:`, error);
+            if (session.killTimeout) {
+              clearTimeout(session.killTimeout);
+              session.killTimeout = null;
+            }
+            session.active = false;
+            this.sessions.delete(sessionId);
+            onError(error);
+          });
+          console.log(`Claude session ${sessionId} started successfully`);
+          return session;
+        } catch (error) {
+          console.error(`Failed to start Claude session ${sessionId}:`, error);
+          throw new Error(`Failed to start Claude Code: ${error.message}`);
+        }
+      }
+      async sendInput(sessionId, data) {
+        const session = this.sessions.get(sessionId);
+        if (!session || !session.active) {
+          throw new Error(`Session ${sessionId} not found or not active`);
+        }
+        try {
+          session.process.write(data);
+        } catch (error) {
+          throw new Error(`Failed to send input to session ${sessionId}: ${error.message}`);
+        }
+      }
+      async resize(sessionId, cols, rows) {
+        const session = this.sessions.get(sessionId);
+        if (!session || !session.active) {
+          throw new Error(`Session ${sessionId} not found or not active`);
+        }
+        try {
+          session.process.resize(cols, rows);
+        } catch (error) {
+          console.warn(`Failed to resize session ${sessionId}:`, error.message);
+        }
+      }
+      async stopSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+          return;
+        }
+        try {
+          if (session.killTimeout) {
+            clearTimeout(session.killTimeout);
+            session.killTimeout = null;
+          }
+          if (session.active && session.process) {
+            session.process.kill("SIGTERM");
+            session.killTimeout = setTimeout(() => {
+              if (session.active && session.process) {
+                session.process.kill("SIGKILL");
+              }
+            }, 5e3);
+          }
+        } catch (error) {
+          console.warn(`Error stopping session ${sessionId}:`, error.message);
+        }
+        session.active = false;
+        this.sessions.delete(sessionId);
+      }
+      getSession(sessionId) {
+        return this.sessions.get(sessionId);
+      }
+      getAllSessions() {
+        return Array.from(this.sessions.entries()).map(([id, session]) => ({
+          id,
+          workingDir: session.workingDir,
+          created: session.created,
+          active: session.active
+        }));
+      }
+      async cleanup() {
+        const sessionIds = Array.from(this.sessions.keys());
+        for (const sessionId of sessionIds) {
+          await this.stopSession(sessionId);
+        }
+      }
+    };
+    module2.exports = ClaudeBridge;
+  }
+});
+
+// ../claude-code-web/src/codex-bridge.js
+var require_codex_bridge = __commonJS({
+  "../claude-code-web/src/codex-bridge.js"(exports2, module2) {
+    "use strict";
+    var { spawn } = require("node-pty");
+    var path = require("path");
+    var fs = require("fs");
+    var CodexBridge = class {
+      constructor() {
+        this.sessions = /* @__PURE__ */ new Map();
+        this.codexCommand = this.findCodexCommand();
+      }
+      findCodexCommand() {
+        const possibleCommands = [
+          path.join(process.env.HOME || "/", ".codex", "local", "codex"),
+          "codex",
+          "codex-code",
+          path.join(process.env.HOME || "/", ".local", "bin", "codex"),
+          "/usr/local/bin/codex",
+          "/usr/bin/codex"
+        ];
+        for (const cmd of possibleCommands) {
+          try {
+            if (fs.existsSync(cmd) || this.commandExists(cmd)) {
+              console.log(`Found Codex command at: ${cmd}`);
+              return cmd;
+            }
+          } catch (error) {
+            continue;
+          }
+        }
+        console.error('Codex command not found, using default "codex"');
+        return "codex";
+      }
+      commandExists(command) {
+        try {
+          require("child_process").execFileSync("which", [command], { stdio: "ignore" });
+          return true;
+        } catch (error) {
+          return false;
+        }
+      }
+      async startSession(sessionId, options = {}) {
+        if (this.sessions.has(sessionId)) {
+          throw new Error(`Session ${sessionId} already exists`);
+        }
+        const {
+          workingDir = process.cwd(),
+          dangerouslySkipPermissions = false,
+          onOutput = () => {
+          },
+          onExit = () => {
+          },
+          onError = () => {
+          },
+          cols = 80,
+          rows = 24
+        } = options;
+        try {
+          console.log(`Starting Codex session ${sessionId}`);
+          console.log(`Command: ${this.codexCommand}`);
+          console.log(`Working directory: ${workingDir}`);
+          console.log(`Terminal size: ${cols}x${rows}`);
+          if (dangerouslySkipPermissions) {
+            console.log(`\u26A0\uFE0F WARNING: Bypassing approvals and sandbox with --dangerously-bypass-approvals-and-sandbox flag`);
+          }
+          const args = dangerouslySkipPermissions ? ["--dangerously-bypass-approvals-and-sandbox"] : [];
+          const codexProcess = spawn(this.codexCommand, args, {
+            cwd: workingDir,
+            env: {
+              ...process.env,
+              TERM: "xterm-256color",
+              FORCE_COLOR: "1",
+              COLORTERM: "truecolor"
+            },
+            cols,
+            rows,
+            name: "xterm-color"
+          });
+          const session = {
+            process: codexProcess,
+            workingDir,
+            created: /* @__PURE__ */ new Date(),
+            active: true,
+            killTimeout: null
+          };
+          this.sessions.set(sessionId, session);
+          let dataBuffer = "";
+          codexProcess.onData((data) => {
+            if (process.env.DEBUG) {
+              console.log(`Codex session ${sessionId} output:`, data);
+            }
+            dataBuffer += data;
+            if (dataBuffer.length > 1e4) {
+              dataBuffer = dataBuffer.slice(-5e3);
+            }
+            onOutput(data);
+          });
+          codexProcess.onExit((exitCode, signal) => {
+            console.log(`Codex session ${sessionId} exited with code ${exitCode}, signal ${signal}`);
+            if (session.killTimeout) {
+              clearTimeout(session.killTimeout);
+              session.killTimeout = null;
+            }
+            session.active = false;
+            this.sessions.delete(sessionId);
+            onExit(exitCode, signal);
+          });
+          codexProcess.on("error", (error) => {
+            console.error(`Codex session ${sessionId} error:`, error);
+            if (session.killTimeout) {
+              clearTimeout(session.killTimeout);
+              session.killTimeout = null;
+            }
+            session.active = false;
+            this.sessions.delete(sessionId);
+            onError(error);
+          });
+          console.log(`Codex session ${sessionId} started successfully`);
+          return session;
+        } catch (error) {
+          console.error(`Failed to start Codex session ${sessionId}:`, error);
+          throw new Error(`Failed to start Codex Code: ${error.message}`);
+        }
+      }
+      async sendInput(sessionId, data) {
+        const session = this.sessions.get(sessionId);
+        if (!session || !session.active) {
+          throw new Error(`Session ${sessionId} not found or not active`);
+        }
+        try {
+          session.process.write(data);
+        } catch (error) {
+          throw new Error(`Failed to send input to session ${sessionId}: ${error.message}`);
+        }
+      }
+      async resize(sessionId, cols, rows) {
+        const session = this.sessions.get(sessionId);
+        if (!session || !session.active) {
+          throw new Error(`Session ${sessionId} not found or not active`);
+        }
+        try {
+          session.process.resize(cols, rows);
+        } catch (error) {
+          console.warn(`Failed to resize session ${sessionId}:`, error.message);
+        }
+      }
+      async stopSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+          return;
+        }
+        try {
+          if (session.killTimeout) {
+            clearTimeout(session.killTimeout);
+            session.killTimeout = null;
+          }
+          if (session.active && session.process) {
+            session.process.kill("SIGTERM");
+            session.killTimeout = setTimeout(() => {
+              if (session.active && session.process) {
+                session.process.kill("SIGKILL");
+              }
+            }, 5e3);
+          }
+        } catch (error) {
+          console.warn(`Error stopping codex session ${sessionId}:`, error.message);
+        }
+        session.active = false;
+        this.sessions.delete(sessionId);
+      }
+      getSession(sessionId) {
+        return this.sessions.get(sessionId);
+      }
+      getAllSessions() {
+        return Array.from(this.sessions.entries()).map(([id, session]) => ({
+          id,
+          workingDir: session.workingDir,
+          created: session.created,
+          active: session.active
+        }));
+      }
+      async cleanup() {
+        const sessionIds = Array.from(this.sessions.keys());
+        for (const sessionId of sessionIds) {
+          await this.stopSession(sessionId);
+        }
+      }
+    };
+    module2.exports = CodexBridge;
+  }
+});
+
+// ../claude-code-web/src/agent-bridge.js
+var require_agent_bridge = __commonJS({
+  "../claude-code-web/src/agent-bridge.js"(exports2, module2) {
+    "use strict";
+    var { spawn } = require("node-pty");
+    var path = require("path");
+    var fs = require("fs");
+    var AgentBridge = class {
+      constructor() {
+        this.sessions = /* @__PURE__ */ new Map();
+        this.agentCommand = this.findAgentCommand();
+      }
+      findAgentCommand() {
+        const possibleCommands = [
+          path.join(process.env.HOME || "/", ".cursor", "local", "cursor-agent"),
+          "cursor-agent",
+          path.join(process.env.HOME || "/", ".local", "bin", "cursor-agent"),
+          "/usr/local/bin/cursor-agent",
+          "/usr/bin/cursor-agent"
+        ];
+        for (const cmd of possibleCommands) {
+          try {
+            if (fs.existsSync(cmd) || this.commandExists(cmd)) {
+              console.log(`Found Agent command at: ${cmd}`);
+              return cmd;
+            }
+          } catch (error) {
+            continue;
+          }
+        }
+        console.error('Agent command not found, using default "cursor-agent"');
+        return "cursor-agent";
+      }
+      commandExists(command) {
+        try {
+          require("child_process").execFileSync("which", [command], { stdio: "ignore" });
+          return true;
+        } catch (error) {
+          return false;
+        }
+      }
+      async startSession(sessionId, options = {}) {
+        if (this.sessions.has(sessionId)) {
+          throw new Error(`Session ${sessionId} already exists`);
+        }
+        const {
+          workingDir = process.cwd(),
+          onOutput = () => {
+          },
+          onExit = () => {
+          },
+          onError = () => {
+          },
+          cols = 80,
+          rows = 24
+        } = options;
+        try {
+          console.log(`Starting Agent session ${sessionId}`);
+          console.log(`Command: ${this.agentCommand}`);
+          console.log(`Working directory: ${workingDir}`);
+          console.log(`Terminal size: ${cols}x${rows}`);
+          const agentProcess = spawn(this.agentCommand, [], {
+            cwd: workingDir,
+            env: {
+              ...process.env,
+              TERM: "xterm-256color",
+              FORCE_COLOR: "1",
+              COLORTERM: "truecolor"
+            },
+            cols,
+            rows,
+            name: "xterm-color"
+          });
+          const session = {
+            process: agentProcess,
+            workingDir,
+            created: /* @__PURE__ */ new Date(),
+            active: true,
+            killTimeout: null
+          };
+          this.sessions.set(sessionId, session);
+          let dataBuffer = "";
+          agentProcess.onData((data) => {
+            if (process.env.DEBUG) {
+              console.log(`Agent session ${sessionId} output:`, data);
+            }
+            dataBuffer += data;
+            if (dataBuffer.length > 1e4) {
+              dataBuffer = dataBuffer.slice(-5e3);
+            }
+            onOutput(data);
+          });
+          agentProcess.onExit((exitCode, signal) => {
+            console.log(`Agent session ${sessionId} exited with code ${exitCode}, signal ${signal}`);
+            if (session.killTimeout) {
+              clearTimeout(session.killTimeout);
+              session.killTimeout = null;
+            }
+            session.active = false;
+            this.sessions.delete(sessionId);
+            onExit(exitCode, signal);
+          });
+          agentProcess.on("error", (error) => {
+            console.error(`Agent session ${sessionId} error:`, error);
+            if (session.killTimeout) {
+              clearTimeout(session.killTimeout);
+              session.killTimeout = null;
+            }
+            session.active = false;
+            this.sessions.delete(sessionId);
+            onError(error);
+          });
+          console.log(`Agent session ${sessionId} started successfully`);
+          return session;
+        } catch (error) {
+          console.error(`Failed to start Agent session ${sessionId}:`, error);
+          throw new Error(`Failed to start Agent: ${error.message}`);
+        }
+      }
+      async sendInput(sessionId, data) {
+        const session = this.sessions.get(sessionId);
+        if (!session || !session.active) {
+          throw new Error(`Session ${sessionId} not found or not active`);
+        }
+        try {
+          session.process.write(data);
+        } catch (error) {
+          throw new Error(`Failed to send input to session ${sessionId}: ${error.message}`);
+        }
+      }
+      async resize(sessionId, cols, rows) {
+        const session = this.sessions.get(sessionId);
+        if (!session || !session.active) {
+          throw new Error(`Session ${sessionId} not found or not active`);
+        }
+        try {
+          session.process.resize(cols, rows);
+        } catch (error) {
+          console.warn(`Failed to resize session ${sessionId}:`, error.message);
+        }
+      }
+      async stopSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+          return;
+        }
+        try {
+          if (session.killTimeout) {
+            clearTimeout(session.killTimeout);
+            session.killTimeout = null;
+          }
+          if (session.active && session.process) {
+            session.process.kill("SIGTERM");
+            session.killTimeout = setTimeout(() => {
+              if (session.active && session.process) {
+                session.process.kill("SIGKILL");
+              }
+            }, 5e3);
+          }
+        } catch (error) {
+          console.warn(`Error stopping agent session ${sessionId}:`, error.message);
+        }
+        session.active = false;
+        this.sessions.delete(sessionId);
+      }
+      getSession(sessionId) {
+        return this.sessions.get(sessionId);
+      }
+      getAllSessions() {
+        return Array.from(this.sessions.entries()).map(([id, session]) => ({
+          id,
+          workingDir: session.workingDir,
+          created: session.created,
+          active: session.active
+        }));
+      }
+      async cleanup() {
+        const sessionIds = Array.from(this.sessions.keys());
+        for (const sessionId of sessionIds) {
+          await this.stopSession(sessionId);
+        }
+      }
+    };
+    module2.exports = AgentBridge;
+  }
+});
+
+// ../claude-code-web/src/script-bridge.js
+var require_script_bridge = __commonJS({
+  "../claude-code-web/src/script-bridge.js"(exports2, module2) {
+    "use strict";
+    var { spawn } = require("node-pty");
+    var ScriptBridge = class {
+      constructor() {
+        this.sessions = /* @__PURE__ */ new Map();
+      }
+      async startSession(sessionId, options = {}) {
+        if (this.sessions.has(sessionId)) {
+          throw new Error(`Script session ${sessionId} already exists`);
+        }
+        const {
+          command,
+          args = [],
+          workingDir = process.cwd(),
+          env = {},
+          onOutput = () => {
+          },
+          onExit = () => {
+          },
+          onError = () => {
+          },
+          cols = 80,
+          rows = 24
+        } = options;
+        if (!command) {
+          throw new Error("ScriptBridge.startSession requires a command");
+        }
+        try {
+          console.log(`Starting script session ${sessionId}: ${command} ${args.join(" ")}`);
+          console.log(`Working directory: ${workingDir}`);
+          const proc = spawn(command, args, {
+            cwd: workingDir,
+            env: {
+              ...process.env,
+              ...env,
+              TERM: "xterm-256color",
+              FORCE_COLOR: "1",
+              COLORTERM: "truecolor"
+            },
+            cols,
+            rows,
+            name: "xterm-color"
+          });
+          const session = {
+            process: proc,
+            command,
+            workingDir,
+            created: /* @__PURE__ */ new Date(),
+            active: true,
+            killTimeout: null
+          };
+          this.sessions.set(sessionId, session);
+          proc.onData((data) => {
+            if (process.env.DEBUG) {
+              console.log(`Script session ${sessionId} output:`, data);
+            }
+            onOutput(data);
+          });
+          proc.onExit((exitCode, signal) => {
+            console.log(`Script session ${sessionId} exited with code ${exitCode}, signal ${signal}`);
+            if (session.killTimeout) {
+              clearTimeout(session.killTimeout);
+              session.killTimeout = null;
+            }
+            session.active = false;
+            this.sessions.delete(sessionId);
+            onExit(exitCode, signal);
+          });
+          proc.on("error", (error) => {
+            console.error(`Script session ${sessionId} error:`, error);
+            if (session.killTimeout) {
+              clearTimeout(session.killTimeout);
+              session.killTimeout = null;
+            }
+            session.active = false;
+            this.sessions.delete(sessionId);
+            onError(error);
+          });
+          console.log(`Script session ${sessionId} started successfully`);
+          return session;
+        } catch (error) {
+          console.error(`Failed to start script session ${sessionId}:`, error);
+          throw new Error(`Failed to start script: ${error.message}`);
+        }
+      }
+      async sendInput(sessionId, data) {
+        const session = this.sessions.get(sessionId);
+        if (!session || !session.active) {
+          throw new Error(`Script session ${sessionId} not found or not active`);
+        }
+        try {
+          session.process.write(data);
+        } catch (error) {
+          throw new Error(`Failed to send input to script session ${sessionId}: ${error.message}`);
+        }
+      }
+      async resize(sessionId, cols, rows) {
+        const session = this.sessions.get(sessionId);
+        if (!session || !session.active) {
+          throw new Error(`Script session ${sessionId} not found or not active`);
+        }
+        try {
+          session.process.resize(cols, rows);
+        } catch (error) {
+          console.warn(`Failed to resize script session ${sessionId}:`, error.message);
+        }
+      }
+      async stopSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) return;
+        try {
+          if (session.killTimeout) {
+            clearTimeout(session.killTimeout);
+            session.killTimeout = null;
+          }
+          if (session.active && session.process) {
+            session.process.kill("SIGTERM");
+            session.killTimeout = setTimeout(() => {
+              if (session.active && session.process) {
+                session.process.kill("SIGKILL");
+              }
+            }, 5e3);
+          }
+        } catch (error) {
+          console.warn(`Error stopping script session ${sessionId}:`, error.message);
+        }
+        session.active = false;
+        this.sessions.delete(sessionId);
+      }
+      getSession(sessionId) {
+        return this.sessions.get(sessionId);
+      }
+      getAllSessions() {
+        return Array.from(this.sessions.entries()).map(([id, session]) => ({
+          id,
+          command: session.command,
+          workingDir: session.workingDir,
+          created: session.created,
+          active: session.active
+        }));
+      }
+      async cleanup() {
+        const sessionIds = Array.from(this.sessions.keys());
+        for (const sessionId of sessionIds) {
+          await this.stopSession(sessionId);
+        }
+      }
+    };
+    module2.exports = ScriptBridge;
+  }
+});
+
+// ../claude-code-web/src/utils/session-store.js
+var require_session_store = __commonJS({
+  "../claude-code-web/src/utils/session-store.js"(exports2, module2) {
+    "use strict";
+    var fs = require("fs").promises;
+    var path = require("path");
+    var os = require("os");
+    var SessionStore = class {
+      constructor(options = {}) {
+        this.storageDir = options.storageDir || path.join(os.homedir(), ".claude-code-web");
+        this.sessionsFile = path.join(this.storageDir, "sessions.json");
+        this.initializeStorage();
+      }
+      async initializeStorage() {
+        try {
+          await fs.mkdir(this.storageDir, { recursive: true });
+        } catch (error) {
+          console.error("Failed to create storage directory:", error);
+        }
+      }
+      async saveSessions(sessions) {
+        try {
+          await fs.mkdir(this.storageDir, { recursive: true });
+          const sessionsArray = Array.from(sessions.entries()).map(([id, session]) => ({
+            id,
+            name: session.name || "Unnamed Session",
+            created: session.created || /* @__PURE__ */ new Date(),
+            lastActivity: session.lastActivity || /* @__PURE__ */ new Date(),
+            workingDir: session.workingDir || process.cwd(),
+            active: false,
+            // Always set to false when saving (processes won't persist)
+            outputBuffer: Array.isArray(session.outputBuffer) ? session.outputBuffer.slice(-100) : [],
+            // Keep last 100 lines
+            connections: [],
+            // Clear connections (they won't persist)
+            lastAccessed: session.lastAccessed || Date.now(),
+            // Session-specific usage tracking
+            sessionStartTime: session.sessionStartTime || null,
+            sessionUsage: session.sessionUsage || {
+              requests: 0,
+              inputTokens: 0,
+              outputTokens: 0,
+              cacheTokens: 0,
+              totalCost: 0,
+              models: {}
+            }
+          }));
+          const data = {
+            version: "1.0",
+            savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            sessions: sessionsArray
+          };
+          const tempFile = `${this.sessionsFile}.tmp`;
+          await fs.writeFile(tempFile, JSON.stringify(data, null, 2));
+          await fs.mkdir(this.storageDir, { recursive: true });
+          await fs.rename(tempFile, this.sessionsFile);
+          return true;
+        } catch (error) {
+          console.error("Failed to save sessions:", error.message);
+          return false;
+        }
+      }
+      async loadSessions() {
+        try {
+          await fs.access(this.sessionsFile);
+          const data = await fs.readFile(this.sessionsFile, "utf8");
+          if (!data || !data.trim()) {
+            console.log("Sessions file is empty, starting fresh");
+            return /* @__PURE__ */ new Map();
+          }
+          let parsed;
+          try {
+            parsed = JSON.parse(data);
+          } catch (parseError) {
+            console.error("Sessions file is corrupted, starting fresh:", parseError.message);
+            try {
+              await fs.rename(this.sessionsFile, `${this.sessionsFile}.corrupted.${Date.now()}`);
+            } catch (renameError) {
+            }
+            return /* @__PURE__ */ new Map();
+          }
+          if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.sessions)) {
+            console.log("Invalid sessions file format, starting fresh");
+            return /* @__PURE__ */ new Map();
+          }
+          if (parsed.savedAt) {
+            const savedAt = new Date(parsed.savedAt);
+            const now = /* @__PURE__ */ new Date();
+            const daysSinceSave = (now - savedAt) / (1e3 * 60 * 60 * 24);
+            if (daysSinceSave > 7) {
+              console.log("Sessions are too old, starting fresh");
+              return /* @__PURE__ */ new Map();
+            }
+          }
+          const sessions = /* @__PURE__ */ new Map();
+          for (const session of parsed.sessions) {
+            if (!session || !session.id) continue;
+            sessions.set(session.id, {
+              ...session,
+              created: session.created ? new Date(session.created) : /* @__PURE__ */ new Date(),
+              lastActivity: session.lastActivity ? new Date(session.lastActivity) : /* @__PURE__ */ new Date(),
+              active: false,
+              connections: /* @__PURE__ */ new Set(),
+              outputBuffer: session.outputBuffer || [],
+              maxBufferSize: 1e3,
+              // Restore usage data if available
+              usageData: session.usageData || null
+            });
+          }
+          console.log(`Restored ${sessions.size} sessions from disk`);
+          return sessions;
+        } catch (error) {
+          if (error.code !== "ENOENT") {
+            console.error("Failed to load sessions:", error.message);
+          }
+          return /* @__PURE__ */ new Map();
+        }
+      }
+      async clearOldSessions() {
+        try {
+          await fs.unlink(this.sessionsFile);
+          console.log("Cleared old sessions");
+          return true;
+        } catch (error) {
+          if (error.code !== "ENOENT") {
+            console.error("Failed to clear sessions:", error);
+          }
+          return false;
+        }
+      }
+      async getSessionMetadata() {
+        try {
+          await fs.access(this.sessionsFile);
+          const stats = await fs.stat(this.sessionsFile);
+          const data = await fs.readFile(this.sessionsFile, "utf8");
+          const parsed = JSON.parse(data);
+          return {
+            exists: true,
+            savedAt: parsed.savedAt,
+            sessionCount: parsed.sessions ? parsed.sessions.length : 0,
+            fileSize: stats.size,
+            version: parsed.version
+          };
+        } catch (error) {
+          return {
+            exists: false,
+            error: error.message
+          };
+        }
+      }
+    };
+    module2.exports = SessionStore;
+  }
+});
+
+// ../claude-code-web/src/usage-reader.js
+var require_usage_reader = __commonJS({
+  "../claude-code-web/src/usage-reader.js"(exports2, module2) {
+    "use strict";
+    var fs = require("fs").promises;
+    var path = require("path");
+    var readline = require("readline");
+    var { createReadStream } = require("fs");
+    var UsageReader = class {
+      constructor(sessionDurationHours = 5) {
+        this.claudeProjectsPath = path.join(process.env.HOME, ".claude", "projects");
+        this.cache = null;
+        this.cacheTime = null;
+        this.cacheTimeout = 5e3;
+        this.sessionDurationHours = sessionDurationHours;
+        this.overlappingSessions = [];
+      }
+      /**
+       * Normalize model names for consistent categorization
+       */
+      normalizeModelName(model) {
+        if (!model || typeof model !== "string") {
+          return "unknown";
+        }
+        const modelLower = model.toLowerCase();
+        if (modelLower.includes("opus")) {
+          return "opus";
+        } else if (modelLower.includes("sonnet")) {
+          return "sonnet";
+        } else if (modelLower.includes("haiku")) {
+          return "haiku";
+        }
+        return "unknown";
+      }
+      /**
+       * Create unique hash for deduplication based on message_id and request_id
+       */
+      createUniqueHash(entry) {
+        const messageId = entry.message_id || entry.messageId || entry.message && entry.message.id || null;
+        const requestId = entry.request_id || entry.requestId || null;
+        if (messageId && requestId) {
+          return `${messageId}:${requestId}`;
+        }
+        return null;
+      }
+      async getUsageStats(hoursBack = 24) {
+        if (this.cache && this.cacheTime && Date.now() - this.cacheTime < this.cacheTimeout) {
+          return this.cache;
+        }
+        try {
+          const cutoffTime = new Date(Date.now() - hoursBack * 60 * 60 * 1e3);
+          const entries = await this.readAllEntries(cutoffTime);
+          const stats = this.calculateStats(entries, hoursBack);
+          this.cache = stats;
+          this.cacheTime = Date.now();
+          return stats;
+        } catch (error) {
+          console.error("Error reading usage stats:", error);
+          return null;
+        }
+      }
+      async getCurrentSessionStats() {
+        try {
+          const currentSession = await this.getCurrentSession();
+          if (!currentSession) {
+            return null;
+          }
+          const startOfDay = this.getStartOfCurrentDay();
+          const allTodayEntries = await this.readAllEntries(startOfDay);
+          if (allTodayEntries.length === 0) {
+            return null;
+          }
+          const sessionEntries = allTodayEntries.filter((entry) => {
+            const entryTime = new Date(entry.timestamp);
+            return entryTime >= currentSession.startTime && entryTime <= currentSession.endTime;
+          });
+          sessionEntries.sort((a, b) => new Date(a.timestamp) - new Date(b.timestamp));
+          const stats = {
+            requests: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheCreationTokens: 0,
+            cacheReadTokens: 0,
+            cacheTokens: 0,
+            totalTokens: 0,
+            totalCost: 0,
+            models: {},
+            sessionStartTime: currentSession.startTime.toISOString(),
+            lastUpdate: null,
+            sessionId: currentSession.sessionId,
+            sessionNumber: currentSession.sessionNumber,
+            // Add session number
+            isExpired: /* @__PURE__ */ new Date() > currentSession.endTime,
+            remainingTokens: null
+          };
+          for (const entry of sessionEntries) {
+            stats.requests++;
+            stats.inputTokens += entry.inputTokens;
+            stats.outputTokens += entry.outputTokens;
+            stats.cacheCreationTokens += entry.cacheCreationTokens;
+            stats.cacheReadTokens += entry.cacheReadTokens;
+            stats.totalCost += entry.totalCost;
+            stats.lastUpdate = entry.timestamp;
+            const model = entry.model || "unknown";
+            if (!stats.models[model]) {
+              stats.models[model] = {
+                requests: 0,
+                inputTokens: 0,
+                outputTokens: 0,
+                cost: 0
+              };
+            }
+            stats.models[model].requests++;
+            stats.models[model].inputTokens += entry.inputTokens;
+            stats.models[model].outputTokens += entry.outputTokens;
+            stats.models[model].cost += entry.totalCost;
+          }
+          stats.cacheTokens = stats.cacheCreationTokens + stats.cacheReadTokens;
+          stats.totalTokens = stats.inputTokens + stats.outputTokens;
+          return stats;
+        } catch (error) {
+          console.error("Error reading current session stats:", error);
+          return null;
+        }
+      }
+      async getAllTimeUsageStats() {
+        try {
+          const entries = await this.readAllEntries(/* @__PURE__ */ new Date(0));
+          const stats = {
+            requests: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheCreationTokens: 0,
+            cacheReadTokens: 0,
+            cacheTokens: 0,
+            totalTokens: 0,
+            totalCost: 0,
+            models: {},
+            firstRequest: null,
+            lastRequest: null
+          };
+          for (const entry of entries) {
+            stats.requests++;
+            stats.inputTokens += entry.inputTokens;
+            stats.outputTokens += entry.outputTokens;
+            stats.cacheCreationTokens += entry.cacheCreationTokens;
+            stats.cacheReadTokens += entry.cacheReadTokens;
+            stats.totalCost += entry.totalCost;
+            if (!stats.firstRequest || new Date(entry.timestamp) < new Date(stats.firstRequest)) {
+              stats.firstRequest = entry.timestamp;
+            }
+            if (!stats.lastRequest || new Date(entry.timestamp) > new Date(stats.lastRequest)) {
+              stats.lastRequest = entry.timestamp;
+            }
+            const model = entry.model || "unknown";
+            if (!stats.models[model]) {
+              stats.models[model] = {
+                requests: 0,
+                inputTokens: 0,
+                outputTokens: 0,
+                cost: 0
+              };
+            }
+            stats.models[model].requests++;
+            stats.models[model].inputTokens += entry.inputTokens;
+            stats.models[model].outputTokens += entry.outputTokens;
+            stats.models[model].cost += entry.totalCost;
+          }
+          stats.cacheTokens = stats.cacheCreationTokens + stats.cacheReadTokens;
+          stats.totalTokens = stats.inputTokens + stats.outputTokens;
+          return stats;
+        } catch (error) {
+          console.error("Error reading all-time usage stats:", error);
+          return null;
+        }
+      }
+      async readAllEntries(cutoffTime) {
+        const entries = [];
+        try {
+          const files = await this.findJsonlFiles();
+          for (const file of files) {
+            const fileEntries = await this.readJsonlFile(file, cutoffTime);
+            entries.push(...fileEntries);
+          }
+          entries.sort((a, b) => new Date(a.timestamp) - new Date(b.timestamp));
+          return entries;
+        } catch (error) {
+          console.error("Error reading entries:", error);
+          return [];
+        }
+      }
+      async readRecentEntries(cutoffTime) {
+        const entries = [];
+        try {
+          const files = await this.findJsonlFiles(true);
+          for (const file of files) {
+            const fileEntries = await this.readJsonlFile(file, cutoffTime);
+            entries.push(...fileEntries);
+          }
+          entries.sort((a, b) => new Date(a.timestamp) - new Date(b.timestamp));
+          return entries;
+        } catch (error) {
+          console.error("Error reading recent entries:", error);
+          return [];
+        }
+      }
+      async getMostRecentSessionFile() {
+        try {
+          const cwd = process.cwd();
+          const projectDirName = cwd.replace(/\//g, "-");
+          let projectPath = path.join(this.claudeProjectsPath, projectDirName);
+          try {
+            await fs.access(projectPath);
+          } catch (err) {
+            console.log(`Project directory not found: ${projectPath}`);
+            return null;
+          }
+          const files = await fs.readdir(projectPath);
+          const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
+          if (jsonlFiles.length === 0) {
+            return null;
+          }
+          let mostRecentFile = null;
+          let mostRecentTime = 0;
+          for (const file of jsonlFiles) {
+            const filePath = path.join(projectPath, file);
+            const stat = await fs.stat(filePath);
+            if (stat.mtime.getTime() > mostRecentTime) {
+              mostRecentTime = stat.mtime.getTime();
+              mostRecentFile = filePath;
+            }
+          }
+          return mostRecentFile;
+        } catch (error) {
+          console.error("Error finding most recent session file:", error);
+          return null;
+        }
+      }
+      async findJsonlFiles(onlyRecent = false) {
+        const files = [];
+        try {
+          const projectDirs = await fs.readdir(this.claudeProjectsPath);
+          for (const projectDir of projectDirs) {
+            const projectPath = path.join(this.claudeProjectsPath, projectDir);
+            const stat = await fs.stat(projectPath);
+            if (stat.isDirectory()) {
+              const projectFiles = await fs.readdir(projectPath);
+              const jsonlFiles = projectFiles.filter((f) => f.endsWith(".jsonl"));
+              for (const jsonlFile of jsonlFiles) {
+                const filePath = path.join(projectPath, jsonlFile);
+                if (onlyRecent) {
+                  const fileStat = await fs.stat(filePath);
+                  const hoursSinceModified = (Date.now() - fileStat.mtime.getTime()) / (1e3 * 60 * 60);
+                  if (hoursSinceModified <= 24) {
+                    files.push(filePath);
+                  }
+                } else {
+                  files.push(filePath);
+                }
+              }
+            }
+          }
+        } catch (error) {
+          console.error("Error finding JSONL files:", error);
+        }
+        return files;
+      }
+      async readJsonlFile(filePath, cutoffTime) {
+        const entries = [];
+        const fileProcessedEntries = /* @__PURE__ */ new Set();
+        return new Promise((resolve) => {
+          const rl = readline.createInterface({
+            input: createReadStream(filePath),
+            crlfDelay: Infinity
+          });
+          rl.on("line", (line) => {
+            try {
+              const entry = JSON.parse(line);
+              if (entry.timestamp && new Date(entry.timestamp) >= cutoffTime) {
+                const uniqueHash = this.createUniqueHash(entry);
+                if (uniqueHash && fileProcessedEntries.has(uniqueHash)) {
+                  return;
+                }
+                const usage = entry.usage || entry.message && entry.message.usage;
+                const rawModel = entry.model || entry.message && entry.message.model || "unknown";
+                const model = this.normalizeModelName(rawModel);
+                if ((entry.type === "assistant" || entry.message && entry.message.role === "assistant") && usage) {
+                  const inputTokens = usage.input_tokens || 0;
+                  const outputTokens = usage.output_tokens || 0;
+                  const cacheCreationTokens = usage.cache_creation_input_tokens || 0;
+                  const cacheReadTokens = usage.cache_read_input_tokens || 0;
+                  let totalCost = 0;
+                  if (model === "opus") {
+                    totalCost = inputTokens * 15e-6 + outputTokens * 75e-6;
+                    totalCost += cacheCreationTokens * 15e-6 + cacheReadTokens * 15e-7;
+                  } else if (model === "sonnet") {
+                    totalCost = inputTokens * 3e-6 + outputTokens * 15e-6;
+                    totalCost += cacheCreationTokens * 3e-6 + cacheReadTokens * 3e-7;
+                  } else if (model === "haiku") {
+                    totalCost = inputTokens * 25e-8 + outputTokens * 125e-8;
+                    totalCost += cacheCreationTokens * 25e-8 + cacheReadTokens * 25e-9;
+                  }
+                  let finalCost = totalCost;
+                  if (usage.total_cost !== void 0) {
+                    finalCost = usage.total_cost > 1 ? usage.total_cost / 100 : usage.total_cost;
+                  }
+                  const processedEntry = {
+                    timestamp: entry.timestamp,
+                    model,
+                    inputTokens,
+                    outputTokens,
+                    cacheCreationTokens,
+                    cacheReadTokens,
+                    totalCost: finalCost,
+                    sessionId: entry.sessionId,
+                    messageId: entry.message_id || entry.messageId || entry.message && entry.message.id || null,
+                    requestId: entry.request_id || entry.requestId || null
+                  };
+                  entries.push(processedEntry);
+                  if (uniqueHash) {
+                    fileProcessedEntries.add(uniqueHash);
+                  }
+                }
+              }
+            } catch (e) {
+            }
+          });
+          rl.on("close", () => {
+            resolve(entries);
+          });
+          rl.on("error", (error) => {
+            console.error("Error reading file:", filePath, error);
+            resolve(entries);
+          });
+        });
+      }
+      calculateStats(entries, hoursBack) {
+        if (!entries || entries.length === 0) {
+          return {
+            requests: 0,
+            totalTokens: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheTokens: 0,
+            totalCost: 0,
+            periodHours: hoursBack,
+            firstEntry: null,
+            lastEntry: null,
+            models: {},
+            hourlyRate: 0,
+            projectedDaily: 0
+          };
+        }
+        const stats = {
+          requests: entries.length,
+          totalTokens: 0,
+          inputTokens: 0,
+          outputTokens: 0,
+          cacheCreationTokens: 0,
+          cacheReadTokens: 0,
+          cacheTokens: 0,
+          // Combined cache tokens for display
+          totalCost: 0,
+          periodHours: hoursBack,
+          firstEntry: entries[0].timestamp,
+          lastEntry: entries[entries.length - 1].timestamp,
+          models: {},
+          hourlyRate: 0,
+          projectedDaily: 0
+        };
+        for (const entry of entries) {
+          stats.inputTokens += entry.inputTokens;
+          stats.outputTokens += entry.outputTokens;
+          stats.cacheCreationTokens += entry.cacheCreationTokens;
+          stats.cacheReadTokens += entry.cacheReadTokens;
+          stats.totalCost += entry.totalCost;
+          if (!stats.models[entry.model]) {
+            stats.models[entry.model] = {
+              requests: 0,
+              inputTokens: 0,
+              outputTokens: 0,
+              cost: 0
+            };
+          }
+          stats.models[entry.model].requests++;
+          stats.models[entry.model].inputTokens += entry.inputTokens;
+          stats.models[entry.model].outputTokens += entry.outputTokens;
+          stats.models[entry.model].cost += entry.totalCost;
+        }
+        stats.cacheTokens = stats.cacheCreationTokens + stats.cacheReadTokens;
+        stats.totalTokens = stats.inputTokens + stats.outputTokens;
+        if (entries.length > 0) {
+          const actualHours = (new Date(stats.lastEntry) - new Date(stats.firstEntry)) / (1e3 * 60 * 60);
+          if (actualHours > 0) {
+            stats.hourlyRate = stats.requests / actualHours;
+            stats.projectedDaily = stats.hourlyRate * 24;
+            stats.tokensPerHour = stats.totalTokens / actualHours;
+            stats.costPerHour = stats.totalCost / actualHours;
+          }
+        }
+        const estimatedDailyLimit = 100;
+        const estimatedTokenLimit = 1e6;
+        stats.requestPercentage = stats.projectedDaily / estimatedDailyLimit * 100;
+        stats.tokenPercentage = stats.tokensPerHour * 24 / estimatedTokenLimit * 100;
+        return stats;
+      }
+      // Get usage for a specific Claude session ID
+      async getSessionUsageById(sessionId) {
+        try {
+          if (!sessionId) {
+            return null;
+          }
+          const sessionFile = path.join(this.claudeProjectsPath, path.basename(process.cwd()).replace(/[^a-zA-Z0-9-]/g, "-"), `${sessionId}.jsonl`);
+          try {
+            await fs.access(sessionFile);
+          } catch (err) {
+            return null;
+          }
+          const entries = await this.readJsonlFile(sessionFile, /* @__PURE__ */ new Date(0));
+          const sessionStats = {
+            requests: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheCreationTokens: 0,
+            cacheReadTokens: 0,
+            cacheTokens: 0,
+            totalCost: 0,
+            models: {},
+            sessionId,
+            lastUpdate: null,
+            firstRequestTime: null
+          };
+          for (const entry of entries) {
+            sessionStats.requests++;
+            sessionStats.inputTokens += entry.inputTokens;
+            sessionStats.outputTokens += entry.outputTokens;
+            sessionStats.cacheCreationTokens += entry.cacheCreationTokens;
+            sessionStats.cacheReadTokens += entry.cacheReadTokens;
+            sessionStats.totalCost += entry.totalCost;
+            sessionStats.lastUpdate = entry.timestamp;
+            if (!sessionStats.firstRequestTime) {
+              sessionStats.firstRequestTime = entry.timestamp;
+            }
+            const model = entry.model || "unknown";
+            if (!sessionStats.models[model]) {
+              sessionStats.models[model] = {
+                requests: 0,
+                inputTokens: 0,
+                outputTokens: 0,
+                cost: 0
+              };
+            }
+            sessionStats.models[model].requests++;
+            sessionStats.models[model].inputTokens += entry.inputTokens;
+            sessionStats.models[model].outputTokens += entry.outputTokens;
+            sessionStats.models[model].cost += entry.totalCost;
+          }
+          sessionStats.cacheTokens = sessionStats.cacheCreationTokens + sessionStats.cacheReadTokens;
+          sessionStats.totalTokens = sessionStats.inputTokens + sessionStats.outputTokens;
+          return sessionStats;
+        } catch (error) {
+          console.error("Error getting session usage:", error);
+          return null;
+        }
+      }
+      // Legacy method - keeping for compatibility
+      async getSessionUsage(sessionStartTime) {
+        return null;
+      }
+      // Detect overlapping sessions within rolling windows
+      async detectOverlappingSessions() {
+        try {
+          const now = /* @__PURE__ */ new Date();
+          const lookbackHours = this.sessionDurationHours * 2;
+          const cutoff = new Date(now - lookbackHours * 60 * 60 * 1e3);
+          const entries = await this.readAllEntries(cutoff);
+          if (entries.length === 0) return [];
+          const sessions = [];
+          let currentSession = null;
+          for (const entry of entries) {
+            if (!currentSession) {
+              currentSession = {
+                startTime: entry.timestamp,
+                endTime: new Date(new Date(entry.timestamp).getTime() + this.sessionDurationHours * 60 * 60 * 1e3),
+                entries: [entry],
+                totalTokens: entry.inputTokens + entry.outputTokens,
+                totalCost: entry.totalCost
+              };
+            } else {
+              const timeSinceLastEntry = new Date(entry.timestamp) - new Date(currentSession.entries[currentSession.entries.length - 1].timestamp);
+              const gapHours = timeSinceLastEntry / (1e3 * 60 * 60);
+              if (gapHours < this.sessionDurationHours) {
+                currentSession.entries.push(entry);
+                currentSession.totalTokens += entry.inputTokens + entry.outputTokens;
+                currentSession.totalCost += entry.totalCost;
+              } else {
+                sessions.push(currentSession);
+                currentSession = {
+                  startTime: entry.timestamp,
+                  endTime: new Date(new Date(entry.timestamp).getTime() + this.sessionDurationHours * 60 * 60 * 1e3),
+                  entries: [entry],
+                  totalTokens: entry.inputTokens + entry.outputTokens,
+                  totalCost: entry.totalCost
+                };
+              }
+            }
+          }
+          if (currentSession) {
+            sessions.push(currentSession);
+          }
+          const overlapping = [];
+          for (let i = 0; i < sessions.length; i++) {
+            for (let j = i + 1; j < sessions.length; j++) {
+              const session1 = sessions[i];
+              const session2 = sessions[j];
+              if (new Date(session1.startTime) < new Date(session2.endTime) && new Date(session2.startTime) < new Date(session1.endTime)) {
+                overlapping.push({
+                  session1,
+                  session2,
+                  overlapStart: new Date(Math.max(new Date(session1.startTime), new Date(session2.startTime))),
+                  overlapEnd: new Date(Math.min(new Date(session1.endTime), new Date(session2.endTime)))
+                });
+              }
+            }
+          }
+          this.overlappingSessions = overlapping;
+          return sessions;
+        } catch (error) {
+          console.error("Error detecting overlapping sessions:", error);
+          return [];
+        }
+      }
+      // Generate a session ID from timestamp
+      generateSessionId(timestamp) {
+        return `session_${new Date(timestamp).getTime()}`;
+      }
+      // Calculate burn rate for a given time window
+      async calculateBurnRate(minutes = 60) {
+        try {
+          const cutoff = new Date(Date.now() - minutes * 60 * 1e3);
+          const entries = await this.readRecentEntries(cutoff);
+          if (entries.length < 2) {
+            return { rate: 0, confidence: 0 };
+          }
+          const totalTokens = entries.reduce((sum, e) => sum + e.inputTokens + e.outputTokens, 0);
+          const duration = (new Date(entries[entries.length - 1].timestamp) - new Date(entries[0].timestamp)) / 1e3 / 60;
+          if (duration === 0) {
+            return { rate: 0, confidence: 0 };
+          }
+          const rate = totalTokens / duration;
+          const confidence = Math.min(entries.length / 10, 1);
+          return { rate, confidence, dataPoints: entries.length };
+        } catch (error) {
+          console.error("Error calculating burn rate:", error);
+          return { rate: 0, confidence: 0 };
+        }
+      }
+      // Get recent sessions for display
+      async getRecentSessions(limit = 5) {
+        try {
+          const entries = await this.readAllEntries(new Date(Date.now() - 24 * 60 * 60 * 1e3));
+          const sessions = {};
+          for (const entry of entries) {
+            const sessionId = entry.sessionId || "unknown";
+            if (!sessions[sessionId]) {
+              sessions[sessionId] = {
+                sessionId,
+                startTime: entry.timestamp,
+                endTime: entry.timestamp,
+                requests: 0,
+                totalTokens: 0,
+                cost: 0
+              };
+            }
+            sessions[sessionId].endTime = entry.timestamp;
+            sessions[sessionId].requests++;
+            sessions[sessionId].totalTokens += entry.inputTokens + entry.outputTokens;
+            sessions[sessionId].cost += entry.totalCost;
+          }
+          const sessionArray = Object.values(sessions);
+          sessionArray.sort((a, b) => new Date(b.endTime) - new Date(a.endTime));
+          return sessionArray.slice(0, limit);
+        } catch (error) {
+          console.error("Error getting recent sessions:", error);
+          return [];
+        }
+      }
+      // Helper function to get start of current day (midnight)
+      getStartOfCurrentDay() {
+        const now = /* @__PURE__ */ new Date();
+        const startOfDay = new Date(now);
+        startOfDay.setHours(0, 0, 0, 0);
+        return startOfDay;
+      }
+      // Helper function to find all sessions for the current day
+      async getDailySessionBoundaries() {
+        try {
+          const startOfDay = this.getStartOfCurrentDay();
+          const endOfDay = new Date(startOfDay);
+          endOfDay.setHours(23, 59, 59, 999);
+          const entries = await this.readAllEntries(startOfDay);
+          if (entries.length === 0) {
+            return [];
+          }
+          const todayEntries = entries.filter((entry) => {
+            const entryTime = new Date(entry.timestamp);
+            return entryTime >= startOfDay && entryTime <= endOfDay;
+          });
+          if (todayEntries.length === 0) {
+            return [];
+          }
+          todayEntries.sort((a, b) => new Date(a.timestamp) - new Date(b.timestamp));
+          const sessions = [];
+          let sessionNumber = 1;
+          let currentSessionStart = null;
+          let processedEntries = /* @__PURE__ */ new Set();
+          for (const entry of todayEntries) {
+            if (processedEntries.has(entry.timestamp)) {
+              continue;
+            }
+            const entryTime = new Date(entry.timestamp);
+            if (!currentSessionStart || entryTime >= new Date(currentSessionStart.getTime() + this.sessionDurationHours * 60 * 60 * 1e3)) {
+              const sessionStart = new Date(entryTime);
+              sessionStart.setMinutes(0, 0, 0);
+              const sessionEnd = new Date(sessionStart.getTime() + this.sessionDurationHours * 60 * 60 * 1e3);
+              const midnightEnd = new Date(endOfDay);
+              const actualSessionEnd = sessionEnd > midnightEnd ? midnightEnd : sessionEnd;
+              sessions.push({
+                sessionNumber,
+                startTime: sessionStart,
+                endTime: actualSessionEnd,
+                sessionId: this.generateSessionId(sessionStart.toISOString())
+              });
+              currentSessionStart = sessionStart;
+              sessionNumber++;
+              for (const e of todayEntries) {
+                const eTime = new Date(e.timestamp);
+                if (eTime >= sessionStart && eTime <= actualSessionEnd) {
+                  processedEntries.add(e.timestamp);
+                }
+              }
+            }
+          }
+          return sessions;
+        } catch (error) {
+          console.error("Error getting daily session boundaries:", error);
+          return [];
+        }
+      }
+      // Helper function to find which session is currently active
+      async getCurrentSession() {
+        try {
+          const now = /* @__PURE__ */ new Date();
+          const sessions = await this.getDailySessionBoundaries();
+          for (const session of sessions) {
+            if (now >= session.startTime && now <= session.endTime) {
+              return session;
+            }
+          }
+          return null;
+        } catch (error) {
+          console.error("Error getting current session:", error);
+          return null;
+        }
+      }
+    };
+    module2.exports = UsageReader;
+  }
+});
+
+// ../claude-code-web/src/usage-analytics.js
+var require_usage_analytics = __commonJS({
+  "../claude-code-web/src/usage-analytics.js"(exports2, module2) {
+    "use strict";
+    var EventEmitter = require("events");
+    var UsageAnalytics = class extends EventEmitter {
+      constructor(options = {}) {
+        super();
+        this.sessionDurationHours = options.sessionDurationHours || 5;
+        this.confidenceThreshold = options.confidenceThreshold || 0.95;
+        this.burnRateWindow = options.burnRateWindow || 60;
+        this.updateInterval = options.updateInterval || 1e4;
+        this.planLimits = {
+          "pro": {
+            tokens: 19e3,
+            cost: 18,
+            messages: 250,
+            algorithm: "fixed"
+          },
+          "claude-pro": {
+            // Keep for backwards compatibility
+            tokens: 19e3,
+            cost: 18,
+            messages: 250,
+            algorithm: "fixed"
+          },
+          "max5": {
+            tokens: 88e3,
+            cost: 35,
+            messages: 1e3,
+            algorithm: "fixed"
+          },
+          "claude-max5": {
+            // Keep for backwards compatibility
+            tokens: 88e3,
+            cost: 35,
+            messages: 1e3,
+            algorithm: "fixed"
+          },
+          "max20": {
+            tokens: 22e4,
+            cost: 140,
+            messages: 2e3,
+            algorithm: "fixed"
+          },
+          "claude-max20": {
+            // Keep for backwards compatibility
+            tokens: 22e4,
+            cost: 140,
+            messages: 2e3,
+            algorithm: "fixed"
+          },
+          "custom": {
+            tokens: null,
+            // Calculated via P90
+            cost: options.customCostLimit || 76.89,
+            // Default based on typical usage
+            messages: 1019,
+            // Higher message limit for custom plans
+            algorithm: "p90"
+          }
+        };
+        this.currentPlan = options.plan || "custom";
+        this.activeSessions = /* @__PURE__ */ new Map();
+        this.sessionHistory = [];
+        this.rollingWindows = /* @__PURE__ */ new Map();
+        this.recentUsage = [];
+        this.historicalData = [];
+        this.p90Limit = null;
+        this.burnRateHistory = [];
+        this.currentBurnRate = 0;
+        this.velocityTrend = "stable";
+        this.depletionTime = null;
+        this.depletionConfidence = 0;
+      }
+      /**
+       * Process new usage data point
+       */
+      addUsageData(data) {
+        const entry = {
+          timestamp: /* @__PURE__ */ new Date(),
+          tokens: (data.inputTokens || 0) + (data.outputTokens || 0),
+          // Only input + output tokens
+          inputTokens: data.inputTokens || 0,
+          outputTokens: data.outputTokens || 0,
+          cacheCreationTokens: data.cacheCreationTokens || 0,
+          cacheReadTokens: data.cacheReadTokens || 0,
+          cost: data.cost || 0,
+          model: data.model || "unknown",
+          sessionId: data.sessionId
+        };
+        this.recentUsage.push(entry);
+        const cutoff = new Date(Date.now() - this.burnRateWindow * 60 * 1e3);
+        this.recentUsage = this.recentUsage.filter((e) => e.timestamp > cutoff);
+        this.calculateBurnRate();
+        this.updatePredictions();
+        this.emit("usage-update", entry);
+      }
+      /**
+       * Start or update a session
+       */
+      startSession(sessionId, startTime = /* @__PURE__ */ new Date()) {
+        const session = {
+          id: sessionId,
+          startTime,
+          endTime: new Date(startTime.getTime() + this.sessionDurationHours * 60 * 60 * 1e3),
+          tokens: 0,
+          cost: 0,
+          messages: 0,
+          isActive: true,
+          window: "current"
+        };
+        this.activeSessions.set(sessionId, session);
+        this.updateRollingWindows();
+        this.emit("session-started", session);
+        return session;
+      }
+      /**
+       * Update rolling windows for overlapping sessions
+       */
+      updateRollingWindows() {
+        const now = /* @__PURE__ */ new Date();
+        this.rollingWindows.clear();
+        const fiveHoursAgo = new Date(now - this.sessionDurationHours * 60 * 60 * 1e3);
+        for (const [id, session] of this.activeSessions) {
+          if (session.startTime > fiveHoursAgo) {
+            const windowId = `window_${session.startTime.getTime()}`;
+            if (!this.rollingWindows.has(windowId)) {
+              this.rollingWindows.set(windowId, {
+                startTime: session.startTime,
+                endTime: session.endTime,
+                sessions: [],
+                totalTokens: 0,
+                totalCost: 0,
+                remainingTokens: this.getTokenLimit(),
+                burnRate: 0
+              });
+            }
+            const window = this.rollingWindows.get(windowId);
+            window.sessions.push(id);
+          }
+        }
+        this.emit("windows-updated", Array.from(this.rollingWindows.values()));
+      }
+      /**
+       * Calculate burn rate with sophisticated analysis
+       */
+      calculateBurnRate() {
+        if (this.recentUsage.length < 2) {
+          this.currentBurnRate = 0;
+          return;
+        }
+        const sorted = [...this.recentUsage].sort((a, b) => a.timestamp - b.timestamp);
+        const rates = [];
+        const windows = [5, 10, 15, 30, 60];
+        for (const window of windows) {
+          const cutoff = new Date(Date.now() - window * 60 * 1e3);
+          const windowData = sorted.filter((e) => e.timestamp > cutoff);
+          if (windowData.length >= 2) {
+            const duration = (windowData[windowData.length - 1].timestamp - windowData[0].timestamp) / 1e3 / 60;
+            const totalTokens = windowData.reduce((sum, e) => sum + e.inputTokens + e.outputTokens, 0);
+            if (duration > 0) {
+              rates.push({
+                window,
+                rate: totalTokens / duration,
+                weight: Math.min(windowData.length / 10, 1)
+                // Weight by data points
+              });
+            }
+          }
+        }
+        if (rates.length === 0) {
+          this.currentBurnRate = 0;
+          return;
+        }
+        const totalWeight = rates.reduce((sum, r) => sum + r.weight, 0);
+        this.currentBurnRate = rates.reduce((sum, r) => sum + r.rate * r.weight, 0) / totalWeight;
+        this.burnRateHistory.push({
+          timestamp: /* @__PURE__ */ new Date(),
+          rate: this.currentBurnRate
+        });
+        const histCutoff = new Date(Date.now() - 60 * 60 * 1e3);
+        this.burnRateHistory = this.burnRateHistory.filter((e) => e.timestamp > histCutoff);
+        this.analyzeTrend();
+        this.emit("burn-rate-updated", {
+          rate: this.currentBurnRate,
+          trend: this.velocityTrend,
+          confidence: this.calculateConfidence()
+        });
+      }
+      /**
+       * Analyze velocity trend
+       */
+      analyzeTrend() {
+        if (this.burnRateHistory.length < 5) {
+          this.velocityTrend = "stable";
+          return;
+        }
+        const mid = Math.floor(this.burnRateHistory.length / 2);
+        const oldRates = this.burnRateHistory.slice(0, mid);
+        const newRates = this.burnRateHistory.slice(mid);
+        const oldAvg = oldRates.reduce((sum, e) => sum + e.rate, 0) / oldRates.length;
+        const newAvg = newRates.reduce((sum, e) => sum + e.rate, 0) / newRates.length;
+        const change = (newAvg - oldAvg) / oldAvg;
+        if (change > 0.15) {
+          this.velocityTrend = "increasing";
+        } else if (change < -0.15) {
+          this.velocityTrend = "decreasing";
+        } else {
+          this.velocityTrend = "stable";
+        }
+      }
+      /**
+       * Update predictions for token depletion
+       */
+      updatePredictions() {
+        const currentSession = this.getCurrentSession();
+        if (!currentSession || this.currentBurnRate === 0) {
+          this.depletionTime = null;
+          this.depletionConfidence = 0;
+          return;
+        }
+        const limit = this.getTokenLimit();
+        const used = this.getSessionTokens(currentSession.id);
+        const remaining = limit - used;
+        if (remaining <= 0) {
+          this.depletionTime = /* @__PURE__ */ new Date();
+          this.depletionConfidence = 1;
+          return;
+        }
+        const minutesToDepletion = remaining / this.currentBurnRate;
+        this.depletionTime = new Date(Date.now() + minutesToDepletion * 60 * 1e3);
+        this.depletionConfidence = this.calculateConfidence();
+        if (this.velocityTrend === "increasing") {
+          const adjustment = 0.9;
+          const adjustedTime = Date.now() + (this.depletionTime - Date.now()) * adjustment;
+          this.depletionTime = new Date(adjustedTime);
+        } else if (this.velocityTrend === "decreasing") {
+          const adjustment = 1.1;
+          const adjustedTime = Date.now() + (this.depletionTime - Date.now()) * adjustment;
+          this.depletionTime = new Date(adjustedTime);
+        }
+        this.emit("prediction-updated", {
+          depletionTime: this.depletionTime,
+          confidence: this.depletionConfidence,
+          remaining,
+          burnRate: this.currentBurnRate
+        });
+      }
+      /**
+       * Calculate confidence score for predictions
+       */
+      calculateConfidence() {
+        let confidence = 0;
+        let factors = 0;
+        if (this.recentUsage.length > 0) {
+          const dataScore = Math.min(this.recentUsage.length / 20, 1);
+          confidence += dataScore * 0.3;
+          factors++;
+        }
+        if (this.burnRateHistory.length > 3) {
+          const rates = this.burnRateHistory.map((e) => e.rate);
+          const mean = rates.reduce((a, b) => a + b, 0) / rates.length;
+          const variance = rates.reduce((sum, r) => sum + Math.pow(r - mean, 2), 0) / rates.length;
+          const cv = mean > 0 ? Math.sqrt(variance) / mean : 1;
+          const consistencyScore = Math.max(0, 1 - cv);
+          confidence += consistencyScore * 0.4;
+          factors++;
+        }
+        const trendScore = this.velocityTrend === "stable" ? 1 : 0.7;
+        confidence += trendScore * 0.3;
+        factors++;
+        return factors > 0 ? confidence / factors : 0;
+      }
+      /**
+       * Get current active session
+       */
+      getCurrentSession() {
+        const now = /* @__PURE__ */ new Date();
+        for (const [id, session] of this.activeSessions) {
+          if (session.startTime <= now && session.endTime > now) {
+            return session;
+          }
+        }
+        return null;
+      }
+      /**
+       * Get token limit based on plan
+       */
+      getTokenLimit() {
+        const plan = this.planLimits[this.currentPlan];
+        if (plan.algorithm === "fixed") {
+          return plan.tokens;
+        } else if (plan.algorithm === "p90") {
+          return this.p90Limit || 188026;
+        }
+        return 188026;
+      }
+      /**
+       * Calculate P90 limit from historical data
+       */
+      calculateP90Limit(historicalSessions) {
+        if (!historicalSessions || historicalSessions.length < 10) {
+          return null;
+        }
+        const tokenCounts = historicalSessions.map((s) => s.totalTokens).filter((t) => t > 0).sort((a, b) => a - b);
+        if (tokenCounts.length === 0) {
+          return null;
+        }
+        const p90Index = Math.floor(tokenCounts.length * 0.9);
+        this.p90Limit = tokenCounts[p90Index];
+        this.emit("p90-calculated", {
+          limit: this.p90Limit,
+          sampleSize: tokenCounts.length,
+          confidence: Math.min(tokenCounts.length / 100, 1)
+        });
+        return this.p90Limit;
+      }
+      /**
+       * Get tokens used in a session
+       */
+      getSessionTokens(sessionId) {
+        const session = this.activeSessions.get(sessionId);
+        if (!session) return 0;
+        const sessionData = this.recentUsage.filter((e) => e.sessionId === sessionId);
+        return sessionData.reduce((sum, e) => sum + e.tokens, 0);
+      }
+      /**
+       * Get comprehensive analytics data
+       */
+      getAnalytics() {
+        const currentSession = this.getCurrentSession();
+        return {
+          currentSession: currentSession ? {
+            id: currentSession.id,
+            startTime: currentSession.startTime,
+            endTime: currentSession.endTime,
+            tokens: this.getSessionTokens(currentSession.id),
+            remaining: this.getTokenLimit() - this.getSessionTokens(currentSession.id),
+            percentUsed: this.getSessionTokens(currentSession.id) / this.getTokenLimit() * 100
+          } : null,
+          burnRate: {
+            current: this.currentBurnRate,
+            trend: this.velocityTrend,
+            history: this.burnRateHistory.slice(-10)
+            // Last 10 data points
+          },
+          predictions: {
+            depletionTime: this.depletionTime,
+            confidence: this.depletionConfidence,
+            minutesRemaining: this.depletionTime ? Math.max(0, (this.depletionTime - Date.now()) / 1e3 / 60) : null
+          },
+          plan: {
+            type: this.currentPlan,
+            limits: this.planLimits[this.currentPlan],
+            p90Limit: this.p90Limit
+          },
+          windows: Array.from(this.rollingWindows.values()),
+          activeSessions: Array.from(this.activeSessions.values()).map((s) => ({
+            id: s.id,
+            startTime: s.startTime,
+            endTime: s.endTime,
+            isActive: s.isActive,
+            tokens: this.getSessionTokens(s.id)
+          }))
+        };
+      }
+      /**
+       * Set user's plan type
+       */
+      setPlan(planType) {
+        if (this.planLimits[planType]) {
+          this.currentPlan = planType;
+          this.updatePredictions();
+          this.emit("plan-changed", planType);
+        }
+      }
+      /**
+       * Clean up old data
+       */
+      cleanup() {
+        const now = /* @__PURE__ */ new Date();
+        for (const [id, session] of this.activeSessions) {
+          if (session.endTime < now) {
+            this.sessionHistory.push(session);
+            this.activeSessions.delete(id);
+          }
+        }
+        const cutoff = new Date(now - 24 * 60 * 60 * 1e3);
+        this.sessionHistory = this.sessionHistory.filter((s) => s.endTime > cutoff);
+      }
+    };
+    module2.exports = UsageAnalytics;
+  }
+});
+
+// ../claude-code-web/src/index.js
+var require_src = __commonJS({
+  "../claude-code-web/src/index.js"(exports2, module2) {
+    "use strict";
+    var path = require("path");
+    var WebSocket = require("ws");
+    var { v4: uuidv4 } = (init_esm_node(), __toCommonJS(esm_node_exports));
+    var ClaudeBridge = require_claude_bridge();
+    var CodexBridge = require_codex_bridge();
+    var AgentBridge = require_agent_bridge();
+    var ScriptBridge = require_script_bridge();
+    var SessionStore = require_session_store();
+    var UsageReader = require_usage_reader();
+    var UsageAnalytics = require_usage_analytics();
+    var fs = require("fs");
+    function stripAnsi(str) {
+      return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").replace(/\x1b\][^\x07]*\x07/g, "").replace(/\x1b[()][AB012]/g, "").replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "").replace(/\r\n?/g, "\n").trim();
+    }
+    var TerminalHandler = class {
+      constructor(options = {}) {
+        this.baseFolder = options.workingDir || process.cwd();
+        this.selectedWorkingDir = null;
+        this.sessionDurationHours = parseFloat(process.env.CLAUDE_SESSION_HOURS || options.sessionHours || 5);
+        this.claudeSessions = /* @__PURE__ */ new Map();
+        this.webSocketConnections = /* @__PURE__ */ new Map();
+        this.claudeBridge = new ClaudeBridge();
+        this.codexBridge = new CodexBridge();
+        this.agentBridge = new AgentBridge();
+        this.scriptBridge = new ScriptBridge();
+        this.sessionStore = new SessionStore({ storageDir: options.sessionStorageDir });
+        this.usageReader = new UsageReader(this.sessionDurationHours);
+        this.usageAnalytics = new UsageAnalytics({
+          sessionDurationHours: this.sessionDurationHours,
+          plan: options.plan || process.env.CLAUDE_PLAN || "max20",
+          customCostLimit: parseFloat(process.env.CLAUDE_COST_LIMIT || options.customCostLimit || 50)
+        });
+        this.autoSaveInterval = null;
+        this.isShuttingDown = false;
+        this.aliases = {
+          claude: options.claudeAlias || process.env.CLAUDE_ALIAS || "Claude",
+          codex: options.codexAlias || process.env.CODEX_ALIAS || "Codex",
+          agent: options.agentAlias || process.env.AGENT_ALIAS || "Cursor"
+        };
+        this.loadPersistedSessions();
+        this.setupAutoSave();
+      }
+      // ── Persistence ──────────────────────────────────────────────────────
+      async loadPersistedSessions() {
+        try {
+          const sessions = await this.sessionStore.loadSessions();
+          let restored = 0;
+          for (const [id, session] of sessions) {
+            if (!this.claudeSessions.has(id)) {
+              this.claudeSessions.set(id, session);
+              restored++;
+            }
+          }
+          if (restored > 0) {
+            console.log(`Loaded ${restored} persisted sessions`);
+          }
+        } catch (error) {
+          console.error("Failed to load persisted sessions:", error);
+        }
+      }
+      setupAutoSave() {
+        this.autoSaveInterval = setInterval(() => {
+          this.saveSessionsToDisk();
+        }, 3e4);
+        process.on("beforeExit", () => this.saveSessionsToDisk());
+      }
+      async saveSessionsToDisk(sessions = this.claudeSessions) {
+        if (sessions.size > 0) {
+          await this.sessionStore.saveSessions(sessions);
+        }
+      }
+      async handleShutdown() {
+        if (this.isShuttingDown) {
+          return;
+        }
+        this.isShuttingDown = true;
+        console.log("\nGracefully shutting down terminal handler...");
+        await this.saveSessionsToDisk();
+        if (this.autoSaveInterval) {
+          clearInterval(this.autoSaveInterval);
+        }
+      }
+      // ── Path validation ──────────────────────────────────────────────────
+      isPathWithinBase(targetPath) {
+        try {
+          const resolvedTarget = path.resolve(targetPath);
+          const resolvedBase = path.resolve(this.baseFolder);
+          return resolvedTarget.startsWith(resolvedBase);
+        } catch (error) {
+          return false;
+        }
+      }
+      validatePath(targetPath) {
+        if (!targetPath) {
+          return { valid: false, error: "Path is required" };
+        }
+        const resolvedPath = path.resolve(targetPath);
+        if (!this.isPathWithinBase(resolvedPath)) {
+          return {
+            valid: false,
+            error: "Access denied: Path is outside the allowed directory"
+          };
+        }
+        return { valid: true, path: resolvedPath };
+      }
+      // ── HTTP request handler ─────────────────────────────────────────────
+      // Replaces setupExpress() — handles API routes for /terminal/api/*
+      // Strips the /terminal prefix before matching routes.
+      // Returns true if handled, false if not.
+      handleRequest(req, res) {
+        const url = new URL(req.url || "/", `http://localhost`);
+        const apiPath = url.pathname.replace(/^\/terminal/, "");
+        if (req.method === "GET" && apiPath === "/api/health") {
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            status: "ok",
+            claudeSessions: this.claudeSessions.size,
+            activeConnections: this.webSocketConnections.size
+          }));
+          return true;
+        }
+        if (req.method === "GET" && apiPath === "/api/sessions/persistence") {
+          (async () => {
+            const metadata = await this.sessionStore.getSessionMetadata();
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+              ...metadata,
+              currentSessions: this.claudeSessions.size,
+              autoSaveEnabled: true,
+              autoSaveInterval: 3e4
+            }));
+          })();
+          return true;
+        }
+        if (req.method === "GET" && apiPath === "/api/sessions/list") {
+          const sessionList = Array.from(this.claudeSessions.entries()).map(([id, session]) => ({
+            id,
+            name: session.name,
+            created: session.created,
+            active: session.active,
+            workingDir: session.workingDir,
+            connectedClients: session.connections.size,
+            lastActivity: session.lastActivity
+          }));
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ sessions: sessionList }));
+          return true;
+        }
+        if (req.method === "POST" && apiPath === "/api/sessions/create") {
+          let body = "";
+          req.on("data", (chunk) => body += chunk);
+          req.on("end", () => {
+            try {
+              const { name, workingDir } = JSON.parse(body);
+              const sessionId = uuidv4();
+              let validWorkingDir = this.baseFolder;
+              if (workingDir) {
+                const validation = this.validatePath(workingDir);
+                if (!validation.valid) {
+                  res.writeHead(403, { "Content-Type": "application/json" });
+                  res.end(JSON.stringify({ error: validation.error }));
+                  return;
+                }
+                validWorkingDir = validation.path;
+              } else if (this.selectedWorkingDir) {
+                validWorkingDir = this.selectedWorkingDir;
+              }
+              const session = {
+                id: sessionId,
+                name: name || `Session ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
+                created: /* @__PURE__ */ new Date(),
+                lastActivity: /* @__PURE__ */ new Date(),
+                active: false,
+                agent: null,
+                workingDir: validWorkingDir,
+                connections: /* @__PURE__ */ new Set(),
+                outputBuffer: [],
+                maxBufferSize: 1e3
+              };
+              this.claudeSessions.set(sessionId, session);
+              this.saveSessionsToDisk();
+              res.writeHead(200, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({
+                success: true,
+                sessionId,
+                session: { id: sessionId, name: session.name, workingDir: session.workingDir }
+              }));
+            } catch (e) {
+              res.writeHead(400, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ error: "Invalid request" }));
+            }
+          });
+          return true;
+        }
+        const sessionMatch = apiPath.match(/^\/api\/sessions\/([^/]+)$/);
+        if (sessionMatch && req.method === "GET") {
+          const session = this.claudeSessions.get(sessionMatch[1]);
+          if (!session) {
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Session not found" }));
+          } else {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+              id: session.id,
+              name: session.name,
+              created: session.created,
+              active: session.active,
+              workingDir: session.workingDir,
+              connectedClients: session.connections.size,
+              lastActivity: session.lastActivity
+            }));
+          }
+          return true;
+        }
+        if (sessionMatch && req.method === "DELETE") {
+          const sessionId = sessionMatch[1];
+          const session = this.claudeSessions.get(sessionId);
+          if (!session) {
+            res.writeHead(404, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Session not found" }));
+          } else {
+            const doDelete = async () => {
+              if (session.active) {
+                try {
+                  if (session.agent === "script") await this.scriptBridge.stopSession(sessionId);
+                  else if (session.agent === "codex") await this.codexBridge.stopSession(sessionId);
+                  else if (session.agent === "agent") await this.agentBridge.stopSession(sessionId);
+                  else await this.claudeBridge.stopSession(sessionId);
+                } catch (err) {
+                  console.error(`Failed to stop agent in session ${sessionId}:`, err);
+                }
+              }
+              session.connections.forEach((wsId) => {
+                const wsInfo = this.webSocketConnections.get(wsId);
+                if (wsInfo && wsInfo.ws.readyState === WebSocket.OPEN) {
+                  wsInfo.ws.send(JSON.stringify({ type: "session_deleted", message: "Session has been deleted" }));
+                  wsInfo.ws.close();
+                }
+              });
+              this.claudeSessions.delete(sessionId);
+              this.saveSessionsToDisk();
+              if (this.onSessionDeleted) this.onSessionDeleted(sessionId);
+              res.writeHead(200, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ success: true }));
+            };
+            doDelete();
+          }
+          return true;
+        }
+        if (req.method === "GET" && apiPath === "/api/config") {
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            folderMode: true,
+            selectedWorkingDir: this.selectedWorkingDir,
+            baseFolder: this.baseFolder,
+            aliases: this.aliases
+          }));
+          return true;
+        }
+        if (req.method === "GET" && apiPath === "/api/folders") {
+          const requestedPath = url.searchParams.get("path") || this.baseFolder;
+          const validation = this.validatePath(requestedPath);
+          if (!validation.valid) {
+            res.writeHead(403, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: validation.error }));
+            return true;
+          }
+          try {
+            const items = fs.readdirSync(validation.path, { withFileTypes: true });
+            const showHidden = url.searchParams.get("showHidden") === "true";
+            const folders = items.filter((item) => item.isDirectory()).filter((item) => !item.name.startsWith(".") || showHidden).map((item) => ({
+              name: item.name,
+              path: path.join(validation.path, item.name),
+              isDirectory: true
+            })).sort((a, b) => a.name.localeCompare(b.name));
+            const parentDir = path.dirname(validation.path);
+            const canGoUp = this.isPathWithinBase(parentDir) && parentDir !== validation.path;
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({
+              currentPath: validation.path,
+              parentPath: canGoUp ? parentDir : null,
+              folders,
+              home: this.baseFolder,
+              baseFolder: this.baseFolder
+            }));
+          } catch (error) {
+            res.writeHead(403, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Cannot access directory" }));
+          }
+          return true;
+        }
+        if (req.method === "POST" && apiPath === "/api/set-working-dir") {
+          let body = "";
+          req.on("data", (chunk) => body += chunk);
+          req.on("end", () => {
+            try {
+              const { path: selectedPath } = JSON.parse(body);
+              const validation = this.validatePath(selectedPath);
+              if (!validation.valid) {
+                res.writeHead(403, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: validation.error }));
+                return;
+              }
+              if (!fs.existsSync(validation.path) || !fs.statSync(validation.path).isDirectory()) {
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Not a valid directory" }));
+                return;
+              }
+              this.selectedWorkingDir = validation.path;
+              res.writeHead(200, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ success: true, workingDir: this.selectedWorkingDir }));
+            } catch (e) {
+              res.writeHead(400, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ error: "Invalid request" }));
+            }
+          });
+          return true;
+        }
+        if (req.method === "POST" && apiPath === "/api/folders/select") {
+          let body = "";
+          req.on("data", (chunk) => body += chunk);
+          req.on("end", () => {
+            try {
+              const { path: selectedPath } = JSON.parse(body);
+              const validation = this.validatePath(selectedPath);
+              if (!validation.valid) {
+                res.writeHead(403, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: validation.error }));
+                return;
+              }
+              if (!fs.existsSync(validation.path) || !fs.statSync(validation.path).isDirectory()) {
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Invalid directory path" }));
+                return;
+              }
+              this.selectedWorkingDir = validation.path;
+              res.writeHead(200, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ success: true, workingDir: this.selectedWorkingDir }));
+            } catch (e) {
+              res.writeHead(400, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ error: "Invalid request" }));
+            }
+          });
+          return true;
+        }
+        if (req.method === "POST" && apiPath === "/api/create-folder") {
+          let body = "";
+          req.on("data", (chunk) => body += chunk);
+          req.on("end", () => {
+            try {
+              const { parentPath, folderName } = JSON.parse(body);
+              if (!folderName || !folderName.trim() || folderName.includes("/") || folderName.includes("\\")) {
+                res.writeHead(400, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ message: "Invalid folder name" }));
+                return;
+              }
+              const basePath = parentPath || this.baseFolder;
+              const fullPath = path.join(basePath, folderName);
+              const parentValidation = this.validatePath(basePath);
+              const fullValidation = this.validatePath(fullPath);
+              if (!parentValidation.valid || !fullValidation.valid) {
+                res.writeHead(403, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ message: "Cannot create folder outside the allowed area" }));
+                return;
+              }
+              if (fs.existsSync(fullValidation.path)) {
+                res.writeHead(409, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ message: "Folder already exists" }));
+                return;
+              }
+              fs.mkdirSync(fullValidation.path, { recursive: true });
+              res.writeHead(200, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ success: true, path: fullValidation.path }));
+            } catch (e) {
+              res.writeHead(500, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ message: "Failed to create folder" }));
+            }
+          });
+          return true;
+        }
+        if (req.method === "POST" && apiPath === "/api/close-session") {
+          this.selectedWorkingDir = null;
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ success: true, message: "Working directory cleared" }));
+          return true;
+        }
+        return false;
+      }
+      // ── Static file serving ──────────────────────────────────────────────
+      // Serves files from the public/ directory for /terminal/* paths.
+      serveStatic(req, res) {
+        const url = new URL(req.url || "/", `http://localhost`);
+        let filePath = url.pathname.replace(/^\/terminal\/?/, "");
+        if (!filePath || filePath === "") filePath = "index.html";
+        const fullPath = path.join(__dirname, "public", filePath);
+        try {
+          if (!fs.existsSync(fullPath)) return false;
+          const ext = path.extname(fullPath);
+          const mimeTypes = {
+            ".html": "text/html",
+            ".js": "application/javascript",
+            ".css": "text/css",
+            ".json": "application/json",
+            ".png": "image/png",
+            ".svg": "image/svg+xml",
+            ".ico": "image/x-icon"
+          };
+          const mime = mimeTypes[ext] || "application/octet-stream";
+          const content = fs.readFileSync(fullPath);
+          res.writeHead(200, { "Content-Type": mime });
+          res.end(content);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      // ── WebSocket handling ───────────────────────────────────────────────
+      handleWebSocketConnection(ws, req) {
+        const wsId = uuidv4();
+        const url = new URL(req.url, `ws://localhost`);
+        const claudeSessionId = url.searchParams.get("sessionId");
+        const wsInfo = {
+          id: wsId,
+          ws,
+          claudeSessionId: null,
+          created: /* @__PURE__ */ new Date()
+        };
+        this.webSocketConnections.set(wsId, wsInfo);
+        ws.on("message", async (message) => {
+          try {
+            const data = JSON.parse(message);
+            await this.handleMessage(wsId, data);
+          } catch (error) {
+            this.sendToWebSocket(ws, {
+              type: "error",
+              message: "Failed to process message"
+            });
+          }
+        });
+        ws.on("close", () => {
+          this.cleanupWebSocketConnection(wsId);
+        });
+        ws.on("error", (error) => {
+          this.cleanupWebSocketConnection(wsId);
+        });
+        this.sendToWebSocket(ws, {
+          type: "connected",
+          connectionId: wsId
+        });
+        if (claudeSessionId && this.claudeSessions.has(claudeSessionId)) {
+          this.joinClaudeSession(wsId, claudeSessionId);
+        }
+      }
+      async handleMessage(wsId, data) {
+        const wsInfo = this.webSocketConnections.get(wsId);
+        if (!wsInfo) return;
+        switch (data.type) {
+          case "create_session":
+            await this.createAndJoinSession(wsId, data.name, data.workingDir);
+            break;
+          case "join_session":
+            await this.joinClaudeSession(wsId, data.sessionId);
+            break;
+          case "leave_session":
+            await this.leaveClaudeSession(wsId);
+            break;
+          case "start_claude":
+            await this.startClaude(wsId, data.options || {});
+            break;
+          case "start_codex":
+            await this.startCodex(wsId, data.options || {});
+            break;
+          case "start_agent":
+            await this.startAgent(wsId, data.options || {});
+            break;
+          case "input":
+            if (wsInfo.claudeSessionId) {
+              const session = this.claudeSessions.get(wsInfo.claudeSessionId);
+              if (session && session.connections.has(wsId)) {
+                if (session.active && session.agent) {
+                  try {
+                    if (session.agent === "script") {
+                      await this.scriptBridge.sendInput(wsInfo.claudeSessionId, data.data);
+                    } else if (session.agent === "codex") {
+                      await this.codexBridge.sendInput(wsInfo.claudeSessionId, data.data);
+                    } else if (session.agent === "agent") {
+                      await this.agentBridge.sendInput(wsInfo.claudeSessionId, data.data);
+                    } else {
+                      await this.claudeBridge.sendInput(wsInfo.claudeSessionId, data.data);
+                    }
+                  } catch (error) {
+                    this.sendToWebSocket(wsInfo.ws, {
+                      type: "error",
+                      message: "Agent is not running in this session. Please start an agent first."
+                    });
+                  }
+                } else {
+                  this.sendToWebSocket(wsInfo.ws, {
+                    type: "info",
+                    message: "No agent is running. Choose an option to start."
+                  });
+                }
+              }
+            }
+            break;
+          case "resize":
+            if (wsInfo.claudeSessionId) {
+              const session = this.claudeSessions.get(wsInfo.claudeSessionId);
+              if (session && session.connections.has(wsId)) {
+                if (session.active && session.agent) {
+                  try {
+                    if (session.agent === "script") {
+                      await this.scriptBridge.resize(wsInfo.claudeSessionId, data.cols, data.rows);
+                    } else if (session.agent === "codex") {
+                      await this.codexBridge.resize(wsInfo.claudeSessionId, data.cols, data.rows);
+                    } else if (session.agent === "agent") {
+                      await this.agentBridge.resize(wsInfo.claudeSessionId, data.cols, data.rows);
+                    } else {
+                      await this.claudeBridge.resize(wsInfo.claudeSessionId, data.cols, data.rows);
+                    }
+                  } catch (error) {
+                  }
+                }
+              }
+            }
+            break;
+          case "stop":
+            if (wsInfo.claudeSessionId) {
+              const session = this.claudeSessions.get(wsInfo.claudeSessionId);
+              if (session?.agent === "codex") {
+                await this.stopCodex(wsInfo.claudeSessionId);
+              } else if (session?.agent === "agent") {
+                await this.stopAgent(wsInfo.claudeSessionId);
+              } else {
+                await this.stopClaude(wsInfo.claudeSessionId);
+              }
+            }
+            break;
+          case "ping":
+            this.sendToWebSocket(wsInfo.ws, { type: "pong" });
+            break;
+          case "get_usage":
+            this.handleGetUsage(wsInfo);
+            break;
+          default:
+            break;
+        }
+      }
+      // ── Session management ───────────────────────────────────────────────
+      async createAndJoinSession(wsId, name, workingDir) {
+        const wsInfo = this.webSocketConnections.get(wsId);
+        if (!wsInfo) return;
+        let validWorkingDir = this.baseFolder;
+        if (workingDir) {
+          const validation = this.validatePath(workingDir);
+          if (!validation.valid) {
+            this.sendToWebSocket(wsInfo.ws, {
+              type: "error",
+              message: "Cannot create session with working directory outside the allowed area"
+            });
+            return;
+          }
+          validWorkingDir = validation.path;
+        } else if (this.selectedWorkingDir) {
+          validWorkingDir = this.selectedWorkingDir;
+        }
+        const sessionId = uuidv4();
+        const session = {
+          id: sessionId,
+          name: name || `Session ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
+          created: /* @__PURE__ */ new Date(),
+          lastActivity: /* @__PURE__ */ new Date(),
+          active: false,
+          workingDir: validWorkingDir,
+          connections: /* @__PURE__ */ new Set([wsId]),
+          outputBuffer: [],
+          sessionStartTime: null,
+          sessionUsage: {
+            requests: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheTokens: 0,
+            totalCost: 0,
+            models: {}
+          },
+          maxBufferSize: 1e3
+        };
+        this.claudeSessions.set(sessionId, session);
+        wsInfo.claudeSessionId = sessionId;
+        this.saveSessionsToDisk();
+        this.sendToWebSocket(wsInfo.ws, {
+          type: "session_created",
+          sessionId,
+          sessionName: session.name,
+          workingDir: session.workingDir
+        });
+      }
+      async joinClaudeSession(wsId, claudeSessionId) {
+        const wsInfo = this.webSocketConnections.get(wsId);
+        if (!wsInfo) return;
+        const session = this.claudeSessions.get(claudeSessionId);
+        if (!session) {
+          this.sendToWebSocket(wsInfo.ws, {
+            type: "error",
+            message: "Session not found"
+          });
+          return;
+        }
+        if (wsInfo.claudeSessionId) {
+          await this.leaveClaudeSession(wsId);
+        }
+        wsInfo.claudeSessionId = claudeSessionId;
+        session.connections.add(wsId);
+        session.lastActivity = /* @__PURE__ */ new Date();
+        session.lastAccessed = Date.now();
+        this.sendToWebSocket(wsInfo.ws, {
+          type: "session_joined",
+          sessionId: claudeSessionId,
+          sessionName: session.name,
+          workingDir: session.workingDir,
+          active: session.active,
+          outputBuffer: session.outputBuffer.slice(-200)
+        });
+      }
+      async leaveClaudeSession(wsId) {
+        const wsInfo = this.webSocketConnections.get(wsId);
+        if (!wsInfo || !wsInfo.claudeSessionId) return;
+        const session = this.claudeSessions.get(wsInfo.claudeSessionId);
+        if (session) {
+          session.connections.delete(wsId);
+          session.lastActivity = /* @__PURE__ */ new Date();
+        }
+        wsInfo.claudeSessionId = null;
+        this.sendToWebSocket(wsInfo.ws, {
+          type: "session_left"
+        });
+      }
+      // ── Agent start/stop ─────────────────────────────────────────────────
+      async startClaude(wsId, options) {
+        const wsInfo = this.webSocketConnections.get(wsId);
+        if (!wsInfo || !wsInfo.claudeSessionId) {
+          this.sendToWebSocket(wsInfo.ws, {
+            type: "error",
+            message: "No session joined"
+          });
+          return;
+        }
+        const session = this.claudeSessions.get(wsInfo.claudeSessionId);
+        if (!session) return;
+        if (session.active) {
+          this.sendToWebSocket(wsInfo.ws, {
+            type: "error",
+            message: "An agent is already running in this session"
+          });
+          return;
+        }
+        const sessionId = wsInfo.claudeSessionId;
+        try {
+          await this.claudeBridge.startSession(sessionId, {
+            workingDir: session.workingDir,
+            onOutput: (data) => {
+              const currentSession = this.claudeSessions.get(sessionId);
+              if (!currentSession) return;
+              currentSession.lastOutputAt = Date.now();
+              currentSession.outputBuffer.push(data);
+              if (currentSession.outputBuffer.length > currentSession.maxBufferSize) {
+                currentSession.outputBuffer.shift();
+              }
+              this.broadcastToSession(sessionId, {
+                type: "output",
+                data
+              });
+            },
+            onExit: (code, signal) => {
+              const currentSession = this.claudeSessions.get(sessionId);
+              if (currentSession) {
+                currentSession.active = false;
+              }
+              this.broadcastToSession(sessionId, {
+                type: "exit",
+                code,
+                signal
+              });
+            },
+            onError: (error) => {
+              const currentSession = this.claudeSessions.get(sessionId);
+              if (currentSession) {
+                currentSession.active = false;
+              }
+              this.broadcastToSession(sessionId, {
+                type: "error",
+                message: error.message
+              });
+            },
+            ...options
+          });
+          session.active = true;
+          session.agent = "claude";
+          session.lastActivity = /* @__PURE__ */ new Date();
+          if (!session.sessionStartTime) {
+            session.sessionStartTime = /* @__PURE__ */ new Date();
+          }
+          this.broadcastToSession(sessionId, {
+            type: "claude_started",
+            sessionId
+          });
+        } catch (error) {
+          this.sendToWebSocket(wsInfo.ws, {
+            type: "error",
+            message: `Failed to start Claude Code: ${error.message}`
+          });
+        }
+      }
+      async stopClaude(claudeSessionId) {
+        const session = this.claudeSessions.get(claudeSessionId);
+        if (!session || !session.active) return;
+        await this.claudeBridge.stopSession(claudeSessionId);
+        session.active = false;
+        session.agent = null;
+        session.lastActivity = /* @__PURE__ */ new Date();
+        this.broadcastToSession(claudeSessionId, {
+          type: "claude_stopped"
+        });
+      }
+      async startCodex(wsId, options) {
+        const wsInfo = this.webSocketConnections.get(wsId);
+        if (!wsInfo || !wsInfo.claudeSessionId) {
+          this.sendToWebSocket(wsInfo.ws, {
+            type: "error",
+            message: "No session joined"
+          });
+          return;
+        }
+        const session = this.claudeSessions.get(wsInfo.claudeSessionId);
+        if (!session) return;
+        if (session.active) {
+          this.sendToWebSocket(wsInfo.ws, {
+            type: "error",
+            message: "An agent is already running in this session"
+          });
+          return;
+        }
+        const sessionId = wsInfo.claudeSessionId;
+        try {
+          await this.codexBridge.startSession(sessionId, {
+            workingDir: session.workingDir,
+            onOutput: (data) => {
+              const currentSession = this.claudeSessions.get(sessionId);
+              if (!currentSession) return;
+              currentSession.lastOutputAt = Date.now();
+              currentSession.outputBuffer.push(data);
+              if (currentSession.outputBuffer.length > currentSession.maxBufferSize) {
+                currentSession.outputBuffer.shift();
+              }
+              this.broadcastToSession(sessionId, { type: "output", data });
+            },
+            onExit: (code, signal) => {
+              const currentSession = this.claudeSessions.get(sessionId);
+              if (currentSession) {
+                currentSession.active = false;
+                currentSession.agent = null;
+              }
+              this.broadcastToSession(sessionId, { type: "exit", code, signal });
+            },
+            onError: (error) => {
+              const currentSession = this.claudeSessions.get(sessionId);
+              if (currentSession) {
+                currentSession.active = false;
+                currentSession.agent = null;
+              }
+              this.broadcastToSession(sessionId, { type: "error", message: error.message });
+            },
+            ...options
+          });
+          session.active = true;
+          session.agent = "codex";
+          session.lastActivity = /* @__PURE__ */ new Date();
+          if (!session.sessionStartTime) {
+            session.sessionStartTime = /* @__PURE__ */ new Date();
+          }
+          this.broadcastToSession(sessionId, {
+            type: "codex_started",
+            sessionId
+          });
+        } catch (error) {
+          this.sendToWebSocket(wsInfo.ws, {
+            type: "error",
+            message: `Failed to start Codex Code: ${error.message}`
+          });
+        }
+      }
+      async stopCodex(sessionId) {
+        const session = this.claudeSessions.get(sessionId);
+        if (!session || !session.active) return;
+        await this.codexBridge.stopSession(sessionId);
+        session.active = false;
+        session.agent = null;
+        session.lastActivity = /* @__PURE__ */ new Date();
+        this.broadcastToSession(sessionId, { type: "codex_stopped" });
+      }
+      async startAgent(wsId, options) {
+        const wsInfo = this.webSocketConnections.get(wsId);
+        if (!wsInfo || !wsInfo.claudeSessionId) {
+          this.sendToWebSocket(wsInfo.ws, {
+            type: "error",
+            message: "No session joined"
+          });
+          return;
+        }
+        const session = this.claudeSessions.get(wsInfo.claudeSessionId);
+        if (!session) return;
+        if (session.active) {
+          this.sendToWebSocket(wsInfo.ws, {
+            type: "error",
+            message: "An agent is already running in this session"
+          });
+          return;
+        }
+        const sessionId = wsInfo.claudeSessionId;
+        try {
+          await this.agentBridge.startSession(sessionId, {
+            workingDir: session.workingDir,
+            onOutput: (data) => {
+              const currentSession = this.claudeSessions.get(sessionId);
+              if (!currentSession) return;
+              currentSession.lastOutputAt = Date.now();
+              currentSession.outputBuffer.push(data);
+              if (currentSession.outputBuffer.length > currentSession.maxBufferSize) {
+                currentSession.outputBuffer.shift();
+              }
+              this.broadcastToSession(sessionId, { type: "output", data });
+            },
+            onExit: (code, signal) => {
+              const currentSession = this.claudeSessions.get(sessionId);
+              if (currentSession) {
+                currentSession.active = false;
+                currentSession.agent = null;
+              }
+              this.broadcastToSession(sessionId, { type: "exit", code, signal });
+            },
+            onError: (error) => {
+              const currentSession = this.claudeSessions.get(sessionId);
+              if (currentSession) {
+                currentSession.active = false;
+                currentSession.agent = null;
+              }
+              this.broadcastToSession(sessionId, { type: "error", message: error.message });
+            },
+            ...options
+          });
+          session.active = true;
+          session.agent = "agent";
+          session.lastActivity = /* @__PURE__ */ new Date();
+          if (!session.sessionStartTime) {
+            session.sessionStartTime = /* @__PURE__ */ new Date();
+          }
+          this.broadcastToSession(sessionId, {
+            type: "agent_started",
+            sessionId
+          });
+        } catch (error) {
+          this.sendToWebSocket(wsInfo.ws, {
+            type: "error",
+            message: `Failed to start Agent: ${error.message}`
+          });
+        }
+      }
+      async stopAgent(sessionId) {
+        const session = this.claudeSessions.get(sessionId);
+        if (!session || !session.active) return;
+        await this.agentBridge.stopSession(sessionId);
+        session.active = false;
+        session.agent = null;
+        session.lastActivity = /* @__PURE__ */ new Date();
+        this.broadcastToSession(sessionId, { type: "agent_stopped" });
+      }
+      // ── WebSocket helpers ────────────────────────────────────────────────
+      sendToWebSocket(ws, data) {
+        if (ws && ws.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify(data));
+        }
+      }
+      broadcastToSession(claudeSessionId, data) {
+        const session = this.claudeSessions.get(claudeSessionId);
+        if (!session) return;
+        session.connections.forEach((wsId) => {
+          const wsInfo = this.webSocketConnections.get(wsId);
+          if (wsInfo && wsInfo.claudeSessionId === claudeSessionId && wsInfo.ws.readyState === WebSocket.OPEN) {
+            this.sendToWebSocket(wsInfo.ws, data);
+          }
+        });
+      }
+      cleanupWebSocketConnection(wsId) {
+        const wsInfo = this.webSocketConnections.get(wsId);
+        if (!wsInfo) return;
+        if (wsInfo.claudeSessionId) {
+          const session = this.claudeSessions.get(wsInfo.claudeSessionId);
+          if (session) {
+            session.connections.delete(wsId);
+            session.lastActivity = /* @__PURE__ */ new Date();
+          }
+        }
+        this.webSocketConnections.delete(wsId);
+      }
+      // ── Usage ────────────────────────────────────────────────────────────
+      async handleGetUsage(wsInfo) {
+        try {
+          const currentSessionStats = await this.usageReader.getCurrentSessionStats();
+          const burnRateData = await this.usageReader.calculateBurnRate(60);
+          const overlappingSessions = await this.usageReader.detectOverlappingSessions();
+          const dailyStats = await this.usageReader.getUsageStats(24);
+          if (currentSessionStats && currentSessionStats.sessionStartTime) {
+            this.usageAnalytics.startSession(
+              currentSessionStats.sessionId,
+              new Date(currentSessionStats.sessionStartTime)
+            );
+            if (currentSessionStats.totalTokens > 0) {
+              this.usageAnalytics.addUsageData({
+                tokens: currentSessionStats.totalTokens,
+                inputTokens: currentSessionStats.inputTokens,
+                outputTokens: currentSessionStats.outputTokens,
+                cacheCreationTokens: currentSessionStats.cacheCreationTokens,
+                cacheReadTokens: currentSessionStats.cacheReadTokens,
+                cost: currentSessionStats.totalCost,
+                model: Object.keys(currentSessionStats.models)[0] || "unknown",
+                sessionId: currentSessionStats.sessionId
+              });
+            }
+          }
+          const analytics = this.usageAnalytics.getAnalytics();
+          let sessionTimer = null;
+          if (currentSessionStats && currentSessionStats.sessionStartTime) {
+            const startTime = new Date(currentSessionStats.sessionStartTime);
+            const now = /* @__PURE__ */ new Date();
+            const elapsedMs = now - startTime;
+            const sessionDurationMs = this.sessionDurationHours * 60 * 60 * 1e3;
+            const remainingMs = Math.max(0, sessionDurationMs - elapsedMs);
+            const hours = Math.floor(elapsedMs / (1e3 * 60 * 60));
+            const minutes = Math.floor(elapsedMs % (1e3 * 60 * 60) / (1e3 * 60));
+            const seconds = Math.floor(elapsedMs % (1e3 * 60) / 1e3);
+            const remainingHours = Math.floor(remainingMs / (1e3 * 60 * 60));
+            const remainingMinutes = Math.floor(remainingMs % (1e3 * 60 * 60) / (1e3 * 60));
+            sessionTimer = {
+              startTime: currentSessionStats.sessionStartTime,
+              elapsed: elapsedMs,
+              remaining: remainingMs,
+              formatted: `${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}:${String(seconds).padStart(2, "0")}`,
+              remainingFormatted: `${String(remainingHours).padStart(2, "0")}:${String(remainingMinutes).padStart(2, "0")}`,
+              hours,
+              minutes,
+              seconds,
+              remainingMs,
+              sessionDurationHours: this.sessionDurationHours,
+              sessionNumber: currentSessionStats.sessionNumber || 1,
+              isExpired: remainingMs === 0,
+              burnRate: burnRateData.rate,
+              burnRateConfidence: burnRateData.confidence,
+              depletionTime: analytics.predictions.depletionTime,
+              depletionConfidence: analytics.predictions.confidence
+            };
+          }
+          this.sendToWebSocket(wsInfo.ws, {
+            type: "usage_update",
+            sessionStats: currentSessionStats || {
+              requests: 0,
+              totalTokens: 0,
+              totalCost: 0,
+              message: "No active Claude session"
+            },
+            dailyStats,
+            sessionTimer,
+            analytics,
+            burnRate: burnRateData,
+            overlappingSessions: overlappingSessions.length,
+            plan: this.usageAnalytics.currentPlan,
+            limits: this.usageAnalytics.planLimits[this.usageAnalytics.currentPlan]
+          });
+        } catch (error) {
+          console.error("Error getting usage stats:", error);
+          this.sendToWebSocket(wsInfo.ws, {
+            type: "error",
+            message: "Failed to retrieve usage statistics"
+          });
+        }
+      }
+      // ── Direct session access (for server-side adapter) ─────────────────
+      // existingId is optional: when present, reuse the given UUID instead of
+      // minting a fresh one. Used by the radar agent to resume sessions across
+      // process restarts — the wsSessionId must match the JSONL filename so the
+      // transcript reader, textbox, and interrupt button all stay wired to the
+      // same identity. If an entry with the id already exists (loaded from
+      // sessionStorageDir), return it as-is rather than clobbering.
+      createSessionDirect(name, workingDir, existingId) {
+        const sessionId = existingId || uuidv4();
+        if (existingId && this.claudeSessions.has(sessionId)) {
+          const existing = this.claudeSessions.get(sessionId);
+          existing.active = false;
+          return sessionId;
+        }
+        const session = {
+          id: sessionId,
+          name: name || `Agent ${(/* @__PURE__ */ new Date()).toLocaleTimeString()}`,
+          created: /* @__PURE__ */ new Date(),
+          lastActivity: /* @__PURE__ */ new Date(),
+          active: false,
+          workingDir: workingDir || this.baseFolder,
+          connections: /* @__PURE__ */ new Set(),
+          outputBuffer: [],
+          sessionStartTime: null,
+          sessionUsage: {
+            requests: 0,
+            inputTokens: 0,
+            outputTokens: 0,
+            cacheTokens: 0,
+            totalCost: 0,
+            models: {}
+          },
+          maxBufferSize: 1e3
+        };
+        this.claudeSessions.set(sessionId, session);
+        this.saveSessionsToDisk();
+        return sessionId;
+      }
+      async startClaudeInSession(sessionId, options = {}) {
+        const session = this.claudeSessions.get(sessionId);
+        if (!session) throw new Error(`Session ${sessionId} not found`);
+        if (session.active) throw new Error(`Agent already running in session ${sessionId}`);
+        await this.claudeBridge.startSession(sessionId, {
+          workingDir: session.workingDir,
+          onOutput: (data) => {
+            const s = this.claudeSessions.get(sessionId);
+            if (!s) return;
+            s.lastOutputAt = Date.now();
+            s.outputBuffer.push(data);
+            if (s.outputBuffer.length > s.maxBufferSize) s.outputBuffer.shift();
+            this.broadcastToSession(sessionId, { type: "output", data });
+          },
+          onExit: (code, signal) => {
+            const s = this.claudeSessions.get(sessionId);
+            if (s) s.active = false;
+            this.broadcastToSession(sessionId, { type: "exit", code, signal });
+          },
+          onError: (error) => {
+            const s = this.claudeSessions.get(sessionId);
+            if (s) s.active = false;
+            this.broadcastToSession(sessionId, { type: "error", message: error.message });
+          },
+          ...options
+        });
+        session.active = true;
+        session.agent = "claude";
+        session.lastActivity = /* @__PURE__ */ new Date();
+        if (!session.sessionStartTime) session.sessionStartTime = /* @__PURE__ */ new Date();
+        this.broadcastToSession(sessionId, { type: "claude_started", sessionId });
+      }
+      async stopAgentInSession(sessionId) {
+        const session = this.claudeSessions.get(sessionId);
+        if (!session || !session.active) return;
+        if (session.agent === "script") await this.scriptBridge.stopSession(sessionId);
+        else if (session.agent === "codex") await this.codexBridge.stopSession(sessionId);
+        else if (session.agent === "agent") await this.agentBridge.stopSession(sessionId);
+        else await this.claudeBridge.stopSession(sessionId);
+        session.active = false;
+        session.agent = null;
+      }
+      async startScriptInSession(sessionId, options = {}) {
+        const session = this.claudeSessions.get(sessionId);
+        if (!session) throw new Error(`Session ${sessionId} not found`);
+        if (session.active) throw new Error(`Agent already running in session ${sessionId}`);
+        const { command, args = [], env = {} } = options;
+        if (!command) throw new Error("startScriptInSession requires a command");
+        return new Promise((resolve, reject) => {
+          this.scriptBridge.startSession(sessionId, {
+            command,
+            args,
+            workingDir: session.workingDir || this.baseFolder,
+            env,
+            cols: 80,
+            rows: 24,
+            onOutput: (data) => {
+              session.lastActivity = /* @__PURE__ */ new Date();
+              this.broadcastToSession(sessionId, {
+                type: "output",
+                data,
+                sessionId
+              });
+            },
+            onExit: (exitCode, signal) => {
+              session.active = false;
+              session.agent = null;
+              session.lastActivity = /* @__PURE__ */ new Date();
+              this.broadcastToSession(sessionId, { type: "script_stopped", sessionId });
+              if (exitCode === 0) {
+                resolve({ code: exitCode, signal });
+              } else {
+                reject(new Error(`Script exited with code ${exitCode}`));
+              }
+            },
+            onError: (error) => {
+              session.active = false;
+              session.agent = null;
+              reject(error);
+            }
+          });
+          session.active = true;
+          session.agent = "script";
+          session.lastActivity = /* @__PURE__ */ new Date();
+          if (!session.sessionStartTime) session.sessionStartTime = /* @__PURE__ */ new Date();
+          this.broadcastToSession(sessionId, { type: "script_started", sessionId });
+        });
+      }
+      isSessionActive(sessionId) {
+        const session = this.claudeSessions.get(sessionId);
+        return session?.active ?? false;
+      }
+      /**
+       * Returns session IDs that are active but haven't produced output
+       * for longer than thresholdMs. Used as a heuristic for "terminal
+       * may need user input" (e.g. permission prompt).
+       */
+      getIdleSessions(thresholdMs = 15e3) {
+        const now = Date.now();
+        const idle = [];
+        for (const [sessionId, session] of this.claudeSessions) {
+          if (session.active && session.lastOutputAt && now - session.lastOutputAt > thresholdMs) {
+            idle.push(sessionId);
+          }
+        }
+        return idle;
+      }
+      getSessionPreviews() {
+        const previews = {};
+        for (const [sessionId, session] of this.claudeSessions) {
+          if (session.outputBuffer.length === 0) continue;
+          const raw = session.outputBuffer.slice(-5).join("");
+          const text = stripAnsi(raw).slice(-100);
+          if (text.length === 0) continue;
+          previews[sessionId] = { text, active: !!session.active };
+        }
+        return previews;
+      }
+      // ── Shutdown ─────────────────────────────────────────────────────────
+      shutdown() {
+        this.isShuttingDown = true;
+        const sessionsSnapshot = new Map(this.claudeSessions);
+        this.saveSessionsToDisk(sessionsSnapshot).catch(
+          (err) => console.error("shutdown save failed:", err)
+        );
+        if (this.autoSaveInterval) clearInterval(this.autoSaveInterval);
+        for (const [sessionId, session] of this.claudeSessions.entries()) {
+          if (session.active) {
+            if (session.agent === "script") this.scriptBridge.stopSession(sessionId);
+            else if (session.agent === "codex") this.codexBridge.stopSession(sessionId);
+            else if (session.agent === "agent") this.agentBridge.stopSession(sessionId);
+            else this.claudeBridge.stopSession(sessionId);
+          }
+        }
+        this.claudeSessions.clear();
+        this.webSocketConnections.clear();
+      }
+    };
+    function createTerminalHandler2(options) {
+      return new TerminalHandler(options);
+    }
+    function createWebSocketHandler2(httpServer, handler2, wsPath = "/terminal/ws") {
+      const wss2 = new WebSocket.Server({
+        server: httpServer,
+        path: wsPath
+      });
+      wss2.on("connection", (ws, req) => {
+        handler2.handleWebSocketConnection(ws, req);
+      });
+      return wss2;
+    }
+    function detectClaudeCli2() {
+      const ClaudeBridgeTemp = require_claude_bridge();
+      const bridge = new ClaudeBridgeTemp();
+      try {
+        require("child_process").execFileSync("which", [bridge.claudeCommand], { stdio: "ignore" });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    module2.exports = { createTerminalHandler: createTerminalHandler2, createWebSocketHandler: createWebSocketHandler2, detectClaudeCli: detectClaudeCli2, TerminalHandler };
+  }
+});
+
+// src/server/launch-bot-entry.ts
+var import_node_http = __toESM(require("node:http"));
+
+// src/server/terminal-bridge.ts
+var { createTerminalHandler, createWebSocketHandler, detectClaudeCli } = require_src();
+var handler = null;
+var wss = null;
+function isTerminalAvailable() {
+  return handler !== null;
+}
+function initTerminalBridge(httpServer, workingDir, sessionStorageDir) {
+  try {
+    const cliAvailable = detectClaudeCli();
+    if (!cliAvailable) {
+      console.log("Terminal bridge: Claude CLI not found, terminal features disabled");
+      return false;
+    }
+    handler = createTerminalHandler({ workingDir, sessionStorageDir });
+    wss = createWebSocketHandler(httpServer, handler);
+    console.log("Terminal bridge initialized");
+    return true;
+  } catch (err) {
+    console.error("Failed to initialize terminal bridge:", err);
+    return false;
+  }
+}
+function handleTerminalRequest(req, res) {
+  if (!handler) return false;
+  const url = new URL(req.url || "/", "http://localhost");
+  if (url.pathname.startsWith("/terminal/api/")) {
+    return handler.handleRequest(req, res);
+  }
+  if (url.pathname.startsWith("/terminal")) {
+    return handler.serveStatic(req, res);
+  }
+  return false;
+}
+function shutdownTerminalBridge() {
+  if (handler) {
+    handler.shutdown();
+    handler = null;
+  }
+  if (wss) {
+    wss.close();
+    wss = null;
+  }
+}
+
+// src/server/launch-bot-entry.ts
+var DEFAULT_PORT = 52849;
+var TILES = [
+  {
+    id: "claude-code",
+    title: "Claude Code",
+    subtitle: "Interactive Claude session in this project",
+    glyph: "\u2736",
+    href: "/app/claude-code"
+  },
+  {
+    id: "openrouter",
+    title: "OpenRouter",
+    subtitle: "Bring-your-own model \u2014 under construction",
+    glyph: "\u25F4"
+  }
+];
+function logStderr(msg) {
+  process.stderr.write(`[launch-bot] ${msg}
+`);
+}
+function printUsage() {
+  process.stdout.write(
+    [
+      "Usage: launch-bot <command> [options]",
+      "",
+      "Commands:",
+      "  serve [--port=<p>]   start the AI workbench shell (foreground).",
+      "                       Port also resolves from $PORT; default 52849.",
+      "",
+      "Environment:",
+      "  LAUNCHKIT_BOT_WORKDIR   working dir for provider sessions (default: cwd)",
+      "  LAUNCHKIT_BOT_SESSIONS  session-store dir (default: <workdir>/.launchpod/bot-sessions)",
+      ""
+    ].join("\n")
+  );
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+var BASE_STYLE = `
+  :root { color-scheme: dark; }
+  * { box-sizing: border-box; }
+  html, body { height: 100%; }
+  body {
+    margin: 0;
+    font-family: ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
+    color: #e2e8f0;
+  }
+`;
+function renderTile(t) {
+  const inner = `
+      <div class="glyph">${escapeHtml(t.glyph)}</div>
+      <div class="meta">
+        <div class="title">${escapeHtml(t.title)}</div>
+        <div class="subtitle">${escapeHtml(t.subtitle)}</div>
+      </div>
+      ${t.href ? '<div class="badge open">Open &rarr;</div>' : '<div class="badge soon">Soon</div>'}`;
+  return t.href ? `<a class="tile active" href="${escapeHtml(t.href)}">${inner}</a>` : `<div class="tile placeholder" aria-disabled="true">${inner}</div>`;
+}
+function renderHome() {
+  const tiles = TILES.map(renderTile).join("\n");
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>launch-bot \xB7 AI workbench</title>
+<style>
+  ${BASE_STYLE}
+  body { background: radial-gradient(1200px 600px at 50% -10%, #0f1b2d 0%, #060a12 60%) fixed, #060a12; }
+  .wrap { max-width: 760px; margin: 0 auto; padding: 64px 24px; }
+  header { display: flex; align-items: flex-start; justify-content: space-between; gap: 16px; margin-bottom: 32px; }
+  h1 { font-size: 20px; font-weight: 600; margin: 0 0 6px; letter-spacing: -0.01em; }
+  .sub { font-size: 13px; color: #7c8aa0; margin: 0; }
+  .controls { display: flex; align-items: center; gap: 10px; flex: 0 0 auto; }
+  .count { font-size: 12px; color: #94a3b8; white-space: nowrap; padding: 5px 10px; border-radius: 999px; background: rgba(148,163,184,0.1); }
+  .clear {
+    font: inherit; font-size: 12px; cursor: pointer; color: #fda4af;
+    padding: 5px 11px; border-radius: 8px;
+    border: 1px solid rgba(244,63,94,0.3); background: rgba(244,63,94,0.08);
+    transition: border-color .15s ease, opacity .15s ease;
+  }
+  .clear:hover:not(:disabled) { border-color: rgba(244,63,94,0.55); }
+  .clear:disabled { opacity: .4; cursor: default; }
+  .grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(240px, 1fr)); gap: 14px; }
+  .tile {
+    display: flex; align-items: center; gap: 14px;
+    padding: 16px; border-radius: 12px; text-decoration: none;
+    border: 1px solid rgba(148,163,184,0.18);
+    background: linear-gradient(160deg, rgba(30,41,59,0.55), rgba(8,12,20,0.7));
+    transition: border-color .15s ease, transform .15s ease;
+  }
+  .tile.active:hover { border-color: rgba(34,211,238,0.45); transform: translateY(-1px); }
+  .tile.placeholder { opacity: .55; }
+  .glyph {
+    flex: 0 0 auto; width: 40px; height: 40px; border-radius: 10px;
+    display: grid; place-items: center; font-size: 20px;
+    background: rgba(34,211,238,0.08); border: 1px solid rgba(34,211,238,0.18); color: #67e8f9;
+  }
+  .placeholder .glyph { background: rgba(148,163,184,0.08); border-color: rgba(148,163,184,0.18); color: #94a3b8; }
+  .meta { flex: 1 1 auto; min-width: 0; }
+  .title { font-size: 14px; font-weight: 600; color: #f1f5f9; }
+  .subtitle { font-size: 12px; color: #7c8aa0; margin-top: 2px; }
+  .badge { flex: 0 0 auto; font-size: 11px; padding: 3px 8px; border-radius: 999px; }
+  .badge.open { color: #67e8f9; background: rgba(34,211,238,0.1); }
+  .badge.soon { color: #94a3b8; background: rgba(148,163,184,0.1); }
+  footer { margin-top: 28px; font-size: 11px; color: #475569; }
+</style>
+</head>
+<body>
+  <div class="wrap">
+    <header>
+      <div>
+        <h1>AI workbench</h1>
+        <p class="sub">Pick a provider to start a session against this project.</p>
+      </div>
+      <div class="controls">
+        <span class="count" id="count">\u2026</span>
+        <button class="clear" id="clearBtn" disabled>Clear sessions</button>
+      </div>
+    </header>
+    <div class="grid">
+${tiles}
+    </div>
+    <footer>launch-bot \xB7 providers reach project services via MCP</footer>
+  </div>
+<script>
+  var SESSIONS_URL = '/terminal/api/sessions/list';
+  function sessionUrl(id) { return '/terminal/api/sessions/' + encodeURIComponent(id); }
+
+  function setCount(n) {
+    document.getElementById('count').textContent = n + (n === 1 ? ' session' : ' sessions');
+    document.getElementById('clearBtn').disabled = n === 0;
+  }
+
+  function loadSessions() {
+    return fetch(SESSIONS_URL)
+      .then(function (r) { return r.ok ? r.json() : { sessions: [] }; })
+      .then(function (d) { var s = (d && d.sessions) || []; setCount(s.length); return s; })
+      .catch(function () { setCount(0); return []; });
+  }
+
+  function clearAll() {
+    var btn = document.getElementById('clearBtn');
+    loadSessions().then(function (sessions) {
+      if (!sessions.length) { return; }
+      if (!window.confirm('Stop and remove all ' + sessions.length + ' running session(s)?')) { return; }
+      btn.disabled = true;
+      btn.textContent = 'Clearing\u2026';
+      Promise.all(sessions.map(function (s) {
+        return fetch(sessionUrl(s.id), { method: 'DELETE' }).catch(function () {});
+      })).then(function () {
+        btn.textContent = 'Clear sessions';
+        loadSessions();
+      });
+    });
+  }
+
+  document.getElementById('clearBtn').addEventListener('click', clearAll);
+  loadSessions();
+  // Refresh when returning to this tab (e.g. back from the terminal).
+  window.addEventListener('pageshow', loadSessions);
+</script>
+</body>
+</html>`;
+}
+function renderClaudeApp() {
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>Claude Code \xB7 launch-bot</title>
+<style>
+  ${BASE_STYLE}
+  body { display: flex; flex-direction: column; background: #060a12; }
+  .bar {
+    flex: 0 0 auto; display: flex; align-items: center; gap: 12px;
+    height: 40px; padding: 0 14px;
+    border-bottom: 1px solid rgba(148,163,184,0.16); background: #0b1220;
+  }
+  .back {
+    display: inline-flex; align-items: center; gap: 6px;
+    font-size: 12px; text-decoration: none; color: #cbd5e1;
+    padding: 4px 10px; border-radius: 8px; border: 1px solid rgba(148,163,184,0.2);
+    transition: border-color .15s ease, color .15s ease;
+  }
+  .back:hover { border-color: rgba(34,211,238,0.45); color: #67e8f9; }
+  .name { font-size: 13px; font-weight: 600; color: #f1f5f9; }
+  .dim { font-size: 12px; color: #64748b; }
+  iframe { flex: 1 1 auto; width: 100%; border: 0; display: block; }
+</style>
+</head>
+<body>
+  <div class="bar">
+    <a class="back" href="/">&larr; Workbench</a>
+    <span class="name">Claude Code</span>
+    <span class="dim">\xB7</span>
+    <span class="dim">interactive session</span>
+  </div>
+  <iframe src="/terminal/" title="Claude Code terminal" allow="clipboard-read; clipboard-write"></iframe>
+</body>
+</html>`;
+}
+function serveHtml(res, html) {
+  res.statusCode = 200;
+  res.setHeader("Content-Type", "text/html; charset=utf-8");
+  res.end(html);
+}
+function parseServeArgs(argv) {
+  let port;
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i].startsWith("--port=")) {
+      port = Number.parseInt(argv[i].slice("--port=".length), 10);
+    } else if (argv[i] === "--port" && argv[i + 1]) {
+      port = Number.parseInt(argv[++i], 10);
+    }
+  }
+  if (!port && process.env.PORT) {
+    port = Number.parseInt(process.env.PORT, 10);
+  }
+  if (!port || !Number.isFinite(port)) {
+    port = DEFAULT_PORT;
+  }
+  const workingDir = process.env.LAUNCHKIT_BOT_WORKDIR || process.cwd();
+  const sessionStorageDir = process.env.LAUNCHKIT_BOT_SESSIONS || `${workingDir.replace(/\/+$/, "")}/.launchpod/bot-sessions`;
+  return { port, workingDir, sessionStorageDir };
+}
+async function runServe(argv) {
+  const { port, workingDir, sessionStorageDir } = parseServeArgs(argv);
+  const server = import_node_http.default.createServer((req, res) => {
+    const path = (req.url ?? "/").split("?")[0];
+    if (path === "/" || path === "/bot" || path === "/bot/") {
+      serveHtml(res, renderHome());
+      return;
+    }
+    if (path === "/app/claude-code" || path === "/app/claude-code/") {
+      serveHtml(res, renderClaudeApp());
+      return;
+    }
+    if (handleTerminalRequest(req, res)) return;
+    res.statusCode = 404;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify({ error: "not_found", path }));
+  });
+  const ok = initTerminalBridge(server, workingDir, sessionStorageDir);
+  if (!ok || !isTerminalAvailable()) {
+    throw new Error(
+      "terminal bridge failed to initialize \u2014 is the `claude` CLI installed and on PATH?"
+    );
+  }
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", () => resolve());
+  });
+  logStderr(`workbench on http://127.0.0.1:${port}/  (workdir: ${workingDir})`);
+  const shutdown = (signal) => {
+    logStderr(`received ${signal}, shutting down`);
+    shutdownTerminalBridge();
+    server.close(() => process.exit(0));
+    setTimeout(() => process.exit(0), 3e3).unref();
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  process.on("SIGHUP", shutdown);
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  const subcommand = argv[0];
+  if (!subcommand || subcommand === "--help" || subcommand === "-h") {
+    printUsage();
+    return;
+  }
+  switch (subcommand) {
+    case "serve":
+      await runServe(argv.slice(1));
+      return;
+    default:
+      logStderr(`unknown command "${subcommand}"`);
+      printUsage();
+      process.exitCode = 1;
+  }
+}
+main().catch((err) => {
+  logStderr(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});