sparkecoder 0.1.64 → 0.1.66

package/dist/cli.js

@@ -10,6 +10,25 @@ var __export = (target, all) => {
 };
 
 // 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;
@@ -18,6 +37,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);
@@ -65,7 +87,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, remoteIndexedChunkQueries, 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";
@@ -204,6 +248,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 } });
@@ -364,6 +436,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 });
+      }
+    };
   }
 });
 
@@ -1911,7 +2004,7 @@ function isPathExcluded(relativePath, exclude) {
 }
 async function walkDirectory(dir, include, exclude, baseDir) {
   const { readdirSync: readdirSync2 } = await import("fs");
-  const { join: join10, relative: relative10 } = await import("path");
+  const { join: join12, relative: relative10 } = await import("path");
   const files = [];
   function walk(currentDir) {
     let entries;
@@ -1921,7 +2014,7 @@ async function walkDirectory(dir, include, exclude, baseDir) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = join10(currentDir, entry.name);
+      const fullPath = join12(currentDir, entry.name);
       const relativePath = relative10(baseDir, fullPath);
       if (isPathExcluded(relativePath, exclude)) {
         continue;
@@ -2451,6 +2544,280 @@ 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) {
+  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/cli.ts
 import { Command } from "commander";
 import chalk from "chalk";
@@ -2465,7 +2832,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";
@@ -2474,17 +2841,17 @@ 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";
 
 // src/agent/index.ts
 import {
   streamText as streamText2,
   generateText as generateText3,
-  tool as tool12,
+  tool as tool13,
   stepCountIs as stepCountIs2
 } from "ai";
 
@@ -2665,8 +3032,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";
@@ -2952,8 +3319,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);
@@ -3015,6 +3382,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."),
@@ -3180,6 +3570,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) {
@@ -3189,8 +3589,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
         });
@@ -3203,16 +3603,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,
@@ -3230,7 +3636,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,
@@ -3605,12 +4011,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;
@@ -3908,7 +4314,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) {
@@ -3922,7 +4328,7 @@ async function createClient(serverId, handle, root) {
         const finish = () => {
           if (resolved) return;
           resolved = true;
-          cleanup();
+          cleanup2();
           resolve12(diagnostics.get(normalized) || []);
         };
         const onDiagnostic = () => {
@@ -6027,8 +6433,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 = {
@@ -6066,6 +6570,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()) {
@@ -6160,6 +6670,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.
@@ -6418,14 +6929,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
@@ -6433,7 +6983,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.
 `;
 }
@@ -6941,11 +7491,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: {
@@ -7016,12 +7584,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,
@@ -7041,11 +7621,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",
@@ -7057,6 +7643,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: join12, basename: basename6 } = await import("path");
+      const urls = [];
+      for (const filePath of filePaths) {
+        try {
+          const fullPath = filePath.startsWith("/") ? filePath : join12(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
    */
@@ -7070,11 +7763,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,
@@ -7092,10 +7785,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",
@@ -7105,14 +7798,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;
           }
         }
@@ -7213,18 +7906,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(
   "/",
@@ -7363,10 +8056,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",
@@ -7436,8 +8129,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",
@@ -7468,13 +8161,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",
@@ -7642,7 +8335,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);
@@ -7663,7 +8356,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],
@@ -7695,10 +8388,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({
@@ -7721,10 +8414,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];
@@ -7761,14 +8454,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([
@@ -7841,10 +8534,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;
@@ -7852,7 +8545,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;
       }
@@ -7941,14 +8634,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
@@ -8024,7 +8773,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;
@@ -8111,35 +8864,35 @@ function enrichPromptWithDevtoolsContext(sessionId, prompt) {
 ${prompt}`;
 }
 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);
@@ -8155,7 +8908,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;
@@ -8323,6 +9076,40 @@ ${prompt}` });
               }));
               await new Promise((resolve12) => setTimeout(resolve12, 0));
             }
+            const browserPort = progress.data?.browserStreamPort;
+            const browserClosed = progress.data?.browserClosed;
+            if (progress.toolName === "bash" && browserClosed) {
+              console.log(`[BROWSER-STREAM] agent-browser close detected, destroying proxy`);
+              destroyProxy(sessionId);
+            } else if (progress.toolName === "bash" && browserPort) {
+              console.log(`[BROWSER-STREAM] agent-browser command detected, ensuring proxy on port ${browserPort}`);
+              const proxy = getOrCreateProxy(sessionId, browserPort);
+              if (!sessionRecorders.has(sessionId)) {
+                const recorder = new FrameRecorder(sessionId);
+                recorder.start();
+                sessionRecorders.set(sessionId, recorder);
+              }
+              if (proxy.listenerCount("frame") === 0) {
+                proxy.on("frame", (frame) => {
+                  const rec = sessionRecorders.get(sessionId);
+                  rec?.addFrame(frame);
+                  writeSSE(JSON.stringify({
+                    type: "browser-frame",
+                    data: frame.data,
+                    metadata: frame.metadata
+                  })).catch(() => {
+                  });
+                });
+                proxy.on("status", (s) => {
+                  console.log(`[BROWSER-STREAM] Status:`, s);
+                  writeSSE(JSON.stringify({
+                    type: "browser-status",
+                    ...s
+                  })).catch(() => {
+                  });
+                });
+              }
+            }
           },
           onStepFinish: async () => {
             await writeSSE(JSON.stringify({ type: "finish-step" }));
@@ -8509,7 +9296,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,
@@ -8708,7 +9495,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 = () => {
@@ -8787,6 +9574,40 @@ agents.post(
                 }));
                 await new Promise((resolve12) => setTimeout(resolve12, 0));
               }
+              const browserPort = progress.data?.browserStreamPort;
+              const browserClosed = progress.data?.browserClosed;
+              if (progress.toolName === "bash" && browserClosed) {
+                console.log(`[BROWSER-STREAM] agent-browser close detected`);
+                destroyProxy(session.id);
+              } else if (progress.toolName === "bash" && browserPort) {
+                console.log(`[BROWSER-STREAM] agent-browser command detected, port ${browserPort}`);
+                const proxy = getOrCreateProxy(session.id, browserPort);
+                if (!sessionRecorders.has(session.id)) {
+                  const recorder = new FrameRecorder(session.id);
+                  recorder.start();
+                  sessionRecorders.set(session.id, recorder);
+                }
+                if (proxy.listenerCount("frame") === 0) {
+                  proxy.on("frame", (frame) => {
+                    const rec = sessionRecorders.get(session.id);
+                    rec?.addFrame(frame);
+                    writeSSE(JSON.stringify({
+                      type: "browser-frame",
+                      data: frame.data,
+                      metadata: frame.metadata
+                    })).catch(() => {
+                    });
+                  });
+                  proxy.on("status", (s) => {
+                    console.log(`[BROWSER-STREAM] Status:`, s);
+                    writeSSE(JSON.stringify({
+                      type: "browser-status",
+                      ...s
+                    })).catch(() => {
+                    });
+                  });
+                }
+              }
             },
             onStepFinish: async () => {
               await writeSSE(JSON.stringify({ type: "finish-step" }));
@@ -8917,25 +9738,71 @@ 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 });
+  }
+);
+agents.get("/:id/browser-stream", async (c) => {
+  const sessionId = c.req.param("id");
+  const proxy = getProxy(sessionId);
+  return c.json({
+    sessionId,
+    active: !!proxy?.connected,
+    hasProxy: !!proxy,
+    latestFrame: proxy?.latestFrame ? {
+      metadata: proxy.latestFrame.metadata,
+      timestamp: proxy.latestFrame.timestamp
+    } : null
+  });
+});
 
 // 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";
@@ -9032,9 +9899,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",
@@ -9073,13 +9940,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",
@@ -9160,8 +10027,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",
@@ -9185,8 +10052,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",
@@ -9200,8 +10067,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",
@@ -9386,18 +10253,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(
   "/",
@@ -9476,6 +10343,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,
@@ -9485,7 +10361,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) => {
@@ -9533,10 +10410,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") {
@@ -9569,7 +10446,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,
@@ -9610,7 +10487,7 @@ async function checkDependencies(options = {}) {
 }
 async function checkAgentBrowser() {
   try {
-    const { stdout } = await execAsync5("agent-browser --version", { timeout: 1e4 });
+    const { stdout } = await execAsync6("agent-browser --version", { timeout: 1e4 });
     const version = stdout.trim();
     return { available: true, version };
   } catch {
@@ -9626,12 +10503,12 @@ async function tryInstallAgentBrowser(options = {}) {
     if (!options.quiet) {
       console.log("\u{1F4E6} Installing agent-browser globally...");
     }
-    await execAsync5("npm install -g agent-browser", { timeout: 12e4 });
+    await execAsync6("npm install -g agent-browser", { timeout: 12e4 });
     try {
       if (!options.quiet) {
         console.log("\u{1F4E6} Installing Chromium for browser automation...");
       }
-      await execAsync5("agent-browser install", { timeout: 12e4 });
+      await execAsync6("agent-browser install", { timeout: 12e4 });
     } catch {
     }
     if (!options.quiet) {
@@ -9650,21 +10527,21 @@ async function tryAutoInstallTmux() {
   try {
     if (os2 === "darwin") {
       try {
-        await execAsync5("which brew", { timeout: 5e3 });
+        await execAsync6("which brew", { timeout: 5e3 });
       } catch {
         return false;
       }
       console.log("\u{1F4E6} Installing tmux via Homebrew...");
-      await execAsync5("brew install tmux", { timeout: 3e5 });
+      await execAsync6("brew install tmux", { timeout: 3e5 });
       console.log("\u2705 tmux installed successfully");
       return true;
     }
     if (os2 === "linux") {
       try {
-        await execAsync5("which apt-get", { timeout: 5e3 });
+        await execAsync6("which apt-get", { timeout: 5e3 });
         console.log("\u{1F4E6} Installing tmux via apt-get...");
         console.log("   (This may require sudo password)");
-        await execAsync5("sudo apt-get update && sudo apt-get install -y tmux", {
+        await execAsync6("sudo apt-get update && sudo apt-get install -y tmux", {
           timeout: 3e5
         });
         console.log("\u2705 tmux installed successfully");
@@ -9672,9 +10549,9 @@ async function tryAutoInstallTmux() {
       } catch {
       }
       try {
-        await execAsync5("which dnf", { timeout: 5e3 });
+        await execAsync6("which dnf", { timeout: 5e3 });
         console.log("\u{1F4E6} Installing tmux via dnf...");
-        await execAsync5("sudo dnf install -y tmux", { timeout: 3e5 });
+        await execAsync6("sudo dnf install -y tmux", { timeout: 3e5 });
         console.log("\u2705 tmux installed successfully");
         return true;
       } catch {
@@ -9714,11 +10591,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;
@@ -9776,20 +10653,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)) {
@@ -9832,13 +10709,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}`);
@@ -10549,7 +11426,7 @@ init_config();
 init_semantic();
 init_db();
 import { writeFileSync as writeFileSync5, readFileSync as readFileSync6, existsSync as existsSync16 } from "fs";
-import { resolve as resolve11, join as join9 } from "path";
+import { resolve as resolve11, join as join11 } from "path";
 async function apiRequest(baseUrl, path, options = {}) {
   const url = `${baseUrl}${path}`;
   const init = {
@@ -10769,14 +11646,14 @@ async function runChat(options) {
         } else {
           spinner.succeed(`Web UI: ${chalk.cyan(webUrl)}`);
         }
-        const cleanup = () => {
+        const cleanup2 = () => {
           if (serverStartedByUs) {
             stopServer();
           }
           process.exit(0);
         };
-        process.on("SIGINT", cleanup);
-        process.on("SIGTERM", cleanup);
+        process.on("SIGINT", cleanup2);
+        process.on("SIGTERM", cleanup2);
       } catch (err) {
         spinner.fail(chalk.red(`Failed to start server: ${err.message}`));
         process.exit(1);
@@ -11140,13 +12017,13 @@ program.command("server").description("Start the SparkECoder server (API + Web U
     console.log(chalk.dim(`  Swagger: http://${host}:${port}/swagger`));
     console.log("");
     console.log(chalk.dim("Press Ctrl+C to stop"));
-    const cleanup = () => {
+    const cleanup2 = () => {
       console.log(chalk.dim("\nShutting down..."));
       stopServer();
       process.exit(0);
     };
-    process.on("SIGINT", cleanup);
-    process.on("SIGTERM", cleanup);
+    process.on("SIGINT", cleanup2);
+    process.on("SIGTERM", cleanup2);
   } catch (error) {
     spinner.fail(chalk.red(`Failed to start server: ${error.message}`));
     process.exit(1);
@@ -11251,7 +12128,7 @@ program.command("init").description("Create a sparkecoder.config.json file").opt
   let configLocation;
   if (options.global) {
     const appDataDir = ensureAppDataDirectory();
-    configPath = join9(appDataDir, "sparkecoder.config.json");
+    configPath = join11(appDataDir, "sparkecoder.config.json");
     configLocation = "global";
   } else {
     configPath = resolve11(process.cwd(), "sparkecoder.config.json");