amalgm 0.1.88 → 0.1.89

package/runtime/scripts/amalgm-mcp/browser/recorder.js

@@ -0,0 +1,199 @@
+'use strict';
+
+/**
+ * Session recorder: capture any browser session to a local WebM file.
+ *
+ * Implementation is a direct CDP Page.startScreencast consumer piped into
+ * ffmpeg (ffmpeg-static when bundled, PATH ffmpeg otherwise). This is
+ * deliberately NOT agent-browser's `record` command:
+ *  - `record` needs ffmpeg on the daemon's PATH at daemon-spawn time, and
+ *    silently "starts" even when ffmpeg is missing (fails only on stop).
+ *  - `record` calls Target.createBrowserContext, which Electron forbids — so
+ *    it can never capture the visible in-tab webview.
+ * A raw screencast works against every CDP target we care about: launched
+ * chromium AND the desktop app's splitscreen webview.
+ *
+ * Storage: recordings belong to the Amalgm project the work is for —
+ * <project>/.amalgm/recordings/ when a project path is known, otherwise
+ * ~/.amalgm/browser-sessions/<session>/.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const cli = require('./cli');
+const engine = require('./engine');
+
+const active = new Map(); // session -> { ws, ffmpeg, file, frames, startedAt }
+
+function ffmpegBinary() {
+  try {
+    const resolved = require('ffmpeg-static');
+    if (resolved && fs.existsSync(resolved)) return resolved;
+  } catch {}
+  return 'ffmpeg';
+}
+
+function resolveProjectPath(args = {}, context = {}) {
+  const candidate = args.projectPath
+    || context?.sessionMetadata?.projectPath
+    || context?.sessionMetadata?.cwd
+    || process.env.AMALGM_PROJECT_PATH
+    || null;
+  if (!candidate) return null;
+  try {
+    return fs.statSync(candidate).isDirectory() ? candidate : null;
+  } catch {
+    return null;
+  }
+}
+
+function recordingDir(args = {}, context = {}, session) {
+  const project = resolveProjectPath(args, context);
+  if (project) return cli.ensureDir(path.join(project, '.amalgm', 'recordings'));
+  return cli.ensureDir(path.join(cli.amalgmDir(), 'browser-sessions', session));
+}
+
+function recordingFile(args, context, session) {
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const name = cli.safeId(args.name || session, session);
+  return path.join(recordingDir(args, context, session), `${name}-${stamp}.webm`);
+}
+
+/**
+ * Page.startScreencast only works on a page-level CDP connection. Launched
+ * sessions report a browser-level ws URL, so resolve the active page target
+ * through the /json/list endpoint on the same debugger port.
+ */
+async function pageWsUrl(wsUrl) {
+  if (!/\/devtools\/browser\//.test(wsUrl)) return wsUrl;
+  const { hostname, port } = new URL(wsUrl);
+  const list = await new Promise((resolve, reject) => {
+    const http = require('http');
+    const req = http.get({ hostname, port, path: '/json/list', timeout: 5_000 }, (res) => {
+      let raw = '';
+      res.on('data', (chunk) => { raw += chunk.toString(); });
+      res.on('end', () => {
+        try { resolve(JSON.parse(raw)); } catch (err) { reject(err); }
+      });
+    });
+    req.on('error', reject);
+    req.on('timeout', () => req.destroy(new Error('Timed out listing CDP targets')));
+  });
+  const page = list.find((t) => t.type === 'webview' && t.webSocketDebuggerUrl)
+    || list.find((t) => t.type === 'page' && t.webSocketDebuggerUrl && !t.url.startsWith('devtools://'));
+  if (!page) throw new Error('No recordable page target found on the CDP endpoint.');
+  return page.webSocketDebuggerUrl;
+}
+
+async function start(args = {}, context = {}) {
+  const session = engine.sessionFor(args, context);
+  if (active.has(session)) {
+    throw new Error(`Recording already active for session "${session}". Call record_stop first.`);
+  }
+
+  const rawUrl = await engine.cdpUrlForSession(session);
+  if (!rawUrl) throw new Error('Could not resolve a CDP endpoint for this browser session.');
+  const wsUrl = await pageWsUrl(rawUrl);
+
+  const WebSocket = require('ws');
+  const file = recordingFile(args, context, session);
+  const fps = Math.min(Math.max(Number(args.fps) || 10, 1), 30);
+
+  const ffmpeg = spawn(ffmpegBinary(), [
+    '-y', '-f', 'image2pipe', '-c:v', 'mjpeg', '-framerate', String(fps), '-i', 'pipe:0',
+    '-vf', 'pad=ceil(iw/2)*2:ceil(ih/2)*2', '-c:v', 'libvpx', '-pix_fmt', 'yuv420p', file,
+  ], { stdio: ['pipe', 'ignore', 'pipe'] });
+  let ffmpegErr = '';
+  ffmpeg.stderr.on('data', (chunk) => { ffmpegErr = (ffmpegErr + chunk.toString()).slice(-2000); });
+
+  const ws = new WebSocket(wsUrl, { perMessageDeflate: false });
+  const recording = { ws, ffmpeg, file, frames: 0, startedAt: Date.now(), ffmpegErr: () => ffmpegErr };
+  active.set(session, recording);
+
+  await new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error('Timed out connecting to browser CDP endpoint')), 10_000);
+    ws.on('open', () => { clearTimeout(timer); resolve(); });
+    ws.on('error', (err) => { clearTimeout(timer); reject(err); });
+  }).catch((err) => {
+    active.delete(session);
+    try { ffmpeg.kill('SIGKILL'); } catch {}
+    throw err;
+  });
+
+  let id = 0;
+  const send = (method, params = {}) => ws.send(JSON.stringify({ id: ++id, method, params }));
+  ws.on('message', (raw) => {
+    let msg;
+    try { msg = JSON.parse(raw); } catch { return; }
+    if (msg.method === 'Page.screencastFrame') {
+      recording.frames += 1;
+      try { ffmpeg.stdin.write(Buffer.from(msg.params.data, 'base64')); } catch {}
+      send('Page.screencastFrameAck', { sessionId: msg.params.sessionId });
+    }
+  });
+  send('Page.enable');
+  send('Page.startScreencast', { format: 'jpeg', quality: 70, everyNthFrame: 1 });
+
+  return { session, path: file, fps, mimeType: 'video/webm', backend: engine.mode() };
+}
+
+async function stop(args = {}, context = {}) {
+  const session = engine.sessionFor(args, context);
+  const recording = active.get(session);
+  if (!recording) throw new Error(`No active recording for session "${session}".`);
+  active.delete(session);
+
+  try {
+    recording.ws.send(JSON.stringify({ id: 9_999, method: 'Page.stopScreencast' }));
+  } catch {}
+  try { recording.ws.close(); } catch {}
+
+  const exitCode = await new Promise((resolve) => {
+    recording.ffmpeg.on('close', resolve);
+    try { recording.ffmpeg.stdin.end(); } catch { resolve(-1); }
+  });
+
+  const durationMs = Date.now() - recording.startedAt;
+  if (recording.frames === 0 || exitCode !== 0) {
+    try { fs.rmSync(recording.file, { force: true }); } catch {}
+    throw new Error(recording.frames === 0
+      ? 'No frames captured — the page may not have repainted while recording. (Screencast only emits on visual change.)'
+      : `ffmpeg failed (exit ${exitCode}): ${recording.ffmpegErr()}`);
+  }
+
+  const bytes = fs.existsSync(recording.file) ? fs.statSync(recording.file).size : 0;
+  return {
+    session,
+    path: recording.file,
+    relativePath: path.relative(cli.amalgmDir(), recording.file),
+    bytes,
+    frames: recording.frames,
+    durationMs,
+    mimeType: 'video/webm',
+  };
+}
+
+function list(args = {}, context = {}) {
+  const session = engine.sessionFor(args, context);
+  const dir = recordingDir(args, context, session);
+  let entries = [];
+  try {
+    entries = fs.readdirSync(dir)
+      .filter((name) => name.endsWith('.webm'))
+      .map((name) => {
+        const file = path.join(dir, name);
+        const stat = fs.statSync(file);
+        return { name, path: file, bytes: stat.size, modifiedAt: stat.mtime.toISOString() };
+      })
+      .sort((a, b) => b.modifiedAt.localeCompare(a.modifiedAt));
+  } catch {}
+  return { dir, recordings: entries, activeSession: active.has(session) ? session : null };
+}
+
+function isActive(session) {
+  return active.has(session);
+}
+
+module.exports = { isActive, list, recordingDir, resolveProjectPath, start, stop };

package/runtime/scripts/amalgm-mcp/browser/rest.js

@@ -1,6 +1,10 @@
 'use strict';
 
-const { loadStateBrowser, navigateBrowser, saveStateBrowser } = require('./page');
+const engine = require('./engine');
+
+const loadStateBrowser = (args, ctx) => engine.loadState(args, ctx);
+const saveStateBrowser = (args, ctx) => engine.saveState(args, ctx);
+const navigateBrowser = (args, ctx) => engine.open(args, ctx);
 const {
   assertBrowserLoginSessionToken,
   cancelBrowserLoginSession,