chainlesschain 0.47.6 → 0.47.8

package/src/gateways/ws/video-protocol.js

@@ -0,0 +1,230 @@
+/**
+ * Video Editing Protocol — WebSocket routes for cc ui video editing.
+ *
+ * Follows the same pattern as session-core-protocol.js:
+ * - Request/response handlers return { ok, ... } or { ok: false, error }
+ * - Streaming handlers take (message, sender, signal) and emit stream.event
+ *
+ * Route keys use dot-case: video.assets.list, video.deconstruct, etc.
+ */
+
+function ok(data = {}) {
+  return { ok: true, ...data };
+}
+function fail(code, message) {
+  return { ok: false, error: { code, message } };
+}
+
+function createPipeline(message) {
+  const { VideoPipeline } = require("../../skills/video-editing/pipeline.js");
+  return new VideoPipeline({
+    videoPath: message.videoPath,
+    audioPath: message.audioPath,
+    instruction: message.instruction || "",
+    outputPath: message.outputPath || "./output.mp4",
+    existingSrt: message.existingSrt,
+    fps: message.fps || 2,
+    mainCharacter: message.mainCharacter || "",
+  });
+}
+
+// ── Request/Response handlers ─────────────────────────────────
+
+async function videoAssetsList(_message) {
+  const fs = require("fs").promises;
+  const path = require("path");
+  const base = process.env.APPDATA
+    ? path.join(
+        process.env.APPDATA,
+        "chainlesschain-desktop-vue",
+        ".chainlesschain",
+        "video-editing",
+      )
+    : path.join(process.env.HOME || "~", ".chainlesschain", "video-editing");
+  try {
+    const dirs = await fs.readdir(base);
+    const assets = [];
+    for (const d of dirs) {
+      const metaPath = path.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 {
+        /* skip invalid */
+      }
+    }
+    return ok({ assets });
+  } catch {
+    return ok({ assets: [] });
+  }
+}
+
+// ── Streaming handlers ────────────────────────────────────────
+
+async function videoDeconstruct(message, sender, signal) {
+  if (!message.videoPath) return fail("BAD_REQUEST", "videoPath required");
+  const pipeline = createPipeline(message);
+  pipeline.on("event", (ev) => {
+    if (signal?.aborted) return;
+    sender({ type: "stream.event", event: ev });
+  });
+  try {
+    const dir = await pipeline.deconstruct();
+    return ok({
+      assetDir: dir,
+      hash: dir.split(/[/\\]/).pop(),
+    });
+  } catch (err) {
+    return fail("DECONSTRUCT_ERROR", err.message);
+  }
+}
+
+async function videoPlan(message, sender, signal) {
+  if (!message.assetDir && !message.assetHash)
+    return fail("BAD_REQUEST", "assetDir or assetHash required");
+  const pipeline = createPipeline(message);
+  if (message.assetDir) pipeline.cacheDir = message.assetDir;
+  pipeline.on("event", (ev) => {
+    if (signal?.aborted) return;
+    sender({ type: "stream.event", event: ev });
+  });
+  try {
+    const plan = await pipeline.plan(message.assetDir);
+    return ok({ shotPlan: plan });
+  } catch (err) {
+    return fail("PLAN_ERROR", err.message);
+  }
+}
+
+async function videoAssemble(message, sender, signal) {
+  if (!message.assetDir) return fail("BAD_REQUEST", "assetDir required");
+  if (!message.shotPlan) return fail("BAD_REQUEST", "shotPlan required");
+  const pipeline = createPipeline(message);
+  pipeline.cacheDir = message.assetDir;
+  pipeline.on("event", (ev) => {
+    if (signal?.aborted) return;
+    sender({ type: "stream.event", event: ev });
+  });
+  try {
+    const points = await pipeline.assemble(message.shotPlan, message.assetDir);
+    return ok({ shotPoint: points });
+  } catch (err) {
+    return fail("ASSEMBLE_ERROR", err.message);
+  }
+}
+
+async function videoRender(message, sender, signal) {
+  if (!message.videoPath) return fail("BAD_REQUEST", "videoPath required");
+  if (!message.shotPoint) return fail("BAD_REQUEST", "shotPoint required");
+  const pipeline = createPipeline(message);
+  pipeline.on("event", (ev) => {
+    if (signal?.aborted) return;
+    sender({ type: "stream.event", event: ev });
+  });
+  try {
+    const outPath = await pipeline.render(message.shotPoint, message.assetDir);
+    return ok({ outputPath: outPath });
+  } catch (err) {
+    return fail("RENDER_ERROR", err.message);
+  }
+}
+
+async function videoEdit(message, sender, signal) {
+  if (!message.videoPath) return fail("BAD_REQUEST", "videoPath required");
+  const pipeline = createPipeline(message);
+  pipeline.on("event", (ev) => {
+    if (signal?.aborted) return;
+    sender({ type: "stream.event", event: ev });
+  });
+  try {
+    const result = await pipeline.run();
+    return ok({
+      assetDir: result.assetDir,
+      shotPlan: result.shotPlan,
+      shotPoints: result.shotPoints,
+      outputPath: result.outputPath,
+    });
+  } catch (err) {
+    return fail("EDIT_ERROR", err.message);
+  }
+}
+
+// ── Exports ───────────────────────────────────────────────────
+
+export const VIDEO_STREAMING_HANDLERS = {
+  "video.deconstruct": videoDeconstruct,
+  "video.plan": videoPlan,
+  "video.assemble": videoAssemble,
+  "video.render": videoRender,
+  "video.edit": videoEdit,
+};
+
+export const VIDEO_HANDLERS = {
+  "video.assets.list": videoAssetsList,
+};
+
+/**
+ * Attach video routes to the dispatcher's routes object.
+ * Same pattern as attachSessionCoreRoutes.
+ */
+export function attachVideoRoutes(routes, server) {
+  for (const [type, handler] of Object.entries(VIDEO_HANDLERS)) {
+    routes[type] = async (message, ws) => {
+      try {
+        const result = await handler(message);
+        server._send(ws, {
+          id: message.id,
+          type: `${type}.response`,
+          ...result,
+        });
+      } catch (err) {
+        server._send(ws, {
+          id: message.id,
+          type: "error",
+          code: "VIDEO_ERROR",
+          message: err?.message || String(err),
+        });
+      }
+    };
+  }
+
+  for (const [type, handler] of Object.entries(VIDEO_STREAMING_HANDLERS)) {
+    routes[type] = async (message, ws) => {
+      const ac = new AbortController();
+      const cancelKey = message.id;
+      if (cancelKey) {
+        const cancelHandler = (msg) => {
+          if (msg.type === "cancel" && msg.id === cancelKey) ac.abort();
+        };
+        server._cancelHandlers?.set(cancelKey, cancelHandler);
+      }
+      const sender = (ev) => {
+        server._send(ws, { id: message.id, ...ev });
+      };
+      try {
+        const result = await handler(message, sender, ac.signal);
+        server._send(ws, {
+          id: message.id,
+          type: `${type}.end`,
+          ...result,
+        });
+      } catch (err) {
+        server._send(ws, {
+          id: message.id,
+          type: `${type}.end`,
+          ok: false,
+          error: { code: "STREAM_ERROR", message: err?.message || String(err) },
+        });
+      } finally {
+        server._cancelHandlers?.delete(cancelKey);
+      }
+    };
+  }
+
+  return routes;
+}

package/src/gateways/ws/ws-server.js

@@ -15,6 +15,11 @@ import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 import { WebSocketServer } from "ws";
+import {
+  createEnvelope,
+  envelopeFromStreamEvent,
+  validateEnvelope,
+} from "@chainlesschain/session-core";
 import { createTaskRecord } from "../../runtime/contracts/task-record.js";
 import {
   RUNTIME_EVENTS,
@@ -143,6 +148,9 @@ export class ChainlessChainWSServer extends EventEmitter {
     this.maxConnections = options.maxConnections || 10;
     this.timeout = options.timeout || 30000;
 
+    /** Optional Phase-5 envelope bus for fan-out to hosted HTTP SSE. */
+    this.envelopeBus = options.envelopeBus || null;
+
     /** @type {WebSocketServer|null} */
     this.wss = null;
 
@@ -803,4 +811,68 @@ export class ChainlessChainWSServer extends EventEmitter {
       }
     }
   }
+
+  /**
+   * Send a Phase-5 service envelope to a single client.
+   * Accepts either a pre-built envelope or `{ type, sessionId, runId, requestId, payload }`.
+   * Falls back to legacy `_send` shape if envelope construction fails so callers
+   * never lose messages because of a contract bug.
+   *
+   * @param {WebSocket} ws
+   * @param {object} envOrSpec
+   */
+  sendEnvelope(ws, envOrSpec) {
+    let env = envOrSpec;
+    if (!env || typeof env !== "object") return;
+    if (!("v" in env)) {
+      try {
+        env = createEnvelope(envOrSpec);
+      } catch (_e) {
+        this._send(ws, envOrSpec);
+        return;
+      }
+    }
+    const errors = validateEnvelope(env);
+    if (errors.length) {
+      this._send(ws, envOrSpec);
+      return;
+    }
+    this._send(ws, env);
+  }
+
+  /**
+   * Broadcast a Phase-5 service envelope to all authenticated clients.
+   */
+  broadcastEnvelope(envOrSpec) {
+    let env = envOrSpec;
+    if (!("v" in (env || {}))) {
+      try {
+        env = createEnvelope(envOrSpec);
+      } catch (_e) {
+        this._broadcast(envOrSpec);
+        return;
+      }
+    }
+    this._broadcast(env);
+    if (this.envelopeBus && env && env.sessionId) {
+      try {
+        this.envelopeBus.publish(env.sessionId, env);
+      } catch (_e) {
+        // HTTP fan-out must never break the WS path.
+      }
+    }
+  }
+
+  /**
+   * Adapt a StreamRouter event ({type:"token", content:"..."} etc.) into a
+   * Phase-5 run.* envelope and send it to a single client.
+   */
+  sendStreamEnvelope(ws, streamEvent, ctx) {
+    try {
+      const env = envelopeFromStreamEvent(streamEvent, ctx);
+      this._send(ws, env);
+    } catch (_e) {
+      this._send(ws, streamEvent);
+    }
+  }
 }

package/src/gateways/ws/ws-session-gateway.js

@@ -93,6 +93,8 @@ export class WSSessionManager {
     this.trustedMcpServers = createTrustedMcpServerMap(
       options.mcpServerRegistry || null,
     );
+    this.defaultSystemPromptExtension =
+      options.defaultSystemPromptExtension || null;
 
     /** @type {Map<string, Session>} */
     this.sessions = new Map();
@@ -320,9 +322,11 @@ export class WSSessionManager {
     // Build initial system prompt (includes persona + rules.md)
     let systemPrompt = buildSystemPrompt(projectRoot);
 
-    // Append optional extension (e.g. cowork template instructions)
-    if (options.systemPromptExtension) {
-      systemPrompt += "\n\n" + options.systemPromptExtension;
+    // Append optional extension (e.g. cowork template instructions, or bundle AGENTS.md)
+    const promptExtension =
+      options.systemPromptExtension || this.defaultSystemPromptExtension;
+    if (promptExtension) {
+      systemPrompt += "\n\n" + promptExtension;
     }
 
     const messages = [{ role: "system", content: systemPrompt }];

package/src/harness/jsonl-session-store.js

@@ -21,10 +21,14 @@ function getSessionsDir() {
   return dir;
 }
 
-function sessionPath(sessionId) {
+export function sessionPath(sessionId) {
   return join(getSessionsDir(), `${sessionId}.jsonl`);
 }
 
+export function appendTokenUsage(sessionId, usage) {
+  appendEvent(sessionId, "token_usage", usage || {});
+}
+
 export function appendEvent(sessionId, type, data) {
   const line = JSON.stringify({ type, timestamp: Date.now(), data }) + "\n";
   appendFileSync(sessionPath(sessionId), line, "utf-8");
@@ -356,7 +360,10 @@ function performLegacySessionMigration(sourcePath, options) {
     }
 
     const validation = validateJsonlSession(sessionId);
-    if (!validation.valid || validation.messageCount !== legacy.messages.length) {
+    if (
+      !validation.valid ||
+      validation.messageCount !== legacy.messages.length
+    ) {
       throw new Error(
         `post-migration validation failed for ${sessionId} (${validation.messageCount}/${legacy.messages.length} messages)`,
       );
@@ -408,7 +415,8 @@ function normalizeLegacySession(payload, fallbackId) {
   return {
     id: payload?.id || fallbackId || `session-${Date.now()}`,
     meta: {
-      title: payload?.title || payload?.name || fallbackId || "Migrated Session",
+      title:
+        payload?.title || payload?.name || fallbackId || "Migrated Session",
       provider: payload?.provider || "",
       model: payload?.model || "",
     },
@@ -425,11 +433,7 @@ function normalizeLegacyMessage(message) {
 
   const role = message.role || message.sender || message.type || "user";
   const content =
-    message.content ??
-    message.text ??
-    message.message ??
-    message.result ??
-    "";
+    message.content ?? message.text ?? message.message ?? message.result ?? "";
 
   return {
     role,
@@ -445,7 +449,11 @@ function appendLegacyMessage(sessionId, message) {
       appendAssistantMessage(sessionId, message.content);
       break;
     case "tool":
-      appendToolResult(sessionId, message.tool || "legacy-tool", message.content);
+      appendToolResult(
+        sessionId,
+        message.tool || "legacy-tool",
+        message.content,
+      );
       break;
     case "system":
       appendEvent(sessionId, "system", {

package/src/index.js

@@ -14,6 +14,7 @@ import { registerChatCommand } from "./commands/chat.js";
 import { registerAskCommand } from "./commands/ask.js";
 import { registerLlmCommand } from "./commands/llm.js";
 import { registerAgentCommand } from "./commands/agent.js";
+import { registerStreamCommand } from "./commands/stream.js";
 import { registerSkillCommand } from "./commands/skill.js";
 import { registerSearchCommand } from "./commands/search.js";
 import { registerTokensCommand } from "./commands/tokens.js";
@@ -90,6 +91,9 @@ import { registerServeCommand } from "./commands/serve.js";
 // Web UI
 import { registerUiCommand } from "./commands/ui.js";
 
+// Video Editing Agent (CutClaw-inspired)
+import { registerVideoCommand } from "./commands/video.js";
+
 // Orchestration Layer: ChainlessChain → Claude Code/Codex agents → CI → Notify
 import { registerOrchestrateCommand } from "./commands/orchestrate.js";
 
@@ -126,6 +130,7 @@ export function createProgram() {
   registerAskCommand(program);
   registerLlmCommand(program);
   registerAgentCommand(program);
+  registerStreamCommand(program);
   registerSkillCommand(program);
 
   // Phase 1: AI intelligence layer
@@ -215,5 +220,8 @@ export function createProgram() {
   // Orchestration Layer
   registerOrchestrateCommand(program);
 
+  // Video Editing Agent
+  registerVideoCommand(program);
+
   return program;
 }

package/src/lib/agent-stream.js

@@ -0,0 +1,63 @@
+/**
+ * agent-stream — thin wrapper over session-core StreamRouter for REPL output.
+ *
+ * Managed Agents parity Phase G item #2: every agent response — streaming or
+ * not — goes through a uniform StreamEvent protocol. Non-streaming providers
+ * are "fake-streamed" as `start → message → end` so downstream consumers
+ * (REPL, WS IPC, tests) only need one event contract.
+ *
+ * Exports:
+ *   - streamAgentResponse(source, { onEvent, onToken, noStream, writer })
+ *     Returns `{ text, events, errored, error }`. When `noStream` is true,
+ *     events are still collected but no per-event side effects are emitted
+ *     beyond the final writer flush.
+ */
+
+import {
+  StreamRouter,
+  STREAM_EVENT as EVENT,
+} from "@chainlesschain/session-core";
+
+export async function streamAgentResponse(source, options = {}) {
+  const {
+    onEvent = null,
+    onToken = null,
+    noStream = false,
+    writer = null,
+  } = options;
+
+  let writtenByToken = false;
+
+  const router = new StreamRouter({
+    onEvent: (ev) => {
+      try {
+        if (onEvent) onEvent(ev);
+      } catch {
+        /* swallow */
+      }
+      if (noStream || !writer) return;
+      if (ev.type === EVENT.TOKEN && typeof ev.text === "string") {
+        writer(ev.text);
+        writtenByToken = true;
+      }
+    },
+    onToken: (t) => {
+      try {
+        if (onToken) onToken(t);
+      } catch {
+        /* swallow */
+      }
+    },
+  });
+
+  const result = await router.collect(source);
+
+  // Flush MESSAGE content if we haven't already written via TOKEN events.
+  if (writer && !noStream && !writtenByToken && result.text) {
+    writer(result.text);
+  }
+
+  return result;
+}
+
+export { EVENT };