@vybestack/llxprt-code 0.10.0 → 0.11.0-nightly.260728.ffaa8d5d7

package/src/ui/hooks/useFolderTrust.ts

@@ -7,19 +7,32 @@
 import { useState, useCallback, useEffect, useRef } from 'react';
 import { ExitCodes } from '@vybestack/llxprt-code-core';
 import { DebugLogger } from '@vybestack/llxprt-code-telemetry';
-import type { LoadedSettings, Settings } from '../../config/settings.js';
+import type { LoadedSettings } from '../../config/settings.js';
 import { FolderTrustChoice } from '../components/FolderTrustDialog.js';
 import {
   loadTrustedFolders,
+  resolveLocalWorkspaceTrust,
   TrustLevel,
   isWorkspaceTrusted,
+  type TrustedFolderSnapshot,
 } from '../../config/trustedFolders.js';
 import { type HistoryItemWithoutId, MessageType } from '../types.js';
+import type { CliUiRuntime } from '../cliUiRuntime.js';
 import process from 'node:process';
+import {
+  combineTrustUpdateFailure,
+  getTrustCommitErrorMessage,
+} from '../trustDialogHelpers.js';
+
+export type FolderTrustRuntime = Pick<
+  CliUiRuntime,
+  'getWorkingDir' | 'setTrustedFolderLive' | 'isTrustedFolder'
+>;
 
 const debug = new DebugLogger('llxprt:ui:useFolderTrust');
 
 type AddItemFn = (item: HistoryItemWithoutId, timestamp: number) => number;
+type SetDialogOpenFn = (open: boolean) => void;
 
 function getTrustLevelFromChoice(choice: FolderTrustChoice): TrustLevel | null {
   switch (choice) {
@@ -34,39 +47,6 @@ function getTrustLevelFromChoice(choice: FolderTrustChoice): TrustLevel | null {
   }
 }
 
-function saveTrustLevel(
-  cwd: string,
-  trustLevel: TrustLevel,
-  addItem?: AddItemFn,
-): boolean {
-  try {
-    const trustedFolders = loadTrustedFolders();
-    trustedFolders.setValue(cwd, trustLevel);
-    return true;
-  } catch {
-    if (addItem) {
-      addItem(
-        {
-          type: MessageType.ERROR,
-          text: 'Failed to save trust settings. Exiting LLxprt Code.',
-        },
-        Date.now(),
-      );
-    }
-    setTimeout(() => {
-      process.exit(ExitCodes.FATAL_CONFIG_ERROR);
-    }, 100);
-    return false;
-  }
-}
-
-function computeNewTrustedState(trustLevel: TrustLevel): boolean {
-  return (
-    trustLevel === TrustLevel.TRUST_FOLDER ||
-    trustLevel === TrustLevel.TRUST_PARENT
-  );
-}
-
 function showStartupMessage(
   trusted: boolean | undefined = undefined,
   addItem: AddItemFn | undefined,
@@ -76,77 +56,134 @@ function showStartupMessage(
     debug.log(
       'Folder is untrusted - displaying permissions command hint on startup',
     );
-    if (addItem) {
-      addItem(
-        {
-          type: MessageType.INFO,
-          text: 'This folder is not trusted. Some features may be disabled. Use the `/permissions` command to change the trust level.',
-        },
-        Date.now(),
-      );
-    }
+    addItem?.(
+      {
+        type: MessageType.INFO,
+        text: 'This folder is not trusted. Some features may be disabled. Use the `/permissions` command to change the trust level.',
+      },
+      Date.now(),
+    );
     startupMessageSent.current = true;
   }
 }
 
+async function applyFolderTrustChoice(
+  choice: FolderTrustChoice,
+  settings: LoadedSettings,
+  config: FolderTrustRuntime | undefined,
+  addItem: AddItemFn | undefined,
+  setDialogOpen: SetDialogOpenFn,
+  mountedRef: React.MutableRefObject<boolean>,
+): Promise<void> {
+  const trustLevel = getTrustLevelFromChoice(choice);
+  if (trustLevel === null) {
+    return;
+  }
+  const workingDirectory = config?.getWorkingDir() ?? process.cwd();
+  let trustedFolders: ReturnType<typeof loadTrustedFolders> | undefined;
+  let savedSnapshot: TrustedFolderSnapshot | undefined;
+  let previousLiveTrust = false;
+  let failedPhase: 'persistence' | 'live' = 'persistence';
+  try {
+    trustedFolders = loadTrustedFolders();
+    savedSnapshot = trustedFolders.snapshotValue(workingDirectory);
+    previousLiveTrust = config?.isTrustedFolder() ?? false;
+    trustedFolders.setValue(workingDirectory, trustLevel);
+    const newIsTrusted =
+      resolveLocalWorkspaceTrust(
+        settings.merged,
+        trustedFolders,
+        workingDirectory,
+      ) ?? false;
+    failedPhase = 'live';
+    await config?.setTrustedFolderLive(newIsTrusted);
+    if (mountedRef.current) {
+      setDialogOpen(false);
+    }
+  } catch (error) {
+    const rollbackFailures: unknown[] = [];
+    if (trustedFolders !== undefined && savedSnapshot !== undefined) {
+      try {
+        trustedFolders.restoreSnapshot(savedSnapshot);
+      } catch (rollbackError) {
+        rollbackFailures.push(rollbackError);
+      }
+    }
+    if (failedPhase === 'live') {
+      try {
+        await config?.setTrustedFolderLive(previousLiveTrust);
+      } catch (rollbackError) {
+        rollbackFailures.push(rollbackError);
+      }
+    }
+    if (!mountedRef.current) {
+      return;
+    }
+    const failure = combineTrustUpdateFailure(
+      error,
+      rollbackFailures,
+      'Trust update and rollback failed',
+    );
+    const message = `${getTrustCommitErrorMessage(
+      failedPhase,
+      failure.error,
+      failure.rollbackSucceeded,
+    )} Exiting LLxprt Code.`;
+    debug.error(message);
+    addItem?.({ type: MessageType.ERROR, text: message }, Date.now());
+    setTimeout(() => process.exit(ExitCodes.FATAL_CONFIG_ERROR), 100);
+  }
+}
+
 export const useFolderTrust = (
   settings: LoadedSettings,
   addItem?: AddItemFn,
+  config?: FolderTrustRuntime,
 ) => {
-  // Folder trust feature flag removed - now using settings directly
   const { folderTrust } = settings.merged;
-  const initialTrust = isWorkspaceTrusted({ folderTrust } as Settings);
-  const [isTrusted, setIsTrusted] = useState<boolean | undefined>(initialTrust);
+  const initialTrust = isWorkspaceTrusted(
+    settings.merged,
+    config?.getWorkingDir() ?? process.cwd(),
+  );
   const [isFolderTrustDialogOpen, setIsFolderTrustDialogOpen] = useState(
     initialTrust === undefined,
   );
-  const [isRestarting, setIsRestarting] = useState(false);
   const startupMessageSent = useRef(false);
   const previousFolderTrust = useRef(folderTrust);
+  const mountedRef = useRef(true);
+
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
 
   useEffect(() => {
     const folderTrustChanged = previousFolderTrust.current !== folderTrust;
     previousFolderTrust.current = folderTrust;
-    const trusted = isWorkspaceTrusted({ folderTrust } as Settings);
+    const trusted = isWorkspaceTrusted(
+      settings.merged,
+      config?.getWorkingDir() ?? process.cwd(),
+    );
     if (folderTrustChanged) {
-      setIsTrusted(trusted);
       setIsFolderTrustDialogOpen(trusted === undefined);
     }
-
     showStartupMessage(trusted, addItem, startupMessageSent);
-  }, [folderTrust, addItem]);
+  }, [folderTrust, addItem, config, settings.merged]);
 
   const handleFolderTrustSelect = useCallback(
-    (choice: FolderTrustChoice) => {
-      const trustLevel = getTrustLevelFromChoice(choice);
-      if (trustLevel === null) {
-        return;
-      }
-
-      const cwd = process.cwd();
-      const wasTrusted = isTrusted ?? false;
-
-      if (!saveTrustLevel(cwd, trustLevel, addItem)) {
-        return;
-      }
-
-      const newIsTrusted = computeNewTrustedState(trustLevel);
-      setIsTrusted(newIsTrusted);
-
-      const needsRestart = wasTrusted !== newIsTrusted;
-      if (needsRestart) {
-        setIsRestarting(true);
-        setIsFolderTrustDialogOpen(true);
-      } else {
-        setIsFolderTrustDialogOpen(false);
-      }
-    },
-    [isTrusted, addItem],
+    (choice: FolderTrustChoice): Promise<void> =>
+      applyFolderTrustChoice(
+        choice,
+        settings,
+        config,
+        addItem,
+        setIsFolderTrustDialogOpen,
+        mountedRef,
+      ),
+    [addItem, config, settings],
   );
 
-  return {
-    isFolderTrustDialogOpen,
-    handleFolderTrustSelect,
-    isRestarting,
-  };
+  return { isFolderTrustDialogOpen, handleFolderTrustSelect };
 };

package/src/ui/hooks/useGitBranchName.ts

@@ -4,56 +4,97 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { useState, useEffect, useCallback } from 'react';
+import { useState, useEffect, useCallback, useRef } from 'react';
 import { exec } from 'node:child_process';
 import fs from 'node:fs';
 import fsPromises from 'node:fs/promises';
 import path from 'path';
 
+/**
+ * Debounce window for coalescing rapid reflog writes caused by compound
+ * git commands (e.g. `git checkout main && git fetch && git pull`). Without
+ * this, each write to `.git/logs/HEAD` spawns an overlapping `exec()`,
+ * increasing the chance that a stale result clobbers the latest branch name.
+ *
+ * 200ms was chosen empirically: compound git commands (checkout + fetch +
+ * pull) typically write the reflog 2-3 times within ~50ms. A 200ms window
+ * safely covers the burst while keeping the visible latency below a typical
+ * user's perception threshold. It is also well under the 3000ms fs.watchFile
+ * polling interval, so it never delays a legitimate single-command update
+ * beyond what the polling itself already imposes.
+ */
+const FETCH_DEBOUNCE_MS = 200;
+
+/** Exposed for tests so timing assertions track the production constant. */
+export { FETCH_DEBOUNCE_MS };
+
 export function useGitBranchName(cwd: string): string | undefined {
   const [branchName, setBranchName] = useState<string | undefined>(undefined);
 
-  const fetchBranchName = useCallback(
-    () =>
-      exec(
-        'git rev-parse --abbrev-ref HEAD',
-        { cwd },
-        (error, stdout, _stderr) => {
-          if (error) {
-            setBranchName(undefined);
-            return;
-          }
-          const branch = stdout.toString().trim();
-          if (branch && branch !== 'HEAD') {
-            setBranchName(branch);
-          } else {
-            exec(
-              'git rev-parse --short HEAD',
-              { cwd },
-              (error, stdout, _stderr) => {
-                if (error) {
-                  setBranchName(undefined);
-                  return;
-                }
-                setBranchName(stdout.toString().trim());
-              },
-            );
-          }
-        },
-      ),
-    [cwd, setBranchName],
-  );
+  // Monotonic token that guards against stale exec callbacks. Each fetch
+  // increments the token; when an exec callback fires, it only applies the
+  // result if its token still matches the latest one. This prevents an
+  // earlier-started exec (whose callback resolves after a newer one) from
+  // overwriting the branch name with a stale value.
+  const fetchTokenRef = useRef(0);
+  const debounceRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  const cancelledRef = useRef(false);
+
+  const fetchBranchName = useCallback(() => {
+    const token = ++fetchTokenRef.current;
+    exec(
+      'git rev-parse --abbrev-ref HEAD',
+      { cwd },
+      (error, stdout, _stderr) => {
+        if (cancelledRef.current || token !== fetchTokenRef.current) return;
+        if (error) {
+          setBranchName(undefined);
+          return;
+        }
+        const branch = stdout.toString().trim();
+        if (branch && branch !== 'HEAD') {
+          setBranchName(branch);
+        } else {
+          exec(
+            'git rev-parse --short HEAD',
+            { cwd },
+            (error, stdout, _stderr) => {
+              if (cancelledRef.current || token !== fetchTokenRef.current)
+                return;
+              if (error) {
+                setBranchName(undefined);
+                return;
+              }
+              setBranchName(stdout.toString().trim());
+            },
+          );
+        }
+      },
+    );
+  }, [cwd]);
+
+  const scheduleFetch = useCallback(() => {
+    if (debounceRef.current) {
+      clearTimeout(debounceRef.current);
+    }
+    debounceRef.current = setTimeout(() => {
+      debounceRef.current = null;
+      fetchBranchName();
+    }, FETCH_DEBOUNCE_MS);
+  }, [fetchBranchName]);
 
   useEffect(() => {
     fetchBranchName(); // Initial fetch
 
     const gitLogsHeadPath = path.join(cwd, '.git', 'logs', 'HEAD');
     let cancelled = false;
+    cancelledRef.current = false;
 
     const onGitLogsHeadChange = (curr: fs.Stats, prev: fs.Stats) => {
       if (cancelled) return;
       if (curr.mtimeMs !== prev.mtimeMs || curr.size !== prev.size) {
-        fetchBranchName();
+        scheduleFetch();
       }
     };
 
@@ -77,9 +118,14 @@ export function useGitBranchName(cwd: string): string | undefined {
 
     return () => {
       cancelled = true;
+      cancelledRef.current = true;
+      if (debounceRef.current) {
+        clearTimeout(debounceRef.current);
+        debounceRef.current = null;
+      }
       fs.unwatchFile(gitLogsHeadPath, onGitLogsHeadChange);
     };
-  }, [cwd, fetchBranchName]);
+  }, [cwd, fetchBranchName, scheduleFetch]);
 
   return branchName;
 }

package/src/ui/hooks/useIdeTrustListener.ts

@@ -4,17 +4,16 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { useCallback, useEffect, useState, useSyncExternalStore } from 'react';
+import { useCallback, useSyncExternalStore } from 'react';
 
 import { ideContext } from '@vybestack/llxprt-code-core';
 import type { IdeState } from '../cliUiRuntime.js';
 
 /**
- * This hook listens for trust status updates from the IDE companion extension.
- * It provides the current trust status from the IDE and a flag indicating
- * if a restart is needed because the trust state has changed.
+ * This hook listens for trust status updates from the IDE companion extension
+ * and provides the current IDE trust status.
  */
-export function useIdeTrustListener(ide: IdeState) {
+export function useIdeTrustListener(ide: Pick<IdeState, 'getIdeClient'>) {
   const subscribe = useCallback(
     (onStoreChange: () => void) => {
       const ideClient = ide.getIdeClient();
@@ -34,18 +33,5 @@ export function useIdeTrustListener(ide: IdeState) {
 
   const isIdeTrusted = useSyncExternalStore(subscribe, getSnapshot);
 
-  const [needsRestart, setNeedsRestart] = useState(false);
-  const [initialTrustValue] = useState(isIdeTrusted);
-
-  useEffect(() => {
-    if (
-      !needsRestart &&
-      initialTrustValue !== undefined &&
-      initialTrustValue !== isIdeTrusted
-    ) {
-      setNeedsRestart(true);
-    }
-  }, [isIdeTrusted, initialTrustValue, needsRestart]);
-
-  return { isIdeTrusted, needsRestart };
+  return { isIdeTrusted };
 }