@ckanner/dsh-plugin-flywheel 0.27.3 → 0.28.1

package/dist/codex-pro-bridge.js

@@ -0,0 +1,60 @@
+// Public machine API consumer. Go remains the owner of scheduling and acceptance.
+import { createRequire } from 'node:module';
+
+export const ADAPTER = Object.freeze({ package: 'dsh-subagent-codex-pro', version: '0.8.0', protocol: 1 });
+export const LIMITS = Object.freeze({ requestBytes: 1024 * 1024, machineOutputBytes: 1024 * 1024,
+  progressBytes: 1024 * 1024, receiptFrameBytes: 8 * 1024 * 1024, admissionMs: 10000 });
+const require = createRequire(import.meta.url);
+
+export class WorkerError extends Error {
+  constructor(code, message) { super(message); this.name = 'WorkerError'; this.code = code; }
+}
+
+/** The doctor executes this same import, but never calls runMachine. */
+export async function loadAdapter() {
+  const [major, minor] = process.versions.node.split('.').map(Number);
+  if (major < 22 || (major === 22 && minor < 18)) throw new WorkerError('UNSUPPORTED_RUNTIME', 'Codex Pro requires Node.js 22.18.0 or newer');
+  if (!['darwin', 'linux'].includes(process.platform)) throw new WorkerError('UNSUPPORTED_RUNTIME', 'Codex Pro requires a supported POSIX platform');
+  let manifest, api;
+  try {
+    manifest = require('dsh-subagent-codex-pro/package.json');
+  } catch {
+    throw new WorkerError('ADAPTER_UNAVAILABLE', 'Install the exact dsh-subagent-codex-pro@0.8.0 dependency with Flywheel');
+  }
+  if (manifest.name !== ADAPTER.package || manifest.version !== ADAPTER.version) {
+    throw new WorkerError('ADAPTER_MISMATCH', 'Codex Pro package identity or version does not match the pinned contract');
+  }
+  try { api = await import('dsh-subagent-codex-pro/machine'); }
+  catch { throw new WorkerError('ADAPTER_UNAVAILABLE', 'The pinned Codex Pro public machine API could not be imported'); }
+  if (api.MACHINE_PROTOCOL_VERSION !== ADAPTER.protocol ||
+      typeof api.parseMachineRequest !== 'function' || typeof api.runMachine !== 'function' || typeof api.MachineInputError !== 'function') {
+    throw new WorkerError('ADAPTER_MISMATCH', 'Codex Pro package identity, version or public machine API does not match the pinned contract');
+  }
+  return api;
+}
+
+/** Reject unsupported fields and permissions before any process or prompt starts. */
+export function machineRequest(value, api, env) {
+  const keys = new Set(['type', 'protocol', 'requestId', 'cwd', 'model', 'reasoningEffort', 'permissionMode', 'prompt', 'timeoutMs']);
+  if (value === null || typeof value !== 'object' || Array.isArray(value) || value.type !== 'start' || value.protocol !== 1 ||
+      Object.keys(value).some(key => !keys.has(key)) || typeof value.requestId !== 'string' || value.requestId.length > 256 ||
+      !['read-only', 'workspace-write'].includes(value.permissionMode)) {
+    throw new WorkerError('INVALID_REQUEST', 'Expected one protocol=1 start request with an explicit supported permission mode');
+  }
+  if (value.timeoutMs !== undefined && (!Number.isSafeInteger(value.timeoutMs) || value.timeoutMs < 1 || value.timeoutMs > 2147483647)) {
+    throw new WorkerError('INVALID_REQUEST', 'timeoutMs must be a positive safe integer no greater than 2147483647');
+  }
+  try {
+    return api.parseMachineRequest({ protocol: 1, requestId: value.requestId, cwd: value.cwd, model: value.model,
+      effort: value.reasoningEffort, permissionMode: value.permissionMode, prompt: value.prompt,
+      ...(value.timeoutMs === undefined ? {} : { timeoutMs: value.timeoutMs }),
+      command: env.FLYWHEEL_CODEX_BIN || 'codex', threadMode: 'ephemeral', maxOutputBytes: LIMITS.machineOutputBytes });
+  } catch (error) {
+    throw new WorkerError('INVALID_REQUEST', error instanceof api.MachineInputError ? error.message : 'Invalid Codex Pro machine request');
+  }
+}
+
+export function doctorResult() {
+  return { protocol: 1, type: 'doctor', package: ADAPTER.package, version: ADAPTER.version,
+    machineProtocol: ADAPTER.protocol, available: true, inferenceTested: false };
+}

package/dist/codex-pro-worker.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+// One owned invocation. stdin remains a lifeline to the Go parent after admission.
+import { ADAPTER, LIMITS, WorkerError, loadAdapter, machineRequest, doctorResult } from './codex-pro-bridge.js';
+
+const controller = new AbortController();
+let cancelledBy, inputFailure, outputFailure, requestId = 'invalid-request', finished = false;
+const cancel = signal => { cancelledBy ??= signal; controller.abort(); };
+const handlers = new Map(['SIGTERM', 'SIGINT', 'SIGHUP'].map(signal => [signal, () => cancel(signal)]));
+for (const [signal, handler] of handlers) process.on(signal, handler);
+process.stdout.on('error', () => {
+  outputFailure ??= new WorkerError('OUTPUT_ERROR', 'The result consumer closed or failed');
+  process.exitCode = 1;
+  controller.abort();
+});
+
+function write(frame) {
+  if (outputFailure) return;
+  const line = JSON.stringify(frame) + '\n';
+  if (Buffer.byteLength(line) > LIMITS.receiptFrameBytes) throw new WorkerError('OUTPUT_LIMIT', 'Codex Pro result exceeded the complete receipt frame limit');
+  process.stdout.write(line);
+}
+
+/** Do not close stdin after the first line: parent death must cancel the run. */
+function input() {
+  let bytes = 0, buffer = Buffer.alloc(0), admitted = false, resolveInput, rejectInput;
+  const promise = new Promise((resolve, reject) => { resolveInput = resolve; rejectInput = reject; });
+  const fail = (code, message) => {
+    if (finished) return;
+    inputFailure ??= new WorkerError(code, message);
+    clearTimeout(timer);
+    rejectInput(inputFailure);
+    controller.abort();
+  };
+  const timer = setTimeout(() => fail('INPUT_TIMEOUT', 'No complete start request arrived within 10 seconds'), LIMITS.admissionMs);
+  const onData = chunk => {
+    bytes += chunk.length;
+    if (bytes > LIMITS.requestBytes) { fail('INPUT_LIMIT', 'The request exceeded the 1 MiB input limit'); return; }
+    if (admitted) {
+      if (chunk.toString('utf8').trim() !== '') fail('INVALID_REQUEST', 'Only one start request is allowed');
+      return;
+    }
+    buffer = Buffer.concat([buffer, chunk]);
+    const newline = buffer.indexOf(10);
+    if (newline < 0) return;
+    admitted = true;
+    clearTimeout(timer);
+    if (buffer.subarray(newline + 1).toString('utf8').trim() !== '') { fail('INVALID_REQUEST', 'Only one start request is allowed'); return; }
+    try { resolveInput(JSON.parse(buffer.subarray(0, newline).toString('utf8'))); }
+    catch { fail('INVALID_REQUEST', 'The first line must contain one JSON request'); }
+    buffer = Buffer.alloc(0);
+  };
+  const onEnd = () => fail('PARENT_DISCONNECTED', 'The parent stdin lifeline closed before completion');
+  const onError = () => fail('INPUT_ERROR', 'The parent stdin lifeline failed');
+  const onAbort = () => { clearTimeout(timer); rejectInput(new WorkerError('CANCELLED', 'Codex Pro worker was cancelled before admission')); };
+  process.stdin.on('data', onData);
+  process.stdin.once('end', onEnd);
+  process.stdin.once('error', onError);
+  controller.signal.addEventListener('abort', onAbort, { once: true });
+  if (controller.signal.aborted) onAbort();
+  return { promise, stop() {
+    clearTimeout(timer);
+    process.stdin.off('data', onData); process.stdin.off('end', onEnd); process.stdin.off('error', onError);
+    controller.signal.removeEventListener('abort', onAbort);
+    process.stdin.pause();
+    process.stdin.destroy();
+  } };
+}
+
+let lifeline;
+try {
+  const args = process.argv.slice(2);
+  if (args.length > 1 || (args.length === 1 && args[0] !== '--doctor')) throw new WorkerError('INVALID_REQUEST', 'Use flywheel-codex-pro-worker [--doctor]');
+  if (args[0] === '--doctor') {
+    await loadAdapter();
+    write(doctorResult());
+    process.exitCode = 0;
+  } else {
+    lifeline = input();
+    const value = await lifeline.promise;
+    if (typeof value?.requestId === 'string' && value.requestId.trim() !== '' && value.requestId.length <= 256) requestId = value.requestId;
+    const api = await loadAdapter();
+    if (controller.signal.aborted) throw inputFailure || new WorkerError('CANCELLED', 'Codex Pro worker was cancelled before the run');
+    const request = machineRequest(value, api, process.env);
+    requestId = request.requestId;
+    let progressBytes = 0;
+    const receipt = await api.runMachine(request, { signal: controller.signal, env: process.env, onProgress(text) {
+      if (controller.signal.aborted) return;
+      const frame = { protocol: 1, type: 'progress', requestId, text };
+      progressBytes += Buffer.byteLength(JSON.stringify(frame) + '\n');
+      if (progressBytes > LIMITS.progressBytes) {
+        outputFailure ??= new WorkerError('OUTPUT_LIMIT', 'Codex Pro progress exceeded the 1 MiB stream limit');
+        controller.abort();
+      } else write(frame);
+    } });
+    finished = true;
+    lifeline.stop();
+    const error = inputFailure || outputFailure;
+    // An output-limit error still allows a bounded terminal receipt. A broken
+    // stdout cannot, but the run has already settled and cleanup was awaited.
+    if (outputFailure?.code === 'OUTPUT_LIMIT') outputFailure = undefined;
+    write({ protocol: 1, type: 'result', requestId, adapter: ADAPTER, receipt,
+      error: error ? { code: error.code, message: error.message } : null });
+    process.exitCode = receipt.ok && !error && !controller.signal.aborted ? 0 : 1;
+  }
+} catch (error) {
+  finished = true;
+  lifeline?.stop();
+  const known = error instanceof WorkerError ? error : new WorkerError('WORKER_ERROR', 'Codex Pro worker failed before a complete receipt was available');
+  write({ protocol: 1, type: 'result', requestId, adapter: ADAPTER, receipt: null,
+    error: { code: known.code, message: known.message } });
+  process.exitCode = 1;
+} finally {
+  finished = true;
+  lifeline?.stop();
+  if (cancelledBy) process.exitCode = { SIGINT: 130, SIGTERM: 143, SIGHUP: 129 }[cancelledBy];
+  for (const [signal, handler] of handlers) process.off(signal, handler);
+}

package/dist/control.js

@@ -4,6 +4,15 @@ import { directory, nonempty, record } from './protocol.js';
 const actions = ['start', 'status', 'stop', 'config', 'doctor'];
 const checkStatuses = ['pass', 'fail', 'warn', 'unknown', 'skipped'];
 
+// This marker is issued only where the host can prove that no control process
+// started. An engine/transport error after spawn must never acquire it.
+export class ControlNotDispatchedError extends Error {
+  constructor(cause) {
+    super(cause instanceof Error ? cause.message : String(cause), { cause });
+    this.name = 'ControlNotDispatchedError';
+  }
+}
+
 export async function validateControl(input, defaultCwd) {
   if (!record(input) || !actions.includes(input.action)) {
     throw new Error('action must be start, status, stop, config, or doctor');
@@ -46,13 +55,18 @@ function validDiagnostic(value, request) {
 
 /** Only the engine executable can mutate engine state. No shell interpolation. */
 export async function runControl(input, { binary = 'flywheel', defaultCwd, signal, timeoutMs = 60000 } = {}) {
-  nonempty(binary, 'flywheelBinary', 4096);
-  if (binary.startsWith('-')) throw new Error('flywheelBinary must name an executable');
-  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 100 || timeoutMs > 120000) {
-    throw new Error('controlTimeoutMs must be between 100 and 120000');
+  let request;
+  try {
+    nonempty(binary, 'flywheelBinary', 4096);
+    if (binary.startsWith('-')) throw new Error('flywheelBinary must name an executable');
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 100 || timeoutMs > 120000) {
+      throw new Error('controlTimeoutMs must be between 100 and 120000');
+    }
+    request = await validateControl(input, defaultCwd);
+    if (signal?.aborted) throw new Error('Flywheel control request cancelled');
+  } catch (error) {
+    throw new ControlNotDispatchedError(error);
   }
-  const request = await validateControl(input, defaultCwd);
-  if (signal?.aborted) throw new Error('Flywheel control request cancelled');
   // Diagnostic commands own watchdog child groups. Its TERM grace, pipe
   // WaitDelay, and quiescence confirmation may each take 5s; keep the Go owner
   // alive long enough to finish all three instead of orphaning its workers.
@@ -61,9 +75,17 @@ export async function runControl(input, { binary = 'flywheel', defaultCwd, signa
   if (request.taskDir) args.push('--task-dir', request.taskDir);
   if (request.probe) args.push('--probe');
   return new Promise((resolve, reject) => {
-    const child = spawn(binary, args, {
-      cwd: request.cwd, detached: false, stdio: ['ignore', 'pipe', 'pipe'],
-    });
+    let child;
+    try {
+      child = spawn(binary, args, {
+        cwd: request.cwd, detached: false, stdio: ['ignore', 'pipe', 'pipe'],
+      });
+    } catch (error) {
+      reject(new ControlNotDispatchedError(error));
+      return;
+    }
+    let spawned = false;
+    child.once('spawn', () => { spawned = true; });
     let stdout = '';
     let stderr = '';
     let failure;
@@ -88,7 +110,11 @@ export async function runControl(input, { binary = 'flywheel', defaultCwd, signa
       if (Buffer.byteLength(stdout) > 1024 * 1024) stop(new Error('Flywheel control response exceeds 1 MiB'));
     });
     child.stderr.on('data', chunk => { stderr = (stderr + chunk).slice(-8192); });
-    child.on('error', error => { failure = error; });
+    child.on('error', error => {
+      // Node emits spawn before other events after successful process creation.
+      // Require both the missing spawn event and missing PID for positive proof.
+      failure = !spawned && child.pid === undefined ? new ControlNotDispatchedError(error) : error;
+    });
     child.on('close', (code, childSignal) => {
       clearTimeout(timer);
       clearTimeout(killTimer);

package/dist/index.js

@@ -1,4 +1,4 @@
-import { runControl } from './control.js';
+import { ControlNotDispatchedError, runControl } from './control.js';
 import { resolveFlywheelBinary } from './installation.js';
 
 export const inject = ['commands', 'tools'];
@@ -33,11 +33,25 @@ export function apply(ctx, config = {}) {
     description: '通过 Go 引擎控制 Flywheel 任务、查看实际模型配置或执行无推理环境检查。',
     input: { hint: '{"action":"doctor"} 或 {"action":"status","taskDir":"/absolute/docs/task"}' },
     async handler({ rawInput, agent, signal }) {
+      let input;
       try {
-        const value = await control(JSON.parse(rawInput), agent, signal);
+        try {
+          input = JSON.parse(rawInput);
+        } catch (error) {
+          throw new ControlNotDispatchedError(error);
+        }
+        const value = await control(input, agent, signal);
         return { kind: 'success', text: JSON.stringify(value, null, 2) };
       } catch (error) {
-        return { kind: 'error', text: error.message };
+        // CommandResult preserves only kind/text. Wrap every failure, including
+        // unknown outcomes, so a child error's text cannot impersonate host proof.
+        return { kind: 'error', text: JSON.stringify({
+          protocol: 1,
+          type: 'flywheel-control-error',
+          action: typeof input?.action === 'string' ? input.action : null,
+          dispatch: error instanceof ControlNotDispatchedError ? 'not-dispatched' : 'unknown',
+          message: error instanceof Error ? error.message : String(error),
+        }, null, 2) };
       }
     },
   });

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@ckanner/dsh-plugin-flywheel",
-  "version": "0.27.3",
-  "description": "Flywheel engine controls and an owned native DSH SDK worker",
+  "version": "0.28.1",
+  "description": "Flywheel engine controls with owned DSH SDK and Codex Pro machine workers",
   "type": "module",
   "license": "UNLICENSED",
   "engines": {
-    "node": ">=22.0.0",
+    "node": ">=22.18.0",
     "dsh": "0.2.1-rc.5"
   },
   "exports": {
@@ -13,16 +13,20 @@
     "./client": "./dist/client.js",
     "./worker-policy": "./dist/policy.js",
     "./worker": "./dist/worker.js",
+    "./codex-pro-worker": "./dist/codex-pro-worker.js",
     "./package.json": "./package.json"
   },
   "bin": {
-    "flywheel-dsh-worker": "./dist/worker.js"
+    "flywheel-dsh-worker": "./dist/worker.js",
+    "flywheel-codex-pro-worker": "./dist/codex-pro-worker.js"
   },
   "files": [
     "dist",
     "cordis.patch.yml",
     "README.md",
-    "PROTOCOL.md"
+    "README.en.md",
+    "PROTOCOL.md",
+    "THIRD_PARTY_NOTICES.md"
   ],
   "dsh": {
     "bundle": {
@@ -30,9 +34,10 @@
     },
     "client": {
       "inject": [
-        "@deepseek-ai/dsh-client-ui-chat",
+        "@deepseek-ai/dsh-client-ui-conversation",
         "@deepseek-ai/dsh-client-ui-commands",
-        "@deepseek-ai/dsh-api-remotes"
+        "@deepseek-ai/dsh-api-remotes",
+        "@deepseek-ai/dsh-client-locale"
       ],
       "platform": "web"
     }
@@ -59,8 +64,15 @@
     "check": "npm test",
     "prepack": "npm run build"
   },
+  "dependencies": {
+    "dsh-subagent-codex-pro": "0.8.0"
+  },
   "devDependencies": {
+    "@deepseek-ai/cordis": "4.0.5",
+    "@deepseek-ai/dsh-client-ui-renderer": "0.2.1-rc.5",
+    "@deepseek-ai/dsh-client-ui-slots": "0.2.1-rc.5",
     "jsdom": "26.1.0",
+    "lightningcss": "1.33.0",
     "react": "18.3.1",
     "react-dom": "18.3.1"
   },