@jayjiang/open-cc 0.2.1

package/dist/chunk-bqfnp99q.js

@@ -0,0 +1,477 @@
+// @bun
+import {
+  require_src
+} from "./chunk-sdj9b9wh.js";
+import {
+  __commonJS,
+  __require
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/agent-base@7.1.4/node_modules/agent-base/dist/helpers.js
+var require_helpers = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = exports && exports.__importStar || function(mod) {
+    if (mod && mod.__esModule)
+      return mod;
+    var result = {};
+    if (mod != null) {
+      for (var k in mod)
+        if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+          __createBinding(result, mod, k);
+    }
+    __setModuleDefault(result, mod);
+    return result;
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.req = exports.json = exports.toBuffer = undefined;
+  var http = __importStar(__require("http"));
+  var https = __importStar(__require("https"));
+  async function toBuffer(stream) {
+    let length = 0;
+    const chunks = [];
+    for await (const chunk of stream) {
+      length += chunk.length;
+      chunks.push(chunk);
+    }
+    return Buffer.concat(chunks, length);
+  }
+  exports.toBuffer = toBuffer;
+  async function json(stream) {
+    const buf = await toBuffer(stream);
+    const str = buf.toString("utf8");
+    try {
+      return JSON.parse(str);
+    } catch (_err) {
+      const err = _err;
+      err.message += ` (input: ${str})`;
+      throw err;
+    }
+  }
+  exports.json = json;
+  function req(url, opts = {}) {
+    const href = typeof url === "string" ? url : url.href;
+    const req2 = (href.startsWith("https:") ? https : http).request(url, opts);
+    const promise = new Promise((resolve, reject) => {
+      req2.once("response", resolve).once("error", reject).end();
+    });
+    req2.then = promise.then.bind(promise);
+    return req2;
+  }
+  exports.req = req;
+});
+
+// node_modules/.bun/agent-base@7.1.4/node_modules/agent-base/dist/index.js
+var require_dist = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = exports && exports.__importStar || function(mod) {
+    if (mod && mod.__esModule)
+      return mod;
+    var result = {};
+    if (mod != null) {
+      for (var k in mod)
+        if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+          __createBinding(result, mod, k);
+    }
+    __setModuleDefault(result, mod);
+    return result;
+  };
+  var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+    for (var p in m)
+      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+        __createBinding(exports2, m, p);
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.Agent = undefined;
+  var net = __importStar(__require("net"));
+  var http = __importStar(__require("http"));
+  var https_1 = __require("https");
+  __exportStar(require_helpers(), exports);
+  var INTERNAL = Symbol("AgentBaseInternalState");
+
+  class Agent extends http.Agent {
+    constructor(opts) {
+      super(opts);
+      this[INTERNAL] = {};
+    }
+    isSecureEndpoint(options) {
+      if (options) {
+        if (typeof options.secureEndpoint === "boolean") {
+          return options.secureEndpoint;
+        }
+        if (typeof options.protocol === "string") {
+          return options.protocol === "https:";
+        }
+      }
+      const { stack } = new Error;
+      if (typeof stack !== "string")
+        return false;
+      return stack.split(`
+`).some((l) => l.indexOf("(https.js:") !== -1 || l.indexOf("node:https:") !== -1);
+    }
+    incrementSockets(name) {
+      if (this.maxSockets === Infinity && this.maxTotalSockets === Infinity) {
+        return null;
+      }
+      if (!this.sockets[name]) {
+        this.sockets[name] = [];
+      }
+      const fakeSocket = new net.Socket({ writable: false });
+      this.sockets[name].push(fakeSocket);
+      this.totalSocketCount++;
+      return fakeSocket;
+    }
+    decrementSockets(name, socket) {
+      if (!this.sockets[name] || socket === null) {
+        return;
+      }
+      const sockets = this.sockets[name];
+      const index = sockets.indexOf(socket);
+      if (index !== -1) {
+        sockets.splice(index, 1);
+        this.totalSocketCount--;
+        if (sockets.length === 0) {
+          delete this.sockets[name];
+        }
+      }
+    }
+    getName(options) {
+      const secureEndpoint = this.isSecureEndpoint(options);
+      if (secureEndpoint) {
+        return https_1.Agent.prototype.getName.call(this, options);
+      }
+      return super.getName(options);
+    }
+    createSocket(req, options, cb) {
+      const connectOpts = {
+        ...options,
+        secureEndpoint: this.isSecureEndpoint(options)
+      };
+      const name = this.getName(connectOpts);
+      const fakeSocket = this.incrementSockets(name);
+      Promise.resolve().then(() => this.connect(req, connectOpts)).then((socket) => {
+        this.decrementSockets(name, fakeSocket);
+        if (socket instanceof http.Agent) {
+          try {
+            return socket.addRequest(req, connectOpts);
+          } catch (err) {
+            return cb(err);
+          }
+        }
+        this[INTERNAL].currentSocket = socket;
+        super.createSocket(req, options, cb);
+      }, (err) => {
+        this.decrementSockets(name, fakeSocket);
+        cb(err);
+      });
+    }
+    createConnection() {
+      const socket = this[INTERNAL].currentSocket;
+      this[INTERNAL].currentSocket = undefined;
+      if (!socket) {
+        throw new Error("No socket was returned in the `connect()` function");
+      }
+      return socket;
+    }
+    get defaultPort() {
+      return this[INTERNAL].defaultPort ?? (this.protocol === "https:" ? 443 : 80);
+    }
+    set defaultPort(v) {
+      if (this[INTERNAL]) {
+        this[INTERNAL].defaultPort = v;
+      }
+    }
+    get protocol() {
+      return this[INTERNAL].protocol ?? (this.isSecureEndpoint() ? "https:" : "http:");
+    }
+    set protocol(v) {
+      if (this[INTERNAL]) {
+        this[INTERNAL].protocol = v;
+      }
+    }
+  }
+  exports.Agent = Agent;
+});
+
+// node_modules/.bun/https-proxy-agent@7.0.6/node_modules/https-proxy-agent/dist/parse-proxy-response.js
+var require_parse_proxy_response = __commonJS((exports) => {
+  var __importDefault = exports && exports.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.parseProxyResponse = undefined;
+  var debug_1 = __importDefault(require_src());
+  var debug = (0, debug_1.default)("https-proxy-agent:parse-proxy-response");
+  function parseProxyResponse(socket) {
+    return new Promise((resolve, reject) => {
+      let buffersLength = 0;
+      const buffers = [];
+      function read() {
+        const b = socket.read();
+        if (b)
+          ondata(b);
+        else
+          socket.once("readable", read);
+      }
+      function cleanup() {
+        socket.removeListener("end", onend);
+        socket.removeListener("error", onerror);
+        socket.removeListener("readable", read);
+      }
+      function onend() {
+        cleanup();
+        debug("onend");
+        reject(new Error("Proxy connection ended before receiving CONNECT response"));
+      }
+      function onerror(err) {
+        cleanup();
+        debug("onerror %o", err);
+        reject(err);
+      }
+      function ondata(b) {
+        buffers.push(b);
+        buffersLength += b.length;
+        const buffered = Buffer.concat(buffers, buffersLength);
+        const endOfHeaders = buffered.indexOf(`\r
+\r
+`);
+        if (endOfHeaders === -1) {
+          debug("have not received end of HTTP headers yet...");
+          read();
+          return;
+        }
+        const headerParts = buffered.slice(0, endOfHeaders).toString("ascii").split(`\r
+`);
+        const firstLine = headerParts.shift();
+        if (!firstLine) {
+          socket.destroy();
+          return reject(new Error("No header received from proxy CONNECT response"));
+        }
+        const firstLineParts = firstLine.split(" ");
+        const statusCode = +firstLineParts[1];
+        const statusText = firstLineParts.slice(2).join(" ");
+        const headers = {};
+        for (const header of headerParts) {
+          if (!header)
+            continue;
+          const firstColon = header.indexOf(":");
+          if (firstColon === -1) {
+            socket.destroy();
+            return reject(new Error(`Invalid header from proxy CONNECT response: "${header}"`));
+          }
+          const key = header.slice(0, firstColon).toLowerCase();
+          const value = header.slice(firstColon + 1).trimStart();
+          const current = headers[key];
+          if (typeof current === "string") {
+            headers[key] = [current, value];
+          } else if (Array.isArray(current)) {
+            current.push(value);
+          } else {
+            headers[key] = value;
+          }
+        }
+        debug("got proxy server response: %o %o", firstLine, headers);
+        cleanup();
+        resolve({
+          connect: {
+            statusCode,
+            statusText,
+            headers
+          },
+          buffered
+        });
+      }
+      socket.on("error", onerror);
+      socket.on("end", onend);
+      read();
+    });
+  }
+  exports.parseProxyResponse = parseProxyResponse;
+});
+
+// node_modules/.bun/https-proxy-agent@7.0.6/node_modules/https-proxy-agent/dist/index.js
+var require_dist2 = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
+    }
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = exports && exports.__importStar || function(mod) {
+    if (mod && mod.__esModule)
+      return mod;
+    var result = {};
+    if (mod != null) {
+      for (var k in mod)
+        if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+          __createBinding(result, mod, k);
+    }
+    __setModuleDefault(result, mod);
+    return result;
+  };
+  var __importDefault = exports && exports.__importDefault || function(mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.HttpsProxyAgent = undefined;
+  var net = __importStar(__require("net"));
+  var tls = __importStar(__require("tls"));
+  var assert_1 = __importDefault(__require("assert"));
+  var debug_1 = __importDefault(require_src());
+  var agent_base_1 = require_dist();
+  var url_1 = __require("url");
+  var parse_proxy_response_1 = require_parse_proxy_response();
+  var debug = (0, debug_1.default)("https-proxy-agent");
+  var setServernameFromNonIpHost = (options) => {
+    if (options.servername === undefined && options.host && !net.isIP(options.host)) {
+      return {
+        ...options,
+        servername: options.host
+      };
+    }
+    return options;
+  };
+
+  class HttpsProxyAgent extends agent_base_1.Agent {
+    constructor(proxy, opts) {
+      super(opts);
+      this.options = { path: undefined };
+      this.proxy = typeof proxy === "string" ? new url_1.URL(proxy) : proxy;
+      this.proxyHeaders = opts?.headers ?? {};
+      debug("Creating new HttpsProxyAgent instance: %o", this.proxy.href);
+      const host = (this.proxy.hostname || this.proxy.host).replace(/^\[|\]$/g, "");
+      const port = this.proxy.port ? parseInt(this.proxy.port, 10) : this.proxy.protocol === "https:" ? 443 : 80;
+      this.connectOpts = {
+        ALPNProtocols: ["http/1.1"],
+        ...opts ? omit(opts, "headers") : null,
+        host,
+        port
+      };
+    }
+    async connect(req, opts) {
+      const { proxy } = this;
+      if (!opts.host) {
+        throw new TypeError('No "host" provided');
+      }
+      let socket;
+      if (proxy.protocol === "https:") {
+        debug("Creating `tls.Socket`: %o", this.connectOpts);
+        socket = tls.connect(setServernameFromNonIpHost(this.connectOpts));
+      } else {
+        debug("Creating `net.Socket`: %o", this.connectOpts);
+        socket = net.connect(this.connectOpts);
+      }
+      const headers = typeof this.proxyHeaders === "function" ? this.proxyHeaders() : { ...this.proxyHeaders };
+      const host = net.isIPv6(opts.host) ? `[${opts.host}]` : opts.host;
+      let payload = `CONNECT ${host}:${opts.port} HTTP/1.1\r
+`;
+      if (proxy.username || proxy.password) {
+        const auth = `${decodeURIComponent(proxy.username)}:${decodeURIComponent(proxy.password)}`;
+        headers["Proxy-Authorization"] = `Basic ${Buffer.from(auth).toString("base64")}`;
+      }
+      headers.Host = `${host}:${opts.port}`;
+      if (!headers["Proxy-Connection"]) {
+        headers["Proxy-Connection"] = this.keepAlive ? "Keep-Alive" : "close";
+      }
+      for (const name of Object.keys(headers)) {
+        payload += `${name}: ${headers[name]}\r
+`;
+      }
+      const proxyResponsePromise = (0, parse_proxy_response_1.parseProxyResponse)(socket);
+      socket.write(`${payload}\r
+`);
+      const { connect, buffered } = await proxyResponsePromise;
+      req.emit("proxyConnect", connect);
+      this.emit("proxyConnect", connect, req);
+      if (connect.statusCode === 200) {
+        req.once("socket", resume);
+        if (opts.secureEndpoint) {
+          debug("Upgrading socket connection to TLS");
+          return tls.connect({
+            ...omit(setServernameFromNonIpHost(opts), "host", "path", "port"),
+            socket
+          });
+        }
+        return socket;
+      }
+      socket.destroy();
+      const fakeSocket = new net.Socket({ writable: false });
+      fakeSocket.readable = true;
+      req.once("socket", (s) => {
+        debug("Replaying proxy buffer for failed request");
+        (0, assert_1.default)(s.listenerCount("data") > 0);
+        s.push(buffered);
+        s.push(null);
+      });
+      return fakeSocket;
+    }
+  }
+  HttpsProxyAgent.protocols = ["http", "https"];
+  exports.HttpsProxyAgent = HttpsProxyAgent;
+  function resume(socket) {
+    socket.resume();
+  }
+  function omit(obj, ...keys) {
+    const ret = {};
+    let key;
+    for (key in obj) {
+      if (!keys.includes(key)) {
+        ret[key] = obj[key];
+      }
+    }
+    return ret;
+  }
+});
+
+export { require_dist, require_dist2 as require_dist1 };

package/dist/chunk-bs6keys0.js

@@ -0,0 +1,158 @@
+// @bun
+import {
+  generateSessionName,
+  init_generateSessionName
+} from "./chunk-wpqbrv0f.js";
+import"./chunk-p5z8t6r3.js";
+import {
+  getBridgeBaseUrlOverride,
+  getBridgeTokenOverride,
+  init_bridgeConfig
+} from "./chunk-zxa7st21.js";
+import {
+  getMessagesAfterCompactBoundary,
+  getTranscriptPath,
+  init_messages1 as init_messages,
+  init_sessionStorage,
+  saveAgentName,
+  saveCustomTitle
+} from "./chunk-2y54j9ew.js";
+import"./chunk-1yzc16qa.js";
+import"./chunk-s10vyjz4.js";
+import"./chunk-1k4j1xcf.js";
+import"./chunk-3c4qja3e.js";
+import"./chunk-rc5bbzx4.js";
+import"./chunk-e6rrwzv0.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-743znc5c.js";
+import"./chunk-5p2ssw3d.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-bhdt6k7w.js";
+import"./chunk-6wkdqk81.js";
+import"./chunk-5dbk24zg.js";
+import"./chunk-bda3gxxz.js";
+import"./chunk-zxhezavg.js";
+import"./chunk-x8eg216f.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-t175chdd.js";
+import"./chunk-7rjyn5d3.js";
+import"./chunk-6q2x8zeg.js";
+import"./chunk-0yb4dz9c.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-g338npwr.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-eh474zhj.js";
+import"./chunk-ga5faygf.js";
+import"./chunk-e7c8ypwc.js";
+import"./chunk-g6qddbvf.js";
+import"./chunk-b1s11z4y.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-yxmz5k16.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-30chpfyc.js";
+import"./chunk-84k64e4a.js";
+import"./chunk-y3py9g5d.js";
+import"./chunk-7pemewz2.js";
+import {
+  init_teammate,
+  isTeammate
+} from "./chunk-s4w01jsb.js";
+import"./chunk-c8vn3ynx.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-6kpbgc5w.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-mzdtkccs.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-5k2gdxnr.js";
+import"./chunk-2qhs9n36.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-mr9df5v8.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-f2mhrmww.js";
+import"./chunk-10fdxge0.js";
+import"./chunk-r1v8d6da.js";
+import"./chunk-d3v2fbay.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-f2zhqnb6.js";
+import"./chunk-cvp5vayb.js";
+import"./chunk-b5b7h81y.js";
+import"./chunk-nm2cncrq.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-0rkbrabt.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-rwagvxh5.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-0fkqze0v.js";
+import {
+  getSessionId,
+  init_state
+} from "./chunk-2zcaw1jd.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import {
+  __esm,
+  __require
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/rename/rename.ts
+async function call(onDone, context, args) {
+  if (isTeammate()) {
+    onDone("Cannot rename: This session is a swarm teammate. Teammate names are set by the team leader.", { display: "system" });
+    return null;
+  }
+  let newName;
+  if (!args || args.trim() === "") {
+    const generated = await generateSessionName(getMessagesAfterCompactBoundary(context.messages), context.abortController.signal);
+    if (!generated) {
+      onDone("Could not generate a name: no conversation context yet. Usage: /rename <name>", { display: "system" });
+      return null;
+    }
+    newName = generated;
+  } else {
+    newName = args.trim();
+  }
+  const sessionId = getSessionId();
+  const fullPath = getTranscriptPath();
+  await saveCustomTitle(sessionId, newName, fullPath);
+  const appState = context.getAppState();
+  const bridgeSessionId = appState.replBridgeSessionId;
+  if (bridgeSessionId) {
+    const tokenOverride = getBridgeTokenOverride();
+    import("./chunk-zq9r43cb.js").then(({ updateBridgeSessionTitle }) => updateBridgeSessionTitle(bridgeSessionId, newName, {
+      baseUrl: getBridgeBaseUrlOverride(),
+      getAccessToken: tokenOverride ? () => tokenOverride : undefined
+    }).catch(() => {}));
+  }
+  await saveAgentName(sessionId, newName, fullPath);
+  context.setAppState((prev) => ({
+    ...prev,
+    standaloneAgentContext: {
+      ...prev.standaloneAgentContext,
+      name: newName
+    }
+  }));
+  onDone(`Session renamed to: ${newName}`, { display: "system" });
+  return null;
+}
+var init_rename = __esm(() => {
+  init_state();
+  init_bridgeConfig();
+  init_messages();
+  init_sessionStorage();
+  init_teammate();
+  init_generateSessionName();
+});
+init_rename();
+
+export {
+  call
+};

package/dist/chunk-bsbmmfyt.js

@@ -0,0 +1,17 @@
+// @bun
+import {
+  BRIDGE_LOGIN_ERROR,
+  BRIDGE_LOGIN_INSTRUCTION,
+  DEFAULT_SESSION_TIMEOUT_MS,
+  REMOTE_CONTROL_DISCONNECTED_MSG,
+  init_types
+} from "./chunk-bhdt6k7w.js";
+import"./chunk-qp2qdcda.js";
+init_types();
+
+export {
+  REMOTE_CONTROL_DISCONNECTED_MSG,
+  DEFAULT_SESSION_TIMEOUT_MS,
+  BRIDGE_LOGIN_INSTRUCTION,
+  BRIDGE_LOGIN_ERROR
+};