pi-ultracode 0.1.0 → 0.1.2

package/src/workflow/agent-types.ts

@@ -14,7 +14,7 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import type { ThinkingLevel } from "./agent-runner.ts";
+import { isThinkingLevel, type ThinkingLevel } from "../thinking.ts";
 
 export interface AgentTypeDef {
   name: string;
@@ -76,8 +76,6 @@ const BUILTIN_AGENT_TYPES: AgentTypeDef[] = [
   },
 ];
 
-const VALID_THINKING = new Set(["off", "minimal", "low", "medium", "high", "xhigh"]);
-
 export function discoverAgentTypes(cwd: string): Map<string, AgentTypeDef> {
   const map = new Map<string, AgentTypeDef>();
   for (const def of BUILTIN_AGENT_TYPES) map.set(def.name, def);
@@ -138,9 +136,8 @@ export function parseAgentTypeFile(
         .map((t) => t.trim())
         .filter(Boolean)
     : undefined;
-  const thinking = frontmatter.thinking && VALID_THINKING.has(frontmatter.thinking.trim())
-    ? (frontmatter.thinking.trim() as ThinkingLevel)
-    : undefined;
+  const rawThinking = frontmatter.thinking?.trim();
+  const thinking = rawThinking && isThinkingLevel(rawThinking) ? rawThinking : undefined;
   const systemPromptMode = frontmatter.systemPromptMode === "replace" ? "replace" : "append";
   const systemPrompt = (frontmatter.systemPrompt ?? body ?? "").trim();
   return {

package/src/workflow/display-text.ts

@@ -0,0 +1,461 @@
+/** Terminal-safe, bounded text helpers for workflow progress UI. */
+
+const ESC = 0x1b;
+const BEL = 0x07;
+
+/** Hard ceiling before any terminal scanning or redaction work. */
+export const DISPLAY_INPUT_LIMIT = 16_384;
+export const DISPLAY_OMITTED_TEXT = "[output omitted]";
+
+function isInvisibleFormat(code: number): boolean {
+  return code === 0x00ad
+    || code === 0x034f
+    || (code >= 0x0600 && code <= 0x0605)
+    || code === 0x061c
+    || code === 0x06dd
+    || code === 0x070f
+    || (code >= 0x0890 && code <= 0x0891)
+    || code === 0x08e2
+    || (code >= 0x17b4 && code <= 0x17b5)
+    || (code >= 0x180b && code <= 0x180f)
+    || (code >= 0x200b && code <= 0x200f)
+    || (code >= 0x202a && code <= 0x202e)
+    || (code >= 0x2060 && code <= 0x206f)
+    || (code >= 0xfe00 && code <= 0xfe0f)
+    || code === 0xfeff
+    || (code >= 0xfff9 && code <= 0xfffb)
+    || code === 0x110bd
+    || code === 0x110cd
+    || (code >= 0x13430 && code <= 0x1345f)
+    || (code >= 0x1bca0 && code <= 0x1bca3)
+    || (code >= 0x1d173 && code <= 0x1d17a)
+    || code === 0xe0001
+    || (code >= 0xe0020 && code <= 0xe007f)
+    || (code >= 0xe0100 && code <= 0xe01ef);
+}
+
+const SAFE_SUBCOMMANDS = new Map<string, ReadonlySet<string>>([
+  ["npm", new Set(["test", "install", "ci", "run", "exec"])],
+  ["pnpm", new Set(["test", "install", "run", "exec"])],
+  ["yarn", new Set(["test", "install", "run"])],
+  ["bun", new Set(["test", "install", "run"])],
+  ["git", new Set(["status", "diff", "log", "show", "branch", "grep"])],
+  ["cargo", new Set(["test", "check", "build", "clippy"])],
+  ["go", new Set(["test", "build", "vet"])],
+]);
+const SAFE_EXECUTABLES = new Set([
+  ...SAFE_SUBCOMMANDS.keys(),
+  "sleep", "curl", "wget", "node", "python", "python3", "pytest", "tsc", "make", "cmake",
+  "rg", "grep", "find", "ls", "pwd",
+]);
+
+/**
+ * Remove terminal and invisible formatting controls in one pass while preserving
+ * ordinary newlines/tabs. Work is capped before scanning. Unterminated OSC/DCS
+ * strings consume the bounded remainder, avoiding injection and backtracking.
+ */
+export function stripTerminalControls(value: string, inputLimit = DISPLAY_INPUT_LIMIT): string {
+  const limit = Math.max(0, Math.floor(inputLimit));
+  const truncated = value.length > limit;
+  const source = truncated ? value.slice(0, limit) : value;
+  const output: string[] = [];
+  let index = 0;
+  while (index < source.length) {
+    const code = source.charCodeAt(index);
+    if (code === ESC) {
+      index++;
+      if (index >= source.length) break;
+      const kind = source.charCodeAt(index);
+      if (kind === 0x5d) {
+        // OSC: ESC ] ... BEL or ST (ESC \).
+        index++;
+        while (index < source.length) {
+          const current = source.charCodeAt(index);
+          if (current === BEL) {
+            index++;
+            break;
+          }
+          if (current === ESC && source.charCodeAt(index + 1) === 0x5c) {
+            index += 2;
+            break;
+          }
+          index++;
+        }
+        continue;
+      }
+      if (kind === 0x50 || kind === 0x5e || kind === 0x5f || kind === 0x58) {
+        // DCS/SOS/PM/APC: ESC P/^/_/X ... ST (ESC \).
+        index++;
+        while (index < source.length) {
+          if (source.charCodeAt(index) === ESC && source.charCodeAt(index + 1) === 0x5c) {
+            index += 2;
+            break;
+          }
+          index++;
+        }
+        continue;
+      }
+      if (kind === 0x5b) {
+        // CSI: ESC [ parameters/intermediates final-byte.
+        index++;
+        while (index < source.length) {
+          const current = source.charCodeAt(index++);
+          if (current >= 0x40 && current <= 0x7e) break;
+        }
+        continue;
+      }
+      // Generic two-byte ESC sequence, with optional intermediates.
+      while (index < source.length) {
+        const current = source.charCodeAt(index);
+        if (current >= 0x20 && current <= 0x2f) {
+          index++;
+          continue;
+        }
+        if (current >= 0x30 && current <= 0x7e) index++;
+        break;
+      }
+      continue;
+    }
+
+    const codePoint = source.codePointAt(index) ?? code;
+    const width = codePoint > 0xffff ? 2 : 1;
+    const c0 = codePoint <= 0x1f && codePoint !== 0x09 && codePoint !== 0x0a && codePoint !== 0x0d;
+    const c1 = codePoint >= 0x7f && codePoint <= 0x9f;
+    if (!c0 && !c1 && !isInvisibleFormat(codePoint)) {
+      output.push(source.slice(index, index + width));
+    }
+    index += width;
+  }
+  if (truncated) output.push("…");
+  return output.join("");
+}
+
+export function displayOneLine(value: string): string {
+  return stripTerminalControls(value).replace(/\s+/g, " ").trim();
+}
+
+export function truncateDisplay(value: string, max: number): string {
+  const text = displayOneLine(value);
+  if (text.length <= max) return text;
+  if (max <= 1) return "…".slice(0, Math.max(0, max));
+  return `${text.slice(0, max - 1)}…`;
+}
+
+/** Keep the newest end only when the complete input fits the safety window. */
+export function truncateDisplayTail(value: string, max: number): string {
+  if (value.length > DISPLAY_INPUT_LIMIT) return fitMarker(DISPLAY_OMITTED_TEXT, max);
+  const text = displayOneLine(value);
+  if (text.length <= max) return text;
+  if (max <= 1) return "…".slice(0, Math.max(0, max));
+  return `…${text.slice(-(max - 1))}`;
+}
+
+/** Best-effort redaction for provider errors and other bounded status text. */
+export function redactCommand(value: string): string {
+  const text = displayOneLine(value);
+  if (value.length > DISPLAY_INPUT_LIMIT && hasPendingCredentialContextPrepared(text)) {
+    return DISPLAY_OMITTED_TEXT;
+  }
+  return redactPrepared(text);
+}
+
+/** Terminal-safe, redacted, and bounded status text. */
+export function safeDisplayText(value: string, max: number): string {
+  return truncatePrepared(redactCommand(value), max, false);
+}
+
+/** Keep the newest terminal-safe text, or omit it when prior context was dropped. */
+export function safeDisplayTail(value: string, max: number): string {
+  if (value.length > DISPLAY_INPUT_LIMIT) return fitMarker(DISPLAY_OMITTED_TEXT, max);
+  return truncatePrepared(redactCommand(value), max, true);
+}
+
+/**
+ * Preserve newlines and indentation while applying the same terminal-control
+ * stripping and credential redaction used by compact status text. The caller
+ * owns the explicit input bound; transcript buffers use this only after their
+ * own per-task/run limits have been enforced.
+ */
+export function safeTranscriptText(value: string, maxInput = 1024 * 1024): string {
+  return redactPrepared(stripTerminalControls(value, maxInput));
+}
+
+/**
+ * Whether a bounded stream fragment ends inside a credential-shaped construct
+ * whose safe rendering depends on a later delimiter.
+ */
+export function hasPendingCredentialContext(value: string): boolean {
+  if (value.length > DISPLAY_INPUT_LIMIT) return true;
+  if (hasPendingTerminalSequence(value)) return true;
+  return hasPendingCredentialContextPrepared(stripTerminalControls(value));
+}
+
+function redactPrepared(value: string): string {
+  const text = redactSensitiveHeaders(value);
+  return text
+    .replace(
+      /(\b[A-Z0-9_]*(?:API[_-]?KEY|TOKEN|SECRET|PASSWORD|PASSWD)[A-Z0-9_]*=)(?:"(?:\\.|[^"\\])*(?:"|$)|'(?:\\.|[^'\\])*(?:'|$)|[^\s]+)/gi,
+      "$1***",
+    )
+    .replace(
+      /(\B--?(?:api[-_]?key|token|access[-_]?token|refresh[-_]?token|id[-_]?token|password|passwd|secret|client-secret|user)(?:=|\s+))(?:"(?:\\.|[^"\\])*(?:"|$)|'(?:\\.|[^'\\])*(?:'|$)|[^\s]+)/gi,
+      "$1***",
+    )
+    .replace(/(\s-u)(?:\s+)?(?:"(?:\\.|[^"\\])*(?:"|$)|'(?:\\.|[^'\\])*(?:'|$)|[^\s]+)/gi, "$1***")
+    .replace(/(^|[^A-Za-z0-9+.-])([A-Za-z][A-Za-z0-9+.-]*:\/\/)[^/@\s]+@/g, "$1$2***@")
+    .replace(/(^|[^A-Za-z0-9+.-])([A-Za-z][A-Za-z0-9+.-]*:\/\/)[^/@\s]+:[^/@\s]*(?=$|[/?#\s])/g, "$1$2***")
+    .replace(/([?&](?:api[_-]?key|token|access[_-]?token|refresh[_-]?token|id[_-]?token|password|secret|client_secret)=)[^&\s'" ]+/gi, "$1***")
+    .replace(/\b(?:sk|ghp|github_pat|xox[baprs])[-_][A-Za-z0-9_-]{6,}\b/g, "***");
+}
+
+function truncatePrepared(value: string, max: number, tail: boolean): string {
+  if (value.length <= max) return value;
+  if (max <= 1) return "…".slice(0, Math.max(0, max));
+  return tail ? `…${value.slice(-(max - 1))}` : `${value.slice(0, max - 1)}…`;
+}
+
+/**
+ * Commands can carry secrets in arbitrary shell syntax, so status uses a
+ * whitelist synopsis instead of trying to display every argument safely.
+ */
+export function safeCommandPreview(value: string): string {
+  const command = displayOneLine(value);
+  if (!command) return "command";
+  const tokens = command.match(/"[^"]*"|'[^']*'|[^\s]+/g) ?? [];
+  const index = 0;
+  if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(tokens[0] ?? "")) return "environment-prefixed command";
+  const rawExecutable = tokens[index] ?? "command";
+  const basename = rawExecutable.replace(/^['"]|['"]$/g, "").split("/").pop() || "command";
+  const candidate = /^[A-Za-z0-9_.+-]+$/.test(basename) ? basename.toLowerCase() : "";
+  if (!SAFE_EXECUTABLES.has(candidate)) return "command";
+  const executable = truncateDisplay(basename, 32);
+  const next = (tokens[index + 1] ?? "").replace(/^['"]|['"]$/g, "");
+
+  const allowed = SAFE_SUBCOMMANDS.get(candidate);
+  if (allowed?.has(next.toLowerCase())) return `${executable} ${truncateDisplay(next, 24)}`;
+  if (executable.toLowerCase() === "sleep" && /^\d+(?:\.\d+)?[smhd]?$/.test(next)) {
+    return `${executable} ${next}`;
+  }
+  return tokens.length > index + 1 ? `${executable} …` : executable;
+}
+
+const SENSITIVE_HEADER_NAME = "(?:proxy-authorization|authorization|x-auth-token|x-api-key|api-key|api_key|client-secret|client_secret|access-token|access_token|refresh-token|refresh_token|id-token|id_token|set-cookie|cookie|token|password|passwd|secret)";
+const SENSITIVE_HEADER = new RegExp(
+  `(^|[^A-Za-z0-9_-]|(?:^|\\s)-H\\s*["']?)((?:["']?${SENSITIVE_HEADER_NAME}["']?)\\s*:\\s*)`,
+  "gi",
+);
+const PENDING_URI_USERINFO = /(?:^|[^A-Za-z0-9+.-])[A-Za-z][A-Za-z0-9+.-]*:\/\/[^/\s@]*$/;
+
+function hasPendingTerminalSequence(value: string): boolean {
+  let index = 0;
+  while (index < value.length) {
+    if (value.charCodeAt(index) !== ESC) {
+      index++;
+      continue;
+    }
+    index++;
+    if (index >= value.length) return true;
+    const kind = value.charCodeAt(index++);
+    if (kind === 0x5d) {
+      let terminated = false;
+      while (index < value.length) {
+        const current = value.charCodeAt(index);
+        if (current === BEL) {
+          index++;
+          terminated = true;
+          break;
+        }
+        if (current === ESC && value.charCodeAt(index + 1) === 0x5c) {
+          index += 2;
+          terminated = true;
+          break;
+        }
+        index++;
+      }
+      if (!terminated) return true;
+      continue;
+    }
+    if (kind === 0x50 || kind === 0x5e || kind === 0x5f || kind === 0x58) {
+      let terminated = false;
+      while (index < value.length) {
+        if (value.charCodeAt(index) === ESC && value.charCodeAt(index + 1) === 0x5c) {
+          index += 2;
+          terminated = true;
+          break;
+        }
+        index++;
+      }
+      if (!terminated) return true;
+      continue;
+    }
+    if (kind === 0x5b) {
+      let terminated = false;
+      while (index < value.length) {
+        const current = value.charCodeAt(index++);
+        if (current >= 0x40 && current <= 0x7e) {
+          terminated = true;
+          break;
+        }
+      }
+      if (!terminated) return true;
+      continue;
+    }
+    while (index < value.length && value.charCodeAt(index) >= 0x20 && value.charCodeAt(index) <= 0x2f) {
+      index++;
+    }
+    if (index >= value.length) return true;
+    const final = value.charCodeAt(index);
+    if (final >= 0x30 && final <= 0x7e) index++;
+  }
+  return false;
+}
+
+function hasPendingCredentialContextPrepared(value: string): boolean {
+  if (PENDING_URI_USERINFO.test(value)) return true;
+  SENSITIVE_HEADER.lastIndex = 0;
+  for (let match = SENSITIVE_HEADER.exec(value); match; match = SENSITIVE_HEADER.exec(value)) {
+    const start = SENSITIVE_HEADER.lastIndex;
+    if (!sensitiveValueIsComplete(value, start, /authorization|cookie/i.test(match[2]))) {
+      SENSITIVE_HEADER.lastIndex = 0;
+      return true;
+    }
+  }
+  SENSITIVE_HEADER.lastIndex = 0;
+  return false;
+}
+
+function sensitiveValueIsComplete(value: string, start: number, authorizationHeader: boolean): boolean {
+  if (start >= value.length) return false;
+  if (value.startsWith("***", start)) return true;
+  const opener = value[start];
+  if (opener === '"' || opener === "'") return quotedValueIsComplete(value, start, opener);
+  if (opener === "[" || opener === "{") return structuredValueIsComplete(value, start, opener);
+  const delimiters = authorizationHeader ? /[\r\n}\]]/ : /[,}\]\r\n]/;
+  return delimiters.test(value.slice(start));
+}
+
+function quotedValueIsComplete(value: string, start: number, quote: string): boolean {
+  for (let index = start + 1; index < value.length; index++) {
+    if (value[index] === "\\") {
+      index++;
+      continue;
+    }
+    if (value[index] === quote) return true;
+  }
+  return false;
+}
+
+function structuredValueIsComplete(value: string, start: number, opener: string): boolean {
+  const stack = [opener];
+  let quote: string | undefined;
+  for (let index = start + 1; index < value.length; index++) {
+    const character = value[index];
+    if (quote) {
+      if (character === "\\") {
+        index++;
+      } else if (character === quote) {
+        quote = undefined;
+      }
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+    } else if (character === "[" || character === "{") {
+      stack.push(character);
+    } else if (character === "]" || character === "}") {
+      const expected = character === "]" ? "[" : "{";
+      if (stack.pop() !== expected) return false;
+      if (stack.length === 0) return true;
+    }
+  }
+  return false;
+}
+
+function redactSensitiveHeaders(value: string): string {
+  let cursor = 0;
+  let output = "";
+  SENSITIVE_HEADER.lastIndex = 0;
+  for (let match = SENSITIVE_HEADER.exec(value); match; match = SENSITIVE_HEADER.exec(value)) {
+    const valueStart = SENSITIVE_HEADER.lastIndex;
+    const consumeUnquotedRemainder = /authorization|cookie/i.test(match[2]);
+    const valueEnd = consumeSensitiveValue(value, valueStart, consumeUnquotedRemainder);
+    output += value.slice(cursor, valueStart);
+    output += "***";
+    cursor = valueEnd;
+    SENSITIVE_HEADER.lastIndex = valueEnd;
+  }
+  return output + value.slice(cursor);
+}
+
+function consumeSensitiveValue(value: string, start: number, consumeUnquotedRemainder: boolean): number {
+  if (start >= value.length) return start;
+  if (value.startsWith("***", start)) return start + 3;
+  const opener = value[start];
+  if (opener === '"' || opener === "'") return consumeQuoted(value, start, opener);
+  if (opener === "[" || opener === "{") return consumeStructured(value, start, opener);
+  if (consumeUnquotedRemainder) return value.length;
+
+  let index = start;
+  while (index < value.length && value[index] !== "," && value[index] !== "}" && value[index] !== "]") {
+    index++;
+  }
+  return index;
+}
+
+function consumeQuoted(value: string, start: number, quote: string): number {
+  let index = start + 1;
+  while (index < value.length) {
+    if (value[index] === "\\") {
+      index = Math.min(value.length, index + 2);
+      continue;
+    }
+    if (value[index] === quote) return index + 1;
+    index++;
+  }
+  return value.length;
+}
+
+function consumeStructured(value: string, start: number, opener: string): number {
+  const stack = [opener];
+  let quote: string | undefined;
+  let index = start + 1;
+  while (index < value.length) {
+    const character = value[index];
+    if (quote) {
+      if (character === "\\") {
+        index = Math.min(value.length, index + 2);
+        continue;
+      }
+      if (character === quote) quote = undefined;
+      index++;
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+      index++;
+      continue;
+    }
+    if (character === "[" || character === "{") {
+      stack.push(character);
+      index++;
+      continue;
+    }
+    if (character === "]" || character === "}") {
+      const expected = character === "]" ? "[" : "{";
+      if (stack.at(-1) !== expected) return value.length;
+      stack.pop();
+      index++;
+      if (stack.length === 0) return index;
+      continue;
+    }
+    index++;
+  }
+  return value.length;
+}
+
+function fitMarker(marker: string, max: number): string {
+  if (max <= 0) return "";
+  if (marker.length <= max) return marker;
+  if (max === 1) return "…";
+  return `${marker.slice(0, max - 1)}…`;
+}