@ash-cloud/ash-ai 0.1.13 → 0.1.15

package/dist/index.cjs

@@ -5289,6 +5289,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) {
@@ -5357,6 +5374,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) {
@@ -5836,19 +5901,7 @@ function getFileWatcherManager() {
 function createFileWatcherManager() {
   return new exports.FileWatcherManager();
 }
-function createRemoteFileWatcher(options) {
-  return new exports.RemoteSandboxFileWatcher(options);
-}
-function getRemoteFileWatcherManager() {
-  if (!globalRemoteWatcherManager) {
-    globalRemoteWatcherManager = new exports.RemoteFileWatcherManager();
-  }
-  return globalRemoteWatcherManager;
-}
-function createRemoteFileWatcherManager() {
-  return new exports.RemoteFileWatcherManager();
-}
-exports.SandboxFileWatcher = void 0; exports.FileWatcherManager = void 0; var globalWatcherManager; exports.RemoteSandboxFileWatcher = void 0; exports.RemoteFileWatcherManager = void 0; var globalRemoteWatcherManager;
+exports.SandboxFileWatcher = void 0; exports.FileWatcherManager = void 0; var globalWatcherManager;
 var init_sandbox_file_watcher = __esm({
   "src/runtime/sandbox-file-watcher.ts"() {
     exports.SandboxFileWatcher = class {
@@ -6090,214 +6143,327 @@ var init_sandbox_file_watcher = __esm({
       }
     };
     globalWatcherManager = null;
-    exports.RemoteSandboxFileWatcher = class {
+  }
+});
+
+// src/runtime/in-sandbox-watcher.ts
+function createInSandboxWatcher(options) {
+  return new exports.InSandboxWatcher(options);
+}
+function getInSandboxWatcherManager() {
+  if (!globalInSandboxManager) {
+    globalInSandboxManager = new exports.InSandboxWatcherManager();
+  }
+  return globalInSandboxManager;
+}
+function createInSandboxWatcherManager() {
+  return new exports.InSandboxWatcherManager();
+}
+var WATCHER_SCRIPT; exports.InSandboxWatcher = void 0; exports.InSandboxWatcherManager = void 0; var 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 }));
+`;
+    exports.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
-       */
-      subscribe(callback) {
-        this.subscribers.add(callback);
-        return () => this.subscribers.delete(callback);
       }
       /**
-       * Remove a subscriber
+       * Poll the output file for new events
        */
-      unsubscribe(callback) {
-        this.subscribers.delete(callback);
+      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 {
+        }
       }
       /**
-       * Check if watcher is active
+       * Process output from the watcher script
        */
-      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
-        };
-      }
-      /**
-       * Force an immediate scan (useful for testing or manual refresh)
-       */
-      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);
           }
         }
       }
     };
-    exports.RemoteFileWatcherManager = class {
+    exports.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 exports.RemoteSandboxFileWatcher(options);
+        await this.stopWatching(sessionId);
+        const watcher = new exports.InSandboxWatcher(options);
         await watcher.start();
         this.watchers.set(sessionId, watcher);
         return watcher;
@@ -6313,17 +6479,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
@@ -6334,7 +6499,7 @@ var init_sandbox_file_watcher = __esm({
         this.watchers.clear();
       }
     };
-    globalRemoteWatcherManager = null;
+    globalInSandboxManager = null;
   }
 });
 function extractErrorMessage(error) {
@@ -6383,6 +6548,7 @@ exports.SandboxFileSync = void 0;
 var init_sandbox_file_sync = __esm({
   "src/runtime/sandbox-file-sync.ts"() {
     init_sandbox_file_watcher();
+    init_in_sandbox_watcher();
     init_types();
     exports.SandboxFileSync = class {
       fileStore;
@@ -6393,7 +6559,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)
@@ -7184,34 +7350,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 exports.RemoteSandboxFileWatcher({
+          const watcher = new exports.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) {
@@ -7223,7 +7382,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.
@@ -7257,10 +7416,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();
       }
       /**
@@ -7268,8 +7427,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() });
@@ -7280,364 +7439,6 @@ var init_sandbox_file_sync = __esm({
   }
 });
 
-// src/runtime/in-sandbox-watcher.ts
-function createInSandboxWatcher(options) {
-  return new exports.InSandboxWatcher(options);
-}
-function getInSandboxWatcherManager() {
-  if (!globalInSandboxManager) {
-    globalInSandboxManager = new exports.InSandboxWatcherManager();
-  }
-  return globalInSandboxManager;
-}
-function createInSandboxWatcherManager() {
-  return new exports.InSandboxWatcherManager();
-}
-var WATCHER_SCRIPT; exports.InSandboxWatcher = void 0; exports.InSandboxWatcherManager = void 0; var 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 }));
-`;
-    exports.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);
-          }
-        }
-      }
-    };
-    exports.InSandboxWatcherManager = class {
-      watchers = /* @__PURE__ */ new Map();
-      /**
-       * Start watching a sandbox
-       */
-      async startWatching(options) {
-        const { sessionId } = options;
-        await this.stopWatching(sessionId);
-        const watcher = new exports.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"];
@@ -19064,8 +18865,6 @@ exports.createQueueProcessor = createQueueProcessor;
 exports.createQueueRouter = createQueueRouter;
 exports.createR2BundleStore = createR2BundleStore;
 exports.createR2FileStore = createR2FileStore;
-exports.createRemoteFileWatcher = createRemoteFileWatcher;
-exports.createRemoteFileWatcherManager = createRemoteFileWatcherManager;
 exports.createS3BundleStore = createS3BundleStore;
 exports.createS3FileStore = createS3FileStore;
 exports.createSandboxFileOperations = createSandboxFileOperations;
@@ -19091,6 +18890,7 @@ exports.defineConfig = defineConfig;
 exports.ensureSandboxPoolInitialized = ensureSandboxPoolInitialized;
 exports.env = env;
 exports.envOptional = envOptional;
+exports.executeCommandInSandbox = executeCommandInSandbox;
 exports.extractTextContent = extractTextContent;
 exports.extractTextFromMessage = extractTextFromMessage;
 exports.formatToolName = formatToolName;
@@ -19103,12 +18903,12 @@ exports.getActionIcon = getActionIcon;
 exports.getActionLabel = getActionLabel;
 exports.getAllHeartbeatStatuses = getAllHeartbeatStatuses;
 exports.getApiKeyEnvVar = getApiKeyEnvVar;
+exports.getCachedSandbox = getCachedSandbox;
 exports.getDefaultModel = getDefaultModel;
 exports.getFileWatcherManager = getFileWatcherManager;
 exports.getHeartbeatStatus = getHeartbeatStatus;
 exports.getInSandboxWatcherManager = getInSandboxWatcherManager;
 exports.getOrCreateSandbox = getOrCreateSandbox;
-exports.getRemoteFileWatcherManager = getRemoteFileWatcherManager;
 exports.getSandboxCacheStats = getSandboxCacheStats;
 exports.getSandboxPool = getSandboxPool;
 exports.getWorkspaceManager = getWorkspaceManager;