@ash-cloud/ash-ai 0.1.13 → 0.1.16

package/dist/index.js

@@ -4205,6 +4205,50 @@ VERCEL_EOF`);
   }
 });
 
+// src/runtime/providers/firecracker/types.ts
+var init_types3 = __esm({
+  "src/runtime/providers/firecracker/types.ts"() {
+  }
+});
+
+// src/runtime/providers/firecracker/image-manager.ts
+var init_image_manager = __esm({
+  "src/runtime/providers/firecracker/image-manager.ts"() {
+  }
+});
+
+// src/runtime/providers/firecracker/network-manager.ts
+var init_network_manager = __esm({
+  "src/runtime/providers/firecracker/network-manager.ts"() {
+  }
+});
+
+// src/runtime/providers/firecracker/ssh-executor.ts
+var init_ssh_executor = __esm({
+  "src/runtime/providers/firecracker/ssh-executor.ts"() {
+  }
+});
+
+// src/runtime/providers/firecracker/vm-manager.ts
+var init_vm_manager = __esm({
+  "src/runtime/providers/firecracker/vm-manager.ts"() {
+    init_types3();
+  }
+});
+
+// src/runtime/providers/firecracker.ts
+var init_firecracker = __esm({
+  "src/runtime/providers/firecracker.ts"() {
+    init_types2();
+    init_types3();
+    init_image_manager();
+    init_network_manager();
+    init_ssh_executor();
+    init_vm_manager();
+    init_types3();
+  }
+});
+
 // src/runtime/providers/index.ts
 var init_providers = __esm({
   "src/runtime/providers/index.ts"() {
@@ -4216,6 +4260,7 @@ var init_providers = __esm({
     init_fly();
     init_daytona();
     init_vercel();
+    init_firecracker();
     init_local();
     init_modal();
     init_e2b();
@@ -4223,6 +4268,7 @@ var init_providers = __esm({
     init_fly();
     init_daytona();
     init_vercel();
+    init_firecracker();
   }
 });
 
@@ -5261,6 +5307,23 @@ function isSandboxRunning(sessionId) {
   const cached = sandboxCache.get(sessionId);
   return cached !== void 0 && !cached.isExpired;
 }
+function getCachedSandbox(sessionId) {
+  const cached = sandboxCache.get(sessionId);
+  if (!cached || cached.isExpired) {
+    return null;
+  }
+  cached.lastUsedAt = Date.now();
+  return {
+    sandbox: cached.sandbox,
+    sandboxId: cached.sandbox.sandboxId,
+    sdkInstalled: cached.sdkInstalled,
+    startupScriptRan: cached.startupScriptRan,
+    startupScriptHash: cached.startupScriptHash,
+    isNew: false,
+    configFileUrl: cached.configFileUrl,
+    configInstalledAt: cached.configInstalledAt
+  };
+}
 async function writeFileToSandbox(sessionId, path15, content) {
   const cached = sandboxCache.get(sessionId);
   if (!cached) {
@@ -5329,6 +5392,54 @@ async function readFileFromSandbox(sessionId, path15) {
     };
   }
 }
+async function executeCommandInSandbox(sessionId, command, options) {
+  const cached = sandboxCache.get(sessionId);
+  if (!cached) {
+    return { success: false, error: "No active sandbox for session" };
+  }
+  if (cached.isExpired) {
+    return { success: false, error: "Sandbox has expired" };
+  }
+  const startTime = Date.now();
+  try {
+    const sandbox = cached.sandbox;
+    let fullCommand = command;
+    if (options?.cwd) {
+      fullCommand = `cd ${JSON.stringify(options.cwd)} && ${command}`;
+    }
+    const result = await sandbox.runCommand({
+      cmd: "bash",
+      args: ["-c", fullCommand],
+      env: options?.env
+    });
+    const stdout = await result.stdout();
+    const stderr = await result.stderr();
+    const durationMs = Date.now() - startTime;
+    cached.lastUsedAt = Date.now();
+    return {
+      success: result.exitCode === 0,
+      exitCode: result.exitCode,
+      stdout,
+      stderr,
+      durationMs
+    };
+  } catch (error) {
+    const durationMs = Date.now() - startTime;
+    if (isSandboxExpiredError(error)) {
+      cached.isExpired = true;
+      return {
+        success: false,
+        error: "Sandbox has expired",
+        durationMs
+      };
+    }
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error",
+      durationMs
+    };
+  }
+}
 async function listFilesInSandbox(sessionId, path15) {
   const cached = sandboxCache.get(sessionId);
   if (!cached) {
@@ -5808,19 +5919,7 @@ function getFileWatcherManager() {
 function createFileWatcherManager() {
   return new FileWatcherManager();
 }
-function createRemoteFileWatcher(options) {
-  return new RemoteSandboxFileWatcher(options);
-}
-function getRemoteFileWatcherManager() {
-  if (!globalRemoteWatcherManager) {
-    globalRemoteWatcherManager = new RemoteFileWatcherManager();
-  }
-  return globalRemoteWatcherManager;
-}
-function createRemoteFileWatcherManager() {
-  return new RemoteFileWatcherManager();
-}
-var SandboxFileWatcher, FileWatcherManager, globalWatcherManager, RemoteSandboxFileWatcher, RemoteFileWatcherManager, globalRemoteWatcherManager;
+var SandboxFileWatcher, FileWatcherManager, globalWatcherManager;
 var init_sandbox_file_watcher = __esm({
   "src/runtime/sandbox-file-watcher.ts"() {
     SandboxFileWatcher = class {
@@ -5846,7 +5945,18 @@ var init_sandbox_file_watcher = __esm({
         this.watchPath = options.watchPath;
         this.debounceMs = options.debounceMs ?? 300;
         this.patterns = options.patterns ?? ["**/*"];
-        this.ignored = options.ignored ?? ["**/node_modules/**", "**/.git/**", "**/*.log"];
+        this.ignored = options.ignored ?? [
+          "**/node_modules/**",
+          "**/.git/**",
+          "**/*.log",
+          // Temporary files from atomic saves and editors
+          "**/*.tmp",
+          "**/*.tmp.*",
+          "**/*~",
+          "**/*.swp",
+          "**/*.swo",
+          "**/.DS_Store"
+        ];
         this.emitInitialEvents = options.emitInitialEvents ?? false;
         this.followSymlinks = options.followSymlinks ?? false;
         this.usePolling = options.usePolling ?? false;
@@ -6062,214 +6172,343 @@ var init_sandbox_file_watcher = __esm({
       }
     };
     globalWatcherManager = null;
-    RemoteSandboxFileWatcher = class {
+  }
+});
+
+// src/runtime/in-sandbox-watcher.ts
+function createInSandboxWatcher(options) {
+  return new InSandboxWatcher(options);
+}
+function getInSandboxWatcherManager() {
+  if (!globalInSandboxManager) {
+    globalInSandboxManager = new InSandboxWatcherManager();
+  }
+  return globalInSandboxManager;
+}
+function createInSandboxWatcherManager() {
+  return new InSandboxWatcherManager();
+}
+var WATCHER_SCRIPT, InSandboxWatcher, InSandboxWatcherManager, globalInSandboxManager;
+var init_in_sandbox_watcher = __esm({
+  "src/runtime/in-sandbox-watcher.ts"() {
+    init_vercel_sandbox_executor();
+    WATCHER_SCRIPT = `
+const fs = require('fs');
+const path = require('path');
+
+const watchPath = process.argv[2] || '.';
+const ignoredDirs = new Set(['node_modules', '.git', '.cache', '__pycache__']);
+
+// Track all watchers for cleanup
+const watchers = new Map();
+
+// Debounce map to coalesce rapid changes
+const pending = new Map();
+const DEBOUNCE_MS = 100;
+
+function emit(type, filePath) {
+  const event = {
+    type,
+    path: filePath,
+    timestamp: Date.now()
+  };
+  console.log(JSON.stringify(event));
+}
+
+function shouldIgnore(name) {
+  // Ignore hidden files/dirs (starting with .)
+  if (name.startsWith('.')) return true;
+
+  // Ignore known directories
+  if (ignoredDirs.has(name)) return true;
+
+  // Ignore temporary files from atomic saves and editors:
+  // - filename.tmp (ends with .tmp)
+  // - filename.tmp.123456789 (has .tmp. in middle - atomic write pattern)
+  // - filename~ (editor backup files)
+  // - filename.swp / filename.swo (Vim swap files)
+  if (name.endsWith('.tmp')) return true;
+  if (name.includes('.tmp.')) return true;
+  if (name.endsWith('~')) return true;
+  if (name.endsWith('.swp') || name.endsWith('.swo')) return true;
+
+  return false;
+}
+
+function watchDir(dir) {
+  try {
+    const watcher = fs.watch(dir, { persistent: true }, (eventType, filename) => {
+      if (!filename || shouldIgnore(filename)) return;
+
+      const fullPath = path.join(dir, filename);
+      const key = fullPath;
+
+      // Debounce
+      if (pending.has(key)) {
+        clearTimeout(pending.get(key));
+      }
+
+      pending.set(key, setTimeout(() => {
+        pending.delete(key);
+
+        fs.stat(fullPath, (err, stats) => {
+          if (err) {
+            if (err.code === 'ENOENT') {
+              emit('unlink', fullPath);
+              // Stop watching if it was a directory
+              if (watchers.has(fullPath)) {
+                watchers.get(fullPath).close();
+                watchers.delete(fullPath);
+              }
+            }
+          } else {
+            const type = eventType === 'rename' ? 'add' : 'change';
+            emit(type, fullPath);
+
+            // If it's a new directory, start watching it
+            if (stats.isDirectory() && !watchers.has(fullPath)) {
+              watchDir(fullPath);
+            }
+          }
+        });
+      }, DEBOUNCE_MS));
+    });
+
+    watchers.set(dir, watcher);
+
+    // Watch subdirectories
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && !shouldIgnore(entry.name)) {
+        watchDir(path.join(dir, entry.name));
+      }
+    }
+  } catch (err) {
+    // Directory may not exist or be inaccessible
+    console.error(JSON.stringify({ error: err.message, dir }));
+  }
+}
+
+// Start watching
+watchDir(watchPath);
+
+// Keep alive
+process.on('SIGTERM', () => {
+  for (const watcher of watchers.values()) {
+    watcher.close();
+  }
+  process.exit(0);
+});
+
+// Heartbeat to indicate we're running
+setInterval(() => {
+  console.log(JSON.stringify({ heartbeat: true, timestamp: Date.now() }));
+}, 5000);
+
+console.log(JSON.stringify({ started: true, path: watchPath }));
+`;
+    InSandboxWatcher = class {
       sessionId;
-      sandboxOps;
-      basePath;
-      pollIntervalMs;
-      ignored;
-      pollTimer = null;
-      previousFiles = /* @__PURE__ */ new Map();
+      watchPath;
+      outputPollIntervalMs;
+      sandboxState = null;
+      outputPollTimer = null;
       subscribers = /* @__PURE__ */ new Set();
-      isWatching = false;
+      isRunning = false;
       startedAt;
-      lastPollAt;
-      pollCount = 0;
+      lastHeartbeat;
+      lastOutputPosition = 0;
       onError;
+      onReady;
       constructor(options) {
         this.sessionId = options.sessionId;
-        this.sandboxOps = options.sandboxOps;
-        this.basePath = options.basePath;
-        this.pollIntervalMs = options.pollIntervalMs ?? 2e3;
-        this.ignored = options.ignored ?? ["**/node_modules/**", "**/.git/**"];
+        this.watchPath = options.watchPath;
+        this.outputPollIntervalMs = options.outputPollIntervalMs ?? 1e3;
         this.onError = options.onError;
+        this.onReady = options.onReady;
         if (options.onFileChange) {
           this.subscribers.add(options.onFileChange);
         }
       }
       /**
-       * Start polling for file changes
+       * Start the watcher process inside the sandbox
        */
       async start() {
-        if (this.isWatching) {
-          console.warn(`[REMOTE_WATCHER] Already watching session ${this.sessionId}`);
+        if (this.isRunning) {
+          console.warn(`[IN_SANDBOX_WATCHER] Already running for session ${this.sessionId}`);
           return;
         }
-        if (!this.sandboxOps.isSandboxRunning(this.sessionId)) {
-          throw new Error(`Sandbox is not running for session ${this.sessionId}`);
-        }
-        await this.scan(true);
-        this.pollTimer = setInterval(async () => {
-          try {
-            await this.scan(false);
-          } catch (error) {
-            console.error(`[REMOTE_WATCHER] Poll error for session ${this.sessionId}:`, error);
-            if (this.onError && error instanceof Error) {
-              this.onError(error);
-            }
+        try {
+          this.sandboxState = getCachedSandbox(this.sessionId);
+          if (!this.sandboxState) {
+            throw new Error(`No active sandbox found for session ${this.sessionId}. Sandbox must be created before starting file watcher.`);
           }
-        }, this.pollIntervalMs);
-        this.isWatching = true;
-        this.startedAt = /* @__PURE__ */ new Date();
-        console.log(`[REMOTE_WATCHER] Started watching session ${this.sessionId} at ${this.basePath}`);
-      }
-      /**
-       * Stop polling and cleanup
-       */
-      async stop() {
-        if (!this.isWatching) {
-          return;
-        }
-        if (this.pollTimer) {
-          clearInterval(this.pollTimer);
-          this.pollTimer = null;
+          const { sandbox } = this.sandboxState;
+          const scriptPath = "/tmp/.file-watcher.js";
+          const outputPath = "/tmp/.file-watcher-output.log";
+          const writeScriptCmd = `cat > ${scriptPath} << 'WATCHER_EOF'
+${WATCHER_SCRIPT}
+WATCHER_EOF`;
+          await sandbox.runCommand({
+            cmd: "sh",
+            args: ["-c", writeScriptCmd]
+          });
+          const startCmd = `nohup node ${scriptPath} "${this.watchPath}" > ${outputPath} 2>&1 &`;
+          await sandbox.runCommand({
+            cmd: "sh",
+            args: ["-c", startCmd]
+          });
+          console.log(`[IN_SANDBOX_WATCHER] Started watcher in sandbox for ${this.watchPath}`);
+          this.isRunning = true;
+          this.startedAt = /* @__PURE__ */ new Date();
+          this.outputPollTimer = setInterval(async () => {
+            try {
+              await this.pollOutput(outputPath);
+            } catch (error) {
+              console.error("[IN_SANDBOX_WATCHER] Error polling output:", error);
+              if (this.onError && error instanceof Error) {
+                this.onError(error);
+              }
+            }
+          }, this.outputPollIntervalMs);
+          setTimeout(() => {
+            this.pollOutput(outputPath).catch(console.error);
+          }, 500);
+        } catch (error) {
+          console.error(`[IN_SANDBOX_WATCHER] Failed to start watcher:`, error);
+          throw error;
         }
-        this.isWatching = false;
-        this.previousFiles.clear();
-        console.log(`[REMOTE_WATCHER] Stopped watching session ${this.sessionId}`);
       }
       /**
-       * Subscribe to file change events
+       * Poll the output file for new events
        */
-      subscribe(callback) {
-        this.subscribers.add(callback);
-        return () => this.subscribers.delete(callback);
-      }
-      /**
-       * Remove a subscriber
-       */
-      unsubscribe(callback) {
-        this.subscribers.delete(callback);
-      }
-      /**
-       * Check if watcher is active
-       */
-      isActive() {
-        return this.isWatching;
-      }
-      /**
-       * Get watcher status
-       */
-      getStatus() {
-        return {
-          sessionId: this.sessionId,
-          watchPath: this.basePath,
-          isWatching: this.isWatching,
-          watchedFileCount: this.previousFiles.size,
-          pendingEventCount: 0,
-          startedAt: this.startedAt,
-          lastPollAt: this.lastPollAt,
-          pollCount: this.pollCount
-        };
+      async pollOutput(outputPath) {
+        if (!this.sandboxState?.sandbox) return;
+        try {
+          const result = await this.sandboxState.sandbox.runCommand({
+            cmd: "sh",
+            args: ["-c", `tail -c +${this.lastOutputPosition + 1} ${outputPath} 2>/dev/null || true`]
+          });
+          const output = await result.stdout();
+          if (output && output.trim()) {
+            const sizeResult = await this.sandboxState.sandbox.runCommand({
+              cmd: "sh",
+              args: ["-c", `stat -c%s ${outputPath} 2>/dev/null || echo 0`]
+            });
+            const sizeStr = await sizeResult.stdout();
+            this.lastOutputPosition = parseInt(sizeStr.trim(), 10) || 0;
+            this.processOutput(output);
+          }
+        } catch {
+        }
       }
       /**
-       * Force an immediate scan (useful for testing or manual refresh)
+       * Process output from the watcher script
        */
-      async forceScan() {
-        await this.scan(false);
+      processOutput(stdout) {
+        const lines = stdout.split("\n").filter(Boolean);
+        for (const line of lines) {
+          try {
+            const data = JSON.parse(line);
+            if (data.started) {
+              console.log(`[IN_SANDBOX_WATCHER] Watcher started for ${data.path}`);
+              if (this.onReady) {
+                this.onReady();
+              }
+            } else if (data.heartbeat) {
+              this.lastHeartbeat = new Date(data.timestamp);
+            } else if (data.error) {
+              console.warn(`[IN_SANDBOX_WATCHER] Error in sandbox:`, data.error);
+            } else if (data.type && data.path) {
+              this.emitEvent({
+                type: data.type,
+                relativePath: data.path.replace(/^\.\//, ""),
+                absolutePath: data.path,
+                basePath: this.watchPath,
+                sessionId: this.sessionId,
+                timestamp: new Date(data.timestamp)
+              });
+            }
+          } catch {
+          }
+        }
       }
       /**
-       * Scan the sandbox for file changes
+       * Stop the watcher process
        */
-      async scan(isInitial) {
-        if (!this.sandboxOps.isSandboxRunning(this.sessionId)) {
-          console.warn(`[REMOTE_WATCHER] Sandbox stopped for session ${this.sessionId}`);
-          await this.stop();
+      async stop() {
+        if (!this.isRunning) {
           return;
         }
-        const listResult = await this.sandboxOps.listFiles(this.sessionId, this.basePath);
-        if (!listResult.success || !listResult.files) {
-          throw new Error(listResult.error ?? "Failed to list files in sandbox");
-        }
-        const currentFiles = /* @__PURE__ */ new Map();
-        for (const filePath of listResult.files) {
-          if (this.shouldIgnore(filePath)) {
-            continue;
-          }
-          currentFiles.set(filePath, { path: filePath });
-        }
-        this.lastPollAt = /* @__PURE__ */ new Date();
-        this.pollCount++;
-        if (isInitial) {
-          this.previousFiles = currentFiles;
-          return;
+        if (this.outputPollTimer) {
+          clearInterval(this.outputPollTimer);
+          this.outputPollTimer = null;
         }
-        const changes = [];
-        for (const [filePath, info] of currentFiles) {
-          const previous = this.previousFiles.get(filePath);
-          if (!previous) {
-            changes.push({
-              type: "add",
-              relativePath: filePath,
-              absolutePath: `${this.basePath}/${filePath}`,
-              basePath: this.basePath,
-              sessionId: this.sessionId,
-              fileSize: info.size,
-              timestamp: /* @__PURE__ */ new Date()
+        try {
+          if (this.sandboxState?.sandbox) {
+            await this.sandboxState.sandbox.runCommand({
+              cmd: "sh",
+              args: ["-c", "pkill -f file-watcher.js 2>/dev/null || true"]
             });
-          }
-        }
-        for (const [filePath] of this.previousFiles) {
-          if (!currentFiles.has(filePath)) {
-            changes.push({
-              type: "unlink",
-              relativePath: filePath,
-              absolutePath: `${this.basePath}/${filePath}`,
-              basePath: this.basePath,
-              sessionId: this.sessionId,
-              timestamp: /* @__PURE__ */ new Date()
+            await this.sandboxState.sandbox.runCommand({
+              cmd: "sh",
+              args: ["-c", "rm -f /tmp/.file-watcher.js /tmp/.file-watcher-output.log"]
             });
           }
+        } catch {
         }
-        this.previousFiles = currentFiles;
-        for (const event of changes) {
-          await this.emitEvent(event);
-        }
+        this.isRunning = false;
+        this.sandboxState = null;
+        this.lastOutputPosition = 0;
+        console.log(`[IN_SANDBOX_WATCHER] Stopped watcher for session ${this.sessionId}`);
       }
       /**
-       * Check if a path should be ignored
+       * Subscribe to file change events
        */
-      shouldIgnore(filePath) {
-        for (const pattern of this.ignored) {
-          if (this.matchesGlob(filePath, pattern)) {
-            return true;
-          }
-        }
-        return false;
+      subscribe(callback) {
+        this.subscribers.add(callback);
+        return () => this.subscribers.delete(callback);
       }
       /**
-       * Simple glob matching (supports ** and *)
+       * Check if watcher is running
        */
-      matchesGlob(filePath, pattern) {
-        const regexPattern = pattern.replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/{{GLOBSTAR}}/g, ".*").replace(/\//g, "\\/");
-        const regex = new RegExp(`^${regexPattern}$`);
-        return regex.test(filePath);
+      isActive() {
+        return this.isRunning;
       }
       /**
-       * Emit a file change event to all subscribers
+       * Get watcher status
+       */
+      getStatus() {
+        return {
+          sessionId: this.sessionId,
+          watchPath: this.watchPath,
+          isRunning: this.isRunning,
+          startedAt: this.startedAt,
+          lastHeartbeat: this.lastHeartbeat
+        };
+      }
+      /**
+       * Emit event to all subscribers
        */
       async emitEvent(event) {
         for (const callback of this.subscribers) {
           try {
             await callback(event);
           } catch (error) {
-            console.error("[REMOTE_WATCHER] Error in subscriber callback:", error);
+            console.error("[IN_SANDBOX_WATCHER] Error in subscriber callback:", error);
           }
         }
       }
     };
-    RemoteFileWatcherManager = class {
+    InSandboxWatcherManager = class {
       watchers = /* @__PURE__ */ new Map();
       /**
-       * Start watching a session's sandbox
+       * Start watching a sandbox
        */
       async startWatching(options) {
         const { sessionId } = options;
-        const existing = this.watchers.get(sessionId);
-        if (existing) {
-          await existing.stop();
-        }
-        const watcher = new RemoteSandboxFileWatcher(options);
+        await this.stopWatching(sessionId);
+        const watcher = new InSandboxWatcher(options);
         await watcher.start();
         this.watchers.set(sessionId, watcher);
         return watcher;
@@ -6285,17 +6524,16 @@ var init_sandbox_file_watcher = __esm({
         }
       }
       /**
-       * Get a watcher for a session
+       * Get watcher for a session
        */
       getWatcher(sessionId) {
         return this.watchers.get(sessionId);
       }
       /**
-       * Check if a session is being watched
+       * Check if watching
        */
       isWatching(sessionId) {
-        const watcher = this.watchers.get(sessionId);
-        return watcher?.isActive() ?? false;
+        return this.watchers.get(sessionId)?.isActive() ?? false;
       }
       /**
        * Stop all watchers
@@ -6306,7 +6544,7 @@ var init_sandbox_file_watcher = __esm({
         this.watchers.clear();
       }
     };
-    globalRemoteWatcherManager = null;
+    globalInSandboxManager = null;
   }
 });
 function extractErrorMessage(error) {
@@ -6355,6 +6593,7 @@ var SandboxFileSync;
 var init_sandbox_file_sync = __esm({
   "src/runtime/sandbox-file-sync.ts"() {
     init_sandbox_file_watcher();
+    init_in_sandbox_watcher();
     init_types();
     SandboxFileSync = class {
       fileStore;
@@ -6365,7 +6604,7 @@ var init_sandbox_file_sync = __esm({
       eventStorage;
       webhookConfig;
       // Watcher management
-      remoteWatchers = /* @__PURE__ */ new Map();
+      inSandboxWatchers = /* @__PURE__ */ new Map();
       localWatchers = /* @__PURE__ */ new Map();
       fileChangeSubscribers = /* @__PURE__ */ new Set();
       // Sequence number cache per session (for event storage)
@@ -7156,34 +7395,27 @@ var init_sandbox_file_sync = __esm({
           this.localWatchers.set(sessionId, watcher);
           console.log(`[FILE_SYNC] Started local file watching for session ${sessionId} at ${opts.localPath}`);
         } else {
-          if (!this.sandboxOps) {
-            throw new Error("Sandbox operations not configured. Call setSandboxOperations first.");
-          }
-          const watcher = new RemoteSandboxFileWatcher({
+          const watcher = new InSandboxWatcher({
             sessionId,
-            sandboxOps: this.sandboxOps,
-            basePath: watchPath,
-            // Use watchPath instead of sandboxBasePath
-            pollIntervalMs: opts.pollIntervalMs ?? 2e3,
-            ignored: opts.ignored ?? ["**/node_modules/**", "**/.git/**"],
+            watchPath,
             onFileChange: handleFileChange,
             onError: (error) => {
-              console.error(`[FILE_SYNC] Remote watcher error for session ${sessionId}:`, error);
+              console.error(`[FILE_SYNC] In-sandbox watcher error for session ${sessionId}:`, error);
             }
           });
           await watcher.start();
-          this.remoteWatchers.set(sessionId, watcher);
-          console.log(`[FILE_SYNC] Started remote file watching for session ${sessionId} at path: ${watchPath}`);
+          this.inSandboxWatchers.set(sessionId, watcher);
+          console.log(`[FILE_SYNC] Started in-sandbox file watching for session ${sessionId} at path: ${watchPath}`);
         }
       }
       /**
        * Stop watching a session's sandbox
        */
       async stopWatching(sessionId) {
-        const remoteWatcher = this.remoteWatchers.get(sessionId);
-        if (remoteWatcher) {
-          await remoteWatcher.stop();
-          this.remoteWatchers.delete(sessionId);
+        const inSandboxWatcher = this.inSandboxWatchers.get(sessionId);
+        if (inSandboxWatcher) {
+          await inSandboxWatcher.stop();
+          this.inSandboxWatchers.delete(sessionId);
         }
         const localWatcher = this.localWatchers.get(sessionId);
         if (localWatcher) {
@@ -7195,7 +7427,7 @@ var init_sandbox_file_sync = __esm({
        * Check if a session is being watched
        */
       isWatching(sessionId) {
-        return this.remoteWatchers.has(sessionId) || this.localWatchers.has(sessionId);
+        return this.inSandboxWatchers.has(sessionId) || this.localWatchers.has(sessionId);
       }
       /**
        * Subscribe to file change events across all watched sessions.
@@ -7229,10 +7461,10 @@ var init_sandbox_file_sync = __esm({
        * Stop all watchers and cleanup
        */
       async stopAllWatching() {
-        const remotePromises = Array.from(this.remoteWatchers.values()).map((w) => w.stop());
+        const inSandboxPromises = Array.from(this.inSandboxWatchers.values()).map((w) => w.stop());
         const localPromises = Array.from(this.localWatchers.values()).map((w) => w.stop());
-        await Promise.all([...remotePromises, ...localPromises]);
-        this.remoteWatchers.clear();
+        await Promise.all([...inSandboxPromises, ...localPromises]);
+        this.inSandboxWatchers.clear();
         this.localWatchers.clear();
       }
       /**
@@ -7240,8 +7472,8 @@ var init_sandbox_file_sync = __esm({
        */
       getWatchingStatus() {
         const statuses = [];
-        for (const [sessionId, watcher] of this.remoteWatchers) {
-          statuses.push({ sessionId, type: "remote", isActive: watcher.isActive() });
+        for (const [sessionId, watcher] of this.inSandboxWatchers) {
+          statuses.push({ sessionId, type: "in-sandbox", isActive: watcher.isActive() });
         }
         for (const [sessionId, watcher] of this.localWatchers) {
           statuses.push({ sessionId, type: "local", isActive: watcher.isActive() });
@@ -7252,364 +7484,6 @@ var init_sandbox_file_sync = __esm({
   }
 });
 
-// src/runtime/in-sandbox-watcher.ts
-function createInSandboxWatcher(options) {
-  return new InSandboxWatcher(options);
-}
-function getInSandboxWatcherManager() {
-  if (!globalInSandboxManager) {
-    globalInSandboxManager = new InSandboxWatcherManager();
-  }
-  return globalInSandboxManager;
-}
-function createInSandboxWatcherManager() {
-  return new InSandboxWatcherManager();
-}
-var WATCHER_SCRIPT, InSandboxWatcher, InSandboxWatcherManager, globalInSandboxManager;
-var init_in_sandbox_watcher = __esm({
-  "src/runtime/in-sandbox-watcher.ts"() {
-    init_vercel_sandbox_executor();
-    WATCHER_SCRIPT = `
-const fs = require('fs');
-const path = require('path');
-
-const watchPath = process.argv[2] || '.';
-const ignored = new Set(['node_modules', '.git', '.cache', '__pycache__']);
-
-// Track all watchers for cleanup
-const watchers = new Map();
-
-// Debounce map to coalesce rapid changes
-const pending = new Map();
-const DEBOUNCE_MS = 100;
-
-function emit(type, filePath) {
-  const event = {
-    type,
-    path: filePath,
-    timestamp: Date.now()
-  };
-  console.log(JSON.stringify(event));
-}
-
-function shouldIgnore(name) {
-  return ignored.has(name) || name.startsWith('.');
-}
-
-function watchDir(dir) {
-  try {
-    const watcher = fs.watch(dir, { persistent: true }, (eventType, filename) => {
-      if (!filename || shouldIgnore(filename)) return;
-
-      const fullPath = path.join(dir, filename);
-      const key = fullPath;
-
-      // Debounce
-      if (pending.has(key)) {
-        clearTimeout(pending.get(key));
-      }
-
-      pending.set(key, setTimeout(() => {
-        pending.delete(key);
-
-        fs.stat(fullPath, (err, stats) => {
-          if (err) {
-            if (err.code === 'ENOENT') {
-              emit('unlink', fullPath);
-              // Stop watching if it was a directory
-              if (watchers.has(fullPath)) {
-                watchers.get(fullPath).close();
-                watchers.delete(fullPath);
-              }
-            }
-          } else {
-            const type = eventType === 'rename' ? 'add' : 'change';
-            emit(type, fullPath);
-
-            // If it's a new directory, start watching it
-            if (stats.isDirectory() && !watchers.has(fullPath)) {
-              watchDir(fullPath);
-            }
-          }
-        });
-      }, DEBOUNCE_MS));
-    });
-
-    watchers.set(dir, watcher);
-
-    // Watch subdirectories
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isDirectory() && !shouldIgnore(entry.name)) {
-        watchDir(path.join(dir, entry.name));
-      }
-    }
-  } catch (err) {
-    // Directory may not exist or be inaccessible
-    console.error(JSON.stringify({ error: err.message, dir }));
-  }
-}
-
-// Start watching
-watchDir(watchPath);
-
-// Keep alive
-process.on('SIGTERM', () => {
-  for (const watcher of watchers.values()) {
-    watcher.close();
-  }
-  process.exit(0);
-});
-
-// Heartbeat to indicate we're running
-setInterval(() => {
-  console.log(JSON.stringify({ heartbeat: true, timestamp: Date.now() }));
-}, 5000);
-
-console.log(JSON.stringify({ started: true, path: watchPath }));
-`;
-    InSandboxWatcher = class {
-      sessionId;
-      watchPath;
-      outputPollIntervalMs;
-      sandboxState = null;
-      outputPollTimer = null;
-      subscribers = /* @__PURE__ */ new Set();
-      isRunning = false;
-      startedAt;
-      lastHeartbeat;
-      lastOutputPosition = 0;
-      onError;
-      onReady;
-      constructor(options) {
-        this.sessionId = options.sessionId;
-        this.watchPath = options.watchPath;
-        this.outputPollIntervalMs = options.outputPollIntervalMs ?? 1e3;
-        this.onError = options.onError;
-        this.onReady = options.onReady;
-        if (options.onFileChange) {
-          this.subscribers.add(options.onFileChange);
-        }
-      }
-      /**
-       * Start the watcher process inside the sandbox
-       */
-      async start() {
-        if (this.isRunning) {
-          console.warn(`[IN_SANDBOX_WATCHER] Already running for session ${this.sessionId}`);
-          return;
-        }
-        try {
-          this.sandboxState = await getOrCreateSandbox({
-            sessionId: this.sessionId,
-            runtime: "node22",
-            timeout: 600
-          });
-          const { sandbox } = this.sandboxState;
-          const scriptPath = "/tmp/.file-watcher.js";
-          const outputPath = "/tmp/.file-watcher-output.log";
-          const writeScriptCmd = `cat > ${scriptPath} << 'WATCHER_EOF'
-${WATCHER_SCRIPT}
-WATCHER_EOF`;
-          await sandbox.runCommand({
-            cmd: "sh",
-            args: ["-c", writeScriptCmd]
-          });
-          const startCmd = `nohup node ${scriptPath} "${this.watchPath}" > ${outputPath} 2>&1 &`;
-          await sandbox.runCommand({
-            cmd: "sh",
-            args: ["-c", startCmd]
-          });
-          console.log(`[IN_SANDBOX_WATCHER] Started watcher in sandbox for ${this.watchPath}`);
-          this.isRunning = true;
-          this.startedAt = /* @__PURE__ */ new Date();
-          this.outputPollTimer = setInterval(async () => {
-            try {
-              await this.pollOutput(outputPath);
-            } catch (error) {
-              console.error("[IN_SANDBOX_WATCHER] Error polling output:", error);
-              if (this.onError && error instanceof Error) {
-                this.onError(error);
-              }
-            }
-          }, this.outputPollIntervalMs);
-          setTimeout(() => {
-            this.pollOutput(outputPath).catch(console.error);
-          }, 500);
-        } catch (error) {
-          console.error(`[IN_SANDBOX_WATCHER] Failed to start watcher:`, error);
-          throw error;
-        }
-      }
-      /**
-       * Poll the output file for new events
-       */
-      async pollOutput(outputPath) {
-        if (!this.sandboxState?.sandbox) return;
-        try {
-          const result = await this.sandboxState.sandbox.runCommand({
-            cmd: "sh",
-            args: ["-c", `tail -c +${this.lastOutputPosition + 1} ${outputPath} 2>/dev/null || true`]
-          });
-          const output = await result.stdout();
-          if (output && output.trim()) {
-            const sizeResult = await this.sandboxState.sandbox.runCommand({
-              cmd: "sh",
-              args: ["-c", `stat -c%s ${outputPath} 2>/dev/null || echo 0`]
-            });
-            const sizeStr = await sizeResult.stdout();
-            this.lastOutputPosition = parseInt(sizeStr.trim(), 10) || 0;
-            this.processOutput(output);
-          }
-        } catch {
-        }
-      }
-      /**
-       * Process output from the watcher script
-       */
-      processOutput(stdout) {
-        const lines = stdout.split("\n").filter(Boolean);
-        for (const line of lines) {
-          try {
-            const data = JSON.parse(line);
-            if (data.started) {
-              console.log(`[IN_SANDBOX_WATCHER] Watcher started for ${data.path}`);
-              if (this.onReady) {
-                this.onReady();
-              }
-            } else if (data.heartbeat) {
-              this.lastHeartbeat = new Date(data.timestamp);
-            } else if (data.error) {
-              console.warn(`[IN_SANDBOX_WATCHER] Error in sandbox:`, data.error);
-            } else if (data.type && data.path) {
-              this.emitEvent({
-                type: data.type,
-                relativePath: data.path.replace(/^\.\//, ""),
-                absolutePath: data.path,
-                basePath: this.watchPath,
-                sessionId: this.sessionId,
-                timestamp: new Date(data.timestamp)
-              });
-            }
-          } catch {
-          }
-        }
-      }
-      /**
-       * Stop the watcher process
-       */
-      async stop() {
-        if (!this.isRunning) {
-          return;
-        }
-        if (this.outputPollTimer) {
-          clearInterval(this.outputPollTimer);
-          this.outputPollTimer = null;
-        }
-        try {
-          if (this.sandboxState?.sandbox) {
-            await this.sandboxState.sandbox.runCommand({
-              cmd: "sh",
-              args: ["-c", "pkill -f file-watcher.js 2>/dev/null || true"]
-            });
-            await this.sandboxState.sandbox.runCommand({
-              cmd: "sh",
-              args: ["-c", "rm -f /tmp/.file-watcher.js /tmp/.file-watcher-output.log"]
-            });
-          }
-        } catch {
-        }
-        this.isRunning = false;
-        this.sandboxState = null;
-        this.lastOutputPosition = 0;
-        console.log(`[IN_SANDBOX_WATCHER] Stopped watcher for session ${this.sessionId}`);
-      }
-      /**
-       * Subscribe to file change events
-       */
-      subscribe(callback) {
-        this.subscribers.add(callback);
-        return () => this.subscribers.delete(callback);
-      }
-      /**
-       * Check if watcher is running
-       */
-      isActive() {
-        return this.isRunning;
-      }
-      /**
-       * Get watcher status
-       */
-      getStatus() {
-        return {
-          sessionId: this.sessionId,
-          watchPath: this.watchPath,
-          isRunning: this.isRunning,
-          startedAt: this.startedAt,
-          lastHeartbeat: this.lastHeartbeat
-        };
-      }
-      /**
-       * Emit event to all subscribers
-       */
-      async emitEvent(event) {
-        for (const callback of this.subscribers) {
-          try {
-            await callback(event);
-          } catch (error) {
-            console.error("[IN_SANDBOX_WATCHER] Error in subscriber callback:", error);
-          }
-        }
-      }
-    };
-    InSandboxWatcherManager = class {
-      watchers = /* @__PURE__ */ new Map();
-      /**
-       * Start watching a sandbox
-       */
-      async startWatching(options) {
-        const { sessionId } = options;
-        await this.stopWatching(sessionId);
-        const watcher = new InSandboxWatcher(options);
-        await watcher.start();
-        this.watchers.set(sessionId, watcher);
-        return watcher;
-      }
-      /**
-       * Stop watching a session
-       */
-      async stopWatching(sessionId) {
-        const watcher = this.watchers.get(sessionId);
-        if (watcher) {
-          await watcher.stop();
-          this.watchers.delete(sessionId);
-        }
-      }
-      /**
-       * Get watcher for a session
-       */
-      getWatcher(sessionId) {
-        return this.watchers.get(sessionId);
-      }
-      /**
-       * Check if watching
-       */
-      isWatching(sessionId) {
-        return this.watchers.get(sessionId)?.isActive() ?? false;
-      }
-      /**
-       * Stop all watchers
-       */
-      async stopAll() {
-        const promises = Array.from(this.watchers.values()).map((w) => w.stop());
-        await Promise.all(promises);
-        this.watchers.clear();
-      }
-    };
-    globalInSandboxManager = null;
-  }
-});
-
 // src/runtime/index.ts
 function generateDockerCommand(config) {
   const args = ["docker", "run"];
@@ -8042,7 +7916,7 @@ var init_credentials = __esm({
   }
 });
 var gitHubSkillSourceSchema, localSkillSourceSchema, skillSourceSchema, skillConfigSchema, fileEntrySchema;
-var init_types3 = __esm({
+var init_types4 = __esm({
   "src/skills/types.ts"() {
     gitHubSkillSourceSchema = z.object({
       type: z.literal("github"),
@@ -8586,7 +8460,7 @@ var init_manager2 = __esm({
 // src/skills/index.ts
 var init_skills = __esm({
   "src/skills/index.ts"() {
-    init_types3();
+    init_types4();
     init_local_provider();
     init_github_provider();
     init_manager2();
@@ -18106,7 +17980,7 @@ var init_storage3 = __esm({
         }
         if (options.filePath) {
           query = query.or(
-            `event_data->>filePath.eq.${options.filePath},and(category.eq.tool,tool_name.in.(Read,Write,Edit),event_data->input->>file_path.eq.${options.filePath})`
+            `event_data->>filePath.eq.${options.filePath},event_data->>canonicalPath.eq.${options.filePath},and(category.eq.tool,tool_name.in.(Read,Write,Edit),event_data->input->>file_path.eq.${options.filePath})`
           );
         }
         const ascending = options.order !== "desc";
@@ -18990,6 +18864,6 @@ var init_src = __esm({
 });
 init_src();
 
-export { AVAILABLE_MODELS, AgentConfigSchema, AgentError, AgentHarness, AgentStatus, AshCloud, AshCloudApiError, AshCloudClient, AttachmentConfigSchema, AttachmentStorage, ClaudeSdkClient, CloudSandbox, CloudStorage, ConfigBuilder, ConfigError, CredentialManager, DEFAULT_MODELS, DEFAULT_SANDBOX_PROVIDER_CONFIG, EventCategory, FileWatcherManager, GCSBundleStore, GeminiCliClient, GitHubFileProvider, HarnessConfigSchema, HarnessError, HarnessErrorCode, HarnessEventEmitter, InSandboxWatcher, InSandboxWatcherManager, LocalBundleStore, LocalFileProvider, LocalSandbox, McpConfigBuilder, McpPresets, McpServers, MemoryBundleStore, MemoryCredentialStorage, MemoryQueueStorage, MemoryRateLimitStore, MemoryStorage, MessageRole, NotFoundError, PostgresQueueStorage, PostgresStorage, ProviderSandbox, QueueItemStatus, QueueProcessor, RemoteFileWatcherManager, RemoteSandboxFileWatcher, RuntimeConfigBuilder, RuntimePresets, S3BundleStore, S3FileStore, SENSITIVE_PATHS, SandboxFileSync, SandboxFileWatcher, SandboxGitRepo, SandboxLogger, SandboxPool, ServerConfigSchema, SessionError, SessionManager, SessionStatus, SkillCatalog, SkillManager, StorageConfigSchema, StorageError, StreamEventType, SupabaseBundleStore, SupabaseStorage, ToolCallProcessor, ToolError, ValidationError, Workspace, WorkspaceManager, attachmentSchema, attachmentToDataUrl, checkSecurityConfig, claudeClient, cleanupAllSandboxes, configureMcp, configureRuntime, convertClaudeMessage, createAgentsRouter, createAshCloud, createBackendExecutor, createCloudSandbox, createConfig, createCredentialManager, createOpenAPIServer as createDocumentedServer, createE2BSandbox, createEventHandler, createEventMiddlewareChain, createFileWatcher, createFileWatcherManager, createGCSBundleStore, createGeminiExecutor, createGitHubFileProvider, createGitRepo, createHarnessServer, createInSandboxWatcher, createInSandboxWatcherManager, createLocalBundleStore, createLocalFileProvider, createLocalSandbox, createLogger, createMemoryBundleStore, createMinioBundleStore, createMinioFileStore, createModalSandbox, createAgentsRouter2 as createOpenAPIAgentsRouter, createOpenAPIServer, createSessionsRouter2 as createOpenAPISessionsRouter, createSkillsRouter2 as createOpenAPISkillsRouter, createProviderSandbox, createQueueProcessor, createQueueRouter, createR2BundleStore, createR2FileStore, createRemoteFileWatcher, createRemoteFileWatcherManager, createS3BundleStore, createS3FileStore, createSandboxFileOperations, createSandboxFileSync, createSandboxLogger, createSandboxOptions, createSessionWorkspace, createSessionsRouter, createSkillCatalog, createSkillManager, createSupabaseBundleStore, createSupabaseBundleStoreFromEnv, createToolCall, createToolCallProcessor, createVercelSandbox, createVercelSandboxExecutor, createWorkspace, createWorkspaceHooks, createWorkspaceManager, dataUrlToBuffer, defineAgent, defineConfig, ensureSandboxPoolInitialized, env, envOptional, extractTextContent, extractTextFromMessage, fileEntrySchema, formatToolName, generateDockerCommand, generateMcpServerPackage, generateMcpServers, generateProxyEnv, generateToolSummary, getActionIcon, getActionLabel, getAllHeartbeatStatuses, getApiKeyEnvVar, getDefaultModel, getFileWatcherManager, getHeartbeatStatus, getInSandboxWatcherManager, getOrCreateSandbox, getRemoteFileWatcherManager, getSandboxCacheStats, getSandboxPool, getWorkspaceManager, gitHubSkillSourceSchema, globalEventEmitter, hasErrorCode, hashStartupScript, httpMcpWithAuth, initializeSandboxPool, introspectMcpServer, invalidateSandbox, isCommandRunAction, isDocumentMimeType, isErrorEntry, isFileEditAction, isFileReadAction, isFileWriteAction, isGenericToolAction, isGlobAction, isHarnessError, isHttpMcpConfig, isImageMimeType, isMcpToolAction, isSandboxExpiredError, isSandboxRunning, isSearchAction, isSensitivePath, isStdioMcpConfig, isTodoWriteAction, isToolCallEntry, isValidModel, isWebFetchAction, isWebSearchAction, listFilesInSandbox, loadConfig, loadGitHubSkill, loadGitHubSkills, loadWorkspaceState, localSkillSourceSchema, log, mapClaudeOptionsToGemini, mapToolToActionType, markConfigInstalled, markSdkInstalled, markStartupScriptRan, mcpAuthToHeaders, messageContentSchema, messageSchema, needsStartupScriptRerun, normalizeGitHubConfigs, normalizeMcpServers, normalizeMessages, normalizeToolResult, onHeartbeat, schemas_exports as openApiSchemas, parseCommandResult, parseGitHubUrl, parseMcpToolName, processStreamEvents, rateLimit, rateLimiters, readFileFromSandbox, rekeySessionId, releaseSandbox, requestLogger, saveWorkspaceState, schema_exports as schema, sessionSchema, shouldUseSandbox, shutdownSandboxPool, skillConfigSchema, skillSourceSchema, sseMcpWithAuth, startServer, updateToolCallWithResult, writeFileToSandbox };
+export { AVAILABLE_MODELS, AgentConfigSchema, AgentError, AgentHarness, AgentStatus, AshCloud, AshCloudApiError, AshCloudClient, AttachmentConfigSchema, AttachmentStorage, ClaudeSdkClient, CloudSandbox, CloudStorage, ConfigBuilder, ConfigError, CredentialManager, DEFAULT_MODELS, DEFAULT_SANDBOX_PROVIDER_CONFIG, EventCategory, FileWatcherManager, GCSBundleStore, GeminiCliClient, GitHubFileProvider, HarnessConfigSchema, HarnessError, HarnessErrorCode, HarnessEventEmitter, InSandboxWatcher, InSandboxWatcherManager, LocalBundleStore, LocalFileProvider, LocalSandbox, McpConfigBuilder, McpPresets, McpServers, MemoryBundleStore, MemoryCredentialStorage, MemoryQueueStorage, MemoryRateLimitStore, MemoryStorage, MessageRole, NotFoundError, PostgresQueueStorage, PostgresStorage, ProviderSandbox, QueueItemStatus, QueueProcessor, RuntimeConfigBuilder, RuntimePresets, S3BundleStore, S3FileStore, SENSITIVE_PATHS, SandboxFileSync, SandboxFileWatcher, SandboxGitRepo, SandboxLogger, SandboxPool, ServerConfigSchema, SessionError, SessionManager, SessionStatus, SkillCatalog, SkillManager, StorageConfigSchema, StorageError, StreamEventType, SupabaseBundleStore, SupabaseStorage, ToolCallProcessor, ToolError, ValidationError, Workspace, WorkspaceManager, attachmentSchema, attachmentToDataUrl, checkSecurityConfig, claudeClient, cleanupAllSandboxes, configureMcp, configureRuntime, convertClaudeMessage, createAgentsRouter, createAshCloud, createBackendExecutor, createCloudSandbox, createConfig, createCredentialManager, createOpenAPIServer as createDocumentedServer, createE2BSandbox, createEventHandler, createEventMiddlewareChain, createFileWatcher, createFileWatcherManager, createGCSBundleStore, createGeminiExecutor, createGitHubFileProvider, createGitRepo, createHarnessServer, createInSandboxWatcher, createInSandboxWatcherManager, createLocalBundleStore, createLocalFileProvider, createLocalSandbox, createLogger, createMemoryBundleStore, createMinioBundleStore, createMinioFileStore, createModalSandbox, createAgentsRouter2 as createOpenAPIAgentsRouter, createOpenAPIServer, createSessionsRouter2 as createOpenAPISessionsRouter, createSkillsRouter2 as createOpenAPISkillsRouter, createProviderSandbox, createQueueProcessor, createQueueRouter, createR2BundleStore, createR2FileStore, createS3BundleStore, createS3FileStore, createSandboxFileOperations, createSandboxFileSync, createSandboxLogger, createSandboxOptions, createSessionWorkspace, createSessionsRouter, createSkillCatalog, createSkillManager, createSupabaseBundleStore, createSupabaseBundleStoreFromEnv, createToolCall, createToolCallProcessor, createVercelSandbox, createVercelSandboxExecutor, createWorkspace, createWorkspaceHooks, createWorkspaceManager, dataUrlToBuffer, defineAgent, defineConfig, ensureSandboxPoolInitialized, env, envOptional, executeCommandInSandbox, extractTextContent, extractTextFromMessage, fileEntrySchema, formatToolName, generateDockerCommand, generateMcpServerPackage, generateMcpServers, generateProxyEnv, generateToolSummary, getActionIcon, getActionLabel, getAllHeartbeatStatuses, getApiKeyEnvVar, getCachedSandbox, getDefaultModel, getFileWatcherManager, getHeartbeatStatus, getInSandboxWatcherManager, getOrCreateSandbox, getSandboxCacheStats, getSandboxPool, getWorkspaceManager, gitHubSkillSourceSchema, globalEventEmitter, hasErrorCode, hashStartupScript, httpMcpWithAuth, initializeSandboxPool, introspectMcpServer, invalidateSandbox, isCommandRunAction, isDocumentMimeType, isErrorEntry, isFileEditAction, isFileReadAction, isFileWriteAction, isGenericToolAction, isGlobAction, isHarnessError, isHttpMcpConfig, isImageMimeType, isMcpToolAction, isSandboxExpiredError, isSandboxRunning, isSearchAction, isSensitivePath, isStdioMcpConfig, isTodoWriteAction, isToolCallEntry, isValidModel, isWebFetchAction, isWebSearchAction, listFilesInSandbox, loadConfig, loadGitHubSkill, loadGitHubSkills, loadWorkspaceState, localSkillSourceSchema, log, mapClaudeOptionsToGemini, mapToolToActionType, markConfigInstalled, markSdkInstalled, markStartupScriptRan, mcpAuthToHeaders, messageContentSchema, messageSchema, needsStartupScriptRerun, normalizeGitHubConfigs, normalizeMcpServers, normalizeMessages, normalizeToolResult, onHeartbeat, schemas_exports as openApiSchemas, parseCommandResult, parseGitHubUrl, parseMcpToolName, processStreamEvents, rateLimit, rateLimiters, readFileFromSandbox, rekeySessionId, releaseSandbox, requestLogger, saveWorkspaceState, schema_exports as schema, sessionSchema, shouldUseSandbox, shutdownSandboxPool, skillConfigSchema, skillSourceSchema, sseMcpWithAuth, startServer, updateToolCallWithResult, writeFileToSandbox };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map