@bitkyc08/opencodex 2.52.0-preview.20260911 → 2.52.0

package/src/adapters/devin-cli/acp.ts

@@ -0,0 +1,204 @@
+/**
+ * Agent Client Protocol framing for the Devin CLI.
+ *
+ * `devin acp` speaks newline-delimited JSON-RPC on stdin/stdout. One ACP session
+ * answers one prompt, so a turn is: initialize -> session/new -> session/prompt,
+ * with session/update notifications streaming in between and a unary reply to
+ * the prompt carrying the stop reason and usage.
+ *
+ * This module is pure. It never spawns a process and never touches the network,
+ * so the framing and the event mapping are testable against captured lines, the
+ * same discipline src/adapters/coding-agent/protocol.ts follows for the
+ * stream-json CLIs.
+ */
+import type { AdapterEvent, OcxParsedRequest, OcxToolCall, OcxUsage } from "../../types";
+
+/** Hard ceiling on a single buffered stdout line. */
+export const MAX_ACP_LINE_BYTES = 8 * 1024 * 1024;
+/** Hard ceiling on total stdout bytes consumed for one turn. */
+export const MAX_ACP_TOTAL_BYTES = 64 * 1024 * 1024;
+
+export class AcpProtocolError extends Error {
+  readonly code = "protocol_error";
+  readonly status = 502;
+  constructor(message: string) {
+    super(message);
+    this.name = "AcpProtocolError";
+  }
+}
+
+export const ACP_INITIALIZE_ID = 1;
+export const ACP_SESSION_NEW_ID = 2;
+export const ACP_SESSION_PROMPT_ID = 3;
+
+export function initializeFrame(clientVersion: string): Record<string, unknown> {
+  return {
+    jsonrpc: "2.0",
+    id: ACP_INITIALIZE_ID,
+    method: "initialize",
+    params: { protocolVersion: 1, clientInfo: { name: "opencodex", version: clientVersion }, capabilities: {} },
+  };
+}
+
+export function sessionNewFrame(cwd: string, modelId?: string): Record<string, unknown> {
+  const params: Record<string, unknown> = { cwd, mcpServers: [] };
+  // The CLI picks its own default when no model is named, which is what an
+  // unset or vendor-default selection should do.
+  if (modelId) params.model = modelId;
+  return { jsonrpc: "2.0", id: ACP_SESSION_NEW_ID, method: "session/new", params };
+}
+
+export function sessionPromptFrame(sessionId: string, prompt: string): Record<string, unknown> {
+  return {
+    jsonrpc: "2.0",
+    id: ACP_SESSION_PROMPT_ID,
+    method: "session/prompt",
+    params: { sessionId, prompt: [{ type: "text", text: prompt }] },
+  };
+}
+
+/**
+ * Answer a permission request without a human.
+ *
+ * A headless turn has nobody to approve a tool call, and an unanswered
+ * `session/request_permission` stalls the agent until the turn times out. The
+ * answer is a refusal by default: this provider runs an agent in the operator's
+ * own tree, and auto-approving whatever it asks for would let any prompt that
+ * reaches the proxy read, write and execute there. Approval is an explicit
+ * operator decision, and only then is an allow-shaped option preferred over
+ * positional guessing — the first option in a real prompt is sometimes the
+ * rejection.
+ */
+export function permissionResponseFrame(
+  id: number | string,
+  options: Array<{ optionId?: string; name?: string; kind?: string }> | undefined,
+  allowed = false,
+): Record<string, unknown> {
+  if (!allowed) {
+    return { jsonrpc: "2.0", id, result: { outcome: { outcome: "cancelled" } } };
+  }
+  const list = options ?? [];
+  const allow =
+    list.find((o) => typeof o.kind === "string" && /^allow/i.test(o.kind)) ??
+    list.find((o) => /allow|accept|yes/i.test(`${o.optionId ?? ""} ${o.name ?? ""}`));
+  if (!allow?.optionId) {
+    // Nothing offered says "allow". Guessing at `list[0]` here is how an
+    // auto-answer selects a rejection and calls it approval.
+    return { jsonrpc: "2.0", id, result: { outcome: { outcome: "cancelled" } } };
+  }
+  return { jsonrpc: "2.0", id, result: { outcome: { outcome: "selected", optionId: allow.optionId } } };
+}
+
+/**
+ * Flatten an OcxContext into the single prompt string one ACP session takes.
+ *
+ * ACP has no multi-message history on session/prompt, so the conversation is
+ * projected into labelled blocks. Tool calls and results are rendered rather
+ * than dropped, because a turn that omits them loses the thread of a tool loop.
+ */
+export function buildAcpPrompt(parsed: OcxParsedRequest): string {
+  const blocks: string[] = [];
+  const system = parsed.context.systemPrompt?.filter((line) => line.trim().length > 0).join("\n");
+  if (system) blocks.push(fence("System", system));
+  for (const message of parsed.context.messages) {
+    if (message.role === "toolResult") {
+      const body = typeof message.content === "string" ? message.content : JSON.stringify(message.content ?? "");
+      blocks.push(fence("Tool", `[result id=${message.toolCallId}]\n${body}`));
+      continue;
+    }
+    const parts = typeof message.content === "string" ? [] : message.content;
+    let text = typeof message.content === "string"
+      ? message.content
+      : parts.map((p) => (p.type === "text" ? p.text : "")).filter(Boolean).join("\n");
+    if (message.role === "assistant" && Array.isArray(parts)) {
+      const calls = parts
+        .filter((p): p is OcxToolCall => p.type === "toolCall")
+        .map((c) => `[call ${c.name} id=${c.id}]\n${JSON.stringify(c.arguments ?? {})}`)
+        .join("\n\n");
+      if (calls) text = text ? `${text}\n\n${calls}` : calls;
+    }
+    if (!text.trim()) continue;
+    const label = message.role === "assistant" ? "Assistant" : message.role === "developer" ? "System" : "User";
+    blocks.push(fence(label, text));
+  }
+  if (blocks.length === 0) return "(empty)";
+  const joined = blocks.join("\n\n");
+  // Keep the oldest turns rather than the newest when trimming: the tail is
+  // what the agent is answering.
+  return joined.length > MAX_ACP_PROMPT_CHARS
+    ? `[truncated]\n${joined.slice(joined.length - MAX_ACP_PROMPT_CHARS)}`
+    : joined;
+}
+
+export type AcpTurnOutcome = { stopReason?: string; usage?: OcxUsage };
+
+/** ACP stop reasons that mean the turn ended normally. */
+const NATURAL_STOP = new Set(["end_turn", "stop", "completed"]);
+
+export function mapAcpStopReason(reason: unknown): string | undefined {
+  if (typeof reason !== "string" || NATURAL_STOP.has(reason)) return undefined;
+  if (reason === "max_tokens") return "max_tokens";
+  return reason;
+}
+
+export function mapAcpUsage(raw: unknown): OcxUsage | undefined {
+  if (!raw || typeof raw !== "object") return undefined;
+  const u = raw as Record<string, unknown>;
+  const input = typeof u.inputTokens === "number" ? u.inputTokens : 0;
+  const output = typeof u.outputTokens === "number" ? u.outputTokens : 0;
+  if (input === 0 && output === 0) return undefined;
+  const total = typeof u.totalTokens === "number" ? u.totalTokens : input + output;
+  return { inputTokens: input, outputTokens: output, ...(total > 0 ? { totalTokens: total } : {}) };
+}
+
+function chunkText(content: unknown): string {
+  if (typeof content === "string") return content;
+  if (content && typeof content === "object") {
+    const text = (content as { text?: unknown }).text;
+    if (typeof text === "string") return text;
+  }
+  return "";
+}
+
+/**
+ * Translate one session/update notification into adapter events.
+ *
+ * Tool lifecycle is explicit in ACP: `tool_call` opens one and
+ * `tool_call_update` with a terminal status closes it, so the caller does not
+ * have to infer boundaries from interleaving the way a delta-only wire forces.
+ */
+export function acpUpdateToEvents(update: Record<string, unknown>): AdapterEvent[] {
+  const kind = update.sessionUpdate;
+  if (kind === "agent_message_chunk") {
+    const text = chunkText(update.content);
+    return text ? [{ type: "text_delta", text }] : [];
+  }
+  if (kind === "agent_thought_chunk") {
+    const text = chunkText(update.content);
+    return text ? [{ type: "thinking_delta", thinking: text }] : [];
+  }
+  // The CLI's own tool calls are NOT client tools. Devin executes them itself
+  // inside its session, so emitting tool_call_start here would either fail the
+  // turn — the Responses bridge rejects a tool Codex never declared — or ask
+  // Codex to run something the agent has already run. Vendor tools stay
+  // internal and Codex keeps ownership of mutation, which is the same rule the
+  // CodeBuddy and Qoder adapters follow.
+  //
+  // They are not dropped silently, though. A Devin tool operation that runs
+  // longer than the bridge's stall timeout would otherwise look like upstream
+  // silence and get the still-working turn aborted, so an internal update
+  // becomes a heartbeat: proof of life without a client-visible tool.
+  if (kind === "tool_call" || kind === "tool_call_update" || kind === "plan" || kind === "current_mode_update") {
+    return [{ type: "heartbeat" }];
+  }
+  return [];
+}
+/** Ceiling on the flattened conversation handed to one ACP prompt. */
+export const MAX_ACP_PROMPT_CHARS = 200_000;
+
+/** Fence a block label so a message body cannot forge one. */
+function fence(label: string, body: string): string {
+  // A user or tool result that contains a line reading `[System]` would
+  // otherwise appear to open a system block in the flattened prompt.
+  return `[${label}]\n${body.replace(/^\[(System|User|Assistant|Tool)\]/gm, " $&")}`;
+}

package/src/adapters/devin-cli/adapter.ts

@@ -0,0 +1,345 @@
+/**
+ * Devin CLI adapter: one ACP session per turn over stdio.
+ *
+ * This is the local half of Devin support. The cloud-direct `devin` adapter
+ * talks to Cognition's api-server; this one drives the installed `devin` CLI,
+ * which carries its own credentials from `devin auth login`, so the proxy never
+ * sees a token for this provider.
+ *
+ * runTurn-only, like the Cursor and cloud Devin adapters: a JSON-RPC handshake
+ * over a child process has no fetch-shaped request to hand to the generic wire
+ * path.
+ *
+ * The child is treated as untrusted and unprivileged. It gets a scoped
+ * environment rather than the proxy's, its permission requests are refused
+ * unless an operator opted in, and it is reaped rather than merely signalled,
+ * because a Devin grandchild that ignores SIGTERM would otherwise keep writing
+ * in the operator's tree after the turn returned.
+ */
+import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
+import type { AdapterEvent, OcxParsedRequest, OcxProviderConfig, OcxUsage } from "../../types";
+import type { IncomingMeta, ProviderAdapter } from "../base";
+import { baseScopedEnv } from "../coding-agent/turn";
+import {
+  ACP_INITIALIZE_ID,
+  ACP_SESSION_NEW_ID,
+  ACP_SESSION_PROMPT_ID,
+  MAX_ACP_LINE_BYTES,
+  MAX_ACP_TOTAL_BYTES,
+  acpUpdateToEvents,
+  buildAcpPrompt,
+  initializeFrame,
+  mapAcpStopReason,
+  mapAcpUsage,
+  permissionResponseFrame,
+  sessionNewFrame,
+  sessionPromptFrame,
+} from "./acp";
+import { DEVIN_CLI_INSTALL_HINT, resolveDevinCliBinary } from "./binary";
+
+/** A turn that has not produced a prompt reply by this point is abandoned. */
+const DEVIN_CLI_TURN_TIMEOUT_MS = 10 * 60 * 1000;
+/** Grace between SIGTERM and SIGKILL when reaping the child. */
+const DEVIN_CLI_KILL_GRACE_MS = 2_000;
+/** How long to wait for the child to actually exit before giving up on it. */
+const DEVIN_CLI_REAP_MS = 5_000;
+
+/**
+ * Identity URL for the provider. The CLI does the real transport over stdio;
+ * this is only what the configuration records as the destination, and it has to
+ * be an http(s) URL because provider config validation rejects other schemes.
+ */
+export const DEVIN_CLI_IDENTITY_URL = "https://cli.devin.ai";
+
+/**
+ * Opt-in for letting the CLI act on the machine.
+ *
+ * Off by default: this provider runs an agent in the operator's own tree, and a
+ * proxy that auto-approves whatever a prompt asks for is a remote shell.
+ */
+const DEVIN_CLI_ALLOW_TOOLS_ENV = "OPENCODEX_DEVIN_CLI_ALLOW_TOOLS";
+
+export type DevinCliSpawn = (binary: string, args: string[], options: { cwd: string; env: Record<string, string> }) => ChildProcessWithoutNullStreams;
+
+export function devinCliToolsAllowed(env: NodeJS.ProcessEnv = process.env): boolean {
+  const raw = env[DEVIN_CLI_ALLOW_TOOLS_ENV]?.trim().toLowerCase();
+  return raw === "1" || raw === "true" || raw === "yes";
+}
+
+export function createDevinCliAdapter(provider: OcxProviderConfig, deps?: { spawn?: DevinCliSpawn }): ProviderAdapter {
+  const spawnChild: DevinCliSpawn = deps?.spawn
+    ?? ((binary, args, options) => spawn(binary, args, {
+      ...options,
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true,
+      // Give the child its own process group on POSIX so the reap below can
+      // signal the whole tree. Devin spawns shells and tools of its own when
+      // the operator allows them, and signalling only the direct pid leaves
+      // those descendants writing in the operator's tree after the turn ended.
+      detached: process.platform !== "win32",
+    }) as ChildProcessWithoutNullStreams);
+
+  return {
+    name: "devin-cli",
+
+    buildRequest() {
+      // Placeholder: this adapter never travels the fetch path. The URL is the
+      // provider's identity, not a destination anything connects to.
+      return { url: provider.baseUrl || DEVIN_CLI_IDENTITY_URL, method: "POST", headers: {}, body: "" };
+    },
+
+    async *parseStream(): AsyncGenerator<AdapterEvent> {
+      yield { type: "error", message: "Devin CLI adapter uses runTurn; the fetch/parseStream path is disabled." };
+    },
+
+    async runTurn(parsed: OcxParsedRequest, incoming: IncomingMeta, emit: (event: AdapterEvent) => void) {
+      if (incoming.abortSignal?.aborted) {
+        emit({ type: "error", message: "Devin CLI turn was aborted before start." });
+        return;
+      }
+      const binary = resolveDevinCliBinary();
+      if (!binary) {
+        emit({ type: "error", message: `Devin CLI not found. ${DEVIN_CLI_INSTALL_HINT}` });
+        return;
+      }
+
+      const modelId = parsed.modelId.includes("/")
+        ? parsed.modelId.slice(parsed.modelId.lastIndexOf("/") + 1)
+        : parsed.modelId;
+      const cwd = process.env.OPENCODEX_DEVIN_CLI_CWD?.trim() || process.cwd();
+      const toolsAllowed = devinCliToolsAllowed();
+
+      await new Promise<void>((resolve) => {
+        let child: ChildProcessWithoutNullStreams;
+        try {
+          child = spawnChild(binary, ["acp"], {
+            cwd,
+            env: {
+              // A scoped environment, not the proxy's. The child would
+              // otherwise inherit every credential this process holds.
+              ...baseScopedEnv(),
+              NO_COLOR: "1",
+              // "normal" is the CLI's own refuse-by-default mode. "ask" reads like
+              // the right name for it but is not a value the binary accepts: Devin
+              // CLI 3000.10.21 exits 2 with
+              //   invalid value 'ask' for '--permission-mode <PERMISSION_MODE>'
+              //   Valid options: normal (auto), accept-edits, dangerous (yolo,
+              //   bypass), autonomous (requires --sandbox)
+              // before answering a single prompt, so every turn on this provider
+              // failed with the default (tools not allowed) configuration — the
+              // one path most operators are on. Found by running a real turn
+              // against an installed, signed-in CLI; no unit test could see it,
+              // because the spawn is injected and the fake child accepts anything.
+              DEVIN_PERMISSION_MODE: toolsAllowed ? (process.env.DEVIN_PERMISSION_MODE ?? "bypass") : "normal",
+            },
+          });
+        } catch (error) {
+          emit({ type: "error", message: `Devin CLI failed to start (${binary}): ${(error as Error).message}. ${DEVIN_CLI_INSTALL_HINT}` });
+          return resolve();
+        }
+
+        let settled = false;
+        let closed = false;
+        let sawProtocolFrame = false;
+        let sawPromptReply = false;
+        let buffer = "";
+        let totalBytes = 0;
+        let usage: OcxUsage | undefined;
+        let stopReason: string | undefined;
+        let stderrTail = "";
+
+        const turnTimer = setTimeout(
+          () => finish(`Devin CLI turn exceeded ${DEVIN_CLI_TURN_TIMEOUT_MS}ms`),
+          DEVIN_CLI_TURN_TIMEOUT_MS,
+        );
+        const onAbort = () => finish("Devin CLI turn was aborted.");
+
+        /**
+         * Reap the child rather than just signalling it, then resolve.
+         *
+         * `child.killed` only records that a signal was sent. Resolving on that
+         * lets a grandchild keep running in the operator's tree after runTurn
+         * returned, which is why this waits for `close` and escalates.
+         */
+        function reapAndResolve(): void {
+          if (closed || child.exitCode !== null || child.signalCode !== null) return resolve();
+          let done = false;
+          const settle = () => {
+            if (done) return;
+            done = true;
+            clearTimeout(killTimer);
+            clearTimeout(reapTimer);
+            resolve();
+          };
+          child.once("close", settle);
+          signalTree("SIGTERM");
+          const killTimer = setTimeout(() => signalTree("SIGKILL"), DEVIN_CLI_KILL_GRACE_MS);
+          const reapTimer = setTimeout(settle, DEVIN_CLI_REAP_MS);
+        }
+
+        /**
+         * Signal the child's whole process group where the platform has one.
+         * Devin launches shells and tools of its own once the operator allows
+         * them, and those descendants do not receive a signal aimed at the
+         * direct pid. Falls back to the single process when the group send is
+         * unavailable or the group is already gone.
+         */
+        function signalTree(signal: NodeJS.Signals): void {
+          const pid = child.pid;
+          if (pid !== undefined && process.platform !== "win32") {
+            try {
+              process.kill(-pid, signal);
+              return;
+            } catch { /* no group, or already reaped - fall through */ }
+          }
+          try { child.kill(signal); } catch { /* already gone */ }
+        }
+
+        /** Terminate the turn exactly once, with an error when given a reason. */
+        function finish(errorMessage?: string): void {
+          if (settled) return;
+          settled = true;
+          clearTimeout(turnTimer);
+          incoming.abortSignal?.removeEventListener("abort", onAbort);
+          child.stdout.destroy();
+          if (errorMessage) emit({ type: "error", message: errorMessage, ...(usage ? { usage } : {}) });
+          else emit({ type: "done", ...(usage ? { usage } : {}), ...(stopReason ? { stopReason } : {}) });
+          reapAndResolve();
+        }
+
+        incoming.abortSignal?.addEventListener("abort", onAbort, { once: true });
+        // The signal can fire between the pre-spawn check and this listener.
+        if (incoming.abortSignal?.aborted) return finish("Devin CLI turn was aborted.");
+
+        const send = (frame: Record<string, unknown>): void => {
+          if (!child.stdin.destroyed) child.stdin.write(`${JSON.stringify(frame)}\n`);
+        };
+        // EPIPE after the child is killed is an ordinary race, not a crash.
+        child.stdin.on("error", () => {});
+
+        child.on("error", (err) => finish(`Devin CLI failed to start (${binary}): ${err.message}. ${DEVIN_CLI_INSTALL_HINT}`));
+
+        child.on("close", (code) => {
+          closed = true;
+          if (settled) return;
+          // Flush a final frame that arrived without a trailing newline before
+          // deciding the turn failed: the prompt reply carrying usage and the
+          // stop reason is often the last line written.
+          flush(buffer);
+          buffer = "";
+          if (settled) return;
+          // A close without a prompt reply is a failure, not an empty success.
+          const detail = stderrTail.trim().slice(-400);
+          finish(
+            `Devin CLI exited (code ${code ?? "null"}) before answering the prompt` +
+            (detail ? `: ${detail}` : "."),
+          );
+        });
+
+        child.stderr?.setEncoding("utf8");
+        child.stderr?.on("data", (chunk: string) => {
+          // Bounded: diagnostics are for the error message, not a buffer to grow.
+          stderrTail = (stderrTail + chunk).slice(-4096);
+        });
+
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk: string) => {
+          if (settled) return;
+          totalBytes += Buffer.byteLength(chunk, "utf8");
+          if (totalBytes > MAX_ACP_TOTAL_BYTES) return finish("Devin CLI produced more output than one turn may consume.");
+          buffer += chunk;
+          let index: number;
+          while ((index = buffer.indexOf("\n")) >= 0) {
+            const line = buffer.slice(0, index);
+            buffer = buffer.slice(index + 1);
+            flush(line);
+            if (settled) return;
+          }
+          if (Buffer.byteLength(buffer, "utf8") > MAX_ACP_LINE_BYTES) {
+            finish("Devin CLI emitted a single line larger than the frame cap.");
+          }
+        });
+
+        // The prompt reply carrying usage and the stop reason is often the last
+        // thing written, and it is not guaranteed to end with a newline. Flush
+        // the remainder when the stream ends rather than waiting for the child
+        // to exit and then calling a complete turn a failure.
+        child.stdout.on("end", () => {
+          const tail = buffer;
+          buffer = "";
+          flush(tail);
+        });
+
+        function flush(raw: string): void {
+          const line = raw.trim();
+          if (!line || settled) return;
+          let frame: Record<string, unknown>;
+          try {
+            frame = JSON.parse(line) as Record<string, unknown>;
+          } catch {
+            // The CLI prints a banner before the protocol starts, so plain text
+            // is expected up to the first valid frame. After that the stream is
+            // protocol, and a line that is shaped like a frame but does not
+            // parse is corruption: dropping it silently loses a session/update
+            // or lets the turn wait out the timeout for a reply that already
+            // arrived damaged.
+            if (sawProtocolFrame || line.startsWith("{")) {
+              finish("Devin CLI emitted a malformed ACP frame.");
+            }
+            return;
+          }
+          sawProtocolFrame = true;
+          handle(frame);
+        }
+
+        /** JSON-RPC ids are allowed to come back as strings. */
+        const idOf = (value: unknown): number | undefined => {
+          if (typeof value === "number") return value;
+          if (typeof value === "string" && /^\d+$/.test(value)) return Number(value);
+          return undefined;
+        };
+
+        function handle(frame: Record<string, unknown>): void {
+          if (settled) return;
+          const id = idOf(frame.id);
+          const error = frame.error as { message?: string } | undefined;
+
+          if (id === ACP_INITIALIZE_ID) {
+            if (error) return finish(`Devin CLI initialize failed: ${error.message ?? "unknown error"}`);
+            send(sessionNewFrame(cwd, modelId));
+            return;
+          }
+          if (id === ACP_SESSION_NEW_ID) {
+            if (error) return finish(`Devin CLI session/new failed: ${error.message ?? "unknown error"}`);
+            const sessionId = (frame.result as { sessionId?: string } | undefined)?.sessionId;
+            if (!sessionId) return finish("Devin CLI session/new returned no sessionId.");
+            send(sessionPromptFrame(sessionId, buildAcpPrompt(parsed)));
+            return;
+          }
+          if (frame.method === "session/request_permission" && frame.id != null) {
+            const params = frame.params as { options?: Array<{ optionId?: string; name?: string; kind?: string }> } | undefined;
+            send(permissionResponseFrame(frame.id as number | string, params?.options, toolsAllowed));
+            return;
+          }
+          if (frame.method === "session/update") {
+            const update = (frame.params as { update?: Record<string, unknown> } | undefined)?.update;
+            if (!update) return;
+            for (const event of acpUpdateToEvents(update)) emit(event);
+            return;
+          }
+          if (id === ACP_SESSION_PROMPT_ID) {
+            if (error) return finish(`Devin CLI session/prompt failed: ${error.message ?? "unknown error"}`);
+            sawPromptReply = true;
+            const result = frame.result as { stopReason?: unknown; usage?: unknown } | undefined;
+            usage = mapAcpUsage(result?.usage) ?? usage;
+            stopReason = mapAcpStopReason(result?.stopReason);
+            finish();
+          }
+        }
+
+        void sawPromptReply;
+        send(initializeFrame(process.env.OPENCODEX_VERSION ?? "0.0.0"));
+      });
+    },
+  };
+}

package/src/adapters/devin-cli/binary.ts

@@ -0,0 +1,69 @@
+/**
+ * Locate the Devin CLI.
+ *
+ * The official installer (`curl -fsSL https://cli.devin.ai/install.sh | bash`)
+ * and the Homebrew cask both drop the binary in one of a small set of places.
+ * The environment override comes first so an operator can point at a specific
+ * build without touching PATH, and PATH is the last resort rather than the
+ * first so a shadowed name cannot silently win.
+ */
+import { existsSync } from "node:fs";
+import { delimiter, join } from "node:path";
+import { homedir } from "node:os";
+
+export const DEVIN_CLI_BIN_ENV = "OPENCODEX_DEVIN_CLI_BIN";
+
+export const DEVIN_CLI_INSTALL_HINT =
+  "Install the Devin CLI with `curl -fsSL https://cli.devin.ai/install.sh | bash` or `brew install --cask devin-cli`, then run `devin auth login`.";
+
+let cached: string | undefined;
+
+/** Reset the discovery cache (tests, or an explicit re-check after an install). */
+export function clearDevinCliBinaryCache(): void {
+  cached = undefined;
+}
+
+function candidatePaths(home: string): string[] {
+  return [
+    join(home, "AppData", "Local", "Microsoft", "WinGet", "Links", "devin.exe"),
+    join(home, ".local", "share", "devin", "bin", "devin"),
+    join(home, ".devin", "bin", "devin"),
+    join(home, ".local", "bin", "devin"),
+    "/opt/homebrew/bin/devin",
+    "/usr/local/bin/devin",
+    "/usr/bin/devin",
+  ];
+}
+
+function fromPath(exists: (p: string) => boolean): string | undefined {
+  const pathVar = process.env.PATH ?? "";
+  for (const dir of pathVar.split(delimiter)) {
+    if (!dir) continue;
+    for (const name of ["devin", "devin.exe"]) {
+      const full = join(dir, name);
+      if (exists(full)) return full;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Resolve the executable, or undefined when it is not installed.
+ *
+ * `exists` and `home` are seams so the resolution order can be tested without
+ * depending on what happens to be installed on the machine running the tests.
+ */
+export function resolveDevinCliBinary(opts?: { exists?: (p: string) => boolean; home?: string; useCache?: boolean }): string | undefined {
+  const exists = opts?.exists ?? existsSync;
+  const useCache = opts?.useCache ?? opts === undefined;
+  if (useCache && cached) return cached;
+  const override = process.env[DEVIN_CLI_BIN_ENV]?.trim();
+  if (override) {
+    if (useCache) cached = override;
+    return override;
+  }
+  const home = opts?.home ?? homedir();
+  const found = candidatePaths(home).find((p) => exists(p)) ?? fromPath(exists);
+  if (found && useCache) cached = found;
+  return found;
+}

package/src/adapters/devin-cli/models.ts

@@ -0,0 +1,57 @@
+/**
+ * Models the Devin CLI accepts on `session/new`.
+ *
+ * The CLI picks its own default when no model is named, so this roster exists
+ * for the picker rather than as a gate. It is a static list on purpose: ACP has
+ * no discovery call, and the vendor roster moves faster than a pinned copy
+ * would, so an unknown id is passed through to the CLI to accept or refuse.
+ */
+export const DEVIN_CLI_DEFAULT_MODEL = "swe-2";
+
+export const DEVIN_CLI_MODELS = [
+  "swe-2",
+  "swe-2-high",
+  "claude-opus-5-medium",
+  "claude-fable-5-1-medium",
+  "claude-sonnet-5-medium",
+  "gpt-6-astra-medium",
+  "gpt-5-6-sol-medium",
+  "gemini-3-8-flash-medium",
+  "glm-5-3-high",
+  "glm-5-3-low",
+  "kimi-k3-high",
+] as const;
+
+/**
+ * Context windows for the CLI roster, in the same effort-suffixed ids the CLI
+ * accepts.
+ *
+ * Without this the picker fell back to the 128k default for every Devin CLI
+ * model, including `swe-2`, which is the roster's own default — so the one
+ * model most sessions ran reported less than half its real window.
+ *
+ * The numbers come from Cognition's `GetCascadeModelConfigs` catalog
+ * (`ClientModelConfig` field #18), which is the only first-party source: the
+ * Devin CLI and Desktop model pages, the SWE-2 announcement, and the Windsurf
+ * model reference all list these models without a window. The CLI is a separate
+ * product from the cloud, but Cognition documents the same models on both and
+ * describes no per-surface difference — the SWE-2 announcement ships it to
+ * Desktop, CLI, Web, and Fusion in one sentence — so the catalog's figure is
+ * used for both rather than inventing a second table.
+ *
+ * ACP has no discovery call, so unlike the cloud provider this cannot be
+ * refreshed live; it needs updating when the roster above does.
+ */
+export const DEVIN_CLI_MODEL_CONTEXT_WINDOWS: Record<string, number> = {
+  "swe-2": 262_000,
+  "swe-2-high": 262_000,
+  "claude-opus-5-medium": 1_000_000,
+  "claude-fable-5-1-medium": 1_000_000,
+  "claude-sonnet-5-medium": 1_000_000,
+  "gpt-6-astra-medium": 1_000_000,
+  "gpt-5-6-sol-medium": 1_000_000,
+  "gemini-3-8-flash-medium": 1_048_576,
+  "glm-5-3-high": 1_048_576,
+  "glm-5-3-low": 1_048_576,
+  "kimi-k3-high": 1_048_576,
+};