@xortex/xcode 3.0.1 → 3.0.2

package/components/NativeAutoUpdater.tsx

@@ -0,0 +1,193 @@
+import * as React from 'react';
+import { useEffect, useRef, useState } from 'react';
+import { logEvent } from 'src/services/analytics/index.js';
+import { logForDebugging } from 'src/utils/debug.js';
+import { logError } from 'src/utils/log.js';
+import { useInterval } from 'usehooks-ts';
+import { useUpdateNotification } from '../hooks/useUpdateNotification.js';
+import { Box, Text } from '../ink.js';
+import type { AutoUpdaterResult } from '../utils/autoUpdater.js';
+import { getMaxVersion, getMaxVersionMessage } from '../utils/autoUpdater.js';
+import { isAutoUpdaterDisabled } from '../utils/config.js';
+import { installLatest } from '../utils/nativeInstaller/index.js';
+import { gt } from '../utils/semver.js';
+import { getInitialSettings } from '../utils/settings/settings.js';
+
+/**
+ * Categorize error messages for analytics
+ */
+function getErrorType(errorMessage: string): string {
+  if (errorMessage.includes('timeout')) {
+    return 'timeout';
+  }
+  if (errorMessage.includes('Checksum mismatch')) {
+    return 'checksum_mismatch';
+  }
+  if (errorMessage.includes('ENOENT') || errorMessage.includes('not found')) {
+    return 'not_found';
+  }
+  if (errorMessage.includes('EACCES') || errorMessage.includes('permission')) {
+    return 'permission_denied';
+  }
+  if (errorMessage.includes('ENOSPC')) {
+    return 'disk_full';
+  }
+  if (errorMessage.includes('npm')) {
+    return 'npm_error';
+  }
+  if (errorMessage.includes('network') || errorMessage.includes('ECONNREFUSED') || errorMessage.includes('ENOTFOUND')) {
+    return 'network_error';
+  }
+  return 'unknown';
+}
+type Props = {
+  isUpdating: boolean;
+  onChangeIsUpdating: (isUpdating: boolean) => void;
+  onAutoUpdaterResult: (autoUpdaterResult: AutoUpdaterResult) => void;
+  autoUpdaterResult: AutoUpdaterResult | null;
+  showSuccessMessage: boolean;
+  verbose: boolean;
+};
+export function NativeAutoUpdater({
+  isUpdating,
+  onChangeIsUpdating,
+  onAutoUpdaterResult,
+  autoUpdaterResult,
+  showSuccessMessage,
+  verbose
+}: Props): React.ReactNode {
+  const [versions, setVersions] = useState<{
+    current?: string | null;
+    latest?: string | null;
+  }>({});
+  const [maxVersionIssue, setMaxVersionIssue] = useState<string | null>(null);
+  const updateSemver = useUpdateNotification(autoUpdaterResult?.version);
+  const channel = getInitialSettings()?.autoUpdatesChannel ?? 'latest';
+
+  // Track latest isUpdating value in a ref so the memoized checkForUpdates
+  // callback always sees the current value without changing callback identity
+  // (which would re-trigger the initial-check useEffect below and cause
+  // repeated downloads on remount — the upstream trigger for #22413).
+  const isUpdatingRef = useRef(isUpdating);
+  isUpdatingRef.current = isUpdating;
+  const checkForUpdates = React.useCallback(async () => {
+    if (isUpdatingRef.current) {
+      return;
+    }
+    if ("production" === 'test' || "production" === 'development') {
+      logForDebugging('NativeAutoUpdater: Skipping update check in test/dev environment');
+      return;
+    }
+    if (isAutoUpdaterDisabled()) {
+      return;
+    }
+    onChangeIsUpdating(true);
+    const startTime = Date.now();
+
+    // Log the start of an auto-update check for funnel analysis
+    logEvent('tengu_native_auto_updater_start', {});
+    try {
+      // Check if current version is above the max allowed version
+      const maxVersion = await getMaxVersion();
+      if (maxVersion && gt(MACRO.VERSION, maxVersion)) {
+        const msg = await getMaxVersionMessage();
+        setMaxVersionIssue(msg ?? 'affects your version');
+      }
+      const result = await installLatest(channel);
+      const currentVersion = MACRO.VERSION;
+      const latencyMs = Date.now() - startTime;
+
+      // Handle lock contention gracefully - just return without treating as error
+      if (result.lockFailed) {
+        logEvent('tengu_native_auto_updater_lock_contention', {
+          latency_ms: latencyMs
+        });
+        return; // Silently skip this update check, will try again later
+      }
+
+      // Update versions for display
+      setVersions({
+        current: currentVersion,
+        latest: result.latestVersion
+      });
+      if (result.wasUpdated) {
+        logEvent('tengu_native_auto_updater_success', {
+          latency_ms: latencyMs
+        });
+        onAutoUpdaterResult({
+          version: result.latestVersion,
+          status: 'success'
+        });
+      } else {
+        // Already up to date
+        logEvent('tengu_native_auto_updater_up_to_date', {
+          latency_ms: latencyMs
+        });
+      }
+    } catch (error) {
+      const latencyMs = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logError(error);
+      const errorType = getErrorType(errorMessage);
+      logEvent('tengu_native_auto_updater_fail', {
+        latency_ms: latencyMs,
+        error_timeout: errorType === 'timeout',
+        error_checksum: errorType === 'checksum_mismatch',
+        error_not_found: errorType === 'not_found',
+        error_permission: errorType === 'permission_denied',
+        error_disk_full: errorType === 'disk_full',
+        error_npm: errorType === 'npm_error',
+        error_network: errorType === 'network_error'
+      });
+      onAutoUpdaterResult({
+        version: null,
+        status: 'install_failed'
+      });
+    } finally {
+      onChangeIsUpdating(false);
+    }
+    // isUpdating intentionally omitted from deps; we read isUpdatingRef
+    // instead so the guard is always current without changing callback
+    // identity (which would re-trigger the initial-check useEffect below).
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    // biome-ignore lint/correctness/useExhaustiveDependencies: isUpdating read via ref
+  }, [onAutoUpdaterResult, channel]);
+
+  // Initial check
+  useEffect(() => {
+    void checkForUpdates();
+  }, [checkForUpdates]);
+
+  // Check every 30 minutes
+  useInterval(checkForUpdates, 30 * 60 * 1000);
+  const hasUpdateResult = !!autoUpdaterResult?.version;
+  const hasVersionInfo = !!versions.current && !!versions.latest;
+  // Show the component when:
+  // - warning banner needed (above max version), or
+  // - there's an update result to display (success/error), or
+  // - actively checking and we have version info to show
+  const shouldRender = !!maxVersionIssue || hasUpdateResult || isUpdating && hasVersionInfo;
+  if (!shouldRender) {
+    return null;
+  }
+  return <Box flexDirection="row" gap={1}>
+      {verbose && <Text dimColor wrap="truncate">
+          current: {versions.current} &middot; {channel}: {versions.latest}
+        </Text>}
+      {isUpdating ? <Box>
+          <Text dimColor wrap="truncate">
+            Checking for updates
+          </Text>
+        </Box> : autoUpdaterResult?.status === 'success' && showSuccessMessage && updateSemver && <Text color="success" wrap="truncate">
+            ✓ Update installed · Restart to update
+          </Text>}
+      {autoUpdaterResult?.status === 'install_failed' && <Text color="error" wrap="truncate">
+          ✗ Auto-update failed &middot; Try <Text bold>/status</Text>
+        </Text>}
+      {maxVersionIssue && "external" === 'ant' && <Text color="warning">
+          ⚠ Known issue: {maxVersionIssue} &middot; Run{' '}
+          <Text bold>claude rollback --safe</Text> to downgrade
+        </Text>}
+    </Box>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useEffect","useRef","useState","logEvent","logForDebugging","logError","useInterval","useUpdateNotification","Box","Text","AutoUpdaterResult","getMaxVersion","getMaxVersionMessage","isAutoUpdaterDisabled","installLatest","gt","getInitialSettings","getErrorType","errorMessage","includes","Props","isUpdating","onChangeIsUpdating","onAutoUpdaterResult","autoUpdaterResult","showSuccessMessage","verbose","NativeAutoUpdater","ReactNode","versions","setVersions","current","latest","maxVersionIssue","setMaxVersionIssue","updateSemver","version","channel","autoUpdatesChannel","isUpdatingRef","checkForUpdates","useCallback","startTime","Date","now","maxVersion","MACRO","VERSION","msg","result","currentVersion","latencyMs","lockFailed","latency_ms","latestVersion","wasUpdated","status","error","Error","message","String","errorType","error_timeout","error_checksum","error_not_found","error_permission","error_disk_full","error_npm","error_network","hasUpdateResult","hasVersionInfo","shouldRender"],"sources":["NativeAutoUpdater.tsx"],"sourcesContent":["import * as React from 'react'\nimport { useEffect, useRef, useState } from 'react'\nimport { logEvent } from 'src/services/analytics/index.js'\nimport { logForDebugging } from 'src/utils/debug.js'\nimport { logError } from 'src/utils/log.js'\nimport { useInterval } from 'usehooks-ts'\nimport { useUpdateNotification } from '../hooks/useUpdateNotification.js'\nimport { Box, Text } from '../ink.js'\nimport type { AutoUpdaterResult } from '../utils/autoUpdater.js'\nimport { getMaxVersion, getMaxVersionMessage } from '../utils/autoUpdater.js'\nimport { isAutoUpdaterDisabled } from '../utils/config.js'\nimport { installLatest } from '../utils/nativeInstaller/index.js'\nimport { gt } from '../utils/semver.js'\nimport { getInitialSettings } from '../utils/settings/settings.js'\n\n/**\n * Categorize error messages for analytics\n */\nfunction getErrorType(errorMessage: string): string {\n  if (errorMessage.includes('timeout')) {\n    return 'timeout'\n  }\n  if (errorMessage.includes('Checksum mismatch')) {\n    return 'checksum_mismatch'\n  }\n  if (errorMessage.includes('ENOENT') || errorMessage.includes('not found')) {\n    return 'not_found'\n  }\n  if (errorMessage.includes('EACCES') || errorMessage.includes('permission')) {\n    return 'permission_denied'\n  }\n  if (errorMessage.includes('ENOSPC')) {\n    return 'disk_full'\n  }\n  if (errorMessage.includes('npm')) {\n    return 'npm_error'\n  }\n  if (\n    errorMessage.includes('network') ||\n    errorMessage.includes('ECONNREFUSED') ||\n    errorMessage.includes('ENOTFOUND')\n  ) {\n    return 'network_error'\n  }\n  return 'unknown'\n}\n\ntype Props = {\n  isUpdating: boolean\n  onChangeIsUpdating: (isUpdating: boolean) => void\n  onAutoUpdaterResult: (autoUpdaterResult: AutoUpdaterResult) => void\n  autoUpdaterResult: AutoUpdaterResult | null\n  showSuccessMessage: boolean\n  verbose: boolean\n}\n\nexport function NativeAutoUpdater({\n  isUpdating,\n  onChangeIsUpdating,\n  onAutoUpdaterResult,\n  autoUpdaterResult,\n  showSuccessMessage,\n  verbose,\n}: Props): React.ReactNode {\n  const [versions, setVersions] = useState<{\n    current?: string | null\n    latest?: string | null\n  }>({})\n  const [maxVersionIssue, setMaxVersionIssue] = useState<string | null>(null)\n  const updateSemver = useUpdateNotification(autoUpdaterResult?.version)\n  const channel = getInitialSettings()?.autoUpdatesChannel ?? 'latest'\n\n  // Track latest isUpdating value in a ref so the memoized checkForUpdates\n  // callback always sees the current value without changing callback identity\n  // (which would re-trigger the initial-check useEffect below and cause\n  // repeated downloads on remount — the upstream trigger for #22413).\n  const isUpdatingRef = useRef(isUpdating)\n  isUpdatingRef.current = isUpdating\n\n  const checkForUpdates = React.useCallback(async () => {\n    if (isUpdatingRef.current) {\n      return\n    }\n\n    if (\n      \"production\" === 'test' ||\n      \"production\" === 'development'\n    ) {\n      logForDebugging(\n        'NativeAutoUpdater: Skipping update check in test/dev environment',\n      )\n      return\n    }\n\n    if (isAutoUpdaterDisabled()) {\n      return\n    }\n\n    onChangeIsUpdating(true)\n    const startTime = Date.now()\n\n    // Log the start of an auto-update check for funnel analysis\n    logEvent('tengu_native_auto_updater_start', {})\n\n    try {\n      // Check if current version is above the max allowed version\n      const maxVersion = await getMaxVersion()\n      if (maxVersion && gt(MACRO.VERSION, maxVersion)) {\n        const msg = await getMaxVersionMessage()\n        setMaxVersionIssue(msg ?? 'affects your version')\n      }\n\n      const result = await installLatest(channel)\n      const currentVersion = MACRO.VERSION\n      const latencyMs = Date.now() - startTime\n\n      // Handle lock contention gracefully - just return without treating as error\n      if (result.lockFailed) {\n        logEvent('tengu_native_auto_updater_lock_contention', {\n          latency_ms: latencyMs,\n        })\n        return // Silently skip this update check, will try again later\n      }\n\n      // Update versions for display\n      setVersions({ current: currentVersion, latest: result.latestVersion })\n\n      if (result.wasUpdated) {\n        logEvent('tengu_native_auto_updater_success', {\n          latency_ms: latencyMs,\n        })\n\n        onAutoUpdaterResult({\n          version: result.latestVersion,\n          status: 'success',\n        })\n      } else {\n        // Already up to date\n        logEvent('tengu_native_auto_updater_up_to_date', {\n          latency_ms: latencyMs,\n        })\n      }\n    } catch (error) {\n      const latencyMs = Date.now() - startTime\n      const errorMessage =\n        error instanceof Error ? error.message : String(error)\n      logError(error)\n\n      const errorType = getErrorType(errorMessage)\n      logEvent('tengu_native_auto_updater_fail', {\n        latency_ms: latencyMs,\n        error_timeout: errorType === 'timeout',\n        error_checksum: errorType === 'checksum_mismatch',\n        error_not_found: errorType === 'not_found',\n        error_permission: errorType === 'permission_denied',\n        error_disk_full: errorType === 'disk_full',\n        error_npm: errorType === 'npm_error',\n        error_network: errorType === 'network_error',\n      })\n\n      onAutoUpdaterResult({\n        version: null,\n        status: 'install_failed',\n      })\n    } finally {\n      onChangeIsUpdating(false)\n    }\n    // isUpdating intentionally omitted from deps; we read isUpdatingRef\n    // instead so the guard is always current without changing callback\n    // identity (which would re-trigger the initial-check useEffect below).\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    // biome-ignore lint/correctness/useExhaustiveDependencies: isUpdating read via ref\n  }, [onAutoUpdaterResult, channel])\n\n  // Initial check\n  useEffect(() => {\n    void checkForUpdates()\n  }, [checkForUpdates])\n\n  // Check every 30 minutes\n  useInterval(checkForUpdates, 30 * 60 * 1000)\n\n  const hasUpdateResult = !!autoUpdaterResult?.version\n  const hasVersionInfo = !!versions.current && !!versions.latest\n  // Show the component when:\n  // - warning banner needed (above max version), or\n  // - there's an update result to display (success/error), or\n  // - actively checking and we have version info to show\n  const shouldRender =\n    !!maxVersionIssue || hasUpdateResult || (isUpdating && hasVersionInfo)\n\n  if (!shouldRender) {\n    return null\n  }\n\n  return (\n    <Box flexDirection=\"row\" gap={1}>\n      {verbose && (\n        <Text dimColor wrap=\"truncate\">\n          current: {versions.current} &middot; {channel}: {versions.latest}\n        </Text>\n      )}\n      {isUpdating ? (\n        <Box>\n          <Text dimColor wrap=\"truncate\">\n            Checking for updates\n          </Text>\n        </Box>\n      ) : (\n        autoUpdaterResult?.status === 'success' &&\n        showSuccessMessage &&\n        updateSemver && (\n          <Text color=\"success\" wrap=\"truncate\">\n            ✓ Update installed · Restart to update\n          </Text>\n        )\n      )}\n      {autoUpdaterResult?.status === 'install_failed' && (\n        <Text color=\"error\" wrap=\"truncate\">\n          ✗ Auto-update failed &middot; Try <Text bold>/status</Text>\n        </Text>\n      )}\n      {maxVersionIssue && \"external\" === 'ant' && (\n        <Text color=\"warning\">\n          ⚠ Known issue: {maxVersionIssue} &middot; Run{' '}\n          <Text bold>claude rollback --safe</Text> to downgrade\n        </Text>\n      )}\n    </Box>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/components/NotebookEditToolUseRejectedMessage.tsx

@@ -0,0 +1,92 @@
+import { c as _c } from "react/compiler-runtime";
+import { relative } from 'path';
+import * as React from 'react';
+import { getCwd } from 'src/utils/cwd.js';
+import { Box, Text } from '../ink.js';
+import { HighlightedCode } from './HighlightedCode.js';
+import { MessageResponse } from './MessageResponse.js';
+type Props = {
+  notebook_path: string;
+  cell_id: string | undefined;
+  new_source: string;
+  cell_type?: 'code' | 'markdown';
+  edit_mode?: 'replace' | 'insert' | 'delete';
+  verbose: boolean;
+};
+export function NotebookEditToolUseRejectedMessage(t0) {
+  const $ = _c(20);
+  const {
+    notebook_path,
+    cell_id,
+    new_source,
+    cell_type,
+    edit_mode: t1,
+    verbose
+  } = t0;
+  const edit_mode = t1 === undefined ? "replace" : t1;
+  const operation = edit_mode === "delete" ? "delete" : `${edit_mode} cell in`;
+  let t2;
+  if ($[0] !== operation) {
+    t2 = <Text color="subtle">User rejected {operation} </Text>;
+    $[0] = operation;
+    $[1] = t2;
+  } else {
+    t2 = $[1];
+  }
+  let t3;
+  if ($[2] !== notebook_path || $[3] !== verbose) {
+    t3 = verbose ? notebook_path : relative(getCwd(), notebook_path);
+    $[2] = notebook_path;
+    $[3] = verbose;
+    $[4] = t3;
+  } else {
+    t3 = $[4];
+  }
+  let t4;
+  if ($[5] !== t3) {
+    t4 = <Text bold={true} color="subtle">{t3}</Text>;
+    $[5] = t3;
+    $[6] = t4;
+  } else {
+    t4 = $[6];
+  }
+  let t5;
+  if ($[7] !== cell_id) {
+    t5 = <Text color="subtle"> at cell {cell_id}</Text>;
+    $[7] = cell_id;
+    $[8] = t5;
+  } else {
+    t5 = $[8];
+  }
+  let t6;
+  if ($[9] !== t2 || $[10] !== t4 || $[11] !== t5) {
+    t6 = <Box flexDirection="row">{t2}{t4}{t5}</Box>;
+    $[9] = t2;
+    $[10] = t4;
+    $[11] = t5;
+    $[12] = t6;
+  } else {
+    t6 = $[12];
+  }
+  let t7;
+  if ($[13] !== cell_type || $[14] !== edit_mode || $[15] !== new_source) {
+    t7 = edit_mode !== "delete" && <Box marginTop={1} flexDirection="column"><HighlightedCode code={new_source} filePath={cell_type === "markdown" ? "file.md" : "file.py"} dim={true} /></Box>;
+    $[13] = cell_type;
+    $[14] = edit_mode;
+    $[15] = new_source;
+    $[16] = t7;
+  } else {
+    t7 = $[16];
+  }
+  let t8;
+  if ($[17] !== t6 || $[18] !== t7) {
+    t8 = <MessageResponse><Box flexDirection="column">{t6}{t7}</Box></MessageResponse>;
+    $[17] = t6;
+    $[18] = t7;
+    $[19] = t8;
+  } else {
+    t8 = $[19];
+  }
+  return t8;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/components/OffscreenFreeze.tsx

@@ -0,0 +1,44 @@
+import React, { useContext, useRef } from 'react';
+import { useTerminalViewport } from '../ink/hooks/use-terminal-viewport.js';
+import { Box } from '../ink.js';
+import { InVirtualListContext } from './messageActions.js';
+type Props = {
+  children: React.ReactNode;
+};
+
+/**
+ * Freezes children when they scroll above the terminal viewport (into scrollback).
+ *
+ * Any content change above the viewport forces log-update.ts into a full terminal
+ * reset (it cannot partially update rows that have scrolled out). For content that
+ * updates on a timer — spinners, elapsed counters — this produces a reset per tick.
+ *
+ * When offscreen, returns the same ReactElement reference that was cached during
+ * the last visible render. React's reconciler bails on identical element refs, so
+ * the subtree never re-renders, producing zero diff.
+ *
+ * The cache is one slot deep: the first re-render after scrolling back into view
+ * picks up the live children. Content still updates normally while visible.
+ */
+export function OffscreenFreeze({
+  children
+}: Props): React.ReactNode {
+  // React Compiler: reading cached.current in the return is the entire
+  // freeze mechanism — memoizing this component would defeat it. Opt out.
+  'use no memo';
+
+  const inVirtualList = useContext(InVirtualListContext);
+  const [ref, {
+    isVisible
+  }] = useTerminalViewport();
+  const cached = useRef(children);
+  // Virtual list has no terminal scrollback — the ScrollBox clips inside the
+  // viewport, so there's nothing to freeze. Freezing there also blocks
+  // click-to-expand since useTerminalViewport's visibility calc can disagree
+  // with the ScrollBox's virtual scroll position.
+  if (isVisible || inVirtualList) {
+    cached.current = children;
+  }
+  return <Box ref={ref}>{cached.current}</Box>;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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