@lalalic/markcut 2.0.0 → 2.2.0

package/src/player/server.mjs

@@ -17,7 +17,7 @@ import { fileURLToPath } from "node:url";
 import { isDescriptiveRoot, resolveAndCompile, resolveAndCompileMarkdown, parseImportsBlock, extractDependencySpecs } from "./pipeline.mjs";
 import { bundleFromEntries } from "./bundler.mjs";
 import { extractScenes, MIME, serveFile, handleShutdown } from "./server-shared.mjs";
-import { DEFAULT_AGENT_CLI } from "../config.mjs";
+import { DEFAULT_EDIT_CLI } from "../config.mjs";
 
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -78,6 +78,180 @@ let shutdownTimer = null;
 // ─── Label store for label mode ───────────────────────────────────────────
 let labels = [];
 
+// ─── Agent process (rpc mode) for --edit mode ─────────────────────────────
+// A persistent `pi --mode rpc` subprocess: ONE cold start, MANY edit turns.
+// The agent keeps conversation memory across edits (fast, no re-spawn).
+//
+// JSON-lines protocol over stdio:
+//   request:  {"id":N,"type":"prompt","message":"..."}
+//   response: {"id":N,"type":"response","command":"prompt","success":true}  (accepted)
+//   events:   streamed; a turn ENDS at {"type":"agent_settled"}
+// We collect assistant text from {"type":"message_end", message:{role:"assistant"}}
+// events and resolve the pending /api/edit call on agent_settled.
+let agentProcess = null;
+let agentBusy = false;
+let agentLineBuf = "";          // partial stdout line buffer
+let agentTurnText = "";         // accumulated assistant text for the current turn
+let agentTurnTimer = null;
+/** Resolve/reject for the pending edit API call */
+let pendingEditResolver = null;
+const AGENT_TURN_TIMEOUT = 300000; // 5min safety net per turn
+
+/** Pull text out of an assistant message_end event's content blocks. */
+function extractAssistantText(message) {
+  if (!message || message.role !== "assistant") return "";
+  const content = Array.isArray(message.content) ? message.content : [];
+  return content
+    .filter((b) => b && b.type === "text" && typeof b.text === "string")
+    .map((b) => b.text)
+    .join("");
+}
+
+/** Resolve the pending edit call and reset per-turn state. */
+function finishAgentTurn(result) {
+  if (agentTurnTimer) { clearTimeout(agentTurnTimer); agentTurnTimer = null; }
+  agentBusy = false;
+  const turnText = agentTurnText;
+  agentTurnText = "";
+  const resolver = pendingEditResolver;
+  pendingEditResolver = null;
+  if (resolver) resolver({ ...result, output: result.output != null ? result.output : turnText });
+}
+
+/** Dispatch one parsed JSON line emitted on the agent's stdout. */
+function handleAgentLine(obj) {
+  if (!obj || typeof obj !== "object") return;
+  const t = obj.type;
+  if (t === "message_end") {
+    const txt = extractAssistantText(obj.message);
+    if (txt) agentTurnText += (agentTurnText ? "\n" : "") + txt;
+    return;
+  }
+  if (t === "agent_settled" && pendingEditResolver) {
+    finishAgentTurn({ ok: true });
+    return;
+  }
+  if (t === "response" && obj.command === "prompt" && pendingEditResolver) {
+    // Preflight result: success means "accepted, events incoming"; failure aborts.
+    if (obj.success === false) finishAgentTurn({ ok: false, error: obj.error || "prompt rejected" });
+    return;
+  }
+  if (t === "extension_error" && obj.error) {
+    console.warn(`  ⚠ agent extension error: ${String(obj.error).substring(0, 120)}`);
+  }
+}
+
+/**
+ * Start the persistent agent subprocess in rpc mode.
+ * The system prompt is fixed for the server lifetime (it only references the
+ * constant file path); per-edit context rides on each prompt's message.
+ */
+function startAgentProcess() {
+  if (!MODE_EDIT) return;
+
+  const agentCli = process.env.MARKCUT_EDIT_CLI || DEFAULT_EDIT_CLI;
+
+  const fileLabel = VIDEO_JSON.split("/").pop();
+  const sessionId = VIDEO_JSON.replace(/[^a-zA-Z0-9\-_.]/g, "_").replace(/^[^a-zA-Z0-9]+/, "").replace(/[^a-zA-Z0-9]+$/, "");
+  const promptTemplate = readFileSync(join(ROOT, "docs", "system-prompt-edit.md"), "utf-8");
+  const systemPrompt = promptTemplate
+    .replace(/@\{([^}]+)\}/g, (_, refPath) => {
+      try { return readFileSync(resolve(ROOT, refPath.trim()), "utf-8"); }
+      catch { console.warn(`  ⚠ could not read @{${refPath}}`); return `[Missing: ${refPath}]`; }
+    })
+    .replace(/\$\{fileName\}/g, fileLabel)
+    .replace(/\$\{filePath\}/g, VIDEO_JSON);
+
+  // Build the CLI command — strip -p/--prompt (rpc takes prompts via stdin) and
+  // force --mode rpc. e.g.
+  //   "npx pi --session-id {sessionid} --system-prompt {systemprompt} -p {prompt}"
+  //   → "npx pi --session-id SID --system-prompt SP --mode rpc"
+  const parts = agentCli.split(/\s+/).filter(Boolean);
+  const resolvedParts = [];
+  for (let i = 0; i < parts.length; i++) {
+    const p = parts[i];
+    if (p === "-p" || p === "--prompt") { i++; continue; } // drop prompt flag + value
+    const resolved = p
+      .replace(/\{sessionid\}/g, sessionId)
+      .replace(/\{systemprompt\}/g, systemPrompt)
+      .replace(/\{prompt\}/g, "");
+    if (resolved) resolvedParts.push(resolved);
+  }
+  if (!resolvedParts.includes("--mode")) resolvedParts.push("--mode", "rpc");
+  const cmd = resolvedParts[0];
+  const cmdArgs = resolvedParts.slice(1);
+
+  console.log(`  🎬 starting persistent agent (rpc): ${cmd} ${cmdArgs.slice(0, -1).join(" ")} --system-prompt <${systemPrompt.length} chars>`);
+
+  const child = spawn(cmd, cmdArgs, { cwd: ROOT, stdio: ["pipe", "pipe", "pipe"] });
+  agentProcess = child;
+  agentLineBuf = "";
+
+  // stdout is pure JSON-lines in rpc mode (it takes over stdout). Parse line by line.
+  child.stdout.on("data", (chunk) => {
+    agentLineBuf += chunk.toString();
+    let nl;
+    while ((nl = agentLineBuf.indexOf("\n")) >= 0) {
+      const line = agentLineBuf.slice(0, nl).trim();
+      agentLineBuf = agentLineBuf.slice(nl + 1);
+      if (!line) continue;
+      let obj;
+      try { obj = JSON.parse(line); } catch { continue; } // not JSON — ignore
+      handleAgentLine(obj);
+    }
+  });
+
+  child.stderr.on("data", (chunk) => { process.stderr.write(chunk); });
+
+  child.on("exit", (code) => {
+    console.log(`  ⚫ agent process exited (code ${code})`);
+    agentProcess = null;
+    if (pendingEditResolver) finishAgentTurn({ ok: false, error: `agent exited (code ${code})` });
+    agentBusy = false;
+    // Keep the session warm: restart on any exit while in edit mode.
+    // The --session-id resumes conversation history from disk.
+    if (MODE_EDIT) {
+      console.log(`  🔄 restarting agent in 1s...`);
+      setTimeout(() => startAgentProcess(), 1000);
+    }
+  });
+}
+
+/**
+ * Send an edit prompt to the persistent rpc agent and resolve when the turn
+ * settles. Completion is signalled authoritatively by the `agent_settled`
+ * event — no idle-timeout guessing.
+ * @param {string} prompt
+ * @returns {Promise<{ok: boolean, output: string, error?: string}>}
+ */
+function sendToAgent(prompt) {
+  return new Promise((resolve) => {
+    if (!agentProcess || agentProcess.killed) {
+      resolve({ ok: false, output: "", error: "agent process not running" });
+      return;
+    }
+    if (agentBusy) {
+      resolve({ ok: false, output: "", error: "agent is busy" });
+      return;
+    }
+
+    agentBusy = true;
+    agentTurnText = "";
+    pendingEditResolver = resolve;
+
+    // Safety net — the agent_settled event is the real completion signal.
+    agentTurnTimer = setTimeout(() => {
+      console.warn(`  ⏰ agent turn timed out after ${AGENT_TURN_TIMEOUT / 1000}s`);
+      finishAgentTurn({ ok: false, output: agentTurnText + "\n[TIMEOUT]", error: "agent turn timed out" });
+    }, AGENT_TURN_TIMEOUT);
+
+    const id = Date.now();
+    const req = JSON.stringify({ id, type: "prompt", message: prompt }) + "\n";
+    console.log(`  📤 rpc prompt (id=${id}): ${prompt.substring(0, 80).replace(/\n/g, " ")}`);
+    agentProcess.stdin.write(req);
+  });
+}
+
 // ─── Edit history for context ─────────────────────────────────────────────
 let editHistory = [];
 
@@ -618,13 +792,9 @@ function getHtml(variantLabel) {
   #scene-thumbnails { display: flex; gap: 6px; width: 100%; max-width: 500px; padding: 4px 12px; flex-shrink: 0; overflow-x: auto; scrollbar-width: thin; }
   #scene-thumbnails::-webkit-scrollbar { height: 4px; }
   #scene-thumbnails::-webkit-scrollbar-thumb { background: rgba(255,255,255,.15); border-radius: 2px; }
-  .sthumb-item { flex-shrink: 0; width: 72px; cursor: pointer; border-radius: 6px; overflow: hidden; border: 2px solid transparent; transition: all .15s; background: rgba(255,255,255,.05); display: flex; flex-direction: column; }
-  .sthumb-item:hover { border-color: rgba(74,158,255,.4); }
-  .sthumb-item.active { border-color: #4a9eff; box-shadow: 0 0 8px rgba(74,158,255,.3); }
-  .sthumb-media { width: 100%; height: 48px; overflow: hidden; position: relative; }
-  .sthumb-media img, .sthumb-media video { width: 100%; height: 100%; object-fit: cover; }
-  .sthumb-fallback { width: 100%; height: 100%; display: flex; align-items: center; justify-content: center; background: rgba(255,255,255,.08); color: rgba(255,255,255,.3); font-size: 16px; font-weight: 600; }
-  .sthumb-name { font-size: 9px; color: rgba(255,255,255,.45); text-align: center; padding: 2px 0; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+  .scene-pill { flex-shrink: 0; padding: 4px 12px; border-radius: 12px; cursor: pointer; border: 1px solid transparent; transition: all .15s; background: rgba(255,255,255,.06); color: rgba(255,255,255,.45); font-size: 11px; white-space: nowrap; }
+  .scene-pill:hover { border-color: rgba(74,158,255,.4); color: rgba(255,255,255,.7); }
+  .scene-pill.active { background: rgba(74,158,255,.2); border-color: #4a9eff; color: #4a9eff; }
 </style>
 </head>
 <body>
@@ -759,145 +929,58 @@ const server = createServer(async (req, res) => {
       return;
     }
 
-    // API: Edit — call configured agent CLI to edit the .md source file
-    // Only supports markdown-descriptive (.md) files — the primary authoring format
-    // Uses DEFAULT_AGENT_CLI with {sessionid} replaced by sanitized file path for continuity
-    // System prompt: role "video director" + markcut skill + @{docs/markdown-descriptive.md}
-    // User prompt: current timestamp + active scene + edit request
+    // API: Edit — send prompt to the persistent rpc agent (startAgentProcess)
     if (path === "/api/edit" && req.method === "POST") {
       let body = "";
       req.on("data", c => body += c);
-      req.on("end", () => {
+      req.on("end", async () => {
         try {
           const { text, currentTime, activeScene } = JSON.parse(body);
           if (!text) { res.writeHead(400); res.end(JSON.stringify({ error: "empty text" })); return; }
 
           editHistory.push(text);
 
-          // Read the current file content for the agent to edit
-          const rawContent = readFileSync(VIDEO_JSON, "utf-8");
-          const fileLabel = VIDEO_JSON.split("/").pop();
-          // Sanitize file path to a valid session ID (alphanumeric, -, _, .)
-          const sessionId = VIDEO_JSON.replace(/[^a-zA-Z0-9\-_.]/g, "_").replace(/^[^a-zA-Z0-9]+/, "").replace(/[^a-zA-Z0-9]+$/, "");
-
-          // Build tree structure description for context
-          let treeInfo = "";
-          try {
-            const parsed = JSON.parse(rawContent);
-            const root = parsed.root || parsed;
-
-            function describeNode(node, depth) {
-              const indent = "  ".repeat(depth);
-              const id = node.id || "";
-              const name = node.name || "";
-              const label = name || id;
-              const type = node.type || "unknown";
-              const dur = node.durationInSeconds !== undefined ? `, ${node.durationInSeconds}s` : "";
-              let line = `${indent}${type} "${label}"`;
-              if (type === "root") line += ` (${node.width}x${node.height}, ${node.fps}fps${node.isSeries ? ", series" : ""}${node.transition ? `, transition:${node.transition}` : ""}${node.theme ? `, theme:${node.theme}` : ""})`;
-              else if (type === "folder") line += ` (${node.isSeries ? "series" : "parallel"}${node.transition ? `, transition:${node.transition}` : ""}${dur})`;
-              else if (type === "component") {
-                const props = node.props ? JSON.stringify(Object.fromEntries(Object.entries(node.props).filter(([k]) => !k.startsWith("_")))) : "{}";
-                line += ` ${node.componentName}(${props.slice(0, 100)})${dur}`;
-              }
-              else if (type === "subtitle") { const txt = (node.src || "").slice(0, 60); line += ` "${txt}"${dur}`; }
-              else if (type === "video" || type === "audio" || type === "image") { const src = (node.src || "").slice(0, 50); line += ` "${src}"${dur}`; }
-              else if (type === "effect") line += ` animation:${node.animation || "custom"}${dur}`;
-              else if (type === "rhythm") line += ` src:"${(node.src || "").slice(0, 40)}"${dur}`;
-              else if (type === "map") line += ` waypoints:${(node.waypoints || []).length}${dur}`;
-              else if (type === "include") line += ` src:"${(node.src || "").slice(0, 50)}"${dur}`;
-              if (typeof node.start === "number" || typeof node.end === "number") {
-                const sStart = node.start ?? 0; const sEnd = node.end ?? sStart;
-                line += ` [${sStart}→${sEnd}s${node.isBackground ? ", bg" : ""}${node.volume !== undefined ? `, vol:${node.volume}` : ""}${node.loop ? `, loop:${node.loop}` : ""}]`;
-              } else if (node.isBackground) line += ` [bg]`;
-              const extras = [];
-              if (node.componentName) extras.push(node.componentName);
-              if (node.fit) extras.push(`fit:${node.fit}`);
-              if (node.fontSize) extras.push(`fontSize:${node.fontSize}`);
-              if (node.volume !== undefined && type !== "root") extras.push(`vol:${node.volume}`);
-              if (node.playbackRate) extras.push(`rate:${node.playbackRate}`);
-              if (node.transitionTime !== undefined) extras.push(`transTime:${node.transitionTime}`);
-              if (node.visible === false) extras.push("hidden");
-              if (extras.length > 0) line += ` {${extras.join(", ")}}`;
-              return line;
-            }
-            function walkTree(node, depth = 0) {
-              const lines = [describeNode(node, depth)];
-              if (node.children && node.children.length > 0) {
-                for (const child of node.children.filter(c => c.visible !== false || c.visible === undefined)) lines.push(...walkTree(child, depth + 1));
-              }
-              return lines;
-            }
-            treeInfo = walkTree(root).join("\n");
-          } catch {}
-
-          const historyStr = editHistory.length > 1
-            ? "Previous edits (in order):\n" + editHistory.slice(0, -1).map((e, i) => `${i+1}. ${e}`).join("\n") + "\n"
-            : "";
-
-          // Build system prompt from template file (resolves @{path} references)
-          // System prompt is stable — it contains the role, skills, and format docs.
-          // Tree info and history change per-edit, so they go in the user prompt.
-          const promptTemplate = readFileSync(join(ROOT, "docs", "system-prompt-edit.md"), "utf-8");
-          const systemPrompt = promptTemplate
-            .replace(/@\{([^}]+)\}/g, (_, refPath) => {
-              try {
-                return readFileSync(resolve(ROOT, refPath.trim()), "utf-8");
-              } catch {
-                console.warn(`  ⚠ could not read @{${refPath}}`);
-                return `[Missing: ${refPath}]`;
-              }
-            })
-            .replace(/\$\{fileName\}/g, fileLabel)
-            .replace(/\$\{filePath\}/g, VIDEO_JSON);
-
-          // Build user prompt with current context (changes every edit)
+          // Build user prompt with context (system prompt is fixed at agent startup)
           const timeStr = currentTime !== undefined ? `Current playback time: ${Number(currentTime).toFixed(1)}s` : "";
           const sceneStr = activeScene ? `Active scene: ${activeScene}` : "";
           const contextBlock = [timeStr, sceneStr].filter(Boolean).join("\n");
-
-          const userPrompt = `--- Current stream tree (for reference) ---
-${treeInfo || "(compiled tree)"}
+          const historyStr = editHistory.length > 1
+            ? "Previous edits (in order):\n" + editHistory.slice(0, -1).map((e, i) => `${i+1}. ${e}`).join("\n") + "\n"
+            : "";
+          const userPrompt = `${contextBlock}
 ${historyStr}
-${contextBlock}
 Edit request: ${text}`;
 
-          // Resolve agent CLI template with all placeholders
-          // Each placeholder is its own argument in the template (no shell quotes needed)
-          const agentCli = process.env.MARKCUT_AGENT_CLI || DEFAULT_AGENT_CLI;
-          const parts = agentCli.split(/\s+/);
-          const resolvedParts = parts.map(p =>
-            p.replace(/\{sessionid\}/g, sessionId)
-             .replace(/\{systemprompt\}/g, systemPrompt)
-             .replace(/\{prompt\}/g, userPrompt)
-          );
-          const cmd = resolvedParts[0];
-          const cmdArgs = resolvedParts.slice(1);
-
           console.log(`  🤖 edit: ${text}  (${currentTime !== undefined ? currentTime.toFixed(1) + "s" : ""} ${activeScene || ""})`);
-          console.log(`  🎬 session: ${sessionId}`);
-          console.log(`  📋 cmd: ${agentCli.split(/\s+/)[0]} ${agentCli.split(/\s+/).slice(1).join(" ").replace(/\{prompt\}/g, "...").substring(0, 120)}`);
-
-          const child = spawn(cmd, cmdArgs, {
-            cwd: ROOT,
-            stdio: ["ignore", "pipe", "pipe"],
-          });
-
-          let output = "";
-          child.stdout.on("data", d => output += d);
-          child.stderr.on("data", d => output += d);
-
-          child.on("exit", (code) => {
-            if (code === 0) {
-              console.log(`  ✅ edit complete`);
-              res.writeHead(200, { "Content-Type": "application/json" });
-              res.end(JSON.stringify({ done: true, output: output.trim() }));
+
+          // Send to the persistent rpc agent (one cold start; conversation kept in memory)
+          const result = await sendToAgent(userPrompt);
+
+          if (result.ok) {
+            // Parse JSON summary from the agent's final assistant text
+            let summary = "";
+            let fileChanged = false;
+            const raw = (result.output || "").trim();
+            const jsonMatch = raw.match(/\{[\s\S]*"summary"[\s\S]*\}/);
+            if (jsonMatch) {
+              try {
+                const parsed = JSON.parse(jsonMatch[0]);
+                summary = parsed.summary || raw.substring(0, 120);
+                fileChanged = parsed.fileChanged === true;
+              } catch { summary = raw.substring(0, 120); }
             } else {
-              console.error(`  ❌ edit failed (exit ${code}): ${output.trim()}`);
-              res.writeHead(500, { "Content-Type": "application/json" });
-              res.end(JSON.stringify({ error: `agent exited with code ${code}`, output: output.trim() }));
+              summary = raw.substring(0, 120) || "done";
             }
-          });
+            console.log(`  ✅ ${fileChanged ? "edited" : "no change"}: ${summary}`);
+            console.log(`  📤 response summary="${summary}" fileChanged=${fileChanged}`);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ done: true, summary, fileChanged, output: "" }));
+          } else {
+            const msg = result.error || "failed";
+            console.error(`  ❌ edit ${msg}: ${(result.output || "").trim().substring(0, 100)}`);
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: msg, output: (result.output || "").trim().substring(0, 200) }));
+          }
         } catch (e) {
           res.writeHead(500, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ error: e.message }));
@@ -1000,6 +1083,11 @@ server.listen(PORT, async () => {
     // Pipeline failed — still announce ready so the player can show an error state
   }
 
+  // Start persistent agent process for edit mode (after initial compilation)
+  if (MODE_EDIT) {
+    startAgentProcess();
+  }
+
   const mode = MODE_LABEL ? " --label" : MODE_EDIT ? " --edit" : "";
   console.log(`\n🎬 Player ready at http://localhost:${PORT}${mode}`);
   if (VARIANT_CONFIGS.length > 1) {