Move adapter implementations into shared workspace packages

Extract claude-local and codex-local adapter code from cli/server/ui
into packages/adapters/ and packages/adapter-utils/. CLI, server, and
UI now import shared adapter logic instead of duplicating it. Removes
~1100 lines of duplicated code across packages. Register new packages
in pnpm workspace.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

packages/adapters/codex-local/src/server/execute.ts

@@ -0,0 +1,117 @@
+import type { AdapterExecutionContext, AdapterExecutionResult } from "@paperclip/adapter-utils";
+import {
+  asString,
+  asNumber,
+  asBoolean,
+  asStringArray,
+  parseObject,
+  buildPaperclipEnv,
+  redactEnvForLogs,
+  ensureAbsoluteDirectory,
+  ensureCommandResolvable,
+  ensurePathInEnv,
+  renderTemplate,
+  runChildProcess,
+} from "@paperclip/adapter-utils/server-utils";
+import { parseCodexJsonl } from "./parse.js";
+
+export async function execute(ctx: AdapterExecutionContext): Promise<AdapterExecutionResult> {
+  const { runId, agent, runtime, config, context, onLog, onMeta } = ctx;
+
+  const promptTemplate = asString(
+    config.promptTemplate,
+    "You are agent {{agent.id}} ({{agent.name}}). Continue your Paperclip work.",
+  );
+  const bootstrapTemplate = asString(config.bootstrapPromptTemplate, promptTemplate);
+  const command = asString(config.command, "codex");
+  const model = asString(config.model, "");
+  const search = asBoolean(config.search, false);
+  const bypass = asBoolean(config.dangerouslyBypassApprovalsAndSandbox, false);
+
+  const cwd = asString(config.cwd, process.cwd());
+  await ensureAbsoluteDirectory(cwd);
+  const envConfig = parseObject(config.env);
+  const env: Record<string, string> = { ...buildPaperclipEnv(agent) };
+  for (const [k, v] of Object.entries(envConfig)) {
+    if (typeof v === "string") env[k] = v;
+  }
+  const runtimeEnv = ensurePathInEnv({ ...process.env, ...env });
+  await ensureCommandResolvable(command, cwd, runtimeEnv);
+
+  const timeoutSec = asNumber(config.timeoutSec, 1800);
+  const graceSec = asNumber(config.graceSec, 20);
+  const extraArgs = (() => {
+    const fromExtraArgs = asStringArray(config.extraArgs);
+    if (fromExtraArgs.length > 0) return fromExtraArgs;
+    return asStringArray(config.args);
+  })();
+
+  const sessionId = runtime.sessionId;
+  const template = sessionId ? promptTemplate : bootstrapTemplate;
+  const prompt = renderTemplate(template, {
+    company: { id: agent.companyId },
+    agent,
+    run: { id: runId, source: "on_demand" },
+    context,
+  });
+
+  const args = ["exec", "--json"];
+  if (search) args.unshift("--search");
+  if (bypass) args.push("--dangerously-bypass-approvals-and-sandbox");
+  if (model) args.push("--model", model);
+  if (extraArgs.length > 0) args.push(...extraArgs);
+  if (sessionId) args.push("resume", sessionId, prompt);
+  else args.push(prompt);
+
+  if (onMeta) {
+    await onMeta({
+      adapterType: "codex_local",
+      command,
+      cwd,
+      commandArgs: args.map((value, idx) => {
+        if (!sessionId && idx === args.length - 1) return `<prompt ${prompt.length} chars>`;
+        if (sessionId && idx === args.length - 1) return `<prompt ${prompt.length} chars>`;
+        return value;
+      }),
+      env: redactEnvForLogs(env),
+      prompt,
+      context,
+    });
+  }
+
+  const proc = await runChildProcess(runId, command, args, {
+    cwd,
+    env,
+    timeoutSec,
+    graceSec,
+    onLog,
+  });
+
+  if (proc.timedOut) {
+    return {
+      exitCode: proc.exitCode,
+      signal: proc.signal,
+      timedOut: true,
+      errorMessage: `Timed out after ${timeoutSec}s`,
+    };
+  }
+
+  const parsed = parseCodexJsonl(proc.stdout);
+
+  return {
+    exitCode: proc.exitCode,
+    signal: proc.signal,
+    timedOut: false,
+    errorMessage: (proc.exitCode ?? 0) === 0 ? null : `Codex exited with code ${proc.exitCode ?? -1}`,
+    usage: parsed.usage,
+    sessionId: parsed.sessionId ?? runtime.sessionId,
+    provider: "openai",
+    model,
+    costUsd: null,
+    resultJson: {
+      stdout: proc.stdout,
+      stderr: proc.stderr,
+    },
+    summary: parsed.summary,
+  };
+}

packages/adapters/codex-local/src/server/index.ts

@@ -0,0 +1,2 @@
+export { execute } from "./execute.js";
+export { parseCodexJsonl } from "./parse.js";

packages/adapters/codex-local/src/server/parse.ts

@@ -0,0 +1,47 @@
+import { asString, asNumber, parseObject, parseJson } from "@paperclip/adapter-utils/server-utils";
+
+export function parseCodexJsonl(stdout: string) {
+  let sessionId: string | null = null;
+  const messages: string[] = [];
+  const usage = {
+    inputTokens: 0,
+    cachedInputTokens: 0,
+    outputTokens: 0,
+  };
+
+  for (const rawLine of stdout.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) continue;
+
+    const event = parseJson(line);
+    if (!event) continue;
+
+    const type = asString(event.type, "");
+    if (type === "thread.started") {
+      sessionId = asString(event.thread_id, sessionId ?? "") || sessionId;
+      continue;
+    }
+
+    if (type === "item.completed") {
+      const item = parseObject(event.item);
+      if (asString(item.type, "") === "agent_message") {
+        const text = asString(item.text, "");
+        if (text) messages.push(text);
+      }
+      continue;
+    }
+
+    if (type === "turn.completed") {
+      const usageObj = parseObject(event.usage);
+      usage.inputTokens = asNumber(usageObj.input_tokens, usage.inputTokens);
+      usage.cachedInputTokens = asNumber(usageObj.cached_input_tokens, usage.cachedInputTokens);
+      usage.outputTokens = asNumber(usageObj.output_tokens, usage.outputTokens);
+    }
+  }
+
+  return {
+    sessionId,
+    summary: messages.join("\n\n").trim(),
+    usage,
+  };
+}