@zhang6hk/dsh-codex 0.0.0-stage → 0.1.0

package/lib/commands.js

@@ -0,0 +1,242 @@
+import { buildReviewArgv, buildTaskArgv } from './args.js'
+import { renderBackground, renderRun, renderSetup, tail } from './render.js'
+
+const RESUME_FLAG = /(^|\s)--(?:resume|resume-last|fresh)(?=\s|$)/u
+const FOLLOW_UP = /(继续|接着|再往下|接着改|深入|再查|keep going|continue|resume|dig deeper|apply the top fix)/iu
+const DEFAULT_LAUNCH_TIMEOUT_MS = 120_000
+const RESUME_LOOKUP_TIMEOUT_MS = 15_000
+
+/**
+ * Pull `--wait` / `--background` out of the raw input: they choose the
+ * transport, so the engine must never see them.
+ *
+ * @param {string} rawInput
+ * @returns {{wait: boolean, rest: string}}
+ */
+export function extractMode(rawInput) {
+  const text = String(rawInput ?? '')
+  const has = (flag) => new RegExp(`(^|\\s)--${flag}(?=\\s|$)`, 'u').test(text)
+  const wait = has('wait')
+  const rest = text
+    .replace(/(^|\s)--(?:wait|background)(?=\s|$)/gu, ' ')
+    .replace(/\s+/gu, ' ')
+    .trim()
+  return { wait: wait || false, rest }
+}
+
+/**
+ * @param {import('@deepseek-ai/dsh-commands').CommandInvocation} invocation
+ * @returns {string | undefined}
+ */
+function sessionIdOf(invocation) {
+  const agent = invocation?.agent
+  const id = agent?.session?.id ?? agent?.id
+  return id === undefined ? undefined : String(id)
+}
+
+/**
+ * Build the seven slash commands.
+ *
+ * @param {object} deps
+ * @param {(argv: string[], options: {cwd: string, sessionId?: string, signal?: AbortSignal, timeoutMs?: number}) => Promise<import('./companion.js').CompanionResult>} deps.run
+ * @param {(invocation: unknown) => string} deps.resolveCwd
+ * @param {Record<string, any>} deps.settings
+ * @returns {import('@deepseek-ai/dsh-commands').CommandDefinition[]}
+ */
+export function createCommandDefinitions(deps) {
+  const { run, resolveCwd, settings } = deps
+  const maxConcurrent = settings.maxConcurrent
+
+  /**
+   * @param {object} options
+   * @param {string[]} options.argv
+   * @param {string} options.label
+   * @param {string | undefined} options.sessionId
+   * @param {string} options.cwd
+   * @param {AbortSignal | undefined} options.signal
+   * @param {boolean} options.background
+   */
+  async function launch({ argv, label, sessionId, cwd, signal, background }) {
+    if (!background) {
+      return renderRun(await run(argv, { cwd, sessionId, signal, timeoutMs: settings.timeoutMs }), label)
+    }
+
+    const running = await countRunning({ cwd, sessionId, signal })
+    if (running >= maxConcurrent) {
+      return {
+        kind: 'error',
+        text: `已有 ${running} 个 Codex 任务在运行（上限 ${maxConcurrent}）。等它们结束，或用 \`/codex-cancel <id>\` 取消一个。`,
+      }
+    }
+
+    const result = await run([...argv, '--background', '--json'], {
+      cwd,
+      sessionId,
+      signal,
+      timeoutMs: DEFAULT_LAUNCH_TIMEOUT_MS,
+    })
+
+    if (result.code !== 0) {
+      return renderRun(result, label)
+    }
+
+    try {
+      const payload = JSON.parse(result.stdout)
+      if (typeof payload?.jobId === 'string' && payload.jobId.length > 0) {
+        return { kind: 'success', text: renderBackground({ jobId: payload.jobId, title: payload.title }, label) }
+      }
+    } catch {
+      // fall through to the raw output below
+    }
+    return { kind: 'success', text: tail(result.stdout) || `${label}已启动。` }
+  }
+
+  async function countRunning({ cwd, sessionId, signal }) {
+    const result = await run(['status', '--json', '--timeout-ms', '1'], {
+      cwd,
+      sessionId,
+      signal,
+      timeoutMs: RESUME_LOOKUP_TIMEOUT_MS,
+    })
+    if (result.code !== 0) {
+      return 0
+    }
+    try {
+      const report = JSON.parse(result.stdout)
+      return Array.isArray(report?.running) ? report.running.length : 0
+    } catch {
+      return 0
+    }
+  }
+
+  async function resumeAvailable({ cwd, sessionId, signal }) {
+    const result = await run(['task-resume-candidate', '--json'], {
+      cwd,
+      sessionId,
+      signal,
+      timeoutMs: RESUME_LOOKUP_TIMEOUT_MS,
+    })
+    if (result.code !== 0) {
+      return false
+    }
+    try {
+      return JSON.parse(result.stdout)?.available === true
+    } catch {
+      return false
+    }
+  }
+
+  /** @type {import('@deepseek-ai/dsh-commands').CommandDefinition[]} */
+  return [
+    {
+      name: 'codex-review',
+      description: '用 Codex 审查当前 git 改动（原生 review，不修改代码）',
+      input: { hint: '[--wait] [--base <ref>] [--scope auto|working-tree|branch]' },
+      async handler(invocation) {
+        const { rest } = extractMode(invocation.rawInput)
+        const { argv, prompt } = buildReviewArgv('review', rest, settings)
+        if (prompt.length > 0) {
+          return {
+            kind: 'error',
+            text: '原生 review 不接受额外审查指令。需要自定义关注点或对抗式审查，请用 `/codex-adversarial-review <关注点>`。',
+          }
+        }
+        // The engine's review path always runs in the foreground; `--background`
+        // only exists for task launches, so reviews never take the job branch.
+        return launch({ argv, label: 'Codex Review', cwd: resolveCwd(invocation), sessionId: sessionIdOf(invocation), signal: invocation.signal, background: false })
+      },
+    },
+    {
+      name: 'codex-adversarial-review',
+      description: '用 Codex 对抗式审查：质疑实现方案、设计取舍与隐含假设',
+      input: { hint: '[--wait] [--base <ref>] [--scope …] [关注点 …]' },
+      async handler(invocation) {
+        const { rest } = extractMode(invocation.rawInput)
+        const { argv, prompt } = buildReviewArgv('adversarial-review', rest, settings)
+        if (prompt.length > 0) {
+          argv.push(prompt)
+        }
+        return launch({ argv, label: 'Codex 对抗式审查', cwd: resolveCwd(invocation), sessionId: sessionIdOf(invocation), signal: invocation.signal, background: false })
+      },
+    },
+    {
+      name: 'codex-rescue',
+      description: '把调查、修复或续跑交给 Codex（会话内保持同一线程）',
+      input: { hint: '[--wait] [--resume|--fresh] [--model …] [--effort …] <任务描述>' },
+      async handler(invocation) {
+        const { wait, rest } = extractMode(invocation.rawInput)
+        const { argv, prompt } = buildTaskArgv(rest, settings)
+        if (prompt.length === 0) {
+          return { kind: 'error', text: '请描述要交给 Codex 的任务，例如 `/codex-rescue 修一下登录超时`。' }
+        }
+        argv.push(prompt)
+
+        const cwd = resolveCwd(invocation)
+        const sessionId = sessionIdOf(invocation)
+        let hint = ''
+        if (!RESUME_FLAG.test(rest)) {
+          const available = await resumeAvailable({ cwd, sessionId, signal: invocation.signal })
+          if (available) {
+            if (FOLLOW_UP.test(prompt)) {
+              argv.splice(1, 1, '--resume')
+              hint = '\n\n（检测到同一会话里可续跑的 Codex 线程，已自动续跑；要新开线程加 `--fresh`。）'
+            } else {
+              hint = '\n\n（同一会话里有可续跑的 Codex 线程，要接着上次的改动加 `--resume`。）'
+            }
+          }
+        }
+
+        const result = await launch({ argv, label: 'Codex 任务', cwd, sessionId, signal: invocation.signal, background: !wait })
+        return hint && result.kind === 'success' ? { ...result, text: result.text + hint } : result
+      },
+    },
+    {
+      name: 'codex-status',
+      description: '查看本仓库的 Codex 任务进度',
+      input: { hint: '[job-id] [--all]' },
+      async handler(invocation) {
+        const { rest } = extractMode(invocation.rawInput)
+        const extra = rest.length > 0 ? rest.split(/\s+/u) : []
+        const argv = ['status', ...extra, '--timeout-ms', String(settings.statusTimeoutMs)]
+        return renderRun(await run(argv, { cwd: resolveCwd(invocation), sessionId: sessionIdOf(invocation), signal: invocation.signal, timeoutMs: settings.statusTimeoutMs + 10_000 }), '查询任务状态')
+      },
+    },
+    {
+      name: 'codex-result',
+      description: '取出某个 Codex 任务的完整结果',
+      input: { hint: '<job-id>' },
+      async handler(invocation) {
+        const jobId = extractMode(invocation.rawInput).rest.trim()
+        if (jobId.length === 0) {
+          return { kind: 'error', text: '需要任务 ID：`/codex-result <job-id>`。ID 来自 `/codex-status` 或启动任务时的提示。' }
+        }
+        return renderRun(await run(['result', jobId], { cwd: resolveCwd(invocation), sessionId: sessionIdOf(invocation), signal: invocation.signal, timeoutMs: 60_000 }), '读取结果')
+      },
+    },
+    {
+      name: 'codex-cancel',
+      description: '取消一个正在运行的 Codex 任务',
+      input: { hint: '<job-id>' },
+      async handler(invocation) {
+        const jobId = extractMode(invocation.rawInput).rest.trim()
+        const argv = jobId.length > 0 ? ['cancel', jobId] : ['cancel']
+        return renderRun(await run(argv, { cwd: resolveCwd(invocation), sessionId: sessionIdOf(invocation), signal: invocation.signal, timeoutMs: 60_000 }), '取消任务')
+      },
+    },
+    {
+      name: 'codex-setup',
+      description: '检查 Codex CLI、登录状态与运行时',
+      async handler(invocation) {
+        const result = await run(['setup', '--json'], { cwd: resolveCwd(invocation), sessionId: sessionIdOf(invocation), signal: invocation.signal, timeoutMs: 60_000 })
+        if (result.code !== 0) {
+          return renderRun(result, '环境检查')
+        }
+        try {
+          return renderSetup(JSON.parse(result.stdout))
+        } catch {
+          return { kind: 'success', text: tail(result.stdout) }
+        }
+      },
+    },
+  ]
+}

package/lib/companion.js

@@ -0,0 +1,177 @@
+import { spawn } from 'node:child_process'
+import process from 'node:process'
+import { fileURLToPath } from 'node:url'
+
+/** The vendored upstream engine, shipped inside this package. */
+export const COMPANION_PATH = fileURLToPath(new URL('../vendor/codex/scripts/codex-companion.mjs', import.meta.url))
+
+const MAX_CAPTURE = 64 * 1024
+const KILL_GRACE_MS = 2000
+
+/**
+ * GUI apps on macOS launch with a minimal PATH, which hides Homebrew and
+ * npm-global installs. Prepend the usual locations so `codex` resolves.
+ *
+ * @param {NodeJS.ProcessEnv} env
+ * @param {string} home
+ * @returns {NodeJS.ProcessEnv}
+ */
+export function augmentPath(env, home = process.env.HOME ?? '') {
+  const extra = ['/opt/homebrew/bin', '/usr/local/bin', home ? `${home}/.local/bin` : ''].filter(Boolean)
+  const existing = String(env.PATH ?? '').split(':').filter(Boolean)
+  /** @type {string[]} */
+  const merged = []
+  for (const entry of [...extra, ...existing]) {
+    if (!merged.includes(entry)) {
+      merged.push(entry)
+    }
+  }
+  return { ...env, PATH: merged.join(':') }
+}
+
+/**
+ * @typedef {object} CompanionResult
+ * @property {number | 'TIMEOUT' | 'ABORTED' | 'SPAWN_ERROR'} code
+ * @property {string} stdout
+ * @property {string} stderr
+ * @property {string} [error] Present when the process could not be spawned.
+ */
+
+/**
+ * @param {{env: NodeJS.ProcessEnv, dataDir: string, sessionId?: string, binDir?: string | null}} options
+ * @returns {NodeJS.ProcessEnv}
+ */
+export function childEnv({ env, dataDir, sessionId, binDir }) {
+  const base = augmentPath(env)
+  if (binDir) {
+    base.PATH = `${binDir}:${base.PATH}`
+  }
+  base.CLAUDE_PLUGIN_DATA = dataDir
+  if (sessionId) {
+    base.CODEX_COMPANION_SESSION_ID = sessionId
+  }
+  return base
+}
+
+/**
+ * Run the vendored engine once and collect its output.
+ *
+ * @param {object} options
+ * @param {string[]} options.argv Engine arguments, without the script path.
+ * @param {string} options.cwd Session working directory.
+ * @param {string} options.dataDir Plugin data directory, exported as `CLAUDE_PLUGIN_DATA`.
+ * @param {NodeJS.ProcessEnv} [options.env]
+ * @param {string} [options.companionPath]
+ * @param {string} [options.nodePath]
+ * @param {number} [options.timeoutMs]
+ * @param {AbortSignal} [options.signal]
+ * @param {string} [options.sessionId] Exported as `CODEX_COMPANION_SESSION_ID` so the engine scopes threads per session.
+ * @param {string | null} [options.binDir] Directory prepended to PATH (see `prepareCodexBinDir`).
+ * @returns {Promise<CompanionResult>}
+ */
+export function runCompanion(options) {
+  const {
+    argv,
+    cwd,
+    dataDir,
+    env = process.env,
+    companionPath = COMPANION_PATH,
+    nodePath = process.execPath,
+    timeoutMs = 30 * 60 * 1000,
+    signal,
+    sessionId,
+    binDir = null,
+  } = options
+
+  return new Promise((resolve) => {
+    let stdout = ''
+    let stderr = ''
+    let settled = false
+    let killTimer
+
+    const child = spawn(nodePath, [companionPath, ...argv], {
+      cwd,
+      env: childEnv({ env, dataDir, sessionId, binDir }),
+      stdio: ['ignore', 'pipe', 'pipe'],
+      detached: true,
+    })
+
+    const killGroup = () => {
+      if (child.pid === undefined) {
+        return
+      }
+      try {
+        process.kill(-child.pid, 'SIGTERM')
+      } catch {
+        try {
+          child.kill('SIGTERM')
+        } catch {
+          // already gone
+        }
+      }
+      killTimer = setTimeout(() => {
+        try {
+          process.kill(-child.pid, 'SIGKILL')
+        } catch {
+          // already gone
+        }
+      }, KILL_GRACE_MS)
+      killTimer.unref?.()
+    }
+
+    /** @param {number | 'TIMEOUT' | 'ABORTED' | 'SPAWN_ERROR'} code */
+    const settle = (code) => {
+      if (settled) {
+        return
+      }
+      settled = true
+      clearTimeout(timer)
+      if (killTimer !== undefined) {
+        clearTimeout(killTimer)
+      }
+      signal?.removeEventListener('abort', onAbort)
+      resolve({ code, stdout, stderr })
+    }
+
+    const onAbort = () => {
+      killGroup()
+      settle('ABORTED')
+    }
+
+    const timer = timeoutMs > 0
+      ? setTimeout(() => {
+        killGroup()
+        settle('TIMEOUT')
+      }, timeoutMs)
+      : undefined
+
+    if (signal?.aborted) {
+      onAbort()
+    } else {
+      signal?.addEventListener('abort', onAbort, { once: true })
+    }
+
+    child.stdout?.setEncoding('utf8')
+    child.stdout?.on('data', (chunk) => {
+      stdout += chunk
+      if (stdout.length > MAX_CAPTURE) {
+        stdout = stdout.slice(-MAX_CAPTURE)
+      }
+    })
+    child.stderr?.setEncoding('utf8')
+    child.stderr?.on('data', (chunk) => {
+      stderr += chunk
+      if (stderr.length > MAX_CAPTURE) {
+        stderr = stderr.slice(-MAX_CAPTURE)
+      }
+    })
+
+    child.on('error', (error) => {
+      stderr += String(error?.message ?? error)
+      settle('SPAWN_ERROR')
+    })
+    child.on('close', (code) => {
+      settle(code ?? 0)
+    })
+  })
+}

package/lib/index.js

@@ -0,0 +1,105 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import process from 'node:process'
+
+import { createCommandDefinitions } from './commands.js'
+import { prepareCodexBinDir } from './codex-path.js'
+import { runCompanion } from './companion.js'
+import { createCodexTaskTool } from './tool.js'
+
+export const name = 'dsh-codex'
+export const inject = ['commands', 'tools', 'workingDirectory']
+
+const DEFAULTS = {
+  codexPath: 'codex',
+  model: '',
+  effort: '',
+  defaultBase: '',
+  maxConcurrent: 2,
+  timeoutMs: 30 * 60 * 1000,
+  statusTimeoutMs: 15_000,
+}
+
+/**
+ * @param {Record<string, unknown>} [config]
+ * @returns {typeof DEFAULTS}
+ */
+export function normalizeSettings(config = {}) {
+  const text = (value, fallback) => (typeof value === 'string' && value.trim().length > 0 ? value.trim() : fallback)
+  const positive = (value, fallback) => (Number.isFinite(value) && value > 0 ? Math.floor(Number(value)) : fallback)
+
+  return {
+    codexPath: text(config.codexPath, DEFAULTS.codexPath),
+    model: text(config.model, DEFAULTS.model),
+    effort: text(config.effort, DEFAULTS.effort),
+    defaultBase: text(config.defaultBase, DEFAULTS.defaultBase),
+    maxConcurrent: positive(config.maxConcurrent, DEFAULTS.maxConcurrent),
+    timeoutMs: positive(config.timeoutMs, DEFAULTS.timeoutMs),
+    statusTimeoutMs: positive(config.statusTimeoutMs, DEFAULTS.statusTimeoutMs),
+  }
+}
+
+/**
+ * @returns {string} Plugin-owned data directory (also the engine's state root).
+ */
+export function resolveDataDir() {
+  const home = process.env.DSH_HOME && process.env.DSH_HOME.trim().length > 0
+    ? process.env.DSH_HOME.trim()
+    : path.join(os.homedir(), '.dsh')
+  const dir = path.join(home, 'plugin-data', 'dsh-codex')
+  fs.mkdirSync(dir, { recursive: true })
+  return dir
+}
+
+/**
+ * @param {import('@deepseek-ai/cordis').Context} ctx
+ * @param {Record<string, unknown>} [config]
+ */
+export function apply(ctx, config = {}) {
+  const settings = normalizeSettings(config)
+  const dataDir = resolveDataDir()
+  const binDir = prepareCodexBinDir({ codexPath: settings.codexPath, dataDir })
+
+  const run = (argv, options = {}) => runCompanion({
+    argv,
+    cwd: options.cwd,
+    dataDir,
+    sessionId: options.sessionId,
+    signal: options.signal,
+    timeoutMs: options.timeoutMs ?? settings.timeoutMs,
+    binDir,
+  })
+
+  const resolveCwd = (holder) => {
+    try {
+      const session = holder?.agent?.session
+      const directory = ctx.workingDirectory.get(session)
+      if (typeof directory === 'string' && directory.length > 0) {
+        return directory
+      }
+    } catch {
+      // fall through to the host's launch directory
+    }
+    return process.cwd()
+  }
+
+  ctx.effect(function* registerCodexSurface() {
+    const disposers = []
+
+    for (const definition of createCommandDefinitions({ run, resolveCwd, settings })) {
+      disposers.push(ctx.commands.register(definition))
+    }
+    disposers.push(ctx.tools.register(createCodexTaskTool({ run, resolveCwd, settings })))
+
+    yield () => {
+      for (const dispose of disposers.reverse()) {
+        try {
+          dispose()
+        } catch {
+          // already gone
+        }
+      }
+    }
+  })
+}

package/lib/render.js

@@ -0,0 +1,114 @@
+/**
+ * User-facing text for command results. Kept apart from the command wiring so
+ * the wording can be reviewed (and translated) without touching behavior.
+ */
+
+const TAIL_LIMIT = 4000
+
+/**
+ * @param {string} text
+ * @param {number} [limit]
+ * @returns {string}
+ */
+export function tail(text, limit = TAIL_LIMIT) {
+  const value = String(text ?? '').trim()
+  if (value.length <= limit) {
+    return value
+  }
+  return `…${value.slice(-limit)}`
+}
+
+/**
+ * @param {{jobId: string, title?: string}} payload
+ * @param {string} label Human name for the work, e.g. `Codex Review`.
+ * @returns {string}
+ */
+export function renderBackground(payload, label) {
+  const title = payload.title ? `${label}（${payload.title}）` : label
+  return [
+    `${title}已在后台启动，不会阻塞当前会话。`,
+    '',
+    `- 任务 ID：${payload.jobId}`,
+    `- 查看进度：/codex-status ${payload.jobId}`,
+    `- 查看结果：/codex-result ${payload.jobId}`,
+    `- 取消任务：/codex-cancel ${payload.jobId}`,
+  ].join('\n')
+}
+
+/**
+ * @param {string} text
+ * @returns {string | null} A concrete next step when the engine failed.
+ */
+function hintFor(text) {
+  if (/not a git repository|fatal: not a git/iu.test(text)) {
+    return '当前目录不是 git 仓库。`/codex-review` 只能审查 git 工作区，请先 `git init` 或在仓库内调用。'
+  }
+  if (/codex(?:-cli)?[^\n]*(?:not found|ENOENT)|spawn codex ENOENT/iu.test(text)) {
+    return '找不到 `codex` 可执行文件。安装：`npm install -g @openai/codex`；若装在非标准位置，在 `cordis.patch.yml` 里把 `codexPath` 指向它的绝对路径。'
+  }
+  if (/not logged in|login|unauthorized|401/iu.test(text)) {
+    return 'Codex 未登录。先在终端运行 `codex login`，再执行 `/codex-setup` 确认状态。'
+  }
+  return null
+}
+
+/**
+ * Normalize one engine run into a command result.
+ *
+ * @param {{code: number | string, stdout: string, stderr: string}} result
+ * @param {string} what Human name of the failed operation.
+ * @returns {{kind: 'success' | 'error', text: string}}
+ */
+export function renderRun(result, what) {
+  if (result.code === 0) {
+    return { kind: 'success', text: result.stdout.trim() || `${what}已完成。` }
+  }
+  if (result.code === 'TIMEOUT') {
+    return { kind: 'error', text: `${what}超时。Codex 可能仍在运行，用 \`/codex-status\` 查看任务，或调大 \`timeoutMs\`。` }
+  }
+  if (result.code === 'ABORTED') {
+    return { kind: 'error', text: `${what}已取消。` }
+  }
+  if (result.code === 'SPAWN_ERROR') {
+    return { kind: 'error', text: `${what}无法启动：${tail(result.stderr) || '未能启动 Node 子进程。'}` }
+  }
+
+  const combined = [result.stderr, result.stdout].filter(Boolean).join('\n')
+  const hint = hintFor(combined)
+  const detail = tail(combined) || `退出码 ${result.code}`
+  return { kind: 'error', text: hint ? `${hint}\n\n${detail}` : `${what}失败：\n${detail}` }
+}
+
+/**
+ * @param {Record<string, any>} report Parsed `setup --json` payload.
+ * @returns {{kind: 'success' | 'error', text: string}}
+ */
+export function renderSetup(report) {
+  const line = (label, entry) => {
+    const ok = entry?.available !== false
+    const detail = entry?.detail ? `：${entry.detail}` : ''
+    return `- ${label}：${ok ? '正常' : '不可用'}${detail}`
+  }
+
+  const auth = report?.auth
+  const authLine = auth
+    ? `- 登录：${auth.loggedIn ? `已登录${auth.detail ? `（${auth.detail}）` : ''}` : '未登录'}`
+    : '- 登录：未知'
+
+  const runtime = report?.sessionRuntime
+  const lines = [
+    `Codex 环境检查：${report?.ready ? '就绪' : '未就绪'}`,
+    '',
+    line('Node', report?.node),
+    line('npm', report?.npm),
+    line('Codex', report?.codex),
+    authLine,
+    runtime ? `- 会话运行时：${runtime.label ?? runtime.mode}${runtime.detail ? `（${runtime.detail}）` : ''}` : '',
+  ].filter(Boolean)
+
+  if (!report?.ready) {
+    lines.push('', '修复建议：安装 Codex（`npm install -g @openai/codex`）并运行 `codex login`。')
+  }
+
+  return { kind: report?.ready ? 'success' : 'error', text: lines.join('\n') }
+}