@zhang6hk/dsh-codex 0.0.0-stage → 0.1.0

package/lib/tool.js

@@ -0,0 +1,103 @@
+import { renderRun } from './render.js'
+
+const DESCRIPTION = [
+  '把一段需要自己跑代码、改文件或复现问题的任务交给本机 Codex CLI。',
+  'Codex 在独立线程里工作，能用同一线程续跑；返回它的最终结论与改动摘要。',
+  '适合：复现并定位问题、按描述实施修改、把一次探索沉淀成结论。',
+  '不适合：只读的代码审查（用 /codex-review）、纯知识问答。',
+].join('')
+
+/**
+ * @param {object} deps
+ * @param {(argv: string[], options: {cwd: string, sessionId?: string, signal?: AbortSignal, timeoutMs?: number}) => Promise<import('./companion.js').CompanionResult>} deps.run
+ * @param {(invocation: {agent?: unknown}) => string} deps.resolveCwd
+ * @param {Record<string, any>} deps.settings
+ * @returns {object} A registry-ready ToolDefinition.
+ */
+export function createCodexTaskTool(deps) {
+  const { run, resolveCwd, settings } = deps
+
+  return {
+    name: 'codex_task',
+    description: DESCRIPTION,
+    parameters: {
+      type: 'object',
+      properties: {
+        prompt: {
+          type: 'string',
+          description: '交给 Codex 的任务描述，写清目标与验收标准。',
+        },
+        resume: {
+          type: 'boolean',
+          description: '续跑本会话里最近的 Codex 线程，而不是新开一个。',
+        },
+      },
+      required: ['prompt'],
+      additionalProperties: false,
+    },
+    output: {
+      schema: {
+        type: 'object',
+        properties: {
+          status: { type: 'number' },
+          threadId: { type: 'string' },
+          output: { type: 'string' },
+        },
+        required: ['status', 'threadId', 'output'],
+        additionalProperties: false,
+      },
+      render(_args, value) {
+        return [{ type: 'text', text: String(value?.output ?? '') }]
+      },
+    },
+    timeoutMs: settings.timeoutMs,
+    isConcurrencySafe: () => false,
+    async execute(args, exec) {
+      const prompt = typeof args?.prompt === 'string' ? args.prompt.trim() : ''
+      if (prompt.length === 0) {
+        throw new Error('codex_task 需要非空的 prompt。')
+      }
+
+      const argv = ['task', '--json', args?.resume === true ? '--resume' : '--fresh']
+      if (typeof settings.model === 'string' && settings.model.length > 0) {
+        argv.push('--model', settings.model)
+      }
+      if (typeof settings.effort === 'string' && settings.effort.length > 0) {
+        argv.push('--effort', settings.effort)
+      }
+      argv.push(prompt)
+
+      const result = await run(argv, {
+        cwd: resolveCwd(exec),
+        sessionId: exec?.agent?.session?.id === undefined ? undefined : String(exec.agent.session.id),
+        signal: exec?.signal,
+        timeoutMs: settings.timeoutMs,
+      })
+
+      if (result.code !== 0) {
+        const failure = renderRun(result, 'Codex 任务')
+        throw new Error(failure.text)
+      }
+
+      const payload = parseJson(result.stdout)
+      const output = payload?.rawOutput ?? payload?.output ?? result.stdout.trim()
+      return {
+        status: typeof payload?.status === 'number' ? payload.status : 0,
+        threadId: typeof payload?.threadId === 'string' ? payload.threadId : '',
+        output: typeof output === 'string' && output.length > 0 ? output : 'Codex 已完成任务。',
+      }
+    },
+  }
+}
+
+/**
+ * @param {string} text
+ * @returns {Record<string, any> | null}
+ */
+function parseJson(text) {
+  try {
+    return JSON.parse(text)
+  } catch {
+    return null
+  }
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Codex Bridge",
+    "description": "Run Codex code reviews and delegate investigation or fix tasks from DeepSeek Harness."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Codex 协作",
+    "description": "在 DSH 里调用本机 Codex CLI 做代码审查，或把调查与修复任务交给它。"
+  }
+}

package/package.json

@@ -1,6 +1,51 @@
 {
   "name": "@zhang6hk/dsh-codex",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Run Codex CLI code reviews and hand investigation or fix tasks to Codex from DeepSeek Harness.",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib",
+    "vendor",
+    "locale",
+    "cordis.patch.yml",
+    "LICENSE",
+    "NOTICE",
+    "README.md",
+    "README.zh.md"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "test": "node --test test/"
+  },
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "codex",
+    "code-review",
+    "codex-cli",
+    "review",
+    "agent"
+  ],
+  "license": "Apache-2.0",
+  "author": "zhang6hk",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zhang6hk/dsh-codex.git"
+  },
+  "homepage": "https://github.com/zhang6hk/dsh-codex#readme",
+  "bugs": {
+    "url": "https://github.com/zhang6hk/dsh-codex/issues"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  }
+}

package/vendor/codex/.claude-plugin/plugin.json

@@ -0,0 +1,8 @@
+{
+  "name": "codex",
+  "version": "1.0.6",
+  "description": "Use Codex from Claude Code to review code or delegate tasks.",
+  "author": {
+    "name": "OpenAI"
+  }
+}

package/vendor/codex/prompts/adversarial-review.md

@@ -0,0 +1,84 @@
+<role>
+You are Codex performing an adversarial software review.
+Your job is to break confidence in the change, not to validate it.
+</role>
+
+<task>
+Review the provided repository context as if you are trying to find the strongest reasons this change should not ship yet.
+Target: {{TARGET_LABEL}}
+User focus: {{USER_FOCUS}}
+</task>
+
+<operating_stance>
+Default to skepticism.
+Assume the change can fail in subtle, high-cost, or user-visible ways until the evidence says otherwise.
+Do not give credit for good intent, partial fixes, or likely follow-up work.
+If something only works on the happy path, treat that as a real weakness.
+</operating_stance>
+
+<attack_surface>
+Prioritize the kinds of failures that are expensive, dangerous, or hard to detect:
+- auth, permissions, tenant isolation, and trust boundaries
+- data loss, corruption, duplication, and irreversible state changes
+- rollback safety, retries, partial failure, and idempotency gaps
+- race conditions, ordering assumptions, stale state, and re-entrancy
+- empty-state, null, timeout, and degraded dependency behavior
+- version skew, schema drift, migration hazards, and compatibility regressions
+- observability gaps that would hide failure or make recovery harder
+</attack_surface>
+
+<review_method>
+Actively try to disprove the change.
+Look for violated invariants, missing guards, unhandled failure paths, and assumptions that stop being true under stress.
+Trace how bad inputs, retries, concurrent actions, or partially completed operations move through the code.
+If the user supplied a focus area, weight it heavily, but still report any other material issue you can defend.
+{{REVIEW_COLLECTION_GUIDANCE}}
+</review_method>
+
+<finding_bar>
+Report only material findings.
+Do not include style feedback, naming feedback, low-value cleanup, or speculative concerns without evidence.
+A finding should answer:
+1. What can go wrong?
+2. Why is this code path vulnerable?
+3. What is the likely impact?
+4. What concrete change would reduce the risk?
+</finding_bar>
+
+<structured_output_contract>
+Return only valid JSON matching the provided schema.
+Keep the output compact and specific.
+Use `needs-attention` if there is any material risk worth blocking on.
+Use `approve` only if you cannot support any substantive adversarial finding from the provided context.
+Every finding must include:
+- the affected file
+- `line_start` and `line_end`
+- a confidence score from 0 to 1
+- a concrete recommendation
+Write the summary like a terse ship/no-ship assessment, not a neutral recap.
+</structured_output_contract>
+
+<grounding_rules>
+Be aggressive, but stay grounded.
+Every finding must be defensible from the provided repository context or tool outputs.
+Do not invent files, lines, code paths, incidents, attack chains, or runtime behavior you cannot support.
+If a conclusion depends on an inference, state that explicitly in the finding body and keep the confidence honest.
+</grounding_rules>
+
+<calibration_rules>
+Prefer one strong finding over several weak ones.
+Do not dilute serious issues with filler.
+If the change looks safe, say so directly and return no findings.
+</calibration_rules>
+
+<final_check>
+Before finalizing, check that each finding is:
+- adversarial rather than stylistic
+- tied to a concrete code location
+- plausible under a real failure scenario
+- actionable for an engineer fixing the issue
+</final_check>
+
+<repository_context>
+{{REVIEW_INPUT}}
+</repository_context>

package/vendor/codex/prompts/stop-review-gate.md

@@ -0,0 +1,36 @@
+<task>
+Run a stop-gate review of the previous Claude turn.
+Only review the work from the previous Claude turn.
+Only review it if Claude actually did code changes in that turn.
+Pure status, setup, or reporting output does not count as reviewable work.
+For example, the output of /codex:setup or /codex:status does not count.
+Only direct edits made in that specific turn count.
+If the previous Claude turn was only a status update, a summary, a setup/login check, a review result, or output from a command that did not itself make direct edits in that turn, return ALLOW immediately and do no further work.
+Challenge whether that specific work and its design choices should ship.
+
+{{CLAUDE_RESPONSE_BLOCK}}
+</task>
+
+<compact_output_contract>
+Return a compact final answer.
+Your first line must be exactly one of:
+- ALLOW: <short reason>
+- BLOCK: <short reason>
+Do not put anything before that first line.
+</compact_output_contract>
+
+<default_follow_through_policy>
+Use ALLOW if the previous turn did not make code changes or if you do not see a blocking issue.
+Use ALLOW immediately, without extra investigation, if the previous turn was not an edit-producing turn.
+Use BLOCK only if the previous turn made code changes and you found something that still needs to be fixed before stopping.
+</default_follow_through_policy>
+
+<grounding_rules>
+Ground every blocking claim in the repository context or tool outputs you inspected during this run.
+Do not treat the previous Claude response as proof that code changes happened; verify that from the repository state before you block.
+Do not block based on older edits from earlier turns when the immediately previous turn did not itself make direct edits.
+</grounding_rules>
+
+<dig_deeper_nudge>
+If the previous turn did make code changes, check for second-order failures, empty-state behavior, retries, stale state, rollback risk, and design tradeoffs before you finalize.
+</dig_deeper_nudge>

package/vendor/codex/schemas/review-output.schema.json

@@ -0,0 +1,87 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "verdict",
+    "summary",
+    "findings",
+    "next_steps"
+  ],
+  "properties": {
+    "verdict": {
+      "type": "string",
+      "enum": [
+        "approve",
+        "needs-attention"
+      ]
+    },
+    "summary": {
+      "type": "string",
+      "minLength": 1
+    },
+    "findings": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "severity",
+          "title",
+          "body",
+          "file",
+          "line_start",
+          "line_end",
+          "confidence",
+          "recommendation"
+        ],
+        "properties": {
+          "severity": {
+            "type": "string",
+            "enum": [
+              "critical",
+              "high",
+              "medium",
+              "low"
+            ]
+          },
+          "title": {
+            "type": "string",
+            "minLength": 1
+          },
+          "body": {
+            "type": "string",
+            "minLength": 1
+          },
+          "file": {
+            "type": "string",
+            "minLength": 1
+          },
+          "line_start": {
+            "type": "integer",
+            "minimum": 1
+          },
+          "line_end": {
+            "type": "integer",
+            "minimum": 1
+          },
+          "confidence": {
+            "type": "number",
+            "minimum": 0,
+            "maximum": 1
+          },
+          "recommendation": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "next_steps": {
+      "type": "array",
+      "items": {
+        "type": "string",
+        "minLength": 1
+      }
+    }
+  }
+}

package/vendor/codex/scripts/app-server-broker.mjs

@@ -0,0 +1,252 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import net from "node:net";
+import path from "node:path";
+import process from "node:process";
+
+import { parseArgs } from "./lib/args.mjs";
+import { BROKER_BUSY_RPC_CODE, CodexAppServerClient } from "./lib/app-server.mjs";
+import { parseBrokerEndpoint } from "./lib/broker-endpoint.mjs";
+
+const STREAMING_METHODS = new Set(["turn/start", "review/start", "thread/compact/start"]);
+
+function buildStreamThreadIds(method, params, result) {
+  const threadIds = new Set();
+  if (params?.threadId) {
+    threadIds.add(params.threadId);
+  }
+  if (method === "review/start" && result?.reviewThreadId) {
+    threadIds.add(result.reviewThreadId);
+  }
+  return threadIds;
+}
+
+function buildJsonRpcError(code, message, data) {
+  return data === undefined ? { code, message } : { code, message, data };
+}
+
+function send(socket, message) {
+  if (socket.destroyed) {
+    return;
+  }
+  socket.write(`${JSON.stringify(message)}\n`);
+}
+
+function isInterruptRequest(message) {
+  return message?.method === "turn/interrupt";
+}
+
+function writePidFile(pidFile) {
+  if (!pidFile) {
+    return;
+  }
+  fs.mkdirSync(path.dirname(pidFile), { recursive: true });
+  fs.writeFileSync(pidFile, `${process.pid}\n`, "utf8");
+}
+
+async function main() {
+  const [subcommand, ...argv] = process.argv.slice(2);
+  if (subcommand !== "serve") {
+    throw new Error("Usage: node scripts/app-server-broker.mjs serve --endpoint <value> [--cwd <path>] [--pid-file <path>]");
+  }
+
+  const { options } = parseArgs(argv, {
+    valueOptions: ["cwd", "pid-file", "endpoint"]
+  });
+
+  if (!options.endpoint) {
+    throw new Error("Missing required --endpoint.");
+  }
+
+  const cwd = options.cwd ? path.resolve(process.cwd(), options.cwd) : process.cwd();
+  const endpoint = String(options.endpoint);
+  const listenTarget = parseBrokerEndpoint(endpoint);
+  const pidFile = options["pid-file"] ? path.resolve(options["pid-file"]) : null;
+  writePidFile(pidFile);
+
+  const appClient = await CodexAppServerClient.connect(cwd, { disableBroker: true });
+  let activeRequestSocket = null;
+  let activeStreamSocket = null;
+  let activeStreamThreadIds = null;
+  const sockets = new Set();
+
+  function clearSocketOwnership(socket) {
+    if (activeRequestSocket === socket) {
+      activeRequestSocket = null;
+    }
+    if (activeStreamSocket === socket) {
+      activeStreamSocket = null;
+      activeStreamThreadIds = null;
+    }
+  }
+
+  function routeNotification(message) {
+    const target = activeRequestSocket ?? activeStreamSocket;
+    if (!target) {
+      return;
+    }
+    send(target, message);
+    if (message.method === "turn/completed" && activeStreamSocket === target) {
+      const threadId = message.params?.threadId ?? null;
+      if (!threadId || !activeStreamThreadIds || activeStreamThreadIds.has(threadId)) {
+        activeStreamSocket = null;
+        activeStreamThreadIds = null;
+        if (activeRequestSocket === target) {
+          activeRequestSocket = null;
+        }
+      }
+    }
+  }
+
+  async function shutdown(server) {
+    for (const socket of sockets) {
+      socket.end();
+    }
+    await appClient.close().catch(() => {});
+    await new Promise((resolve) => server.close(resolve));
+    if (listenTarget.kind === "unix" && fs.existsSync(listenTarget.path)) {
+      fs.unlinkSync(listenTarget.path);
+    }
+    if (pidFile && fs.existsSync(pidFile)) {
+      fs.unlinkSync(pidFile);
+    }
+  }
+
+  appClient.setNotificationHandler(routeNotification);
+
+  const server = net.createServer((socket) => {
+    sockets.add(socket);
+    socket.setEncoding("utf8");
+    let buffer = "";
+
+    socket.on("data", async (chunk) => {
+      buffer += chunk;
+      let newlineIndex = buffer.indexOf("\n");
+      while (newlineIndex !== -1) {
+        const line = buffer.slice(0, newlineIndex);
+        buffer = buffer.slice(newlineIndex + 1);
+        newlineIndex = buffer.indexOf("\n");
+
+        if (!line.trim()) {
+          continue;
+        }
+
+        let message;
+        try {
+          message = JSON.parse(line);
+        } catch (error) {
+          send(socket, {
+            id: null,
+            error: buildJsonRpcError(-32700, `Invalid JSON: ${error.message}`)
+          });
+          continue;
+        }
+
+        if (message.id !== undefined && message.method === "initialize") {
+          send(socket, {
+            id: message.id,
+            result: {
+              userAgent: "codex-companion-broker"
+            }
+          });
+          continue;
+        }
+
+        if (message.method === "initialized" && message.id === undefined) {
+          continue;
+        }
+
+        if (message.id !== undefined && message.method === "broker/shutdown") {
+          send(socket, { id: message.id, result: {} });
+          await shutdown(server);
+          process.exit(0);
+        }
+
+        if (message.id === undefined) {
+          continue;
+        }
+
+        const allowInterruptDuringActiveStream =
+          isInterruptRequest(message) && activeStreamSocket && activeStreamSocket !== socket && !activeRequestSocket;
+
+        if (
+          ((activeRequestSocket && activeRequestSocket !== socket) || (activeStreamSocket && activeStreamSocket !== socket)) &&
+          !allowInterruptDuringActiveStream
+        ) {
+          send(socket, {
+            id: message.id,
+            error: buildJsonRpcError(BROKER_BUSY_RPC_CODE, "Shared Codex broker is busy.")
+          });
+          continue;
+        }
+
+        if (allowInterruptDuringActiveStream) {
+          try {
+            const result = await appClient.request(message.method, message.params ?? {});
+            send(socket, { id: message.id, result });
+          } catch (error) {
+            send(socket, {
+              id: message.id,
+              error: buildJsonRpcError(error.rpcCode ?? -32000, error.message)
+            });
+          }
+          continue;
+        }
+
+        const isStreaming = STREAMING_METHODS.has(message.method);
+        activeRequestSocket = socket;
+
+        try {
+          const result = await appClient.request(message.method, message.params ?? {});
+          send(socket, { id: message.id, result });
+          if (isStreaming) {
+            activeStreamSocket = socket;
+            activeStreamThreadIds = buildStreamThreadIds(message.method, message.params ?? {}, result);
+          }
+          if (activeRequestSocket === socket) {
+            activeRequestSocket = null;
+          }
+        } catch (error) {
+          send(socket, {
+            id: message.id,
+            error: buildJsonRpcError(error.rpcCode ?? -32000, error.message)
+          });
+          if (activeRequestSocket === socket) {
+            activeRequestSocket = null;
+          }
+          if (activeStreamSocket === socket && !isStreaming) {
+            activeStreamSocket = null;
+          }
+        }
+      }
+    });
+
+    socket.on("close", () => {
+      sockets.delete(socket);
+      clearSocketOwnership(socket);
+    });
+
+    socket.on("error", () => {
+      sockets.delete(socket);
+      clearSocketOwnership(socket);
+    });
+  });
+
+  process.on("SIGTERM", async () => {
+    await shutdown(server);
+    process.exit(0);
+  });
+
+  process.on("SIGINT", async () => {
+    await shutdown(server);
+    process.exit(0);
+  });
+
+  server.listen(listenTarget.path);
+}
+
+main().catch((error) => {
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+  process.exit(1);
+});