@foxclicom/foxcli 2.1.89

package/dist/chunk-003e621m.js

@@ -0,0 +1,247 @@
+// @bun
+import {
+  getDesktopPath,
+  init_file
+} from "./chunk-skctedsv.js";
+import"./chunk-e3g8q4cn.js";
+import"./chunk-ctw5jwcd.js";
+import"./chunk-vratq94g.js";
+import"./chunk-rvqtbt9h.js";
+import"./chunk-0e1xsncc.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-tjaqa99q.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-w2z5pqd3.js";
+import"./chunk-7ymfj7m3.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-x14dq3v1.js";
+import"./chunk-cdz5yb0r.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-h0rbjg6x.js";
+import"./chunk-hrzerbfw.js";
+import"./chunk-d18z9pna.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-hjhc4cpt.js";
+import"./chunk-vyc0rjyx.js";
+import"./chunk-hx2tr4ep.js";
+import {
+  init_log,
+  logError
+} from "./chunk-p7g7pf3f.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import {
+  getFsImplementation,
+  init_debug,
+  init_errors,
+  init_fsOperations,
+  init_slowOperations,
+  jsonStringify,
+  logForDebugging,
+  toError
+} from "./chunk-nxsh6de2.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-3r24h7t6.js";
+import {
+  getSessionId,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/heapDumpService.ts
+import { createWriteStream, writeFileSync } from "fs";
+import { readdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import { pipeline } from "stream/promises";
+import {
+  getHeapSnapshot,
+  getHeapSpaceStatistics,
+  getHeapStatistics
+} from "v8";
+async function captureMemoryDiagnostics(trigger, dumpNumber = 0) {
+  const usage = process.memoryUsage();
+  const heapStats = getHeapStatistics();
+  const resourceUsage = process.resourceUsage();
+  const uptimeSeconds = process.uptime();
+  let heapSpaceStats;
+  try {
+    heapSpaceStats = getHeapSpaceStatistics();
+  } catch {}
+  const activeHandles = process._getActiveHandles().length;
+  const activeRequests = process._getActiveRequests().length;
+  let openFileDescriptors;
+  try {
+    openFileDescriptors = (await readdir("/proc/self/fd")).length;
+  } catch {}
+  let smapsRollup;
+  try {
+    smapsRollup = await readFile("/proc/self/smaps_rollup", "utf8");
+  } catch {}
+  const nativeMemory = usage.rss - usage.heapUsed;
+  const bytesPerSecond = uptimeSeconds > 0 ? usage.rss / uptimeSeconds : 0;
+  const mbPerHour = bytesPerSecond * 3600 / (1024 * 1024);
+  const potentialLeaks = [];
+  if (heapStats.number_of_detached_contexts > 0) {
+    potentialLeaks.push(`${heapStats.number_of_detached_contexts} detached context(s) - possible iframe/context leak`);
+  }
+  if (activeHandles > 100) {
+    potentialLeaks.push(`${activeHandles} active handles - possible timer/socket leak`);
+  }
+  if (nativeMemory > usage.heapUsed) {
+    potentialLeaks.push("Native memory > heap - leak may be in native addons (node-pty, sharp, etc.)");
+  }
+  if (mbPerHour > 100) {
+    potentialLeaks.push(`High memory growth rate: ${mbPerHour.toFixed(1)} MB/hour`);
+  }
+  if (openFileDescriptors && openFileDescriptors > 500) {
+    potentialLeaks.push(`${openFileDescriptors} open file descriptors - possible file/socket leak`);
+  }
+  return {
+    timestamp: new Date().toISOString(),
+    sessionId: getSessionId(),
+    trigger,
+    dumpNumber,
+    uptimeSeconds,
+    memoryUsage: {
+      heapUsed: usage.heapUsed,
+      heapTotal: usage.heapTotal,
+      external: usage.external,
+      arrayBuffers: usage.arrayBuffers,
+      rss: usage.rss
+    },
+    memoryGrowthRate: {
+      bytesPerSecond,
+      mbPerHour
+    },
+    v8HeapStats: {
+      heapSizeLimit: heapStats.heap_size_limit,
+      mallocedMemory: heapStats.malloced_memory,
+      peakMallocedMemory: heapStats.peak_malloced_memory,
+      detachedContexts: heapStats.number_of_detached_contexts,
+      nativeContexts: heapStats.number_of_native_contexts
+    },
+    v8HeapSpaces: heapSpaceStats?.map((space) => ({
+      name: space.space_name,
+      size: space.space_size,
+      used: space.space_used_size,
+      available: space.space_available_size
+    })),
+    resourceUsage: {
+      maxRSS: resourceUsage.maxRSS * 1024,
+      userCPUTime: resourceUsage.userCPUTime,
+      systemCPUTime: resourceUsage.systemCPUTime
+    },
+    activeHandles,
+    activeRequests,
+    openFileDescriptors,
+    analysis: {
+      potentialLeaks,
+      recommendation: potentialLeaks.length > 0 ? `WARNING: ${potentialLeaks.length} potential leak indicator(s) found. See potentialLeaks array.` : "No obvious leak indicators. Check heap snapshot for retained objects."
+    },
+    smapsRollup,
+    platform: process.platform,
+    nodeVersion: process.version,
+    ccVersion: "2.1.888"
+  };
+}
+async function performHeapDump(trigger = "manual", dumpNumber = 0) {
+  try {
+    const sessionId = getSessionId();
+    const diagnostics = await captureMemoryDiagnostics(trigger, dumpNumber);
+    const toGB = (bytes) => (bytes / 1024 / 1024 / 1024).toFixed(3);
+    logForDebugging(`[HeapDump] Memory state:
+  heapUsed: ${toGB(diagnostics.memoryUsage.heapUsed)} GB (in snapshot)
+  external: ${toGB(diagnostics.memoryUsage.external)} GB (NOT in snapshot)
+  rss: ${toGB(diagnostics.memoryUsage.rss)} GB (total process)
+  ${diagnostics.analysis.recommendation}`);
+    const dumpDir = getDesktopPath();
+    await getFsImplementation().mkdir(dumpDir);
+    const suffix = dumpNumber > 0 ? `-dump${dumpNumber}` : "";
+    const heapFilename = `${sessionId}${suffix}.heapsnapshot`;
+    const diagFilename = `${sessionId}${suffix}-diagnostics.json`;
+    const heapPath = join(dumpDir, heapFilename);
+    const diagPath = join(dumpDir, diagFilename);
+    await writeFile(diagPath, jsonStringify(diagnostics, null, 2), {
+      mode: 384
+    });
+    logForDebugging(`[HeapDump] Diagnostics written to ${diagPath}`);
+    await writeHeapSnapshot(heapPath);
+    logForDebugging(`[HeapDump] Heap dump written to ${heapPath}`);
+    logEvent("tengu_heap_dump", {
+      triggerManual: trigger === "manual",
+      triggerAuto15GB: trigger === "auto-1.5GB",
+      dumpNumber,
+      success: true
+    });
+    return { success: true, heapPath, diagPath };
+  } catch (err) {
+    const error = toError(err);
+    logError(error);
+    logEvent("tengu_heap_dump", {
+      triggerManual: trigger === "manual",
+      triggerAuto15GB: trigger === "auto-1.5GB",
+      dumpNumber,
+      success: false
+    });
+    return { success: false, error: error.message };
+  }
+}
+async function writeHeapSnapshot(filepath) {
+  if (typeof Bun !== "undefined") {
+    writeFileSync(filepath, Bun.generateHeapSnapshot("v8", "arraybuffer"), {
+      mode: 384
+    });
+    Bun.gc(true);
+    return;
+  }
+  const writeStream = createWriteStream(filepath, { mode: 384 });
+  const heapSnapshotStream = getHeapSnapshot();
+  await pipeline(heapSnapshotStream, writeStream);
+}
+var init_heapDumpService = __esm(() => {
+  init_state();
+  init_analytics();
+  init_debug();
+  init_errors();
+  init_file();
+  init_fsOperations();
+  init_log();
+  init_slowOperations();
+});
+
+// src/commands/heapdump/heapdump.ts
+async function call() {
+  const result = await performHeapDump();
+  if (!result.success) {
+    return {
+      type: "text",
+      value: `Failed to create heap dump: ${result.error}`
+    };
+  }
+  return {
+    type: "text",
+    value: `${result.heapPath}
+${result.diagPath}`
+  };
+}
+var init_heapdump = __esm(() => {
+  init_heapDumpService();
+});
+init_heapdump();
+
+export {
+  call
+};

package/dist/chunk-04he5cyw.js

@@ -0,0 +1,169 @@
+// @bun
+import {
+  Box_default,
+  init_Box,
+  init_dom,
+  init_reconciler,
+  markCommitStart,
+  markDirty,
+  scheduleRenderFrom
+} from "./chunk-nswqqqdd.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-g338npwr.js";
+import {
+  init_state,
+  markScrollActivity
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/ink/components/ScrollBox.tsx
+function ScrollBox({
+  children,
+  ref,
+  stickyScroll,
+  ...style
+}) {
+  const domRef = import_react.useRef(null);
+  const [, forceRender] = import_react.useState(0);
+  const listenersRef = import_react.useRef(new Set);
+  const renderQueuedRef = import_react.useRef(false);
+  const notify = () => {
+    for (const l of listenersRef.current)
+      l();
+  };
+  function scrollMutated(el) {
+    markScrollActivity();
+    markDirty(el);
+    markCommitStart();
+    notify();
+    if (renderQueuedRef.current)
+      return;
+    renderQueuedRef.current = true;
+    queueMicrotask(() => {
+      renderQueuedRef.current = false;
+      scheduleRenderFrom(el);
+    });
+  }
+  import_react.useImperativeHandle(ref, () => ({
+    scrollTo(y) {
+      const el = domRef.current;
+      if (!el)
+        return;
+      el.stickyScroll = false;
+      el.pendingScrollDelta = undefined;
+      el.scrollAnchor = undefined;
+      el.scrollTop = Math.max(0, Math.floor(y));
+      scrollMutated(el);
+    },
+    scrollToElement(el, offset = 0) {
+      const box = domRef.current;
+      if (!box)
+        return;
+      box.stickyScroll = false;
+      box.pendingScrollDelta = undefined;
+      box.scrollAnchor = {
+        el,
+        offset
+      };
+      scrollMutated(box);
+    },
+    scrollBy(dy) {
+      const el = domRef.current;
+      if (!el)
+        return;
+      el.stickyScroll = false;
+      el.scrollAnchor = undefined;
+      el.pendingScrollDelta = (el.pendingScrollDelta ?? 0) + Math.floor(dy);
+      scrollMutated(el);
+    },
+    scrollToBottom() {
+      const el = domRef.current;
+      if (!el)
+        return;
+      el.pendingScrollDelta = undefined;
+      el.stickyScroll = true;
+      markDirty(el);
+      notify();
+      forceRender((n) => n + 1);
+    },
+    getScrollTop() {
+      return domRef.current?.scrollTop ?? 0;
+    },
+    getPendingDelta() {
+      return domRef.current?.pendingScrollDelta ?? 0;
+    },
+    getScrollHeight() {
+      return domRef.current?.scrollHeight ?? 0;
+    },
+    getFreshScrollHeight() {
+      const content = domRef.current?.childNodes[0];
+      return content?.yogaNode?.getComputedHeight() ?? domRef.current?.scrollHeight ?? 0;
+    },
+    getViewportHeight() {
+      return domRef.current?.scrollViewportHeight ?? 0;
+    },
+    getViewportTop() {
+      return domRef.current?.scrollViewportTop ?? 0;
+    },
+    isSticky() {
+      const el = domRef.current;
+      if (!el)
+        return false;
+      return el.stickyScroll ?? Boolean(el.attributes["stickyScroll"]);
+    },
+    subscribe(listener) {
+      listenersRef.current.add(listener);
+      return () => listenersRef.current.delete(listener);
+    },
+    setClampBounds(min, max) {
+      const el = domRef.current;
+      if (!el)
+        return;
+      el.scrollClampMin = min;
+      el.scrollClampMax = max;
+    }
+  }), []);
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV("ink-box", {
+    ref: (el) => {
+      domRef.current = el;
+      if (el)
+        el.scrollTop ??= 0;
+    },
+    style: {
+      flexWrap: "nowrap",
+      flexDirection: style.flexDirection ?? "row",
+      flexGrow: style.flexGrow ?? 0,
+      flexShrink: style.flexShrink ?? 1,
+      ...style,
+      overflowX: "scroll",
+      overflowY: "scroll"
+    },
+    ...stickyScroll ? {
+      stickyScroll: true
+    } : {},
+    children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Box_default, {
+      flexDirection: "column",
+      flexGrow: 1,
+      flexShrink: 0,
+      width: "100%",
+      children
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+var import_react, jsx_dev_runtime, ScrollBox_default;
+var init_ScrollBox = __esm(() => {
+  init_state();
+  init_dom();
+  init_reconciler();
+  init_Box();
+  import_react = __toESM(require_react(), 1);
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+  ScrollBox_default = ScrollBox;
+});
+
+export { ScrollBox_default, init_ScrollBox };

package/dist/chunk-05gpckd1.js

@@ -0,0 +1,56 @@
+// @bun
+import {
+  captureTeammateModeSnapshot,
+  clearCliTeammateModeOverride,
+  getCliTeammateModeOverride,
+  getTeammateModeFromSnapshot,
+  init_teammateModeSnapshot,
+  setCliTeammateModeOverride
+} from "./chunk-t0zcygwt.js";
+import"./chunk-skctedsv.js";
+import"./chunk-e3g8q4cn.js";
+import"./chunk-ctw5jwcd.js";
+import"./chunk-vratq94g.js";
+import"./chunk-rvqtbt9h.js";
+import"./chunk-0e1xsncc.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-tjaqa99q.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-w2z5pqd3.js";
+import"./chunk-7ymfj7m3.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-x14dq3v1.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-h0rbjg6x.js";
+import"./chunk-hrzerbfw.js";
+import"./chunk-d18z9pna.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-hjhc4cpt.js";
+import"./chunk-vyc0rjyx.js";
+import"./chunk-hx2tr4ep.js";
+import"./chunk-p7g7pf3f.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-nxsh6de2.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-3r24h7t6.js";
+import"./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import"./chunk-qp2qdcda.js";
+init_teammateModeSnapshot();
+
+export {
+  setCliTeammateModeOverride,
+  getTeammateModeFromSnapshot,
+  getCliTeammateModeOverride,
+  clearCliTeammateModeOverride,
+  captureTeammateModeSnapshot
+};

package/dist/chunk-06saje2v.js

@@ -0,0 +1,39 @@
+// @bun
+import {
+  require_execAsync
+} from "./chunk-3w6s9m5w.js";
+import {
+  require_src
+} from "./chunk-p2816w9z.js";
+import {
+  __commonJS,
+  __require
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@opentelemetry+resources@2.6.1+e40b0dfdd726a224/node_modules/@opentelemetry/resources/build/src/detectors/platform/node/machine-id/getMachineId-win.js
+var require_getMachineId_win = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.getMachineId = undefined;
+  var process = __require("process");
+  var execAsync_1 = require_execAsync();
+  var api_1 = require_src();
+  async function getMachineId() {
+    const args = "QUERY HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography /v MachineGuid";
+    let command = "%windir%\\System32\\REG.exe";
+    if (process.arch === "ia32" && "PROCESSOR_ARCHITEW6432" in process.env) {
+      command = "%windir%\\sysnative\\cmd.exe /c " + command;
+    }
+    try {
+      const result = await (0, execAsync_1.execAsync)(`${command} ${args}`);
+      const parts = result.stdout.split("REG_SZ");
+      if (parts.length === 2) {
+        return parts[1].trim();
+      }
+    } catch (e) {
+      api_1.diag.debug(`error reading machine id: ${e}`);
+    }
+    return;
+  }
+  exports.getMachineId = getMachineId;
+});
+export default require_getMachineId_win();

package/dist/chunk-0731m51q.js

@@ -0,0 +1,8 @@
+// @bun
+import"./chunk-qp2qdcda.js";
+
+// src/assistant/AssistantSessionChooser.ts
+var AssistantSessionChooser = () => null;
+export {
+  AssistantSessionChooser
+};