sparkecoder 0.1.64 → 0.1.65

package/dist/index.js

@@ -524,6 +524,25 @@ var init_config = __esm({
 });
 
 // src/db/remote.ts
+var remote_exports = {};
+__export(remote_exports, {
+  closeRemoteDatabase: () => closeRemoteDatabase,
+  initRemoteDatabase: () => initRemoteDatabase,
+  isRemoteConfigured: () => isRemoteConfigured,
+  remoteActiveStreamQueries: () => remoteActiveStreamQueries,
+  remoteCheckpointQueries: () => remoteCheckpointQueries,
+  remoteFileBackupQueries: () => remoteFileBackupQueries,
+  remoteIndexStatusQueries: () => remoteIndexStatusQueries,
+  remoteIndexedChunkQueries: () => remoteIndexedChunkQueries,
+  remoteMessageQueries: () => remoteMessageQueries,
+  remoteSessionQueries: () => remoteSessionQueries,
+  remoteSkillQueries: () => remoteSkillQueries,
+  remoteSubagentQueries: () => remoteSubagentQueries,
+  remoteTerminalQueries: () => remoteTerminalQueries,
+  remoteTodoQueries: () => remoteTodoQueries,
+  remoteToolExecutionQueries: () => remoteToolExecutionQueries,
+  storageQueries: () => storageQueries
+});
 function initRemoteDatabase(serverUrl, key) {
   remoteServerUrl = serverUrl.replace(/\/$/, "");
   authKey = key;
@@ -532,6 +551,9 @@ function closeRemoteDatabase() {
   remoteServerUrl = null;
   authKey = null;
 }
+function isRemoteConfigured() {
+  return !!remoteServerUrl && !!authKey;
+}
 function parseDates(obj) {
   if (obj === null || obj === void 0) return obj;
   if (Array.isArray(obj)) return obj.map(parseDates);
@@ -579,7 +601,29 @@ async function api(path, options = {}) {
   }
   return parseDates(parsed);
 }
-var remoteServerUrl, authKey, DATE_FIELDS, MODEL_MESSAGE_FIELDS, remoteSessionQueries, remoteMessageQueries, remoteToolExecutionQueries, remoteTodoQueries, remoteSkillQueries, remoteActiveStreamQueries, remoteCheckpointQueries, remoteFileBackupQueries, remoteSubagentQueries, remoteIndexStatusQueries;
+async function storageApi(path, options = {}) {
+  if (!remoteServerUrl || !authKey) {
+    throw new Error("Remote database not initialized");
+  }
+  const url = `${remoteServerUrl}/storage${path}`;
+  const init = {
+    method: options.method || "GET",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${authKey}`
+    }
+  };
+  if (options.body) {
+    init.body = JSON.stringify(options.body);
+  }
+  const response = await fetch(url, init);
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => "Unknown error");
+    throw new Error(`Storage API error ${response.status}: ${errorText}`);
+  }
+  return response.json();
+}
+var remoteServerUrl, authKey, DATE_FIELDS, MODEL_MESSAGE_FIELDS, remoteSessionQueries, remoteMessageQueries, remoteToolExecutionQueries, remoteTodoQueries, remoteSkillQueries, remoteTerminalQueries, remoteActiveStreamQueries, remoteCheckpointQueries, remoteFileBackupQueries, remoteSubagentQueries, remoteIndexedChunkQueries, remoteIndexStatusQueries, storageQueries;
 var init_remote = __esm({
   "src/db/remote.ts"() {
     "use strict";
@@ -718,6 +762,34 @@ var init_remote = __esm({
         return result.isLoaded;
       }
     };
+    remoteTerminalQueries = {
+      create(data) {
+        return api("/terminals", { method: "POST", body: data });
+      },
+      getById(id) {
+        return api(`/terminals/${id}`).catch(() => void 0);
+      },
+      getBySession(sessionId) {
+        return api(`/terminals/session/${sessionId}`);
+      },
+      getRunning(sessionId) {
+        return api(`/terminals/session/${sessionId}/running`);
+      },
+      updateStatus(id, status, exitCode, error) {
+        return api(`/terminals/${id}`, { method: "PATCH", body: { status, exitCode, error } });
+      },
+      updatePid(id, pid) {
+        return api(`/terminals/${id}`, { method: "PATCH", body: { pid } });
+      },
+      async delete(id) {
+        const result = await api(`/terminals/${id}`, { method: "DELETE" });
+        return result?.success ?? false;
+      },
+      async deleteBySession(sessionId) {
+        const result = await api(`/terminals/session/${sessionId}`, { method: "DELETE" });
+        return result.deleted;
+      }
+    };
     remoteActiveStreamQueries = {
       create(sessionId, streamId) {
         return api("/streams", { method: "POST", body: { sessionId, streamId } });
@@ -821,6 +893,41 @@ var init_remote = __esm({
         return result.deleted;
       }
     };
+    remoteIndexedChunkQueries = {
+      upsert(_db, data) {
+        return api("/indexed-chunks", { method: "POST", body: data });
+      },
+      batchUpsert(_db, chunks) {
+        return api("/indexed-chunks/batch", {
+          method: "POST",
+          body: { chunks }
+        });
+      },
+      getById(_db, id) {
+        return api(`/indexed-chunks/${id}`).catch(() => void 0);
+      },
+      getByNamespace(_db, namespace) {
+        return api(`/indexed-chunks/namespace/${namespace}`);
+      },
+      getByFilePath(_db, namespace, filePath) {
+        return api(`/indexed-chunks/namespace/${namespace}/file/${encodeURIComponent(filePath)}`);
+      },
+      async deleteByNamespace(_db, namespace) {
+        const result = await api(`/indexed-chunks/namespace/${namespace}`, { method: "DELETE" });
+        return result.deleted;
+      },
+      async deleteByFilePath(_db, namespace, filePath) {
+        const result = await api(
+          `/indexed-chunks/namespace/${namespace}/file/${encodeURIComponent(filePath)}`,
+          { method: "DELETE" }
+        );
+        return result.deleted;
+      },
+      async countByNamespace(_db, namespace) {
+        const result = await api(`/indexed-chunks/namespace/${namespace}/count`);
+        return result.count;
+      }
+    };
     remoteIndexStatusQueries = {
       upsert(_db, data) {
         return api("/index-status", {
@@ -843,6 +950,27 @@ var init_remote = __esm({
         return api("/index-status");
       }
     };
+    storageQueries = {
+      async getUploadUrl(sessionId, fileName, contentType, category) {
+        return storageApi("/upload-url", {
+          method: "POST",
+          body: { sessionId, fileName, contentType, category }
+        });
+      },
+      async getSessionFiles(sessionId) {
+        const result = await storageApi(`/files/${sessionId}`);
+        return result.files;
+      },
+      async getDownloadUrl(fileId) {
+        return storageApi(`/download/${fileId}`);
+      },
+      async deleteFile(fileId) {
+        await storageApi(`/files/${fileId}`, { method: "DELETE" });
+      },
+      async updateFile(fileId, data) {
+        await storageApi(`/files/${fileId}`, { method: "PATCH", body: data });
+      }
+    };
   }
 });
 
@@ -1645,11 +1773,287 @@ var init_webhook = __esm({
   }
 });
 
+// src/browser/stream-proxy.ts
+var stream_proxy_exports = {};
+__export(stream_proxy_exports, {
+  BrowserStreamProxy: () => BrowserStreamProxy,
+  destroyProxy: () => destroyProxy,
+  getOrCreateProxy: () => getOrCreateProxy,
+  getProxy: () => getProxy
+});
+import WebSocket from "ws";
+import { EventEmitter } from "events";
+function getOrCreateProxy(sessionId, port) {
+  let proxy = activeProxies.get(sessionId);
+  if (proxy && !proxy.connected) {
+    proxy.destroy();
+    proxy = void 0;
+  }
+  if (!proxy) {
+    proxy = new BrowserStreamProxy(port);
+    activeProxies.set(sessionId, proxy);
+    proxy.on("close", () => {
+      activeProxies.delete(sessionId);
+    });
+    proxy.connect();
+  }
+  return proxy;
+}
+function getProxy(sessionId) {
+  return activeProxies.get(sessionId);
+}
+function destroyProxy(sessionId) {
+  const proxy = activeProxies.get(sessionId);
+  if (proxy) {
+    proxy.destroy();
+    activeProxies.delete(sessionId);
+  }
+}
+var RECONNECT_DELAY_MS, MAX_RECONNECT_ATTEMPTS, FRAME_THROTTLE_MS, BrowserStreamProxy, activeProxies;
+var init_stream_proxy = __esm({
+  "src/browser/stream-proxy.ts"() {
+    "use strict";
+    RECONNECT_DELAY_MS = 500;
+    MAX_RECONNECT_ATTEMPTS = 10;
+    FRAME_THROTTLE_MS = 100;
+    BrowserStreamProxy = class extends EventEmitter {
+      ws = null;
+      port;
+      reconnectAttempts = 0;
+      reconnectTimer = null;
+      destroyed = false;
+      lastFrameTime = 0;
+      _latestFrame = null;
+      _connected = false;
+      constructor(port) {
+        super();
+        this.port = port;
+      }
+      get connected() {
+        return this._connected;
+      }
+      get latestFrame() {
+        return this._latestFrame;
+      }
+      connect() {
+        if (this.destroyed) return;
+        this.doConnect();
+      }
+      doConnect() {
+        if (this.destroyed) return;
+        const url = `ws://localhost:${this.port}`;
+        try {
+          this.ws = new WebSocket(url);
+        } catch {
+          this.scheduleReconnect();
+          return;
+        }
+        this.ws.on("open", () => {
+          this.reconnectAttempts = 0;
+          this._connected = true;
+          this.emit("status", {
+            connected: true,
+            screencasting: true
+          });
+        });
+        this.ws.on("message", (raw) => {
+          try {
+            const msg = JSON.parse(typeof raw === "string" ? raw : raw.toString("utf8"));
+            this.handleMessage(msg);
+          } catch {
+          }
+        });
+        this.ws.on("close", () => {
+          this._connected = false;
+          this.emit("status", { connected: false, screencasting: false });
+          if (!this.destroyed) {
+            this.scheduleReconnect();
+          }
+        });
+        this.ws.on("error", () => {
+        });
+      }
+      handleMessage(msg) {
+        if (msg.type === "frame") {
+          const now = Date.now();
+          if (now - this.lastFrameTime < FRAME_THROTTLE_MS) return;
+          this.lastFrameTime = now;
+          const frame = {
+            data: msg.data,
+            metadata: msg.metadata ?? {
+              deviceWidth: 1280,
+              deviceHeight: 720,
+              pageScaleFactor: 1,
+              offsetTop: 0,
+              scrollOffsetX: 0,
+              scrollOffsetY: 0
+            },
+            timestamp: now
+          };
+          this._latestFrame = frame;
+          this.emit("frame", frame);
+        } else if (msg.type === "status") {
+          this.emit("status", {
+            connected: msg.connected ?? true,
+            screencasting: msg.screencasting ?? true,
+            viewportWidth: msg.viewportWidth,
+            viewportHeight: msg.viewportHeight
+          });
+        }
+      }
+      scheduleReconnect() {
+        if (this.destroyed || this.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+          this.emit("close");
+          return;
+        }
+        this.reconnectAttempts++;
+        const delay = RECONNECT_DELAY_MS * this.reconnectAttempts;
+        this.reconnectTimer = setTimeout(() => this.doConnect(), delay);
+      }
+      /**
+       * Send an input event to the browser for pair-browsing.
+       */
+      injectInput(event) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+          this.ws.send(JSON.stringify(event));
+        }
+      }
+      destroy() {
+        this.destroyed = true;
+        if (this.reconnectTimer) {
+          clearTimeout(this.reconnectTimer);
+          this.reconnectTimer = null;
+        }
+        if (this.ws) {
+          this.ws.removeAllListeners();
+          this.ws.close();
+          this.ws = null;
+        }
+        this._connected = false;
+        this.removeAllListeners();
+      }
+    };
+    activeProxies = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/browser/recorder.ts
+var recorder_exports = {};
+__export(recorder_exports, {
+  FrameRecorder: () => FrameRecorder
+});
+import { exec as exec5 } from "child_process";
+import { promisify as promisify5 } from "util";
+import { writeFile as writeFile4, mkdir as mkdir4, readFile as readFile10, unlink as unlink2, readdir as readdir5, rm } from "fs/promises";
+import { join as join6 } from "path";
+import { tmpdir } from "os";
+import { nanoid as nanoid3 } from "nanoid";
+async function checkFfmpeg() {
+  try {
+    await execAsync5("ffmpeg -version", { timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function cleanup(dir) {
+  try {
+    await rm(dir, { recursive: true, force: true });
+  } catch {
+  }
+}
+var execAsync5, FrameRecorder;
+var init_recorder = __esm({
+  "src/browser/recorder.ts"() {
+    "use strict";
+    execAsync5 = promisify5(exec5);
+    FrameRecorder = class {
+      frames = [];
+      startTime = null;
+      recording = false;
+      sessionId;
+      constructor(sessionId) {
+        this.sessionId = sessionId;
+      }
+      get isRecording() {
+        return this.recording;
+      }
+      get frameCount() {
+        return this.frames.length;
+      }
+      start() {
+        this.frames = [];
+        this.startTime = Date.now();
+        this.recording = true;
+      }
+      addFrame(frame) {
+        if (!this.recording) return;
+        this.frames.push({
+          data: Buffer.from(frame.data, "base64"),
+          timestamp: frame.timestamp
+        });
+      }
+      stop() {
+        this.recording = false;
+      }
+      /**
+       * Encode recorded frames into an MP4 using ffmpeg.
+       * Returns the file path to the generated MP4, or null if encoding fails.
+       */
+      async encode() {
+        if (this.frames.length === 0) return null;
+        const workDir = join6(tmpdir(), `sparkecoder-recording-${nanoid3(8)}`);
+        await mkdir4(workDir, { recursive: true });
+        try {
+          for (let i = 0; i < this.frames.length; i++) {
+            const framePath = join6(workDir, `frame_${String(i).padStart(6, "0")}.jpg`);
+            await writeFile4(framePath, this.frames[i].data);
+          }
+          const duration = (this.frames[this.frames.length - 1].timestamp - this.frames[0].timestamp) / 1e3;
+          const fps = duration > 0 ? Math.round(this.frames.length / duration) : 10;
+          const clampedFps = Math.max(1, Math.min(fps, 30));
+          const outputPath = join6(workDir, `recording_${this.sessionId}.mp4`);
+          const hasFfmpeg = await checkFfmpeg();
+          if (hasFfmpeg) {
+            await execAsync5(
+              `ffmpeg -y -framerate ${clampedFps} -i "${join6(workDir, "frame_%06d.jpg")}" -c:v libx264 -pix_fmt yuv420p -preset fast -crf 23 "${outputPath}"`,
+              { timeout: 12e4 }
+            );
+          } else {
+            console.warn("[RECORDER] ffmpeg not available, cannot encode recording");
+            await cleanup(workDir);
+            return null;
+          }
+          const outputBuf = await readFile10(outputPath);
+          const files = await readdir5(workDir);
+          for (const f of files) {
+            if (f.startsWith("frame_")) {
+              await unlink2(join6(workDir, f)).catch(() => {
+              });
+            }
+          }
+          return { path: outputPath, sizeBytes: outputBuf.length };
+        } catch (error) {
+          console.error("[RECORDER] Failed to encode recording:", error);
+          await cleanup(workDir);
+          return null;
+        }
+      }
+      /** Discard all frames and free memory */
+      clear() {
+        this.frames = [];
+        this.startTime = null;
+        this.recording = false;
+      }
+    };
+  }
+});
+
 // src/agent/index.ts
 import {
   streamText as streamText2,
   generateText as generateText3,
-  tool as tool12,
+  tool as tool13,
   stepCountIs as stepCountIs2
 } from "ai";
 
@@ -1830,8 +2234,8 @@ var SUBAGENT_MODELS = {
 // src/agent/index.ts
 init_db();
 init_config();
-import { z as z13 } from "zod";
-import { nanoid as nanoid3 } from "nanoid";
+import { z as z14 } from "zod";
+import { nanoid as nanoid4 } from "nanoid";
 
 // src/tools/bash.ts
 import { tool } from "ai";
@@ -2134,8 +2538,8 @@ async function listSessionTerminals(sessionId, workingDirectory) {
   const terminalsDir = join2(workingDirectory, LOG_BASE_DIR, sessionId, "terminals");
   const terminals2 = [];
   try {
-    const { readdir: readdir6 } = await import("fs/promises");
-    const entries = await readdir6(terminalsDir, { withFileTypes: true });
+    const { readdir: readdir7 } = await import("fs/promises");
+    const entries = await readdir7(terminalsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory()) {
         const meta = await getMeta(entry.name, workingDirectory, sessionId);
@@ -2197,6 +2601,29 @@ function isBlockedCommand(command) {
     (blocked) => normalizedCommand.includes(blocked.toLowerCase())
   );
 }
+var BROWSER_STREAM_BASE_PORT = 9223;
+var sessionBrowserPorts = /* @__PURE__ */ new Map();
+var nextPortOffset = 0;
+function getBrowserStreamPort(sessionId) {
+  let port = sessionBrowserPorts.get(sessionId);
+  if (!port) {
+    port = BROWSER_STREAM_BASE_PORT + nextPortOffset++;
+    sessionBrowserPorts.set(sessionId, port);
+  }
+  return port;
+}
+function isAgentBrowserOpenCommand(command) {
+  return /\bagent-browser\s+open\b/.test(command);
+}
+function isAgentBrowserCloseCommand(command) {
+  return /\bagent-browser\s+close\b/.test(command);
+}
+function injectBrowserStreamPort(command, port) {
+  return command.replace(
+    /\bagent-browser\b/,
+    `AGENT_BROWSER_STREAM_PORT=${port} agent-browser`
+  );
+}
 var bashInputSchema = z2.object({
   command: z2.string().optional().describe("The command to execute. Required for running new commands."),
   background: z2.boolean().default(false).describe("Run the command in background mode (for dev servers, watchers). Returns immediately with terminal ID."),
@@ -2362,6 +2789,14 @@ Terminal output is stored in the global SparkECoder data directory. Use the \`ta
           exitCode: 1
         };
       }
+      let actualCommand = command;
+      const browserOpen = isAgentBrowserOpenCommand(command);
+      const browserClose = isAgentBrowserCloseCommand(command);
+      let browserPort;
+      if (browserOpen) {
+        browserPort = getBrowserStreamPort(options.sessionId);
+        actualCommand = injectBrowserStreamPort(command, browserPort);
+      }
       const canUseTmux = await shouldUseTmux();
       if (background) {
         if (!canUseTmux) {
@@ -2371,11 +2806,14 @@ Terminal output is stored in the global SparkECoder data directory. Use the \`ta
           };
         }
         const terminalId = generateTerminalId();
-        options.onProgress?.({ terminalId, status: "started", command });
-        const result = await runBackground(command, options.workingDirectory, {
+        options.onProgress?.({ terminalId, status: "started", command, browserStreamPort: browserPort });
+        const result = await runBackground(actualCommand, options.workingDirectory, {
           sessionId: options.sessionId,
           terminalId
         });
+        if (browserOpen && browserPort) {
+          options.onProgress?.({ terminalId, status: "running", command, browserStreamPort: browserPort });
+        }
         return {
           success: true,
           id: result.id,
@@ -2385,16 +2823,16 @@ Terminal output is stored in the global SparkECoder data directory. Use the \`ta
       }
       if (canUseTmux) {
         const terminalId = generateTerminalId();
-        options.onProgress?.({ terminalId, status: "started", command });
+        options.onProgress?.({ terminalId, status: "started", command, browserStreamPort: browserPort });
         try {
-          const result = await runSync(command, options.workingDirectory, {
+          const result = await runSync(actualCommand, options.workingDirectory, {
             sessionId: options.sessionId,
             timeout: COMMAND_TIMEOUT,
             terminalId
           });
           const truncatedOutput = truncateOutput(result.output, MAX_OUTPUT_CHARS2);
           options.onOutput?.(truncatedOutput);
-          options.onProgress?.({ terminalId, status: "completed", command });
+          options.onProgress?.({ terminalId, status: "completed", command, browserStreamPort: browserClose ? browserPort : void 0 });
           return {
             success: result.exitCode === 0,
             id: result.id,
@@ -2412,7 +2850,7 @@ Terminal output is stored in the global SparkECoder data directory. Use the \`ta
           };
         }
       } else {
-        const result = await execFallback(command, options.workingDirectory, options.onOutput);
+        const result = await execFallback(actualCommand, options.workingDirectory, options.onOutput);
         return {
           success: result.success,
           output: result.output,
@@ -2787,12 +3225,12 @@ function findNearestRoot(startDir, markers) {
 }
 async function commandExists(cmd) {
   try {
-    const { exec: exec6 } = await import("child_process");
-    const { promisify: promisify6 } = await import("util");
-    const execAsync6 = promisify6(exec6);
+    const { exec: exec7 } = await import("child_process");
+    const { promisify: promisify7 } = await import("util");
+    const execAsync7 = promisify7(exec7);
     const isWindows = process.platform === "win32";
     const checkCmd = isWindows ? `where ${cmd}` : `which ${cmd}`;
-    await execAsync6(checkCmd);
+    await execAsync7(checkCmd);
     return true;
   } catch {
     return false;
@@ -3090,7 +3528,7 @@ async function createClient(serverId, handle, root) {
         const startTime = Date.now();
         let debounceTimer;
         let resolved = false;
-        const cleanup = () => {
+        const cleanup2 = () => {
           if (debounceTimer) clearTimeout(debounceTimer);
           const listeners = diagnosticListeners.get(normalized);
           if (listeners) {
@@ -3104,7 +3542,7 @@ async function createClient(serverId, handle, root) {
         const finish = () => {
           if (resolved) return;
           resolved = true;
-          cleanup();
+          cleanup2();
           resolve11(diagnostics.get(normalized) || []);
         };
         const onDiagnostic = () => {
@@ -5209,8 +5647,106 @@ function createTaskFailedTool(options) {
   });
 }
 
+// src/tools/upload-file.ts
+import { tool as tool12 } from "ai";
+import { z as z13 } from "zod";
+import { readFile as readFile9, stat as stat4 } from "fs/promises";
+import { join as join5, basename as basename4, extname as extname7 } from "path";
+var MIME_TYPES = {
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".html": "text/html",
+  ".css": "text/css",
+  ".js": "application/javascript",
+  ".ts": "application/typescript",
+  ".json": "application/json",
+  ".csv": "text/csv",
+  ".xml": "application/xml",
+  ".pdf": "application/pdf",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".zip": "application/zip",
+  ".tar": "application/x-tar",
+  ".gz": "application/gzip"
+};
+function createUploadFileTool(options) {
+  return tool12({
+    description: `Upload a file to cloud storage and get back a shareable download URL. Use this when the user needs a hosted link to a file (e.g. a generated report, image, export, or any artifact they want to download or share). The file must already exist on disk.`,
+    inputSchema: z13.object({
+      path: z13.string().describe("Path to the file to upload (relative to working directory or absolute)"),
+      name: z13.string().optional().describe("Display name for the file (defaults to the filename)")
+    }),
+    execute: async (input) => {
+      try {
+        const { isRemoteConfigured: isRemoteConfigured2, storageQueries: storageQueries2 } = await Promise.resolve().then(() => (init_remote(), remote_exports));
+        if (!isRemoteConfigured2()) {
+          return {
+            success: false,
+            error: "File upload is not available \u2014 remote server with GCS is not configured."
+          };
+        }
+        const fullPath = input.path.startsWith("/") ? input.path : join5(options.workingDirectory, input.path);
+        try {
+          await stat4(fullPath);
+        } catch {
+          return {
+            success: false,
+            error: `File not found: ${input.path}`
+          };
+        }
+        const fileName = input.name || basename4(fullPath);
+        const ext = extname7(fullPath).toLowerCase();
+        const contentType = MIME_TYPES[ext] || "application/octet-stream";
+        const uploadInfo = await storageQueries2.getUploadUrl(
+          options.sessionId,
+          fileName,
+          contentType,
+          "general"
+        );
+        const fileData = await readFile9(fullPath);
+        const putRes = await fetch(uploadInfo.uploadUrl, {
+          method: "PUT",
+          headers: { "Content-Type": contentType },
+          body: fileData
+        });
+        if (!putRes.ok) {
+          return {
+            success: false,
+            error: `Upload failed: ${putRes.status} ${putRes.statusText}`
+          };
+        }
+        await storageQueries2.updateFile(uploadInfo.fileId, { sizeBytes: fileData.length });
+        const downloadInfo = await storageQueries2.getDownloadUrl(uploadInfo.fileId);
+        return {
+          success: true,
+          fileId: uploadInfo.fileId,
+          fileName,
+          sizeBytes: fileData.length,
+          contentType,
+          downloadUrl: downloadInfo.downloadUrl,
+          expiresAt: downloadInfo.expiresAt
+        };
+      } catch (err) {
+        return {
+          success: false,
+          error: `Upload failed: ${err.message}`
+        };
+      }
+    }
+  });
+}
+
 // src/tools/index.ts
 init_semantic();
+init_remote();
 init_semantic_search();
 async function createTools(options) {
   const tools = {
@@ -5248,6 +5784,12 @@ async function createTools(options) {
       workingDirectory: options.workingDirectory
     })
   };
+  if (isRemoteConfigured()) {
+    tools.upload_file = createUploadFileTool({
+      workingDirectory: options.workingDirectory,
+      sessionId: options.sessionId
+    });
+  }
   if (options.enableSemanticSearch !== false) {
     try {
       if (isVectorGatewayConfigured()) {
@@ -5342,6 +5884,7 @@ You have access to powerful tools for:
 - **load_skill**: Load specialized knowledge documents for specific tasks
 - **explore_agent**: Explore agent for semantic discovery - for exploratory questions and finding code by meaning
 - **code_graph**: Inspect a symbol's type hierarchy and usage graph via the TypeScript language server
+- **upload_file**: Upload a file to cloud storage and get a shareable download URL (available when remote storage is configured)
 
 
 IMPORTANT: If you have zero context of where you are working, always explore it first to understand the structure before doing things for the user.
@@ -5600,14 +6143,53 @@ function buildTaskPromptAddendum(outputSchema) {
 ## Task Mode
 
 You are running in **task mode**. You have been given a specific task to complete autonomously.
+You have access to ALL the same tools as a normal session \u2014 bash, read_file, write_file, linter, todo, load_skill, explore_agent, code_graph, upload_file, and more. Use them all. This is not a limited session.
+If you need to give the user a downloadable file (report, image, export, etc.), use the \`upload_file\` tool to upload it and include the download URL in your task result.
 
 ### Rules
 1. Work independently \u2014 no human will approve tool calls. All tools run without approval.
-2. Keep working until the task is fully complete.
+2. Keep working until the task is fully complete \u2014 and then VERIFY it is complete before finishing.
 3. When done, call the \`complete_task\` tool with a JSON result matching the output schema below.
 4. If you determine the task is impossible or encounter an unrecoverable error, call the \`task_failed\` tool with a clear reason.
 5. Do NOT stop without calling one of these two tools.
 
+### Verification \u2014 BE EXTREMELY THOROUGH
+Before calling \`complete_task\`, you MUST verify your work completely. Do not just assume it worked. Actually check.
+
+**After making code changes:**
+- Run the **linter** on every file you touched to catch type errors and lint issues. Fix any you introduced.
+- **Read back the files you edited** to confirm the changes are correct and complete \u2014 don't rely on memory.
+- If there are **tests**, run them (\`npm test\`, \`pytest\`, etc.) and ensure they pass.
+- If you created new files, verify they exist and contain what you expect.
+
+**For UI / web changes:**
+- Start the dev server if it isn't already running (it might be so double check ur context)
+- **Open the browser** to verify the changes visually: using your agent-browser tool read the skill
+- Check the dev server logs for errors or warnings.
+- If the app crashes or shows errors, fix them before completing.
+
+**For backend / API changes:**
+- Test the endpoint with curl or a quick script to confirm it works as expected.
+- Check server logs for errors.
+
+**For search and exploration tasks:**
+- Actually search in the RIGHT directories \u2014 don't just search the root if the relevant code is in \`src/\`, \`app/\`, \`lib/\`, etc.
+- Use \`explore_agent\` for semantic/conceptual questions and \`grep\`/\`code_graph\` for exact lookups.
+- Cross-reference findings \u2014 if you find something in one place, verify related files are consistent.
+- Don't stop at the first match \u2014 make sure you've found ALL relevant occurrences.
+
+**General verification checklist:**
+- Re-read the original task prompt and confirm every requirement has been addressed.
+- If the task asked for multiple things, verify EACH one individually.
+- If something doesn't look right, fix it \u2014 don't complete with known issues.
+
+### Use All Available Tools
+- **load_skill**: Load specialized skills/knowledge relevant to the task. Check what skills are available and use them.
+- **explore_agent**: Use for codebase exploration and understanding before making changes.
+- **code_graph**: Use to understand type hierarchies, references, and impact before refactoring.
+- **todo**: Track your progress on multi-step tasks so you don't miss steps.
+- **bash**: Full shell access \u2014 run builds, tests, dev servers, open browsers, curl endpoints, anything.
+
 ### Output Schema
 The \`complete_task\` tool expects a \`result\` object matching this JSON Schema:
 \`\`\`json
@@ -5615,7 +6197,7 @@ ${JSON.stringify(outputSchema, null, 2)}
 \`\`\`
 
 ### Completion Tools
-- **\`complete_task({ result: ... })\`** \u2014 Call when the task is done. The result is validated against the schema above. If validation fails you will get errors back \u2014 fix and retry.
+- **\`complete_task({ result: ... })\`** \u2014 Call ONLY after thorough verification. The result is validated against the schema above. If validation fails you will get errors back \u2014 fix and retry.
 - **\`task_failed({ reason: "..." })\`** \u2014 Call only if the task truly cannot be completed.
 `;
 }
@@ -6123,11 +6705,29 @@ ${prompt}` });
     const onComplete = (signal) => {
       completion.signal = signal;
     };
+    let taskRecorder = null;
+    const sessionId = this.session.id;
+    const bashProgressHandler = (progress) => {
+      options.onToolProgress?.({ toolName: "bash", data: progress });
+      const port = progress.browserStreamPort;
+      if (port && progress.status === "started") {
+        Promise.resolve().then(() => (init_stream_proxy(), stream_proxy_exports)).then(({ getOrCreateProxy: getOrCreateProxy2 }) => {
+          const proxy = getOrCreateProxy2(sessionId, port);
+          if (!taskRecorder) {
+            Promise.resolve().then(() => (init_recorder(), recorder_exports)).then(({ FrameRecorder: FrameRecorder2 }) => {
+              taskRecorder = new FrameRecorder2(sessionId);
+              taskRecorder.start();
+              proxy.on("frame", (frame) => taskRecorder?.addFrame(frame));
+            });
+          }
+        });
+      }
+    };
     const taskTools = await createTools({
       sessionId: this.session.id,
       workingDirectory: this.session.workingDirectory,
       skillsDirectories: config.resolvedSkillsDirectories,
-      onBashProgress: options.onToolProgress ? (progress) => options.onToolProgress({ toolName: "bash", data: progress }) : void 0,
+      onBashProgress: bashProgressHandler,
       onWriteFileProgress: options.onToolProgress ? (progress) => options.onToolProgress({ toolName: "write_file", data: progress }) : void 0,
       onSearchProgress: options.onToolProgress ? (progress) => options.onToolProgress({ toolName: "explore_agent", data: progress }) : void 0,
       taskTools: {
@@ -6198,12 +6798,24 @@ ${taskAddendum}`;
       if (completion.signal) {
         const sig = completion.signal;
         const finalStatus = sig.status;
+        let fileUrls;
+        if (finalStatus === "completed" && sig.result && typeof sig.result === "object") {
+          const resultObj = sig.result;
+          const filePaths = Array.isArray(resultObj.files) ? resultObj.files : [];
+          if (filePaths.length > 0) {
+            fileUrls = await this.uploadTaskFiles(filePaths);
+          }
+        }
+        const recordingUrls = await this.finishTaskRecording(taskRecorder);
+        const allFileUrls = [...fileUrls || [], ...recordingUrls];
         const eventType = finalStatus === "completed" ? "task.completed" : "task.failed";
         fireWebhook(eventType, {
           status: finalStatus,
           result: sig.result,
           error: sig.error,
-          iterations: iteration
+          iterations: iteration,
+          fileUrls: allFileUrls.length > 0 ? allFileUrls : void 0,
+          browserRecordingUrls: recordingUrls.length > 0 ? recordingUrls : void 0
         });
         const updatedTask2 = {
           ...options.taskConfig,
@@ -6223,11 +6835,17 @@ ${taskAddendum}`;
         };
       }
       await this.context.addUserMessage(
-        "Continue working on the task. When done, call `complete_task` with the result. If you cannot complete it, call `task_failed` with a reason."
+        "Continue working on the task. Before calling `complete_task`, VERIFY your work is correct \u2014 re-read edited files, run the linter, run tests if applicable, and check the browser/server if you made UI or API changes. Make sure you searched the right directories and found everything relevant. When fully verified, call `complete_task` with the result. If you cannot complete it, call `task_failed` with a reason."
       );
     }
     const timeoutError = `Task did not complete within ${maxIterations} iterations`;
-    fireWebhook("task.failed", { status: "failed", error: timeoutError, iterations: iteration });
+    const timeoutRecordingUrls = await this.finishTaskRecording(taskRecorder);
+    fireWebhook("task.failed", {
+      status: "failed",
+      error: timeoutError,
+      iterations: iteration,
+      browserRecordingUrls: timeoutRecordingUrls.length > 0 ? timeoutRecordingUrls : void 0
+    });
     const updatedTask = {
       ...options.taskConfig,
       status: "failed",
@@ -6239,6 +6857,113 @@ ${taskAddendum}`;
     });
     return { status: "failed", error: timeoutError, iterations: iteration };
   }
+  /**
+   * Stop a task-mode browser recording, encode to MP4, upload to GCS.
+   * Returns download URLs for any recordings produced.
+   */
+  async finishTaskRecording(recorder) {
+    try {
+      const { destroyProxy: destroyProxy2 } = await Promise.resolve().then(() => (init_stream_proxy(), stream_proxy_exports));
+      destroyProxy2(this.session.id);
+    } catch {
+    }
+    if (!recorder || recorder.frameCount === 0) {
+      recorder?.clear();
+      return [];
+    }
+    recorder.stop();
+    try {
+      const { isRemoteConfigured: isRemoteConfigured2, storageQueries: storageQueries2 } = await Promise.resolve().then(() => (init_remote(), remote_exports));
+      if (!isRemoteConfigured2()) {
+        recorder.clear();
+        return [];
+      }
+      const result = await recorder.encode();
+      recorder.clear();
+      if (!result) return [];
+      const { readFile: readFile11, unlink: unlink3 } = await import("fs/promises");
+      const uploadInfo = await storageQueries2.getUploadUrl(
+        this.session.id,
+        `browser-recording-${Date.now()}.mp4`,
+        "video/mp4",
+        "browser-recording"
+      );
+      const fileData = await readFile11(result.path);
+      await fetch(uploadInfo.uploadUrl, {
+        method: "PUT",
+        headers: { "Content-Type": "video/mp4" },
+        body: fileData
+      });
+      await storageQueries2.updateFile(uploadInfo.fileId, { sizeBytes: result.sizeBytes });
+      const dlInfo = await storageQueries2.getDownloadUrl(uploadInfo.fileId);
+      await unlink3(result.path).catch(() => {
+      });
+      console.log(`[TASK] Browser recording uploaded (${result.sizeBytes} bytes)`);
+      return [dlInfo.downloadUrl];
+    } catch (err) {
+      console.error("[TASK] Failed to upload browser recording:", err.message);
+      recorder.clear();
+      return [];
+    }
+  }
+  /**
+   * Upload task output files to GCS via the remote server.
+   * Returns an array of download URLs for successfully uploaded files.
+   */
+  async uploadTaskFiles(filePaths) {
+    try {
+      const { isRemoteConfigured: isRemoteConfigured2, storageQueries: storageQueries2 } = await Promise.resolve().then(() => (init_remote(), remote_exports));
+      if (!isRemoteConfigured2()) return [];
+      const { readFile: readFile11 } = await import("fs/promises");
+      const { join: join11, basename: basename6 } = await import("path");
+      const urls = [];
+      for (const filePath of filePaths) {
+        try {
+          const fullPath = filePath.startsWith("/") ? filePath : join11(this.session.workingDirectory, filePath);
+          const fileName = basename6(fullPath);
+          const ext = fileName.split(".").pop()?.toLowerCase() || "";
+          const mimeMap = {
+            pdf: "application/pdf",
+            json: "application/json",
+            csv: "text/csv",
+            txt: "text/plain",
+            md: "text/markdown",
+            html: "text/html",
+            png: "image/png",
+            jpg: "image/jpeg",
+            jpeg: "image/jpeg",
+            gif: "image/gif",
+            svg: "image/svg+xml",
+            mp4: "video/mp4",
+            zip: "application/zip"
+          };
+          const contentType = mimeMap[ext] || "application/octet-stream";
+          const uploadInfo = await storageQueries2.getUploadUrl(
+            this.session.id,
+            fileName,
+            contentType,
+            "task-output"
+          );
+          const fileData = await readFile11(fullPath);
+          await fetch(uploadInfo.uploadUrl, {
+            method: "PUT",
+            headers: { "Content-Type": contentType },
+            body: fileData
+          });
+          await storageQueries2.updateFile(uploadInfo.fileId, { sizeBytes: fileData.length });
+          const downloadInfo = await storageQueries2.getDownloadUrl(uploadInfo.fileId);
+          urls.push(downloadInfo.downloadUrl);
+          console.log(`[TASK] Uploaded file: ${fileName} (${fileData.length} bytes)`);
+        } catch (err) {
+          console.error(`[TASK] Failed to upload file ${filePath}:`, err.message);
+        }
+      }
+      return urls;
+    } catch (err) {
+      console.error("[TASK] File upload failed:", err.message);
+      return [];
+    }
+  }
   /**
    * Wrap tools to add approval checking
    */
@@ -6252,11 +6977,11 @@ ${taskAddendum}`;
         wrappedTools[name] = originalTool;
         continue;
       }
-      wrappedTools[name] = tool12({
+      wrappedTools[name] = tool13({
         description: originalTool.description || "",
-        inputSchema: originalTool.inputSchema || z13.object({}),
+        inputSchema: originalTool.inputSchema || z14.object({}),
         execute: async (input, toolOptions) => {
-          const toolCallId = toolOptions.toolCallId || nanoid3();
+          const toolCallId = toolOptions.toolCallId || nanoid4();
           const execution = toolExecutionQueries.create({
             sessionId: this.session.id,
             toolName: name,
@@ -6274,10 +6999,10 @@ ${taskAddendum}`;
           const resolverData = approvalResolvers.get(toolCallId);
           approvalResolvers.delete(toolCallId);
           this.pendingApprovals.delete(toolCallId);
-          const exec6 = await execution;
+          const exec7 = await execution;
           if (!approved) {
             const reason = resolverData?.reason || "User rejected the tool execution";
-            await toolExecutionQueries.reject(exec6.id);
+            await toolExecutionQueries.reject(exec7.id);
             await sessionQueries.updateStatus(this.session.id, "active");
             return {
               status: "rejected",
@@ -6287,14 +7012,14 @@ ${taskAddendum}`;
               message: `Tool "${name}" was rejected by the user. Reason: ${reason}`
             };
           }
-          await toolExecutionQueries.approve(exec6.id);
+          await toolExecutionQueries.approve(exec7.id);
           await sessionQueries.updateStatus(this.session.id, "active");
           try {
             const result = await originalTool.execute(input, toolOptions);
-            await toolExecutionQueries.complete(exec6.id, result);
+            await toolExecutionQueries.complete(exec7.id, result);
             return result;
           } catch (error) {
-            await toolExecutionQueries.complete(exec6.id, null, error.message);
+            await toolExecutionQueries.complete(exec7.id, null, error.message);
             throw error;
           }
         }
@@ -6370,7 +7095,7 @@ import { serve } from "@hono/node-server";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
 import { existsSync as existsSync15, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "fs";
-import { resolve as resolve10, dirname as dirname7, join as join8 } from "path";
+import { resolve as resolve10, dirname as dirname7, join as join10 } from "path";
 import { spawn as spawn2 } from "child_process";
 import { createServer as createNetServer } from "net";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -6379,11 +7104,11 @@ import { fileURLToPath as fileURLToPath4 } from "url";
 init_db();
 import { Hono } from "hono";
 import { zValidator } from "@hono/zod-validator";
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 import { existsSync as existsSync13, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2, readdirSync, statSync as statSync2, unlinkSync } from "fs";
-import { readdir as readdir5 } from "fs/promises";
-import { join as join5, basename as basename4, extname as extname7, relative as relative9 } from "path";
-import { nanoid as nanoid4 } from "nanoid";
+import { readdir as readdir6 } from "fs/promises";
+import { join as join7, basename as basename5, extname as extname8, relative as relative9 } from "path";
+import { nanoid as nanoid5 } from "nanoid";
 init_config();
 
 // src/server/devtools-store.ts
@@ -6415,18 +7140,18 @@ function cleanupPendingInputs() {
     }
   }
 }
-var createSessionSchema = z14.object({
-  name: z14.string().optional(),
-  workingDirectory: z14.string().optional(),
-  model: z14.string().optional(),
-  toolApprovals: z14.record(z14.string(), z14.boolean()).optional()
+var createSessionSchema = z15.object({
+  name: z15.string().optional(),
+  workingDirectory: z15.string().optional(),
+  model: z15.string().optional(),
+  toolApprovals: z15.record(z15.string(), z15.boolean()).optional()
 });
-var paginationQuerySchema = z14.object({
-  limit: z14.string().optional(),
-  offset: z14.string().optional()
+var paginationQuerySchema = z15.object({
+  limit: z15.string().optional(),
+  offset: z15.string().optional()
 });
-var messagesQuerySchema = z14.object({
-  limit: z14.string().optional()
+var messagesQuerySchema = z15.object({
+  limit: z15.string().optional()
 });
 sessions.get(
   "/",
@@ -6565,10 +7290,10 @@ sessions.get("/:id/tools", async (c) => {
     count: executions.length
   });
 });
-var updateSessionSchema = z14.object({
-  model: z14.string().optional(),
-  name: z14.string().optional(),
-  toolApprovals: z14.record(z14.string(), z14.boolean()).optional()
+var updateSessionSchema = z15.object({
+  model: z15.string().optional(),
+  name: z15.string().optional(),
+  toolApprovals: z15.record(z15.string(), z15.boolean()).optional()
 });
 sessions.patch(
   "/:id",
@@ -6638,8 +7363,8 @@ sessions.post("/:id/clear", async (c) => {
   await agent.clearContext();
   return c.json({ success: true, sessionId: id });
 });
-var pendingInputSchema = z14.object({
-  text: z14.string()
+var pendingInputSchema = z15.object({
+  text: z15.string()
 });
 sessions.post(
   "/:id/pending-input",
@@ -6670,13 +7395,13 @@ sessions.get("/:id/pending-input", async (c) => {
     createdAt: pending.createdAt.toISOString()
   });
 });
-var devtoolsContextSchema = z14.object({
-  url: z14.string(),
-  path: z14.string(),
-  pageName: z14.string().optional(),
-  screenWidth: z14.number().optional(),
-  screenHeight: z14.number().optional(),
-  devicePixelRatio: z14.number().optional()
+var devtoolsContextSchema = z15.object({
+  url: z15.string(),
+  path: z15.string(),
+  pageName: z15.string().optional(),
+  screenWidth: z15.number().optional(),
+  screenHeight: z15.number().optional(),
+  devicePixelRatio: z15.number().optional()
 });
 sessions.post(
   "/:id/devtools-context",
@@ -6844,7 +7569,7 @@ sessions.get("/:id/diff/:filePath", async (c) => {
 });
 function getAttachmentsDir(sessionId) {
   const appDataDir = getAppDataDirectory();
-  return join5(appDataDir, "attachments", sessionId);
+  return join7(appDataDir, "attachments", sessionId);
 }
 function ensureAttachmentsDir(sessionId) {
   const dir = getAttachmentsDir(sessionId);
@@ -6865,7 +7590,7 @@ sessions.get("/:id/attachments", async (c) => {
   }
   const files = readdirSync(dir);
   const attachments = files.map((filename) => {
-    const filePath = join5(dir, filename);
+    const filePath = join7(dir, filename);
     const stats = statSync2(filePath);
     return {
       id: filename.split("_")[0],
@@ -6897,10 +7622,10 @@ sessions.post("/:id/attachments", async (c) => {
         return c.json({ error: "No file provided" }, 400);
       }
       const dir = ensureAttachmentsDir(sessionId);
-      const id = nanoid4(10);
-      const ext = extname7(file.name) || "";
-      const safeFilename = `${id}_${basename4(file.name).replace(/[^a-zA-Z0-9._-]/g, "_")}`;
-      const filePath = join5(dir, safeFilename);
+      const id = nanoid5(10);
+      const ext = extname8(file.name) || "";
+      const safeFilename = `${id}_${basename5(file.name).replace(/[^a-zA-Z0-9._-]/g, "_")}`;
+      const filePath = join7(dir, safeFilename);
       const arrayBuffer = await file.arrayBuffer();
       writeFileSync2(filePath, Buffer.from(arrayBuffer));
       return c.json({
@@ -6923,10 +7648,10 @@ sessions.post("/:id/attachments", async (c) => {
       return c.json({ error: "Missing filename or data" }, 400);
     }
     const dir = ensureAttachmentsDir(sessionId);
-    const id = nanoid4(10);
-    const ext = extname7(body.filename) || "";
-    const safeFilename = `${id}_${basename4(body.filename).replace(/[^a-zA-Z0-9._-]/g, "_")}`;
-    const filePath = join5(dir, safeFilename);
+    const id = nanoid5(10);
+    const ext = extname8(body.filename) || "";
+    const safeFilename = `${id}_${basename5(body.filename).replace(/[^a-zA-Z0-9._-]/g, "_")}`;
+    const filePath = join7(dir, safeFilename);
     let base64Data = body.data;
     if (base64Data.includes(",")) {
       base64Data = base64Data.split(",")[1];
@@ -6963,14 +7688,14 @@ sessions.delete("/:id/attachments/:attachmentId", async (c) => {
   if (!file) {
     return c.json({ error: "Attachment not found" }, 404);
   }
-  const filePath = join5(dir, file);
+  const filePath = join7(dir, file);
   unlinkSync(filePath);
   return c.json({ success: true, id: attachmentId });
 });
-var filesQuerySchema = z14.object({
-  query: z14.string().optional(),
+var filesQuerySchema = z15.object({
+  query: z15.string().optional(),
   // Filter query (e.g., "src/com" to match "src/components")
-  limit: z14.string().optional()
+  limit: z15.string().optional()
   // Max results (default 50)
 });
 var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
@@ -7043,10 +7768,10 @@ async function listWorkspaceFiles(baseDir, currentDir, query, limit, results = [
     return results;
   }
   try {
-    const entries = await readdir5(currentDir, { withFileTypes: true });
+    const entries = await readdir6(currentDir, { withFileTypes: true });
     for (const entry of entries) {
       if (results.length >= limit * 2) break;
-      const fullPath = join5(currentDir, entry.name);
+      const fullPath = join7(currentDir, entry.name);
       const relativePath = relative9(baseDir, fullPath);
       if (entry.isDirectory() && IGNORED_DIRECTORIES.has(entry.name)) {
         continue;
@@ -7054,7 +7779,7 @@ async function listWorkspaceFiles(baseDir, currentDir, query, limit, results = [
       if (entry.name.startsWith(".")) {
         continue;
       }
-      const ext = extname7(entry.name).toLowerCase();
+      const ext = extname8(entry.name).toLowerCase();
       if (IGNORED_EXTENSIONS.has(ext)) {
         continue;
       }
@@ -7143,14 +7868,70 @@ sessions.get(
     }
   }
 );
+sessions.get("/:id/session-files", async (c) => {
+  const sessionId = c.req.param("id");
+  try {
+    const { isRemoteConfigured: isRemoteConfigured2 } = await Promise.resolve().then(() => (init_remote(), remote_exports));
+    if (!isRemoteConfigured2()) {
+      return c.json({ files: [] });
+    }
+    const { storageQueries: storageQueries2 } = await Promise.resolve().then(() => (init_remote(), remote_exports));
+    const files = await storageQueries2.getSessionFiles(sessionId);
+    return c.json({ sessionId, files });
+  } catch (err) {
+    console.error("Failed to get session files:", err.message);
+    return c.json({ sessionId, files: [] });
+  }
+});
+sessions.get("/files/:fileId/download", async (c) => {
+  const fileId = c.req.param("fileId");
+  try {
+    const { isRemoteConfigured: isRemoteConfigured2, storageQueries: storageQueries2 } = await Promise.resolve().then(() => (init_remote(), remote_exports));
+    if (!isRemoteConfigured2()) {
+      return c.json({ error: "Remote server not configured" }, 503);
+    }
+    const result = await storageQueries2.getDownloadUrl(fileId);
+    return c.json(result);
+  } catch (err) {
+    return c.json({ error: err.message }, 500);
+  }
+});
+sessions.get("/:id/browser-recording", async (c) => {
+  const sessionId = c.req.param("id");
+  try {
+    const { isRemoteConfigured: isRemoteConfigured2, storageQueries: storageQueries2 } = await Promise.resolve().then(() => (init_remote(), remote_exports));
+    if (!isRemoteConfigured2()) {
+      return c.json({ sessionId, recordings: [] });
+    }
+    const files = await storageQueries2.getSessionFiles(sessionId);
+    const recordings = files.filter((f) => f.category === "browser-recording");
+    if (recordings.length === 0) {
+      return c.json({ sessionId, recordings: [], message: "No browser recordings for this session" });
+    }
+    return c.json({
+      sessionId,
+      recordings: recordings.map((r) => ({
+        id: r.id,
+        fileName: r.fileName,
+        sizeBytes: r.sizeBytes,
+        createdAt: r.createdAt,
+        downloadUrl: r.downloadUrl,
+        expiresAt: r.downloadUrlExpiresAt
+      }))
+    });
+  } catch (err) {
+    console.error("Failed to get browser recordings:", err.message);
+    return c.json({ sessionId, recordings: [], error: err.message });
+  }
+});
 
 // src/server/routes/agents.ts
 init_db();
 import { Hono as Hono2 } from "hono";
 import { zValidator as zValidator2 } from "@hono/zod-validator";
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 import { existsSync as existsSync14, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
-import { join as join6 } from "path";
+import { join as join8 } from "path";
 init_config();
 
 // src/server/resumable-stream.ts
@@ -7226,7 +8007,11 @@ var streamContext = createResumableStreamContext({
 });
 
 // src/server/routes/agents.ts
-import { nanoid as nanoid5 } from "nanoid";
+import { nanoid as nanoid6 } from "nanoid";
+init_stream_proxy();
+init_recorder();
+init_remote();
+var sessionRecorders = /* @__PURE__ */ new Map();
 var MAX_TOOL_INPUT_LENGTH = 8 * 1024;
 var MAX_TOOL_INPUT_PREVIEW = 2 * 1024;
 var MAX_TOOL_ARGS_CHUNK = 2 * 1024;
@@ -7312,36 +8097,72 @@ function enrichPromptWithDevtoolsContext(sessionId, prompt) {
 
 ${prompt}`;
 }
+async function encodAndUploadRecording(sessionId, recorder) {
+  if (!isRemoteConfigured()) {
+    console.log("[RECORDING] Remote server not configured, skipping upload");
+    recorder.clear();
+    return;
+  }
+  console.log(`[RECORDING] Encoding ${recorder.frameCount} frames for session ${sessionId}...`);
+  const result = await recorder.encode();
+  recorder.clear();
+  if (!result) {
+    console.log("[RECORDING] Encoding failed or produced no output");
+    return;
+  }
+  try {
+    const { storageQueries: storageQueries2 } = await Promise.resolve().then(() => (init_remote(), remote_exports));
+    const { readFile: readFile11, unlink: unlink3 } = await import("fs/promises");
+    const uploadInfo = await storageQueries2.getUploadUrl(
+      sessionId,
+      `browser-recording-${Date.now()}.mp4`,
+      "video/mp4",
+      "browser-recording"
+    );
+    const fileData = await readFile11(result.path);
+    await fetch(uploadInfo.uploadUrl, {
+      method: "PUT",
+      headers: { "Content-Type": "video/mp4" },
+      body: fileData
+    });
+    await storageQueries2.updateFile(uploadInfo.fileId, { sizeBytes: result.sizeBytes });
+    console.log(`[RECORDING] Uploaded recording for session ${sessionId} (${result.sizeBytes} bytes)`);
+    await unlink3(result.path).catch(() => {
+    });
+  } catch (err) {
+    console.error("[RECORDING] Upload failed:", err.message);
+  }
+}
 var agents = new Hono2();
-var attachmentSchema = z15.object({
-  type: z15.enum(["image", "file"]),
-  data: z15.string(),
+var attachmentSchema = z16.object({
+  type: z16.enum(["image", "file"]),
+  data: z16.string(),
   // base64 data URL or raw base64
-  mediaType: z15.string().optional(),
-  filename: z15.string().optional()
+  mediaType: z16.string().optional(),
+  filename: z16.string().optional()
 });
-var runPromptSchema = z15.object({
-  prompt: z15.string(),
+var runPromptSchema = z16.object({
+  prompt: z16.string(),
   // Can be empty if attachments are provided
-  attachments: z15.array(attachmentSchema).optional()
+  attachments: z16.array(attachmentSchema).optional()
 }).refine(
   (data) => data.prompt.trim().length > 0 || data.attachments && data.attachments.length > 0,
   { message: "Either prompt or attachments must be provided" }
 );
-var quickStartSchema = z15.object({
-  prompt: z15.string().min(1),
-  name: z15.string().optional(),
-  workingDirectory: z15.string().optional(),
-  model: z15.string().optional(),
-  toolApprovals: z15.record(z15.string(), z15.boolean()).optional()
+var quickStartSchema = z16.object({
+  prompt: z16.string().min(1),
+  name: z16.string().optional(),
+  workingDirectory: z16.string().optional(),
+  model: z16.string().optional(),
+  toolApprovals: z16.record(z16.string(), z16.boolean()).optional()
 });
-var rejectSchema = z15.object({
-  reason: z15.string().optional()
+var rejectSchema = z16.object({
+  reason: z16.string().optional()
 }).optional();
 var streamAbortControllers = /* @__PURE__ */ new Map();
 function getAttachmentsDirectory(sessionId) {
   const appDataDir = getAppDataDirectory();
-  return join6(appDataDir, "attachments", sessionId);
+  return join8(appDataDir, "attachments", sessionId);
 }
 function saveAttachmentToDisk(sessionId, attachment, index) {
   const attachmentsDir = getAttachmentsDirectory(sessionId);
@@ -7357,7 +8178,7 @@ function saveAttachmentToDisk(sessionId, attachment, index) {
   if (base64Data.includes(",")) {
     base64Data = base64Data.split(",")[1];
   }
-  const filePath = join6(attachmentsDir, filename);
+  const filePath = join8(attachmentsDir, filename);
   const buffer = Buffer.from(base64Data, "base64");
   writeFileSync3(filePath, buffer);
   return filePath;
@@ -7525,6 +8346,32 @@ ${prompt}` });
               }));
               await new Promise((resolve11) => setTimeout(resolve11, 0));
             }
+            const browserPort = progress.data?.browserStreamPort;
+            if (progress.toolName === "bash" && browserPort && status === "started") {
+              const proxy = getOrCreateProxy(sessionId, browserPort);
+              let recorder = sessionRecorders.get(sessionId);
+              if (!recorder) {
+                recorder = new FrameRecorder(sessionId);
+                recorder.start();
+                sessionRecorders.set(sessionId, recorder);
+              }
+              proxy.on("frame", (frame) => {
+                recorder.addFrame(frame);
+                writeSSE(JSON.stringify({
+                  type: "browser-frame",
+                  data: frame.data,
+                  metadata: frame.metadata
+                })).catch(() => {
+                });
+              });
+              proxy.on("status", (s) => {
+                writeSSE(JSON.stringify({
+                  type: "browser-status",
+                  ...s
+                })).catch(() => {
+                });
+              });
+            }
           },
           onStepFinish: async () => {
             await writeSSE(JSON.stringify({ type: "finish-step" }));
@@ -7635,6 +8482,15 @@ ${prompt}` });
         }
       } finally {
         cleanupAbortController();
+        destroyProxy(sessionId);
+        const recorder = sessionRecorders.get(sessionId);
+        if (recorder && recorder.frameCount > 0) {
+          sessionRecorders.delete(sessionId);
+          recorder.stop();
+          encodAndUploadRecording(sessionId, recorder).catch((err) => {
+            console.error("[RECORDING] Failed to encode/upload:", err.message);
+          });
+        }
         await writeSSE("[DONE]");
         await safeClose();
       }
@@ -7711,7 +8567,7 @@ ${prompt}` });
       userMessageContent = prompt;
     }
     await messageQueries.create(id, { role: "user", content: userMessageContent });
-    const streamId = `stream_${id}_${nanoid5(10)}`;
+    const streamId = `stream_${id}_${nanoid6(10)}`;
     await activeStreamQueries.create(id, streamId);
     const stream = await streamContext.resumableStream(
       streamId,
@@ -7910,7 +8766,7 @@ agents.post(
     });
     const session = agent.getSession();
     const enrichedPrompt = enrichPromptWithDevtoolsContext(session.id, body.prompt);
-    const streamId = `stream_${session.id}_${nanoid5(10)}`;
+    const streamId = `stream_${session.id}_${nanoid6(10)}`;
     await createCheckpoint(session.id, session.workingDirectory, 0);
     await activeStreamQueries.create(session.id, streamId);
     const createQuickStreamProducer = () => {
@@ -7989,6 +8845,32 @@ agents.post(
                 }));
                 await new Promise((resolve11) => setTimeout(resolve11, 0));
               }
+              const browserPort = progress.data?.browserStreamPort;
+              if (progress.toolName === "bash" && browserPort && status === "started") {
+                const proxy = getOrCreateProxy(session.id, browserPort);
+                let recorder = sessionRecorders.get(session.id);
+                if (!recorder) {
+                  recorder = new FrameRecorder(session.id);
+                  recorder.start();
+                  sessionRecorders.set(session.id, recorder);
+                }
+                proxy.on("frame", (frame) => {
+                  recorder.addFrame(frame);
+                  writeSSE(JSON.stringify({
+                    type: "browser-frame",
+                    data: frame.data,
+                    metadata: frame.metadata
+                  })).catch(() => {
+                  });
+                });
+                proxy.on("status", (s) => {
+                  writeSSE(JSON.stringify({
+                    type: "browser-status",
+                    ...s
+                  })).catch(() => {
+                  });
+                });
+              }
             },
             onStepFinish: async () => {
               await writeSSE(JSON.stringify({ type: "finish-step" }));
@@ -8093,6 +8975,15 @@ agents.post(
           }
         } finally {
           cleanupAbortController();
+          destroyProxy(session.id);
+          const recorder = sessionRecorders.get(session.id);
+          if (recorder && recorder.frameCount > 0) {
+            sessionRecorders.delete(session.id);
+            recorder.stop();
+            encodAndUploadRecording(session.id, recorder).catch((err) => {
+              console.error("[RECORDING] Failed to encode/upload:", err.message);
+            });
+          }
           await writeSSE("[DONE]");
           await safeClose();
         }
@@ -8119,25 +9010,58 @@ agents.post(
     });
   }
 );
+var browserInputSchema = z16.object({
+  type: z16.enum(["input_mouse", "input_keyboard", "input_touch"]),
+  eventType: z16.string(),
+  x: z16.number().optional(),
+  y: z16.number().optional(),
+  button: z16.string().optional(),
+  clickCount: z16.number().optional(),
+  deltaX: z16.number().optional(),
+  deltaY: z16.number().optional(),
+  key: z16.string().optional(),
+  code: z16.string().optional(),
+  text: z16.string().optional(),
+  modifiers: z16.number().optional(),
+  touchPoints: z16.array(z16.object({
+    x: z16.number(),
+    y: z16.number(),
+    id: z16.number().optional()
+  })).optional()
+});
+agents.post(
+  "/:id/browser-input",
+  zValidator2("json", browserInputSchema),
+  async (c) => {
+    const sessionId = c.req.param("id");
+    const event = c.req.valid("json");
+    const proxy = getProxy(sessionId);
+    if (!proxy || !proxy.connected) {
+      return c.json({ error: "No active browser stream for this session" }, 404);
+    }
+    proxy.injectInput(event);
+    return c.json({ success: true });
+  }
+);
 
 // src/server/routes/health.ts
 init_config();
 import { Hono as Hono3 } from "hono";
 import { zValidator as zValidator3 } from "@hono/zod-validator";
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 import { readFileSync as readFileSync5 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { dirname as dirname6, join as join7 } from "path";
+import { dirname as dirname6, join as join9 } from "path";
 var __filename = fileURLToPath3(import.meta.url);
 var __dirname = dirname6(__filename);
 var possiblePaths = [
-  join7(__dirname, "../package.json"),
+  join9(__dirname, "../package.json"),
   // From dist/server -> dist/../package.json
-  join7(__dirname, "../../package.json"),
+  join9(__dirname, "../../package.json"),
   // From dist/server (if nested differently)
-  join7(__dirname, "../../../package.json"),
+  join9(__dirname, "../../../package.json"),
   // From src/server/routes (development)
-  join7(process.cwd(), "package.json")
+  join9(process.cwd(), "package.json")
   // From current working directory
 ];
 var currentVersion = "0.0.0";
@@ -8234,9 +9158,9 @@ health.get("/api-keys", async (c) => {
     supportedProviders: SUPPORTED_PROVIDERS
   });
 });
-var setApiKeySchema = z16.object({
-  provider: z16.string(),
-  apiKey: z16.string().min(1)
+var setApiKeySchema = z17.object({
+  provider: z17.string(),
+  apiKey: z17.string().min(1)
 });
 health.post(
   "/api-keys",
@@ -8275,13 +9199,13 @@ health.delete("/api-keys/:provider", async (c) => {
 // src/server/routes/terminals.ts
 import { Hono as Hono4 } from "hono";
 import { zValidator as zValidator4 } from "@hono/zod-validator";
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 init_db();
 var terminals = new Hono4();
-var spawnSchema = z17.object({
-  command: z17.string(),
-  cwd: z17.string().optional(),
-  name: z17.string().optional()
+var spawnSchema = z18.object({
+  command: z18.string(),
+  cwd: z18.string().optional(),
+  name: z18.string().optional()
 });
 terminals.post(
   "/:sessionId/terminals",
@@ -8362,8 +9286,8 @@ terminals.get("/:sessionId/terminals/:terminalId", async (c) => {
     // We don't track exit codes in tmux mode
   });
 });
-var logsQuerySchema = z17.object({
-  tail: z17.string().optional().transform((v) => v ? parseInt(v, 10) : void 0)
+var logsQuerySchema = z18.object({
+  tail: z18.string().optional().transform((v) => v ? parseInt(v, 10) : void 0)
 });
 terminals.get(
   "/:sessionId/terminals/:terminalId/logs",
@@ -8387,8 +9311,8 @@ terminals.get(
     });
   }
 );
-var killSchema = z17.object({
-  signal: z17.enum(["SIGTERM", "SIGKILL"]).optional()
+var killSchema = z18.object({
+  signal: z18.enum(["SIGTERM", "SIGKILL"]).optional()
 });
 terminals.post(
   "/:sessionId/terminals/:terminalId/kill",
@@ -8402,8 +9326,8 @@ terminals.post(
     return c.json({ success: true, message: "Terminal killed" });
   }
 );
-var writeSchema = z17.object({
-  input: z17.string()
+var writeSchema = z18.object({
+  input: z18.string()
 });
 terminals.post(
   "/:sessionId/terminals/:terminalId/write",
@@ -8588,18 +9512,18 @@ data: ${JSON.stringify({ status: "stopped" })}
 init_db();
 import { Hono as Hono5 } from "hono";
 import { zValidator as zValidator5 } from "@hono/zod-validator";
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 init_config();
 var tasks = new Hono5();
 var taskAbortControllers = /* @__PURE__ */ new Map();
-var createTaskSchema = z18.object({
-  prompt: z18.string().min(1),
-  outputSchema: z18.record(z18.string(), z18.unknown()),
-  webhookUrl: z18.string().url().optional(),
-  model: z18.string().optional(),
-  workingDirectory: z18.string().optional(),
-  name: z18.string().optional(),
-  maxIterations: z18.number().int().min(1).max(500).optional()
+var createTaskSchema = z19.object({
+  prompt: z19.string().min(1),
+  outputSchema: z19.record(z19.string(), z19.unknown()),
+  webhookUrl: z19.string().url().optional(),
+  model: z19.string().optional(),
+  workingDirectory: z19.string().optional(),
+  name: z19.string().optional(),
+  maxIterations: z19.number().int().min(1).max(500).optional()
 });
 tasks.post(
   "/",
@@ -8678,6 +9602,15 @@ tasks.get("/:id", async (c) => {
   if (!task?.enabled) {
     return c.json({ error: "Session is not a task" }, 400);
   }
+  let browserRecordings = [];
+  try {
+    const { isRemoteConfigured: isRemoteConfigured2, storageQueries: storageQueries2 } = await Promise.resolve().then(() => (init_remote(), remote_exports));
+    if (isRemoteConfigured2()) {
+      const files = await storageQueries2.getSessionFiles(id);
+      browserRecordings = files.filter((f) => f.category === "browser-recording").map((f) => ({ fileName: f.fileName, downloadUrl: f.downloadUrl, sizeBytes: f.sizeBytes }));
+    }
+  } catch {
+  }
   return c.json({
     taskId: id,
     status: task.status,
@@ -8687,7 +9620,8 @@ tasks.get("/:id", async (c) => {
     model: session.model,
     name: session.name,
     createdAt: session.createdAt.toISOString(),
-    updatedAt: session.updatedAt.toISOString()
+    updatedAt: session.updatedAt.toISOString(),
+    browserRecordings: browserRecordings.length > 0 ? browserRecordings : void 0
   });
 });
 tasks.post("/:id/cancel", async (c) => {
@@ -8735,10 +9669,10 @@ init_config();
 init_db();
 
 // src/utils/dependencies.ts
-import { exec as exec5 } from "child_process";
-import { promisify as promisify5 } from "util";
+import { exec as exec6 } from "child_process";
+import { promisify as promisify6 } from "util";
 import { platform as platform2 } from "os";
-var execAsync5 = promisify5(exec5);
+var execAsync6 = promisify6(exec6);
 function getInstallInstructions() {
   const os2 = platform2();
   if (os2 === "darwin") {
@@ -8771,7 +9705,7 @@ Install tmux:
 }
 async function checkTmux() {
   try {
-    const { stdout } = await execAsync5("tmux -V", { timeout: 5e3 });
+    const { stdout } = await execAsync6("tmux -V", { timeout: 5e3 });
     const version = stdout.trim();
     return {
       available: true,
@@ -8820,11 +9754,11 @@ function getWebDirectory() {
   try {
     const currentDir = dirname7(fileURLToPath4(import.meta.url));
     const webDir = resolve10(currentDir, "..", "web");
-    if (existsSync15(webDir) && existsSync15(join8(webDir, "package.json"))) {
+    if (existsSync15(webDir) && existsSync15(join10(webDir, "package.json"))) {
       return webDir;
     }
     const altWebDir = resolve10(currentDir, "..", "..", "web");
-    if (existsSync15(altWebDir) && existsSync15(join8(altWebDir, "package.json"))) {
+    if (existsSync15(altWebDir) && existsSync15(join10(altWebDir, "package.json"))) {
       return altWebDir;
     }
     return null;
@@ -8882,20 +9816,20 @@ async function findWebPort(preferredPort) {
   return { port: preferredPort, alreadyRunning: false };
 }
 function hasProductionBuild(webDir) {
-  const buildIdPath = join8(webDir, ".next", "BUILD_ID");
+  const buildIdPath = join10(webDir, ".next", "BUILD_ID");
   return existsSync15(buildIdPath);
 }
 function hasSourceFiles(webDir) {
-  const appDir = join8(webDir, "src", "app");
-  const pagesDir = join8(webDir, "src", "pages");
-  const rootAppDir = join8(webDir, "app");
-  const rootPagesDir = join8(webDir, "pages");
+  const appDir = join10(webDir, "src", "app");
+  const pagesDir = join10(webDir, "src", "pages");
+  const rootAppDir = join10(webDir, "app");
+  const rootPagesDir = join10(webDir, "pages");
   return existsSync15(appDir) || existsSync15(pagesDir) || existsSync15(rootAppDir) || existsSync15(rootPagesDir);
 }
 function getStandaloneServerPath(webDir) {
   const possiblePaths2 = [
-    join8(webDir, ".next", "standalone", "server.js"),
-    join8(webDir, ".next", "standalone", "web", "server.js")
+    join10(webDir, ".next", "standalone", "server.js"),
+    join10(webDir, ".next", "standalone", "web", "server.js")
   ];
   for (const serverPath of possiblePaths2) {
     if (existsSync15(serverPath)) {
@@ -8938,13 +9872,13 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
     if (!quiet) console.log(`  \u2713 Web UI already running at http://localhost:${actualPort}`);
     return { process: null, port: actualPort };
   }
-  const usePnpm = existsSync15(join8(webDir, "pnpm-lock.yaml"));
-  const useNpm = !usePnpm && existsSync15(join8(webDir, "package-lock.json"));
+  const usePnpm = existsSync15(join10(webDir, "pnpm-lock.yaml"));
+  const useNpm = !usePnpm && existsSync15(join10(webDir, "package-lock.json"));
   const pkgManager = usePnpm ? "pnpm" : useNpm ? "npm" : "npx";
   const { NODE_OPTIONS, TSX_TSCONFIG_PATH, ...cleanEnv } = process.env;
   const apiUrl = publicUrl || `http://127.0.0.1:${apiPort}`;
   const runtimeConfig = { apiBaseUrl: apiUrl };
-  const runtimeConfigPath = join8(webDir, "runtime-config.json");
+  const runtimeConfigPath = join10(webDir, "runtime-config.json");
   try {
     writeFileSync4(runtimeConfigPath, JSON.stringify(runtimeConfig, null, 2));
     if (!quiet) console.log(`  \u{1F4DD} Runtime config written to ${runtimeConfigPath}`);