talon-agent 1.0.0

package/src/frontend/terminal/input.ts

@@ -0,0 +1,297 @@
+/**
+ * Terminal input — raw stdin with manual key parsing.
+ *
+ * Input is a list of parts: text segments and collapsed paste blocks.
+ * You can type, paste, type more, paste again. Backspace removes from the end.
+ * Enter submits everything. Ctrl+U clears all.
+ */
+
+import pc from "picocolors";
+
+// ── Types ────────────────────────────────────────────────────────────────────
+
+export type InputHandler = {
+  onLine(callback: (text: string) => void): void;
+  prompt(): void;
+  waitForInput(): Promise<string>;
+  close(): void;
+  pause(): void;
+  resume(): void;
+};
+
+type TextPart = { type: "text"; content: string };
+type PastePart = { type: "paste"; content: string };
+type Part = TextPart | PastePart;
+
+// ── Constants ────────────────────────────────────────────────────────────────
+
+const PASTE_COLLAPSE_LINES = 3;
+const PASTE_COLLAPSE_CHARS = 150;
+const PASTE_START = "\x1b[200~";
+const PASTE_END = "\x1b[201~";
+
+// ── Factory ──────────────────────────────────────────────────────────────────
+
+export function createInput(promptStr: string): InputHandler {
+  let lineCallback: ((text: string) => void) | null = null;
+  let pendingResolve: ((value: string) => void) | null = null;
+  let paused = false;
+
+  // Input is an ordered list of parts
+  let parts: Part[] = [{ type: "text", content: "" }];
+
+  // Bracketed paste accumulation
+  let inPaste = false;
+  let pasteAccum = "";
+
+  // ── Helpers ──
+
+  function lastPart(): Part {
+    return parts[parts.length - 1]!;
+  }
+
+  /** Ensure the last part is a text part (for typing into). */
+  function ensureTrailingText(): TextPart {
+    const last = lastPart();
+    if (last.type === "text") return last;
+    const t: TextPart = { type: "text", content: "" };
+    parts.push(t);
+    return t;
+  }
+
+  function pasteTag(p: PastePart): string {
+    const lines = p.content.split("\n").length;
+    return lines > 1
+      ? `[Pasted ~${lines} lines]`
+      : `[Pasted ${p.content.length} chars]`;
+  }
+
+  // ── Drawing ──
+  // Track how many visual rows the last render occupied.
+  // Move up to the first row, clear to end of screen, rewrite.
+
+  let prevRows = 1;
+
+  function redraw(): void {
+    const cols = process.stdout.columns || 80;
+
+    // Build display string and measure visible length (strip ANSI)
+    let display = promptStr;
+    let visLen = 4; // "  ❯ " = 4 visible chars
+    for (const p of parts) {
+      if (p.type === "text") {
+        display += p.content;
+        visLen += p.content.length;
+      } else {
+        const tag = pasteTag(p);
+        display += pc.dim(tag);
+        visLen += tag.length;
+      }
+    }
+
+    // Move cursor to start of the previous render, clear to end of screen
+    if (prevRows > 1) {
+      process.stdout.write(`\x1b[${prevRows - 1}A`); // move up
+    }
+    process.stdout.write(`\r\x1b[J${display}\x1b[?25h`); // col 0, clear to EOS, write, show cursor
+
+    prevRows = Math.max(1, Math.ceil(visLen / cols));
+  }
+
+  function getFullText(): string {
+    return parts
+      .map((p) => p.content)
+      .join("\n")
+      .trim();
+  }
+
+  function clear(): void {
+    parts = [{ type: "text", content: "" }];
+  }
+
+  function submit(): void {
+    const text = getFullText();
+    clear();
+    process.stdout.write("\n");
+
+    if (pendingResolve) {
+      const resolve = pendingResolve;
+      pendingResolve = null;
+      resolve(text);
+      return;
+    }
+    if (lineCallback) lineCallback(text);
+  }
+
+  function handlePasteComplete(text: string): void {
+    const lineCount = text.split("\n").length;
+    if (
+      lineCount >= PASTE_COLLAPSE_LINES ||
+      text.length > PASTE_COLLAPSE_CHARS
+    ) {
+      // Collapse into a paste part
+      parts.push({ type: "paste", content: text });
+    } else {
+      // Short paste — inline into current text part
+      ensureTrailingText().content += text.replace(/\n/g, " ");
+    }
+    redraw();
+  }
+
+  function handleBackspace(): void {
+    const last = lastPart();
+    if (last.type === "text" && last.content.length > 0) {
+      // Delete last char from text
+      last.content = last.content.slice(0, -1);
+    } else if (
+      last.type === "text" &&
+      last.content === "" &&
+      parts.length > 1
+    ) {
+      // Empty trailing text — remove it, then remove the paste before it
+      parts.pop();
+      parts.pop();
+      // Ensure we always have at least one text part
+      if (parts.length === 0) parts.push({ type: "text", content: "" });
+      ensureTrailingText();
+    } else if (last.type === "paste") {
+      // Remove the paste block
+      parts.pop();
+      if (parts.length === 0) parts.push({ type: "text", content: "" });
+      ensureTrailingText();
+    }
+    redraw();
+  }
+
+  // ── Raw mode ──
+
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+  process.stdin.resume();
+  process.stdin.setEncoding("utf8");
+  process.stdout.write("\x1b[?2004h");
+
+  process.stdin.on("data", (chunk: string) => {
+    if (paused) return;
+
+    // ── Bracketed paste ──
+    if (chunk.includes(PASTE_START)) {
+      inPaste = true;
+      pasteAccum = chunk.split(PASTE_START).slice(1).join(PASTE_START);
+      if (pasteAccum.includes(PASTE_END)) {
+        inPaste = false;
+        handlePasteComplete(pasteAccum.split(PASTE_END)[0]!);
+        pasteAccum = "";
+      }
+      return;
+    }
+    if (inPaste) {
+      if (chunk.includes(PASTE_END)) {
+        pasteAccum += chunk.split(PASTE_END)[0]!;
+        inPaste = false;
+        handlePasteComplete(pasteAccum);
+        pasteAccum = "";
+      } else {
+        pasteAccum += chunk;
+      }
+      return;
+    }
+
+    // ── Normal input ──
+    for (let i = 0; i < chunk.length; i++) {
+      const ch = chunk[i]!;
+      const code = chunk.charCodeAt(i);
+
+      if (code === 0x03) {
+        // Ctrl+C
+        process.stdout.write("\n\x1b[?2004l");
+        if (process.stdin.isTTY) process.stdin.setRawMode(false);
+        process.exit(0);
+      }
+
+      if (code === 0x15) {
+        // Ctrl+U
+        clear();
+        redraw();
+        continue;
+      }
+
+      if (code === 0x0d || code === 0x0a) {
+        // Enter
+        if (getFullText()) {
+          submit();
+        } else {
+          process.stdout.write("\n");
+          redraw();
+        }
+        continue;
+      }
+
+      if (code === 0x7f || code === 0x08) {
+        // Backspace
+        handleBackspace();
+        continue;
+      }
+
+      if (code === 0x1b) {
+        if (i + 1 < chunk.length && chunk[i + 1] === "[") {
+          // ANSI escape sequence (arrows, etc.) — skip
+          i += 2;
+          while (i < chunk.length && chunk.charCodeAt(i) < 0x40) i++;
+        } else if (pendingResolve) {
+          // Bare Escape during waitForInput — cancel
+          const resolve = pendingResolve;
+          pendingResolve = null;
+          clear();
+          process.stdout.write("\n");
+          resolve("");
+        }
+        continue;
+      }
+
+      if (code === 0x09) {
+        // Tab
+        ensureTrailingText().content += "  ";
+        redraw();
+        continue;
+      }
+
+      if (code < 0x20) continue;
+
+      // Printable char
+      ensureTrailingText().content += ch;
+      redraw();
+    }
+  });
+
+  return {
+    onLine(callback) {
+      lineCallback = callback;
+    },
+    prompt() {
+      paused = false;
+      prevRows = 1; // fresh prompt = 1 row
+      redraw();
+    },
+    waitForInput(): Promise<string> {
+      return new Promise((resolve) => {
+        pendingResolve = resolve;
+        paused = false;
+        prevRows = 1;
+        redraw();
+      });
+    },
+    pause() {
+      paused = true;
+    },
+    resume() {
+      paused = false;
+    },
+    close() {
+      process.stdout.write("\x1b[?2004l");
+      if (process.stdin.isTTY) process.stdin.setRawMode(false);
+      process.stdin.pause();
+    },
+  };
+}

package/src/frontend/terminal/renderer.ts

@@ -0,0 +1,248 @@
+/**
+ * Terminal renderer — minimal, clean output.
+ *
+ * The renderer NEVER touches readline. It only writes to stdout.
+ * The caller (index.ts) is responsible for pausing/resuming readline.
+ * Spinner uses atomic \r overwrite — single write call, zero flicker.
+ */
+
+import pc from "picocolors";
+
+// ── Types ────────────────────────────────────────────────────────────────────
+
+export type StatusBarInfo = {
+  model: string;
+  sessionName?: string;
+  turns: number;
+  inputTokens: number;
+  outputTokens: number;
+  cacheHitPct: number;
+  costUsd: number;
+};
+
+export type Renderer = {
+  readonly cols: number;
+  writeln(text?: string): void;
+  writeSystem(text: string): void;
+  writeError(text: string): void;
+  renderAssistantMessage(text: string): void;
+  renderToolCall(toolName: string, input: Record<string, unknown>): void;
+  renderStatusLine(
+    durationMs: number,
+    tools: number,
+    info: StatusBarInfo,
+  ): void;
+  startSpinner(label?: string): void;
+  updateSpinnerLabel(label: string): void;
+  stopSpinner(): void;
+};
+
+// ── Constants ────────────────────────────────────────────────────────────────
+
+const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const HIDDEN_TOOLS = new Set(["TodoRead", "TodoWrite"]);
+
+// ── Helpers (exported for testing) ───────────────────────────────────────────
+
+export function wrap(text: string, indent: number, maxWidth: number): string {
+  const width = maxWidth - indent;
+  if (width <= 20) return text;
+  const pad = " ".repeat(indent);
+  return text
+    .split("\n")
+    .map((line) => {
+      if (line.length <= width) return pad + line;
+      const words = line.split(" ");
+      const wrapped: string[] = [];
+      let cur = "";
+      for (const w of words) {
+        if (cur.length + w.length + 1 > width && cur) {
+          wrapped.push(pad + cur);
+          cur = w;
+        } else {
+          cur = cur ? cur + " " + w : w;
+        }
+      }
+      if (cur) wrapped.push(pad + cur);
+      return wrapped.join("\n");
+    })
+    .join("\n");
+}
+
+export function formatTimeAgo(ts: number): string {
+  const sec = Math.floor((Date.now() - ts) / 1000);
+  if (sec < 60) return "just now";
+  const min = Math.floor(sec / 60);
+  if (min < 60) return `${min}m ago`;
+  const hr = Math.floor(min / 60);
+  if (hr < 24) return `${hr}h ago`;
+  return `${Math.floor(hr / 24)}d ago`;
+}
+
+function fmtTok(n: number): string {
+  if (n < 1000) return String(n);
+  if (n < 1_000_000) return `${(n / 1000).toFixed(1)}k`;
+  return `${(n / 1_000_000).toFixed(1)}M`;
+}
+
+export function extractToolDetail(
+  input: Record<string, unknown>,
+  maxLen: number,
+): string {
+  if (input.command) {
+    const s = String(input.description || input.command);
+    return s.length > maxLen ? s.slice(0, maxLen - 3) + "..." : s;
+  }
+  if (input.file_path) return String(input.file_path);
+  if (input.pattern && input.path) return `${input.pattern} in ${input.path}`;
+  if (input.pattern) return String(input.pattern);
+  if (input.action) return String(input.action);
+  if (input.query) return String(input.query).slice(0, maxLen);
+  if (input.url) return String(input.url).slice(0, maxLen);
+  if (input.type) return String(input.type);
+  if (input.name) return String(input.name);
+  if (input.model) return String(input.model);
+  if (input.package_url) return String(input.package_url);
+  if (input.build_number) return `#${input.build_number}`;
+  if (input.packages) return (input.packages as string[]).join(", ");
+  const parts: string[] = [];
+  for (const [k, v] of Object.entries(input)) {
+    if (k === "_chatId") continue;
+    if (typeof v === "string" && v.length > 0)
+      parts.push(`${k}=${v.length > 30 ? v.slice(0, 30) + "..." : v}`);
+    else if (typeof v === "number" || typeof v === "boolean")
+      parts.push(`${k}=${v}`);
+  }
+  return parts.join(", ").slice(0, maxLen);
+}
+
+export function cleanToolName(name: string): string {
+  if (name.startsWith("mcp__")) {
+    const parts = name.split("__");
+    return parts[parts.length - 1] || name;
+  }
+  return name;
+}
+
+// ── Factory ──────────────────────────────────────────────────────────────────
+
+export function createRenderer(cols?: number, displayName = "Talon"): Renderer {
+  const COLS = cols ?? Math.min(process.stdout.columns || 100, 120);
+  const botName = displayName;
+
+  let spinnerTimer: ReturnType<typeof setInterval> | null = null;
+  let spinnerFrame = 0;
+  let spinnerLabel = "thinking";
+  let spinnerLineLen = 0;
+  let hasToolOutput = false;
+
+  // ── Output primitives ──
+
+  function writeln(text = ""): void {
+    process.stdout.write(`\x1b[2K\r${text}\n`);
+  }
+
+  function writeSystem(text: string): void {
+    writeln(`  ${pc.dim(text)}`);
+  }
+
+  function writeError(text: string): void {
+    writeln();
+    writeln(`  ${pc.red("✖")} ${pc.red(text)}`);
+  }
+
+  // ── Messages ──
+
+  function renderAssistantMessage(text: string): void {
+    writeln();
+    writeln(`  ${pc.cyan("▍")} ${pc.bold(pc.cyan(botName))}`);
+    for (const line of wrap(text, 2, COLS).split("\n")) {
+      writeln(`  ${pc.cyan("▍")}${line}`);
+    }
+  }
+
+  function renderToolCall(
+    toolName: string,
+    input: Record<string, unknown>,
+  ): void {
+    const clean = cleanToolName(toolName);
+    if (HIDDEN_TOOLS.has(clean)) return;
+    if (!hasToolOutput) {
+      hasToolOutput = true;
+      writeln();
+    }
+    const display = clean.replace(/_/g, " ");
+    const maxD = COLS - display.length - 16;
+    const detail = extractToolDetail(input, maxD);
+    writeln(
+      `    ${pc.dim("→")} ${pc.yellow(display)}${detail ? `  ${pc.dim(detail)}` : ""}`,
+    );
+  }
+
+  function renderStatusLine(
+    ms: number,
+    tools: number,
+    info: StatusBarInfo,
+  ): void {
+    const p = [
+      `${(ms / 1000).toFixed(1)}s`,
+      info.model,
+    ];
+    if (info.sessionName) p.push(`"${info.sessionName}"`);
+    p.push(
+      `${info.turns} turn${info.turns !== 1 ? "s" : ""}`,
+      `${fmtTok(info.inputTokens + info.outputTokens)} tok`,
+      `${info.cacheHitPct}% cache`,
+    );
+    if (tools > 0) p.push(`${tools} tool${tools > 1 ? "s" : ""}`);
+    writeln();
+    writeln(`  ${pc.dim(p.join("  ·  "))}`);
+    hasToolOutput = false;
+  }
+
+  // ── Spinner ──
+  // Pure stdout. Never touches readline.
+
+  function startSpinner(label = "thinking"): void {
+    stopSpinner();
+    spinnerLabel = label;
+    spinnerFrame = 0;
+    spinnerLineLen = 0;
+    spinnerTimer = setInterval(() => {
+      spinnerFrame = (spinnerFrame + 1) % FRAMES.length;
+      const line = `    ${pc.dim(FRAMES[spinnerFrame]!)}  ${pc.dim(spinnerLabel)}`;
+      const pad =
+        spinnerLineLen > line.length
+          ? " ".repeat(spinnerLineLen - line.length)
+          : "";
+      spinnerLineLen = line.length;
+      process.stdout.write(`\r${line}${pad}`);
+    }, 80);
+  }
+
+  function updateSpinnerLabel(label: string): void {
+    spinnerLabel = label;
+  }
+
+  function stopSpinner(): void {
+    if (spinnerTimer) {
+      clearInterval(spinnerTimer);
+      spinnerTimer = null;
+      process.stdout.write("\x1b[2K\r");
+      spinnerLineLen = 0;
+    }
+  }
+
+  return {
+    cols: COLS,
+    writeln,
+    writeSystem,
+    writeError,
+    renderAssistantMessage,
+    renderToolCall,
+    renderStatusLine,
+    startSpinner,
+    updateSpinnerLabel,
+    stopSpinner,
+  };
+}

package/src/index.ts

@@ -0,0 +1,144 @@
+/**
+ * Talon — agentic AI harness.
+ * Composition root: loads config, creates frontend + backend, wires dispatcher.
+ *
+ * Frontends (Telegram, Terminal) and backends (Claude, OpenCode)
+ * are loaded dynamically — only the selected platform's dependencies are required.
+ */
+
+import { getFrontends } from "./util/config.js";
+import { startUploadCleanup, stopUploadCleanup } from "./util/workspace.js";
+import { flushSessions } from "./storage/sessions.js";
+import { flushChatSettings } from "./storage/chat-settings.js";
+import { flushCronJobs } from "./storage/cron-store.js";
+import { flushHistory } from "./storage/history.js";
+import { flushMediaIndex } from "./storage/media-index.js";
+import { getActiveCount } from "./core/dispatcher.js";
+import { startPulseTimer, stopPulseTimer } from "./core/pulse.js";
+import { startCronTimer, stopCronTimer } from "./core/cron.js";
+import { startWatchdog, stopWatchdog } from "./util/watchdog.js";
+import { log, logError, logWarn } from "./util/log.js";
+import { bootstrap, initBackendAndDispatcher } from "./bootstrap.js";
+import { Gateway } from "./core/gateway.js";
+import type { Frontend } from "./bootstrap.js";
+
+// ── Bootstrap ────────────────────────────────────────────────────────────────
+
+import { writeFileSync, unlinkSync } from "node:fs";
+import { files as pathFiles } from "./util/paths.js";
+
+const { config } = await bootstrap();
+
+// Write PID file for daemon management
+try { writeFileSync(pathFiles.pid, String(process.pid)); } catch { /* ok */ }
+
+// ── Create gateway + frontend ─────────────────────────────────────────────────
+
+const gateway = new Gateway();
+
+const selectedFrontend = getFrontends(config)[0]; // use first configured frontend
+let frontend: Frontend;
+
+if (selectedFrontend === "terminal") {
+  const { createTerminalFrontend } = await import("./frontend/terminal/index.js");
+  frontend = createTerminalFrontend(config, gateway);
+  log("bot", "Frontend: Terminal");
+} else if (selectedFrontend === "teams") {
+  const { createTeamsFrontend } = await import("./frontend/teams/index.js");
+  frontend = createTeamsFrontend(config, gateway);
+  log("bot", "Frontend: Teams");
+} else {
+  const { createTelegramFrontend } = await import("./frontend/telegram/index.js");
+  frontend = createTelegramFrontend(config, gateway);
+  log("bot", "Frontend: Telegram");
+}
+
+// ── Create backend + wire dispatcher ─────────────────────────────────────────
+
+await initBackendAndDispatcher(config, frontend);
+
+// ── Graceful shutdown ────────────────────────────────────────────────────────
+
+let shuttingDown = false;
+
+const SHUTDOWN_TIMEOUT_MS = 15_000;
+
+async function gracefulShutdown(signal: string): Promise<void> {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  log("shutdown", `${signal} received, shutting down gracefully...`);
+
+  const forceTimer = setTimeout(() => {
+    logError("shutdown", "Timeout exceeded, forcing exit");
+    process.exit(1);
+  }, SHUTDOWN_TIMEOUT_MS);
+  forceTimer.unref();
+
+  const pending = getActiveCount();
+  if (pending > 0) {
+    log("shutdown", `Waiting for ${pending} in-flight queries to drain...`);
+    await new Promise((r) => setTimeout(r, 5000));
+  }
+
+  await frontend.stop();
+  if (config.backend === "opencode") {
+    const { stopOpenCodeServer } = await import("./backend/opencode/index.js");
+    stopOpenCodeServer();
+  }
+  // Destroy plugins (cleanup resources)
+  if (config.plugins.length > 0) {
+    const { destroyPlugins } = await import("./core/plugin.js");
+    await destroyPlugins();
+  }
+  stopPulseTimer();
+  stopCronTimer();
+  stopWatchdog();
+  stopUploadCleanup();
+  flushSessions();
+  flushChatSettings();
+  flushCronJobs();
+  flushHistory();
+  flushMediaIndex();
+  try { unlinkSync(pathFiles.pid); } catch { /* ok */ }
+  log("shutdown", "State saved");
+  process.exit(0);
+}
+
+process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
+process.on("SIGINT", () => gracefulShutdown("SIGINT"));
+
+process.on("uncaughtException", (err) => {
+  logError("bot", "Uncaught exception", err);
+  flushSessions();
+  flushChatSettings();
+  flushCronJobs();
+  flushHistory();
+  flushMediaIndex();
+  process.exit(1);
+});
+
+process.on("unhandledRejection", (reason) => {
+  logWarn(
+    "bot",
+    `Unhandled rejection: ${reason instanceof Error ? reason.message : reason}`,
+  );
+});
+
+// ── Start ────────────────────────────────────────────────────────────────────
+
+async function main(): Promise<void> {
+  await frontend.init();
+  log("bot", "Starting Talon...");
+
+  if (config.pulse) startPulseTimer(config.pulseIntervalMs);
+  startCronTimer();
+  startWatchdog(config.workspace);
+  startUploadCleanup(config.workspace);
+
+  await frontend.start();
+}
+
+main().catch((err) => {
+  logError("bot", "Fatal startup error", err);
+  process.exit(1);
+});