chainlesschain 0.47.5 → 0.47.7

package/src/commands/video.js

@@ -0,0 +1,363 @@
+/**
+ * cc video — 视频剪辑 Agent (借鉴 CutClaw)
+ *
+ * 子命令：
+ *  edit          一键完整流程
+ *  deconstruct   解构素材（抽帧+ASR+beat）
+ *  plan          生成 shot_plan
+ *  assemble      Editor ReAct 选时间戳
+ *  render        ffmpeg 渲染成片
+ *  assets        管理已解构素材缓存
+ */
+
+import { logger } from "../lib/logger.js";
+
+export function registerVideoCommand(program) {
+  const video = program
+    .command("video")
+    .description(
+      "Video editing agent — long footage + music → montage (CutClaw-inspired)",
+    );
+
+  // ── cc video edit ─────────────────────────────────────────
+  video
+    .command("edit")
+    .description("Full pipeline: deconstruct → plan → assemble → render")
+    .requiredOption("--video <path>", "Input video file")
+    .option("--audio <path>", "Background music file")
+    .option("--instruction <text>", "Editing instruction", "")
+    .option("--output <path>", "Output video path", "./output.mp4")
+    .option("--srt <path>", "Existing subtitle file (skip ASR)")
+    .option("--fps <n>", "Frame sampling FPS", "2")
+    .option("--character <name>", "Main character name")
+    .option("--parallel", "Run sections in parallel with conflict resolution")
+    .option("--concurrency <n>", "Max parallel sections", "4")
+    .option("--review", "Enable quality gate (VLM review before commit)")
+    .option("--use-madmom", "Use madmom Python sidecar for beat detection")
+    .option("--snap-beats", "Snap shot plan timestamps to nearest beat")
+    .option("--ducking", "Enable dialogue ducking in audio mix")
+    .option("--stream", "Emit NDJSON progress events to stdout")
+    .option("--json", "JSON final output")
+    .action(async (options) => {
+      const { VideoPipeline } =
+        await import("../skills/video-editing/pipeline.js");
+
+      const pipeline = new VideoPipeline({
+        videoPath: options.video,
+        audioPath: options.audio,
+        instruction: options.instruction,
+        outputPath: options.output,
+        existingSrt: options.srt,
+        fps: parseInt(options.fps, 10),
+        mainCharacter: options.character,
+        useMadmom: !!options.useMadmom,
+        snapBeats: !!options.snapBeats,
+        ducking: !!options.ducking,
+      });
+
+      if (options.stream) {
+        pipeline.on("event", (ev) => {
+          process.stdout.write(`${JSON.stringify(ev)}\n`);
+        });
+      } else {
+        pipeline.on("event", (ev) => {
+          if (ev.type === "phase.start") logger.info(`▶ ${ev.phase}`);
+          if (ev.type === "phase.progress")
+            logger.info(`  ${ev.pct * 100}% ${ev.message || ""}`);
+          if (ev.type === "phase.end") logger.info(`✓ ${ev.phase} done`);
+          if (ev.type === "error") logger.error(`✗ ${ev.phase}: ${ev.error}`);
+        });
+      }
+
+      try {
+        const runOpts = {
+          parallel: !!options.parallel,
+          maxConcurrency: parseInt(options.concurrency, 10),
+        };
+        const result = options.review
+          ? await pipeline.runWithReview(runOpts)
+          : await pipeline.run(runOpts);
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else if (!options.stream) {
+          logger.info(`\nOutput: ${result.outputPath}`);
+        }
+      } catch (err) {
+        if (options.stream) {
+          process.stdout.write(
+            `${JSON.stringify({ type: "error", error: err.message, ts: Date.now() })}\n`,
+          );
+        }
+        logger.error(`Video edit failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // ── cc video deconstruct ──────────────────────────────────
+  video
+    .command("deconstruct")
+    .description("Extract frames + ASR + beat analysis (results cached)")
+    .requiredOption("--video <path>", "Input video file")
+    .option("--audio <path>", "Audio file for beat analysis")
+    .option("--srt <path>", "Existing subtitle file")
+    .option("--fps <n>", "Frame sampling FPS", "2")
+    .option("--use-madmom", "Use madmom for beat detection")
+    .option("--stream", "NDJSON events")
+    .option("--json", "JSON output")
+    .action(async (options) => {
+      const { VideoPipeline } =
+        await import("../skills/video-editing/pipeline.js");
+
+      const pipeline = new VideoPipeline({
+        videoPath: options.video,
+        audioPath: options.audio,
+        existingSrt: options.srt,
+        fps: parseInt(options.fps, 10),
+        useMadmom: !!options.useMadmom,
+      });
+
+      if (options.stream) {
+        pipeline.on("event", (ev) =>
+          process.stdout.write(`${JSON.stringify(ev)}\n`),
+        );
+      }
+
+      try {
+        const dir = await pipeline.deconstruct();
+        if (options.json) {
+          console.log(
+            JSON.stringify({ assetDir: dir, hash: dir.split(/[/\\]/).pop() }),
+          );
+        } else if (!options.stream) {
+          logger.info(`Assets cached: ${dir}`);
+        }
+      } catch (err) {
+        logger.error(`Deconstruct failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // ── cc video plan ─────────────────────────────────────────
+  video
+    .command("plan")
+    .description("Generate shot_plan from deconstructed assets + instruction")
+    .requiredOption("--asset-dir <path>", "Deconstructed asset directory")
+    .option("--instruction <text>", "Editing instruction", "")
+    .option("--character <name>", "Main character name")
+    .option("--json", "JSON output")
+    .action(async (options) => {
+      const { VideoPipeline } =
+        await import("../skills/video-editing/pipeline.js");
+
+      const pipeline = new VideoPipeline({
+        videoPath: "",
+        instruction: options.instruction,
+        mainCharacter: options.character,
+        cacheDir: options.assetDir,
+      });
+
+      try {
+        const plan = await pipeline.plan(options.assetDir);
+        if (options.json) {
+          console.log(JSON.stringify(plan, null, 2));
+        } else {
+          const shots = (plan.sections || []).reduce(
+            (s, sec) => s + (sec.shots?.length || 0),
+            0,
+          );
+          logger.info(
+            `Shot plan: ${plan.sections?.length || 0} sections, ${shots} shots`,
+          );
+        }
+      } catch (err) {
+        logger.error(`Plan failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // ── cc video assemble ─────────────────────────────────────
+  video
+    .command("assemble")
+    .description("Run Editor ReAct loop to select timestamps from shot_plan")
+    .requiredOption("--asset-dir <path>", "Deconstructed asset directory")
+    .requiredOption("--plan <path>", "shot_plan.json path")
+    .option("--parallel", "Run sections in parallel with conflict resolution")
+    .option("--concurrency <n>", "Max parallel sections", "4")
+    .option("--review", "Enable quality gate (VLM review before commit)")
+    .option("--stream", "NDJSON events")
+    .option("--json", "JSON output")
+    .action(async (options) => {
+      const { promises: fs } = await import("fs");
+      const { VideoPipeline } =
+        await import("../skills/video-editing/pipeline.js");
+
+      const shotPlan = JSON.parse(await fs.readFile(options.plan, "utf-8"));
+      const pipeline = new VideoPipeline({
+        videoPath: "",
+        cacheDir: options.assetDir,
+      });
+
+      if (options.stream) {
+        pipeline.on("event", (ev) =>
+          process.stdout.write(`${JSON.stringify(ev)}\n`),
+        );
+      }
+
+      try {
+        let points;
+        if (options.parallel) {
+          points = await pipeline.assembleParallel(shotPlan, options.assetDir, {
+            maxConcurrency: parseInt(options.concurrency, 10),
+          });
+        } else {
+          points = await pipeline.assemble(shotPlan, options.assetDir);
+        }
+
+        if (options.review) {
+          const { approved } = await pipeline.review(points, options.assetDir);
+          points = approved;
+        }
+        if (options.json) {
+          console.log(JSON.stringify(points, null, 2));
+        } else if (!options.stream) {
+          logger.info(`Assembled ${points.length} shot points`);
+        }
+      } catch (err) {
+        logger.error(`Assemble failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // ── cc video render ───────────────────────────────────────
+  video
+    .command("render")
+    .description("Render shot_point.json into final video via ffmpeg")
+    .requiredOption("--video <path>", "Original video file")
+    .requiredOption("--points <path>", "shot_point.json path")
+    .option("--audio <path>", "Background music to mix")
+    .option("--output <path>", "Output path", "./output.mp4")
+    .option("--stream", "NDJSON events")
+    .option("--json", "JSON output")
+    .action(async (options) => {
+      const { promises: fs } = await import("fs");
+      const { VideoPipeline, getCacheDir } =
+        await import("../skills/video-editing/pipeline.js");
+
+      const shotPoints = JSON.parse(await fs.readFile(options.points, "utf-8"));
+      const pipeline = new VideoPipeline({
+        videoPath: options.video,
+        audioPath: options.audio,
+        outputPath: options.output,
+        cacheDir: getCacheDir(options.video, options.audio),
+      });
+
+      if (options.stream) {
+        pipeline.on("event", (ev) =>
+          process.stdout.write(`${JSON.stringify(ev)}\n`),
+        );
+      }
+
+      try {
+        const outPath = await pipeline.render(shotPoints);
+        if (options.json) {
+          console.log(JSON.stringify({ outputPath: outPath }));
+        } else if (!options.stream) {
+          logger.info(`Rendered: ${outPath}`);
+        }
+      } catch (err) {
+        logger.error(`Render failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // ── cc video assets ───────────────────────────────────────
+  video
+    .command("assets")
+    .description("Manage deconstructed video asset cache")
+    .argument("[action]", "list | show | prune", "list")
+    .option("--hash <hash>", "Asset hash to show")
+    .option("--older-than <days>", "Prune assets older than N days")
+    .option("--json", "JSON output")
+    .action(async (action, options) => {
+      const { promises: fs } = await import("fs");
+      const pathMod = await import("path");
+
+      const base = process.env.APPDATA
+        ? pathMod.join(
+            process.env.APPDATA,
+            "chainlesschain-desktop-vue",
+            ".chainlesschain",
+            "video-editing",
+          )
+        : pathMod.join(
+            process.env.HOME || "~",
+            ".chainlesschain",
+            "video-editing",
+          );
+
+      if (action === "list") {
+        try {
+          const dirs = await fs.readdir(base);
+          const assets = [];
+          for (const d of dirs) {
+            const metaPath = pathMod.join(base, d, "meta.json");
+            try {
+              const meta = JSON.parse(await fs.readFile(metaPath, "utf-8"));
+              const stat = await fs.stat(metaPath);
+              assets.push({
+                hash: d,
+                ...meta,
+                modifiedAt: stat.mtime.toISOString(),
+              });
+            } catch {}
+          }
+          if (options.json) {
+            console.log(JSON.stringify({ assets }, null, 2));
+          } else {
+            if (assets.length === 0) {
+              logger.info("No cached assets.");
+            } else {
+              for (const a of assets) {
+                logger.info(
+                  `${a.hash}  ${a.videoPath || "?"}  ${a.modifiedAt}`,
+                );
+              }
+            }
+          }
+        } catch {
+          logger.info("No cached assets.");
+        }
+      } else if (action === "show" && options.hash) {
+        const dir = pathMod.join(base, options.hash);
+        try {
+          const files = await fs.readdir(dir);
+          if (options.json) {
+            console.log(JSON.stringify({ hash: options.hash, files }));
+          } else {
+            logger.info(`Asset ${options.hash}:`);
+            for (const f of files) logger.info(`  ${f}`);
+          }
+        } catch {
+          logger.error(`Asset not found: ${options.hash}`);
+        }
+      } else if (action === "prune") {
+        const days = parseInt(options.olderThan || "30", 10);
+        const cutoff = Date.now() - days * 86400000;
+        try {
+          const dirs = await fs.readdir(base);
+          let removed = 0;
+          for (const d of dirs) {
+            const dirPath = pathMod.join(base, d);
+            const stat = await fs.stat(dirPath);
+            if (stat.mtimeMs < cutoff) {
+              await fs.rm(dirPath, { recursive: true, force: true });
+              removed++;
+            }
+          }
+          logger.info(`Pruned ${removed} asset(s) older than ${days} days.`);
+        } catch {
+          logger.info("Nothing to prune.");
+        }
+      }
+    });
+}

package/src/gateways/http/envelope-http-server.js

@@ -0,0 +1,194 @@
+/**
+ * Envelope HTTP Server — Deep Agents Deploy Phase 5 (hosted HTTP follow-up)
+ *
+ * Wires the `@chainlesschain/session-core/envelope-sse` primitive to a node
+ * `http.Server` so consumers without a WebSocket can subscribe to a session's
+ * Phase 5 envelope stream via Server-Sent Events.
+ *
+ * Routes:
+ *   GET /v1/health                       → { ok: true, ... }
+ *   GET /v1/sessions/:sessionId/events   → text/event-stream
+ *
+ * The bus is a minimal pub/sub: callers (ws-server / session-protocol) call
+ * `bus.publish(sessionId, envelope)` whenever an envelope is produced, and the
+ * HTTP route forwards it to every subscriber for that session.
+ *
+ * Authentication: optional bearer token via `Authorization: Bearer <token>`
+ * (matches the WS server's `--token` semantics).
+ */
+
+import http from "node:http";
+import { createRequire } from "node:module";
+
+const require_ = createRequire(import.meta.url);
+const { sseResponseHeaders, formatEnvelopeAsSse, formatSseComment } = require_(
+  "@chainlesschain/session-core/envelope-sse",
+);
+
+/** Minimal pub/sub. Not exported as a class to keep the surface small. */
+export function createEnvelopeBus() {
+  /** @type {Map<string, Set<(env: object) => void>>} */
+  const subs = new Map();
+  return {
+    subscribe(sessionId, fn) {
+      let set = subs.get(sessionId);
+      if (!set) {
+        set = new Set();
+        subs.set(sessionId, set);
+      }
+      set.add(fn);
+      return () => {
+        const s = subs.get(sessionId);
+        if (!s) return;
+        s.delete(fn);
+        if (s.size === 0) subs.delete(sessionId);
+      };
+    },
+    publish(sessionId, envelope) {
+      const set = subs.get(sessionId);
+      if (!set) return 0;
+      for (const fn of set) {
+        try {
+          fn(envelope);
+        } catch (_e) {
+          // Subscriber error must not stop fan-out.
+        }
+      }
+      return set.size;
+    },
+    subscriberCount(sessionId) {
+      const set = subs.get(sessionId);
+      return set ? set.size : 0;
+    },
+  };
+}
+
+const SESSION_EVENTS_RE = /^\/v1\/sessions\/([^/]+)\/events\/?$/;
+
+function checkAuth(req, token) {
+  if (!token) return true;
+  const header = req.headers["authorization"] || "";
+  const match = /^Bearer\s+(.+)$/i.exec(header);
+  return Boolean(match && match[1] === token);
+}
+
+/**
+ * @param {object} options
+ * @param {ReturnType<typeof createEnvelopeBus>} options.bus
+ * @param {number} [options.port=18801]
+ * @param {string} [options.host="127.0.0.1"]
+ * @param {string} [options.token] - optional bearer token; required for SSE
+ * @param {number} [options.heartbeatMs=15000]
+ */
+export function createEnvelopeHttpServer(options = {}) {
+  const bus = options.bus;
+  if (!bus)
+    throw new Error("createEnvelopeHttpServer: options.bus is required");
+  const port = options.port ?? 18801;
+  const host = options.host ?? "127.0.0.1";
+  const token = options.token || null;
+  const heartbeatMs = options.heartbeatMs ?? 15000;
+
+  /** Active SSE subscriber unsubscribers, keyed by response object. */
+  const activeStreams = new Set();
+
+  function handleHealth(_req, res) {
+    res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
+    res.end(JSON.stringify({ ok: true, service: "envelope-http", version: 1 }));
+  }
+
+  function handleSessionEvents(req, res, sessionId) {
+    if (!checkAuth(req, token)) {
+      res.writeHead(401, { "Content-Type": "application/json; charset=utf-8" });
+      res.end(JSON.stringify({ error: "unauthorized" }));
+      return;
+    }
+
+    res.writeHead(200, sseResponseHeaders());
+    // Prime the stream so HTTP/1.1 clients see headers immediately.
+    res.write(formatSseComment(`subscribed sessionId=${sessionId}`));
+
+    const send = (envelope) => {
+      try {
+        res.write(formatEnvelopeAsSse(envelope));
+      } catch (_e) {
+        // Bad envelope — drop, do not crash the stream.
+      }
+    };
+
+    const unsubscribe = bus.subscribe(sessionId, send);
+
+    let heartbeatTimer = null;
+    if (heartbeatMs > 0) {
+      heartbeatTimer = setInterval(() => {
+        try {
+          res.write(formatSseComment("keep-alive"));
+        } catch (_e) {
+          // Connection broken — cleanup will run via 'close' below.
+        }
+      }, heartbeatMs);
+      if (typeof heartbeatTimer.unref === "function") heartbeatTimer.unref();
+    }
+
+    const cleanup = () => {
+      if (heartbeatTimer) clearInterval(heartbeatTimer);
+      unsubscribe();
+      activeStreams.delete(cleanup);
+    };
+    activeStreams.add(cleanup);
+
+    req.on("close", cleanup);
+    req.on("aborted", cleanup);
+  }
+
+  function handler(req, res) {
+    const url = req.url || "/";
+    if (req.method !== "GET") {
+      res.writeHead(405, { Allow: "GET" });
+      res.end();
+      return;
+    }
+    if (url === "/v1/health") return handleHealth(req, res);
+    const match = SESSION_EVENTS_RE.exec(url);
+    if (match)
+      return handleSessionEvents(req, res, decodeURIComponent(match[1]));
+    res.writeHead(404, { "Content-Type": "application/json; charset=utf-8" });
+    res.end(JSON.stringify({ error: "not_found" }));
+  }
+
+  const server = http.createServer(handler);
+
+  return {
+    server,
+    bus,
+    start() {
+      return new Promise((resolve, reject) => {
+        const onError = (err) => {
+          server.removeListener("listening", onListening);
+          reject(err);
+        };
+        const onListening = () => {
+          server.removeListener("error", onError);
+          const addr = server.address();
+          resolve({
+            port: typeof addr === "object" && addr ? addr.port : port,
+            host,
+          });
+        };
+        server.once("error", onError);
+        server.once("listening", onListening);
+        server.listen(port, host);
+      });
+    },
+    stop() {
+      return new Promise((resolve) => {
+        for (const cleanup of [...activeStreams]) cleanup();
+        server.close(() => resolve());
+        // Force-close any kept-alive sockets so the server fully shuts down.
+        if (typeof server.closeAllConnections === "function") {
+          server.closeAllConnections();
+        }
+      });
+    },
+  };
+}

package/src/gateways/ws/message-dispatcher.js

@@ -1,3 +1,9 @@
+import {
+  SESSION_CORE_HANDLERS,
+  SESSION_CORE_STREAMING_HANDLERS,
+} from "./session-core-protocol.js";
+import { VIDEO_HANDLERS, VIDEO_STREAMING_HANDLERS } from "./video-protocol.js";
+
 export function createWsMessageDispatcher(server) {
   return {
     async dispatch(clientId, ws, message) {
@@ -86,6 +92,123 @@ export function createWsMessageDispatcher(server) {
         "task-graph-state": () => server._handleTaskGraphState(id, ws, message),
       };
 
+      // Phase I — Hosted Session API streaming routes (stream.run).
+      // Each intermediate event goes out as { id, type: "stream.event", event }
+      // and the final response is sent by the normal ok/err wrapper.
+      for (const streamingType of Object.keys(
+        SESSION_CORE_STREAMING_HANDLERS,
+      )) {
+        routes[streamingType] = async () => {
+          const controller = new AbortController();
+          const client = server.clients.get(clientId);
+          if (client) {
+            client._streamAborts = client._streamAborts || new Map();
+            client._streamAborts.set(id, controller);
+          }
+          const sender = (payload) => server._send(ws, { id, ...payload });
+          const context = { server, ws, clientId };
+          try {
+            const result = await SESSION_CORE_STREAMING_HANDLERS[streamingType](
+              message,
+              sender,
+              controller.signal,
+              context,
+            );
+            server._send(ws, {
+              id,
+              type: `${streamingType}.end`,
+              ...result,
+            });
+          } catch (err) {
+            server._send(ws, {
+              id,
+              type: "error",
+              code: "STREAM_RUN_ERROR",
+              message: err?.message || String(err),
+            });
+          } finally {
+            if (client?._streamAborts) client._streamAborts.delete(id);
+          }
+        };
+      }
+
+      // Video Editing streaming routes
+      for (const videoStreamType of Object.keys(VIDEO_STREAMING_HANDLERS)) {
+        routes[videoStreamType] = async () => {
+          const controller = new AbortController();
+          const client = server.clients.get(clientId);
+          if (client) {
+            client._streamAborts = client._streamAborts || new Map();
+            client._streamAborts.set(id, controller);
+          }
+          const sender = (payload) => server._send(ws, { id, ...payload });
+          try {
+            const result = await VIDEO_STREAMING_HANDLERS[videoStreamType](
+              message,
+              sender,
+              controller.signal,
+            );
+            server._send(ws, {
+              id,
+              type: `${videoStreamType}.end`,
+              ...result,
+            });
+          } catch (err) {
+            server._send(ws, {
+              id,
+              type: "error",
+              code: "VIDEO_STREAM_ERROR",
+              message: err?.message || String(err),
+            });
+          } finally {
+            if (client?._streamAborts) client._streamAborts.delete(id);
+          }
+        };
+      }
+
+      // Video Editing request/response routes
+      for (const videoType of Object.keys(VIDEO_HANDLERS)) {
+        routes[videoType] = async () => {
+          try {
+            const result = await VIDEO_HANDLERS[videoType](message);
+            server._send(ws, {
+              id,
+              type: `${videoType}.response`,
+              ...result,
+            });
+          } catch (err) {
+            server._send(ws, {
+              id,
+              type: "error",
+              code: "VIDEO_ERROR",
+              message: err?.message || String(err),
+            });
+          }
+        };
+      }
+
+      // Phase I — Hosted Session API (session-core, memory, beta, usage)
+      for (const sessionCoreType of Object.keys(SESSION_CORE_HANDLERS)) {
+        routes[sessionCoreType] = async () => {
+          try {
+            const result =
+              await SESSION_CORE_HANDLERS[sessionCoreType](message);
+            server._send(ws, {
+              id,
+              type: `${sessionCoreType}.response`,
+              ...result,
+            });
+          } catch (err) {
+            server._send(ws, {
+              id,
+              type: "error",
+              code: "SESSION_CORE_ERROR",
+              message: err?.message || String(err),
+            });
+          }
+        };
+      }
+
       const handler = routes[type];
       if (!handler) {
         server._send(ws, {