@zyycn/claudex 1.0.3-fork.1453470

package/dist/chunk-kjcfwnj1.js

@@ -0,0 +1,247 @@
+// @bun
+import {
+  getDesktopPath,
+  init_file
+} from "./chunk-3tqnjgfx.js";
+import"./chunk-eebcvtbb.js";
+import"./chunk-xq4cfvpn.js";
+import"./chunk-4qz9vbs1.js";
+import"./chunk-gmaybtrd.js";
+import"./chunk-b75fzr8e.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-nj17bhkh.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-wn2268qd.js";
+import"./chunk-vqvd3qz0.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-wgcssf6v.js";
+import"./chunk-cdz5yb0r.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-h0rbjg6x.js";
+import"./chunk-b8x1gk3y.js";
+import"./chunk-9k2drwej.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-fbpftpf0.js";
+import"./chunk-3vs3nm7w.js";
+import"./chunk-gzzfhtdv.js";
+import {
+  init_log,
+  logError
+} from "./chunk-yysj6sxt.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-sbbj6ta3.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-raqgs410.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: "1.0.3-fork.1453470"
+  };
+}
+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-kjtm8wb0.js

@@ -0,0 +1,95 @@
+// @bun
+import {
+  BASH_TOOL_NAME,
+  getAllowRules,
+  getAskRules,
+  getDenyRules,
+  init_permissions,
+  init_toolName,
+  permissionRuleSourceDisplayString
+} from "./chunk-730qrdey.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/permissions/shadowedRuleDetection.ts
+function isSharedSettingSource(source) {
+  return source === "projectSettings" || source === "policySettings" || source === "command";
+}
+function formatSource(source) {
+  return permissionRuleSourceDisplayString(source);
+}
+function generateFixSuggestion(shadowType, shadowingRule, shadowedRule) {
+  const shadowingSource = formatSource(shadowingRule.source);
+  const shadowedSource = formatSource(shadowedRule.source);
+  const toolName = shadowingRule.ruleValue.toolName;
+  if (shadowType === "deny") {
+    return `Remove the "${toolName}" deny rule from ${shadowingSource}, or remove the specific allow rule from ${shadowedSource}`;
+  }
+  return `Remove the "${toolName}" ask rule from ${shadowingSource}, or remove the specific allow rule from ${shadowedSource}`;
+}
+function isAllowRuleShadowedByAskRule(allowRule, askRules, options) {
+  const { toolName, ruleContent } = allowRule.ruleValue;
+  if (ruleContent === undefined) {
+    return { shadowed: false };
+  }
+  const shadowingAskRule = askRules.find((askRule) => askRule.ruleValue.toolName === toolName && askRule.ruleValue.ruleContent === undefined);
+  if (!shadowingAskRule) {
+    return { shadowed: false };
+  }
+  if (toolName === BASH_TOOL_NAME && options.sandboxAutoAllowEnabled) {
+    if (!isSharedSettingSource(shadowingAskRule.source)) {
+      return { shadowed: false };
+    }
+  }
+  return { shadowed: true, shadowedBy: shadowingAskRule, shadowType: "ask" };
+}
+function isAllowRuleShadowedByDenyRule(allowRule, denyRules) {
+  const { toolName, ruleContent } = allowRule.ruleValue;
+  if (ruleContent === undefined) {
+    return { shadowed: false };
+  }
+  const shadowingDenyRule = denyRules.find((denyRule) => denyRule.ruleValue.toolName === toolName && denyRule.ruleValue.ruleContent === undefined);
+  if (!shadowingDenyRule) {
+    return { shadowed: false };
+  }
+  return { shadowed: true, shadowedBy: shadowingDenyRule, shadowType: "deny" };
+}
+function detectUnreachableRules(context, options) {
+  const unreachable = [];
+  const allowRules = getAllowRules(context);
+  const askRules = getAskRules(context);
+  const denyRules = getDenyRules(context);
+  for (const allowRule of allowRules) {
+    const denyResult = isAllowRuleShadowedByDenyRule(allowRule, denyRules);
+    if (denyResult.shadowed) {
+      const shadowSource = formatSource(denyResult.shadowedBy.source);
+      unreachable.push({
+        rule: allowRule,
+        reason: `Blocked by "${denyResult.shadowedBy.ruleValue.toolName}" deny rule (from ${shadowSource})`,
+        shadowedBy: denyResult.shadowedBy,
+        shadowType: "deny",
+        fix: generateFixSuggestion("deny", denyResult.shadowedBy, allowRule)
+      });
+      continue;
+    }
+    const askResult = isAllowRuleShadowedByAskRule(allowRule, askRules, options);
+    if (askResult.shadowed) {
+      const shadowSource = formatSource(askResult.shadowedBy.source);
+      unreachable.push({
+        rule: allowRule,
+        reason: `Shadowed by "${askResult.shadowedBy.ruleValue.toolName}" ask rule (from ${shadowSource})`,
+        shadowedBy: askResult.shadowedBy,
+        shadowType: "ask",
+        fix: generateFixSuggestion("ask", askResult.shadowedBy, allowRule)
+      });
+    }
+  }
+  return unreachable;
+}
+var init_shadowedRuleDetection = __esm(() => {
+  init_toolName();
+  init_permissions();
+});
+
+export { detectUnreachableRules, init_shadowedRuleDetection };

package/dist/chunk-knzevfpr.js

@@ -0,0 +1,229 @@
+// @bun
+import {
+  getStoredChangelogFromMemory,
+  init_releaseNotes,
+  parseChangelog
+} from "./chunk-7cgwfdew.js";
+import {
+  init_sessionStorage,
+  loadMessageLogs
+} from "./chunk-730qrdey.js";
+import {
+  gt,
+  init_semver
+} from "./chunk-ps49ymvj.js";
+import {
+  getDisplayPath,
+  getInitialSettings,
+  getSubscriptionName,
+  init_auth,
+  init_file,
+  init_settings1 as init_settings,
+  isClaudeAISubscriber
+} from "./chunk-3tqnjgfx.js";
+import {
+  init_format,
+  init_stringWidth,
+  stringWidth,
+  truncate,
+  truncateToWidth,
+  truncateToWidthNoEllipsis
+} from "./chunk-wgcssf6v.js";
+import {
+  getCwd,
+  init_cwd
+} from "./chunk-8bedvdm1.js";
+import {
+  getDirectConnectServerUrl,
+  getSessionId,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/logoV2Utils.ts
+function getLayoutMode(columns) {
+  if (columns >= 70)
+    return "horizontal";
+  return "compact";
+}
+function calculateLayoutDimensions(columns, layoutMode, optimalLeftWidth) {
+  if (layoutMode === "horizontal") {
+    const leftWidth = optimalLeftWidth;
+    const usedSpace = BORDER_PADDING + CONTENT_PADDING + DIVIDER_WIDTH + leftWidth;
+    const availableForRight = columns - usedSpace;
+    let rightWidth = Math.max(30, availableForRight);
+    const totalWidth2 = Math.min(leftWidth + rightWidth + DIVIDER_WIDTH + CONTENT_PADDING, columns - BORDER_PADDING);
+    if (totalWidth2 < leftWidth + rightWidth + DIVIDER_WIDTH + CONTENT_PADDING) {
+      rightWidth = totalWidth2 - leftWidth - DIVIDER_WIDTH - CONTENT_PADDING;
+    }
+    return { leftWidth, rightWidth, totalWidth: totalWidth2 };
+  }
+  const totalWidth = Math.min(columns - BORDER_PADDING, MAX_LEFT_WIDTH + 20);
+  return {
+    leftWidth: totalWidth,
+    rightWidth: totalWidth,
+    totalWidth
+  };
+}
+function calculateOptimalLeftWidth(welcomeMessage, truncatedCwd, modelLine) {
+  const contentWidth = Math.max(stringWidth(welcomeMessage), stringWidth(truncatedCwd), stringWidth(modelLine), 20);
+  return Math.min(contentWidth + 4, MAX_LEFT_WIDTH);
+}
+function formatWelcomeMessage(username) {
+  if (!username || username.length > MAX_USERNAME_LENGTH) {
+    return "Welcome back!";
+  }
+  return `Welcome back ${username}!`;
+}
+function truncatePath(path, maxLength) {
+  if (stringWidth(path) <= maxLength)
+    return path;
+  const separator = "/";
+  const ellipsis = "\u2026";
+  const ellipsisWidth = 1;
+  const separatorWidth = 1;
+  const parts = path.split(separator);
+  const first = parts[0] || "";
+  const last = parts[parts.length - 1] || "";
+  const firstWidth = stringWidth(first);
+  const lastWidth = stringWidth(last);
+  if (parts.length === 1) {
+    return truncateToWidth(path, maxLength);
+  }
+  if (first === "" && ellipsisWidth + separatorWidth + lastWidth >= maxLength) {
+    return `${separator}${truncateToWidth(last, Math.max(1, maxLength - separatorWidth))}`;
+  }
+  if (first !== "" && ellipsisWidth * 2 + separatorWidth + lastWidth >= maxLength) {
+    return `${ellipsis}${separator}${truncateToWidth(last, Math.max(1, maxLength - ellipsisWidth - separatorWidth))}`;
+  }
+  if (parts.length === 2) {
+    const availableForFirst = maxLength - ellipsisWidth - separatorWidth - lastWidth;
+    return `${truncateToWidthNoEllipsis(first, availableForFirst)}${ellipsis}${separator}${last}`;
+  }
+  let available = maxLength - firstWidth - lastWidth - ellipsisWidth - 2 * separatorWidth;
+  if (available <= 0) {
+    const availableForFirst = Math.max(0, maxLength - lastWidth - ellipsisWidth - 2 * separatorWidth);
+    const truncatedFirst = truncateToWidthNoEllipsis(first, availableForFirst);
+    return `${truncatedFirst}${separator}${ellipsis}${separator}${last}`;
+  }
+  const middleParts = [];
+  for (let i = parts.length - 2;i > 0; i--) {
+    const part = parts[i];
+    if (part && stringWidth(part) + separatorWidth <= available) {
+      middleParts.unshift(part);
+      available -= stringWidth(part) + separatorWidth;
+    } else {
+      break;
+    }
+  }
+  if (middleParts.length === 0) {
+    return `${first}${separator}${ellipsis}${separator}${last}`;
+  }
+  return `${first}${separator}${ellipsis}${separator}${middleParts.join(separator)}${separator}${last}`;
+}
+async function getRecentActivity() {
+  if (cachePromise) {
+    return cachePromise;
+  }
+  const currentSessionId = getSessionId();
+  cachePromise = loadMessageLogs(10).then((logs) => {
+    cachedActivity = logs.filter((log) => {
+      if (log.isSidechain)
+        return false;
+      if (log.sessionId === currentSessionId)
+        return false;
+      if (log.summary?.includes("I apologize"))
+        return false;
+      const hasSummary = log.summary && log.summary !== "No prompt";
+      const hasFirstPrompt = log.firstPrompt && log.firstPrompt !== "No prompt";
+      return hasSummary || hasFirstPrompt;
+    }).slice(0, 3);
+    return cachedActivity;
+  }).catch(() => {
+    cachedActivity = [];
+    return cachedActivity;
+  });
+  return cachePromise;
+}
+function getRecentActivitySync() {
+  return cachedActivity;
+}
+function getLogoDisplayData() {
+  const version = process.env.DEMO_VERSION ?? "1.0.3-fork.1453470";
+  const serverUrl = getDirectConnectServerUrl();
+  const displayPath = process.env.DEMO_VERSION ? "/code/claude" : getDisplayPath(getCwd());
+  const cwd = serverUrl ? `${displayPath} in ${serverUrl.replace(/^https?:\/\//, "")}` : displayPath;
+  const billingType = isClaudeAISubscriber() ? getSubscriptionName() : "API Usage Billing";
+  const agentName = getInitialSettings().agent;
+  return {
+    version,
+    cwd,
+    billingType,
+    agentName
+  };
+}
+function formatModelAndBilling(modelName, billingType, availableWidth) {
+  const separator = " \xB7 ";
+  const combinedWidth = stringWidth(modelName) + separator.length + stringWidth(billingType);
+  const shouldSplit = combinedWidth > availableWidth;
+  if (shouldSplit) {
+    return {
+      shouldSplit: true,
+      truncatedModel: truncate(modelName, availableWidth),
+      truncatedBilling: truncate(billingType, availableWidth)
+    };
+  }
+  return {
+    shouldSplit: false,
+    truncatedModel: truncate(modelName, Math.max(availableWidth - stringWidth(billingType) - separator.length, 10)),
+    truncatedBilling: billingType
+  };
+}
+function getRecentReleaseNotesSync(maxItems) {
+  if (process.env.USER_TYPE === "ant") {
+    const changelog2 = "";
+    if (changelog2) {
+      const commits = changelog2.trim().split(`
+`).filter(Boolean);
+      return commits.slice(0, maxItems);
+    }
+    return [];
+  }
+  const changelog = getStoredChangelogFromMemory();
+  if (!changelog) {
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = parseChangelog(changelog);
+  } catch {
+    return [];
+  }
+  const allNotes = [];
+  const versions = Object.keys(parsed).sort((a, b) => gt(a, b) ? -1 : 1).slice(0, 3);
+  for (const version of versions) {
+    const notes = parsed[version];
+    if (notes) {
+      allNotes.push(...notes);
+    }
+  }
+  return allNotes.slice(0, maxItems);
+}
+var MAX_LEFT_WIDTH = 50, MAX_USERNAME_LENGTH = 20, BORDER_PADDING = 4, DIVIDER_WIDTH = 1, CONTENT_PADDING = 2, cachedActivity, cachePromise = null;
+var init_logoV2Utils = __esm(() => {
+  init_state();
+  init_stringWidth();
+  init_auth();
+  init_cwd();
+  init_file();
+  init_format();
+  init_releaseNotes();
+  init_semver();
+  init_sessionStorage();
+  init_settings();
+  cachedActivity = [];
+});
+
+export { getLayoutMode, calculateLayoutDimensions, calculateOptimalLeftWidth, formatWelcomeMessage, truncatePath, getRecentActivity, getRecentActivitySync, getLogoDisplayData, formatModelAndBilling, getRecentReleaseNotesSync, init_logoV2Utils };

package/dist/chunk-krw2vdg2.js

@@ -0,0 +1,44 @@
+// @bun
+import {
+  ThemedText,
+  init_ink,
+  require_compiler_runtime
+} from "./chunk-zp37prdd.js";
+import {
+  require_jsx_dev_runtime
+} from "./chunk-g338npwr.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/components/PressEnterToContinue.tsx
+function PressEnterToContinue() {
+  const $ = import_compiler_runtime.c(1);
+  let t0;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t0 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      color: "permission",
+      children: [
+        "Press ",
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          bold: true,
+          children: "Enter"
+        }, undefined, false, undefined, this),
+        " to continue\u2026"
+      ]
+    }, undefined, true, undefined, this);
+    $[0] = t0;
+  } else {
+    t0 = $[0];
+  }
+  return t0;
+}
+var import_compiler_runtime, jsx_dev_runtime;
+var init_PressEnterToContinue = __esm(() => {
+  init_ink();
+  import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+export { PressEnterToContinue, init_PressEnterToContinue };

package/dist/chunk-kwekc97v.js

@@ -0,0 +1,18 @@
+// @bun
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/rewind/rewind.ts
+async function call(_args, context) {
+  if (context.openMessageSelector) {
+    context.openMessageSelector();
+  }
+  return { type: "skip" };
+}
+var init_rewind = () => {};
+init_rewind();
+
+export {
+  call
+};