@mortz.prk/opencode-auto-mode 1.0.0 → 1.0.2

package/src/traces.ts

@@ -1,5 +1,6 @@
 import { randomBytes } from "node:crypto";
 import type { AuditRecord } from "./audit.js";
+import { sanitizeRecord } from "./audit.js";
 import type { OtlpOptions } from "./otlp.js";
 import type { StageResult } from "./reviewer.js";
 
@@ -55,20 +56,25 @@ export function createTraceExporter(setting: boolean | OtlpOptions | undefined,
       return {
         traceID, spanID, attempts,
         finish(record) {
-          const shared = [attribute("review.id", record.reviewID), attribute("session.id", record.sessionID)];
+          // Both log sinks sanitize before serialising; traces are a third sink
+          // and must not export unbounded record fields.
+          const safe = sanitizeRecord(record);
+          const shared = [attribute("review.id", safe.reviewID), attribute("session.id", safe.sessionID)];
           const spans = [{
             traceId: traceID, spanId: spanID, name: "auto_mode.review", kind: 1,
-            startTimeUnixNano: nano(startedAt), endTimeUnixNano: nano(startedAt + record.durationMs),
-            attributes: [...shared, attribute("action", record.action), attribute("agent", record.agent ?? ""),
-              attribute("decision", record.decision), attribute("stage", record.stage)],
-            status: { code: record.error ? 2 : 1 },
+            startTimeUnixNano: nano(startedAt), endTimeUnixNano: nano(startedAt + safe.durationMs),
+            attributes: [...shared, attribute("action", safe.action), attribute("agent", safe.agent ?? ""),
+              attribute("decision", safe.decision), attribute("stage", safe.stage),
+              ...(safe.errorKind === undefined ? [] : [attribute("error.kind", safe.errorKind)])],
+            status: { code: safe.error ? 2 : 1 },
           }, ...attempts.map((attempt) => ({
             traceId: traceID, spanId: randomBytes(8).toString("hex"), parentSpanId: spanID,
             name: "auto_mode.classifier", kind: 1,
             startTimeUnixNano: nano(attempt.startedAt), endTimeUnixNano: nano(attempt.startedAt + attempt.durationMs),
             attributes: [...shared, attribute("classifier.index", attempt.index), attribute("classifier.type", attempt.type),
-              attribute("model", attempt.model ?? ""), attribute("decision", attempt.result.decision)],
-            status: { code: 1 },
+              attribute("model", attempt.model ?? ""), attribute("decision", attempt.result.decision),
+              ...(attempt.result.errorKind === undefined ? [] : [attribute("error.kind", attempt.result.errorKind)])],
+            status: { code: attempt.result.errorKind === undefined ? 1 : 2 },
           }))];
           const body = JSON.stringify({ resourceSpans: [{
             resource: { attributes: [attribute("service.name", "opencode-auto-mode")] },

package/src/transcript.ts

@@ -1,15 +1,17 @@
 const MAX_USERS = 10;
 const MAX_TOOLS = 20;
-const MAX_ENTRY_CHARS = 500;
-const MAX_TRANSCRIPT_CHARS = 6000;
+const MAX_USER_CHARS = 8_000;
+const MAX_ENTRY_BYTES = 500;
+const MAX_TRANSCRIPT_BYTES = 12_000;
 
 interface ToolEntry {
   name: string;
   input: unknown;
 }
 
-function truncate(value: string, max: number): string {
-  return value.length > max ? `${value.slice(0, max - 1)}…` : value;
+interface Entry {
+  role: "user" | "tool";
+  text: string;
 }
 
 function asRecord(value: unknown): Record<string, unknown> | undefined {
@@ -42,47 +44,161 @@ function assistantTools(message: unknown): ToolEntry[] {
   return tools;
 }
 
-function formatTool(tool: ToolEntry): string {
+function formatTool(tool: ToolEntry): { text: string; truncated: boolean } {
   let detail = "";
+  let truncated = false;
   try {
     const state = asRecord(tool.input);
     const input = state?.["input"] ?? tool.input;
     const raw = typeof input === "string" ? input : JSON.stringify(input);
-    if (raw) detail = truncate(raw, MAX_ENTRY_CHARS);
+    if (raw) {
+      // Keep the tail as well as the head: written payloads and patches often
+      // carry their constraints at the end. Clip once, on escaped bytes, so a
+      // later UTF-16 length check cannot cut the preserved tail back off.
+      detail = clipEscaped(raw, MAX_ENTRY_BYTES);
+      truncated = detail !== raw;
+    }
   } catch {
     detail = "";
   }
-  return detail ? `${tool.name} ${detail}` : tool.name;
+  return { text: detail ? `${tool.name} ${detail}` : tool.name, truncated };
 }
 
-export interface ReviewContext { transcript: string; complete: boolean }
+function escapedSize(value: string): number {
+  return Buffer.byteLength(JSON.stringify(value));
+}
+
+function prefixByEscapedBytes(characters: string[], maxBytes: number): string {
+  let low = 0;
+  let high = characters.length;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    if (escapedSize(characters.slice(0, middle).join("")) <= maxBytes) low = middle;
+    else high = middle - 1;
+  }
+  return characters.slice(0, low).join("");
+}
+
+function suffixByEscapedBytes(characters: string[], maxBytes: number): string {
+  let low = 0;
+  let high = characters.length;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    if (escapedSize(characters.slice(characters.length - middle).join("")) <= maxBytes) low = middle;
+    else high = middle - 1;
+  }
+  return characters.slice(characters.length - low).join("");
+}
+
+/** Clips the head and tail so escaping cannot hide a trailing constraint. */
+function clipEscaped(value: string, maxBytes: number): string {
+  if (escapedSize(value) <= maxBytes) return value;
+  const characters = Array.from(value);
+  const marker = "…";
+  const budget = Math.max(0, maxBytes - escapedSize(marker));
+  const headBudget = Math.floor(budget * 0.6);
+  return `${prefixByEscapedBytes(characters, headBudget)}${marker}${suffixByEscapedBytes(characters, budget - headBudget)}`;
+}
+
+/** Clips text to `max` code points, keeping both ends for review evidence. */
+export function clipChars(value: string, max: number): string {
+  const characters = Array.from(value);
+  // Compare code points, not UTF-16 units, so astral characters cannot make
+  // this return a longer string than it received.
+  if (characters.length <= max) return value;
+  const head = Math.floor(max * 0.6);
+  return `${characters.slice(0, head).join("")}…${characters.slice(characters.length - (max - head)).join("")}`;
+}
+
+interface TranscriptData {
+  transcript: string;
+  userEvidence: boolean;
+  notes: string[];
+}
+
+function renderTranscript(entries: Entry[], toolTruncated: boolean, userClipped: boolean): { transcript: string; notes: string[] } {
+  if (!entries.some((entry) => entry.role === "user")) return { transcript: "(no prior user messages in this session)", notes: [] };
+  let users = 0;
+  let tools = 0;
+  const recent = entries.slice().reverse().filter((entry) => entry.role === "user" ? ++users <= MAX_USERS : ++tools <= MAX_TOOLS).reverse();
+  const notes: string[] = [];
+  if (recent.length < entries.length) notes.push("older messages omitted");
+  if (toolTruncated) notes.push("some tool details truncated");
+  if (userClipped) notes.push("latest user message truncated");
+  const render = () => `User messages and prior tool calls (chronological):\n${JSON.stringify(recent)}` +
+    (notes.length ? `\n… partial session history (${notes.join("; ")})` : "");
+
+  while (Buffer.byteLength(render()) > MAX_TRANSCRIPT_BYTES && recent.length > 1) {
+    // Keep at least the latest user message.
+    const onlyOneUser = recent.filter((entry) => entry.role === "user").length <= 1;
+    const index = onlyOneUser && recent[0].role === "user" ? recent.findIndex((entry) => entry.role === "tool") : 0;
+    if (index < 0) break;
+    recent.splice(index, 1);
+    if (!notes.includes("older messages omitted")) notes.push("older messages omitted");
+  }
+
+  const latestUser = [...recent].reverse().find((entry) => entry.role === "user");
+  for (let attempt = 0; latestUser !== undefined && Buffer.byteLength(render()) > MAX_TRANSCRIPT_BYTES && attempt < 10; attempt++) {
+    if (!notes.includes("latest user message truncated")) notes.push("latest user message truncated");
+    const excess = Buffer.byteLength(render()) - MAX_TRANSCRIPT_BYTES;
+    latestUser.text = clipEscaped(latestUser.text, Math.max(128, escapedSize(latestUser.text) - excess - 64));
+  }
+  return { transcript: render(), notes };
+}
+
+function buildTranscript(messages: unknown[]): TranscriptData {
+  const entries: Entry[] = [];
+  let userEvidence = false;
+  let userClipped = false;
+  let toolTruncated = false;
+  for (const message of messages) {
+    const record = asRecord(message);
+    if (record?.type === "user") {
+      const text = userText(message);
+      // An empty turn (attachments only, synthetic input) says nothing about
+      // authorization; it must not invalidate the rest of the session.
+      if (text === undefined) continue;
+      userEvidence = true;
+      const clipped = clipChars(text, MAX_USER_CHARS);
+      if (clipped !== text) userClipped = true;
+      entries.push({ role: "user", text: clipped });
+    }
+    for (const tool of assistantTools(message)) {
+      const formatted = formatTool(tool);
+      if (formatted.truncated) toolTruncated = true;
+      entries.push({ role: "tool", text: formatted.text });
+    }
+  }
+  const rendered = renderTranscript(entries, toolTruncated, userClipped);
+  return { transcript: rendered.transcript, userEvidence, notes: rendered.notes };
+}
+
+export interface ReviewContext { transcript: string; complete: boolean; reason?: string; notes?: string[] }
 
 export function extractReviewContext(messages: unknown[]): ReviewContext {
-  const supported = messages.every((message) => {
+  const attachment = messages.some((message) => {
     const record = asRecord(message);
-    if (record?.type !== "user") return true;
+    // Skill messages carry model-facing instructions the text-only reviewer cannot see.
+    if (record?.type === "skill") return true;
+    if (record?.type !== "user") return false;
     // These attachments carry evidence that the text-only reviewer cannot see.
-    return userText(message) !== undefined && ["files", "skills", "agents"].every((key) =>
-      record[key] === undefined || (Array.isArray(record[key]) && record[key].length === 0));
+    return ["files", "skills", "agents"].some((key) =>
+      Array.isArray(record[key]) && record[key].length > 0);
   });
-  const transcript = extractTranscript(messages);
-  return {
-    transcript,
-    complete: supported && transcript.startsWith("User messages") && !transcript.includes("…"),
-  };
+  const data = buildTranscript(messages);
+  if (attachment)
+    return {
+      transcript: data.transcript, complete: false, notes: data.notes,
+      reason: "User authorization includes attachments that cannot be reviewed automatically",
+    };
+  if (!data.userEvidence)
+    return {
+      transcript: data.transcript, complete: false, notes: data.notes,
+      reason: "No user authorization message is available",
+    };
+  return { transcript: data.transcript, complete: true, notes: data.notes };
 }
 
 export function extractTranscript(messages: unknown[]): string {
-  const entries: { role: "user" | "tool"; text: string }[] = [];
-  for (const message of messages) {
-    const text = userText(message);
-    if (text !== undefined) entries.push({ role: "user", text: truncate(text, MAX_ENTRY_CHARS) });
-    for (const tool of assistantTools(message)) entries.push({ role: "tool", text: formatTool(tool) });
-  }
-  if (!entries.some((entry) => entry.role === "user")) return "(no prior user messages in this session)";
-  let users = 0;
-  let tools = 0;
-  const recent = entries.slice().reverse().filter((entry) => entry.role === "user" ? ++users <= MAX_USERS : ++tools <= MAX_TOOLS).reverse();
-  const incomplete = recent.length < entries.length ? "\n… incomplete session context" : "";
-  return truncate(`User messages and prior tool calls (chronological):\n${JSON.stringify(recent)}${incomplete}`, MAX_TRANSCRIPT_CHARS);
+  return buildTranscript(messages).transcript;
 }

package/src/tui-state.ts

@@ -1,7 +1,13 @@
 import type { DecisionRecord } from "./state.js";
 
+/**
+ * How long a "reviewing" record keeps the TUI indicator alive. It must exceed
+ * the largest configurable review deadline so a slow review stays visible.
+ */
+export const REVIEW_DISPLAY_WINDOW_MS = 180_000;
+
 export function isReviewing(records: Record<string, DecisionRecord>, sessionID: string | undefined, now = Date.now()): boolean {
   if (!sessionID) return false;
   return Object.values(records).some((record) => record.sessionID === sessionID &&
-    record.decision === "reviewing" && now - record.at >= 0 && now - record.at < 90_000);
+    record.decision === "reviewing" && now - record.at >= 0 && now - record.at < REVIEW_DISPLAY_WINDOW_MS);
 }

package/src/tui.tsx

@@ -1,7 +1,7 @@
 /** @jsxImportSource @opentui/solid */
 import { createSignal, Show } from "solid-js";
 import { Plugin } from "@opencode/plugin/tui";
-import { readDecisions } from "./state.js";
+import { readConfigError, readDecisions } from "./state.js";
 import { isReviewing } from "./tui-state.js";
 
 const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
@@ -11,21 +11,36 @@ export default Plugin.define({
   setup: async (ctx) => {
     if (ctx.options.tui === false) return;
     const [reviewing, setReviewing] = createSignal(false);
+    const [configError, setConfigError] = createSignal(false);
+    let announced = false;
     const update = () => {
       const route = ctx.ui.router.current();
       setReviewing(isReviewing(readDecisions(), route.type === "session" ? route.sessionID : undefined));
+      const error = readConfigError(ctx.location?.directory);
+      setConfigError(error !== undefined);
+      if (error === undefined) announced = false;
+      else if (!announced) {
+        announced = true;
+        ctx.ui.toast.show({
+          variant: "error", title: "auto-mode", duration: 10_000,
+          message: "Invalid configuration; automatic approval is disabled.",
+        });
+      }
     };
     update();
     const poll = setInterval(update, 250);
     const dispose = ctx.ui.slot({
       append: "app",
       render: () => (
-        <Show when={reviewing()}>
-          <box position="absolute" top={0} right={0} zIndex={10_000} flexDirection="row" gap={1}>
+        <box position="absolute" top={0} right={0} zIndex={10_000} flexDirection="row" gap={1}>
+          <Show when={configError()}>
+            <text fg={ctx.theme.text.feedback.error.base}>auto-mode: invalid config</text>
+          </Show>
+          <Show when={reviewing()}>
             <spinner frames={SPINNER_FRAMES} interval={120} color={ctx.theme.text.feedback.warning.base} />
             <text fg={ctx.theme.text.feedback.warning.base}>auto-mode reviewing</text>
-          </box>
-        </Show>
+          </Show>
+        </box>
       ),
     });
     return () => { clearInterval(poll); dispose(); };