chainlesschain 0.45.81 → 0.46.0

package/src/lib/cowork-share.js

@@ -0,0 +1,218 @@
+/**
+ * Cowork Share — export/import signed packets for templates and task results.
+ *
+ * Produces a verifiable JSON packet that can be transferred by any channel
+ * (P2P, email, file drop). The packet contains:
+ *   - `kind`: "template" or "result"
+ *   - `payload`: the shareable object (template JSON or history record)
+ *   - `meta`: { author, createdAt, cliVersion }
+ *   - `checksum`: sha256 hex over the canonicalized payload+meta
+ *
+ * Import validates the checksum before returning the payload. This is not an
+ * identity signature — anyone can produce a packet — but it protects against
+ * accidental corruption during transfer.
+ *
+ * @module cowork-share
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+import {
+  toShareableTemplate,
+  saveUserTemplate,
+} from "./cowork-template-marketplace.js";
+
+export const _deps = {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  now: () => new Date().toISOString(),
+};
+
+const PACKET_VERSION = 1;
+const PACKET_KINDS = ["template", "result"];
+
+// ─── Canonical JSON (stable key ordering for checksum) ───────────────────────
+
+export function canonicalize(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    return "[" + value.map(canonicalize).join(",") + "]";
+  }
+  const keys = Object.keys(value).sort();
+  return (
+    "{" +
+    keys
+      .map((k) => JSON.stringify(k) + ":" + canonicalize(value[k]))
+      .join(",") +
+    "}"
+  );
+}
+
+function sha256Hex(s) {
+  return createHash("sha256").update(s, "utf-8").digest("hex");
+}
+
+// ─── Packet builders ─────────────────────────────────────────────────────────
+
+/**
+ * Build a share packet. `kind` and `payload` are validated; `meta` gets
+ * filled with createdAt/cliVersion defaults; checksum is computed over the
+ * canonical form of `{ kind, version, payload, meta }`.
+ */
+export function buildPacket({ kind, payload, author, cliVersion } = {}) {
+  if (!PACKET_KINDS.includes(kind)) {
+    throw new Error(`kind must be one of ${PACKET_KINDS.join(", ")}`);
+  }
+  if (!payload || typeof payload !== "object") {
+    throw new Error("payload must be an object");
+  }
+  const meta = {
+    author: author || "anonymous",
+    createdAt: _deps.now(),
+    cliVersion: cliVersion || "unknown",
+  };
+  const body = { kind, version: PACKET_VERSION, payload, meta };
+  const checksum = sha256Hex(canonicalize(body));
+  return { ...body, checksum };
+}
+
+/**
+ * Verify a packet: checks shape, version, kind, recomputes checksum.
+ * Returns `{ valid, errors }`.
+ */
+export function verifyPacket(packet) {
+  const errors = [];
+  if (!packet || typeof packet !== "object") {
+    return { valid: false, errors: ["packet must be an object"] };
+  }
+  if (packet.version !== PACKET_VERSION) {
+    errors.push(`unsupported packet version ${packet.version}`);
+  }
+  if (!PACKET_KINDS.includes(packet.kind)) {
+    errors.push(`unknown kind '${packet.kind}'`);
+  }
+  if (!packet.payload || typeof packet.payload !== "object") {
+    errors.push("payload missing or not an object");
+  }
+  if (!packet.meta || typeof packet.meta !== "object") {
+    errors.push("meta missing");
+  }
+  if (!packet.checksum) errors.push("checksum missing");
+  if (errors.length > 0) return { valid: false, errors };
+
+  const { checksum, ...body } = packet;
+  const expected = sha256Hex(canonicalize(body));
+  if (expected !== checksum) {
+    errors.push("checksum mismatch (packet may be corrupted or tampered with)");
+  }
+  return { valid: errors.length === 0, errors };
+}
+
+// ─── Higher-level helpers ────────────────────────────────────────────────────
+
+/**
+ * Build a packet from a full Cowork template object. The template is reduced
+ * to its shareable fields first.
+ */
+export function exportTemplatePacket(template, { author, cliVersion } = {}) {
+  const payload = toShareableTemplate(template);
+  return buildPacket({ kind: "template", payload, author, cliVersion });
+}
+
+/**
+ * Build a packet from a history record (one line of history.jsonl).
+ * Irrelevant internal fields are dropped.
+ */
+export function exportResultPacket(historyRecord, { author, cliVersion } = {}) {
+  if (!historyRecord || typeof historyRecord !== "object") {
+    throw new Error("historyRecord required");
+  }
+  const payload = {
+    taskId: historyRecord.taskId,
+    status: historyRecord.status,
+    templateId: historyRecord.templateId,
+    templateName: historyRecord.templateName,
+    userMessage: historyRecord.userMessage,
+    timestamp: historyRecord.timestamp,
+    result: historyRecord.result,
+  };
+  return buildPacket({ kind: "result", payload, author, cliVersion });
+}
+
+/**
+ * Find a history record by taskId in `.chainlesschain/cowork/history.jsonl`.
+ * Returns null if missing. The last matching line wins.
+ */
+export function findHistoryRecord(cwd, taskId) {
+  const file = join(cwd, ".chainlesschain", "cowork", "history.jsonl");
+  if (!_deps.existsSync(file)) return null;
+  const raw = _deps.readFileSync(file, "utf-8");
+  let match = null;
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const rec = JSON.parse(trimmed);
+      if (rec.taskId === taskId) match = rec;
+    } catch (_e) {
+      // skip malformed
+    }
+  }
+  return match;
+}
+
+/**
+ * Write a packet to disk as pretty-printed JSON.
+ */
+export function writePacket(filePath, packet) {
+  _deps.writeFileSync(filePath, JSON.stringify(packet, null, 2), "utf-8");
+  return filePath;
+}
+
+/**
+ * Read + verify a packet from disk. Throws on verification failure.
+ */
+export function readPacket(filePath) {
+  if (!_deps.existsSync(filePath)) {
+    throw new Error(`Packet not found: ${filePath}`);
+  }
+  const body = _deps.readFileSync(filePath, "utf-8");
+  let packet;
+  try {
+    packet = JSON.parse(body);
+  } catch (err) {
+    throw new Error(`Packet is not valid JSON: ${err.message}`);
+  }
+  const { valid, errors } = verifyPacket(packet);
+  if (!valid) throw new Error(`Invalid packet: ${errors.join("; ")}`);
+  return packet;
+}
+
+/**
+ * Import a template packet into the local marketplace.
+ * Returns the installed template.
+ */
+export function importTemplatePacket(cwd, packet) {
+  if (packet.kind !== "template") {
+    throw new Error(`Expected template packet, got '${packet.kind}'`);
+  }
+  return saveUserTemplate(cwd, packet.payload);
+}
+
+/**
+ * Import a result packet into a local `.chainlesschain/cowork/shared-results/`
+ * directory. Produces one JSON file per result, keyed by taskId.
+ */
+export function importResultPacket(cwd, packet) {
+  if (packet.kind !== "result") {
+    throw new Error(`Expected result packet, got '${packet.kind}'`);
+  }
+  const dir = join(cwd, ".chainlesschain", "cowork", "shared-results");
+  _deps.mkdirSync(dir, { recursive: true });
+  const file = join(dir, `${packet.payload.taskId}.json`);
+  _deps.writeFileSync(file, JSON.stringify(packet, null, 2), "utf-8");
+  return { file, taskId: packet.payload.taskId };
+}

package/src/lib/cowork-task-runner.js

@@ -7,14 +7,16 @@
  * @module cowork-task-runner
  */
 
-import { existsSync, mkdirSync, appendFileSync } from "node:fs";
+import { existsSync, mkdirSync, appendFileSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { SubAgentContext } from "./sub-agent-context.js";
-import { getTemplate } from "./cowork-task-templates.js";
+import { getTemplate, setUserTemplates } from "./cowork-task-templates.js";
+import { mountTemplateMcpTools } from "./cowork-mcp-tools.js";
+import { listUserTemplates } from "./cowork-template-marketplace.js";
 
 // ─── Dependencies (overridable for testing) ──────────────────────────────────
 
-export const _deps = { existsSync, mkdirSync, appendFileSync };
+export const _deps = { existsSync, mkdirSync, appendFileSync, readFileSync };
 
 // ─── Constants ────────────────────────────────────────────────────────────────
 
@@ -63,18 +65,53 @@ export async function runCoworkTask(options = {}) {
     }
   }
 
+  // Merge user-installed templates (marketplace) into the registry before resolving
+  try {
+    setUserTemplates(listUserTemplates(cwd));
+  } catch (_e) {
+    // Non-fatal — marketplace absence should not break task execution
+  }
+
   // Resolve template
   const template = getTemplate(templateId);
 
   // Build the task prompt with template context + files
   const taskParts = [template.systemPromptExtension];
 
+  // N2: apply learning-layer patch for this template if one exists
+  try {
+    const { loadUserTemplate } = await import("./cowork-learning.js");
+    const override = loadUserTemplate(cwd, template.id);
+    if (override?.systemPromptExtension) {
+      taskParts.push(
+        `\n## 历史学习补丁 (learning patch)\n${override.systemPromptExtension}`,
+      );
+    }
+  } catch (_e) {
+    // Non-fatal — learning overrides are optional
+  }
+
   if (files.length > 0) {
     taskParts.push(`\n## 用户提供的文件\n${files.join("\n")}`);
   }
 
   const task = taskParts.join("\n");
 
+  // Mount template-declared MCP servers (best-effort, failures are tolerated)
+  const mcp = await mountTemplateMcpTools(template, {
+    onWarn: (msg) => {
+      if (onProgress) onProgress({ type: "mcp-warning", message: msg });
+    },
+  });
+  if (onProgress && (mcp.mounted.length > 0 || mcp.skipped.length > 0)) {
+    onProgress({
+      type: "mcp-mounted",
+      mounted: mcp.mounted,
+      skipped: mcp.skipped.map((s) => s.name),
+      toolCount: mcp.extraToolDefinitions.length,
+    });
+  }
+
   // Create isolated sub-agent context
   const subAgent = SubAgentContext.create({
     role: `cowork-${template.id}`,
@@ -87,6 +124,10 @@ export async function runCoworkTask(options = {}) {
     cwd,
     onProgress,
     signal,
+    extraToolDefinitions: mcp.extraToolDefinitions,
+    externalToolDescriptors: mcp.externalToolDescriptors,
+    externalToolExecutors: mcp.externalToolExecutors,
+    mcpClient: mcp.mcpClient,
   });
 
   const taskId = subAgent.id;
@@ -128,6 +169,279 @@ export async function runCoworkTask(options = {}) {
     };
     _appendHistory(cwd, entry, userMessage);
     return entry;
+  } finally {
+    await mcp.cleanup();
+  }
+}
+
+// ─── Parallel Runner (Orchestrator) ──────────────────────────────────────────
+
+/**
+ * Run a cowork task using the Orchestrator for multi-agent parallel execution.
+ *
+ * @param {object} options - Same as runCoworkTask, plus:
+ * @param {number} [options.agents] - Number of parallel agents (default 3, max 10)
+ * @param {string} [options.strategy] - Routing strategy (default "round-robin")
+ * @param {function} [options.onProgress] - Progress callback
+ * @param {AbortSignal} [options.signal] - Cancellation signal
+ * @returns {Promise<{ taskId: string, status: string, result: object }>}
+ */
+export async function runCoworkTaskParallel(options = {}) {
+  const {
+    templateId = null,
+    userMessage,
+    files = [],
+    cwd = process.cwd(),
+    agents = 3,
+    strategy,
+    onProgress = null,
+    signal = null,
+  } = options;
+
+  if (!userMessage || typeof userMessage !== "string") {
+    throw new Error("userMessage is required");
+  }
+
+  if (files.length > 0) {
+    const missing = files.filter((f) => !_deps.existsSync(f));
+    if (missing.length > 0) {
+      throw new Error(`File(s) not found: ${missing.join(", ")}`);
+    }
+  }
+
+  const template = getTemplate(templateId);
+
+  // Build full task description for the orchestrator
+  const taskParts = [
+    `[Cowork Template: ${template.name}]`,
+    template.systemPromptExtension,
+    `\n## 用户需求\n${userMessage}`,
+  ];
+  if (files.length > 0) {
+    taskParts.push(`\n## 用户提供的文件\n${files.join("\n")}`);
+  }
+  const fullTask = taskParts.join("\n");
+
+  try {
+    const { Orchestrator, TASK_SOURCE } = await import("./orchestrator.js");
+
+    const orch = new Orchestrator({
+      cwd,
+      maxParallel: Math.min(parseInt(agents, 10) || 3, 10),
+      ciCommand: "echo ok",
+      agents: strategy ? { strategy } : undefined,
+      verbose: false,
+    });
+
+    // Wire progress events
+    if (onProgress) {
+      orch.on("task:added", (t) =>
+        onProgress({
+          type: "orchestrator-started",
+          taskId: t.id,
+          subtaskCount: 0,
+        }),
+      );
+      orch.on("task:decomposed", (t) =>
+        onProgress({
+          type: "orchestrator-decomposed",
+          taskId: t.id,
+          subtaskCount: t.subtasks?.length || 0,
+        }),
+      );
+      orch.on("agents:dispatched", (ev) =>
+        onProgress({
+          type: "agents-dispatched",
+          agentCount: ev.agents?.length || 0,
+        }),
+      );
+      orch.on("agent:output", (ev) =>
+        onProgress({
+          type: "agent-progress",
+          agentIndex: ev.agentIndex,
+          status: ev.status,
+          output: ev.output?.slice(0, 200),
+        }),
+      );
+    }
+
+    // Handle cancellation
+    if (signal) {
+      signal.addEventListener(
+        "abort",
+        () => {
+          orch.stopCronWatch();
+        },
+        { once: true },
+      );
+    }
+
+    const orchResult = await orch.addTask(fullTask, {
+      source: TASK_SOURCE.CLI,
+      cwd,
+      runCI: false,
+      notify: false,
+    });
+
+    const entry = {
+      taskId: orchResult.id,
+      status: orchResult.status === "completed" ? "completed" : "failed",
+      templateId: template.id,
+      templateName: template.name,
+      parallel: true,
+      agentCount: agents,
+      result: {
+        summary:
+          orchResult.agentResults
+            ?.map((r) => r.output?.slice(0, 500))
+            .join("\n---\n") || "Parallel execution completed",
+        artifacts: [],
+        tokenCount: 0,
+        toolsUsed: [],
+        iterationCount: orchResult.retries || 0,
+        subtaskCount: orchResult.subtasks?.length || 0,
+      },
+    };
+    _appendHistory(cwd, entry, userMessage);
+    return entry;
+  } catch (err) {
+    const entry = {
+      taskId: `cowork-parallel-${Date.now()}`,
+      status: "failed",
+      templateId: template.id,
+      templateName: template.name,
+      parallel: true,
+      result: {
+        summary: `Parallel task failed: ${err.message}`,
+        artifacts: [],
+        tokenCount: 0,
+        toolsUsed: [],
+        iterationCount: 0,
+        subtaskCount: 0,
+      },
+    };
+    _appendHistory(cwd, entry, userMessage);
+    return entry;
+  }
+}
+
+// ─── Debate Runner (Multi-perspective Review) ───────────────────────────────
+
+/**
+ * Run a cowork task in debate mode — multiple reviewer perspectives converge
+ * into a final verdict via moderator synthesis.
+ *
+ * @param {object} options
+ * @param {string|null} options.templateId - Should be "code-review" or null
+ * @param {string} options.userMessage - Target description / review instructions
+ * @param {string[]} [options.files] - File paths to review (concatenated as code body)
+ * @param {string[]} [options.perspectives] - Override template perspectives
+ * @param {string} [options.cwd] - Working directory for history
+ * @param {object} [options.llmOptions] - LLM provider/model/key
+ * @param {function} [options.onProgress] - Progress callback
+ * @returns {Promise<{ taskId, status, result }>}
+ */
+export async function runCoworkDebate(options = {}) {
+  const {
+    templateId = "code-review",
+    userMessage,
+    files = [],
+    perspectives,
+    cwd = process.cwd(),
+    llmOptions = {},
+    onProgress = null,
+  } = options;
+
+  if (!userMessage || typeof userMessage !== "string") {
+    throw new Error("userMessage is required");
+  }
+
+  if (files.length > 0) {
+    const missing = files.filter((f) => !_deps.existsSync(f));
+    if (missing.length > 0) {
+      throw new Error(`File(s) not found: ${missing.join(", ")}`);
+    }
+  }
+
+  const template = getTemplate(templateId);
+  const reviewPerspectives = perspectives ||
+    template.debatePerspectives || [
+      "performance",
+      "security",
+      "maintainability",
+    ];
+
+  // Build code body from files (or from userMessage if no files provided)
+  let code = "";
+  if (files.length > 0) {
+    const chunks = files.map((f) => {
+      try {
+        return `// ===== ${f} =====\n${_deps.readFileSync(f, "utf-8")}`;
+      } catch (err) {
+        return `// ===== ${f} (read error: ${err.message}) =====`;
+      }
+    });
+    code = chunks.join("\n\n");
+  } else {
+    code = userMessage;
+  }
+
+  const taskId = `cowork-debate-${Date.now()}`;
+
+  if (onProgress) {
+    onProgress({ type: "debate-started", perspectives: reviewPerspectives });
+  }
+
+  try {
+    const { startDebate } = await import("./cowork/debate-review-cli.js");
+    const debateResult = await startDebate({
+      target: userMessage,
+      code,
+      perspectives: reviewPerspectives,
+      llmOptions,
+    });
+
+    if (onProgress) {
+      onProgress({ type: "debate-completed", verdict: debateResult.verdict });
+    }
+
+    const entry = {
+      taskId,
+      status: "completed",
+      templateId: template.id,
+      templateName: template.name,
+      mode: "debate",
+      result: {
+        summary: debateResult.summary,
+        verdict: debateResult.verdict,
+        consensusScore: debateResult.consensusScore,
+        reviews: debateResult.reviews,
+        perspectives: debateResult.perspectives,
+        artifacts: [],
+        tokenCount: 0,
+        toolsUsed: [],
+        iterationCount: debateResult.reviews.length + 1,
+      },
+    };
+    _appendHistory(cwd, entry, userMessage);
+    return entry;
+  } catch (err) {
+    const entry = {
+      taskId,
+      status: "failed",
+      templateId: template.id,
+      templateName: template.name,
+      mode: "debate",
+      result: {
+        summary: `Debate failed: ${err.message}`,
+        artifacts: [],
+        tokenCount: 0,
+        toolsUsed: [],
+        iterationCount: 0,
+      },
+    };
+    _appendHistory(cwd, entry, userMessage);
+    return entry;
   }
 }