sparkecoder 0.1.64 → 0.1.66

package/dist/tools/index.js

@@ -177,6 +177,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);
@@ -224,7 +254,29 @@ async function api(path, options = {}) {
   }
   return parseDates(parsed);
 }
-var remoteServerUrl, authKey, DATE_FIELDS, MODEL_MESSAGE_FIELDS, 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";
@@ -232,6 +284,103 @@ var init_remote = __esm({
     authKey = null;
     DATE_FIELDS = ["createdAt", "updatedAt", "startedAt", "completedAt", "stoppedAt", "finishedAt", "loadedAt", "indexedAt", "lastFullIndex", "lastIncrementalIndex"];
     MODEL_MESSAGE_FIELDS = ["modelMessage", "modelMessages"];
+    remoteSessionQueries = {
+      create(data) {
+        return api("/sessions", { method: "POST", body: data });
+      },
+      getById(id) {
+        return api(`/sessions/${id}`).catch(() => void 0);
+      },
+      list(limit = 50, offset = 0) {
+        return api(`/sessions?limit=${limit}&offset=${offset}`);
+      },
+      updateStatus(id, status) {
+        return api(`/sessions/${id}`, { method: "PATCH", body: { status } });
+      },
+      updateModel(id, model) {
+        return api(`/sessions/${id}`, { method: "PATCH", body: { model } });
+      },
+      update(id, updates) {
+        return api(`/sessions/${id}`, { method: "PATCH", body: updates });
+      },
+      delete(id) {
+        return api(`/sessions/${id}`, { method: "DELETE" }).then((r) => r?.success ?? false);
+      }
+    };
+    remoteMessageQueries = {
+      async getNextSequence(sessionId) {
+        const result = await api(`/messages/session/${sessionId}/next-sequence`);
+        return result.nextSequence;
+      },
+      create(sessionId, modelMessage) {
+        return api("/messages", { method: "POST", body: { sessionId, modelMessage } });
+      },
+      addMany(sessionId, modelMessages) {
+        return api("/messages/batch", { method: "POST", body: { sessionId, modelMessages } });
+      },
+      getBySession(sessionId) {
+        return api(`/messages/session/${sessionId}`);
+      },
+      getModelMessages(sessionId) {
+        return api(`/messages/session/${sessionId}/model-messages`, { skipParseDates: true });
+      },
+      async getRecentBySession(sessionId, limit = 50) {
+        const messages = await api(`/messages/session/${sessionId}`);
+        return messages.slice(-limit);
+      },
+      async countBySession(sessionId) {
+        const result = await api(`/messages/session/${sessionId}/count`);
+        return result.count;
+      },
+      async deleteBySession(sessionId) {
+        const result = await api(`/messages/session/${sessionId}`, { method: "DELETE" });
+        return result.deleted;
+      },
+      async deleteFromSequence(sessionId, fromSequence) {
+        const result = await api(
+          `/messages/session/${sessionId}/from-sequence/${fromSequence}`,
+          { method: "DELETE" }
+        );
+        return result.deleted;
+      }
+    };
+    remoteToolExecutionQueries = {
+      create(data) {
+        return api("/tool-executions", { method: "POST", body: data });
+      },
+      getById(id) {
+        return api(`/tool-executions/${id}`).catch(() => void 0);
+      },
+      getByToolCallId(toolCallId) {
+        return api(`/tool-executions/by-tool-call-id/${toolCallId}`).catch(() => void 0);
+      },
+      getPendingApprovals(sessionId) {
+        return api(`/tool-executions/session/${sessionId}/pending`);
+      },
+      approve(id) {
+        return api(`/tool-executions/${id}`, { method: "PATCH", body: { status: "approved" } });
+      },
+      reject(id) {
+        return api(`/tool-executions/${id}`, { method: "PATCH", body: { status: "rejected" } });
+      },
+      complete(id, output, error) {
+        return api(`/tool-executions/${id}`, {
+          method: "PATCH",
+          body: { status: error ? "error" : "completed", output, error }
+        });
+      },
+      getBySession(sessionId) {
+        return api(`/tool-executions/session/${sessionId}`);
+      },
+      async deleteAfterTime(sessionId, afterTime) {
+        const timestamp = afterTime instanceof Date ? afterTime.getTime() : new Date(afterTime).getTime();
+        const result = await api(
+          `/tool-executions/session/${sessionId}/after/${timestamp}`,
+          { method: "DELETE" }
+        );
+        return result.deleted;
+      }
+    };
     remoteTodoQueries = {
       create(data) {
         return api("/todos", { method: "POST", body: data });
@@ -266,6 +415,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 });
@@ -320,6 +546,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", {
@@ -342,6 +603,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 });
+      }
+    };
   }
 });
 
@@ -1076,6 +1358,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."),
@@ -1241,6 +1546,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) {
@@ -1250,8 +1565,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
         });
@@ -1264,16 +1579,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,
@@ -1291,7 +1612,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,
@@ -4302,8 +4623,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 = {
@@ -4341,6 +4760,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()) {
@@ -4372,6 +4797,7 @@ export {
   createTaskFailedTool,
   createTodoTool,
   createTools,
+  createUploadFileTool,
   createWriteFileTool
 };
 //# sourceMappingURL=index.js.map