@sunshaobei/dsh-workflow 0.0.0-stage → 2.1.2

package/lib/registry.js

@@ -0,0 +1,218 @@
+import { promises as fs } from "node:fs";
+import { join, basename } from "node:path";
+import { randomUUID } from "node:crypto";
+import { parse, stringify } from "yaml";
+import {
+  validateWorkflowName,
+  listDirOrEmpty,
+  readTextOrNull,
+} from "./core.js";
+
+// 与 MCode saved-workflows/frontmatter.ts 同一文件协议；保留正文逐字节。
+export function decode(source) {
+  const match =
+    /^\s*\/\* (?:zcode|dsh)-workflow\s*\n([\s\S]*?)\n\*\/\r?\n?/.exec(source);
+  if (!match) {
+    if (/^\s*\/\* (?:zcode|dsh)-workflow/.test(source))
+      throw new Error("工作流元数据未闭合");
+    const description =
+      /@description\s+([^\n]+)/.exec(source)?.[1]?.trim() ?? "";
+    const args = Object.fromEntries(
+      [...source.matchAll(/@arg\s+([\w-]+)\s+([^\n]+)/g)].map((m) => [
+        m[1],
+        { type: "string", description: m[2].trim() },
+      ]),
+    );
+    return { meta: { description, args }, script: source, legacy: true };
+  }
+  const meta = parse(match[1], { maxAliasCount: 20 });
+  checkMeta(meta);
+  return { meta, script: source.slice(match[0].length), legacy: false };
+}
+export function checkMeta(meta) {
+  if (!meta || typeof meta.description !== "string")
+    throw new Error("description 必须是字符串");
+  if (
+    meta.args != null &&
+    (typeof meta.args !== "object" || Array.isArray(meta.args))
+  )
+    throw new Error("args 必须是参数声明对象");
+  for (const [key, spec] of Object.entries(meta.args ?? {})) {
+    if (!spec || !["string", "number", "boolean", "json"].includes(spec.type))
+      throw new Error(`参数 ${key} 的类型无效`);
+    if (spec.required !== undefined && typeof spec.required !== "boolean")
+      throw new Error(`参数 ${key} 的 required 必须是布尔值`);
+    if (spec.default !== undefined)
+      validateArgs({ [key]: spec }, { [key]: spec.default });
+  }
+}
+export function encode(meta, script) {
+  checkMeta(meta);
+  return `/* zcode-workflow\n${stringify({ description: meta.description, ...(meta.whenToUse ? { whenToUse: meta.whenToUse } : {}), args: meta.args ?? {} })}*/\n${script}`;
+}
+export function validateArgs(declared = {}, given = {}) {
+  if (!given || typeof given !== "object" || Array.isArray(given))
+    throw new Error("参数必须是对象");
+  const errors = [],
+    args = {};
+  for (const key of Object.keys(given))
+    if (!Object.hasOwn(declared, key)) errors.push(`未知参数：${key}`);
+  for (const [key, spec] of Object.entries(declared)) {
+    const value = given[key] === undefined ? spec.default : given[key];
+    if (value === undefined) {
+      if (spec.required) errors.push(`请填写必填参数：${key}`);
+      continue;
+    }
+    if (
+      spec.type !== "json" &&
+      (typeof value !== spec.type ||
+        (spec.type === "number" && !Number.isFinite(value)))
+    )
+      errors.push(`${key} 必须是 ${spec.type}`);
+    else args[key] = value;
+  }
+  if (errors.length) throw new Error(errors.join("\n"));
+  return args;
+}
+export class Registry {
+  constructor(root, projects = () => []) {
+    this.root = root;
+    this.projects = projects;
+  }
+  groups() {
+    return [
+      {
+        id: "global",
+        name: "全局",
+        scope: "global",
+        path: join(this.root, "saved"),
+      },
+      ...this.projects().map((p) => ({
+        id: p.id,
+        name: p.title || basename(p.path),
+        scope: "project",
+        workspacePath: p.path,
+        path: join(p.path, ".dsh", "workflows"),
+      })),
+    ];
+  }
+  group(id = "global") {
+    const g = this.groups().find((g) => g.id === id);
+    if (!g) throw new Error("项目已关闭或不存在");
+    return g;
+  }
+  path(name, groupId) {
+    return join(
+      this.group(groupId).path,
+      validateWorkflowName(name) + ".dwf.ts",
+    );
+  }
+  async get(name, groupId) {
+    const path = this.path(name, groupId),
+      source = await readTextOrNull(path);
+    if (source === null)
+      throw Object.assign(new Error("找不到工作流：" + name), {
+        code: "ENOENT",
+      });
+    const { meta, script, legacy } = decode(source);
+    return {
+      ...this.group(groupId),
+      ...meta,
+      name,
+      groupId: groupId ?? "global",
+      path,
+      source,
+      script,
+      legacy,
+      updatedAt: (await fs.stat(path)).mtimeMs,
+      id: `${groupId ?? "global"}:${name}`,
+    };
+  }
+  async list() {
+    return Promise.all(
+      this.groups().map(async (group) => {
+        const entries = [],
+          errors = [];
+        // 已有项目的 MCode 文件也可直接读取，迁移/修改时写到 dsh 的目录。
+        const dirs = [
+          group.path,
+          ...(group.workspacePath
+            ? [join(group.workspacePath, ".zcode", "workflows")]
+            : []),
+        ];
+        for (const dir of dirs)
+          for (const file of await listDirOrEmpty(dir)) {
+            if (
+              !file.endsWith(".dwf.ts") ||
+              entries.some((e) => e.name === file.slice(0, -7))
+            )
+              continue;
+            try {
+              const path = join(dir, file),
+                source = await fs.readFile(path, "utf8"),
+                { meta } = decode(source);
+              entries.push({
+                ...meta,
+                name: file.slice(0, -7),
+                groupId: group.id,
+                scope: group.scope,
+                workspacePath: group.workspacePath,
+                path,
+                updatedAt: (await fs.stat(path)).mtimeMs,
+              });
+            } catch (e) {
+              errors.push({ file, error: e.message });
+            }
+          }
+        return { ...group, entries, errors };
+      }),
+    );
+  }
+  async resolveEntry(name, groupId = "global") {
+    try {
+      return await this.get(name, groupId);
+    } catch (e) {
+      if (e.code !== "ENOENT" || !this.group(groupId).workspacePath) throw e;
+      const path = join(
+        this.group(groupId).workspacePath,
+        ".zcode",
+        "workflows",
+        validateWorkflowName(name) + ".dwf.ts",
+      );
+      const source = await readTextOrNull(path);
+      if (source === null) throw e;
+      return {
+        ...decode(source).meta,
+        script: decode(source).script,
+        source,
+        path,
+        name,
+        groupId,
+        workspacePath: this.group(groupId).workspacePath,
+      };
+    }
+  }
+  async save(name, source, groupId = "global", { overwrite = true } = {}) {
+    decode(source);
+    const path = this.path(name, groupId);
+    await fs.mkdir(this.group(groupId).path, { recursive: true });
+    if (!overwrite) await fs.writeFile(path, source, { flag: "wx" });
+    else {
+      const tmp = `${path}.${randomUUID()}.tmp`;
+      await fs.writeFile(tmp, source);
+      await fs.rename(tmp, path);
+    }
+    return this.get(name, groupId);
+  }
+  async move(name, from, to) {
+    if (from === to) return this.resolveEntry(name, from);
+    const entry = await this.resolveEntry(name, from);
+    const saved = await this.save(name, entry.source, to, { overwrite: false });
+    await fs.unlink(entry.path);
+    return saved;
+  }
+  async remove(name, groupId) {
+    const entry = await this.resolveEntry(name, groupId);
+    await fs.unlink(entry.path);
+  }
+}

package/lib/session-records.js

@@ -0,0 +1,54 @@
+/** Plugin-owned UI anchors must remain replayable even without this plugin. */
+export const WORKFLOW_RUN_RECORD = "plugin:dsh-workflow/run";
+
+export function workflowSessionTitle(name, time = Date.now()) {
+  const parts = new Intl.DateTimeFormat("en-GB", {
+    timeZone: "Asia/Shanghai",
+    year: "numeric", month: "2-digit", day: "2-digit",
+    hour: "2-digit", minute: "2-digit", second: "2-digit", hourCycle: "h23",
+  }).formatToParts(new Date(time));
+  const values = Object.fromEntries(parts.map(({ type, value }) => [type, value]));
+  const stamp = ["year", "month", "day", "hour", "minute", "second"].map((key) => values[key]).join("");
+  const label = typeof name === "string" && name.trim() ? name.trim() : "工作流";
+  return `${label}-${stamp}`;
+}
+
+export function workflowRunId(event) {
+  if (event?.type !== WORKFLOW_RUN_RECORD && event?.type !== "dsh-workflow/run") return undefined;
+  return typeof event.data?.runId === "string" && event.data.runId.length > 0
+    ? event.data.runId : undefined;
+}
+
+/** Offline repair: retain every sequence/data payload; only repair our own record envelope. */
+export function repairWorkflowSessionEvents(events, now = Date.now()) {
+  let changed = false;
+  const repaired = events.map((event) => {
+    if (!workflowRunId(event)) return event;
+    if (event.type === WORKFLOW_RUN_RECORD && event.ignorable === true) return event;
+    changed = true;
+    return { ...event, type: WORKFLOW_RUN_RECORD, ignorable: true };
+  });
+  const firstRun = repaired.find((event) => workflowRunId(event));
+  if (firstRun && !repaired.some((event) => event.type === "session/title")) {
+    repaired.push({
+      type: "session/title", seq: repaired.length, time: now,
+      data: { title: workflowSessionTitle(undefined, firstRun.time), messageSeqs: [], source: { kind: "user" } },
+    });
+    changed = true;
+  }
+  return { changed, events: repaired };
+}
+
+/** Resolve the host's module, not a bundled Session copy with different private fields. */
+export async function prepareWorkflowSession(ctx, session) {
+  const loader = ctx.get("loader");
+  const titles = ctx.get("sessionTitle");
+  if (!loader || !titles) throw new Error("工作流会话需要宿主 loader 和 sessionTitle 服务");
+  const { appendPluginRecord } = await loader.import("@deepseek-ai/dsh-session");
+  if (typeof appendPluginRecord !== "function") throw new Error("宿主不支持可重放的插件会话记录");
+  return (runId, startedAt, runName) => {
+    appendPluginRecord(session, WORKFLOW_RUN_RECORD, { runId });
+    // Only name an untitled workflow session; preserve an existing user title.
+    if (!titles.get(session)?.title) titles.rename(session, workflowSessionTitle(runName, startedAt));
+  };
+}

package/lib/submission-commit.js

@@ -0,0 +1,34 @@
+/** DSH can wrap tools in another transport. Commit only after every wrapper
+ * succeeds, using execution identity for staging and tokens for parent links. */
+export function submissionCommit(commit, onError) {
+  const staged = new Map(),
+    parents = new Map();
+  return {
+    stage(exec, value) {
+      staged.set(exec, value);
+    },
+    result(exec, result) {
+      const values = [
+        ...(parents.get(exec.token) ?? []),
+        ...(staged.has(exec) ? [staged.get(exec)] : []),
+      ];
+      staged.delete(exec);
+      parents.delete(exec.token);
+      if (result.isError || !values.length) return;
+      if (exec.parent !== undefined)
+        parents.set(exec.parent, [
+          ...(parents.get(exec.parent) ?? []),
+          ...values,
+        ]);
+      else
+        for (const value of values)
+          Promise.resolve()
+            .then(() => commit(value))
+            .catch(onError);
+    },
+    clear() {
+      staged.clear();
+      parents.clear();
+    },
+  };
+}

package/lib/world-driver.js

@@ -0,0 +1,275 @@
+import { spawn } from "node:child_process";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { executeWorldRead } from "../vendor/mcode-host/workflow-world-read.js";
+
+// MCode owns the operation schemas, Git parsing and result caps. This adapter
+// supplies only filesystem/process I/O and cancels the entire process group.
+export function createWorldDriver(cwd) {
+  const controller = new AbortController();
+  async function run({ command, timeoutMs = 300000, outputLimit = {} }) {
+    if (controller.signal.aborted) throw new Error("工作流已停止");
+    return new Promise((resolve) => {
+      const buffers = { stdout: [], stderr: [] },
+        sizes = { stdout: 0, stderr: 0 };
+      const cap = outputLimit.maxInlineBytes ?? 1024 * 1024;
+      let reason, error;
+      const child = spawn(command.file, command.args ?? [], {
+        cwd,
+        detached: process.platform !== "win32",
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+      const kill = () => {
+        try {
+          process.platform === "win32"
+            ? child.kill("SIGKILL")
+            : process.kill(-child.pid, "SIGKILL");
+        } catch {}
+      };
+      const abort = () => {
+        reason = "cancelled";
+        kill();
+      };
+      controller.signal.addEventListener("abort", abort, { once: true });
+      const timer = setTimeout(() => {
+        reason = "timed_out";
+        kill();
+      }, timeoutMs);
+      for (const stream of ["stdout", "stderr"])
+        child[stream].on("data", (chunk) => {
+          const remaining = cap + 1 - sizes[stream];
+          if (remaining > 0) buffers[stream].push(chunk.subarray(0, remaining));
+          sizes[stream] += chunk.length;
+          if (sizes[stream] > cap) kill();
+        });
+      child.on("error", (e) => {
+        error = { message: e.message };
+      });
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        controller.signal.removeEventListener("abort", abort);
+        const result = {
+          status:
+            reason ??
+            (error ? "spawn_error" : code === 0 ? "completed" : "failed"),
+          exitCode: code,
+          error,
+        };
+        for (const stream of ["stdout", "stderr"])
+          result[stream] = {
+            text: Buffer.concat(buffers[stream]).toString("utf8"),
+            bytes: sizes[stream],
+            truncated: sizes[stream] > cap,
+          };
+        resolve(result);
+      });
+    });
+  }
+  // Ripgrep may not be installed on the host. Probe once; when it is missing,
+  // fall back to a pure-Node walker that keeps the same result shape.
+  let rgAvailable;
+  const hasRg = async () => {
+    if (rgAvailable === undefined) {
+      const probe = await run({
+        command: { file: "rg", args: ["--version"] },
+        outputLimit: { maxInlineBytes: 4096 },
+      });
+      rgAvailable = probe.status === "completed";
+    }
+    return rgAvailable;
+  };
+  const rgArgs = [
+    "--hidden",
+    "-g",
+    "!.git",
+    "-g",
+    "!node_modules",
+  ];
+  const rg = async (args) => {
+    const result = await run({
+      command: { file: "rg", args },
+      outputLimit: { maxInlineBytes: 4 * 1024 * 1024 },
+    });
+    if (
+      !["completed", "failed"].includes(result.status) ||
+      (result.exitCode !== 0 && result.exitCode !== 1)
+    )
+      throw new Error(
+        result.stderr.text || result.error?.message || "文件搜索失败",
+      );
+    return result;
+  };
+  const GLOB_SKIP = new Set([".git", "node_modules"]);
+  const SCAN_FILE_CAP = 20000;
+  const SCAN_BYTES_PER_FILE = 8 * 1024 * 1024;
+  function globToRegExp(pattern) {
+    let re = "";
+    for (let i = 0; i < pattern.length; i++) {
+      const c = pattern[i];
+      if (c === "*") {
+        if (pattern[i + 1] === "*") {
+          i++;
+          if (pattern[i + 1] === "/") {
+            i++;
+            re += "(?:.*/)?";
+          } else re += ".*";
+        } else re += "[^/]*";
+      } else if (c === "?") re += "[^/]";
+      else re += c.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+    }
+    return new RegExp(`^${re}$`);
+  }
+  function matchGlob(pattern, rel) {
+    const re = globToRegExp(pattern);
+    if (re.test(rel)) return true;
+    if (!pattern.includes("/")) {
+      const base = rel.split("/").pop();
+      if (base !== undefined && re.test(base)) return true;
+    }
+    return false;
+  }
+  async function* walk(dir, rel = "") {
+    let entries;
+    try {
+      entries = await fs.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (GLOB_SKIP.has(entry.name)) continue;
+      const r = rel ? `${rel}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) yield* walk(path.join(dir, entry.name), r);
+      else if (entry.isFile()) yield { abs: path.join(dir, entry.name), rel: r };
+    }
+  }
+  async function searchFilesNative({ pattern, maxResults }) {
+    const re = globToRegExp(pattern);
+    const files = [];
+    let scanned = 0;
+    let truncated = false;
+    for await (const f of walk(cwd)) {
+      if (matchGlob(pattern, f.rel)) {
+        files.push(path.resolve(cwd, f.rel));
+        if (files.length > maxResults) {
+          truncated = true;
+          break;
+        }
+      }
+      if (++scanned >= SCAN_FILE_CAP) {
+        truncated = true;
+        break;
+      }
+    }
+    return { files, truncated };
+  }
+  async function searchTextNative({ pattern, glob, headLimit }) {
+    let re;
+    try {
+      re = new RegExp(pattern);
+    } catch {
+      re = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+    }
+    const entries = [];
+    let truncated = false;
+    let scanned = 0;
+    for await (const f of walk(cwd)) {
+      if (glob && !matchGlob(glob, f.rel)) continue;
+      if (++scanned >= SCAN_FILE_CAP) {
+        truncated = true;
+        break;
+      }
+      let content;
+      try {
+        const handle = await fs.open(f.abs, "r");
+        try {
+          const buffer = Buffer.alloc(SCAN_BYTES_PER_FILE);
+          const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+          content = buffer.subarray(0, bytesRead).toString("utf8");
+        } finally {
+          await handle.close();
+        }
+      } catch {
+        continue;
+      }
+      const lines = content.split("\n");
+      if (lines.length > 1) lines.pop(); // trailing newline
+      for (let i = 0; i < lines.length; i++) {
+        if (re.test(lines[i])) {
+          entries.push({
+            path: path.resolve(cwd, f.rel),
+            lineNumber: i + 1,
+            text: lines[i],
+          });
+          if (entries.length > headLimit) {
+            return { entries, truncated: true };
+          }
+        }
+      }
+    }
+    return { entries, truncated };
+  }
+  const deps = {
+    cwd,
+    executionPort: { run },
+    fileSystemPort: {
+      async readTextFile({ path: file }) {
+        return { content: await fs.readFile(file, "utf8") };
+      },
+      async searchFiles({ pattern, maxResults }) {
+        if (!(await hasRg()))
+          return searchFilesNative({ pattern, maxResults });
+        const r = await rg([
+          "--files",
+          "--hidden",
+          "-g",
+          "!.git",
+          "-g",
+          pattern,
+          "-0",
+          ".",
+        ]);
+        const all = r.stdout.text.split("\0").filter(Boolean);
+        return {
+          files: all.slice(0, maxResults).map((p) => path.resolve(cwd, p)),
+          truncated: all.length > maxResults || r.stdout.truncated,
+        };
+      },
+      async searchText({ pattern, glob, headLimit }) {
+        if (!(await hasRg()))
+          return searchTextNative({ pattern, glob, headLimit });
+        const r = await rg([
+          "--json",
+          ...rgArgs,
+          ...(glob ? ["-g", glob] : []),
+          "--",
+          pattern,
+          ".",
+        ]);
+        const entries = [];
+        for (const line of r.stdout.text.split("\n")) {
+          if (!line) continue;
+          let event;
+          try {
+            event = JSON.parse(line);
+          } catch {
+            continue;
+          }
+          if (event.type === "match")
+            entries.push({
+              path: path.resolve(cwd, event.data.path.text),
+              lineNumber: event.data.line_number,
+              text: event.data.lines.text.replace(/\r?\n$/, ""),
+            });
+        }
+        return {
+          entries: entries.slice(0, headLimit),
+          truncated: entries.length > headLimit || r.stdout.truncated,
+        };
+      },
+    },
+  };
+  return {
+    execute: (op, args) => executeWorldRead(deps, op, args),
+    dispose: () => controller.abort(),
+  };
+}

package/package.json

@@ -1,6 +1,69 @@
 {
   "name": "@sunshaobei/dsh-workflow",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "description": "MCode workflow UI and runtime integration for DSH",
+  "version": "2.1.2",
+  "type": "module",
+  "main": "./lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "vendor",
+    "cordis.patch.yml",
+    "README.md"
+  ],
+  "dependencies": {
+    "react-markdown": "^10.1.0",
+    "remark-gfm": "^4.0.1",
+    "typescript": "^5.9.3",
+    "yaml": "^2.8.1"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-workspace",
+        "@deepseek-ai/dsh-client-ui-sidebar-right",
+        "@deepseek-ai/dsh-client-ui-tool",
+        "@deepseek-ai/dsh-client-ui-chat"
+      ],
+      "immediately": true
+    }
+  },
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "workflow",
+    "subagents",
+    "dynamic-workflow"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@deepseek-ai/dsh-llm": "0.2.1-rc.2",
+    "@deepseek-ai/dsh-tools": "0.2.1-rc.2",
+    "@deepseek-ai/schemastery": "~3.18.5"
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "test": "node --test tests/*.test.mjs",
+    "preview": "node scripts/preview.mjs",
+    "test:engine": "node scripts/selftest.mjs"
+  },
+  "devDependencies": {
+    "esbuild": "^0.25.0",
+    "jsdom": "^26.1.0",
+    "prettier": "^3.9.10",
+    "react": "^19.3.1",
+    "react-dom": "^19.3.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/vendor/PROVENANCE.md

@@ -0,0 +1,9 @@
+# Source provenance
+
+Reference checkout: `<本地 MCode 检出>`, inspected HEAD `434fd17661f14b9421b4acaf1a185616be275cfb`.
+
+- `dynamic-workflow/`: compiled MCode compiler, analyzer, schema, facade and engine.
+- `dynamic-workflow-runtime/`: transpiled runtime; relative imports, `.dsh` script directory, temporary prefix and Electron Node environment adapted.
+- `mcode-host/`: bootstrap `workflow-world-read.ts`, `workflow-git-world-read.ts`, `dynamic-workflow-import.ts`; runtime imports adapted and terminal status set inlined.
+
+DSH filesystem, process, storage and session adapters live in `lib/`. Vendor files are not reformatted with plugin sources.