@thacio/auditaria 0.30.1 → 0.30.12

package/bundle/gemini.js

@@ -120030,7 +120030,7 @@ function getVersion() {
   }
   versionPromise = (async () => {
     const pkgJson = await getPackageJson(__dirname3);
-    return "0.30.1";
+    return "0.30.12";
   })();
   return versionPromise;
 }
@@ -184383,7 +184383,7 @@ var require_util11 = __commonJS({
     var os39 = __require("os");
     var fs132 = __require("fs");
     var path154 = __require("path");
-    var spawn17 = __require("child_process").spawn;
+    var spawn18 = __require("child_process").spawn;
     var exec7 = __require("child_process").exec;
     var execSync8 = __require("child_process").execSync;
     var util5 = __require("util");
@@ -184747,7 +184747,7 @@ var require_util11 = __commonJS({
     }
     function powerShellStart() {
       if (!_psChild) {
-        _psChild = spawn17(_powerShell, ["-NoProfile", "-NoLogo", "-InputFormat", "Text", "-NoExit", "-Command", "-"], {
+        _psChild = spawn18(_powerShell, ["-NoProfile", "-NoLogo", "-InputFormat", "Text", "-NoExit", "-Command", "-"], {
           stdio: "pipe",
           windowsHide: true,
           maxBuffer: 1024 * 102400,
@@ -184821,7 +184821,7 @@ var require_util11 = __commonJS({
             try {
               const osVersion = os39.release().split(".").map(Number);
               const spanOptions = osVersion[0] < 10 ? ["-NoProfile", "-NoLogo", "-InputFormat", "Text", "-NoExit", "-ExecutionPolicy", "Unrestricted", "-Command", "-"] : ["-NoProfile", "-NoLogo", "-InputFormat", "Text", "-ExecutionPolicy", "Unrestricted", "-Command", cmd];
-              const child = spawn17(_powerShell, spanOptions, {
+              const child = spawn18(_powerShell, spanOptions, {
                 stdio: "pipe",
                 windowsHide: true,
                 maxBuffer: 1024 * 102400,
@@ -184875,7 +184875,7 @@ var require_util11 = __commonJS({
       return new Promise((resolve34) => {
         process.nextTick(() => {
           try {
-            const child = spawn17(cmd, args2, options);
+            const child = spawn18(cmd, args2, options);
             if (child && !child.pid) {
               child.on("error", () => {
                 resolve34(result2);
@@ -202503,8 +202503,8 @@ var GIT_COMMIT_INFO, CLI_VERSION;
 var init_git_commit = __esm({
   "packages/core/dist/src/generated/git-commit.js"() {
     "use strict";
-    GIT_COMMIT_INFO = "ab60e625a";
-    CLI_VERSION = "0.30.1";
+    GIT_COMMIT_INFO = "f9d3697df";
+    CLI_VERSION = "0.30.12";
   }
 });
 
@@ -319412,7 +319412,7 @@ var require_cross_spawn = __commonJS({
     var cp3 = __require("child_process");
     var parse15 = require_parse7();
     var enoent = require_enoent();
-    function spawn17(command2, args2, options) {
+    function spawn18(command2, args2, options) {
       const parsed = parse15(command2, args2, options);
       const spawned = cp3.spawn(parsed.command, parsed.args, parsed.options);
       enoent.hookChildProcess(spawned, parsed);
@@ -319424,8 +319424,8 @@ var require_cross_spawn = __commonJS({
       result2.error = result2.error || enoent.verifyENOENTSync(result2.status, parsed);
       return result2;
     }
-    module2.exports = spawn17;
-    module2.exports.spawn = spawn17;
+    module2.exports = spawn18;
+    module2.exports.spawn = spawn18;
     module2.exports.sync = spawnSync6;
     module2.exports._parse = parse15;
     module2.exports._enoent = enoent;
@@ -398156,12 +398156,14 @@ var init_stagehand_adapter = __esm({
           return this.resolutionPaths;
         }
         this.resolutionPaths = [
-          // 1. Try from bundle location (global install - node_modules is sibling to bundle/)
+          // 1. Try from bundle directory (self-contained stagehand in bundle/node_modules/)
           // __dirname is set by esbuild banner to the bundle directory
+          typeof __dirname !== "undefined" ? `file://${__dirname}/package.json` : null,
+          // 2. Try from package root (global install - npm-installed deps in node_modules/)
           typeof __dirname !== "undefined" ? `file://${__dirname}/../package.json` : null,
-          // 2. Try from CLI package (when running from project root)
+          // 3. Try from CLI package (when running from project root)
           `file://${process.cwd()}/packages/cli/package.json`,
-          // 3. Try from browser-agent package (local dev fallback)
+          // 4. Try from browser-agent package (local dev fallback)
           `file://${process.cwd()}/packages/browser-agent/package.json`
         ].filter(Boolean);
         return this.resolutionPaths;
@@ -499122,10 +499124,12 @@ import { EventEmitter as EventEmitter16 } from "events";
 // packages/cli/src/services/FileSystemService.ts
 import path85 from "node:path";
 import { promises as fs70 } from "node:fs";
-var FileSystemService = class {
+import { spawn as spawn12 } from "node:child_process";
+var FileSystemService = class _FileSystemService {
   workspaceRoot;
   maxFileSize;
   ignoredPatterns;
+  rgPath = null;
   /**
    * Create a new FileSystemService
    * @param workspaceRoot - Absolute path to workspace root directory
@@ -499158,6 +499162,14 @@ var FileSystemService = class {
       "temp"
     ];
   }
+  /**
+   * Set ripgrep binary path for fast file search.
+   * When set, searchFiles() uses ripgrep with BFS fallback.
+   * @param rgPath - Absolute path to rg binary
+   */
+  setRgPath(rgPath2) {
+    this.rgPath = rgPath2;
+  }
   /**
    * Get workspace root path
    */
@@ -499172,33 +499184,65 @@ var FileSystemService = class {
   getIgnoredPatterns() {
     return [...this.ignoredPatterns];
   }
+  /**
+   * Options for lazy tree loading
+   */
+  static TREE_DEFAULTS = {
+    maxDepth: 1,
+    maxChildren: 500,
+    searchMaxResults: 200,
+    searchMaxDirsVisited: 5e3
+  };
   /**
    * Get directory tree structure
    *
    * @param relativePath - Optional subdirectory path (relative to workspace root)
+   * @param options - Lazy loading options (maxDepth, maxChildren, currentDepth)
    * @returns Array of tree nodes representing files and folders
    * @throws Error if path is invalid or outside workspace
    */
-  async getFileTree(relativePath = ".") {
+  async getFileTree(relativePath = ".", options = {}) {
+    const maxDepth = options.maxDepth ?? Infinity;
+    const maxChildren = options.maxChildren ?? Infinity;
+    const currentDepth = options.currentDepth ?? 0;
     const absolutePath = this.validatePath(relativePath);
     try {
       const entries2 = await fs70.readdir(absolutePath, { withFileTypes: true });
       const nodes = [];
+      let totalValid = 0;
       for (const entry of entries2) {
         if (this.shouldIgnore(entry.name)) {
           continue;
         }
+        totalValid++;
+        if (nodes.length >= maxChildren) {
+          continue;
+        }
         const entryRelativePath = path85.join(relativePath, entry.name);
         const absoluteEntryPath = path85.join(absolutePath, entry.name);
         try {
           if (entry.isDirectory()) {
-            const children = await this.getFileTree(entryRelativePath);
-            nodes.push({
-              label: entry.name,
-              path: entryRelativePath,
-              type: "folder",
-              children
-            });
+            if (currentDepth < maxDepth) {
+              const children = await this.getFileTree(entryRelativePath, {
+                maxDepth,
+                maxChildren,
+                currentDepth: currentDepth + 1
+              });
+              nodes.push({
+                label: entry.name,
+                path: entryRelativePath,
+                type: "folder",
+                children
+              });
+            } else {
+              const hasChildren2 = await this.folderHasChildren(absoluteEntryPath);
+              nodes.push({
+                label: entry.name,
+                path: entryRelativePath,
+                type: "folder",
+                hasChildren: hasChildren2
+              });
+            }
           } else if (entry.isFile()) {
             const stats = await fs70.stat(absoluteEntryPath);
             nodes.push({
@@ -499216,7 +499260,19 @@ var FileSystemService = class {
           continue;
         }
       }
+      if (totalValid > maxChildren && nodes.length > 0) {
+        const lastNode = nodes[nodes.length - 1];
+        nodes.push({
+          label: `... and ${totalValid - maxChildren} more items`,
+          path: path85.join(relativePath, "__truncated__"),
+          type: "file",
+          truncated: true,
+          totalChildren: totalValid
+        });
+      }
       nodes.sort((a2, b) => {
+        if (a2.truncated) return 1;
+        if (b.truncated) return -1;
         if (a2.type !== b.type) {
           return a2.type === "folder" ? -1 : 1;
         }
@@ -499233,6 +499289,178 @@ var FileSystemService = class {
       throw new Error(`Failed to read directory: ${error40.message}`);
     }
   }
+  /**
+   * Lightweight check: does a folder contain any non-ignored children?
+   * Used at depth limit to decide if the expand arrow should show.
+   */
+  async folderHasChildren(absoluteFolderPath) {
+    try {
+      const entries2 = await fs70.readdir(absoluteFolderPath, { withFileTypes: true });
+      for (const entry of entries2) {
+        if (!this.shouldIgnore(entry.name) && (entry.isFile() || entry.isDirectory())) {
+          return true;
+        }
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Search files by name. Uses ripgrep when available for speed and regex support,
+   * falls back to Node.js BFS traversal otherwise.
+   *
+   * The query is treated as a regex pattern. If the regex is invalid, it falls
+   * back to case-insensitive substring matching.
+   *
+   * @param query - Search string (regex or plain substring)
+   * @param maxResults - Maximum results to return
+   * @returns Flat array of matching TreeNode items
+   */
+  async searchFiles(query, maxResults = _FileSystemService.TREE_DEFAULTS.searchMaxResults) {
+    if (this.rgPath) {
+      try {
+        return await this.searchFilesWithRg(query, maxResults);
+      } catch (error40) {
+        console.error("Ripgrep search failed, falling back to BFS:", error40);
+      }
+    }
+    return this.searchFilesBFS(query, maxResults);
+  }
+  /**
+   * Build a name matcher from a query string.
+   * Tries regex first; falls back to case-insensitive substring.
+   */
+  buildNameMatcher(query) {
+    try {
+      const regex3 = new RegExp(query, "i");
+      return (name4) => regex3.test(name4);
+    } catch {
+      const lower2 = query.toLowerCase();
+      return (name4) => name4.toLowerCase().includes(lower2);
+    }
+  }
+  /**
+   * Search files using ripgrep (fast, multi-threaded, respects .gitignore).
+   * Spawns `rg --files` and filters output by name.
+   *
+   * Note: rg --files only lists files, not directories. This is acceptable
+   * since users typically search for files. Directories matching the query
+   * are found via BFS fallback when rg is unavailable.
+   */
+  searchFilesWithRg(query, maxResults) {
+    const matcher = this.buildNameMatcher(query);
+    const args2 = [
+      "--files",
+      // List files only (no content search)
+      "--hidden",
+      // Include hidden files (we exclude specific ones below)
+      "--no-ignore",
+      // Don't respect .gitignore/.ignore — use our custom excludes only
+      "--threads",
+      "4"
+      // Multi-threaded for large directories
+    ];
+    for (const pattern of this.ignoredPatterns) {
+      args2.push("--glob", `!${pattern}`);
+    }
+    args2.push(this.workspaceRoot);
+    return new Promise((resolve34, reject) => {
+      const results = [];
+      const rg = spawn12(this.rgPath, args2, { stdio: ["ignore", "pipe", "ignore"] });
+      let buffer = "";
+      let done = false;
+      const finish = () => {
+        if (done) return;
+        done = true;
+        const lastLine = buffer.trim();
+        if (lastLine && results.length < maxResults) {
+          const basename25 = path85.basename(lastLine);
+          if (matcher(basename25)) {
+            results.push({
+              label: basename25,
+              path: path85.relative(this.workspaceRoot, lastLine),
+              type: "file"
+            });
+          }
+        }
+        resolve34(results);
+      };
+      rg.stdout.on("data", (chunk2) => {
+        if (done) return;
+        buffer += chunk2.toString();
+        const lines = buffer.split("\n");
+        buffer = lines.pop();
+        for (const line of lines) {
+          const filePath = line.trim();
+          if (!filePath) continue;
+          const basename25 = path85.basename(filePath);
+          if (matcher(basename25)) {
+            results.push({
+              label: basename25,
+              path: path85.relative(this.workspaceRoot, filePath),
+              type: "file"
+            });
+            if (results.length >= maxResults) {
+              done = true;
+              rg.kill();
+              resolve34(results);
+              return;
+            }
+          }
+        }
+      });
+      rg.on("close", finish);
+      rg.on("error", (err2) => {
+        if (!done) {
+          done = true;
+          reject(err2);
+        }
+      });
+      setTimeout(() => {
+        if (!done) {
+          done = true;
+          rg.kill();
+          resolve34(results);
+        }
+      }, 1e4);
+    });
+  }
+  /**
+   * Search files by name using BFS through directories (fallback when rg is unavailable).
+   * Supports regex patterns — falls back to substring match on invalid regex.
+   */
+  async searchFilesBFS(query, maxResults) {
+    const matcher = this.buildNameMatcher(query);
+    const results = [];
+    const queue = ["."];
+    const maxDirs = _FileSystemService.TREE_DEFAULTS.searchMaxDirsVisited;
+    let queueIdx = 0;
+    while (queueIdx < queue.length && results.length < maxResults && queueIdx < maxDirs) {
+      const currentRelPath = queue[queueIdx++];
+      const absolutePath = this.validatePath(currentRelPath);
+      let entries2;
+      try {
+        entries2 = await fs70.readdir(absolutePath, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const entry of entries2) {
+        if (this.shouldIgnore(entry.name)) continue;
+        if (results.length >= maxResults) break;
+        const entryRelPath = path85.join(currentRelPath, entry.name);
+        if (entry.isDirectory()) {
+          queue.push(entryRelPath);
+          if (matcher(entry.name)) {
+            results.push({ label: entry.name, path: entryRelPath, type: "folder" });
+          }
+        } else if (entry.isFile() && matcher(entry.name)) {
+          results.push({ label: entry.name, path: entryRelPath, type: "file" });
+        }
+      }
+    }
+    return results;
+  }
   /**
    * Read file contents
    *
@@ -499537,12 +499765,12 @@ var FileSystemService = class {
       }
       const platform22 = process.platform;
       if (platform22 === "win32") {
-        const { spawn: spawn17 } = await import("node:child_process");
+        const { spawn: spawn18 } = await import("node:child_process");
         const stats = await fs70.stat(absolutePath);
         if (stats.isDirectory()) {
-          spawn17("explorer", [absolutePath], { detached: true, stdio: "ignore" });
+          spawn18("explorer", [absolutePath], { detached: true, stdio: "ignore" });
         } else {
-          spawn17("explorer", ["/select,", absolutePath], { detached: true, stdio: "ignore" });
+          spawn18("explorer", ["/select,", absolutePath], { detached: true, stdio: "ignore" });
         }
         return;
       }
@@ -500194,6 +500422,8 @@ async function getSearchModule() {
 var LATEST_ONLY_MESSAGE_TYPES = /* @__PURE__ */ new Set([
   "file_tree_response",
   // Full tree snapshot (5MB+) - only latest matters
+  "file_tree_search_response",
+  // Search results snapshot - only latest matters
   "mcp_servers",
   // Full server list - only latest matters
   "slash_commands",
@@ -500802,6 +501032,7 @@ var WebInterfaceService = class extends EventEmitter16 {
       });
       this.setupWebSocketHandlers();
       this.fileSystemService = new FileSystemService(process.cwd());
+      this.initRipgrepForSearch();
       this.fileWatcherService = new FileWatcherService(process.cwd());
       this.setupFileWatcherHandlers();
       this.directoryWatcherService = new DirectoryWatcherService(process.cwd(), this.fileSystemService?.getIgnoredPatterns());
@@ -501375,6 +501606,10 @@ var WebInterfaceService = class extends EventEmitter16 {
       });
     } else if (message.type === "file_tree_request") {
       this.handleFileTreeRequest(message.relativePath);
+    } else if (message.type === "file_tree_children_request" && message.path) {
+      this.handleFileTreeChildrenRequest(message.path);
+    } else if (message.type === "file_tree_search_request" && message.query) {
+      this.handleFileTreeSearchRequest(message.query);
     } else if (message.type === "file_read_request" && message.path) {
       this.handleFileReadRequest(message.path);
     } else if (message.type === "file_write_request" && message.path && message.content !== void 0) {
@@ -501729,6 +501964,18 @@ var WebInterfaceService = class extends EventEmitter16 {
     });
   }
   // AUDITARIA_END
+  /**
+   * Resolve ripgrep binary path and enable rg-backed file search.
+   * Non-blocking: if rg isn't available, search falls back to BFS.
+   */
+  initRipgrepForSearch() {
+    ensureRgPath().then((rgPath2) => {
+      if (this.fileSystemService) {
+        this.fileSystemService.setRgPath(rgPath2);
+      }
+    }).catch(() => {
+    });
+  }
   // WEB_INTERFACE_START: File operation handler methods
   /**
    * Handle file tree request
@@ -501739,7 +501986,14 @@ var WebInterfaceService = class extends EventEmitter16 {
       return;
     }
     try {
-      const tree = await this.fileSystemService.getFileTree(relativePath || ".");
+      const {
+        maxDepth,
+        maxChildren
+      } = FileSystemService.TREE_DEFAULTS;
+      const tree = await this.fileSystemService.getFileTree(relativePath || ".", {
+        maxDepth,
+        maxChildren
+      });
       this.broadcastWithSequence("file_tree_response", {
         tree,
         workspaceRoot: this.fileSystemService.getWorkspaceRoot()
@@ -501753,6 +502007,60 @@ var WebInterfaceService = class extends EventEmitter16 {
       });
     }
   }
+  /**
+   * Handle request to load children of a specific folder (lazy expand)
+   */
+  async handleFileTreeChildrenRequest(relativePath) {
+    if (!this.fileSystemService) {
+      console.error("FileSystemService not initialized");
+      return;
+    }
+    try {
+      const {
+        maxDepth,
+        maxChildren
+      } = FileSystemService.TREE_DEFAULTS;
+      const children = await this.fileSystemService.getFileTree(relativePath, {
+        maxDepth,
+        maxChildren
+      });
+      this.broadcastWithSequence("file_tree_children_response", {
+        path: relativePath,
+        children,
+        workspaceRoot: this.fileSystemService.getWorkspaceRoot()
+      });
+    } catch (error40) {
+      console.error("Error reading folder children:", error40);
+      this.broadcastWithSequence("file_tree_children_response", {
+        path: relativePath,
+        children: [],
+        error: error40.message
+      });
+    }
+  }
+  /**
+   * Handle server-side file search request
+   */
+  async handleFileTreeSearchRequest(query) {
+    if (!this.fileSystemService) {
+      console.error("FileSystemService not initialized");
+      return;
+    }
+    try {
+      const results = await this.fileSystemService.searchFiles(query);
+      this.broadcastWithSequence("file_tree_search_response", {
+        query,
+        results
+      });
+    } catch (error40) {
+      console.error("Error searching files:", error40);
+      this.broadcastWithSequence("file_tree_search_response", {
+        query,
+        results: [],
+        error: error40.message
+      });
+    }
+  }
   /**
    * Handle file read request
    */
@@ -501815,7 +502123,10 @@ var WebInterfaceService = class extends EventEmitter16 {
         path: path154,
         message: t("File created successfully")
       });
-      this.handleFileTreeRequest();
+      const parentDir = path154.includes("/") || path154.includes("\\") ? path154.substring(0, Math.max(path154.lastIndexOf("/"), path154.lastIndexOf("\\"))) : ".";
+      this.broadcastWithSequence("directory_change_notification", {
+        path: parentDir || "."
+      });
     } catch (error40) {
       console.error("Error creating file:", error40);
       this.broadcastWithSequence("file_operation_error", {
@@ -501840,7 +502151,10 @@ var WebInterfaceService = class extends EventEmitter16 {
         path: path154,
         message: t("File deleted successfully")
       });
-      this.handleFileTreeRequest();
+      const parentDir = path154.includes("/") || path154.includes("\\") ? path154.substring(0, Math.max(path154.lastIndexOf("/"), path154.lastIndexOf("\\"))) : ".";
+      this.broadcastWithSequence("directory_change_notification", {
+        path: parentDir || "."
+      });
     } catch (error40) {
       console.error("Error deleting file:", error40);
       this.broadcastWithSequence("file_operation_error", {
@@ -501866,7 +502180,20 @@ var WebInterfaceService = class extends EventEmitter16 {
         newPath,
         message: t("File renamed successfully")
       });
-      this.handleFileTreeRequest();
+      const getParent = (p) => {
+        const idx = Math.max(p.lastIndexOf("/"), p.lastIndexOf("\\"));
+        return idx > 0 ? p.substring(0, idx) : ".";
+      };
+      const oldParent = getParent(oldPath);
+      const newParent = getParent(newPath);
+      this.broadcastWithSequence("directory_change_notification", {
+        path: oldParent
+      });
+      if (newParent !== oldParent) {
+        this.broadcastWithSequence("directory_change_notification", {
+          path: newParent
+        });
+      }
     } catch (error40) {
       console.error("Error renaming file:", error40);
       this.broadcastWithSequence("file_operation_error", {
@@ -502172,8 +502499,12 @@ var WebInterfaceService = class extends EventEmitter16 {
     if (!this.directoryWatcherService) {
       return;
     }
-    this.directoryWatcherService.on("directory-change", (_event) => {
-      this.handleFileTreeRequest();
+    this.directoryWatcherService.on("directory-change", (event) => {
+      const changedPath = event?.path || event?.relativePath || ".";
+      const parentDir = changedPath.includes("/") || changedPath.includes("\\") ? changedPath.substring(0, Math.max(changedPath.lastIndexOf("/"), changedPath.lastIndexOf("\\"))) : ".";
+      this.broadcastWithSequence("directory_change_notification", {
+        path: parentDir || "."
+      });
     });
     this.directoryWatcherService.on("error", (error40) => {
       console.error("Directory watcher error:", error40);
@@ -502740,7 +503071,7 @@ function useSubmitQueryRegistration() {
 }
 
 // packages/cli/src/utils/browserUtils.ts
-import { spawn as spawn12 } from "node:child_process";
+import { spawn as spawn13 } from "node:child_process";
 import { platform as platform13 } from "node:os";
 async function openBrowser(url3) {
   return new Promise((resolve34, reject) => {
@@ -502761,7 +503092,7 @@ async function openBrowser(url3) {
         args2 = [url3];
         break;
     }
-    const child = spawn12(command2, args2, {
+    const child = spawn13(command2, args2, {
       detached: true,
       stdio: "ignore"
     });
@@ -512429,7 +512760,7 @@ import * as path98 from "node:path";
 init_dist8();
 import * as fs81 from "node:fs/promises";
 import { createWriteStream as createWriteStream6, existsSync as existsSync23, statSync as statSync5 } from "node:fs";
-import { execSync as execSync4, spawn as spawn13 } from "node:child_process";
+import { execSync as execSync4, spawn as spawn14 } from "node:child_process";
 import * as path97 from "node:path";
 var IMAGE_EXTENSIONS = [
   ".png",
@@ -512461,7 +512792,7 @@ function getUserLinuxClipboardTool() {
 }
 async function saveFromCommand(command2, args2, destination) {
   return new Promise((resolve34) => {
-    const child = spawn13(command2, args2);
+    const child = spawn14(command2, args2);
     const fileStream = createWriteStream6(destination);
     let resolved = false;
     const safeResolve = (value) => {
@@ -535590,7 +535921,7 @@ var WarningMessage = ({ text }) => {
 init_dist8();
 
 // packages/cli/src/generated/git-commit.ts
-var GIT_COMMIT_INFO2 = "ab60e625a";
+var GIT_COMMIT_INFO2 = "f9d3697df";
 
 // packages/cli/src/ui/components/AboutBox.tsx
 var import_jsx_runtime43 = __toESM(require_jsx_runtime(), 1);
@@ -570127,8 +570458,8 @@ import { EventEmitter as EventEmitter17 } from "node:events";
 var updateEventEmitter = new EventEmitter17();
 
 // packages/cli/src/utils/spawnWrapper.ts
-import { spawn as spawn14 } from "node:child_process";
-var spawnWrapper = spawn14;
+import { spawn as spawn15 } from "node:child_process";
+var spawnWrapper = spawn15;
 
 // packages/cli/src/utils/handleAutoUpdate.ts
 function handleAutoUpdate(info2, settings, projectRoot, spawnFn = spawnWrapper) {
@@ -584054,7 +584385,7 @@ import dns from "node:dns";
 // packages/cli/src/utils/sandbox.ts
 var import_shell_quote5 = __toESM(require_shell_quote(), 1);
 init_dist8();
-import { exec as exec6, execSync as execSync7, spawn as spawn15 } from "node:child_process";
+import { exec as exec6, execSync as execSync7, spawn as spawn16 } from "node:child_process";
 import path151 from "node:path";
 import fs128 from "node:fs";
 import os36 from "node:os";
@@ -584306,7 +584637,7 @@ async function start_sandbox(config2, nodeArgs = [], cliConfig, cliArgs = []) {
           sandboxEnv["NO_PROXY"] = noProxy;
           sandboxEnv["no_proxy"] = noProxy;
         }
-        proxyProcess2 = spawn15(proxyCommand2, {
+        proxyProcess2 = spawn16(proxyCommand2, {
           stdio: ["ignore", "pipe", "pipe"],
           shell: true,
           detached: true
@@ -584340,7 +584671,7 @@ async function start_sandbox(config2, nodeArgs = [], cliConfig, cliArgs = []) {
         );
       }
       process.stdin.pause();
-      sandboxProcess2 = spawn15(config2.command, args3, {
+      sandboxProcess2 = spawn16(config2.command, args3, {
         stdio: "inherit"
       });
       return await new Promise((resolve34, reject) => {
@@ -584664,7 +584995,7 @@ async function start_sandbox(config2, nodeArgs = [], cliConfig, cliArgs = []) {
     let sandboxProcess = void 0;
     if (proxyCommand) {
       const proxyContainerCommand = `${config2.command} run --rm --init ${userFlag} --name ${SANDBOX_PROXY_NAME} --network ${SANDBOX_PROXY_NAME} -p 8877:8877 -v ${process.cwd()}:${workdir} --workdir ${workdir} ${image3} ${proxyCommand}`;
-      proxyProcess = spawn15(proxyContainerCommand, {
+      proxyProcess = spawn16(proxyContainerCommand, {
         stdio: ["ignore", "pipe", "pipe"],
         shell: true,
         detached: true
@@ -584699,7 +585030,7 @@ async function start_sandbox(config2, nodeArgs = [], cliConfig, cliArgs = []) {
       );
     }
     process.stdin.pause();
-    sandboxProcess = spawn15(config2.command, args2, {
+    sandboxProcess = spawn16(config2.command, args2, {
       stdio: "inherit"
     });
     return await new Promise((resolve34, reject) => {
@@ -584724,7 +585055,7 @@ async function start_sandbox(config2, nodeArgs = [], cliConfig, cliArgs = []) {
 async function imageExists(sandbox, image3) {
   return new Promise((resolve34) => {
     const args2 = ["images", "-q", image3];
-    const checkProcess = spawn15(sandbox, args2);
+    const checkProcess = spawn16(sandbox, args2);
     let stdoutData = "";
     if (checkProcess.stdout) {
       checkProcess.stdout.on("data", (data) => {
@@ -584748,7 +585079,7 @@ async function pullImage(sandbox, image3, cliConfig) {
   debugLogger.debug(`Attempting to pull image ${image3} using ${sandbox}...`);
   return new Promise((resolve34) => {
     const args2 = ["pull", image3];
-    const pullProcess = spawn15(sandbox, args2, { stdio: "pipe" });
+    const pullProcess = spawn16(sandbox, args2, { stdio: "pipe" });
     let stderrData = "";
     const onStdoutData = (data) => {
       if (cliConfig?.getDebugMode() || process.env["DEBUG"]) {
@@ -587909,7 +588240,7 @@ async function validateNonInteractiveAuth(configuredAuthType, useExternalAuth, n
 }
 
 // packages/cli/src/utils/relaunch.ts
-import { spawn as spawn16 } from "node:child_process";
+import { spawn as spawn17 } from "node:child_process";
 init_dist8();
 async function relaunchOnExitCode(runner) {
   while (true) {
@@ -587947,7 +588278,7 @@ async function relaunchAppInChildProcess(additionalNodeArgs, additionalScriptArg
     ];
     const newEnv = { ...process.env, GEMINI_CLI_NO_RELAUNCH: "true" };
     process.stdin.pause();
-    const child = spawn16(process.execPath, nodeArgs, {
+    const child = spawn17(process.execPath, nodeArgs, {
       stdio: ["inherit", "inherit", "inherit", "ipc"],
       env: newEnv
     });