npm - coxpit - Versions diffs - 3.4.0 → 3.5.0 - Mend

coxpit 3.4.0 → 3.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/README.md CHANGED Viewed

@@ -13,6 +13,7 @@ Your machines. Your auth. Your code never leaves your network.
 ## What it does
 - **Fleet runs** — one task, N agents. Each run = worktree + branch + tmux window. No agent ever touches your checkout.
+- **Two providers** — Claude Code and OpenAI Codex CLI, selectable per launch. Fan the same task across both and compare; steering resumes each agent's own session. The provider seam (`src/providers.ts`) is ~100 lines per provider — adding a third is a PR, not a fork.
 - **Live board** — WebSocket-driven console: status, event timeline (parsed from the agent's stream-json), per-run diff.
 - **Compare & merge** — all runs of a task side by side; pick the winner, merge to the base branch (auto-commits the worktree, guards a clean base, aborts on conflict).
 - **Real terminal** — attach to any run's tmux session in the browser (xterm.js over a server-side PTY; resize propagates, `Ctrl-b d` detaches).
@@ -53,7 +54,7 @@ Coxpit has no accounts of its own — it drives the agent CLI already on your ma
    npm i -g @anthropic-ai/claude-code
    claude        # first run opens browser login
    ```
-   Prefer another CLI? Set `COXPIT_AGENT_BIN`.
+   For the Codex provider, also: `npm i -g @openai/codex && codex` (sign in once). Other binaries: `COXPIT_AGENT_BIN` / `COXPIT_CODEX_BIN`.
 2. **Open the board** — the first-run panel checks this machine (git · tmux · agent CLI) and tells you what's missing.
 3. **Rehearse with Dry run**, then flip to Real agent. Real runs spend your CLI account's credits — nothing is billed through coxpit.
@@ -69,8 +70,10 @@ Your keys and login never touch coxpit's config or database.
 | `COXPIT_AUTH_DISABLED` | — | `1` disables auth (local dev only) |
 | `COXPIT_SSH_KEY` | — | private key for remote machines (else ssh defaults/agent) |
 | `COXPIT_AGENT_REAL` | — | `1` = real agent CLI by default (credits!) |
-| `COXPIT_AGENT_BIN` | `claude` | agent command |
-| `COXPIT_AGENT_PERM` | `acceptEdits` | headless permission mode passed to the agent |
+| `COXPIT_AGENT_BIN` | `claude` | Claude Code command |
+| `COXPIT_AGENT_PERM` | `acceptEdits` | Claude Code headless permission mode |
+| `COXPIT_CODEX_BIN` | `codex` | Codex CLI command (optional second provider) |
+| `COXPIT_CODEX_SANDBOX` | `workspace-write` | Codex sandbox policy (`danger-full-access` for full autonomy) |
 | `COXPIT_WEBHOOK_URL` | — | POSTs `{event:"run.settled",run:{...}}` when a run finishes — wire it to Telegram, Slack, anything |
 Running on the open internet? Put it behind your own front door (Tailscale, Cloudflare Access, a reverse proxy with TLS) and keep basic auth on — it exposes shells.

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "coxpit",
-  "version": "3.4.0",
+  "version": "3.5.0",
   "description": "Self-hosted cockpit for running a fleet of AI coding agents across your own machines — parallel worktree runs, live board, compare & merge, web terminal, design capture.",
   "type": "module",
   "license": "MIT",

package/src/board.ts CHANGED Viewed

@@ -343,6 +343,10 @@ export const BOARD_HTML = /* html */ `<!doctype html>
         <div id="panelTask" style="display:flex;flex-direction:column;gap:8px">
           <input id="taskTitle" placeholder="Task title" />
           <textarea id="taskPrompt" placeholder="Prompt — target files, constraints, how to verify"></textarea>
+          <div class="seg" id="provSeg" role="group" aria-label="agent provider">
+            <button type="button" class="seg-opt on" data-agent="claude-code">Claude</button>
+            <button type="button" class="seg-opt" data-agent="codex">Codex</button>
+          </div>
           <p class="flabel">design capture · optional</p>
           <select id="taskCapture"><option value="">no design capture</option></select>
         </div>
@@ -734,7 +738,8 @@ function paintOnboarding(){
     checks = chkRow('connection', !!r.reachable, machines.length ? machines[0].slug : '')
       + chkRow('git', r.git ? r.git.ok : false, r.git ? r.git.version : '')
       + chkRow('tmux', r.tmux ? r.tmux.ok : false, r.tmux ? r.tmux.version : '')
-      + chkRow('agent', r.agent ? r.agent.ok : false, r.agent ? (r.agent.ok ? agentBin+' '+r.agent.version : 'not found on PATH') : '');
+      + chkRow('agent', r.agent ? r.agent.ok : false, r.agent ? (r.agent.ok ? agentBin+' '+r.agent.version : 'not found on PATH') : '')
+      + (r.codex && r.codex.ok ? chkRow('codex', true, r.codex.bin+' '+r.codex.version+' · optional 2nd provider') : '');
   }
   const agentMissing = r && r.agent && !r.agent.ok;
   $('empty').innerHTML = '<div class="setup">'
@@ -1158,14 +1163,20 @@ let termRunId = null, termClosing = false, termRetry = 0, termRetryTimer = null;
 function termConnect(){
   if (termRunId==null || termClosing || !termObj) return;
   const proto = location.protocol==='https:'?'wss':'ws';
-  termWS = new WebSocket(proto+'://'+location.host+'/ws/term/'+termRunId
+  // 소켓 정체성 가드 — close 이벤트는 비동기라 termClosing 토글만으론 못 막는다.
+  // 대체된(sock!==termWS) 소켓은 출력도 재연결도 금지: 같은 tmux 세션에 WS 가
+  // 누적 attach 되면 tmux 가 전 클라이언트에 미러링해 글자가 N번씩 보인다.
+  const sock = new WebSocket(proto+'://'+location.host+'/ws/term/'+termRunId
     +'?cols='+termObj.cols+'&rows='+termObj.rows);
-  termWS.onopen = ()=>{
+  termWS = sock;
+  sock.onopen = ()=>{
+    if (sock!==termWS){ try{ sock.close(); }catch{} return; }
     termRetry = 0;
     $('termTitle').textContent = ((runs.get(termRunId)||{}).tmuxWindow||'terminal');
     termObj.focus();
   };
-  termWS.onmessage = (m)=>{
+  sock.onmessage = (m)=>{
+    if (sock!==termWS || !termObj) return;
     try{
       const d = JSON.parse(m.data);
       if (d.t==='o') termObj.write(d.d);
@@ -1173,7 +1184,8 @@ function termConnect(){
       else if (d.t==='exit') termObj.write('\\r\\n\\x1b[90m[session ended — reconnecting will revive it]\\x1b[0m\\r\\n');
     }catch{}
   };
-  termWS.onclose = ()=>{
+  sock.onclose = ()=>{
+    if (sock!==termWS) return;
     if (termClosing || termRunId==null) return;
     // 예기치 않은 끊김 — 백오프 재연결(서버가 죽은 세션도 소생시킴)
     const delay = Math.min(8000, 800 * Math.pow(2, termRetry++));
@@ -1204,6 +1216,9 @@ function termSwitch(id){
 }
 function openTerm(runId){
   const r = runs.get(runId); if(!r) return;
+  // 재진입 방어 — 이전 소켓/타이머가 남아 있으면 정리(중복 attach 방지)
+  if (termRetryTimer){ clearTimeout(termRetryTimer); termRetryTimer=null; }
+  if (termWS){ const old=termWS; termWS=null; try{ old.close(); }catch{} }
   termRunId = runId; termClosing = false; termRetry = 0;
   $('termRid').textContent = 'r'+runId;
   $('termTitle').textContent = (r.tmuxWindow||'terminal');
@@ -1319,7 +1334,7 @@ $('taskForm').addEventListener('submit', async (e)=>{
   if (!t.ok){ toast('task create failed', 'error'); return; }
   tasks.set(t.task.id, t.task);
   await fetch('/api/tasks/'+t.task.id+'/run',{method:'POST',headers:{'content-type':'application/json'},
-    body:JSON.stringify({count:Number($('taskCount').value)||1, real: $('taskReal').checked})});
+    body:JSON.stringify({count:Number($('taskCount').value)||1, real: $('taskReal').checked, agent: selAgent})});
   $('taskTitle').value=''; $('taskPrompt').value='';
 });
@@ -1339,6 +1354,23 @@ let savedMode = null;
 try { savedMode = localStorage.getItem('coxpit.real'); } catch {}
 setMode(savedMode === '1', false);
+/* ── provider segmented control — Task 탭 전용(Goal 플래너·Workbench 는 무관) ── */
+let selAgent = 'claude-code';
+const provOpts = Array.from(document.querySelectorAll('#provSeg .seg-opt'));
+function setProvider(id, persist){
+  selAgent = id;
+  for (const b of provOpts){
+    const on = b.dataset.agent === id;
+    b.classList.toggle('on', on);
+    b.setAttribute('aria-pressed', on ? 'true' : 'false');
+  }
+  if (persist) try { localStorage.setItem('coxpit.agent', id); } catch {}
+}
+for (const b of provOpts) b.addEventListener('click', ()=>setProvider(b.dataset.agent, true));
+let savedAgent = null;
+try { savedAgent = localStorage.getItem('coxpit.agent'); } catch {}
+if (savedAgent === 'codex') setProvider('codex', false);
 hydrate().then(connectWS);
 </script>
 </body>

package/src/config.ts CHANGED Viewed

@@ -73,6 +73,13 @@ export const config = {
     // 완전 자율은 bypassPermissions.
     perm: process.env.COXPIT_AGENT_PERM ?? 'acceptEdits',
   },
+  codex: {
+    // 두 번째 프로바이더 — OpenAI Codex CLI (선택 설치). providers.ts 의 시임.
+    bin: process.env.COXPIT_CODEX_BIN ?? 'codex',
+    // workspace-write = acceptEdits 상응(워크스페이스 안 편집 자동허용).
+    // 완전 자율은 danger-full-access.
+    sandbox: process.env.COXPIT_CODEX_SANDBOX ?? 'workspace-write',
+  },
   auth: {
     disabled: process.env.COXPIT_AUTH_DISABLED === '1',
     user: process.env.COXPIT_AUTH_USER ?? 'admin',

package/src/orchestrator.ts CHANGED Viewed

@@ -10,15 +10,13 @@ import { db } from './db';
 import { agentRuns, agentEvents, tasks, repos, machines, designCaptures } from './db/schema';
 import { runShellOn, spawnShellOn, shq, type MachineTarget } from './exec';
 import { broadcast } from './hub';
+import { getProvider, type Provider } from './providers';
 /** 에이전트 실행 커맨드. 드라이런=모의 stream-json + 실제 파일 1건 변경. */
-function agentCommand(prompt: string, real: boolean): string {
-  if (real) {
-    // claude-code headless. stream-json 라인이 stdout 으로 흐른다.
-    return `${config.agent.bin} -p ${shq(prompt)} --output-format stream-json --verbose` +
-      ` --permission-mode ${config.agent.perm}`;
-  }
-  // 모의: init → assistant → (파일 변경) → result. 진짜 stream-json 라인 형태.
+function agentCommand(provider: Provider, prompt: string, real: boolean): string {
+  if (real) return provider.launchCmd(prompt);
+  // 모의: init → assistant → (파일 변경) → result. claude stream-json 라인 형태
+  // (드라이런은 프로바이더 불문 배관 리허설 — claude 파서가 처리한다).
   return [
     `printf '%s\\n' '{"type":"system","subtype":"init","session":"dryrun"}'`,
     `printf '%s\\n' '{"type":"assistant","text":"planning: '"$(printf %s ${shq(prompt)} | cut -c1-40)"'"}'`,
@@ -70,6 +68,7 @@ interface RunContext {
   baseBranch: string;
   prompt: string;
   real: boolean;
+  agent: string;
 }
 async function loadContext(runId: number): Promise<RunContext | null> {
@@ -107,7 +106,8 @@ async function loadContext(runId: number): Promise<RunContext | null> {
     repoPath: repo.path,
     baseBranch: repo.defaultBranch,
     prompt,
-    real: run.agent === 'claude-code' ? config.agent.real : config.agent.real,
+    real: config.agent.real,
+    agent: run.agent,
   };
 }
@@ -153,8 +153,10 @@ export async function launchRun(runId: number, real?: boolean): Promise<void> {
     // 원격은 ssh 채널이 죽어도 프로세스가 남을 수 있어 pid 파일을 남긴다(stop 시 원격 kill).
     const isRemote = ctx.machine.kind !== 'local' && ctx.machine.address !== '';
     const pidPrefix = isRemote ? `printf '%s' "$$" > .coxpit-agent.pid && ` : '';
-    const cmd = `cd ${shq(wtPath)} && ${pidPrefix}{ ${agentCommand(ctx.prompt, useReal)}; }`;
-    await runAgentChild(runId, ctx.machine, wtPath, cmd);
+    // 드라이런 모의 스트림은 claude 형태 — 파서도 claude 로 (배관 리허설은 프로바이더 불문)
+    const provider = useReal ? getProvider(ctx.agent) : getProvider('claude-code');
+    const cmd = `cd ${shq(wtPath)} && ${pidPrefix}{ ${agentCommand(provider, ctx.prompt, useReal)}; }`;
+    await runAgentChild(runId, ctx.machine, wtPath, cmd, provider);
   } catch (e) {
     await recordEvent(runId, 'error', String(e).slice(0, 500));
     await setRun(runId, { status: 'error', endedAt: new Date(), exitSummary: 'orchestrator error' });
@@ -162,10 +164,10 @@ export async function launchRun(runId: number, real?: boolean): Promise<void> {
 }
 /**
- * 에이전트 자식 프로세스 배선(공용) — stream-json 파싱→이벤트, session 캡처,
- * 종료 시 files_changed 집계 + 상태 전이. launchRun/steerRun 이 공유.
+ * 에이전트 자식 프로세스 배선(공용) — 프로바이더가 stdout 라인을 정규화 이벤트로
+ * 파싱, session 캡처, 종료 시 files_changed 집계 + 상태 전이. launchRun/steerRun 공유.
  */
-async function runAgentChild(runId: number, machine: MachineTarget, wtPath: string, cmd: string): Promise<void> {
+async function runAgentChild(runId: number, machine: MachineTarget, wtPath: string, cmd: string, provider: Provider): Promise<void> {
   const child = spawnShellOn(machine, cmd);
   liveChildren.set(runId, child);
@@ -173,44 +175,11 @@ async function runAgentChild(runId: number, machine: MachineTarget, wtPath: stri
   if (child.stdout) {
     const rl = createInterface({ input: child.stdout });
     rl.on('line', (line: string) => {
-      const s = line.trim();
-      if (!s) return;
-      let kind = 'log';
-      let stored = s;
-      try {
-        const obj = JSON.parse(s) as {
-          type?: string; subtype?: string; model?: string; result?: string; session_id?: string;
-          message?: { content?: Array<{ type?: string; text?: string; name?: string; input?: Record<string, unknown> }> };
-        };
-        if (obj.type) kind = obj.type;
-        // steer(--resume) 용 세션 키 캡처
-        if (obj.type === 'system' && typeof obj.session_id === 'string') {
-          void setRun(runId, { sessionId: obj.session_id });
-        }
-        // result 이벤트의 사람이 읽는 요약만 뽑아 둔다(없으면 원본 라인).
-        if (obj.type === 'result') lastResult = typeof obj.result === 'string' ? obj.result : s;
-        // 2000자 초과 이벤트는 자르면 JSON 이 깨져 잔해가 화면에 노출된다 —
-        // 저장 전에 "요지만 남긴" 유효 JSON 으로 압축한다.
-        if (s.length > 2000) {
-          if (obj.type === 'assistant' && obj.message) {
-            const content = (obj.message.content ?? [])
-              .filter((c) => c.type === 'text' || c.type === 'tool_use')
-              .map((c) => c.type === 'text'
-                ? { type: 'text', text: (c.text ?? '').slice(0, 600) }
-                : { type: 'tool_use', name: c.name, input: compactInput(c.input) });
-            stored = JSON.stringify({ type: 'assistant', message: { content } }).slice(0, 2000);
-          } else if (obj.type === 'user') {
-            stored = JSON.stringify({ type: 'user' }); // tool 결과 회신 — 표시 안 함
-          } else if (obj.type === 'system') {
-            stored = JSON.stringify({ type: 'system', subtype: obj.subtype, model: obj.model });
-          } else if (obj.type === 'result') {
-            stored = JSON.stringify({ type: 'result', result: (obj.result ?? '').slice(0, 1500) });
-          } else {
-            stored = s.slice(0, 2000);
-          }
-        }
-      } catch { stored = s.slice(0, 2000); /* 비-JSON 로그 라인 */ }
-      void recordEvent(runId, kind, stored.slice(0, 2000));
+      const p = provider.parseLine(line);
+      if (!p) return;
+      if (p.sessionId) void setRun(runId, { sessionId: p.sessionId }); // steer(resume)용 세션 키
+      if (p.resultText != null) lastResult = p.resultText;
+      void recordEvent(runId, p.kind, p.stored.slice(0, 2000));
     });
   }
   if (child.stderr) {
@@ -237,16 +206,6 @@ async function runAgentChild(runId: number, machine: MachineTarget, wtPath: stri
   void notifySettle(runId, status, filesChanged, exitSummary);
 }
-/** tool_use input 을 표시용 핵심 필드만 남긴다(이벤트 압축용). */
-function compactInput(input?: Record<string, unknown>): Record<string, string> {
-  const out: Record<string, string> = {};
-  if (!input) return out;
-  for (const k of ['file_path', 'command', 'path', 'pattern', 'url']) {
-    if (typeof input[k] === 'string') out[k] = (input[k] as string).slice(0, 200);
-  }
-  return out;
-}
 /** run 정착 웹훅(선택) — COXPIT_WEBHOOK_URL 로 JSON POST. 실패는 무해. */
 async function notifySettle(runId: number, status: string, filesChanged: number, exitSummary: string): Promise<void> {
   if (!config.webhookUrl) return;
@@ -293,10 +252,10 @@ export async function steerRun(runId: number, message: string, mode: 'work' | 'a
   const isRemote = ctx.machine.kind !== 'local' && ctx.machine.address !== '';
   const pidPrefix = isRemote ? `printf '%s' "$$" > .coxpit-agent.pid && ` : '';
-  const resume = `${config.agent.bin} -p --resume ${shq(run.sessionId)} ${shq(finalMessage)}` +
-    ` --output-format stream-json --verbose --permission-mode ${config.agent.perm}`;
+  const provider = getProvider(ctx.agent);
+  const resume = provider.resumeCmd(run.sessionId, finalMessage);
   const cmd = `cd ${shq(wt)} && ${pidPrefix}{ ${resume}; }`;
-  void runAgentChild(runId, ctx.machine, wt, cmd);
+  void runAgentChild(runId, ctx.machine, wt, cmd, provider);
   return { ok: true, detail: 'steering' };
 }

package/src/providers.ts ADDED Viewed

@@ -0,0 +1,186 @@
+import { config } from './config';
+import { shq } from './exec';
+/**
+ * Provider seam — coxpit 은 "에이전트들"을 오케스트레이션한다(특정 에이전트가 아니라).
+ * 각 프로바이더는 세 가지만 답하면 된다:
+ *   1) 헤드리스 1회 실행 커맨드는 무엇인가 (launchCmd)
+ *   2) 정착한 세션을 어떻게 이어가는가 (resumeCmd)
+ *   3) stdout 한 줄을 coxpit 이벤트로 어떻게 정규화하는가 (parseLine)
+ * 정규화 목표 = 보드가 이미 아는 형태({type:'assistant',text}·tool_use·result)로
+ * 수렴시키는 것. 보드는 프로바이더를 모른다.
+ */
+export interface ParsedEvent {
+  kind: string;
+  stored: string;
+  /** steer(세션 이어가기)용 세션 키 — 이 라인에서 발견되면 채운다 */
+  sessionId?: string;
+  /** 사람이 읽는 최종 요약 후보 — 마지막 값이 exitSummary 가 된다 */
+  resultText?: string;
+}
+export interface Provider {
+  id: string;
+  label: string;
+  bin: string;
+  launchCmd(prompt: string): string;
+  resumeCmd(sessionId: string, message: string): string;
+  /** null = 저장하지 않는 라인(스트림 잡음) */
+  parseLine(raw: string): ParsedEvent | null;
+}
+/** tool_use input 을 표시용 핵심 필드만 남긴다(이벤트 압축용). */
+function compactInput(input?: Record<string, unknown>): Record<string, string> {
+  const out: Record<string, string> = {};
+  if (!input) return out;
+  for (const k of ['file_path', 'command', 'path', 'pattern', 'url']) {
+    if (typeof input[k] === 'string') out[k] = (input[k] as string).slice(0, 200);
+  }
+  return out;
+}
+/** 보드 tool 렌더용 정규화 tool_use 이벤트 */
+function toolEvent(name: string, input: Record<string, string>): string {
+  return JSON.stringify({ type: 'assistant', message: { content: [{ type: 'tool_use', name, input }] } });
+}
+// ─── claude-code ────────────────────────────────────────────────
+// stream-json: {type:system|assistant|user|result, ...} 라인. 세션 키 = system.session_id.
+const claudeProvider: Provider = {
+  id: 'claude-code',
+  label: 'Claude Code',
+  get bin() { return config.agent.bin; },
+  launchCmd(prompt: string): string {
+    return `${config.agent.bin} -p ${shq(prompt)} --output-format stream-json --verbose` +
+      ` --permission-mode ${config.agent.perm}`;
+  },
+  resumeCmd(sessionId: string, message: string): string {
+    return `${config.agent.bin} -p --resume ${shq(sessionId)} ${shq(message)}` +
+      ` --output-format stream-json --verbose --permission-mode ${config.agent.perm}`;
+  },
+  parseLine(raw: string): ParsedEvent | null {
+    const s = raw.trim();
+    if (!s) return null;
+    let kind = 'log';
+    let stored = s;
+    const ev: ParsedEvent = { kind, stored };
+    try {
+      const obj = JSON.parse(s) as {
+        type?: string; subtype?: string; model?: string; result?: string; session_id?: string;
+        message?: { content?: Array<{ type?: string; text?: string; name?: string; input?: Record<string, unknown> }> };
+      };
+      if (obj.type) kind = obj.type;
+      if (obj.type === 'system' && typeof obj.session_id === 'string') ev.sessionId = obj.session_id;
+      if (obj.type === 'result') ev.resultText = typeof obj.result === 'string' ? obj.result : s;
+      // 2000자 초과 이벤트는 자르면 JSON 이 깨져 잔해가 화면에 노출된다 —
+      // 저장 전에 "요지만 남긴" 유효 JSON 으로 압축한다.
+      if (s.length > 2000) {
+        if (obj.type === 'assistant' && obj.message) {
+          const content = (obj.message.content ?? [])
+            .filter((c) => c.type === 'text' || c.type === 'tool_use')
+            .map((c) => c.type === 'text'
+              ? { type: 'text', text: (c.text ?? '').slice(0, 600) }
+              : { type: 'tool_use', name: c.name, input: compactInput(c.input) });
+          stored = JSON.stringify({ type: 'assistant', message: { content } }).slice(0, 2000);
+        } else if (obj.type === 'user') {
+          stored = JSON.stringify({ type: 'user' }); // tool 결과 회신 — 표시 안 함
+        } else if (obj.type === 'system') {
+          stored = JSON.stringify({ type: 'system', subtype: obj.subtype, model: obj.model });
+        } else if (obj.type === 'result') {
+          stored = JSON.stringify({ type: 'result', result: (obj.result ?? '').slice(0, 1500) });
+        } else {
+          stored = s.slice(0, 2000);
+        }
+      }
+    } catch { stored = s.slice(0, 2000); /* 비-JSON 로그 라인 */ }
+    ev.kind = kind;
+    ev.stored = stored.slice(0, 2000);
+    return ev;
+  },
+};
+// ─── codex ──────────────────────────────────────────────────────
+// codex exec --json: JSONL 이벤트(thread.started·turn.*·item.completed·error).
+// 세션 키 = thread.started.thread_id, resume = `codex exec resume <id>`.
+// 이벤트는 보드가 아는 claude 형태로 정규화해 저장한다.
+interface CodexItem {
+  type?: string; text?: string; command?: string; exit_code?: number;
+  changes?: Array<{ path?: string; kind?: string }>;
+  server?: string; tool?: string; query?: string;
+}
+const codexProvider: Provider = {
+  id: 'codex',
+  label: 'Codex',
+  get bin() { return config.codex.bin; },
+  launchCmd(prompt: string): string {
+    return `${config.codex.bin} exec --json --sandbox ${config.codex.sandbox} ${shq(prompt)}`;
+  },
+  resumeCmd(sessionId: string, message: string): string {
+    // --sandbox 는 exec 의 플래그(resume 서브커맨드는 안 받음) — 반드시 resume 앞에.
+    return `${config.codex.bin} exec --json --sandbox ${config.codex.sandbox} resume ${shq(sessionId)} ${shq(message)}`;
+  },
+  parseLine(raw: string): ParsedEvent | null {
+    const s = raw.trim();
+    if (!s) return null;
+    let obj: { type?: string; thread_id?: string; message?: string; item?: CodexItem };
+    try { obj = JSON.parse(s) as typeof obj; } catch {
+      return { kind: 'log', stored: s.slice(0, 2000) }; // 비-JSON 로그 라인
+    }
+    switch (obj.type) {
+      case 'thread.started':
+        return {
+          kind: 'system',
+          stored: JSON.stringify({ type: 'system', subtype: 'init', model: 'codex' }),
+          sessionId: typeof obj.thread_id === 'string' ? obj.thread_id : undefined,
+        };
+      case 'item.completed': {
+        const it = obj.item ?? {};
+        if (it.type === 'agent_message' && typeof it.text === 'string') {
+          return {
+            kind: 'assistant',
+            stored: JSON.stringify({ type: 'assistant', text: it.text.slice(0, 1500) }),
+            resultText: it.text, // 마지막 agent_message = 최종 요약
+          };
+        }
+        if (it.type === 'command_execution') {
+          return { kind: 'assistant', stored: toolEvent('shell', { command: (it.command ?? '').slice(0, 200) }) };
+        }
+        if (it.type === 'file_change') {
+          const paths = (it.changes ?? []).map((c) => c.path ?? '').filter(Boolean);
+          return { kind: 'assistant', stored: toolEvent('edit', { file_path: paths.join(', ').slice(0, 200) }) };
+        }
+        if (it.type === 'mcp_tool_call') {
+          return { kind: 'assistant', stored: toolEvent(`${it.server ?? 'mcp'}.${it.tool ?? 'tool'}`, {}) };
+        }
+        if (it.type === 'web_search') {
+          return { kind: 'assistant', stored: toolEvent('web_search', { pattern: (it.query ?? '').slice(0, 120) }) };
+        }
+        return null; // reasoning·plan_update 등 — 표시 잡음
+      }
+      case 'error':
+        return { kind: 'error', stored: (obj.message ?? s).slice(0, 500) };
+      default:
+        return null; // turn.started/completed·item.started/updated — 잡음
+    }
+  },
+};
+// ─── registry ───────────────────────────────────────────────────
+const registry: Record<string, Provider> = {
+  [claudeProvider.id]: claudeProvider,
+  [codexProvider.id]: codexProvider,
+};
+/** run.agent → Provider. 미지의 값(workbench 포함)은 claude 로 폴백. */
+export function getProvider(agentId: string | null | undefined): Provider {
+  return registry[agentId ?? ''] ?? claudeProvider;
+}
+export function listProviders(): Array<{ id: string; label: string; bin: string }> {
+  return Object.values(registry).map((p) => ({ id: p.id, label: p.label, bin: p.bin }));
+}

package/src/server.ts CHANGED Viewed

@@ -15,6 +15,7 @@ import { runShellOn, shq } from './exec';
 import { launchRun, cleanupRun, stopRun, getRunDiff, mergeRun, getRunTermInfo, steerRun, exportRun, prRun, integrateRuns, planFanout, reviewTask, syncRun, openWorkbench } from './orchestrator';
 import { openTerm } from './term';
 import { addSink, removeSink, broadcast } from './hub';
+import { getProvider, listProviders } from './providers';
 import { BOARD_HTML } from './board';
 const require_ = createRequire(import.meta.url);
@@ -59,6 +60,7 @@ export async function buildServer(): Promise<FastifyInstance> {
       runs: rns.map((r) => ({ ...r, events: byRun.get(r.id) ?? [] })),
       // 보드 헤더 "어느 데몬에 붙어 있나" 표시용 (인증 뒤라 dbPath 노출 가능)
       daemon: { version: config.version, pid: process.pid, port: config.port, dbPath: config.dbPath },
+      providers: listProviders(),
     };
   });
@@ -103,10 +105,12 @@ export async function buildServer(): Promise<FastifyInstance> {
     if (!m) return reply.code(404).send({ error: 'not found' });
     const agentBin = config.agent.bin;
+    const codexBin = config.codex.bin;
     const cmd = [
       'echo GIT:$(git --version 2>&1)',
       'echo TMUX:$(tmux -V 2>&1)',
       `echo AGENT:$(command -v ${shq(agentBin)} >/dev/null 2>&1 && ${shq(agentBin)} --version 2>/dev/null | head -1 || echo missing)`,
+      `echo CODEX:$(command -v ${shq(codexBin)} >/dev/null 2>&1 && ${shq(codexBin)} --version 2>/dev/null | head -1 || echo missing)`,
       'echo OS:$(uname -sr 2>&1)',
     ].join('; ');
     const r = await runShellOn(m, cmd, 20000);
@@ -118,11 +122,14 @@ export async function buildServer(): Promise<FastifyInstance> {
     const gitStr = pick('GIT');
     const tmuxStr = pick('TMUX');
     const agentStr = pick('AGENT');
+    const codexStr = pick('CODEX');
     const reachable = r.ok;
     const git = { ok: /git version/i.test(gitStr), version: gitStr };
     const tmux = { ok: /tmux \d/i.test(tmuxStr), version: tmuxStr };
     // 에이전트 CLI 존재 여부(인증까지는 여기서 알 수 없음 — 첫 real run 이 판정)
     const agent = { ok: agentStr !== '' && agentStr !== 'missing', version: agentStr, bin: agentBin };
+    // 두 번째 프로바이더(선택) — 없어도 ready 판정엔 영향 없음
+    const codex = { ok: codexStr !== '' && codexStr !== 'missing', version: codexStr, bin: codexBin };
     await db.update(machines)
       .set({ online: reachable, lastSeen: new Date() })
@@ -130,7 +137,7 @@ export async function buildServer(): Promise<FastifyInstance> {
     return {
       slug, reachable,
-      git, tmux, agent, os: pick('OS'),
+      git, tmux, agent, codex, os: pick('OS'),
       ready: reachable && git.ok && tmux.ok,
       error: reachable ? undefined : (r.stderr.trim() || `ssh exit ${r.code}`),
     };
@@ -312,7 +319,8 @@ export async function buildServer(): Promise<FastifyInstance> {
     if (!rp[0]) return reply.code(404).send({ error: 'repo missing' });
     const count = Math.max(1, Math.min(8, Number(b.count) || 1));
-    const agent = b.agent ?? 'claude-code';
+    // 미지의 값은 기본 프로바이더로 정규화(런처 조작·API 오타 방어)
+    const agent = getProvider(b.agent).id;
     const created: Array<typeof agentRuns.$inferSelect> = [];
     for (let i = 0; i < count; i++) {
       const ins = await db.insert(agentRuns)