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

package/src/ui/hooks/usePermissionsModifyTrust.ts

@@ -4,28 +4,71 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { useState, useCallback, useMemo } from 'react';
+import { useState, useCallback, useEffect, useMemo, useRef } from 'react';
 import * as path from 'node:path';
-import type { LoadedTrustedFolders } from '../../config/trustedFolders.js';
-import { loadTrustedFolders, TrustLevel } from '../../config/trustedFolders.js';
-import { useSettings } from '../contexts/SettingsContext.js';
-import { getIdeTrust } from '@vybestack/llxprt-code-core';
+import {
+  loadTrustedFolders,
+  resolveLocalWorkspaceTrust,
+  type LoadedTrustedFolders,
+  TrustLevel,
+  type TrustedFolderSnapshot,
+} from '../../config/trustedFolders.js';
+import type { CliUiRuntime } from '../cliUiRuntime.js';
+import { useIdeTrustListener } from './useIdeTrustListener.js';
+import { combineTrustUpdateFailure } from '../trustDialogHelpers.js';
+import process from 'node:process';
+
+export type PermissionsTrustRuntime = Pick<
+  CliUiRuntime,
+  | 'getWorkingDir'
+  | 'getFolderTrust'
+  | 'getIdeClient'
+  | 'isTrustedFolder'
+  | 'setTrustedFolderLive'
+>;
+
+const emptyIdeState: Pick<PermissionsTrustRuntime, 'getIdeClient'> = {
+  getIdeClient: () => undefined,
+};
+
+function useMountedRef() {
+  const mountedRef = useRef(true);
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  return mountedRef;
+}
 
 export interface UsePermissionsModifyTrustReturn {
-  /** Current trust level for the working directory */
-  currentTrustLevel: TrustLevel | undefined;
   /** Pending trust level change (before commit) */
   pendingTrustLevel: TrustLevel | undefined;
   /** Set a pending trust level change */
   setPendingTrustLevel: (level: TrustLevel) => void;
   /** Commit the pending trust level change */
-  commitTrustLevel: (level?: TrustLevel) => void;
+  commitTrustLevel: (level?: TrustLevel) => Promise<
+    | { success: true }
+    | {
+        success: false;
+        phase: 'persistence' | 'live';
+        error: unknown;
+        rollbackSucceeded: boolean;
+      }
+  >;
+  /** Effective local trust level, including inherited rules */
+  effectiveLocalTrustLevel: TrustLevel | undefined;
   /** Whether the workspace is trusted through IDE */
-  isIdeTrusted: boolean;
-  /** Whether the workspace is trusted through parent folder */
+  isIdeTrusted: boolean | undefined;
+  /** Whether the winning local rule is inherited */
   isParentTrusted: boolean;
-  /** Whether a restart is required after committing */
-  requiresRestart: boolean;
+  /** Whether a trust change was committed */
+  trustChanged: boolean;
+  /** The local trust level saved during this dialog session */
+  committedTrustLevel: TrustLevel | undefined;
+  /** The live effective trust state after the change */
+  effectiveTrust: boolean | undefined;
   /** The current working directory */
   workingDirectory: string;
   /** The parent folder name */
@@ -34,101 +77,196 @@ export interface UsePermissionsModifyTrustReturn {
   trustedFolders: LoadedTrustedFolders;
 }
 
-/**
- * Hook that manages folder trust settings for the permissions dialog.
- * Handles current trust level state, pending changes, inherited trust detection,
- * and restart requirement detection.
- */
-export function usePermissionsModifyTrust(): UsePermissionsModifyTrustReturn {
-  const settings = useSettings();
-  const cwd = process.cwd();
-  const parentFolderName = path.basename(path.dirname(cwd));
-
-  const trustedFolders = useMemo(() => loadTrustedFolders(), []);
-
-  // Determine current trust level for the working directory
-  const currentTrustLevel = useMemo((): TrustLevel | undefined => {
-    // Find exact match for current directory
-    const rule = trustedFolders.rules.find(
-      (r) => path.normalize(r.path) === path.normalize(cwd),
-    );
-    return rule?.trustLevel;
-  }, [trustedFolders, cwd]);
+function restoreSavedTrustLevel(
+  trustedFolders: LoadedTrustedFolders,
+  snapshot: TrustedFolderSnapshot,
+): void {
+  trustedFolders.restoreSnapshot(snapshot);
+}
 
-  // Check if trusted through IDE
-  const isIdeTrusted = useMemo(() => {
-    const ideTrust = getIdeTrust();
-    return ideTrust === true;
-  }, []);
+async function applyLiveTrustLevel(
+  config: PermissionsTrustRuntime,
+  trustedFolders: LoadedTrustedFolders,
+  folderPath: string,
+): Promise<boolean> {
+  await config.setTrustedFolderLive(
+    resolveLocalWorkspaceTrust(
+      { folderTrust: config.getFolderTrust() },
+      trustedFolders,
+      folderPath,
+    ) ?? false,
+  );
+  return config.isTrustedFolder();
+}
 
-  // Check if trusted through parent folder
-  const isParentTrusted = useMemo(() => {
-    if (isIdeTrusted) return false;
+type TrustCommitResult =
+  | { success: true }
+  | {
+      success: false;
+      phase: 'persistence' | 'live';
+      error: unknown;
+      rollbackSucceeded: boolean;
+    };
 
-    // Check if any parent rule would trust this directory
-    for (const rule of trustedFolders.rules) {
-      if (rule.trustLevel === TrustLevel.TRUST_PARENT) {
-        const parentPath = path.dirname(rule.path);
-        if (path.normalize(cwd).startsWith(path.normalize(parentPath))) {
-          return true;
-        }
-      }
-      if (rule.trustLevel === TrustLevel.TRUST_FOLDER) {
-        const normalizedRulePath = path.normalize(rule.path);
-        const normalizedCwd = path.normalize(cwd);
-        if (
-          normalizedCwd.startsWith(normalizedRulePath) &&
-          normalizedCwd !== normalizedRulePath
-        ) {
-          return true;
-        }
-      }
+async function commitSavedTrustLevel(
+  config: PermissionsTrustRuntime | undefined,
+  trustedFolders: LoadedTrustedFolders,
+  folderPath: string,
+  nextLevel: TrustLevel,
+): Promise<{ result: TrustCommitResult; effectiveTrust?: boolean }> {
+  let savedSnapshot: TrustedFolderSnapshot;
+  try {
+    savedSnapshot = trustedFolders.snapshotValue(folderPath);
+  } catch (error) {
+    return {
+      result: {
+        success: false,
+        phase: 'persistence',
+        error,
+        rollbackSucceeded: true,
+      },
+    };
+  }
+  const previousLiveTrust = config?.isTrustedFolder() ?? false;
+  try {
+    trustedFolders.setValue(folderPath, nextLevel);
+  } catch (error) {
+    return {
+      result: {
+        success: false,
+        phase: 'persistence',
+        error,
+        rollbackSucceeded: true,
+      },
+    };
+  }
+  if (config === undefined) {
+    return {
+      result: { success: true },
+      effectiveTrust: nextLevel !== TrustLevel.DO_NOT_TRUST,
+    };
+  }
+  try {
+    return {
+      result: { success: true },
+      effectiveTrust: await applyLiveTrustLevel(
+        config,
+        trustedFolders,
+        folderPath,
+      ),
+    };
+  } catch (error) {
+    const rollbackFailures: unknown[] = [];
+    try {
+      restoreSavedTrustLevel(trustedFolders, savedSnapshot);
+    } catch (rollbackError) {
+      rollbackFailures.push(rollbackError);
     }
-    return false;
-  }, [trustedFolders, cwd, isIdeTrusted]);
+    try {
+      await config.setTrustedFolderLive(previousLiveTrust);
+    } catch (rollbackError) {
+      rollbackFailures.push(rollbackError);
+    }
+    const failure = combineTrustUpdateFailure(
+      error,
+      rollbackFailures,
+      'Live trust update and rollback failed',
+    );
+    return {
+      result: {
+        success: false,
+        phase: 'live',
+        error: failure.error,
+        rollbackSucceeded: failure.rollbackSucceeded,
+      },
+    };
+  }
+}
 
+/**
+ * Hook that manages folder trust settings for the permissions dialog.
+ * Handles current trust level state, pending changes, inherited trust detection,
+ * and live Config updates via setTrustedFolderLive.
+ */
+export function usePermissionsModifyTrust(
+  config?: PermissionsTrustRuntime,
+): UsePermissionsModifyTrustReturn {
+  const normalizedCwd = path.resolve(config?.getWorkingDir() ?? process.cwd());
+  const trustedFolders = useMemo(() => loadTrustedFolders(), []);
+  const winningRule = trustedFolders.resolvePathTrust(normalizedCwd);
+  const currentEffectiveTrust =
+    config?.isTrustedFolder() ?? winningRule?.trusted;
+  const { isIdeTrusted } = useIdeTrustListener(config ?? emptyIdeState);
+  const isParentTrusted =
+    isIdeTrusted === undefined && winningRule?.provenance === 'inherited';
   const [pendingTrustLevel, setPendingTrustLevel] = useState<
     TrustLevel | undefined
-  >(currentTrustLevel);
-
-  const [hasCommitted, setHasCommitted] = useState(false);
-
+  >(() => trustedFolders.getValue(normalizedCwd));
+  const [committedLevel, setCommittedLevel] = useState<TrustLevel>();
+  const [effectiveTrust, setEffectiveTrust] = useState(currentEffectiveTrust);
+  const commitQueueRef = useRef<Promise<void>>(Promise.resolve());
+  const mountedRef = useMountedRef();
+  const currentWorkingDirectoryRef = useRef(normalizedCwd);
+  currentWorkingDirectoryRef.current = normalizedCwd;
+  useEffect(() => {
+    setPendingTrustLevel(trustedFolders.getValue(normalizedCwd));
+    setCommittedLevel(undefined);
+  }, [normalizedCwd, trustedFolders]);
+  useEffect(
+    () => setEffectiveTrust(currentEffectiveTrust),
+    [currentEffectiveTrust],
+  );
   const commitTrustLevel = useCallback(
-    (level?: TrustLevel) => {
+    (level?: TrustLevel): Promise<TrustCommitResult> => {
       const nextLevel = level ?? pendingTrustLevel;
       if (nextLevel === undefined) {
-        return;
+        return Promise.resolve({ success: true });
       }
 
-      setPendingTrustLevel(nextLevel);
-      trustedFolders.setValue(cwd, nextLevel);
-      setHasCommitted(true);
+      const runCommit = async (): Promise<TrustCommitResult> => {
+        const commit = await commitSavedTrustLevel(
+          config,
+          trustedFolders,
+          normalizedCwd,
+          nextLevel,
+        );
+        if (!commit.result.success) {
+          return commit.result;
+        }
+        if (
+          mountedRef.current &&
+          currentWorkingDirectoryRef.current === normalizedCwd
+        ) {
+          setEffectiveTrust(commit.effectiveTrust);
+          setPendingTrustLevel(nextLevel);
+          setCommittedLevel(nextLevel);
+        }
+        return { success: true };
+      };
+      const commit = commitQueueRef.current.then(runCommit, runCommit);
+      commitQueueRef.current = commit.then(
+        () => undefined,
+        () => undefined,
+      );
+      return commit;
     },
-    [pendingTrustLevel, trustedFolders, cwd],
+    [pendingTrustLevel, trustedFolders, normalizedCwd, config, mountedRef],
   );
 
-  // Determine if restart is required after committing
-  const requiresRestart = useMemo(() => {
-    if (!hasCommitted) return false;
-
-    // Check if folder trust feature is enabled
-    const folderTrustEnabled = settings.merged.folderTrust ?? false;
-    if (!folderTrustEnabled) return false;
-
-    // A restart is required if we changed the trust level
-    return pendingTrustLevel !== currentTrustLevel;
-  }, [hasCommitted, pendingTrustLevel, currentTrustLevel, settings]);
+  const trustChanged = committedLevel !== undefined;
 
   return {
-    currentTrustLevel,
     pendingTrustLevel,
     setPendingTrustLevel,
     commitTrustLevel,
+    effectiveLocalTrustLevel: winningRule?.rule.trustLevel,
     isIdeTrusted,
     isParentTrusted,
-    requiresRestart,
-    workingDirectory: cwd,
-    parentFolderName,
+    trustChanged,
+    committedTrustLevel: committedLevel,
+    effectiveTrust,
+    workingDirectory: normalizedCwd,
+    parentFolderName: path.basename(path.dirname(normalizedCwd)),
     trustedFolders,
   };
 }

package/src/ui/hooks/useReactToolScheduler.ts

@@ -14,7 +14,7 @@ import {
   type CancelledToolCall,
   type ToolCall,
   type EditorType,
-  type AnsiOutput,
+  type LiveOutputUpdate,
   type MessageBus,
   accumulateLiveOutput,
 } from '@vybestack/llxprt-code-core';
@@ -86,7 +86,7 @@ export type CancelAllFn = () => void;
 export type ReplaceToolCallsFn = (calls: ToolCall[]) => void;
 export type UpdateToolOutputFn = (
   toolCallId: string,
-  chunk: string | AnsiOutput,
+  update: LiveOutputUpdate,
 ) => void;
 export type ReactToolSchedulerResult = readonly [
   TrackedToolCall[],
@@ -104,7 +104,7 @@ export type ReactToolSchedulerResult = readonly [
 function updatePendingItemWithOutput(
   prevItem: HistoryItemWithoutId | null,
   toolCallId: string,
-  outputChunk: string | AnsiOutput,
+  update: LiveOutputUpdate,
 ): HistoryItemWithoutId | null {
   if (prevItem?.type !== 'tool_group') return prevItem;
   return {
@@ -116,7 +116,7 @@ function updatePendingItemWithOutput(
             ...toolDisplay,
             resultDisplay: accumulateLiveOutput(
               toolDisplay.resultDisplay,
-              outputChunk,
+              update,
             ),
           }
         : toolDisplay,
@@ -148,13 +148,13 @@ function mapCallsWithDisplayClearedFlag(
 function updateCallsWithLiveOutput(
   prevCalls: TrackedToolCall[],
   toolCallId: string,
-  outputChunk: string | AnsiOutput,
+  update: LiveOutputUpdate,
 ): TrackedToolCall[] {
   return prevCalls.map((call) =>
     call.request.callId === toolCallId && call.status === 'executing'
       ? {
           ...call,
-          liveOutput: accumulateLiveOutput(call.liveOutput, outputChunk),
+          liveOutput: accumulateLiveOutput(call.liveOutput, update),
         }
       : call,
   );
@@ -209,7 +209,7 @@ function useToolCallUpdaters(
   updateToolCallOutput: (
     schedulerId: symbol,
     toolCallId: string,
-    outputChunk: string | AnsiOutput,
+    update: LiveOutputUpdate,
   ) => void;
   replaceToolCallsForScheduler: (
     schedulerId: symbol,
@@ -240,23 +240,19 @@ function useToolCallUpdaters(
   );
 
   const updateToolCallOutput = useCallback(
-    (
-      schedulerId: symbol,
-      toolCallId: string,
-      outputChunk: string | AnsiOutput,
-    ) => {
+    (schedulerId: symbol, toolCallId: string, update: LiveOutputUpdate) => {
       updateToolCallsForScheduler(schedulerId, (prevCalls) => {
         const nextCalls = updateCallsWithLiveOutput(
           prevCalls,
           toolCallId,
-          outputChunk,
+          update,
         );
         return nextCalls.some((call, index) => call !== prevCalls[index])
           ? nextCalls
           : prevCalls;
       });
       setPendingHistoryItem((prev) =>
-        updatePendingItemWithOutput(prev, toolCallId, outputChunk),
+        updatePendingItemWithOutput(prev, toolCallId, update),
       );
     },
     [updateToolCallsForScheduler, setPendingHistoryItem],
@@ -378,7 +374,7 @@ function useSchedulerRefs(
     updateToolCallOutput: (
       schedulerId: symbol,
       toolCallId: string,
-      chunk: string | AnsiOutput,
+      update: LiveOutputUpdate,
     ) => void;
     replaceToolCallsForScheduler: (
       schedulerId: symbol,
@@ -470,8 +466,8 @@ function useBoundDisplayUpdaters(
     [replaceToolCallsForScheduler, mainSchedulerId],
   );
   const updateToolOutput = useCallback(
-    (toolCallId: string, chunk: string | AnsiOutput) =>
-      updateToolCallOutput(mainSchedulerId, toolCallId, chunk),
+    (toolCallId: string, update: LiveOutputUpdate) =>
+      updateToolCallOutput(mainSchedulerId, toolCallId, update),
     [updateToolCallOutput, mainSchedulerId],
   );
   return { replaceToolCalls, updateToolOutput };

package/src/ui/hooks/useTodoPausePreserver.ts

@@ -4,7 +4,6 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import { useCallback } from 'react';
 import { type Todo } from '@vybestack/llxprt-code-core';
 
 /**
@@ -20,57 +19,3 @@ export function shouldClearTodos(todos: Todo[]): boolean {
   }
   return todos.every((t) => t.status === 'completed');
 }
-
-export class TodoPausePreserver {
-  private preserveNextSubmission = false;
-
-  /**
-   * @plan PLAN-20260129-TODOPERSIST.P01
-   * Modified to accept todos parameter for conditional clearing logic.
-   */
-  handleSubmit(onClear: () => void, todos: Todo[]): void {
-    if (this.preserveNextSubmission) {
-      this.preserveNextSubmission = false;
-      return;
-    }
-    if (shouldClearTodos(todos)) {
-      onClear();
-    }
-  }
-
-  registerTodoPause(): void {
-    this.preserveNextSubmission = true;
-  }
-}
-
-interface UseTodoPausePreserverOptions {
-  controller: TodoPausePreserver;
-  updateTodos: (todos: Todo[]) => void;
-  handleFinalSubmit: (submittedValue: string) => void;
-  /**
-   * @plan PLAN-20260129-TODOPERSIST.P01
-   * Current todos list required for conditional clearing.
-   */
-  todos: Todo[];
-}
-
-export const useTodoPausePreserver = ({
-  controller,
-  updateTodos,
-  handleFinalSubmit,
-  todos,
-}: UseTodoPausePreserverOptions) => {
-  const handleUserInputSubmit = useCallback(
-    (submittedValue: string) => {
-      controller.handleSubmit(() => {
-        updateTodos([]);
-      }, todos);
-      handleFinalSubmit(submittedValue);
-    },
-    [controller, updateTodos, handleFinalSubmit, todos],
-  );
-
-  return {
-    handleUserInputSubmit,
-  };
-};

package/src/ui/layouts/DefaultAppLayout.tsx

@@ -224,6 +224,8 @@ function buildMainControlsProps(
     history: uiState.history,
     inputWidth: uiState.inputWidth,
     isTodoPanelCollapsed: uiState.isTodoPanelCollapsed,
+    isQueuedMessagesPanelCollapsed: uiState.isQueuedMessagesPanelCollapsed,
+    queuedSubmissions: uiState.queuedSubmissions,
     showTodoPanelSetting: layoutSettings.showTodoPanelSetting,
     dialogsVisible: hasActiveDialog(uiState),
     hideContextSummary: layoutSettings.hideContextSummary,