@aion0/forge 0.10.51 → 0.10.55

package/components/ScratchViewer.tsx

@@ -0,0 +1,152 @@
+'use client';
+
+import { useEffect, useState } from 'react';
+import MarkdownContent from './MarkdownContent';
+
+const TEXT_LIKE = new Set(['md', 'txt', 'log', 'json', 'yaml', 'yml', 'csv', 'html']);
+const IMAGE_LIKE = new Set(['png', 'jpg', 'jpeg', 'gif', 'svg']);
+const EMBED_LIKE = new Set(['pdf']);
+
+/** Cap inline text rendering. Anything larger falls back to a download
+ *  prompt — react-markdown on multi-MB strings locks the tab. */
+const MAX_INLINE_BYTES = 2 * 1024 * 1024;
+
+function extOf(p: string): string {
+  const m = p.match(/\.([^./]+)$/);
+  return m ? m[1].toLowerCase() : '';
+}
+
+export default function ScratchViewer({
+  path,
+  apiBase = '/api/scratch',
+  topLabel = 'scratch',
+}: {
+  path: string;
+  /** API route prefix. /api/scratch resolves under <dataDir>/scratch/;
+   *  /api/files resolves dataDir-wide. Default scratch for back-compat. */
+  apiBase?: string;
+  /** Tiny header tag shown next to the file path (e.g. "scratch", "file"). */
+  topLabel?: string;
+}) {
+  const decoded = (() => {
+    try {
+      return decodeURIComponent(path);
+    } catch {
+      return path;
+    }
+  })();
+  const ext = extOf(decoded);
+  const rawUrl = `${apiBase}/${path}`;
+  const downloadUrl = `${rawUrl}?download=1`;
+
+  const [text, setText] = useState<string | null>(null);
+  const [err, setErr] = useState<string>('');
+  const [tooLarge, setTooLarge] = useState(false);
+
+  useEffect(() => {
+    if (!TEXT_LIKE.has(ext)) return;
+    let cancelled = false;
+    (async () => {
+      try {
+        const r = await fetch(rawUrl);
+        if (!r.ok) {
+          if (!cancelled) setErr(`${r.status} ${r.statusText}`);
+          return;
+        }
+        const len = Number(r.headers.get('content-length') || '0');
+        if (len > MAX_INLINE_BYTES) {
+          if (!cancelled) setTooLarge(true);
+          return;
+        }
+        const body = await r.text();
+        if (cancelled) return;
+        if (body.length > MAX_INLINE_BYTES) {
+          setTooLarge(true);
+          return;
+        }
+        setText(body);
+      } catch (e) {
+        if (!cancelled) setErr((e as Error).message);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [rawUrl, ext]);
+
+  return (
+    <div className="min-h-screen bg-[var(--bg-primary)] text-[var(--text-primary)]">
+      <header className="sticky top-0 z-10 flex items-center justify-between gap-2 px-4 py-2 border-b border-[var(--border)] bg-[var(--bg-secondary)]">
+        <div className="flex items-center gap-2 min-w-0">
+          <span className="text-[10px] uppercase tracking-wide text-[var(--text-secondary)]">{topLabel}</span>
+          <span className="text-xs font-mono truncate" title={decoded}>
+            {decoded}
+          </span>
+        </div>
+        <div className="flex items-center gap-2 flex-shrink-0">
+          <a
+            href={rawUrl}
+            className="text-xs px-2 py-1 rounded border border-[var(--border)] hover:bg-[var(--bg-tertiary)]"
+            target="_blank"
+            rel="noopener"
+          >
+            Open raw
+          </a>
+          <a
+            href={downloadUrl}
+            className="text-xs px-2 py-1 rounded bg-[var(--accent)] text-white hover:opacity-90"
+          >
+            Download
+          </a>
+        </div>
+      </header>
+
+      <main className="px-4 py-3 max-w-4xl mx-auto">
+        {err && (
+          <div className="text-xs text-red-400 border border-red-400/40 rounded p-2 bg-red-400/5">
+            Failed to load: {err}
+          </div>
+        )}
+
+        {tooLarge && (
+          <div className="text-xs text-[var(--text-secondary)] border border-[var(--border)] rounded p-3">
+            File is larger than {Math.round(MAX_INLINE_BYTES / 1024 / 1024)} MB — inline preview skipped. Use Download or Open raw.
+          </div>
+        )}
+
+        {!err && !tooLarge && IMAGE_LIKE.has(ext) && (
+          <img src={rawUrl} alt={decoded} className="max-w-full rounded border border-[var(--border)]" />
+        )}
+
+        {!err && !tooLarge && EMBED_LIKE.has(ext) && (
+          <embed src={rawUrl} type="application/pdf" className="w-full h-[calc(100vh-60px)]" />
+        )}
+
+        {!err && !tooLarge && TEXT_LIKE.has(ext) && text != null && (
+          ext === 'md' ? (
+            <MarkdownContent content={text} />
+          ) : ext === 'html' ? (
+            // Wrap in iframe srcdoc so any embedded scripts can't reach Forge's
+            // origin or steal session cookies. sandbox blocks everything.
+            <iframe
+              srcDoc={text}
+              sandbox=""
+              className="w-full h-[calc(100vh-60px)] bg-white rounded border border-[var(--border)]"
+              title={decoded}
+            />
+          ) : (
+            <pre className="text-[12px] font-mono text-[var(--text-primary)] bg-[var(--bg-tertiary)] border border-[var(--border)] rounded p-3 overflow-auto whitespace-pre-wrap break-words" style={{ fontFamily: 'Menlo, Monaco, "Courier New", monospace' }}>
+              {text}
+            </pre>
+          )
+        )}
+
+        {!err && !tooLarge && !TEXT_LIKE.has(ext) && !IMAGE_LIKE.has(ext) && !EMBED_LIKE.has(ext) && (
+          <div className="text-xs text-[var(--text-secondary)] border border-[var(--border)] rounded p-3">
+            No inline preview for <code className="font-mono">.{ext || '?'}</code> files. Use Download.
+          </div>
+        )}
+      </main>
+    </div>
+  );
+}

package/lib/chat/agent-loop.ts

@@ -28,6 +28,7 @@ import { buildMemoryContext } from './build-memory-context';
 import { buildReferencePromptSection } from './reference-prompt';
 import { buildMemoryTools } from './memory-tools';
 import { buildStartWatchTool } from '../watch/start-watch-tool';
+import { beginTurn, endTurn, isAborted, consumeNotes } from './turn-control';
 import { estimateTokens } from '../memory/token-estimate';
 import {
   listInstalledConnectors,
@@ -419,9 +420,16 @@ function buildSystemPrompt(
     }
   }
   if (builtinDefs.length > 0) {
+    // Builtins are always-active (no connector_open gate) — list their
+    // FULL description so per-tool rules like "save_tmp_file: output
+    // user_message verbatim" / "dispatch_task: ASK before classifying
+    // a save as a task" reach the LLM here, not just buried in the
+    // tools schema. The connector catalog above can be terse because
+    // those tools only become live after connector_open; builtins
+    // never go through that gate, so terseness here loses real guidance.
     lines.push('', 'Builtin tools (always available):');
     for (const t of builtinDefs) {
-      lines.push(`- ${t.name}: ${t.description.slice(0, 100)}`);
+      lines.push(`- ${t.name}: ${t.description}`);
     }
   }
 
@@ -754,10 +762,52 @@ export async function runTurn(args: RunTurnArgs): Promise<{ ok: boolean; error?:
   let lastStop = '';
   let assistantBlocksAccum: ContentBlock[] = [];
 
+  // Mark this turn live so the user can abort it / inject notes mid-flight
+  // (see turn-control.ts). Cleared in the finally below.
+  beginTurn(args.sessionId);
+
   try {
     while (iter < MAX_ITERATIONS) {
       iter += 1;
 
+      // ── User intervention (turn-control) ────────────────────────
+      // Abort: stop the loop cleanly at this boundary with a sentinel so
+      // the turn doesn't just vanish. (The current in-flight LLM call /
+      // tool batch from the previous iteration has already settled here.)
+      if (isAborted(args.sessionId)) {
+        const stopMsg = appendMessage({
+          session_id: args.sessionId,
+          role: 'assistant',
+          blocks: [{ type: 'text', text: '⏹ Stopped by user.' } as TextBlock],
+        });
+        cb({ type: 'message_saved', message_id: stopMsg.id, data: stopMsg });
+        lastStop = 'aborted';
+        break;
+      }
+      // Supplementary notes: splice any queued user notes in as a user
+      // message so THIS iteration's LLM call sees them. Safe after a
+      // tool_result message — the adapter emits that as a `tool` message,
+      // so a following `user` message doesn't collide on role.
+      // Drain notes — each becomes its own user message so the thread
+      // shows them in arrival order (matches the optimistic messages the
+      // client already rendered when the user hit Send). The first note
+      // carries a flag for the model so it knows this is a mid-task
+      // redirect, not ambient chat; subsequent notes go raw to avoid
+      // cluttering the visible thread.
+      const notes = consumeNotes(args.sessionId);
+      if (notes.length > 0) {
+        const FLAG = '[mid-task interjection — sent WHILE you were running tools. Treat as an authoritative redirect that overrides any plan you announced earlier (count, target, scope). Adjust on the very next step.]';
+        for (let i = 0; i < notes.length; i++) {
+          const text = i === 0 ? `${FLAG}\n\n${notes[i]}` : notes[i]!;
+          const noteMsg = appendMessage({
+            session_id: args.sessionId,
+            role: 'user',
+            blocks: [{ type: 'text', text } as TextBlock],
+          });
+          cb({ type: 'message_saved', message_id: noteMsg.id, data: noteMsg });
+        }
+      }
+
       // ── Recompute open set every iteration ──────────────────────
       // Scan history (since last user text msg) + this turn's accumulated
       // blocks → which connectors are open right now. Then filter tools.
@@ -885,10 +935,28 @@ export async function runTurn(args: RunTurnArgs): Promise<{ ok: boolean; error?:
 
       if (result.stopReason !== 'tool_use') break;
 
-      // Execute tool calls
+      // Execute tool calls. The LLM can emit several tool_use blocks per
+      // iteration (parallel batch). Without an in-batch abort check, a
+      // user who clicks Stop after the batch starts has to wait for ALL
+      // tools to finish before the loop top-check fires next iter — feels
+      // like Stop did nothing. So: between tools, if abort was requested,
+      // skip the remaining ones with synthetic "aborted" tool_results
+      // (the tool_use/tool_result pairing invariant must hold for the
+      // Anthropic API; an orphan tool_use rejects the next call).
       const toolUses = result.content.filter((b): b is ToolUseBlock => b.type === 'tool_use');
       const toolResults: ToolResultBlock[] = [];
       for (const t of toolUses) {
+        if (isAborted(args.sessionId)) {
+          const block: ToolResultBlock = {
+            type: 'tool_result',
+            tool_use_id: t.id,
+            content: '⏹ Skipped — user requested stop.',
+            is_error: true,
+          };
+          toolResults.push(block);
+          cb({ type: 'tool_result', data: { tool_use_id: t.id, name: t.name, result: { content: block.content, is_error: true } } });
+          continue;
+        }
         const r = await dispatchTool({ id: t.id, name: t.name, input: t.input }, { extraBuiltins: memHandlers, sessionId: args.sessionId });
         const block: ToolResultBlock = {
           type: 'tool_result',
@@ -960,5 +1028,7 @@ export async function runTurn(args: RunTurnArgs): Promise<{ ok: boolean; error?:
     });
     cb({ type: 'error', data: { error: msg } });
     return { ok: false, error: msg };
+  } finally {
+    endTurn(args.sessionId);
   }
 }

package/lib/chat/link-patterns.ts

@@ -81,17 +81,40 @@ export const LINK_PATTERNS: LinkPattern[] = [
     url: 'https://nvd.nist.gov/vuln/detail/{1}',
     label: '{1}',
   },
-  // Forge scratch-dir files. LLMs frequently emit paths like
-  // `scratch/foo.md` when they write reports during chat-launched tasks.
-  // Turn them into clickable links served by /api/scratch/<path>.
-  // Match path segments + filename with extension; bound to a known set
-  // of extensions to avoid linkifying noise like `scratch/notes`.
+  // Forge-managed files inside <dataDir>/. LLMs emit:
+  //   • `scratch/foo.md`  — legacy task-workspace writes (kept under
+  //                         <dataDir>/scratch/, served by /scratch viewer)
+  //   • `tmp/foo.md`      — chat's save_tmp_file output (<dataDir>/tmp/)
+  //   • `flows/x.yaml`    — pipeline workflow definitions
+  //   • `prompts/y.yaml`  — schedule prompt bodies
+  // All four resolve through the /files/<dataDir-path> viewer (rendered
+  // markdown + download button), which fetches /api/files for raw bytes.
+  // Sensitive top-level items (encrypt key, sqlite DBs, log, token
+  // caches) are blocked at the API layer, so safe to be liberal here.
   {
     id: 'scratch-file',
     regex: /\bscratch\/([\w\-./]+?\.(?:md|txt|json|yaml|yml|csv|log|html|pdf|png|jpg|jpeg|gif|svg))\b/gi,
-    url: '/api/scratch/{1}',
+    url: '/scratch/{1}',
     label: 'scratch/{1}',
   },
+  {
+    id: 'tmp-file',
+    regex: /\btmp\/([\w\-./]+?\.(?:md|txt|json|yaml|yml|csv|log|html|pdf|png|jpg|jpeg|gif|svg))\b/gi,
+    url: '/files/tmp/{1}',
+    label: 'tmp/{1}',
+  },
+  {
+    id: 'flows-file',
+    regex: /\bflows\/([\w\-./]+?\.(?:yaml|yml|json))\b/gi,
+    url: '/files/flows/{1}',
+    label: 'flows/{1}',
+  },
+  {
+    id: 'prompts-file',
+    regex: /\bprompts\/([\w\-./]+?\.(?:yaml|yml|md|txt))\b/gi,
+    url: '/files/prompts/{1}',
+    label: 'prompts/{1}',
+  },
 ];
 
 export interface CompiledPattern {