Skip to content
TypeScript
4.7 KB
Raw Blame
/**
 * Claude Code 러너 (PRD §7).
 * `claude -p "<instruction>" --output-format json --model <id> --dangerously-skip-permissions [--plugin-dir <harness>]`
 * 세션 transcript + subagents/ 를 work_dir 로 복사. 끝나면 verify(taskId, work) 로 resolved.
 * fail-soft: 절대 throw 금지, 항상 output.txt + transcript.jsonl.
 */
import { copyFileSync, existsSync, mkdirSync, readdirSync, writeFileSync } from "node:fs";
import { homedir } from "node:os";
import { join } from "node:path";
import { instructionFor, isLocalBench, setupTask, taskIds, verify } from "../benches/index";
import { parseComboId } from "../combos";
import { resolveModelAlias } from "../config";
import { harnessClaudeArgs } from "../harness";
import { CcHeadlessSchema, type RawRunArtifact, type RunInvocation } from "../models";
import { type RunnerAdapter, RunnerUnavailable } from "./base";
import { commandExists, execCapture } from "./util";

export class ClaudeCodeRunner implements RunnerAdapter {
  name = "cc";

  isAvailable(): boolean {
    return commandExists("claude");
  }

  loadTaskCatalog(bench: string): string[] {
    if (isLocalBench(bench)) return taskIds(bench);
    throw new RunnerUnavailable(`cc runner: external bench '${bench}' not supported directly`);
  }

  async run(inv: RunInvocation): Promise<RawRunArtifact> {
    const { model, harness } = parseComboId(inv.combo.comboId);
    const work = inv.workDir;
    mkdirSync(work, { recursive: true });
    const resultPath = join(work, "output.txt");
    const transcriptPath = join(work, "transcript.jsonl");

    if (isLocalBench(inv.bench)) setupTask(inv.taskId, work);

    const instruction =
      inv.instruction ?? instructionFor(inv.taskId) ?? `Complete task ${inv.taskId}`;
    const resolved = resolveModelAlias(model);
    const args = [
      "-p",
      instruction,
      "--output-format",
      "json",
      "--dangerously-skip-permissions",
      ...(resolved && resolved !== "default" ? ["--model", resolved] : []),
      ...harnessClaudeArgs(harness),
    ];

    const res = await execCapture("claude", args, { cwd: work, timeoutS: inv.timeoutS });

    let costUsd: number | null = null;
    let numTurns: number | null = null;
    let sessionId = "";
    let resultText = res.stdout;
    let ok = res.error === null && !res.timedOut;

    try {
      const parsed = CcHeadlessSchema.parse(JSON.parse(res.stdout));
      costUsd = parsed.total_cost_usd ?? null;
      numTurns = parsed.num_turns ?? null;
      sessionId = parsed.session_id ?? "";
      resultText = parsed.result ?? res.stdout;
      if (parsed.is_error) ok = false;
    } catch {
      // 비-JSON 출력도 fail-soft: 결과 텍스트 유지
    }

    writeFileSync(resultPath, resultText || res.stderr || "(no output)");

    // 세션 transcript + subagents/ 복사
    const copied = sessionId ? this.copySession(sessionId, work, transcriptPath) : false;
    if (!copied) {
      // 최소 transcript 합성(파서가 토큰만이라도 읽도록)
      writeFileSync(transcriptPath, this.fallbackTranscript(res.stdout, model, sessionId));
    }

    const rawResolved = isLocalBench(inv.bench) ? verify(inv.taskId, work) : null;

    return {
      invocation: inv,
      success: ok,
      resultPath,
      transcriptPath,
      wallTimeMs: res.wallTimeMs,
      rawResolved,
      totalCostUsd: costUsd,
      numTurns,
      error: res.error ?? (res.timedOut ? "timeout" : null),
    };
  }

  // ~/.claude/projects/<proj>/<session>.jsonl + subagents/ 탐색·복사
  private copySession(sessionId: string, work: string, transcriptPath: string): boolean {
    const root = join(homedir(), ".claude", "projects");
    if (!existsSync(root)) return false;
    try {
      for (const proj of readdirSync(root)) {
        const dir = join(root, proj);
        const file = join(dir, `${sessionId}.jsonl`);
        if (existsSync(file)) {
          copyFileSync(file, transcriptPath);
          const subSrc = join(dir, "subagents");
          if (existsSync(subSrc)) {
            const subDst = join(work, "transcript_subagents");
            mkdirSync(subDst, { recursive: true });
            for (const f of readdirSync(subSrc)) copyFileSync(join(subSrc, f), join(subDst, f));
          }
          return true;
        }
      }
    } catch {
      return false;
    }
    return false;
  }

  private fallbackTranscript(stdout: string, model: string, sessionId: string): string {
    let usage: any = {};
    try {
      usage = JSON.parse(stdout).usage ?? {};
    } catch {
      // ignore
    }
    return `${JSON.stringify({
      type: "assistant",
      uuid: "fallback",
      parentUuid: null,
      isSidechain: false,
      session_id: sessionId,
      message: { role: "assistant", model, usage, content: [{ type: "text", text: "result" }] },
    })}\n`;
  }
}