loom-agent 1.3.2 → 1.5.0

package/src/tui/App.tsx

@@ -63,6 +63,7 @@ import { loadConfig, saveConfig, getBaseUrl } from "../config/settings.js";
 import { loadAgents, resolveAgent } from "../core/agents.js";
 import { snapshotBefore, snapshotAfter, snapshotBashBefore, diffBashAfter, clearFileDiffs } from "../core/file-diffs.js";
 import { createRestorePoint, listRestorePoints, restoreTo } from "../core/restore.js";
+import { TranscriptUndo } from "../core/transcript-undo.js";
 import { PROVIDERS, PROVIDER_ORDER, PROVIDER_LABELS } from "../providers/index.js";
 import * as plugin from "../core/plugin-cmd.js";
 import * as sandbox from "../core/sandbox.js";
@@ -71,6 +72,13 @@ import { listSkills } from "../skills/skills-manager.js";
 
 let _vimReg = ""; // vim NORMAL-mode paste register
 
+// Transcript undo/redo — one undoable step per user turn. The engine is pure
+// (src/core/transcript-undo.js); App owns the stacks and clones snapshots.
+const _undo = new TranscriptUndo(50);
+// Restore-point id created for the most recent turn, attached to the snapshot
+// pushed just before that turn so an undo can also roll the working tree back.
+let _lastRestoreId: string | null = null;
+
 const ui = palette("loom");
 
 export function App(props: { initialPrompt?: string; resumeSession?: string; autoMode?: boolean }) {
@@ -168,18 +176,37 @@ export function App(props: { initialPrompt?: string; resumeSession?: string; aut
     // Docker-install resume: while an install is pending, "docker is ready"
     // continues the sandbox setup in THIS session instead of going to the
     // model. Outside the pending flow the phrase is ordinary conversation.
+    // All docker state checks are ASYNC (spawn-based) — a sync status call
+    // here froze the whole TUI whenever the docker daemon was slow.
     if (sandbox.isReadySignal(raw)) {
-      var st0 = sandbox.sandboxStatus();
-      if (st0.pending || st0.docker === "ready" && st0.container === "absent" && /set ?up|build|create|make/i.test(raw)) {
+      if (sandbox.sandboxPending()) {
         recordPrompt(raw); setDraft("");
         appendMessage({ role: "user", content: raw });
-        if (st0.docker === "ready" || st0.docker === "no_daemon") {
-          appendMessage({ role: "system", content: "Docker detected \u2014 pick an OS to finish the sandbox setup." });
-          openModal({ type: "sandbox" });
-        } else {
-          sandbox.markInstallPending();
-          appendMessage({ role: "system", content: sandbox.installGuide() });
-        }
+        sandbox.sandboxStatusAsync().then(function(st0) {
+          if (st0.docker === "ready" || st0.docker === "no_daemon") {
+            appendMessage({ role: "system", content: "Docker detected \u2014 pick an OS to finish the sandbox setup." });
+            openModal({ type: "sandbox" });
+          } else {
+            sandbox.markInstallPending();
+            appendMessage({ role: "system", content: sandbox.installGuide() });
+          }
+        });
+        return;
+      }
+      if (!thinking()) {
+        // Might be a "set up the sandbox" request (docker ready, no container
+        // yet). Check async, then either open the wizard or treat as chat.
+        sandbox.sandboxStatusAsync().then(function(st0) {
+          if (st0.docker === "ready" && st0.container === "absent" && /set ?up|build|create|make/i.test(raw)) {
+            recordPrompt(raw); setDraft("");
+            appendMessage({ role: "user", content: raw });
+            appendMessage({ role: "system", content: "Docker detected \u2014 pick an OS to finish the sandbox setup." });
+            openModal({ type: "sandbox" });
+          } else {
+            recordPrompt(raw); setDraft("");
+            runPrompt(raw, false);
+          }
+        });
         return;
       }
     }
@@ -210,10 +237,28 @@ export function App(props: { initialPrompt?: string; resumeSession?: string; aut
   }
 
   function runPrompt(raw: string, shown: boolean, agentId?: string | null, userText?: string) {
+    // Undo checkpoint: capture the transcript as it is BEFORE this turn so
+    // /undo can step back to it. Done synchronously before any message is
+    // appended; the restore point is created in the background below and its
+    // id is stitched onto the snapshot so undo can also roll files back.
+    var preUi = messages().slice();
+    var preSess = getSession().messages.slice();
+    var preTodos = (getSession().todos || []).slice();
+    var preStep = _undo.push({ ui: preUi, session: preSess, todos: preTodos }, raw);
+
     if (!shown) appendMessage({ role: "user", content: raw });
     // Snapshot the project in the background so /restore always works, without
-    // stalling the first API call.
-    setTimeout(function() { try { createRestorePoint(raw); } catch {} }, 0);
+    // stalling the first API call. The created point's id is bound to the undo
+    // step just pushed, so an undo can rewind both transcript and files.
+    setTimeout(function() {
+      try {
+        var rp = createRestorePoint(raw);
+        if (rp && rp.id) {
+          _lastRestoreId = rp.id;
+          if (preStep) preStep.restoreId = rp.id;
+        }
+      } catch {}
+    }, 0);
     setThinking(true); setThinkStart(Date.now());
     var idx = messages().length;
     appendMessage({ role: "assistant", content: "", thinking: true, agentLabel: agentId || undefined });
@@ -517,6 +562,9 @@ export function App(props: { initialPrompt?: string; resumeSession?: string; aut
       clearInterval(speedTimer);
       if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
       if (offTodos) { offTodos(); offTodos = null; }
+      // Per-turn autosave: persist after every turn so a crash/exit never
+      // loses more than the last exchange (previously only /exit saved).
+      try { saveSession(syncSessionForSave()); } catch {}
       // Freeze the subagent panel at its final state ("finished").
       if (subAcc.agent) patchMessageAt(idx, { subagent: { agent: subAcc.agent, text: subAcc.text, log: subAcc.log, status: subAcc.status, done: true } });
       // Let the settled assistant message render before the global turn state
@@ -682,24 +730,48 @@ export function App(props: { initialPrompt?: string; resumeSession?: string; aut
       case "context": {
         const msgs = getSession().messages || [];
         const est = (s: any) => Math.ceil(String(s == null ? "" : (typeof s === "object" ? JSON.stringify(s) : s)).length / 4);
-        let sys = 0, user = 0, asst = 0, tool = 0;
+        let sys = 0, user = 0, asst = 0, tool = 0, schemas = 0;
         try { sys += est(getSession().systemPrompt); } catch {}
+        try { schemas += est(getSession()._agentBlock) + est(getSession()._resolvedPrimary) + est(getSession()._resolvedSandbox) + Math.ceil((getSession()._toolSchemaChars || 0) / 4); } catch {}
         for (const m of msgs) {
           const t = est(m.content) + est(m.toolCalls);
           if (m.role === "user") user += t; else if (m.role === "assistant") asst += t; else if (m.role === "tool") tool += t; else sys += t;
         }
-        const total = sys + user + asst + tool;
+        const total = sys + user + asst + tool + schemas;
+        // Live window estimate from the session (messages + system + tool
+        // schemas) — the percent is recomputed now, not a startup snapshot.
+        let winLine = "";
+        try {
+          const ce = getSession().contextEstimate();
+          winLine = "Window:  ~" + ce.tokens.toLocaleString() + " / " + ce.window.toLocaleString() + " tokens (" + ce.pct + "% used)";
+        } catch {}
         appendMessage({ role: "system", content: [
           "=== Context (~tokens, chars/4 estimate) ===",
           "System+memory: " + sys,
           "User messages: " + user,
           "Assistant:     " + asst,
           "Tool results:  " + tool,
+          "Schemas+turn:  " + schemas,
           "TOTAL:         " + total + "  (" + msgs.length + " messages)",
+          winLine,
           "", "Tip: /compact frees context when this grows large.",
         ].join("\n") });
         return;
       }
+      case "compact": {
+        appendMessage({ role: "system", content: "Compacting…" });
+        getSession().compact({
+          onCompact: (r: any) => {
+            appendMessage({ role: "system", content: r.compacted
+              ? "Compacted (" + r.method + "): summarized/truncated " + r.removed + " earlier messages; ~" + (r.tokensAfter ?? "?") + " tokens remain."
+              : "Nothing to compact — the conversation is still short." });
+          },
+        }).then((r: any) => {
+          if (!r.compacted && !r.reason) appendMessage({ role: "system", content: "Compaction failed — try again." });
+          try { saveSession(syncSessionForSave()); } catch {}
+        }).catch((e: any) => appendMessage({ role: "system", content: "Compaction failed: " + String(e?.message || e) }));
+        return;
+      }
       case "think": {
         const lvl = String(args[0] || "").toLowerCase();
         if (!["off", "low", "medium", "high"].includes(lvl)) { showToast("Usage: /think off|low|medium|high", "error"); return; }
@@ -761,6 +833,50 @@ export function App(props: { initialPrompt?: string; resumeSession?: string; aut
         } catch (e: any) { showToast("Share failed: " + String(e?.message || e), "error"); }
         return;
       }
+      case "export": {
+        // Markdown transcript export — the plain-text counterpart to /share
+        // (which writes HTML). One file per session under .loom/exports/.
+        try {
+          const fsx = require("fs"); const pathx = require("path");
+          const dir = pathx.join(process.cwd(), ".loom", "exports");
+          fsx.mkdirSync(dir, { recursive: true });
+          const lines: string[] = [];
+          lines.push("# Loom Code session");
+          lines.push("");
+          lines.push("- Date: " + new Date().toISOString().slice(0, 19).replace("T", " "));
+          lines.push("- Model: " + providerName() + " / " + modelName());
+          lines.push("- Messages: " + messages().length);
+          lines.push("");
+          for (const m of messages()) {
+            const who = m.role === "user" ? "User" : m.role === "assistant" ? "Assistant" : "System";
+            lines.push("## " + who);
+            lines.push("");
+            const text = String(m.content ?? "").trim();
+            if (text) { lines.push(text); lines.push(""); }
+            if (Array.isArray(m.parts)) {
+              for (const p of m.parts) {
+                if (p.type === "tool" && p.tool) {
+                  const t = p.tool;
+                  let row = "- tool `" + t.name + "` " + (t.status || "");
+                  const out = String(t.output || "").trim();
+                  if (out) row += ": " + out.replace(/\s+/g, " ").slice(0, 300);
+                  lines.push(row);
+                } else if (p.type === "text" && String(p.text || "").trim()) {
+                  lines.push(String(p.text).trim());
+                  lines.push("");
+                }
+              }
+            }
+            if (m.isError) lines.push("**(turn ended with an error)**", "");
+            lines.push("---");
+            lines.push("");
+          }
+          const f = pathx.join(dir, (sessionId() || "session") + ".md");
+          fsx.writeFileSync(f, lines.join("\n"));
+          showToast("Exported: " + f, "ok", 6000);
+        } catch (e: any) { showToast("Export failed: " + String(e?.message || e), "error"); }
+        return;
+      }
       case "worktree": {
         const name = String(args[0] || "").replace(/[^\w-]/g, "");
         if (!name) { showToast("Usage: /worktree <name>", "error"); return; }
@@ -979,6 +1095,63 @@ export function App(props: { initialPrompt?: string; resumeSession?: string; aut
         });
         return;
       }
+      case "undo": {
+        // Step back one turn: restore the transcript captured before the last
+        // user turn, and (when that step has a restore point) offer to rewind
+        // the working tree too so files match the conversation.
+        if (!_undo.canUndo()) { showToast("Nothing to undo.", "info"); return; }
+        // Current state goes on the redo stack so the undo can be re-done.
+        var curSnap = {
+          ui: messages().slice(),
+          session: getSession().messages.slice(),
+          todos: (getSession().todos || []).slice(),
+          restoreId: _lastRestoreId || undefined,
+        };
+        var target = _undo.undo(curSnap);
+        if (!target) { showToast("Nothing to undo.", "info"); return; }
+        setMessages(target.ui || []);
+        getSession().messages = (target.session || []).slice();
+        getSession().todos = (target.todos || []).slice();
+        var undoLine = "Undone \u2014 transcript restored" + (target.label ? " to before: " + target.label.slice(0, 60) : "") + ".";
+        if (target.restoreId) {
+          _lastRestoreId = target.restoreId;
+          undoLine += "\nAlso rewind the working tree to match? Run /undo-files to restore files from the same point.";
+        }
+        appendMessage({ role: "system", content: undoLine });
+        try { saveSession(syncSessionForSave()); } catch {}
+        refreshUsage();
+        return;
+      }
+      case "redo": {
+        if (!_undo.canRedo()) { showToast("Nothing to redo.", "info"); return; }
+        var curSnap2 = {
+          ui: messages().slice(),
+          session: getSession().messages.slice(),
+          todos: (getSession().todos || []).slice(),
+          restoreId: _lastRestoreId || undefined,
+        };
+        var target2 = _undo.redo(curSnap2);
+        if (!target2) { showToast("Nothing to redo.", "info"); return; }
+        setMessages(target2.ui || []);
+        getSession().messages = (target2.session || []).slice();
+        getSession().todos = (target2.todos || []).slice();
+        if (target2.restoreId) _lastRestoreId = target2.restoreId;
+        appendMessage({ role: "system", content: "Redone \u2014 transcript restored" + (target2.label ? " to: " + target2.label.slice(0, 60) : "") + "." });
+        try { saveSession(syncSessionForSave()); } catch {}
+        refreshUsage();
+        return;
+      }
+      case "undo-files": {
+        // Roll the working tree back to the restore point bound to the most
+        // recent undo, so files match the rewound conversation.
+        if (!_lastRestoreId) { showToast("No file restore point bound to the last undo.", "error"); return; }
+        var rr = restoreTo(_lastRestoreId);
+        if (!rr.ok) { showToast("File restore failed: " + rr.error, "error"); return; }
+        appendMessage({ role: "system", content: "Working tree rewound \u2014 " + rr.restored.length + " files restored, " + rr.deleted.length + " removed." });
+        invalidateFilesCache();
+        clearFileDiffs();
+        return;
+      }
       case "usage": {
         refreshUsage();
         const { formatTokens, formatUsd, getUsage } = require("../core/usage.js");
@@ -1077,7 +1250,7 @@ export function App(props: { initialPrompt?: string; resumeSession?: string; aut
       }
       case "connectors": {
         var sub3 = args[0];
-        if (sub3 === "add") { appendMessage({ role: "system", content: plugin.mcpAddCmd(args.slice(1)) }); return; }
+        if (sub3 === "add") { appendMessage({ role: "system", content: plugin.connectorAddCmd(args.slice(1)) }); return; }
         if (sub3 === "remove") { appendMessage({ role: "system", content: plugin.mcpRemoveCmd(args.slice(1)) }); return; }
         if (sub3 === "toggle") { appendMessage({ role: "system", content: plugin.mcpToggleCmd(args.slice(1)) }); return; }
         if (sub3 === "help") { appendMessage({ role: "system", content: plugin.mcpHelp() }); return; }
@@ -1089,39 +1262,60 @@ export function App(props: { initialPrompt?: string; resumeSession?: string; aut
       }
       case "sandbox": {
         var ssub = args[0];
-        var st = sandbox.sandboxStatus();
         // The setup wizard is a modal: docker check (with download link) →
         // OS pick → live build. Bare /sandbox and /sandbox setup open it.
+        // Status/on/rm use ASYNC docker calls — sync ones froze the TUI.
         if (!ssub || ssub === "setup" || ssub === "os") { openModal({ type: "sandbox" }); return; }
         if (ssub === "guide") { appendMessage({ role: "system", content: sandbox.installGuide() }); return; }
         if (ssub === "off") {
           sandbox.setSandboxEnabled(false);
-          appendMessage({ role: "system", content: "Sandbox off — agent commands run on the host again. The container is kept (run /sandbox on to re-enable, /sandbox rm to delete it)." });
+          appendMessage({ role: "system", content: "Sandbox off — the sandbox tool is disabled; the agent works on your machine as usual. The container is kept (run /sandbox on to re-enable, /sandbox rm to delete it)." });
           return;
         }
         if (ssub === "on") {
-          if (st.container !== "running") { appendMessage({ role: "system", content: "Sandbox container is not running. Run /sandbox setup first." }); return; }
-          sandbox.setSandboxEnabled(true);
-          appendMessage({ role: "system", content: "Sandbox on — agent commands now run inside " + sandbox.CONTAINER + "." });
+          sandbox.sandboxStatusAsync().then(function(stOn) {
+            if (stOn.container !== "running") { appendMessage({ role: "system", content: "Sandbox container is not running. Run /sandbox setup first." }); return; }
+            sandbox.setSandboxEnabled(true);
+            appendMessage({ role: "system", content: "Sandbox on — the agent can use the sandbox tool for isolated commands inside " + sandbox.CONTAINER + " when needed. Everything else stays on your machine." });
+          });
           return;
         }
         if (ssub === "rm") {
-          try {
-            require("child_process").execFileSync("docker", ["rm", "-f", sandbox.CONTAINER], { windowsHide: true, timeout: 30000, stdio: "ignore" });
-            sandbox.setSandboxEnabled(false);
-            appendMessage({ role: "system", content: "Sandbox container removed. Run /sandbox setup to rebuild it." });
-          } catch { appendMessage({ role: "system", content: "No sandbox container to remove." }); }
+          appendMessage({ role: "system", content: "Removing the sandbox container…" });
+          var rmCp = require("child_process");
+          var rmSpawn = rmCp.spawn("docker", ["rm", "-f", sandbox.CONTAINER], { windowsHide: true });
+          var rmDone = false;
+          var rmTimer = setTimeout(function() { if (!rmDone) { rmDone = true; try { rmSpawn.kill(); } catch {} appendMessage({ role: "system", content: "Sandbox removal timed out. Is Docker running?" }); } }, 30000);
+          rmSpawn.on("close", function(rmCode) {
+            if (rmDone) return;
+            rmDone = true;
+            clearTimeout(rmTimer);
+            if (rmCode === 0) {
+              sandbox.setSandboxEnabled(false);
+              appendMessage({ role: "system", content: "Sandbox container removed. Run /sandbox setup to rebuild it." });
+            } else {
+              appendMessage({ role: "system", content: "No sandbox container to remove." });
+            }
+          });
+          rmSpawn.on("error", function() {
+            if (rmDone) return;
+            rmDone = true;
+            clearTimeout(rmTimer);
+            appendMessage({ role: "system", content: "No sandbox container to remove (docker not reachable)." });
+          });
           return;
         }
         if (ssub === "status") {
-          var line = "Sandbox: ";
-          if (st.docker === "not_installed") line += "Docker not installed";
-          else if (st.docker === "no_daemon") line += "Docker installed, daemon not running";
-          else line += "Docker " + st.dockerVersion + " \u00b7 container " + st.container + (st.enabled ? " \u00b7 routing ON" : " \u00b7 routing off");
-          if (st.pending) line += "\nWaiting for you to install Docker \u2014 when it's done say \"docker is ready\" (or run /sandbox).";
-          else if (st.docker === "not_installed") line += "\nRun /sandbox for the setup wizard.";
-          else if (st.container === "absent") line += "\nRun /sandbox to build it.";
-          appendMessage({ role: "system", content: line });
+          sandbox.sandboxStatusAsync().then(function(st) {
+            var line = "Sandbox: ";
+            if (st.docker === "not_installed") line += "Docker not installed";
+            else if (st.docker === "no_daemon") line += "Docker installed, daemon not running";
+            else line += "Docker " + st.dockerVersion + " \u00b7 container " + st.container + (st.enabled ? " \u00b7 sandbox tool on" : " \u00b7 sandbox tool off");
+            if (st.pending) line += "\nWaiting for you to install Docker \u2014 when it's done say \"docker is ready\" (or run /sandbox).";
+            else if (st.docker === "not_installed") line += "\nRun /sandbox for the setup wizard.";
+            else if (st.container === "absent") line += "\nRun /sandbox to build it.";
+            appendMessage({ role: "system", content: line });
+          });
           return;
         }
         appendMessage({ role: "system", content: "Usage: /sandbox (wizard) | status | on | off | rm | guide" });
@@ -1566,6 +1760,7 @@ export function App(props: { initialPrompt?: string; resumeSession?: string; aut
   // ═══════════════════════ Lifecycle ═══════════════════════
   let _skillToastOff: (() => void) | null = null;
   let _skillDoneOff: (() => void) | null = null;
+  let _taskToastOff: (() => void) | null = null;
   onMount(function() {
     // Keep the renderer's frame pump alive. The engine only runs its
     // frame callback while there's a non-complete timeline registered;
@@ -1597,10 +1792,11 @@ export function App(props: { initialPrompt?: string; resumeSession?: string; aut
       }, 500);
     }
     // Sandbox install pending from a previous session: remind on start so
-    // the user knows to come back with "docker is ready". Skipped in the
-    // test harness (same flag as the session prompt).
+    // the user knows to come back with "docker is ready". Config-only check
+    // (no docker invocation — the old sandboxStatus() froze startup).
+    // Skipped in the test harness (same flag as the session prompt).
     try {
-      if (!process.env.LOOM_NO_SESSION_PROMPT && sandbox.sandboxStatus().pending) {
+      if (!process.env.LOOM_NO_SESSION_PROMPT && sandbox.sandboxPending()) {
         setTimeout(function() {
           appendMessage({ role: "system", content: "Docker sandbox setup is still pending. Install Docker (see /sandbox guide), then say \"docker is ready\" and I'll build it automatically." });
         }, 800);
@@ -1614,9 +1810,27 @@ export function App(props: { initialPrompt?: string; resumeSession?: string; aut
     _skillDoneOff = on("turn:end", function(d: any) {
       if (d?.skills?.length) showToast("skill handled: " + d.skills.join(", "), "ok");
     });
+    // Background-task completion toasts: bash background:true tasks finishing
+    // (done/error/killed) surface immediately so the model's "started a
+    // server" isn't silent forever.
+    var taskStatuses: Record<string, string> = {};
+    _taskToastOff = on("tasks:changed", function() {
+      try {
+        var bt = require("../core/background-tasks.js");
+        var rows = bt.listBackgroundTasks();
+        for (var i = 0; i < rows.length; i++) {
+          var t = rows[i];
+          var prev = taskStatuses[t.id];
+          taskStatuses[t.id] = t.status;
+          if (prev === "running" && t.status !== "running") {
+            showToast("Task " + t.id + " " + t.status + (t.exitCode != null ? " (exit " + t.exitCode + ")" : "") + " \u2014 /tasks for output", t.status === "done" ? "ok" : "error", 6000);
+          }
+        }
+      } catch {}
+    });
     (globalThis as any).__loomTrace?.("onMount-done", new Error("mount complete"));
   });
-  onCleanup(function() { persistUi(); if (_skillToastOff) _skillToastOff(); if (_skillDoneOff) _skillDoneOff(); });
+  onCleanup(function() { persistUi(); if (_skillToastOff) _skillToastOff(); if (_skillDoneOff) _skillDoneOff(); if (_taskToastOff) _taskToastOff(); });
 
   var showSplash = createMemo(function() { return messages().length === 0; });