gong-code 0.1.0

package/dist/chunk-mr58jv4w.js

@@ -0,0 +1,256 @@
+// @bun
+import"./chunk-jevj87jn.js";
+import"./chunk-qztvd4hd.js";
+import"./chunk-q0xkrxy8.js";
+import"./chunk-52dzw4bc.js";
+import"./chunk-n6q02ya9.js";
+import"./chunk-b4tpz2g1.js";
+import"./chunk-n3agghys.js";
+import"./chunk-f9rahzgr.js";
+import"./chunk-ex41stfq.js";
+import"./chunk-8n4n4m67.js";
+import"./chunk-xjr0n27e.js";
+import"./chunk-0yz17yjy.js";
+import"./chunk-9m5rn7hk.js";
+import"./chunk-19jvvqzp.js";
+import"./chunk-2n0s2dhc.js";
+import"./chunk-epwrzr35.js";
+import"./chunk-1ztm9yps.js";
+import"./chunk-78n9kfp8.js";
+import"./chunk-j8mxc6k6.js";
+import"./chunk-z0exw850.js";
+import"./chunk-3jf3k40v.js";
+import"./chunk-yvmhx96e.js";
+import"./chunk-qezv7msv.js";
+import"./chunk-sscms68s.js";
+import"./chunk-7e1qjk3s.js";
+import"./chunk-1gjysfnf.js";
+import"./chunk-vxgdzx6p.js";
+import"./chunk-kv147680.js";
+import"./chunk-2p0hvt8k.js";
+import"./chunk-ycr0hp6v.js";
+import"./chunk-zb2xrj5t.js";
+import"./chunk-9029sbq1.js";
+import"./chunk-ezpa510h.js";
+import"./chunk-kp6nepx4.js";
+import"./chunk-1jjzp2pa.js";
+import"./chunk-w1jew5sn.js";
+import"./chunk-g98m2qe6.js";
+import {
+  execFileNoThrow,
+  init_execFileNoThrow
+} from "./chunk-sez03qd9.js";
+import"./chunk-vsfj449x.js";
+import"./chunk-r4cxb6t7.js";
+import"./chunk-bp0ynk17.js";
+import"./chunk-7yexhdjs.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./chunk-rex82hys.js";
+import"./chunk-4s93jyky.js";
+import"./chunk-318g78ty.js";
+import"./chunk-c0bdmy7w.js";
+import"./chunk-syxy4pf2.js";
+import {
+  __esm
+} from "./chunk-eta5aekm.js";
+import {
+  init_registry,
+  registerITermBackend
+} from "./chunk-ccyg9ap9.js";
+import"./chunk-846rr9n1.js";
+import"./chunk-fnnpqv92.js";
+import"./chunk-2yqy25z4.js";
+import"./chunk-zygzzzvk.js";
+import"./chunk-evp72hv5.js";
+import"./chunk-jz7tbdyv.js";
+import"./chunk-vxqhjyfz.js";
+import"./chunk-mf4r7918.js";
+import"./chunk-sywdxbs6.js";
+import"./chunk-cjqxdnf9.js";
+import"./chunk-9qasfk8n.js";
+import"./chunk-fpd3zzx1.js";
+import"./chunk-bv4c48a5.js";
+import"./chunk-6jta29r1.js";
+import"./chunk-z4rzc9nd.js";
+import"./chunk-9bs8n985.js";
+import {
+  IT2_COMMAND,
+  init_detection,
+  isInITerm2,
+  isIt2CliAvailable
+} from "./chunk-6xqp51qr.js";
+import"./chunk-35dw2r9g.js";
+import"./chunk-y66bqywr.js";
+import"./chunk-nwk16bbd.js";
+import"./chunk-rx6z23h0.js";
+import"./chunk-df5c1x8m.js";
+import"./chunk-qwrp63wh.js";
+import"./chunk-65z8hg8j.js";
+import"./chunk-5cp2q9sh.js";
+import"./chunk-rjjakkw2.js";
+import"./chunk-0sbddf6m.js";
+import"./chunk-q5b0kpr3.js";
+
+// src/utils/swarm/backends/ITermBackend.ts
+function acquirePaneCreationLock() {
+  let release;
+  const newLock = new Promise((resolve) => {
+    release = resolve;
+  });
+  const previousLock = paneCreationLock;
+  paneCreationLock = newLock;
+  return previousLock.then(() => release);
+}
+function runIt2(args) {
+  return execFileNoThrow(IT2_COMMAND, args);
+}
+function parseSplitOutput(output) {
+  const match = output.match(/Created new pane:\s*(.+)/);
+  if (match && match[1]) {
+    return match[1].trim();
+  }
+  return "";
+}
+function getLeaderSessionId() {
+  const itermSessionId = process.env.ITERM_SESSION_ID;
+  if (!itermSessionId) {
+    return null;
+  }
+  const colonIndex = itermSessionId.indexOf(":");
+  if (colonIndex === -1) {
+    return null;
+  }
+  return itermSessionId.slice(colonIndex + 1);
+}
+
+class ITermBackend {
+  type = "iterm2";
+  displayName = "iTerm2";
+  supportsHideShow = false;
+  async isAvailable() {
+    const inITerm2 = isInITerm2();
+    logForDebugging(`[ITermBackend] isAvailable check: inITerm2=${inITerm2}`);
+    if (!inITerm2) {
+      logForDebugging("[ITermBackend] isAvailable: false (not in iTerm2)");
+      return false;
+    }
+    const it2Available = await isIt2CliAvailable();
+    logForDebugging(`[ITermBackend] isAvailable: ${it2Available} (it2 CLI ${it2Available ? "found" : "not found"})`);
+    return it2Available;
+  }
+  async isRunningInside() {
+    const result = isInITerm2();
+    logForDebugging(`[ITermBackend] isRunningInside: ${result}`);
+    return result;
+  }
+  async createTeammatePaneInSwarmView(name, color) {
+    logForDebugging(`[ITermBackend] createTeammatePaneInSwarmView called for ${name} with color ${color}`);
+    const releaseLock = await acquirePaneCreationLock();
+    try {
+      while (true) {
+        const isFirstTeammate = !firstPaneUsed;
+        logForDebugging(`[ITermBackend] Creating pane: isFirstTeammate=${isFirstTeammate}, existingPanes=${teammateSessionIds.length}`);
+        let splitArgs;
+        let targetedTeammateId;
+        if (isFirstTeammate) {
+          const leaderSessionId = getLeaderSessionId();
+          if (leaderSessionId) {
+            splitArgs = ["session", "split", "-v", "-s", leaderSessionId];
+            logForDebugging(`[ITermBackend] First split from leader session: ${leaderSessionId}`);
+          } else {
+            splitArgs = ["session", "split", "-v"];
+            logForDebugging("[ITermBackend] First split from active session (no leader ID)");
+          }
+        } else {
+          targetedTeammateId = teammateSessionIds[teammateSessionIds.length - 1];
+          if (targetedTeammateId) {
+            splitArgs = ["session", "split", "-s", targetedTeammateId];
+            logForDebugging(`[ITermBackend] Subsequent split from teammate session: ${targetedTeammateId}`);
+          } else {
+            splitArgs = ["session", "split"];
+            logForDebugging("[ITermBackend] Subsequent split from active session (no teammate ID)");
+          }
+        }
+        const splitResult = await runIt2(splitArgs);
+        if (splitResult.code !== 0) {
+          if (targetedTeammateId) {
+            const listResult = await runIt2(["session", "list"]);
+            if (listResult.code === 0 && !listResult.stdout.includes(targetedTeammateId)) {
+              logForDebugging(`[ITermBackend] Split failed targeting dead session ${targetedTeammateId}, pruning and retrying: ${splitResult.stderr}`);
+              const idx = teammateSessionIds.indexOf(targetedTeammateId);
+              if (idx !== -1) {
+                teammateSessionIds.splice(idx, 1);
+              }
+              if (teammateSessionIds.length === 0) {
+                firstPaneUsed = false;
+              }
+              continue;
+            }
+          }
+          throw new Error(`Failed to create iTerm2 split pane: ${splitResult.stderr}`);
+        }
+        if (isFirstTeammate) {
+          firstPaneUsed = true;
+        }
+        const paneId = parseSplitOutput(splitResult.stdout);
+        if (!paneId) {
+          throw new Error(`Failed to parse session ID from split output: ${splitResult.stdout}`);
+        }
+        logForDebugging(`[ITermBackend] Created teammate pane for ${name}: ${paneId}`);
+        teammateSessionIds.push(paneId);
+        return { paneId, isFirstTeammate };
+      }
+    } finally {
+      releaseLock();
+    }
+  }
+  async sendCommandToPane(paneId, command, _useExternalSession) {
+    const args = paneId ? ["session", "run", "-s", paneId, command] : ["session", "run", command];
+    const result = await runIt2(args);
+    if (result.code !== 0) {
+      throw new Error(`Failed to send command to iTerm2 pane ${paneId}: ${result.stderr}`);
+    }
+  }
+  async setPaneBorderColor(_paneId, _color, _useExternalSession) {}
+  async setPaneTitle(_paneId, _name, _color, _useExternalSession) {}
+  async enablePaneBorderStatus(_windowTarget, _useExternalSession) {}
+  async rebalancePanes(_windowTarget, _hasLeader) {
+    logForDebugging("[ITermBackend] Pane rebalancing not implemented for iTerm2");
+  }
+  async killPane(paneId, _useExternalSession) {
+    const result = await runIt2(["session", "close", "-f", "-s", paneId]);
+    const idx = teammateSessionIds.indexOf(paneId);
+    if (idx !== -1) {
+      teammateSessionIds.splice(idx, 1);
+    }
+    if (teammateSessionIds.length === 0) {
+      firstPaneUsed = false;
+    }
+    return result.code === 0;
+  }
+  async hidePane(_paneId, _useExternalSession) {
+    logForDebugging("[ITermBackend] hidePane not supported in iTerm2");
+    return false;
+  }
+  async showPane(_paneId, _targetWindowOrPane, _useExternalSession) {
+    logForDebugging("[ITermBackend] showPane not supported in iTerm2");
+    return false;
+  }
+}
+var teammateSessionIds, firstPaneUsed = false, paneCreationLock;
+var init_ITermBackend = __esm(() => {
+  init_debug();
+  init_execFileNoThrow();
+  init_detection();
+  init_registry();
+  teammateSessionIds = [];
+  paneCreationLock = Promise.resolve();
+  registerITermBackend(ITermBackend);
+});
+init_ITermBackend();
+
+export {
+  ITermBackend
+};

package/dist/chunk-mrrx3bmt.js

@@ -0,0 +1,168 @@
+// @bun
+import {
+  require_dist_cjs
+} from "./chunk-bq75gxjs.js";
+import {
+  __commonJS
+} from "./chunk-eta5aekm.js";
+
+// node_modules/.bun/@smithy+protocol-http@5.3.12/node_modules/@smithy/protocol-http/dist-cjs/index.js
+var require_dist_cjs2 = __commonJS((exports) => {
+  var types = require_dist_cjs();
+  var getHttpHandlerExtensionConfiguration = (runtimeConfig) => {
+    return {
+      setHttpHandler(handler) {
+        runtimeConfig.httpHandler = handler;
+      },
+      httpHandler() {
+        return runtimeConfig.httpHandler;
+      },
+      updateHttpClientConfig(key, value) {
+        runtimeConfig.httpHandler?.updateHttpClientConfig(key, value);
+      },
+      httpHandlerConfigs() {
+        return runtimeConfig.httpHandler.httpHandlerConfigs();
+      }
+    };
+  };
+  var resolveHttpHandlerRuntimeConfig = (httpHandlerExtensionConfiguration) => {
+    return {
+      httpHandler: httpHandlerExtensionConfiguration.httpHandler()
+    };
+  };
+
+  class Field {
+    name;
+    kind;
+    values;
+    constructor({ name, kind = types.FieldPosition.HEADER, values = [] }) {
+      this.name = name;
+      this.kind = kind;
+      this.values = values;
+    }
+    add(value) {
+      this.values.push(value);
+    }
+    set(values) {
+      this.values = values;
+    }
+    remove(value) {
+      this.values = this.values.filter((v) => v !== value);
+    }
+    toString() {
+      return this.values.map((v) => v.includes(",") || v.includes(" ") ? `"${v}"` : v).join(", ");
+    }
+    get() {
+      return this.values;
+    }
+  }
+
+  class Fields {
+    entries = {};
+    encoding;
+    constructor({ fields = [], encoding = "utf-8" }) {
+      fields.forEach(this.setField.bind(this));
+      this.encoding = encoding;
+    }
+    setField(field) {
+      this.entries[field.name.toLowerCase()] = field;
+    }
+    getField(name) {
+      return this.entries[name.toLowerCase()];
+    }
+    removeField(name) {
+      delete this.entries[name.toLowerCase()];
+    }
+    getByType(kind) {
+      return Object.values(this.entries).filter((field) => field.kind === kind);
+    }
+  }
+
+  class HttpRequest {
+    method;
+    protocol;
+    hostname;
+    port;
+    path;
+    query;
+    headers;
+    username;
+    password;
+    fragment;
+    body;
+    constructor(options) {
+      this.method = options.method || "GET";
+      this.hostname = options.hostname || "localhost";
+      this.port = options.port;
+      this.query = options.query || {};
+      this.headers = options.headers || {};
+      this.body = options.body;
+      this.protocol = options.protocol ? options.protocol.slice(-1) !== ":" ? `${options.protocol}:` : options.protocol : "https:";
+      this.path = options.path ? options.path.charAt(0) !== "/" ? `/${options.path}` : options.path : "/";
+      this.username = options.username;
+      this.password = options.password;
+      this.fragment = options.fragment;
+    }
+    static clone(request) {
+      const cloned = new HttpRequest({
+        ...request,
+        headers: { ...request.headers }
+      });
+      if (cloned.query) {
+        cloned.query = cloneQuery(cloned.query);
+      }
+      return cloned;
+    }
+    static isInstance(request) {
+      if (!request) {
+        return false;
+      }
+      const req = request;
+      return "method" in req && "protocol" in req && "hostname" in req && "path" in req && typeof req["query"] === "object" && typeof req["headers"] === "object";
+    }
+    clone() {
+      return HttpRequest.clone(this);
+    }
+  }
+  function cloneQuery(query) {
+    return Object.keys(query).reduce((carry, paramName) => {
+      const param = query[paramName];
+      return {
+        ...carry,
+        [paramName]: Array.isArray(param) ? [...param] : param
+      };
+    }, {});
+  }
+
+  class HttpResponse {
+    statusCode;
+    reason;
+    headers;
+    body;
+    constructor(options) {
+      this.statusCode = options.statusCode;
+      this.reason = options.reason;
+      this.headers = options.headers || {};
+      this.body = options.body;
+    }
+    static isInstance(response) {
+      if (!response)
+        return false;
+      const resp = response;
+      return typeof resp.statusCode === "number" && typeof resp.headers === "object";
+    }
+  }
+  function isValidHostname(hostname) {
+    const hostPattern = /^[a-z0-9][a-z0-9\.\-]*[a-z0-9]$/;
+    return hostPattern.test(hostname);
+  }
+  exports.Field = Field;
+  exports.Fields = Fields;
+  exports.HttpRequest = HttpRequest;
+  exports.HttpResponse = HttpResponse;
+  exports.getHttpHandlerExtensionConfiguration = getHttpHandlerExtensionConfiguration;
+  exports.isValidHostname = isValidHostname;
+  exports.resolveHttpHandlerRuntimeConfig = resolveHttpHandlerRuntimeConfig;
+});
+
+export { require_dist_cjs2 as require_dist_cjs };

package/dist/chunk-mtyk3zz6.js

@@ -0,0 +1,87 @@
+// @bun
+import {
+  require_react
+} from "./chunk-0yz17yjy.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-eta5aekm.js";
+import {
+  createDisabledBypassPermissionsContext,
+  init_AppState,
+  init_permissionSetup,
+  shouldDisableBypassPermissions,
+  useAppState,
+  useAppStateStore,
+  useSetAppState
+} from "./chunk-ccyg9ap9.js";
+import {
+  getIsRemoteMode,
+  init_state
+} from "./chunk-rjjakkw2.js";
+
+// src/utils/permissions/bypassPermissionsKillswitch.ts
+async function checkAndDisableBypassPermissionsIfNeeded(toolPermissionContext, setAppState) {
+  if (bypassPermissionsCheckRan) {
+    return;
+  }
+  bypassPermissionsCheckRan = true;
+  if (!toolPermissionContext.isBypassPermissionsModeAvailable) {
+    return;
+  }
+  const shouldDisable = await shouldDisableBypassPermissions();
+  if (!shouldDisable) {
+    return;
+  }
+  setAppState((prev) => {
+    return {
+      ...prev,
+      toolPermissionContext: createDisabledBypassPermissionsContext(prev.toolPermissionContext)
+    };
+  });
+}
+function resetBypassPermissionsCheck() {
+  bypassPermissionsCheckRan = false;
+}
+function useKickOffCheckAndDisableBypassPermissionsIfNeeded() {
+  const toolPermissionContext = useAppState((s) => s.toolPermissionContext);
+  const setAppState = useSetAppState();
+  import_react.useEffect(() => {
+    if (getIsRemoteMode())
+      return;
+    checkAndDisableBypassPermissionsIfNeeded(toolPermissionContext, setAppState);
+  }, []);
+}
+async function checkAndDisableAutoModeIfNeeded(toolPermissionContext, setAppState, fastMode) {
+  if (false) {}
+}
+function resetAutoModeGateCheck() {
+  autoModeCheckRan = false;
+}
+function useKickOffCheckAndDisableAutoModeIfNeeded() {
+  const mainLoopModel = useAppState((s) => s.mainLoopModel);
+  const mainLoopModelForSession = useAppState((s) => s.mainLoopModelForSession);
+  const fastMode = useAppState((s) => s.fastMode);
+  const setAppState = useSetAppState();
+  const store = useAppStateStore();
+  const isFirstRunRef = import_react.useRef(true);
+  import_react.useEffect(() => {
+    if (getIsRemoteMode())
+      return;
+    if (isFirstRunRef.current) {
+      isFirstRunRef.current = false;
+    } else {
+      resetAutoModeGateCheck();
+    }
+    checkAndDisableAutoModeIfNeeded(store.getState().toolPermissionContext, setAppState, fastMode);
+  }, [mainLoopModel, mainLoopModelForSession, fastMode]);
+}
+var import_react, bypassPermissionsCheckRan = false, autoModeCheckRan = false;
+var init_bypassPermissionsKillswitch = __esm(() => {
+  init_AppState();
+  init_state();
+  init_permissionSetup();
+  import_react = __toESM(require_react(), 1);
+});
+
+export { checkAndDisableBypassPermissionsIfNeeded, resetBypassPermissionsCheck, useKickOffCheckAndDisableBypassPermissionsIfNeeded, useKickOffCheckAndDisableAutoModeIfNeeded, init_bypassPermissionsKillswitch };

package/dist/chunk-mvgxntv6.js

@@ -0,0 +1,62 @@
+// @bun
+import {
+  __esm
+} from "./chunk-eta5aekm.js";
+import {
+  getDefaultSubagentModel,
+  init_agent
+} from "./chunk-ccyg9ap9.js";
+import {
+  getSourceDisplayName,
+  init_constants
+} from "./chunk-y66bqywr.js";
+
+// src/tools/AgentTool/agentDisplay.ts
+function resolveAgentOverrides(allAgents, activeAgents) {
+  const activeMap = new Map;
+  for (const agent of activeAgents) {
+    activeMap.set(agent.agentType, agent);
+  }
+  const seen = new Set;
+  const resolved = [];
+  for (const agent of allAgents) {
+    const key = `${agent.agentType}:${agent.source}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    const active = activeMap.get(agent.agentType);
+    const overriddenBy = active && active.source !== agent.source ? active.source : undefined;
+    resolved.push({ ...agent, overriddenBy });
+  }
+  return resolved;
+}
+function resolveAgentModelDisplay(agent) {
+  const model = agent.model || getDefaultSubagentModel();
+  if (!model)
+    return;
+  return model === "inherit" ? "inherit" : model;
+}
+function getOverrideSourceLabel(source) {
+  return getSourceDisplayName(source).toLowerCase();
+}
+function compareAgentsByName(a, b) {
+  return a.agentType.localeCompare(b.agentType, undefined, {
+    sensitivity: "base"
+  });
+}
+var AGENT_SOURCE_GROUPS;
+var init_agentDisplay = __esm(() => {
+  init_agent();
+  init_constants();
+  AGENT_SOURCE_GROUPS = [
+    { label: "User agents", source: "userSettings" },
+    { label: "Project agents", source: "projectSettings" },
+    { label: "Local agents", source: "localSettings" },
+    { label: "Managed agents", source: "policySettings" },
+    { label: "Plugin agents", source: "plugin" },
+    { label: "CLI arg agents", source: "flagSettings" },
+    { label: "Built-in agents", source: "built-in" }
+  ];
+});
+
+export { AGENT_SOURCE_GROUPS, resolveAgentOverrides, resolveAgentModelDisplay, getOverrideSourceLabel, compareAgentsByName, init_agentDisplay };

package/dist/chunk-mwnjydcm.js

@@ -0,0 +1,102 @@
+// @bun
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-0yz17yjy.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-eta5aekm.js";
+import {
+  init_ink,
+  render,
+  require_compiler_runtime,
+  use_app_default
+} from "./chunk-fpd3zzx1.js";
+import {
+  init_strip_ansi,
+  stripAnsi
+} from "./chunk-df5c1x8m.js";
+
+// src/utils/staticRender.tsx
+import { PassThrough } from "stream";
+function RenderOnceAndExit(t0) {
+  const $ = import_compiler_runtime.c(5);
+  const {
+    children
+  } = t0;
+  const {
+    exit
+  } = use_app_default();
+  let t1;
+  let t2;
+  if ($[0] !== exit) {
+    t1 = () => {
+      const timer = setTimeout(exit, 0);
+      return () => clearTimeout(timer);
+    };
+    t2 = [exit];
+    $[0] = exit;
+    $[1] = t1;
+    $[2] = t2;
+  } else {
+    t1 = $[1];
+    t2 = $[2];
+  }
+  import_react.useLayoutEffect(t1, t2);
+  let t3;
+  if ($[3] !== children) {
+    t3 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(jsx_dev_runtime.Fragment, {
+      children
+    }, undefined, false, undefined, this);
+    $[3] = children;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  return t3;
+}
+function extractFirstFrame(output) {
+  const startIndex = output.indexOf(SYNC_START);
+  if (startIndex === -1)
+    return output;
+  const contentStart = startIndex + SYNC_START.length;
+  const endIndex = output.indexOf(SYNC_END, contentStart);
+  if (endIndex === -1)
+    return output;
+  return output.slice(contentStart, endIndex);
+}
+function renderToAnsiString(node, columns) {
+  return new Promise(async (resolve) => {
+    let output = "";
+    const stream = new PassThrough;
+    if (columns !== undefined) {
+      stream.columns = columns;
+    }
+    stream.on("data", (chunk) => {
+      output += chunk.toString();
+    });
+    const instance = await render(/* @__PURE__ */ jsx_dev_runtime.jsxDEV(RenderOnceAndExit, {
+      children: node
+    }, undefined, false, undefined, this), {
+      stdout: stream,
+      patchConsole: false
+    });
+    await instance.waitUntilExit();
+    await resolve(extractFirstFrame(output));
+  });
+}
+async function renderToString(node, columns) {
+  const output = await renderToAnsiString(node, columns);
+  return stripAnsi(output);
+}
+var import_compiler_runtime, import_react, jsx_dev_runtime, SYNC_START = "\x1B[?2026h", SYNC_END = "\x1B[?2026l";
+var init_staticRender = __esm(() => {
+  init_strip_ansi();
+  init_ink();
+  import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
+  import_react = __toESM(require_react(), 1);
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+export { renderToAnsiString, renderToString, init_staticRender };