sparkecoder 0.1.20 → 0.1.22

package/dist/{schema-CkrIadxa.d.ts → schema-Df7MU3nM.d.ts}

@@ -1263,9 +1263,28 @@ interface SystemModelMessage {
     role: 'system';
     content: string;
 }
+interface UserTextPart {
+    type: 'text';
+    text: string;
+}
+interface UserImagePart {
+    type: 'image';
+    image: string;
+    mediaType?: string;
+    filename?: string;
+    savedPath?: string;
+}
+interface UserFilePart {
+    type: 'file';
+    data: string;
+    mediaType?: string;
+    filename?: string;
+    savedPath?: string;
+}
+type UserContentPart = UserTextPart | UserImagePart | UserFilePart;
 interface UserModelMessage {
     role: 'user';
-    content: string;
+    content: string | UserContentPart[];
 }
 interface AssistantModelMessage {
     role: 'assistant';
@@ -1330,7 +1349,11 @@ type schema_TodoItem = TodoItem;
 type schema_ToolExecution = ToolExecution;
 type schema_ToolModelMessage = ToolModelMessage;
 type schema_ToolResultPart = ToolResultPart;
+type schema_UserContentPart = UserContentPart;
+type schema_UserFilePart = UserFilePart;
+type schema_UserImagePart = UserImagePart;
 type schema_UserModelMessage = UserModelMessage;
+type schema_UserTextPart = UserTextPart;
 declare const schema_activeStreams: typeof activeStreams;
 declare const schema_checkpoints: typeof checkpoints;
 declare const schema_fileBackups: typeof fileBackups;
@@ -1341,7 +1364,7 @@ declare const schema_terminals: typeof terminals;
 declare const schema_todoItems: typeof todoItems;
 declare const schema_toolExecutions: typeof toolExecutions;
 declare namespace schema {
-  export { type schema_ActiveStream as ActiveStream, type schema_AssistantContentPart as AssistantContentPart, type schema_AssistantModelMessage as AssistantModelMessage, type schema_Checkpoint as Checkpoint, type schema_FileBackup as FileBackup, type schema_LoadedSkill as LoadedSkill, type schema_Message as Message, type schema_ModelMessage as ModelMessage, type schema_NewActiveStream as NewActiveStream, type schema_NewCheckpoint as NewCheckpoint, type schema_NewFileBackup as NewFileBackup, type schema_NewMessage as NewMessage, type schema_NewSession as NewSession, type schema_NewTerminal as NewTerminal, type schema_NewTodoItem as NewTodoItem, type schema_NewToolExecution as NewToolExecution, type schema_Session as Session, type schema_SessionConfig as SessionConfig, type schema_SystemModelMessage as SystemModelMessage, type schema_Terminal as Terminal, type schema_TodoItem as TodoItem, type schema_ToolExecution as ToolExecution, type schema_ToolModelMessage as ToolModelMessage, type schema_ToolResultPart as ToolResultPart, type schema_UserModelMessage as UserModelMessage, schema_activeStreams as activeStreams, schema_checkpoints as checkpoints, schema_fileBackups as fileBackups, schema_loadedSkills as loadedSkills, schema_messages as messages, schema_sessions as sessions, schema_terminals as terminals, schema_todoItems as todoItems, schema_toolExecutions as toolExecutions };
+  export { type schema_ActiveStream as ActiveStream, type schema_AssistantContentPart as AssistantContentPart, type schema_AssistantModelMessage as AssistantModelMessage, type schema_Checkpoint as Checkpoint, type schema_FileBackup as FileBackup, type schema_LoadedSkill as LoadedSkill, type schema_Message as Message, type schema_ModelMessage as ModelMessage, type schema_NewActiveStream as NewActiveStream, type schema_NewCheckpoint as NewCheckpoint, type schema_NewFileBackup as NewFileBackup, type schema_NewMessage as NewMessage, type schema_NewSession as NewSession, type schema_NewTerminal as NewTerminal, type schema_NewTodoItem as NewTodoItem, type schema_NewToolExecution as NewToolExecution, type schema_Session as Session, type schema_SessionConfig as SessionConfig, type schema_SystemModelMessage as SystemModelMessage, type schema_Terminal as Terminal, type schema_TodoItem as TodoItem, type schema_ToolExecution as ToolExecution, type schema_ToolModelMessage as ToolModelMessage, type schema_ToolResultPart as ToolResultPart, type schema_UserContentPart as UserContentPart, type schema_UserFilePart as UserFilePart, type schema_UserImagePart as UserImagePart, type schema_UserModelMessage as UserModelMessage, type schema_UserTextPart as UserTextPart, schema_activeStreams as activeStreams, schema_checkpoints as checkpoints, schema_fileBackups as fileBackups, schema_loadedSkills as loadedSkills, schema_messages as messages, schema_sessions as sessions, schema_terminals as terminals, schema_todoItems as todoItems, schema_toolExecutions as toolExecutions };
 }
 
-export { type ActiveStream as A, type Checkpoint as C, type FileBackup as F, type LoadedSkill as L, type ModelMessage as M, type NewSession as N, type Session as S, type TodoItem as T, type Message as a, type SessionConfig as b, type NewTodoItem as c, type NewToolExecution as d, type ToolExecution as e, type NewTerminal as f, type Terminal as g, schema as s };
+export { type ActiveStream as A, type Checkpoint as C, type FileBackup as F, type LoadedSkill as L, type ModelMessage as M, type NewSession as N, type Session as S, type TodoItem as T, type UserContentPart as U, type Message as a, type SessionConfig as b, type NewTodoItem as c, type NewToolExecution as d, type ToolExecution as e, type NewTerminal as f, type Terminal as g, type UserFilePart as h, type UserImagePart as i, type UserModelMessage as j, type UserTextPart as k, schema as s };

package/dist/server/index.js

@@ -10,8 +10,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";
@@ -20,6 +20,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";
@@ -3260,11 +3263,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);
   }
@@ -3364,13 +3368,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({
@@ -3930,11 +3983,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";
@@ -4009,11 +4189,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(),
@@ -4025,7 +4217,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();
@@ -4058,9 +4296,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 }));
@@ -4068,6 +4350,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,
@@ -4177,14 +4461,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();
@@ -4200,19 +4490,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);
@@ -4405,7 +4750,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 = () => {
@@ -5064,11 +5409,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;
@@ -5126,23 +5471,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;
     }
   }
@@ -5182,15 +5527,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}`);
@@ -5216,7 +5561,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...");
@@ -5228,10 +5573,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) {
@@ -5259,6 +5604,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);
@@ -5266,9 +5617,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) => {
@@ -5374,8 +5725,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);