@poncho-ai/cli 0.10.2 → 0.11.1

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   main
-} from "./chunk-COLXQM6J.js";
+} from "./chunk-T2F6ICXI.js";
 
 // src/cli.ts
 void main();

package/dist/index.js

@@ -23,7 +23,7 @@ import {
   runTests,
   startDevServer,
   updateAgentGuidance
-} from "./chunk-COLXQM6J.js";
+} from "./chunk-T2F6ICXI.js";
 export {
   addSkill,
   buildCli,

package/dist/{run-interactive-ink-Z3U5SV4C.js → run-interactive-ink-7FP5PT7Q.js}

@@ -2,10 +2,12 @@ import {
   consumeFirstRunIntro,
   inferConversationTitle,
   resolveHarnessEnvironment
-} from "./chunk-COLXQM6J.js";
+} from "./chunk-T2F6ICXI.js";
 
 // src/run-interactive-ink.ts
 import * as readline from "readline";
+import { readFile } from "fs/promises";
+import { resolve, basename } from "path";
 import { stdout } from "process";
 import {
   parseAgentFile
@@ -1496,7 +1498,7 @@ var loadMetadata = async (workingDir) => {
 var ask = (rl, prompt) => new Promise((res) => {
   rl.question(prompt, (answer) => res(answer));
 });
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var sleep = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
 var streamTextAsTokens = async (text) => {
   const tokens = text.match(/\S+\s*|\n/g) ?? [text];
   for (const token of tokens) {
@@ -1506,6 +1508,41 @@ var streamTextAsTokens = async (text) => {
     await sleep(delay);
   }
 };
+var EXT_MIME = {
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  png: "image/png",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  pdf: "application/pdf",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  txt: "text/plain",
+  json: "application/json",
+  csv: "text/csv",
+  html: "text/html"
+};
+var extToMime = (ext) => EXT_MIME[ext] ?? "application/octet-stream";
+var readPendingFiles = async (files) => {
+  const results = [];
+  for (const f of files) {
+    try {
+      const buf = await readFile(f.resolved);
+      const ext = f.resolved.split(".").pop()?.toLowerCase() ?? "";
+      results.push({
+        data: buf.toString("base64"),
+        mediaType: extToMime(ext),
+        filename: basename(f.path)
+      });
+    } catch {
+      console.log(`${C.yellow}warn: could not read ${f.path}, skipping${C.reset}`);
+    }
+  }
+  return results;
+};
 var OWNER_ID = "local-owner";
 var computeTurn = (messages) => Math.max(1, Math.floor(messages.length / 2) + 1);
 var formatDate = (value) => {
@@ -1521,7 +1558,7 @@ var handleSlash = async (command, state, conversationStore) => {
   if (norm === "/help") {
     console.log(
       gray(
-        "commands> /help /clear /exit /tools /list /open <id> /new [title] /delete [id] /continue /reset [all]"
+        "commands> /help /clear /exit /tools /attach <path> /files /list /open <id> /new [title] /delete [id] /continue /reset [all]"
       )
     );
     return { shouldExit: false };
@@ -1645,6 +1682,33 @@ var handleSlash = async (command, state, conversationStore) => {
     console.log(gray(`conversations> reset ${conversation.conversationId}`));
     return { shouldExit: false };
   }
+  if (norm === "/attach") {
+    const filePath = args.join(" ").trim();
+    if (!filePath) {
+      console.log(yellow("usage> /attach <path>"));
+      return { shouldExit: false };
+    }
+    const resolvedPath = resolve(process.cwd(), filePath);
+    try {
+      await readFile(resolvedPath);
+      state.pendingFiles.push({ path: filePath, resolved: resolvedPath });
+      console.log(gray(`attached> ${filePath} [${state.pendingFiles.length} file(s) queued]`));
+    } catch {
+      console.log(yellow(`attach> file not found: ${filePath}`));
+    }
+    return { shouldExit: false };
+  }
+  if (norm === "/files") {
+    if (state.pendingFiles.length === 0) {
+      console.log(gray("files> none attached"));
+    } else {
+      console.log(gray("files>"));
+      for (const f of state.pendingFiles) {
+        console.log(gray(`  ${f.path}`));
+      }
+    }
+    return { shouldExit: false };
+  }
   console.log(yellow(`Unknown command: ${command}`));
   return { shouldExit: false };
 };
@@ -1694,7 +1758,10 @@ ${C.yellow}approve? (y/n): ${C.reset}`,
   console.log(gray('  Type "exit" to quit, "/help" for commands'));
   console.log(gray("  Press Ctrl+C during a run to stop streaming output."));
   console.log(
-    gray("  Conversation controls: /list /open <id> /new [title] /delete [id] /continue /reset [all]\n")
+    gray("  Conversation: /list /open <id> /new [title] /delete [id] /continue /reset [all]")
+  );
+  console.log(
+    gray("  Files: /attach <path> /files\n")
   );
   const intro = await consumeFirstRunIntro(workingDir, {
     agentName: metadata.agentName,
@@ -1712,6 +1779,7 @@ ${C.yellow}approve? (y/n): ${C.reset}`,
   let activeConversationId = null;
   let showToolPayloads = false;
   let activeRunAbortController = null;
+  let pendingFiles = [];
   rl.on("SIGINT", () => {
     if (activeRunAbortController && !activeRunAbortController.signal.aborted) {
       activeRunAbortController.abort();
@@ -1721,8 +1789,9 @@ ${C.yellow}approve? (y/n): ${C.reset}`,
     }
     rl.close();
   });
-  const prompt = `${C.cyan}you> ${C.reset}`;
   while (true) {
+    const filesTag = pendingFiles.length > 0 ? `${C.dim}[${pendingFiles.length} file(s)] ${C.reset}` : "";
+    const prompt = `${filesTag}${C.cyan}you> ${C.reset}`;
     let task;
     try {
       task = await ask(rl, prompt);
@@ -1742,7 +1811,8 @@ ${C.yellow}approve? (y/n): ${C.reset}`,
       const interactiveState = {
         messages,
         turn,
-        activeConversationId
+        activeConversationId,
+        pendingFiles
       };
       const slashResult = await handleSlash(
         trimmed,
@@ -1755,6 +1825,7 @@ ${C.yellow}approve? (y/n): ${C.reset}`,
       messages = interactiveState.messages;
       turn = interactiveState.turn;
       activeConversationId = interactiveState.activeConversationId;
+      pendingFiles = interactiveState.pendingFiles;
       continue;
     }
     console.log(gray(`
@@ -1782,11 +1853,17 @@ ${C.yellow}approve? (y/n): ${C.reset}`,
     let latestRunId = "";
     const startedAt = Date.now();
     activeRunAbortController = new AbortController();
+    const turnFiles = pendingFiles.length > 0 ? await readPendingFiles(pendingFiles) : [];
+    if (pendingFiles.length > 0) {
+      console.log(gray(`  sending ${turnFiles.length} file(s)`));
+      pendingFiles = [];
+    }
     try {
       for await (const event of harness.run({
         task: trimmed,
         parameters: params,
         messages,
+        files: turnFiles.length > 0 ? turnFiles : void 0,
         abortSignal: activeRunAbortController.signal
       })) {
         if (event.type === "run:started") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poncho-ai/cli",
-  "version": "0.10.2",
+  "version": "0.11.1",
   "description": "CLI for building and deploying AI agents",
   "repository": {
     "type": "git",
@@ -18,6 +18,7 @@
   "types": "./dist/index.d.ts",
   "dependencies": {
     "@inquirer/prompts": "^8.2.0",
+    "busboy": "^1.6.0",
     "commander": "^12.0.0",
     "dotenv": "^16.4.0",
     "ink": "^6.7.0",
@@ -25,10 +26,11 @@
     "react": "^19.2.4",
     "react-devtools-core": "^6.1.5",
     "yaml": "^2.8.1",
-    "@poncho-ai/harness": "0.11.2",
-    "@poncho-ai/sdk": "0.6.0"
+    "@poncho-ai/harness": "0.12.0",
+    "@poncho-ai/sdk": "1.0.0"
   },
   "devDependencies": {
+    "@types/busboy": "^1.5.4",
     "@types/react": "^19.2.14",
     "tsup": "^8.0.0",
     "vitest": "^1.4.0"

package/src/index.ts

@@ -15,14 +15,19 @@ import {
   LocalMcpBridge,
   TelemetryEmitter,
   createConversationStore,
+  createUploadStore,
+  deriveUploadKey,
   ensureAgentIdentity,
   generateAgentId,
   loadPonchoConfig,
   resolveStateConfig,
   type PonchoConfig,
   type ConversationStore,
+  type UploadStore,
 } from "@poncho-ai/harness";
-import type { AgentEvent, Message, RunInput } from "@poncho-ai/sdk";
+import type { AgentEvent, FileInput, Message, RunInput } from "@poncho-ai/sdk";
+import { getTextContent } from "@poncho-ai/sdk";
+import Busboy from "busboy";
 import { Command } from "commander";
 import dotenv from "dotenv";
 import YAML from "yaml";
@@ -63,6 +68,15 @@ const writeHtml = (response: ServerResponse, statusCode: number, payload: string
   response.end(payload);
 };
 
+const EXT_MIME_MAP: Record<string, string> = {
+  jpg: "image/jpeg", jpeg: "image/jpeg", png: "image/png",
+  gif: "image/gif", webp: "image/webp", svg: "image/svg+xml",
+  pdf: "application/pdf", mp4: "video/mp4", webm: "video/webm",
+  mp3: "audio/mpeg", wav: "audio/wav", txt: "text/plain",
+  json: "application/json", csv: "text/csv", html: "text/html",
+};
+const extToMime = (ext: string): string => EXT_MIME_MAP[ext] ?? "application/octet-stream";
+
 const readRequestBody = async (request: IncomingMessage): Promise<unknown> => {
   const chunks: Buffer[] = [];
   for await (const chunk of request) {
@@ -72,6 +86,49 @@ const readRequestBody = async (request: IncomingMessage): Promise<unknown> => {
   return body.length > 0 ? (JSON.parse(body) as unknown) : {};
 };
 
+const MAX_UPLOAD_SIZE = 25 * 1024 * 1024; // 25MB per file
+
+interface ParsedMultipart {
+  message: string;
+  parameters?: Record<string, unknown>;
+  files: FileInput[];
+}
+
+const parseMultipartRequest = (request: IncomingMessage): Promise<ParsedMultipart> =>
+  new Promise((resolve, reject) => {
+    const result: ParsedMultipart = { message: "", files: [] };
+    const bb = Busboy({
+      headers: request.headers,
+      limits: { fileSize: MAX_UPLOAD_SIZE },
+    });
+
+    bb.on("field", (name: string, value: string) => {
+      if (name === "message") result.message = value;
+      if (name === "parameters") {
+        try {
+          result.parameters = JSON.parse(value) as Record<string, unknown>;
+        } catch { /* ignore malformed parameters */ }
+      }
+    });
+
+    bb.on("file", (_name: string, stream: NodeJS.ReadableStream, info: { filename: string; mimeType: string }) => {
+      const chunks: Buffer[] = [];
+      stream.on("data", (chunk: Buffer) => chunks.push(chunk));
+      stream.on("end", () => {
+        const buf = Buffer.concat(chunks);
+        result.files.push({
+          data: buf.toString("base64"),
+          mediaType: info.mimeType,
+          filename: info.filename,
+        });
+      });
+    });
+
+    bb.on("finish", () => resolve(result));
+    bb.on("error", (err: Error) => reject(err));
+    request.pipe(bb);
+  });
+
 /**
  * Detects the runtime environment from platform-specific or standard environment variables.
  * Priority: PONCHO_ENV > platform detection (Vercel, Railway, etc.) > NODE_ENV > "development"
@@ -689,10 +746,19 @@ const writeScaffoldFile = async (
   options.writtenPaths.push(relative(options.baseDir, filePath));
 };
 
+const UPLOAD_PROVIDER_DEPS: Record<string, Array<{ name: string; fallback: string }>> = {
+  "vercel-blob": [{ name: "@vercel/blob", fallback: "^2.3.0" }],
+  s3: [
+    { name: "@aws-sdk/client-s3", fallback: "^3.700.0" },
+    { name: "@aws-sdk/s3-request-presigner", fallback: "^3.700.0" },
+  ],
+};
+
 const ensureRuntimeCliDependency = async (
   projectDir: string,
   cliVersion: string,
-): Promise<string[]> => {
+  config?: PonchoConfig,
+): Promise<{ paths: string[]; addedDeps: string[] }> => {
   const packageJsonPath = resolve(projectDir, "package.json");
   const content = await readFile(packageJsonPath, "utf8");
   const parsed = JSON.parse(content) as {
@@ -713,9 +779,21 @@ const ensureRuntimeCliDependency = async (
   }
   dependencies.marked = await readCliDependencyVersion("marked", "^17.0.2");
   dependencies["@poncho-ai/cli"] = `^${cliVersion}`;
+
+  const addedDeps: string[] = [];
+  const uploadsProvider = config?.uploads?.provider;
+  if (uploadsProvider && UPLOAD_PROVIDER_DEPS[uploadsProvider]) {
+    for (const dep of UPLOAD_PROVIDER_DEPS[uploadsProvider]) {
+      if (!dependencies[dep.name]) {
+        dependencies[dep.name] = dep.fallback;
+        addedDeps.push(dep.name);
+      }
+    }
+  }
+
   parsed.dependencies = dependencies;
   await writeFile(packageJsonPath, `${JSON.stringify(parsed, null, 2)}\n`, "utf8");
-  return [relative(projectDir, packageJsonPath)];
+  return { paths: [relative(projectDir, packageJsonPath)], addedDeps };
 };
 
 const scaffoldDeployTarget = async (
@@ -855,10 +933,16 @@ CMD ["node","server.js"]
     });
   }
 
-  const packagePaths = await ensureRuntimeCliDependency(projectDir, cliVersion);
-  for (const path of packagePaths) {
-    if (!writtenPaths.includes(path)) {
-      writtenPaths.push(path);
+  const config = await loadPonchoConfig(projectDir);
+  const { paths: packagePaths, addedDeps } = await ensureRuntimeCliDependency(
+    projectDir,
+    cliVersion,
+    config,
+  );
+  const depNote = addedDeps.length > 0 ? ` (added ${addedDeps.join(", ")})` : "";
+  for (const p of packagePaths) {
+    if (!writtenPaths.includes(p)) {
+      writtenPaths.push(depNote ? `${p}${depNote}` : p);
     }
   }
 
@@ -1161,9 +1245,11 @@ export const createRequestHandler = async (options?: {
     }
     await persistConversationPendingApprovals(conversationId);
   };
+  const uploadStore = await createUploadStore(config?.uploads, workingDir);
   const harness = new AgentHarness({
     workingDir,
     environment: resolveHarnessEnvironment(),
+    uploadStore,
     approvalHandler: async (request) =>
       new Promise<boolean>((resolveApproval) => {
         const ownerIdForRun = runOwners.get(request.runId) ?? "local-owner";
@@ -1611,6 +1697,31 @@ export const createRequestHandler = async (options?: {
       return;
     }
 
+    const uploadMatch = pathname.match(/^\/api\/uploads\/(.+)$/);
+    if (uploadMatch && request.method === "GET") {
+      const key = decodeURIComponent(uploadMatch[1] ?? "");
+      try {
+        const data = await uploadStore.get(key);
+        const ext = key.split(".").pop() ?? "";
+        const mimeMap: Record<string, string> = {
+          jpg: "image/jpeg", jpeg: "image/jpeg", png: "image/png",
+          gif: "image/gif", webp: "image/webp", svg: "image/svg+xml",
+          pdf: "application/pdf", mp4: "video/mp4", webm: "video/webm",
+          mp3: "audio/mpeg", wav: "audio/wav", txt: "text/plain",
+          json: "application/json", csv: "text/csv", html: "text/html",
+        };
+        response.writeHead(200, {
+          "Content-Type": mimeMap[ext] ?? "application/octet-stream",
+          "Content-Length": data.length,
+          "Cache-Control": "public, max-age=86400",
+        });
+        response.end(data);
+      } catch {
+        writeJson(response, 404, { code: "NOT_FOUND", message: "Upload not found" });
+      }
+      return;
+    }
+
     const conversationMessageMatch = pathname.match(/^\/api\/conversations\/([^/]+)\/messages$/);
     if (conversationMessageMatch && request.method === "POST") {
       const conversationId = decodeURIComponent(conversationMessageMatch[1] ?? "");
@@ -1622,11 +1733,31 @@ export const createRequestHandler = async (options?: {
         });
         return;
       }
-      const body = (await readRequestBody(request)) as {
-        message?: string;
-        parameters?: Record<string, unknown>;
-      };
-      const messageText = body.message?.trim() ?? "";
+      let messageText = "";
+      let bodyParameters: Record<string, unknown> | undefined;
+      let files: FileInput[] = [];
+
+      const contentType = request.headers["content-type"] ?? "";
+      if (contentType.includes("multipart/form-data")) {
+        const parsed = await parseMultipartRequest(request);
+        messageText = parsed.message.trim();
+        bodyParameters = parsed.parameters;
+        files = parsed.files;
+      } else {
+        const body = (await readRequestBody(request)) as {
+          message?: string;
+          parameters?: Record<string, unknown>;
+          files?: Array<{ data?: string; mediaType?: string; filename?: string }>;
+        };
+        messageText = body.message?.trim() ?? "";
+        bodyParameters = body.parameters;
+        if (Array.isArray(body.files)) {
+          files = body.files
+            .filter((f): f is { data: string; mediaType: string; filename?: string } =>
+              typeof f.data === "string" && typeof f.mediaType === "string",
+            );
+        }
+      }
       if (!messageText) {
         writeJson(response, 400, {
           code: "VALIDATION_ERROR",
@@ -1671,9 +1802,44 @@ export const createRequestHandler = async (options?: {
       let currentText = "";
       let currentTools: string[] = [];
       let runCancelled = false;
+      let userContent: Message["content"] = messageText;
+      if (files.length > 0) {
+        try {
+          const uploadedParts = await Promise.all(
+            files.map(async (f) => {
+              const buf = Buffer.from(f.data, "base64");
+              const key = deriveUploadKey(buf, f.mediaType);
+              const ref = await uploadStore.put(key, buf, f.mediaType);
+              return {
+                type: "file" as const,
+                data: ref,
+                mediaType: f.mediaType,
+                filename: f.filename,
+              };
+            }),
+          );
+          userContent = [
+            { type: "text" as const, text: messageText },
+            ...uploadedParts,
+          ];
+        } catch (uploadErr) {
+          const errMsg = uploadErr instanceof Error ? uploadErr.message : String(uploadErr);
+          console.error("[poncho] File upload failed:", errMsg);
+          const errorEvent: AgentEvent = {
+            type: "run:error",
+            runId: "",
+            error: { code: "UPLOAD_ERROR", message: `File upload failed: ${errMsg}` },
+          };
+          broadcastEvent(conversationId, errorEvent);
+          finishConversationStream(conversationId);
+          activeConversationRuns.delete(conversationId);
+          response.end();
+          return;
+        }
+      }
       try {
         // Persist the user turn immediately so refreshing mid-run keeps chat context.
-        conversation.messages = [...historyMessages, { role: "user", content: messageText }];
+        conversation.messages = [...historyMessages, { role: "user", content: userContent }];
         conversation.updatedAt = Date.now();
         await conversationStore.update(conversation);
 
@@ -1697,7 +1863,7 @@ export const createRequestHandler = async (options?: {
           }
           conversation.messages = [
             ...historyMessages,
-            { role: "user", content: messageText },
+            { role: "user", content: userContent },
             {
               role: "assistant",
               content: assistantResponse,
@@ -1723,7 +1889,7 @@ export const createRequestHandler = async (options?: {
             updatedAt: item.updatedAt,
             content: item.messages
               .slice(-6)
-              .map((message) => `${message.role}: ${message.content}`)
+              .map((message) => `${message.role}: ${typeof message.content === "string" ? message.content : getTextContent(message)}`)
               .join("\n")
               .slice(0, 2000),
           }))
@@ -1732,11 +1898,12 @@ export const createRequestHandler = async (options?: {
         for await (const event of harness.runWithTelemetry({
           task: messageText,
           parameters: {
-            ...(body.parameters ?? {}),
+            ...(bodyParameters ?? {}),
             __conversationRecallCorpus: recallCorpus,
             __activeConversationId: conversationId,
           },
           messages: historyMessages,
+          files: files.length > 0 ? files : undefined,
           abortSignal: abortController.signal,
         })) {
           if (event.type === "run:started") {
@@ -1780,6 +1947,9 @@ export const createRequestHandler = async (options?: {
             toolTimeline.push(toolText);
             currentTools.push(toolText);
           }
+          if (event.type === "step:completed") {
+            await persistDraftAssistantTurn();
+          }
           if (event.type === "tool:approval:required") {
             const toolText = `- approval required \`${event.tool}\``;
             toolTimeline.push(toolText);
@@ -1826,7 +1996,7 @@ export const createRequestHandler = async (options?: {
         conversation.messages = hasAssistantContent
           ? [
               ...historyMessages,
-              { role: "user", content: messageText },
+              { role: "user", content: userContent },
               {
                 role: "assistant",
                 content: assistantResponse,
@@ -1839,7 +2009,7 @@ export const createRequestHandler = async (options?: {
                     : undefined,
               },
             ]
-          : [...historyMessages, { role: "user", content: messageText }];
+          : [...historyMessages, { role: "user", content: userContent }];
         conversation.runtimeRunId = latestRunId || conversation.runtimeRunId;
         conversation.pendingApprovals = [];
         conversation.updatedAt = Date.now();
@@ -1856,7 +2026,7 @@ export const createRequestHandler = async (options?: {
           if (assistantResponse.length > 0 || toolTimeline.length > 0 || fallbackSections.length > 0) {
             conversation.messages = [
               ...historyMessages,
-              { role: "user", content: messageText },
+              { role: "user", content: userContent },
               {
                 role: "assistant",
                 content: assistantResponse,
@@ -1898,7 +2068,7 @@ export const createRequestHandler = async (options?: {
           if (assistantResponse.length > 0 || toolTimeline.length > 0 || fallbackSections.length > 0) {
             conversation.messages = [
               ...historyMessages,
-              { role: "user", content: messageText },
+              { role: "user", content: userContent },
               {
                 role: "assistant",
                 content: assistantResponse,
@@ -1975,20 +2145,28 @@ export const runOnce = async (
   const workingDir = options.workingDir ?? process.cwd();
   dotenv.config({ path: resolve(workingDir, ".env") });
   const config = await loadPonchoConfig(workingDir);
-  const harness = new AgentHarness({ workingDir });
+  const uploadStore = await createUploadStore(config?.uploads, workingDir);
+  const harness = new AgentHarness({ workingDir, uploadStore });
   const telemetry = new TelemetryEmitter(config?.telemetry);
   await harness.initialize();
 
-  const fileBlobs = await Promise.all(
-    options.filePaths.map(async (path) => {
-      const content = await readFile(resolve(workingDir, path), "utf8");
-      return `# File: ${path}\n${content}`;
+  const fileInputs: FileInput[] = await Promise.all(
+    options.filePaths.map(async (filePath) => {
+      const absPath = resolve(workingDir, filePath);
+      const buf = await readFile(absPath);
+      const ext = absPath.split(".").pop()?.toLowerCase() ?? "";
+      return {
+        data: buf.toString("base64"),
+        mediaType: extToMime(ext),
+        filename: basename(filePath),
+      };
     }),
   );
 
   const input: RunInput = {
-    task: fileBlobs.length > 0 ? `${task}\n\n${fileBlobs.join("\n\n")}` : task,
+    task,
     parameters: options.params,
+    files: fileInputs.length > 0 ? fileInputs : undefined,
   };
 
   if (options.json) {
@@ -2058,10 +2236,12 @@ export const runInteractive = async (
     });
   };
 
+  const uploadStore = await createUploadStore(config?.uploads, workingDir);
   const harness = new AgentHarness({
     workingDir,
     environment: resolveHarnessEnvironment(),
     approvalHandler,
+    uploadStore,
   });
   await harness.initialize();
   const identity = await ensureAgentIdentity(workingDir);