sparkecoder 0.1.20 → 0.1.22

package/dist/cli.js

@@ -18,8 +18,8 @@ import { Hono as Hono5 } from "hono";
 import { serve } from "@hono/node-server";
 import { cors } from "hono/cors";
 import { logger } from "hono/logger";
-import { existsSync as existsSync10, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "fs";
-import { resolve as resolve8, dirname as dirname6, join as join3 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync5, writeFileSync as writeFileSync4 } from "fs";
+import { resolve as resolve8, dirname as dirname6, join as join5 } from "path";
 import { spawn as spawn2 } from "child_process";
 import { createServer as createNetServer } from "net";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -28,6 +28,9 @@ import { fileURLToPath as fileURLToPath2 } from "url";
 import { Hono } from "hono";
 import { zValidator } from "@hono/zod-validator";
 import { z as z9 } from "zod";
+import { existsSync as existsSync10, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2, readdirSync, statSync, unlinkSync } from "fs";
+import { join as join3, basename as basename2, extname as extname5 } from "path";
+import { nanoid as nanoid4 } from "nanoid";
 
 // src/db/index.ts
 import Database from "better-sqlite3";
@@ -3295,11 +3298,12 @@ ${this.summary}`
   }
   /**
    * Add a user message to the context
+   * Content can be a string or an array of content parts (for messages with images/files)
    */
-  addUserMessage(text2) {
+  addUserMessage(content) {
     const userMessage = {
       role: "user",
-      content: text2
+      content
     };
     messageQueries.create(this.sessionId, userMessage);
   }
@@ -3399,13 +3403,62 @@ var Agent = class _Agent {
   getSession() {
     return this.session;
   }
+  /**
+   * Build user message content from prompt and attachments
+   */
+  buildUserMessageContent(prompt, attachments) {
+    if (!attachments || attachments.length === 0) {
+      return prompt;
+    }
+    const contentParts = [];
+    const attachmentDescriptions = attachments.map((a, i) => {
+      const name = a.filename || `attachment_${i + 1}`;
+      const typeLabel = a.type === "image" ? "Image" : "File";
+      const location = a.savedPath || "(path unknown)";
+      return `${i + 1}. ${typeLabel}: "${name}" saved at: ${location}`;
+    }).join("\n");
+    contentParts.push({
+      type: "text",
+      text: `[FILE ATTACHMENTS - The user has attached the following files which are saved on disk]
+${attachmentDescriptions}
+
+You can reference these files by their paths above. The file contents are also shown inline below.`
+    });
+    if (prompt) {
+      contentParts.push({ type: "text", text: `
+[USER MESSAGE]
+${prompt}` });
+    }
+    for (const attachment of attachments) {
+      if (attachment.type === "image") {
+        contentParts.push({
+          type: "image",
+          image: attachment.data,
+          // base64 data URL or raw base64
+          mediaType: attachment.mediaType,
+          filename: attachment.filename,
+          savedPath: attachment.savedPath
+        });
+      } else {
+        contentParts.push({
+          type: "file",
+          data: attachment.data,
+          mediaType: attachment.mediaType || "application/octet-stream",
+          filename: attachment.filename,
+          savedPath: attachment.savedPath
+        });
+      }
+    }
+    return contentParts;
+  }
   /**
    * Run the agent with a prompt (streaming)
    */
   async stream(options) {
     const config = getConfig();
+    const userContent = this.buildUserMessageContent(options.prompt, options.attachments);
     if (!options.skipSaveUserMessage) {
-      this.context.addUserMessage(options.prompt);
+      this.context.addUserMessage(userContent);
     }
     sessionQueries.updateStatus(this.session.id, "active");
     const systemPrompt = await buildSystemPrompt({
@@ -3965,11 +4018,138 @@ sessions2.get("/:id/diff/:filePath", async (c) => {
     currentContent: fileDiff.currentContent
   });
 });
+function getAttachmentsDir(sessionId) {
+  const appDataDir = getAppDataDirectory();
+  return join3(appDataDir, "attachments", sessionId);
+}
+function ensureAttachmentsDir(sessionId) {
+  const dir = getAttachmentsDir(sessionId);
+  if (!existsSync10(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+  return dir;
+}
+sessions2.get("/:id/attachments", async (c) => {
+  const sessionId = c.req.param("id");
+  const session = sessionQueries.getById(sessionId);
+  if (!session) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  const dir = getAttachmentsDir(sessionId);
+  if (!existsSync10(dir)) {
+    return c.json({ sessionId, attachments: [], count: 0 });
+  }
+  const files = readdirSync(dir);
+  const attachments = files.map((filename) => {
+    const filePath = join3(dir, filename);
+    const stats = statSync(filePath);
+    return {
+      id: filename.split("_")[0],
+      // Extract the nanoid prefix
+      filename,
+      path: filePath,
+      size: stats.size,
+      createdAt: stats.birthtime.toISOString()
+    };
+  });
+  return c.json({
+    sessionId,
+    attachments,
+    count: attachments.length
+  });
+});
+sessions2.post("/:id/attachments", async (c) => {
+  const sessionId = c.req.param("id");
+  const session = sessionQueries.getById(sessionId);
+  if (!session) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  const contentType = c.req.header("content-type") || "";
+  if (contentType.includes("multipart/form-data")) {
+    try {
+      const formData = await c.req.formData();
+      const file = formData.get("file");
+      if (!file || !(file instanceof File)) {
+        return c.json({ error: "No file provided" }, 400);
+      }
+      const dir = ensureAttachmentsDir(sessionId);
+      const id = nanoid4(10);
+      const ext = extname5(file.name) || "";
+      const safeFilename = `${id}_${basename2(file.name).replace(/[^a-zA-Z0-9._-]/g, "_")}`;
+      const filePath = join3(dir, safeFilename);
+      const arrayBuffer = await file.arrayBuffer();
+      writeFileSync2(filePath, Buffer.from(arrayBuffer));
+      return c.json({
+        id,
+        filename: file.name,
+        storedAs: safeFilename,
+        path: filePath,
+        size: file.size,
+        mediaType: file.type,
+        sessionId
+      }, 201);
+    } catch (err) {
+      console.error("Failed to upload attachment:", err);
+      return c.json({ error: "Failed to upload file" }, 500);
+    }
+  }
+  try {
+    const body = await c.req.json();
+    if (!body.filename || !body.data) {
+      return c.json({ error: "Missing filename or data" }, 400);
+    }
+    const dir = ensureAttachmentsDir(sessionId);
+    const id = nanoid4(10);
+    const ext = extname5(body.filename) || "";
+    const safeFilename = `${id}_${basename2(body.filename).replace(/[^a-zA-Z0-9._-]/g, "_")}`;
+    const filePath = join3(dir, safeFilename);
+    let base64Data = body.data;
+    if (base64Data.includes(",")) {
+      base64Data = base64Data.split(",")[1];
+    }
+    const buffer = Buffer.from(base64Data, "base64");
+    writeFileSync2(filePath, buffer);
+    return c.json({
+      id,
+      filename: body.filename,
+      storedAs: safeFilename,
+      path: filePath,
+      size: buffer.length,
+      mediaType: body.mediaType,
+      sessionId
+    }, 201);
+  } catch (err) {
+    console.error("Failed to upload attachment:", err);
+    return c.json({ error: "Failed to upload file" }, 500);
+  }
+});
+sessions2.delete("/:id/attachments/:attachmentId", async (c) => {
+  const sessionId = c.req.param("id");
+  const attachmentId = c.req.param("attachmentId");
+  const session = sessionQueries.getById(sessionId);
+  if (!session) {
+    return c.json({ error: "Session not found" }, 404);
+  }
+  const dir = getAttachmentsDir(sessionId);
+  if (!existsSync10(dir)) {
+    return c.json({ error: "Attachment not found" }, 404);
+  }
+  const files = readdirSync(dir);
+  const file = files.find((f) => f.startsWith(attachmentId + "_"));
+  if (!file) {
+    return c.json({ error: "Attachment not found" }, 404);
+  }
+  const filePath = join3(dir, file);
+  unlinkSync(filePath);
+  return c.json({ success: true, id: attachmentId });
+});
 
 // src/server/routes/agents.ts
 import { Hono as Hono2 } from "hono";
 import { zValidator as zValidator2 } from "@hono/zod-validator";
 import { z as z10 } from "zod";
+import { existsSync as existsSync11, mkdirSync as mkdirSync4, writeFileSync as writeFileSync3 } from "fs";
+import { join as join4 } from "path";
 
 // src/server/resumable-stream.ts
 import { createResumableStreamContext } from "resumable-stream/generic";
@@ -4044,11 +4224,23 @@ var streamContext = createResumableStreamContext({
 });
 
 // src/server/routes/agents.ts
-import { nanoid as nanoid4 } from "nanoid";
+import { nanoid as nanoid5 } from "nanoid";
 var agents = new Hono2();
-var runPromptSchema = z10.object({
-  prompt: z10.string().min(1)
+var attachmentSchema = z10.object({
+  type: z10.enum(["image", "file"]),
+  data: z10.string(),
+  // base64 data URL or raw base64
+  mediaType: z10.string().optional(),
+  filename: z10.string().optional()
 });
+var runPromptSchema = z10.object({
+  prompt: z10.string(),
+  // Can be empty if attachments are provided
+  attachments: z10.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 = z10.object({
   prompt: z10.string().min(1),
   name: z10.string().optional(),
@@ -4060,7 +4252,53 @@ var rejectSchema = z10.object({
   reason: z10.string().optional()
 }).optional();
 var streamAbortControllers = /* @__PURE__ */ new Map();
-function createAgentStreamProducer(sessionId, prompt, streamId) {
+function getAttachmentsDirectory(sessionId) {
+  const appDataDir = getAppDataDirectory();
+  return join4(appDataDir, "attachments", sessionId);
+}
+function saveAttachmentToDisk(sessionId, attachment, index) {
+  const attachmentsDir = getAttachmentsDirectory(sessionId);
+  if (!existsSync11(attachmentsDir)) {
+    mkdirSync4(attachmentsDir, { recursive: true });
+  }
+  let filename = attachment.filename;
+  if (!filename) {
+    const ext = getExtensionFromMediaType(attachment.mediaType, attachment.type);
+    filename = `attachment_${index + 1}${ext}`;
+  }
+  let base64Data = attachment.data;
+  if (base64Data.includes(",")) {
+    base64Data = base64Data.split(",")[1];
+  }
+  const filePath = join4(attachmentsDir, filename);
+  const buffer = Buffer.from(base64Data, "base64");
+  writeFileSync3(filePath, buffer);
+  return filePath;
+}
+function getExtensionFromMediaType(mediaType, type) {
+  if (!mediaType) {
+    return type === "image" ? ".png" : ".bin";
+  }
+  const mimeToExt = {
+    "image/png": ".png",
+    "image/jpeg": ".jpg",
+    "image/jpg": ".jpg",
+    "image/gif": ".gif",
+    "image/webp": ".webp",
+    "image/svg+xml": ".svg",
+    "application/pdf": ".pdf",
+    "text/plain": ".txt",
+    "text/markdown": ".md",
+    "application/json": ".json",
+    "application/javascript": ".js",
+    "text/javascript": ".js",
+    "text/typescript": ".ts",
+    "text/html": ".html",
+    "text/css": ".css"
+  };
+  return mimeToExt[mediaType] || ".bin";
+}
+function createAgentStreamProducer(sessionId, prompt, streamId, attachments) {
   return () => {
     const { readable, writable } = new TransformStream();
     const writer = writable.getWriter();
@@ -4093,9 +4331,53 @@ function createAgentStreamProducer(sessionId, prompt, streamId) {
       try {
         const agent = await Agent.create({ sessionId });
         await writeSSE(JSON.stringify({ type: "data-stream-id", streamId }));
+        let broadcastContent;
+        if (attachments && attachments.length > 0) {
+          const contentParts = [];
+          const attachmentDescriptions = attachments.map((a, i) => {
+            const name = a.filename || `attachment_${i + 1}`;
+            const typeLabel = a.type === "image" ? "Image" : "File";
+            const location = a.savedPath || "(path unknown)";
+            return `${i + 1}. ${typeLabel}: "${name}" saved at: ${location}`;
+          }).join("\n");
+          contentParts.push({
+            type: "text",
+            text: `[FILE ATTACHMENTS - The user has attached the following files which are saved on disk]
+${attachmentDescriptions}
+
+You can reference these files by their paths above. The file contents are also shown inline below.`
+          });
+          if (prompt) {
+            contentParts.push({ type: "text", text: `
+[USER MESSAGE]
+${prompt}` });
+          }
+          for (const attachment of attachments) {
+            if (attachment.type === "image") {
+              contentParts.push({
+                type: "image",
+                image: attachment.data,
+                mediaType: attachment.mediaType,
+                filename: attachment.filename,
+                savedPath: attachment.savedPath
+              });
+            } else {
+              contentParts.push({
+                type: "file",
+                data: attachment.data,
+                mediaType: attachment.mediaType || "application/octet-stream",
+                filename: attachment.filename,
+                savedPath: attachment.savedPath
+              });
+            }
+          }
+          broadcastContent = contentParts;
+        } else {
+          broadcastContent = prompt;
+        }
         await writeSSE(JSON.stringify({
           type: "data-user-message",
-          data: { id: `user_${Date.now()}`, content: prompt }
+          data: { id: `user_${Date.now()}`, content: broadcastContent }
         }));
         const messageId = `msg_${Date.now()}`;
         await writeSSE(JSON.stringify({ type: "start", messageId }));
@@ -4103,6 +4385,8 @@ function createAgentStreamProducer(sessionId, prompt, streamId) {
         let textStarted = false;
         const result = await agent.stream({
           prompt,
+          attachments,
+          // Pass attachments to agent
           abortSignal: abortController.signal,
           // Use our managed abort controller, NOT client signal
           skipSaveUserMessage: true,
@@ -4212,14 +4496,20 @@ function createAgentStreamProducer(sessionId, prompt, streamId) {
         } else {
           await writeSSE(JSON.stringify({ type: "finish" }));
         }
-        activeStreamQueries.finish(streamId);
+        try {
+          activeStreamQueries.finish(streamId);
+        } catch {
+        }
       } catch (error) {
         if (error.name === "AbortError" || error.message?.includes("aborted")) {
           await writeSSE(JSON.stringify({ type: "abort" }));
         } else {
           console.error("Agent error:", error);
           await writeSSE(JSON.stringify({ type: "error", errorText: error.message }));
-          activeStreamQueries.markError(streamId);
+          try {
+            activeStreamQueries.markError(streamId);
+          } catch {
+          }
         }
       } finally {
         cleanupAbortController();
@@ -4235,19 +4525,74 @@ agents.post(
   zValidator2("json", runPromptSchema),
   async (c) => {
     const id = c.req.param("id");
-    const { prompt } = c.req.valid("json");
+    const { prompt, attachments } = c.req.valid("json");
     const session = sessionQueries.getById(id);
     if (!session) {
       return c.json({ error: "Session not found" }, 404);
     }
     const nextSequence = messageQueries.getNextSequence(id);
     await createCheckpoint(id, session.workingDirectory, nextSequence);
-    messageQueries.create(id, { role: "user", content: prompt });
-    const streamId = `stream_${id}_${nanoid4(10)}`;
+    let userMessageContent;
+    const streamAttachments = attachments;
+    if (streamAttachments && streamAttachments.length > 0) {
+      for (let i = 0; i < streamAttachments.length; i++) {
+        const attachment = streamAttachments[i];
+        try {
+          const savedPath = saveAttachmentToDisk(id, attachment, i);
+          attachment.savedPath = savedPath;
+        } catch (err) {
+          console.error(`Failed to save attachment ${i}:`, err);
+        }
+      }
+      const contentParts = [];
+      const attachmentDescriptions = streamAttachments.map((a, i) => {
+        const name = a.filename || `attachment_${i + 1}`;
+        const typeLabel = a.type === "image" ? "Image" : "File";
+        const location = a.savedPath || "(path unknown)";
+        return `${i + 1}. ${typeLabel}: "${name}" saved at: ${location}`;
+      }).join("\n");
+      contentParts.push({
+        type: "text",
+        text: `[FILE ATTACHMENTS - The user has attached the following files which are saved on disk]
+${attachmentDescriptions}
+
+You can reference these files by their paths above. The file contents are also shown inline below.`
+      });
+      if (prompt) {
+        contentParts.push({ type: "text", text: `
+[USER MESSAGE]
+${prompt}` });
+      }
+      for (const attachment of streamAttachments) {
+        if (attachment.type === "image") {
+          contentParts.push({
+            type: "image",
+            image: attachment.data,
+            // base64 data URL or raw base64
+            mediaType: attachment.mediaType,
+            filename: attachment.filename,
+            savedPath: attachment.savedPath
+          });
+        } else {
+          contentParts.push({
+            type: "file",
+            data: attachment.data,
+            mediaType: attachment.mediaType || "application/octet-stream",
+            filename: attachment.filename,
+            savedPath: attachment.savedPath
+          });
+        }
+      }
+      userMessageContent = contentParts;
+    } else {
+      userMessageContent = prompt;
+    }
+    messageQueries.create(id, { role: "user", content: userMessageContent });
+    const streamId = `stream_${id}_${nanoid5(10)}`;
     activeStreamQueries.create(id, streamId);
     const stream = await streamContext.resumableStream(
       streamId,
-      createAgentStreamProducer(id, prompt, streamId)
+      createAgentStreamProducer(id, prompt, streamId, streamAttachments)
     );
     if (!stream) {
       return c.json({ error: "Failed to create stream" }, 500);
@@ -4440,7 +4785,7 @@ agents.post(
       sessionConfig: body.toolApprovals ? { toolApprovals: body.toolApprovals } : void 0
     });
     const session = agent.getSession();
-    const streamId = `stream_${session.id}_${nanoid4(10)}`;
+    const streamId = `stream_${session.id}_${nanoid5(10)}`;
     await createCheckpoint(session.id, session.workingDirectory, 0);
     activeStreamQueries.create(session.id, streamId);
     const createQuickStreamProducer = () => {
@@ -5154,11 +5499,11 @@ function getWebDirectory() {
   try {
     const currentDir = dirname6(fileURLToPath2(import.meta.url));
     const webDir = resolve8(currentDir, "..", "web");
-    if (existsSync10(webDir) && existsSync10(join3(webDir, "package.json"))) {
+    if (existsSync12(webDir) && existsSync12(join5(webDir, "package.json"))) {
       return webDir;
     }
     const altWebDir = resolve8(currentDir, "..", "..", "web");
-    if (existsSync10(altWebDir) && existsSync10(join3(altWebDir, "package.json"))) {
+    if (existsSync12(altWebDir) && existsSync12(join5(altWebDir, "package.json"))) {
       return altWebDir;
     }
     return null;
@@ -5216,23 +5561,23 @@ async function findWebPort(preferredPort) {
   return { port: preferredPort, alreadyRunning: false };
 }
 function hasProductionBuild(webDir) {
-  const buildIdPath = join3(webDir, ".next", "BUILD_ID");
-  return existsSync10(buildIdPath);
+  const buildIdPath = join5(webDir, ".next", "BUILD_ID");
+  return existsSync12(buildIdPath);
 }
 function hasSourceFiles(webDir) {
-  const appDir = join3(webDir, "src", "app");
-  const pagesDir = join3(webDir, "src", "pages");
-  const rootAppDir = join3(webDir, "app");
-  const rootPagesDir = join3(webDir, "pages");
-  return existsSync10(appDir) || existsSync10(pagesDir) || existsSync10(rootAppDir) || existsSync10(rootPagesDir);
+  const appDir = join5(webDir, "src", "app");
+  const pagesDir = join5(webDir, "src", "pages");
+  const rootAppDir = join5(webDir, "app");
+  const rootPagesDir = join5(webDir, "pages");
+  return existsSync12(appDir) || existsSync12(pagesDir) || existsSync12(rootAppDir) || existsSync12(rootPagesDir);
 }
 function getStandaloneServerPath(webDir) {
   const possiblePaths = [
-    join3(webDir, ".next", "standalone", "server.js"),
-    join3(webDir, ".next", "standalone", "web", "server.js")
+    join5(webDir, ".next", "standalone", "server.js"),
+    join5(webDir, ".next", "standalone", "web", "server.js")
   ];
   for (const serverPath of possiblePaths) {
-    if (existsSync10(serverPath)) {
+    if (existsSync12(serverPath)) {
       return serverPath;
     }
   }
@@ -5272,15 +5617,15 @@ 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 = existsSync10(join3(webDir, "pnpm-lock.yaml"));
-  const useNpm = !usePnpm && existsSync10(join3(webDir, "package-lock.json"));
+  const usePnpm = existsSync12(join5(webDir, "pnpm-lock.yaml"));
+  const useNpm = !usePnpm && existsSync12(join5(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 = join3(webDir, "runtime-config.json");
+  const runtimeConfigPath = join5(webDir, "runtime-config.json");
   try {
-    writeFileSync2(runtimeConfigPath, JSON.stringify(runtimeConfig, null, 2));
+    writeFileSync4(runtimeConfigPath, JSON.stringify(runtimeConfig, null, 2));
     if (!quiet) console.log(`  \u{1F4DD} Runtime config written to ${runtimeConfigPath}`);
   } catch (err) {
     if (!quiet) console.warn(`  \u26A0 Could not write runtime config: ${err}`);
@@ -5306,7 +5651,7 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
     if (!quiet) console.log("  \u{1F4E6} Starting Web UI from standalone build...");
   } else if (hasBuild && (isProduction || !hasSource)) {
     command = pkgManager;
-    args = pkgManager === "npx" ? ["next", "start", "-p", String(actualPort)] : ["run", "start", "--", "-p", String(actualPort)];
+    args = pkgManager === "npx" ? ["next", "start", "-p", String(actualPort)] : ["run", "start"];
   } else if (hasSource) {
     if (isProduction && !hasBuild) {
       if (!quiet) console.log("  \u{1F4E6} Building Web UI for production...");
@@ -5318,10 +5663,10 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
       }
       if (!quiet) console.log("  \u2713 Web UI build complete");
       command = pkgManager;
-      args = pkgManager === "npx" ? ["next", "start", "-p", String(actualPort)] : ["run", "start", "--", "-p", String(actualPort)];
+      args = pkgManager === "npx" ? ["next", "start", "-p", String(actualPort)] : ["run", "start"];
     } else {
       command = pkgManager;
-      args = pkgManager === "npx" ? ["next", "dev", "-p", String(actualPort)] : ["run", "dev", "--", "-p", String(actualPort)];
+      args = pkgManager === "npx" ? ["next", "dev", "-p", String(actualPort)] : ["run", "dev"];
     }
   } else {
     if (!quiet) {
@@ -5349,6 +5694,12 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
     }, startupTimeout);
     child.stdout?.on("data", (data) => {
       const output = data.toString();
+      if (!quiet) {
+        const lines = output.trim().split("\n").filter((l) => l.trim());
+        for (const line of lines) {
+          console.log(`  Web UI: ${line}`);
+        }
+      }
       if (!started && (output.includes("Ready") || output.includes("started") || output.includes("localhost"))) {
         started = true;
         clearTimeout(timeout);
@@ -5356,9 +5707,9 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false, pu
       }
     });
     child.stderr?.on("data", (data) => {
-      const output = data.toString();
-      if (output.toLowerCase().includes("error")) {
-        if (!quiet) console.error(`  Web UI error: ${output.trim().slice(0, 200)}`);
+      const output = data.toString().trim();
+      if (!quiet && output) {
+        console.error(`  Web UI: ${output.slice(0, 500)}`);
       }
     });
     child.on("error", (err) => {
@@ -5464,8 +5815,8 @@ async function startServer(options = {}) {
   if (options.workingDirectory) {
     config.resolvedWorkingDirectory = options.workingDirectory;
   }
-  if (!existsSync10(config.resolvedWorkingDirectory)) {
-    mkdirSync3(config.resolvedWorkingDirectory, { recursive: true });
+  if (!existsSync12(config.resolvedWorkingDirectory)) {
+    mkdirSync5(config.resolvedWorkingDirectory, { recursive: true });
     if (!options.quiet) console.log(`\u{1F4C1} Created agent workspace: ${config.resolvedWorkingDirectory}`);
   }
   initDatabase(config.resolvedDatabasePath);
@@ -5968,8 +6319,8 @@ function generateOpenAPISpec() {
 }
 
 // src/cli.ts
-import { writeFileSync as writeFileSync3, existsSync as existsSync11 } from "fs";
-import { resolve as resolve9, join as join4 } from "path";
+import { writeFileSync as writeFileSync5, existsSync as existsSync13 } from "fs";
+import { resolve as resolve9, join as join6 } from "path";
 async function apiRequest(baseUrl, path, options = {}) {
   const url = `${baseUrl}${path}`;
   const init = {
@@ -6526,19 +6877,19 @@ program.command("init").description("Create a sparkecoder.config.json file").opt
   let configLocation;
   if (options.global) {
     const appDataDir = ensureAppDataDirectory();
-    configPath = join4(appDataDir, "sparkecoder.config.json");
+    configPath = join6(appDataDir, "sparkecoder.config.json");
     configLocation = "global";
   } else {
     configPath = resolve9(process.cwd(), "sparkecoder.config.json");
     configLocation = "local";
   }
-  if (existsSync11(configPath) && !options.force) {
+  if (existsSync13(configPath) && !options.force) {
     console.log(chalk.yellow("Config file already exists. Use --force to overwrite."));
     console.log(chalk.dim(`  ${configPath}`));
     return;
   }
   const config = createDefaultConfig();
-  writeFileSync3(configPath, JSON.stringify(config, null, 2));
+  writeFileSync5(configPath, JSON.stringify(config, null, 2));
   console.log(chalk.green(`\u2713 Created ${configLocation} config`));
   console.log(chalk.dim(`  ${configPath}`));
   console.log(chalk.dim("Set AI_GATEWAY_API_KEY and run sparkecoder to start"));