sparkecoder 0.1.64 → 0.1.66

package/dist/agent/index.js

@@ -194,6 +194,36 @@ 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;
+}
+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);
@@ -241,7 +271,29 @@ async function api(path, options = {}) {
   }
   return parseDates(parsed);
 }
-var remoteServerUrl, authKey, DATE_FIELDS, MODEL_MESSAGE_FIELDS, remoteSessionQueries, remoteMessageQueries, remoteToolExecutionQueries, remoteTodoQueries, remoteSkillQueries, 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";
@@ -380,6 +432,83 @@ 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 } });
+      },
+      getBySessionId(sessionId) {
+        return api(`/streams/session/${sessionId}`).then((r) => r ?? void 0);
+      },
+      getByStreamId(streamId) {
+        return api(`/streams/by-stream-id/${streamId}`).catch(() => void 0);
+      },
+      finish(streamId) {
+        return api(`/streams/by-stream-id/${streamId}`, { method: "PATCH", body: { status: "finished" } });
+      },
+      markError(streamId) {
+        return api(`/streams/by-stream-id/${streamId}`, { method: "PATCH", body: { status: "error" } });
+      },
+      async deleteBySession(sessionId) {
+        const result = await api(`/streams/session/${sessionId}`, { method: "DELETE" });
+        return result.deleted;
+      }
+    };
+    remoteCheckpointQueries = {
+      create(data) {
+        return api("/checkpoints", { method: "POST", body: data });
+      },
+      getById(id) {
+        return api(`/checkpoints/${id}`).catch(() => void 0);
+      },
+      getBySession(sessionId) {
+        return api(`/checkpoints/session/${sessionId}`);
+      },
+      getByMessageSequence(sessionId, messageSequence) {
+        return api(`/checkpoints/session/${sessionId}/by-sequence/${messageSequence}`).then((r) => r ?? void 0);
+      },
+      getLatest(sessionId) {
+        return api(`/checkpoints/session/${sessionId}/latest`).then((r) => r ?? void 0);
+      },
+      async deleteAfterSequence(sessionId, messageSequence) {
+        const result = await api(
+          `/checkpoints/session/${sessionId}/after-sequence/${messageSequence}`,
+          { method: "DELETE" }
+        );
+        return result.deleted;
+      },
+      async deleteBySession(sessionId) {
+        const result = await api(`/checkpoints/session/${sessionId}`, { method: "DELETE" });
+        return result.deleted;
+      }
+    };
     remoteFileBackupQueries = {
       create(data) {
         return api("/file-backups", { method: "POST", body: data });
@@ -434,6 +563,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", {
@@ -456,6 +620,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 });
+      }
+    };
   }
 });
 
@@ -1220,11 +1405,285 @@ var init_semantic_search = __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) {
+  const existing = activeProxies.get(sessionId);
+  if (existing) return existing;
+  const 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 = 1e3;
+    MAX_RECONNECT_ATTEMPTS = 20;
+    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", () => {
+          const wasConnected = this._connected;
+          this._connected = false;
+          if (wasConnected) {
+            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 = this.reconnectAttempts <= 5 ? RECONNECT_DELAY_MS : RECONNECT_DELAY_MS * (this.reconnectAttempts - 4);
+        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";
 
@@ -1405,8 +1864,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";
@@ -1707,6 +2166,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 hasAgentBrowserCommand(command) {
+  return /\bagent-browser\b/.test(command);
+}
+function isAgentBrowserCloseCommand(command) {
+  return /\bagent-browser\s+(close|close\s+--all)\b/.test(command);
+}
+function injectBrowserStreamPort(command, port) {
+  return command.replace(
+    /\bagent-browser\b/g,
+    `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."),
@@ -1872,6 +2354,16 @@ Terminal output is stored in the global SparkECoder data directory. Use the \`ta
           exitCode: 1
         };
       }
+      let actualCommand = command;
+      const hasAgentBrowser = hasAgentBrowserCommand(command);
+      const browserClose = isAgentBrowserCloseCommand(command);
+      let browserPort;
+      if (hasAgentBrowser) {
+        browserPort = getBrowserStreamPort(options.sessionId);
+        if (!browserClose) {
+          actualCommand = injectBrowserStreamPort(command, browserPort);
+        }
+      }
       const canUseTmux = await shouldUseTmux();
       if (background) {
         if (!canUseTmux) {
@@ -1881,8 +2373,8 @@ 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
         });
@@ -1895,16 +2387,22 @@ 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: browserPort,
+            browserClosed: browserClose || void 0
+          });
           return {
             success: result.exitCode === 0,
             id: result.id,
@@ -1922,7 +2420,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,
@@ -2161,12 +2659,12 @@ function findNearestRoot(startDir, markers) {
 }
 async function commandExists(cmd) {
   try {
-    const { exec: exec5 } = await import("child_process");
-    const { promisify: promisify5 } = await import("util");
-    const execAsync5 = promisify5(exec5);
+    const { exec: exec6 } = await import("child_process");
+    const { promisify: promisify6 } = await import("util");
+    const execAsync6 = promisify6(exec6);
     const isWindows = process.platform === "win32";
     const checkCmd = isWindows ? `where ${cmd}` : `which ${cmd}`;
-    await execAsync5(checkCmd);
+    await execAsync6(checkCmd);
     return true;
   } catch {
     return false;
@@ -2464,7 +2962,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) {
@@ -2478,7 +2976,7 @@ async function createClient(serverId, handle, root) {
         const finish = () => {
           if (resolved) return;
           resolved = true;
-          cleanup();
+          cleanup2();
           resolve10(diagnostics.get(normalized) || []);
         };
         const onDiagnostic = () => {
@@ -4583,8 +5081,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 = {
@@ -4622,6 +5218,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()) {
@@ -4716,6 +5318,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.
@@ -4974,14 +5577,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
@@ -4989,7 +5631,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.
 `;
 }
@@ -5515,11 +6157,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: {
@@ -5590,12 +6250,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,
@@ -5615,11 +6287,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",
@@ -5631,6 +6309,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: join7, basename: basename5 } = await import("path");
+      const urls = [];
+      for (const filePath of filePaths) {
+        try {
+          const fullPath = filePath.startsWith("/") ? filePath : join7(this.session.workingDirectory, filePath);
+          const fileName = basename5(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
    */
@@ -5644,11 +6429,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,
@@ -5666,10 +6451,10 @@ ${taskAddendum}`;
           const resolverData = approvalResolvers.get(toolCallId);
           approvalResolvers.delete(toolCallId);
           this.pendingApprovals.delete(toolCallId);
-          const exec5 = await execution;
+          const exec6 = await execution;
           if (!approved) {
             const reason = resolverData?.reason || "User rejected the tool execution";
-            await toolExecutionQueries.reject(exec5.id);
+            await toolExecutionQueries.reject(exec6.id);
             await sessionQueries.updateStatus(this.session.id, "active");
             return {
               status: "rejected",
@@ -5679,14 +6464,14 @@ ${taskAddendum}`;
               message: `Tool "${name}" was rejected by the user. Reason: ${reason}`
             };
           }
-          await toolExecutionQueries.approve(exec5.id);
+          await toolExecutionQueries.approve(exec6.id);
           await sessionQueries.updateStatus(this.session.id, "active");
           try {
             const result = await originalTool.execute(input, toolOptions);
-            await toolExecutionQueries.complete(exec5.id, result);
+            await toolExecutionQueries.complete(exec6.id, result);
             return result;
           } catch (error) {
-            await toolExecutionQueries.complete(exec5.id, null, error.message);
+            await toolExecutionQueries.complete(exec6.id, null, error.message);
             throw error;
           }
         }