@poncho-ai/cli 0.3.0 → 0.3.2

package/dist/run-interactive-ink-M5E55KCC.js

@@ -0,0 +1,463 @@
+import {
+  consumeFirstRunIntro,
+  inferConversationTitle,
+  resolveHarnessEnvironment
+} from "./chunk-XABZUC4W.js";
+
+// src/run-interactive-ink.ts
+import * as readline from "readline";
+import { stdout } from "process";
+import {
+  parseAgentFile
+} from "@poncho-ai/harness";
+var C = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  gray: "\x1B[90m",
+  magenta: "\x1B[35m"
+};
+var green = (s) => `${C.green}${s}${C.reset}`;
+var yellow = (s) => `${C.yellow}${s}${C.reset}`;
+var red = (s) => `${C.red}${s}${C.reset}`;
+var gray = (s) => `${C.gray}${s}${C.reset}`;
+var magenta = (s) => `${C.magenta}${s}${C.reset}`;
+var FAUX_TOOL_LOG_PATTERN = /Tool Used:|Tool Result:|\blist_skills\b|\bcreate_skill\b|\bedit_skill\b/i;
+var formatDuration = (ms) => ms < 1e3 ? `${ms}ms` : `${(ms / 1e3).toFixed(1)}s`;
+var stringifyValue = (v) => {
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return String(v);
+  }
+};
+var truncate = (v, max) => v.length <= max ? v : `${v.slice(0, Math.max(0, max - 3))}...`;
+var compactPreview = (v, max = 120) => truncate(stringifyValue(v).replace(/\s+/g, " "), max);
+var loadMetadata = async (workingDir) => {
+  let agentName = "agent";
+  let model = "unknown";
+  let provider = "unknown";
+  try {
+    const parsed = await parseAgentFile(workingDir);
+    agentName = parsed.frontmatter.name ?? agentName;
+    model = parsed.frontmatter.model?.name ?? model;
+    provider = parsed.frontmatter.model?.provider ?? provider;
+  } catch {
+  }
+  return {
+    agentName,
+    model,
+    provider,
+    workingDir,
+    environment: resolveHarnessEnvironment()
+  };
+};
+var ask = (rl, prompt) => new Promise((res) => {
+  rl.question(prompt, (answer) => res(answer));
+});
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var streamTextAsTokens = async (text) => {
+  const tokens = text.match(/\S+\s*|\n/g) ?? [text];
+  for (const token of tokens) {
+    stdout.write(token);
+    const trimmed = token.trim();
+    const delay = trimmed.length === 0 ? 0 : Math.max(4, Math.min(18, Math.floor(trimmed.length / 2)));
+    await sleep(delay);
+  }
+};
+var OWNER_ID = "local-owner";
+var computeTurn = (messages) => Math.max(1, Math.floor(messages.length / 2) + 1);
+var formatDate = (value) => {
+  try {
+    return new Date(value).toLocaleString();
+  } catch {
+    return String(value);
+  }
+};
+var handleSlash = async (command, state, conversationStore) => {
+  const [rawCommand, ...args] = command.trim().split(/\s+/);
+  const norm = rawCommand.toLowerCase();
+  if (norm === "/help") {
+    console.log(
+      gray(
+        "commands> /help /clear /exit /tools /list /open <id> /new [title] /delete [id] /continue /reset [all]"
+      )
+    );
+    return { shouldExit: false };
+  }
+  if (norm === "/clear") {
+    process.stdout.write("\x1B[2J\x1B[H");
+    return { shouldExit: false };
+  }
+  if (norm === "/exit") {
+    return { shouldExit: true };
+  }
+  if (norm === "/list") {
+    const conversations = await conversationStore.list(OWNER_ID);
+    if (conversations.length === 0) {
+      console.log(gray("conversations> none"));
+      return { shouldExit: false };
+    }
+    console.log(gray("conversations>"));
+    for (const conversation of conversations) {
+      const activeMarker = state.activeConversationId === conversation.conversationId ? "*" : " ";
+      console.log(
+        gray(
+          `${activeMarker} ${conversation.conversationId} | ${conversation.title} | ${formatDate(conversation.updatedAt)}`
+        )
+      );
+    }
+    return { shouldExit: false };
+  }
+  if (norm === "/open") {
+    const conversationId = args[0];
+    if (!conversationId) {
+      console.log(yellow("usage> /open <conversationId>"));
+      return { shouldExit: false };
+    }
+    const conversation = await conversationStore.get(conversationId);
+    if (!conversation) {
+      console.log(yellow(`conversations> not found: ${conversationId}`));
+      return { shouldExit: false };
+    }
+    state.activeConversationId = conversation.conversationId;
+    state.messages = [...conversation.messages];
+    state.turn = computeTurn(state.messages);
+    console.log(gray(`conversations> opened ${conversation.conversationId}`));
+    return { shouldExit: false };
+  }
+  if (norm === "/new") {
+    const title = args.join(" ").trim();
+    const conversation = await conversationStore.create(OWNER_ID, title || void 0);
+    state.activeConversationId = conversation.conversationId;
+    state.messages = [];
+    state.turn = 1;
+    console.log(gray(`conversations> new ${conversation.conversationId}`));
+    return { shouldExit: false };
+  }
+  if (norm === "/delete") {
+    const targetConversationId = args[0] ?? state.activeConversationId ?? "";
+    if (!targetConversationId) {
+      console.log(yellow("usage> /delete <conversationId>"));
+      return { shouldExit: false };
+    }
+    const removed = await conversationStore.delete(targetConversationId);
+    if (!removed) {
+      console.log(yellow(`conversations> not found: ${targetConversationId}`));
+      return { shouldExit: false };
+    }
+    if (state.activeConversationId === targetConversationId) {
+      state.activeConversationId = null;
+      state.messages = [];
+      state.turn = 1;
+    }
+    console.log(gray(`conversations> deleted ${targetConversationId}`));
+    return { shouldExit: false };
+  }
+  if (norm === "/continue") {
+    const conversations = await conversationStore.list(OWNER_ID);
+    const latest = conversations[0];
+    if (!latest) {
+      console.log(yellow("conversations> no conversations to continue"));
+      return { shouldExit: false };
+    }
+    state.activeConversationId = latest.conversationId;
+    state.messages = [...latest.messages];
+    state.turn = computeTurn(state.messages);
+    console.log(gray(`conversations> continued ${latest.conversationId}`));
+    return { shouldExit: false };
+  }
+  if (norm === "/reset") {
+    if (args[0]?.toLowerCase() === "all") {
+      const conversations = await conversationStore.list(OWNER_ID);
+      for (const conversation2 of conversations) {
+        await conversationStore.delete(conversation2.conversationId);
+      }
+      state.activeConversationId = null;
+      state.messages = [];
+      state.turn = 1;
+      console.log(gray("conversations> reset all"));
+      return { shouldExit: false };
+    }
+    if (!state.activeConversationId) {
+      state.messages = [];
+      state.turn = 1;
+      console.log(gray("conversations> current session reset"));
+      return { shouldExit: false };
+    }
+    const conversation = await conversationStore.get(state.activeConversationId);
+    if (!conversation) {
+      state.activeConversationId = null;
+      state.messages = [];
+      state.turn = 1;
+      console.log(yellow("conversations> active conversation no longer exists"));
+      return { shouldExit: false };
+    }
+    await conversationStore.update({
+      ...conversation,
+      messages: []
+    });
+    state.messages = [];
+    state.turn = 1;
+    console.log(gray(`conversations> reset ${conversation.conversationId}`));
+    return { shouldExit: false };
+  }
+  console.log(yellow(`Unknown command: ${command}`));
+  return { shouldExit: false };
+};
+var runInteractiveInk = async ({
+  harness,
+  params,
+  workingDir,
+  config,
+  conversationStore,
+  onSetApprovalCallback
+}) => {
+  const metadata = await loadMetadata(workingDir);
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+  });
+  if (onSetApprovalCallback) {
+    onSetApprovalCallback((req) => {
+      process.stdout.write("\n");
+      const preview = compactPreview(req.input, 100);
+      rl.question(
+        `${C.yellow}${C.bold}Tool "${req.tool}" requires approval${C.reset}
+${C.gray}input: ${preview}${C.reset}
+${C.yellow}approve? (y/n): ${C.reset}`,
+        (answer) => {
+          const approved = answer.trim().toLowerCase() === "y";
+          console.log(
+            approved ? green(`  approved ${req.tool}`) : magenta(`  denied ${req.tool}`)
+          );
+          req.resolve(approved);
+        }
+      );
+    });
+  }
+  console.log(
+    gray(
+      `
+${metadata.agentName} | ${metadata.provider}/${metadata.model} | ${metadata.environment}`
+    )
+  );
+  console.log(gray('Type "exit" to quit, "/help" for commands'));
+  console.log(
+    gray("Conversation controls: /list /open <id> /new [title] /delete [id] /continue /reset [all]\n")
+  );
+  const intro = await consumeFirstRunIntro(workingDir, {
+    agentName: metadata.agentName,
+    provider: metadata.provider,
+    model: metadata.model,
+    config
+  });
+  if (intro) {
+    console.log(green("assistant>"));
+    await streamTextAsTokens(intro);
+    stdout.write("\n\n");
+  }
+  let messages = intro ? [{ role: "assistant", content: intro }] : [];
+  let turn = 1;
+  let activeConversationId = null;
+  let showToolPayloads = false;
+  const prompt = `${C.cyan}you> ${C.reset}`;
+  while (true) {
+    let task;
+    try {
+      task = await ask(rl, prompt);
+    } catch {
+      break;
+    }
+    const trimmed = task.trim();
+    if (!trimmed) continue;
+    if (trimmed.toLowerCase() === "exit") break;
+    if (trimmed.startsWith("/")) {
+      if (trimmed.toLowerCase() === "/exit") break;
+      if (trimmed.toLowerCase() === "/tools") {
+        showToolPayloads = !showToolPayloads;
+        console.log(gray(`tool payloads: ${showToolPayloads ? "on" : "off"}`));
+        continue;
+      }
+      const interactiveState = {
+        messages,
+        turn,
+        activeConversationId
+      };
+      const slashResult = await handleSlash(
+        trimmed,
+        interactiveState,
+        conversationStore
+      );
+      if (slashResult.shouldExit) {
+        break;
+      }
+      messages = interactiveState.messages;
+      turn = interactiveState.turn;
+      activeConversationId = interactiveState.activeConversationId;
+      continue;
+    }
+    console.log(gray(`
+--- turn ${turn} ---`));
+    process.stdout.write(gray("thinking..."));
+    let thinkingCleared = false;
+    const clearThinking = () => {
+      if (thinkingCleared) return;
+      thinkingCleared = true;
+      readline.clearLine(process.stdout, 0);
+      readline.cursorTo(process.stdout, 0);
+    };
+    let responseText = "";
+    let streamedText = "";
+    let committedText = false;
+    let sawChunk = false;
+    let toolEvents = 0;
+    const toolTimeline = [];
+    let runFailed = false;
+    let usage;
+    let latestRunId = "";
+    const startedAt = Date.now();
+    try {
+      for await (const event of harness.run({
+        task: trimmed,
+        parameters: params,
+        messages
+      })) {
+        if (event.type === "run:started") {
+          latestRunId = event.runId;
+        }
+        if (event.type === "model:chunk") {
+          sawChunk = true;
+          responseText += event.content;
+          streamedText += event.content;
+          if (!thinkingCleared) {
+            clearThinking();
+            process.stdout.write(`${C.green}assistant> ${C.reset}`);
+          }
+          process.stdout.write(event.content);
+        } else if (event.type === "tool:started" || event.type === "tool:completed" || event.type === "tool:error" || event.type === "tool:approval:required" || event.type === "tool:approval:granted" || event.type === "tool:approval:denied") {
+          if (streamedText.length > 0) {
+            committedText = true;
+            streamedText = "";
+            process.stdout.write("\n");
+          }
+          clearThinking();
+          if (event.type === "tool:started") {
+            const preview = showToolPayloads ? compactPreview(event.input, 400) : compactPreview(event.input, 100);
+            console.log(yellow(`tools> start ${event.tool} input=${preview}`));
+            toolTimeline.push(`- start \`${event.tool}\``);
+            toolEvents += 1;
+          } else if (event.type === "tool:completed") {
+            const preview = showToolPayloads ? compactPreview(event.output, 400) : compactPreview(event.output, 100);
+            console.log(
+              yellow(
+                `tools> done  ${event.tool} in ${formatDuration(event.duration)}`
+              )
+            );
+            if (showToolPayloads) {
+              console.log(yellow(`tools> output ${preview}`));
+            }
+            toolTimeline.push(
+              `- done \`${event.tool}\` in ${formatDuration(event.duration)}`
+            );
+          } else if (event.type === "tool:error") {
+            console.log(
+              red(`tools> error ${event.tool}: ${event.error}`)
+            );
+            toolTimeline.push(`- error \`${event.tool}\`: ${event.error}`);
+          } else if (event.type === "tool:approval:required") {
+            console.log(
+              magenta(`tools> approval required for ${event.tool}`)
+            );
+            toolTimeline.push(`- approval required \`${event.tool}\``);
+          } else if (event.type === "tool:approval:granted") {
+            console.log(
+              gray(`tools> approval granted (${event.approvalId})`)
+            );
+            toolTimeline.push(`- approval granted (${event.approvalId})`);
+          } else if (event.type === "tool:approval:denied") {
+            console.log(
+              magenta(`tools> approval denied (${event.approvalId})`)
+            );
+            toolTimeline.push(`- approval denied (${event.approvalId})`);
+          }
+        } else if (event.type === "run:error") {
+          clearThinking();
+          runFailed = true;
+          console.log(red(`error> ${event.error.message}`));
+        } else if (event.type === "model:response") {
+          usage = event.usage;
+        } else if (event.type === "run:completed" && !sawChunk) {
+          clearThinking();
+          responseText = event.result.response ?? "";
+          if (responseText.length > 0) {
+            process.stdout.write(
+              `${C.green}assistant> ${C.reset}${responseText}
+`
+            );
+          }
+        }
+      }
+    } catch (error) {
+      clearThinking();
+      runFailed = true;
+      console.log(
+        red(
+          `error> ${error instanceof Error ? error.message : "Unknown error"}`
+        )
+      );
+    }
+    if (sawChunk && streamedText.length > 0) {
+      process.stdout.write("\n");
+    } else if (!sawChunk && !runFailed && responseText.length === 0) {
+      clearThinking();
+      console.log(green("assistant> (no response)"));
+    }
+    const fullResponse = responseText || streamedText;
+    if (!runFailed && toolEvents === 0 && FAUX_TOOL_LOG_PATTERN.test(fullResponse)) {
+      console.log(
+        magenta(
+          "warning> assistant described tool execution but no real tool events occurred."
+        )
+      );
+    }
+    const durationMs = Date.now() - startedAt;
+    console.log(
+      gray(`meta> ${formatDuration(durationMs)} | tools: ${toolEvents}
+`)
+    );
+    if (!activeConversationId) {
+      const created = await conversationStore.create(
+        OWNER_ID,
+        inferConversationTitle(trimmed)
+      );
+      activeConversationId = created.conversationId;
+    }
+    messages.push({ role: "user", content: trimmed });
+    messages.push({
+      role: "assistant",
+      content: responseText,
+      metadata: toolTimeline.length > 0 ? { toolActivity: toolTimeline } : void 0
+    });
+    turn = computeTurn(messages);
+    const conversation = await conversationStore.get(activeConversationId);
+    if (conversation) {
+      const maybeTitle = conversation.messages.length === 0 && (conversation.title === "New conversation" || conversation.title.trim().length === 0) ? inferConversationTitle(trimmed) : conversation.title;
+      await conversationStore.update({
+        ...conversation,
+        title: maybeTitle,
+        messages: [...messages],
+        runtimeRunId: latestRunId || conversation.runtimeRunId
+      });
+    }
+  }
+  rl.close();
+};
+export {
+  runInteractiveInk
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poncho-ai/cli",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "CLI for building and deploying AI agents",
   "repository": {
     "type": "git",
@@ -25,7 +25,7 @@
     "react": "^19.2.4",
     "react-devtools-core": "^6.1.5",
     "yaml": "^2.8.1",
-    "@poncho-ai/harness": "0.3.0",
+    "@poncho-ai/harness": "0.3.1",
     "@poncho-ai/sdk": "0.2.0"
   },
   "devDependencies": {

package/src/index.ts

@@ -69,11 +69,63 @@ const readRequestBody = async (request: IncomingMessage): Promise<unknown> => {
   return body.length > 0 ? (JSON.parse(body) as unknown) : {};
 };
 
-const resolveHarnessEnvironment = (): "development" | "staging" | "production" => {
-  const value = (process.env.PONCHO_ENV ?? process.env.NODE_ENV ?? "development").toLowerCase();
-  if (value === "production" || value === "staging") {
-    return value;
+/**
+ * Detects the runtime environment from platform-specific or standard environment variables.
+ * Priority: PONCHO_ENV > platform detection (Vercel, Railway, etc.) > NODE_ENV > "development"
+ */
+export const resolveHarnessEnvironment = (): "development" | "staging" | "production" => {
+  // Check explicit Poncho environment variable first
+  if (process.env.PONCHO_ENV) {
+    const value = process.env.PONCHO_ENV.toLowerCase();
+    if (value === "production" || value === "staging") {
+      return value;
+    }
+    return "development";
+  }
+
+  // Detect platform-specific environment variables
+  // Vercel
+  if (process.env.VERCEL_ENV) {
+    const vercelEnv = process.env.VERCEL_ENV.toLowerCase();
+    if (vercelEnv === "production") return "production";
+    if (vercelEnv === "preview") return "staging";
+    return "development";
+  }
+
+  // Railway
+  if (process.env.RAILWAY_ENVIRONMENT) {
+    const railwayEnv = process.env.RAILWAY_ENVIRONMENT.toLowerCase();
+    if (railwayEnv === "production") return "production";
+    return "staging";
+  }
+
+  // Render
+  if (process.env.RENDER) {
+    // Render sets IS_PULL_REQUEST for preview deploys
+    if (process.env.IS_PULL_REQUEST === "true") return "staging";
+    return "production";
+  }
+
+  // AWS Lambda
+  if (process.env.AWS_EXECUTION_ENV || process.env.AWS_LAMBDA_FUNCTION_NAME) {
+    return "production";
+  }
+
+  // Fly.io
+  if (process.env.FLY_APP_NAME) {
+    return "production";
+  }
+
+  // Fall back to NODE_ENV
+  if (process.env.NODE_ENV) {
+    const value = process.env.NODE_ENV.toLowerCase();
+    if (value === "production" || value === "staging") {
+      return value;
+    }
+    return "development";
   }
+
+  // Default to development
   return "development";
 };
 
@@ -174,17 +226,7 @@ Environment: {{runtime.environment}}
 - Use tools when needed
 - Explain your reasoning clearly
 - Ask clarifying questions when requirements are ambiguous
-- For setup/configuration/skills/MCP questions, proactively read \`README.md\` with \`read_file\` before answering.
-- Prefer concrete commands and examples from \`README.md\` over assumptions.
 - Never claim a file/tool change unless the corresponding tool call actually succeeded
-
-## Default Capabilities in a Fresh Project
-
-- Built-in tools: \`list_directory\` and \`read_file\`
-- \`write_file\` is available in development, and disabled by default in production
-- A starter local skill is included (\`starter-echo\`)
-- Bash/shell commands are **not** available unless you install and enable a shell tool/skill
-- Git operations are only available if a git-capable tool/skill is configured
 `;
 
 /**
@@ -782,7 +824,7 @@ export const createRequestHandler = async (options?: {
       agentModelName = modelMatch[1].trim().replace(/^["']|["']$/g, "");
     }
   } catch {}
-  const harness = new AgentHarness({ workingDir });
+  const harness = new AgentHarness({ workingDir, environment: resolveHarnessEnvironment() });
   await harness.initialize();
   const telemetry = new TelemetryEmitter(config?.telemetry);
   const conversationStore = createConversationStore(resolveStateConfig(config), { workingDir });

package/src/init-feature-context.ts

@@ -3,6 +3,7 @@ import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import { basename, dirname, resolve } from "node:path";
 import { homedir } from "node:os";
 import type { PonchoConfig } from "@poncho-ai/harness";
+import { resolveHarnessEnvironment } from "./index.js";
 
 type IntroInput = {
   agentName: string;
@@ -110,7 +111,7 @@ export const consumeFirstRunIntro = async (
   workingDir: string,
   input: IntroInput,
 ): Promise<string | undefined> => {
-  const runtimeEnv = (process.env.PONCHO_ENV ?? process.env.NODE_ENV ?? "").toLowerCase();
+  const runtimeEnv = resolveHarnessEnvironment();
   if (runtimeEnv === "production") {
     return undefined;
   }

package/src/run-interactive-ink.ts

@@ -17,6 +17,7 @@ import {
 import type { AgentEvent, Message, TokenUsage } from "@poncho-ai/sdk";
 import { inferConversationTitle } from "./web-ui.js";
 import { consumeFirstRunIntro } from "./init-feature-context.js";
+import { resolveHarnessEnvironment } from "./index.js";
 
 // Re-export types that index.ts references
 export type ApprovalRequest = {
@@ -103,7 +104,7 @@ const loadMetadata = async (workingDir: string): Promise<UiMetadata> => {
     model,
     provider,
     workingDir,
-    environment: process.env.PONCHO_ENV ?? process.env.NODE_ENV ?? "development",
+    environment: resolveHarnessEnvironment(),
   };
 };
 

package/src/web-ui.ts

@@ -1813,7 +1813,7 @@ export const renderWebUiHtml = (options?: { agentName?: string }): string => {
           if (!sidebar || !backdrop || !shell) return;
           
           var sidebarWidth = 260;
-          var edgeThreshold = 200; // px from left edge to start drag
+          var edgeThreshold = 50; // px from left edge to start drag
           var velocityThreshold = 0.3; // px/ms to trigger open/close
           
           var dragging = false;