talon-agent 4.3.1 → 4.3.3

package/src/frontend/terminal/input.ts

@@ -4,9 +4,18 @@
  * 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. Up/Down walk prompt history.
+ *
+ * State lives in `input/state.ts`; paste, keys and drawing are each their own
+ * module under `input/`. This file is the wiring.
  */
 
-import pc from "picocolors";
+import { createInputState } from "./input/state.js";
+import { consumePasteChunk } from "./input/paste.js";
+import { handleKeyChunk } from "./input/keys.js";
+import { redraw } from "./input/render.js";
+
+export type { InputPart } from "./input/parts.js";
+export { PromptHistory } from "./input/history.js";
 
 // ── Types ────────────────────────────────────────────────────────────────────
 
@@ -19,232 +28,10 @@ export type InputHandler = {
   resume(): void;
 };
 
-export type InputPart =
-  { type: "text"; content: string } | { type: "paste"; content: string };
-type TextPart = Extract<InputPart, { type: "text" }>;
-type PastePart = Extract<InputPart, { type: "paste" }>;
-
-// ── Constants ────────────────────────────────────────────────────────────────
-
-const PASTE_COLLAPSE_LINES = 3;
-const PASTE_COLLAPSE_CHARS = 150;
-const PASTE_START = "\x1b[200~";
-const PASTE_END = "\x1b[201~";
-const MAX_HISTORY_ITEMS = 100;
-
-function cloneParts(parts: readonly InputPart[]): InputPart[] {
-  return parts.map((part) => ({ ...part }));
-}
-
-function partsText(parts: readonly InputPart[]): string {
-  return parts
-    .map((part) => part.content)
-    .join("\n")
-    .trim();
-}
-
-/**
- * In-process prompt history. Keeping this out of the persistent stores avoids
- * creating a second plaintext transcript while still giving terminal users
- * the expected Up/Down workflow.
- */
-export class PromptHistory {
-  private readonly entries: InputPart[][] = [];
-  private cursor = 0;
-  private draft: InputPart[] | null = null;
-
-  constructor(private readonly maxItems = MAX_HISTORY_ITEMS) {}
-
-  add(parts: readonly InputPart[]): void {
-    const text = partsText(parts);
-    if (!text) return;
-
-    const latest = this.entries.at(-1);
-    if (!latest || partsText(latest) !== text) {
-      this.entries.push(cloneParts(parts));
-      if (this.entries.length > this.maxItems) this.entries.shift();
-    }
-    this.resetNavigation();
-  }
-
-  move(
-    direction: "previous" | "next",
-    current: readonly InputPart[],
-  ): InputPart[] | undefined {
-    if (this.entries.length === 0) return undefined;
-
-    if (direction === "previous") {
-      if (this.cursor === this.entries.length) {
-        this.draft = cloneParts(current);
-      }
-      if (this.cursor > 0) this.cursor--;
-      return cloneParts(this.entries[this.cursor]!);
-    }
-
-    if (this.cursor === this.entries.length) return undefined;
-    if (this.cursor < this.entries.length - 1) {
-      this.cursor++;
-      return cloneParts(this.entries[this.cursor]!);
-    }
-
-    this.cursor = this.entries.length;
-    return cloneParts(this.draft ?? [{ type: "text", content: "" }]);
-  }
-
-  /** Preserve an edited recalled prompt as the current draft. */
-  detach(parts: readonly InputPart[]): void {
-    if (this.cursor === this.entries.length) return;
-    this.cursor = this.entries.length;
-    this.draft = cloneParts(parts);
-  }
-
-  resetNavigation(): void {
-    this.cursor = this.entries.length;
-    this.draft = null;
-  }
-}
-
 // ── 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: InputPart[] = [{ type: "text", content: "" }];
-  const history = new PromptHistory();
-
-  // Bracketed paste accumulation
-  let inPaste = false;
-  let pasteAccum = "";
-
-  // ── Helpers ──
-
-  function lastPart(): InputPart {
-    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 partsText(parts);
-  }
-
-  function clear(): void {
-    parts = [{ type: "text", content: "" }];
-    history.resetNavigation();
-  }
-
-  function submit(): void {
-    const text = getFullText();
-    if (!pendingResolve) history.add(parts);
-    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, " ");
-    }
-    history.detach(parts);
-    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();
-    }
-    history.detach(parts);
-    redraw();
-  }
-
-  function navigateHistory(direction: "previous" | "next"): void {
-    const recalled = history.move(direction, parts);
-    if (!recalled) return;
-    parts = recalled;
-    redraw();
-  }
+  const state = createInputState(promptStr);
 
   // ── Raw mode ──
 
@@ -256,140 +43,38 @@ export function createInput(promptStr: string): InputHandler {
   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] === "[") {
-          // CSI escape sequence. Up/Down navigate history; the rest are
-          // ignored until cursor editing is implemented.
-          let end = i + 2;
-          while (end < chunk.length && chunk.charCodeAt(end) < 0x40) end++;
-          const final = chunk[end];
-          if (final === "A") navigateHistory("previous");
-          if (final === "B") navigateHistory("next");
-          i = end;
-        } else if (
-          i + 2 < chunk.length &&
-          chunk[i + 1] === "O" &&
-          (chunk[i + 2] === "A" || chunk[i + 2] === "B")
-        ) {
-          // Some terminals use application-cursor sequences (ESC O A/B).
-          navigateHistory(chunk[i + 2] === "A" ? "previous" : "next");
-          i += 2;
-        } 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 += "  ";
-        history.detach(parts);
-        redraw();
-        continue;
-      }
-
-      if (code < 0x20) continue;
-
-      // Printable char
-      ensureTrailingText().content += ch;
-      history.detach(parts);
-      redraw();
-    }
+    if (state.paused) return;
+    if (consumePasteChunk(state, chunk)) return;
+    handleKeyChunk(state, chunk);
   });
 
   return {
     onLine(callback) {
-      lineCallback = callback;
+      state.lineCallback = callback;
     },
     prompt() {
-      paused = false;
-      prevRows = 1; // fresh prompt = 1 row
-      redraw();
+      state.paused = false;
+      state.prevRows = 1; // fresh prompt = 1 row
+      redraw(state);
     },
     waitForInput(): Promise<string> {
       return new Promise((resolve) => {
-        pendingResolve = resolve;
-        paused = false;
-        prevRows = 1;
-        redraw();
+        state.pendingResolve = resolve;
+        state.paused = false;
+        state.prevRows = 1;
+        redraw(state);
       });
     },
     pause() {
-      paused = true;
+      state.paused = true;
     },
     resume() {
-      paused = false;
+      state.paused = false;
     },
     close() {
-      if (pendingResolve) {
-        const resolve = pendingResolve;
-        pendingResolve = null;
+      if (state.pendingResolve) {
+        const resolve = state.pendingResolve;
+        state.pendingResolve = null;
         resolve("");
       }
       process.stdout.write("\x1b[?2004l");

package/src/frontend/whatsapp/actions/account.ts

@@ -16,12 +16,9 @@
 
 import { jidNormalizedUser, type WASocket } from "baileys";
 import type { ActionResult } from "../../../core/types.js";
-import {
-  readStatusText,
-  resolveMediaUpload,
-  toUserJid,
-  tryAction,
-} from "./shared.js";
+import { tryAction } from "./try-action.js";
+import { resolveMediaUpload } from "./media-upload.js";
+import { readStatusText, toUserJid } from "./coerce.js";
 import type { WhatsAppActionContext, WhatsAppActionHandlers } from "./types.js";
 
 /** The account's own JID, device suffix stripped. */

package/src/frontend/whatsapp/actions/chat-info.ts

@@ -7,7 +7,8 @@
  * retrieval (get_message_by_id, download_media) lives in history.ts.
  */
 
-import { readStatusText, toUserJid, tryAction } from "./shared.js";
+import { tryAction } from "./try-action.js";
+import { readStatusText, toUserJid } from "./coerce.js";
 import type { WhatsAppActionHandlers } from "./types.js";
 
 /** Render one participant the way the other frontends render members. */

package/src/frontend/whatsapp/actions/coerce.ts

@@ -0,0 +1,30 @@
+/**
+ * Shape coercion for the member-facing WhatsApp actions: model-supplied user
+ * references → JIDs, and Baileys' several `fetchStatus` result shapes → text.
+ */
+
+/**
+ * Coerce a user reference the model supplied — bare number, JID, or the
+ * numeric id from a member listing — into a WhatsApp user JID.
+ */
+export function toUserJid(value: unknown): string | null {
+  const raw = String(value ?? "").trim();
+  if (!raw) return null;
+  if (raw.includes("@")) return raw;
+  const digits = raw.replace(/[^0-9]/g, "");
+  return digits ? `${digits}@s.whatsapp.net` : null;
+}
+
+/**
+ * Pull the about text out of a `fetchStatus` result. Baileys has
+ * returned both a bare object and a one-element array across versions,
+ * and the payload itself nests `status` either as a string or as
+ * `{ status }` — accept all four shapes rather than guess one.
+ */
+export function readStatusText(result: unknown): string | undefined {
+  const entry = (Array.isArray(result) ? result[0] : result) as
+    { status?: string | { status?: string } } | undefined;
+  return typeof entry?.status === "string"
+    ? entry.status
+    : entry?.status?.status;
+}

package/src/frontend/whatsapp/actions/history.ts

@@ -19,7 +19,7 @@ import {
 } from "../../../storage/history.js";
 import { saveInboundMedia } from "../media-store.js";
 import { lookupMessage, resolveKey } from "../message-store.js";
-import { tryAction } from "./shared.js";
+import { tryAction } from "./try-action.js";
 import type { WhatsAppActionHandlers } from "./types.js";
 
 function toMsgId(raw: unknown): number {

package/src/frontend/whatsapp/actions/media-upload.ts

@@ -0,0 +1,82 @@
+/**
+ * Media-source resolution for the WhatsApp send actions: workspace path or
+ * public URL → something Baileys can upload, plus the mimetype guess the
+ * document/audio paths need.
+ */
+
+import { existsSync, statSync } from "node:fs";
+import { basename, extname } from "node:path";
+import { expandFsPath } from "../../../util/fs-path.js";
+
+/** WhatsApp's own ceiling for a media upload. */
+const MAX_MEDIA_BYTES = 64 * 1024 * 1024;
+
+/** Baileys accepts a Buffer, a stream, or `{ url }` for local paths and HTTP. */
+export type MediaUpload = { url: string };
+
+/**
+ * Resolve one media input to something Baileys can upload. Two sources:
+ * a public URL (WhatsApp's uploader fetches it) or a workspace file path
+ * (streamed from disk). `file_id` is a Telegram concept with no WhatsApp
+ * equivalent — say so instead of failing obscurely.
+ */
+export function resolveMediaUpload(
+  src: { file_path?: unknown; url?: unknown; file_id?: unknown },
+  label: string,
+): { media: MediaUpload; fileName: string } | { error: string } {
+  if (src.url) {
+    const url = String(src.url);
+    return {
+      media: { url },
+      fileName: basename(new URL(url).pathname) || "file",
+    };
+  }
+  if (src.file_id) {
+    return {
+      error:
+        `${label}: WhatsApp has no file_id — re-send by url (public) or ` +
+        `file_path (workspace file)`,
+    };
+  }
+  if (!src.file_path) {
+    return {
+      error: `${label}: provide file_path (workspace file) or url (public)`,
+    };
+  }
+  const filePath = expandFsPath(String(src.file_path));
+  if (!existsSync(filePath)) {
+    return {
+      error: `File not found: ${filePath} — check the workspace path, or send by url instead`,
+    };
+  }
+  if (statSync(filePath).size > MAX_MEDIA_BYTES) {
+    return { error: `${label}: file exceeds WhatsApp's 64MB limit` };
+  }
+  return { media: { url: filePath }, fileName: basename(filePath) };
+}
+
+/** Extension → mimetype for the document/audio paths that require one. */
+const MIME_BY_EXT: Record<string, string> = {
+  ".pdf": "application/pdf",
+  ".txt": "text/plain",
+  ".md": "text/markdown",
+  ".json": "application/json",
+  ".csv": "text/csv",
+  ".zip": "application/zip",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".mp4": "video/mp4",
+  ".mov": "video/quicktime",
+  ".mp3": "audio/mpeg",
+  ".m4a": "audio/mp4",
+  ".ogg": "audio/ogg",
+  ".opus": "audio/ogg; codecs=opus",
+  ".wav": "audio/wav",
+};
+
+export function guessMimetype(fileName: string, fallback: string): string {
+  return MIME_BY_EXT[extname(fileName).toLowerCase()] ?? fallback;
+}

package/src/frontend/whatsapp/actions/media.ts

@@ -10,14 +10,9 @@
 
 import type { AnyMessageContent } from "baileys";
 import { toWhatsAppText } from "../formatting.js";
-import {
-  guessMimetype,
-  resolveMediaUpload,
-  resolveQuoted,
-  sendContent,
-  sendText,
-  tryAction,
-} from "./shared.js";
+import { tryAction } from "./try-action.js";
+import { guessMimetype, resolveMediaUpload } from "./media-upload.js";
+import { resolveQuoted, sendContent, sendText } from "./send.js";
 import type { WhatsAppActionHandlers } from "./types.js";
 
 /** Optional caption, translated to WhatsApp's dialect. */

package/src/frontend/whatsapp/actions/messaging.ts

@@ -13,13 +13,8 @@ import { log } from "../../../util/log.js";
 import { toWhatsAppText } from "../formatting.js";
 import { lookupMessage, resolveKey } from "../message-store.js";
 import { recordPin, listPins, forgetPin } from "../pins.js";
-import {
-  resolveQuoted,
-  sendContent,
-  sendText,
-  tryAction,
-  boundedSend,
-} from "./shared.js";
+import { tryAction } from "./try-action.js";
+import { resolveQuoted, sendContent, sendText, boundedSend } from "./send.js";
 import type { WhatsAppActionHandlers } from "./types.js";
 
 /** WhatsApp keeps a pin for 24h, 7d, or 30d — no indefinite option. */

package/src/frontend/whatsapp/actions/moderation.ts

@@ -9,7 +9,8 @@
  * rather than retrying something the platform cannot do.
  */
 
-import { toUserJid, tryAction } from "./shared.js";
+import { tryAction } from "./try-action.js";
+import { toUserJid } from "./coerce.js";
 import type { WhatsAppActionHandlers } from "./types.js";
 
 /** Ops that act on one member. */