@sakki_chin/dsh-codex-orchestrate 1.0.0

package/server/persistence.test.cjs

@@ -0,0 +1,175 @@
+/* eslint-disable no-console */
+'use strict';
+/* persistence.test.cjs — 落盘与跨重启回读
+ *
+ * 复现的原始缺陷：workflow 只活在进程内存，进程重启后
+ * `/api/state?workflowId=` 返回「workflow 不存在」，调用者无法区分
+ * 「没派发过」和「派发过但被重启清掉了」。 */
+const assert = require('node:assert');
+const { mkdtempSync, rmSync, writeFileSync, readFileSync } = require('node:fs');
+const { tmpdir } = require('node:os');
+const { join } = require('node:path');
+const { Orchestrator } = require('./orchestrator.js');
+const { Persistence } = require('./persistence.js');
+
+const tmp = () => mkdtempSync(join(tmpdir(), 'codex-persist-'));
+const sleep = ms => new Promise(done => setTimeout(done, ms));
+const YAML = [
+  'apiVersion: codex.dsh/v1', 'kind: workflow', 'title: 落盘验证', 'concurrency: 2',
+  'nodes:', '  - id: a', '    title: A', '    prompt: 正常', '  - id: b', '    title: B',
+  '    prompt: 正常', '    dependsOn: [a]', '',
+].join('\n');
+
+function runner() {
+  return {
+    defaultModel: 'gpt-test',
+    async run(def, cb) {
+      cb.onSessionId('sess_' + def.id);
+      cb.onItem({ type: 'agent_message', id: 'item_0', text: `done ${def.id}` });
+      return { status: 'completed', finalMessage: `最终 ${def.id}`, usage: { input_tokens: 7, output_tokens: 3 } };
+    },
+  };
+}
+
+async function waitState(orch, id, want) {
+  for (let i = 0; i < 200; i++) {
+    const snap = orch.snapshot(id);
+    if (snap && snap.state === want) return snap;
+    await sleep(10);
+  }
+  throw new Error(`超时未达到 ${want}`);
+}
+
+(async () => {
+  const dir = tmp();
+  const file = join(dir, 'workflows.jsonl');
+  try {
+    /* 1. 终态落盘 → 新实例（模拟重启）能查到 */
+    {
+      const first = new Orchestrator(runner(), { persistFile: file });
+      const { workflowId } = first.dispatch(YAML, { defaultCwd: '/workspace/persisted-project' });
+      await waitState(first, workflowId, 'completed');
+      assert.ok(first.snapshot(workflowId).nodes.every(n => n.status === 'completed'));
+
+      /* 全新实例 = 进程重启：内存为空，必须靠磁盘回读 */
+      const second = new Orchestrator(runner(), { persistFile: file });
+      const snap = second.snapshot(workflowId);
+      assert.ok(snap, '重启后应能从磁盘查到 workflow');
+      assert.strictEqual(snap.title, '落盘验证');
+      assert.strictEqual(snap.state, 'completed');
+      const a = snap.nodes.find(n => n.id === 'a');
+      assert.strictEqual(a.status, 'completed');
+      assert.strictEqual(a.finalMessage, '最终 a', 'finalMessage 必须跨重启保留');
+      assert.deepStrictEqual(a.usage, { input_tokens: 7, output_tokens: 3 }, 'usage 必须跨重启保留');
+      assert.deepStrictEqual(a.dependsOn, [], '扁平回读也要还原 dependsOn');
+      assert.strictEqual(a.turns.length, 1, '每轮对话必须跨重启保留');
+      assert.strictEqual(a.turns[0].input, '正常');
+      assert.strictEqual(a.cwd, '/workspace/persisted-project', '继承的会话 cwd 必须跨重启保留');
+      assert.strictEqual(snap.cwd, '/workspace/persisted-project', 'workflow cwd 必须跨重启保留');
+      assert.ok(a.turns[0].items.some(item => item.type === 'agent_message'));
+      console.log('✓ 终态落盘，重启后可查（含 finalMessage / usage）');
+    }
+
+    /* 2. list() 重启后也能看到历史 */
+    {
+      const third = new Orchestrator(runner(), { persistFile: file });
+      const list = third.list();
+      assert.ok(list.length >= 1, 'list() 应包含磁盘历史');
+      assert.ok(list.every(w => w.workflowId && typeof w.state === 'string'));
+      console.log('✓ list() 重启后包含磁盘历史');
+    }
+
+    /* 3. nodePatch 对「重启前创建的 workflow」仍可用 */
+    {
+      const fresh = new Orchestrator(runner(), { persistFile: file });
+      const known = fresh.list()[0].workflowId;
+      const patch = [
+        'apiVersion: codex.dsh/v1', 'kind: nodePatch', `workflowId: ${known}`,
+        'nodes:', '  - id: c', '    title: C', '    prompt: 正常', '',
+      ].join('\n');
+      const res = fresh.dispatch(patch);
+      assert.deepStrictEqual(res.created, ['c'], '重启后仍能向历史 workflow 追加节点');
+      console.log('✓ 重启后 nodePatch 仍可用');
+    }
+
+    /* 4. 半行 / 损坏行不让整个历史失效 */
+    {
+      const broken = join(tmp(), 'broken.jsonl');
+      const ok = new Orchestrator(runner(), { persistFile: broken });
+      const { workflowId } = ok.dispatch(YAML);
+      await waitState(ok, workflowId, 'completed');
+      writeFileSync(broken, readFileSync(broken, 'utf8') + '{"type":"node","workflowId":"wf_x",\n');
+      const after = new Orchestrator(runner(), { persistFile: broken });
+      assert.ok(after.snapshot(workflowId), '截断行不应让已写入的历史不可读');
+      console.log('✓ 截断行被跳过，历史仍可读');
+    }
+
+    /* 5. 写入失败不打断编排（目录不可写） */
+    {
+      const ro = new Orchestrator(runner(), { persistFile: '/proc/definitely/not/writable/x.jsonl' });
+      const { workflowId } = ro.dispatch(YAML);
+      const snap = await waitState(ro, workflowId, 'completed');
+      assert.strictEqual(snap.state, 'completed', '落盘失败也必须正常跑完');
+      console.log('✓ 落盘失败不影响工作流执行');
+    }
+
+    /* 6. persist:false 完全不落盘（测试隔离所依赖的行为） */
+    {
+      const off = new Orchestrator(runner(), { persist: false });
+      const { workflowId } = off.dispatch(YAML);
+      await waitState(off, workflowId, 'completed');
+      assert.strictEqual(off.persistence.enabled, false);
+      assert.strictEqual(off.list().length, 1, '关盘时不应读入任何历史');
+      console.log('✓ persist:false 完全关盘');
+    }
+
+    /* 7. Persistence 单元：损坏行 / 无 workflow 的 node 行 */
+    {
+      const p = new Persistence(file);
+      const loaded = p.load();
+      assert.ok(loaded instanceof Map);
+      const lines = readFileSync(file, 'utf8').trim().split('\n').map(l => JSON.parse(l));
+      assert.ok(lines.some(l => l.type === 'workflow' && l.workflowId));
+      assert.ok(lines.some(l => l.type === 'node' && l.node?.id));
+      console.log('✓ Persistence.load() 结构与内容正确');
+    }
+
+    /* 8. 删除节点写入墓碑，重启后不得被更早的 node 记录复活 */
+    {
+      let releaseRoot;
+      const gated = {
+        defaultModel: 'gpt-test',
+        async run(def, cb) {
+          cb.onSessionId('sess_' + def.id);
+          if (def.id !== 'root') return { status: 'completed', finalMessage: 'done' };
+          return new Promise(resolve => {
+            releaseRoot = () => resolve({ status: 'completed', finalMessage: 'done root' });
+          });
+        },
+      };
+      const tombstoneFile = join(dir, 'tombstones.jsonl');
+      const first = new Orchestrator(gated, { persistFile: tombstoneFile });
+      const { workflowId } = first.dispatch([
+        'apiVersion: codex.dsh/v1', 'kind: workflow', 'title: 删除落盘', 'concurrency: 1',
+        'nodes:', '  - id: root', '    prompt: root', '  - id: future', '    prompt: future',
+        '    dependsOn: [root]', '',
+      ].join('\n'));
+      const result = first.dispatch([
+        'apiVersion: codex.dsh/v1', 'kind: nodePatch', `workflowId: ${workflowId}`,
+        'remove: [future]', '',
+      ].join('\n'));
+      assert.deepStrictEqual(result.deleted, ['future']);
+      releaseRoot();
+      await waitState(first, workflowId, 'completed');
+
+      const restarted = new Orchestrator(runner(), { persistFile: tombstoneFile });
+      assert.deepStrictEqual(restarted.snapshot(workflowId).nodes.map(n => n.id), ['root']);
+      assert.ok(readFileSync(tombstoneFile, 'utf8').includes('nodeDelete'));
+      console.log('✓ 节点删除墓碑跨重启生效');
+    }
+
+    console.log('\n落盘测试全部通过');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+})().catch(error => { console.error(error); process.exit(1); });

package/server/plugin.mjs

@@ -0,0 +1,312 @@
+/* ============================================================
+ * plugin.mjs — DSH 插件：codex_orchestrate
+ * - ctx.tools.register(defineTool(...))：暴露 codex_orchestrate tool
+ *   （入参 = workflow YAML 文本；增量派发；异步 + 进度可查）
+ * - ctx.webServer.register：
+ *     POST /codex-orchestrate/api/dispatch   { yaml }        → tool 同款入口
+ *     GET  /codex-orchestrate/api/workflows                  → 工作流清单（UI 自动发现最新）
+ *     GET  /codex-orchestrate/api/state?workflowId=          → 进度快照
+ *     POST /codex-orchestrate/api/message   { workflowId, nodeId, text } → 续接节点会话
+ *     POST /codex-orchestrate/api/cancel     { workflowId, nodeId }
+ *     GET  /codex-orchestrate/api/events?workflowId=         → SSE 事件流
+ *     /codex-orchestrate/*                    → 本目录静态 UI
+ * 无硬依赖：不 import @deepseek-ai/dsh-tools（桌面端 profile 无法解析它），
+ * 本地等价构建 defineTool 的 registry-ready 对象（纯 JSON Schema + 校验包装）。
+ * 运行模式：真实 @openai/codex-sdk 链路。
+ * ============================================================ */
+import { dirname, join, resolve, isAbsolute } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { Orchestrator, SCHEMA } = require('./orchestrator.js');
+const { parseWorkflowYaml } = require('./validate.js');
+const { createRunner } = require('./codex-runner.js');
+const { DEFAULT_MODEL, authState } = require('./defaults.js');
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+
+/* 本地 defineTool：与 @deepseek-ai/dsh-tools 的 registry-ready 输出等价 */
+function defineTool({ name, description, parameters, output, execute }) {
+  return {
+    name,
+    description,
+    parameters: {
+      type: 'object',
+      properties: Object.fromEntries(
+        Object.entries(parameters).map(([key, spec]) => {
+          const { required: _flag, ...schema } = spec;
+          return [key, schema];
+        })
+      ),
+      required: Object.entries(parameters).filter(([, spec]) => spec.required).map(([key]) => key),
+      additionalProperties: false,
+    },
+    output: { schema: output.schema, render: output.render },
+    async execute(args, exec) {
+      if (typeof args?.yaml !== 'string' || !args.yaml.trim()) {
+        throw new Error('codex_orchestrate 参数错误：yaml 必须为非空字符串');
+      }
+      return execute(args, exec);
+    },
+  };
+}
+
+/* ToolRunContext 携带发起会话的权威 cwd；不要回退宿主 Electron 进程目录。 */
+export function executionCwd(exec) {
+  const cwd = exec?.agent?.session?.header?.cwd;
+  return typeof cwd === 'string' && isAbsolute(cwd) ? cwd : null;
+}
+
+export const name = 'codex-orchestrate';
+export const inject = ['tools', 'webServer'];
+
+let orchestrator = null;
+let runnerInfo = null;       // createRunner() 的能力声明：缺省模型 + 登录态（只读探测）
+const eventLogs = new Map(); // workflowId -> events[]（SSE 补发用）
+
+async function ensureOrchestrator() {
+  if (orchestrator) return orchestrator;
+  const runner = await createRunner();
+  runnerInfo = { defaultModel: runner.defaultModel, auth: runner.auth };
+  orchestrator = new Orchestrator(runner, { persistFile: stateFile() });
+  orchestrator.on(event => {
+    const log = eventLogs.get(event.workflowId) || [];
+    log.push({ ...event, timestamp: new Date().toISOString() });
+    eventLogs.set(event.workflowId, log);
+  });
+  return orchestrator;
+}
+
+/* 只读查询用的同步 getter：不构造 runner（那要碰 codex 登录态/依赖），
+ * 只建一个空 Orchestrator 以便从磁盘回读历史。
+ * 没有它的话，进程刚重启、还没派发过任何东西时 orchestrator 仍是 null，
+ * 查询接口会短路成「空列表 / workflow 不存在」——正是要修的那个 bug。 */
+let readonlyOrchestrator = null;
+function queryOrchestrator() {
+  if (orchestrator) return orchestrator;
+  if (!readonlyOrchestrator) {
+    readonlyOrchestrator = new Orchestrator(
+      { defaultModel: DEFAULT_MODEL, async run() { throw new Error('只读实例不执行节点'); } },
+      { persistFile: stateFile() }
+    );
+  }
+  return readonlyOrchestrator;
+}
+
+/* workflow 状态落盘位置：放在 DSH_HOME 隔离目录下，进程重启后历史仍可查。
+ * 注意 DSH_HOME 本身已经是 <project>/.runtime/codex-orchestrate
+ * （见 start-codex-orchestrate.mjs），所以这里**不再**拼 'codex-orchestrate'，
+ * 否则会多一层变成 …/codex-orchestrate/codex-orchestrate。 */
+function stateFile() {
+  const dir = process.env.DSH_CODEX_STATE_DIR
+    || process.env.DSH_HOME
+    || join(root, '.runtime', 'codex-orchestrate');
+  return join(dir, 'workflows.jsonl');
+}
+
+/** 模型 / 登录态事实：派发前就能回答「谁在授权、缺省用哪个模型」。 */
+function runtimeStatus() {
+  return {
+    mode: 'real',
+    defaultModel: runnerInfo?.defaultModel ?? DEFAULT_MODEL,
+    auth: runnerInfo?.auth ?? authState(),
+    authEnvOverride: Boolean(process.env.DSH_CODEX_MODEL),
+    instance: instanceIdentity(),
+  };
+}
+
+/* 本进程的对外身份：派发结果必须能定位到「哪个实例、哪个端口」。
+ * 没有这个字段时，调用者拿到裸路径只能靠猜端口——真实踩过这个坑。 */
+const startedAt = new Date().toISOString();
+const instanceId = `co_${process.pid}_${Math.random().toString(16).slice(2, 10)}`;
+
+function listeningOrigin() {
+  /* 优先用启动参数里的 --host/--port（webServer 不一定暴露自身地址） */
+  const argv = process.argv;
+  const portFlag = argv.indexOf('--port');
+  const hostFlag = argv.indexOf('--host');
+  const port = portFlag >= 0 ? argv[portFlag + 1] : null;
+  const host = hostFlag >= 0 ? argv[hostFlag + 1] : '127.0.0.1';
+  if (port) return `http://${host === '0.0.0.0' ? '127.0.0.1' : host}:${port}`;
+  return process.env.DSH_PUBLIC_ORIGIN || null;
+}
+
+function progressUrl(workflowId) {
+  const origin = listeningOrigin();
+  const path = `/codex-orchestrate/api/state?workflowId=${workflowId}`;
+  return origin ? origin + path : path;
+}
+
+function instanceIdentity() {
+  return {
+    instanceId,
+    pid: process.pid,
+    origin: listeningOrigin(),
+    startedAt,
+    /* 帮助调用者识别「我查的是不是派发我的那个实例」：
+     * 与本实例 startedAt 不符 = 进程重启过，内存态已丢失（磁盘历史仍可查）。
+     * 这里直接算路径，不读 orchestrator —— /api/status 会在派发前被调用，
+     * 那时 orchestrator 还是 null，之前会错误地回传 stateFile: null。 */
+    stateFile: stateFile(),
+  };
+}
+
+function publicResult(result, orch = orchestrator) {
+  if (result.operation === 'query') {
+    return {
+      ...result,
+      mode: 'real',
+      defaultModel: runnerInfo?.defaultModel ?? DEFAULT_MODEL,
+      auth: runnerInfo?.auth ?? authState(),
+      instance: instanceIdentity(),
+    };
+  }
+  const nodes = orch.snapshot(result.workflowId)?.nodes
+    .map(({ id, title, status, dependsOn, sessionId, error, model, cwd }) => ({ id, title, status, dependsOn, sessionId, error, model, cwd })) || [];
+  return {
+    ...result,
+    nodes,
+    mode: 'real',
+    defaultModel: runnerInfo?.defaultModel ?? DEFAULT_MODEL,
+    auth: runnerInfo?.auth ?? authState(),
+    note: '已异步派发到真实 codex（@openai/codex-sdk），认证复用本机 codex 登录态。',
+    /* progressUrl 是**绝对地址**，可直接 GET；progress 保留相对路径兼容旧调用方。 */
+    progress: `/codex-orchestrate/api/state?workflowId=${result.workflowId}`,
+    progressUrl: progressUrl(result.workflowId),
+    instance: instanceIdentity(),
+    report: '工作流结束后，通过 progressUrl 获取各节点 finalMessage 与 usage 汇总。',
+  };
+}
+
+/* query 不需要初始化 Codex SDK；create/update/delete 才需要 runner。
+ * 在工具边界只做一次轻量分类，权威校验仍由 Orchestrator.dispatch 完成。 */
+async function executeYaml(yaml, { defaultCwd = null } = {}) {
+  const kind = parseWorkflowYaml(yaml, SCHEMA, { allowExternalDeps: true }).kind;
+  const orch = kind === 'workflowQuery' ? queryOrchestrator() : await ensureOrchestrator();
+  return publicResult(orch.dispatch(yaml, { defaultCwd }), orch);
+}
+
+export function apply(ctx) {
+  /* ---------------- codex_orchestrate tool ---------------- */
+  ctx.tools.register(defineTool({
+    name: 'codex_orchestrate',
+    description:
+      '按 YAML schema 创建、查询和动态修改 codex 工作流。kind=workflow 创建；kind=workflowQuery 查询单个工作流或清单；'
+      + 'kind=nodePatch 可在运行中通过 nodes 新增/更新未来节点，并通过 remove 真正删除未来节点。'
+      + 'running、completed、failed、cancelled 节点不可修改或删除；补丁会校验最终 DAG，并以原子方式整包提交或拒绝。'
+      + '每个节点是一个独立 codex session，按 dependsOn 依赖调度、并发执行。'
+      + '下游首轮会自动获得直接依赖节点的终态结果；未写 cwd 的节点继承当前 DSH 会话工作目录；'
+      + 'sandboxMode 缺省为 danger-full-access，也可由 DSH 在节点 YAML 中覆盖。'
+      + '调用立即返回 workflowId 与进度接口；结果异步推进，可随时查询。'
+      + 'YAML 格式见 /codex-orchestrate/schema/workflow.schema.md。',
+    parameters: {
+      yaml: { type: 'string', required: true, description: 'workflow YAML 文档（apiVersion: codex.dsh/v1）' },
+    },
+    output: {
+      schema: { type: 'object' },
+      render: (_args, value) => [{ type: 'text', text: JSON.stringify(value, null, 2) }],
+    },
+    async execute(args, exec) {
+      try {
+        return await executeYaml(args.yaml, { defaultCwd: executionCwd(exec) });
+      } catch (error) {
+        throw new Error(`codex_orchestrate 操作被拒绝：${error.message}`);
+      }
+    },
+  }));
+
+  /* ---------------- HTTP ---------------- */
+  const sendJson = (res, code, data) => {
+    res.writeHead(code, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
+    res.end(JSON.stringify(data));
+  };
+  const readBody = async (req, limit = 262144) => {
+    let body = '';
+    for await (const chunk of req) { body += chunk; if (body.length > limit) throw new Error('Request too large'); }
+    return JSON.parse(body);
+  };
+  const sameOrigin = req => !req.headers.origin || new URL(req.headers.origin).host === req.headers.host;
+
+  ctx.webServer.register({ kind: 'exact', path: '/codex-orchestrate/api/dispatch', async handler(req, res) {
+    if (req.method !== 'POST') return sendJson(res, 405, { error: 'POST required' });
+    try {
+      if (!sameOrigin(req)) return sendJson(res, 403, { error: 'Same-origin only' });
+      const input = await readBody(req);
+      if (typeof input.yaml !== 'string' || !input.yaml.trim()) throw new Error('yaml required');
+      sendJson(res, 200, await executeYaml(input.yaml));
+    } catch (error) { sendJson(res, 400, { error: error.message }); }
+  } });
+
+  ctx.webServer.register({ kind: 'exact', path: '/codex-orchestrate/api/workflows', async handler(req, res) {
+    sendJson(res, 200, {
+      /* 用 queryOrchestrator()：进程重启后即便还没派发过，也要能从磁盘列出历史 */
+      workflows: queryOrchestrator().list(),
+      mode: 'real',
+      instance: instanceIdentity(),
+    });
+  } });
+
+  /* 只读状态：缺省模型 + 当前 codex 登录态（不触发 codex 构造，未派发也能看） */
+  ctx.webServer.register({ kind: 'exact', path: '/codex-orchestrate/api/status', async handler(req, res) {
+    sendJson(res, 200, runtimeStatus());
+  } });
+
+  ctx.webServer.register({ kind: 'exact', path: '/codex-orchestrate/api/state', async handler(req, res) {
+    const workflowId = new URL(req.url, 'http://127.0.0.1').searchParams.get('workflowId');
+    /* queryOrchestrator() 而非 orchestrator?.：重启后未派发时也要能查到磁盘历史 */
+    const orch = queryOrchestrator();
+    const snap = orch.snapshot(workflowId);
+    /* 404 必须自带可诊断信息：调用者要能分辨「没派发过」和「查错了实例」。
+     * 之前只回一句 "workflow 不存在"，导致把一个正常的跨实例查询误判成链路故障。 */
+    if (!snap) return sendJson(res, 404, {
+      error: 'workflow 不存在',
+      workflowId: workflowId || null,
+      instance: instanceIdentity(),
+      known: orch.list().map(w => w.workflowId),
+      hint: '确认 host:port 是否为本实例的 origin；历史 workflow 由磁盘回读，若仍缺失说明该实例从未派发过它。',
+    });
+    sendJson(res, 200, { ...snap, mode: 'real', instance: instanceIdentity(), events: eventLogs.get(workflowId) || [] });
+  } });
+
+  ctx.webServer.register({ kind: 'exact', path: '/codex-orchestrate/api/message', async handler(req, res) {
+    if (req.method !== 'POST') return sendJson(res, 405, { error: 'POST required' });
+    try {
+      if (!sameOrigin(req)) return sendJson(res, 403, { error: 'Same-origin only' });
+      const input = await readBody(req);
+      if (typeof input.workflowId !== 'string' || typeof input.nodeId !== 'string') {
+        throw new Error('workflowId 与 nodeId 必填');
+      }
+      if (typeof input.text !== 'string') throw new Error('text 必须为字符串');
+      const orch = await ensureOrchestrator();
+      const result = orch.sendMessage(input.workflowId, input.nodeId, input.text, {
+        clientMessageId: typeof input.clientMessageId === 'string' ? input.clientMessageId : null,
+      });
+      sendJson(res, result.duplicate ? 200 : 202, result);
+    } catch (error) { sendJson(res, error.statusCode || 400, { error: error.message }); }
+  } });
+
+  ctx.webServer.register({ kind: 'exact', path: '/codex-orchestrate/api/cancel', async handler(req, res) {
+    if (req.method !== 'POST') return sendJson(res, 405, { error: 'POST required' });
+    try {
+      if (!sameOrigin(req)) return sendJson(res, 403, { error: 'Same-origin only' });
+      const input = await readBody(req);
+      orchestrator.cancelNode(input.workflowId, input.nodeId);
+      sendJson(res, 200, { cancelled: true });
+    } catch (error) { sendJson(res, 400, { error: error.message }); }
+  } });
+
+  /* ---------------- SSE 进度流 ---------------- */
+  ctx.webServer.register({ kind: 'exact', path: '/codex-orchestrate/api/events', async handler(req, res) {
+    const workflowId = new URL(req.url, 'http://127.0.0.1').searchParams.get('workflowId');
+    if (!orchestrator || !orchestrator.snapshot(workflowId)) return sendJson(res, 404, { error: 'workflow 不存在' });
+    res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-store', connection: 'keep-alive' });
+    for (const event of eventLogs.get(workflowId) || []) res.write(`data: ${JSON.stringify(event)}\n\n`);
+    const off = orchestrator.on(event => { if (event.workflowId === workflowId) res.write(`data: ${JSON.stringify(event)}\n\n`); });
+    const ping = setInterval(() => res.write(': ping\n\n'), 15000);
+    req.on('close', () => { clearInterval(ping); off(); });
+  } });
+
+  /* 工作台 UI 已迁移为 dsh.client 原生 React 插件（右侧栏 tab）。
+   * 旧的 index.html / app.js / styles.css / native-strip.js 静态页与注入脚本已删除，
+   * 因此这里不再注册 /codex-orchestrate 静态路由。 */
+}

package/server/plugin.test.cjs

@@ -0,0 +1,181 @@
+/* eslint-disable no-console */
+/* plugin.mjs 的接线测试：tool 注册、HTTP 路由表、清单接口的默认响应。
+ * 不触发真实 codex（ensureOrchestrator 只在 dispatch 时才构造 runner）。 */
+'use strict';
+const assert = require('node:assert');
+const { join } = require('node:path');
+
+const fakeResponse = () => ({
+  status: 0, headers: null, body: '',
+  writeHead(status, headers) { this.status = status; this.headers = headers; },
+  end(chunk = '') { this.body += chunk; },
+});
+
+(async () => {
+  const plugin = await import('./plugin.mjs');
+
+  const tools = [];
+  const routes = [];
+  const hooks = [];
+  plugin.apply({
+    tools: { register: tool => tools.push(tool) },
+    webServer: { register: route => routes.push(route) },
+    on: (name, handler) => hooks.push({ name, handler }),
+  });
+
+  /* 1. tool 定义 */
+  {
+    const tool = tools.find(t => t.name === 'codex_orchestrate');
+    assert.ok(tool, '缺少 codex_orchestrate tool');
+    assert.deepStrictEqual(tool.parameters.required, ['yaml']);
+    assert.strictEqual(tool.parameters.additionalProperties, false);
+    await assert.rejects(() => tool.execute({ yaml: '  ' }), /yaml 必须为非空字符串/);
+    assert.strictEqual(
+      plugin.executionCwd({ agent: { session: { header: { cwd: '/workspace/from-session' } } } }),
+      '/workspace/from-session',
+      '工具应读取发起会话 header.cwd'
+    );
+    assert.strictEqual(plugin.executionCwd({}), null, '缺少会话 cwd 时不得伪造宿主目录');
+    assert.match(tool.description, /新增\/更新未来节点/);
+    assert.match(tool.description, /remove 真正删除/);
+    const queried = await tool.execute({ yaml: 'apiVersion: codex.dsh/v1\nkind: workflowQuery' });
+    assert.strictEqual(queried.operation, 'query');
+    assert.ok(Array.isArray(queried.workflows));
+    console.log('✓ tool 注册与入参校验');
+  }
+
+  /* 2. HTTP 路由表（原生 React 插件的数据源；静态 UI 已随旧工作台删除） */
+  {
+    for (const path of [
+      '/codex-orchestrate/api/dispatch',
+      '/codex-orchestrate/api/workflows',
+      '/codex-orchestrate/api/status',
+      '/codex-orchestrate/api/state',
+      '/codex-orchestrate/api/message',
+      '/codex-orchestrate/api/cancel',
+      '/codex-orchestrate/api/events',
+    ]) assert.ok(routes.some(r => r.path === path), `缺少路由 ${path}`);
+    assert.ok(
+      !routes.some(r => r.path === '/codex-orchestrate'),
+      '旧静态 UI 路由应已删除（工作台已迁移为 dsh.client 客户端插件）',
+    );
+    console.log('✓ HTTP 路由表完整（且旧静态路由已移除）');
+  }
+
+  /* 3. 尚未派发时清单为空（UI 空态而非报错） */
+  {
+    const route = routes.find(r => r.path === '/codex-orchestrate/api/workflows');
+    const res = fakeResponse();
+    await route.handler({ method: 'GET', url: '/codex-orchestrate/api/workflows', headers: {} }, res);
+    assert.strictEqual(res.status, 200);
+    const listBody = JSON.parse(res.body);
+    assert.deepStrictEqual(listBody.workflows, []);
+    assert.strictEqual(listBody.mode, 'real');
+    /* 实例身份必须可回传：调用者要能判断「我查的是不是派发我的那个实例」 */
+    assert.ok(listBody.instance?.instanceId, '缺少 instance.instanceId');
+    assert.strictEqual(typeof listBody.instance.pid, 'number');
+    console.log('✓ 清单接口在无工作流时返回空数组');
+  }
+
+  /* 3b. 未知 workflowId 的 404 必须自带诊断信息（不是光秃秃一句「不存在」） */
+  {
+    const route = routes.find(r => r.path === '/codex-orchestrate/api/state');
+    const res = fakeResponse();
+    await route.handler({ method: 'GET', url: '/codex-orchestrate/api/state?workflowId=wf_nope', headers: {} }, res);
+    assert.strictEqual(res.status, 404);
+    const body = JSON.parse(res.body);
+    assert.strictEqual(body.workflowId, 'wf_nope');
+    assert.ok(body.instance?.instanceId, '404 应回传实例身份，便于识别跨实例查询');
+    assert.ok(Array.isArray(body.known), '404 应回传本实例已知的 workflowId 列表');
+    assert.ok(body.hint, '404 应给出可操作的提示');
+    console.log('✓ 未知 workflow 的 404 自带实例身份与已知列表');
+  }
+
+  /* 3c. 落盘路径不得重复拼 'codex-orchestrate' 段
+   * （真实 bug：DSH_HOME 已经是 …/.runtime/codex-orchestrate，
+   *   再拼一次会写成 …/codex-orchestrate/codex-orchestrate/workflows.jsonl） */
+  {
+    const route = routes.find(r => r.path === '/codex-orchestrate/api/status');
+    const prev = process.env.DSH_HOME;
+    process.env.DSH_HOME = '/tmp/fake-dsh-home/codex-orchestrate';
+    const res = fakeResponse();
+    await route.handler({ method: 'GET', url: '/codex-orchestrate/api/status', headers: {} }, res);
+    if (prev === undefined) delete process.env.DSH_HOME; else process.env.DSH_HOME = prev;
+    const body = JSON.parse(res.body);
+    assert.strictEqual(
+      body.instance.stateFile,
+      join('/tmp/fake-dsh-home', 'codex-orchestrate', 'workflows.jsonl'),
+      'stateFile 必须直接落在 DSH_HOME 下，不得重复 codex-orchestrate 段'
+    );
+    console.log('✓ 落盘路径直接基于 DSH_HOME（无重复段）');
+  }
+
+  /* 3d. 回归：进程重启后（orchestrator 尚未构造、还没派发过任何东西）
+   * 查询接口必须仍能从磁盘回读历史，而不是短路成空列表 / 404。
+   * 这是最初的 bug：读路径写成 `orchestrator ? … : []`，重启后恒为空。 */
+  {
+    const { mkdtempSync, writeFileSync, rmSync } = require('node:fs');
+    const { tmpdir } = require('node:os');
+    const dir = mkdtempSync(join(tmpdir(), 'codex-plugin-'));
+    const stateFile = join(dir, 'workflows.jsonl');
+    /* 手写一份「上个进程留下的」状态：一个已完成的 workflow */
+    writeFileSync(stateFile, [
+      JSON.stringify({ type: 'workflow', workflowId: 'wf_old', title: '上个进程的', goal: '', concurrency: 1, createdAt: '2026-01-01T00:00:00.000Z', seq: 1 }),
+      JSON.stringify({ type: 'node', workflowId: 'wf_old', node: { id: 'p', title: 'P', prompt: 'x', status: 'completed', finalMessage: 'OLD', usage: { input_tokens: 1 }, items: [] } }),
+      '',
+    ].join('\n'));
+
+    const prev = process.env.DSH_CODEX_STATE_DIR;
+    process.env.DSH_CODEX_STATE_DIR = dir;
+    try {
+      /* 重新 apply 一个新「进程」（模块级 orchestrator 仍是首次 dispatch 前的状态） */
+      const freshPlugin = await import('./plugin.mjs?restart=1');
+      const freshRoutes = [];
+      freshPlugin.apply({
+        tools: { register: () => {} },
+        webServer: { register: route => freshRoutes.push(route) },
+        on: () => {},
+      });
+
+      const listRoute = freshRoutes.find(r => r.path === '/codex-orchestrate/api/workflows');
+      const listRes = fakeResponse();
+      await listRoute.handler({ method: 'GET', url: '/codex-orchestrate/api/workflows', headers: {} }, listRes);
+      const listed = JSON.parse(listRes.body).workflows.map(w => w.workflowId);
+      assert.ok(listed.includes('wf_old'), `重启后 list() 应包含磁盘历史，实际 ${JSON.stringify(listed)}`);
+
+      const stateRoute = freshRoutes.find(r => r.path === '/codex-orchestrate/api/state');
+      const stateRes = fakeResponse();
+      await stateRoute.handler({ method: 'GET', url: '/codex-orchestrate/api/state?workflowId=wf_old', headers: {} }, stateRes);
+      assert.strictEqual(stateRes.status, 200, '重启后应能从磁盘查到历史 workflow');
+      const snap = JSON.parse(stateRes.body);
+      assert.strictEqual(snap.nodes[0].finalMessage, 'OLD', 'finalMessage 必须跨重启保留');
+      console.log('✓ 重启后（未派发）查询接口仍能回读磁盘历史');
+    } finally {
+      if (prev === undefined) delete process.env.DSH_CODEX_STATE_DIR; else process.env.DSH_CODEX_STATE_DIR = prev;
+      rmSync(dir, { recursive: true, force: true });
+    }
+  }
+
+  /* 4. 状态接口：缺省模型 + 登录态（未派发也可读，不构造 runner） */
+  {
+    const route = routes.find(r => r.path === '/codex-orchestrate/api/status');
+    const res = fakeResponse();
+    await route.handler({ method: 'GET', url: '/codex-orchestrate/api/status', headers: {} }, res);
+    assert.strictEqual(res.status, 200);
+    const body = JSON.parse(res.body);
+    assert.strictEqual(body.mode, 'real');
+    assert.strictEqual(body.defaultModel, require('./defaults.js').DEFAULT_MODEL);
+    assert.notStrictEqual(body.defaultModel, 'gpt-5-codex', '缺省模型不得回到 ChatGPT 订阅登录下被拒的 slug');
+    assert.ok(typeof body.auth.mode === 'string', '缺少 auth.mode');
+    console.log('✓ 状态接口回传缺省模型与登录态');
+  }
+
+  /* 5. 正式入口由 dsh.client 注册，不再注入 native-strip/iframe */
+  {
+    const inject = hooks.find(h => h.name === 'webserver/index-inject');
+    assert.strictEqual(inject, undefined, '不应继续注入 native-strip/iframe');
+    console.log('✓ 未注入旧侧边栏 iframe 入口');
+  }
+
+  console.log('\nplugin 接线测试通过');
+})().catch(error => { console.error(error); process.exit(1); });