codemax-cli 0.1.1 → 0.1.4

package/src/engines/codex.ts

@@ -1,8 +1,9 @@
 import type { AgentId } from "../adapters/types.ts";
-import type { Engine, EngineEvent, EngineInfo, EngineSessionRef, EngineStartOptions, PermissionRequest, StopReason, ToolStatus } from "./types.ts";
+import type { Engine, EngineEvent, EngineInfo, EngineOption, EngineSessionRef, EngineStartOptions, PermissionRequest, StopReason, ToolStatus } from "./types.ts";
 import { agentEnv } from "./env.ts";
 import { platformArgv } from "../core/spawn.ts";
 import { classifyError } from "./errors.ts";
+import pkg from "../../package.json" with { type: "json" };
 
 export interface CodexEngineOptions {
   /** Command for the app server. Default: codex app-server. */
@@ -18,6 +19,10 @@ export interface CodexEngineOptions {
  * `answerPermission`.
  */
 export class CodexEngine implements Engine {
+  /** Models this account can use, from `model/list`. */
+  private catalog: { id: string; name: string; efforts: string[]; defaultEffort?: string }[] = [];
+  /** Reasoning effort chosen with /effort (sent with each turn); undefined = the model's default. */
+  private effort: string | undefined;
   readonly agent: AgentId = "codex";
   info: EngineInfo | null = null;
   session: EngineSessionRef | null = null;
@@ -49,7 +54,7 @@ export class CodexEngine implements Engine {
     this.cwd = o.cwd;
     this.transport = this.opts.transport ?? this.spawn(o.cwd);
     this.transport.onLine((line) => this.onLine(line));
-    const init = await this.request("initialize", { clientInfo: { name: "codemax", version: "0.3.0" }, capabilities: {} });
+    const init = await this.request("initialize", { clientInfo: { name: "codemax", version: pkg.version }, capabilities: {} });
     this.notify("initialized", {});
 
     let thread: any;
@@ -65,6 +70,9 @@ export class CodexEngine implements Engine {
     this.model = thread.model ?? undefined;
     this.session = { agent: "codex", id: thread.id, cwd: o.cwd, startedAt: Date.now(), lastUsedAt: Date.now() };
     const account: any = await this.request("account/read", {}).catch(() => null);
+    // The models this account can use, straight from Codex: never a list of our own.
+    // An older Codex without model/list must not hold up startup: give it a few seconds.
+    this.catalog = await Promise.race([this.listModels(), Bun.sleep(4000).then(() => [])]).catch(() => []);
     this.info = {
       agent: "codex",
       name: "Codex",
@@ -74,8 +82,9 @@ export class CodexEngine implements Engine {
         { id: "never", name: "full auto (no approvals)" },
       ],
       currentMode: "on-request",
-      models: [...new Set([this.model, "gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna", "gpt-5.5"].filter(Boolean))].map((id) => ({ id: id!, name: id! })),
+      models: this.catalog.length ? this.catalog.map((m) => ({ id: m.id, name: m.name })) : this.model ? [{ id: this.model, name: this.model }] : [],
       currentModel: this.model,
+      options: this.effortOptions(),
       plan: account?.account?.planType ? `chatgpt ${account.account.planType}` : undefined,
     };
     this.emit({ type: "session", ref: this.session });
@@ -281,7 +290,7 @@ export class CodexEngine implements Engine {
     const done = new Promise<StopReason>((resolve) => (this.turn = { resolve }));
     try {
       const approvalPolicy = this.info?.currentMode === "never" ? "never" : "on-request";
-      const res = await this.request("turn/start", { threadId: this.threadId, cwd: this.cwd, input: [{ type: "text", text }], model: this.model, approvalPolicy });
+      const res = await this.request("turn/start", { threadId: this.threadId, cwd: this.cwd, input: [{ type: "text", text }], model: this.model, approvalPolicy, ...(this.effort ? { effort: this.effort } : {}) });
       if (this.turn) this.turn.id = res?.turn?.id;
     } catch (e: any) {
       const msg = `${e?.message ?? e} ${JSON.stringify(e?.data ?? "")}`.trim();
@@ -314,6 +323,46 @@ export class CodexEngine implements Engine {
   async setModel(modelId: string) {
     this.model = modelId;
     if (this.info) this.info.currentModel = modelId;
+    // Reasoning efforts differ per model: keep the chosen one only if the new model has it.
+    const efforts = this.catalog.find((m) => m.id === modelId)?.efforts ?? [];
+    if (this.effort && !efforts.includes(this.effort)) this.effort = undefined;
+    if (this.info) this.info.options = this.effortOptions();
+  }
+
+  async setOption(optionId: string, value: string) {
+    if (optionId !== "effort") return;
+    this.effort = value;
+    if (this.info) this.info.options = this.effortOptions();
+  }
+
+  /** `model/list`, all pages, hidden models left out. */
+  private async listModels(): Promise<{ id: string; name: string; efforts: string[]; defaultEffort?: string }[]> {
+    const out: { id: string; name: string; efforts: string[]; defaultEffort?: string }[] = [];
+    let cursor: string | undefined;
+    for (let page = 0; page < 10; page++) {
+      const r: any = await this.request("model/list", cursor ? { cursor } : {});
+      for (const m of r?.data ?? []) {
+        if (m?.hidden) continue;
+        const id = String(m.model ?? m.id ?? "");
+        if (!id) continue;
+        out.push({
+          id,
+          name: String(m.displayName ?? id),
+          efforts: (m.supportedReasoningEfforts ?? []).map((e: any) => String(e?.reasoningEffort ?? e)).filter(Boolean),
+          defaultEffort: m.defaultReasoningEffort ? String(m.defaultReasoningEffort) : undefined,
+        });
+      }
+      cursor = r?.nextCursor ?? undefined;
+      if (!cursor) break;
+    }
+    return out;
+  }
+
+  /** The current model's reasoning efforts, as Codex lists them. */
+  private effortOptions(): EngineOption[] {
+    const m = this.catalog.find((x) => x.id === this.model);
+    if (!m?.efforts.length) return [];
+    return [{ id: "effort", name: "Reasoning effort", category: "thought_level", current: this.effort ?? m.defaultEffort ?? "default", values: m.efforts.map((e) => ({ value: e, name: e })) }];
   }
 
   async close() {

package/src/engines/index.ts

@@ -35,7 +35,7 @@ function grokUsageTail(cwd: string, sessionId: string): { read(): UsageSample[]
   };
 }
 
-const CLAUDE_ADAPTER_PKG = "@zed-industries/claude-code-acp@0.16.2";
+const CLAUDE_ADAPTER_PKG = "@agentclientprotocol/claude-agent-acp@0.93.0";
 
 /**
  * Command for the Claude ACP adapter (it runs the user's own `claude`).
@@ -46,8 +46,8 @@ function claudeAdapterCmd(): string[] | null {
   const runningOnBun = basename(process.execPath).toLowerCase().startsWith("bun");
   if (process.platform !== "win32") {
     const candidates = [
-      join(import.meta.dir, "..", "..", "node_modules", ".bin", "claude-code-acp"),
-      join(process.cwd(), "node_modules", ".bin", "claude-code-acp"),
+      join(import.meta.dir, "..", "..", "node_modules", ".bin", "claude-agent-acp"),
+      join(process.cwd(), "node_modules", ".bin", "claude-agent-acp"),
     ];
     for (const c of candidates) if (existsSync(c)) return [c];
   }
@@ -55,15 +55,15 @@ function claudeAdapterCmd(): string[] | null {
   // do not (Windows) and when no `bun` is on PATH (installed through npm).
   if (runningOnBun) {
     try {
-      const pkgJson = Bun.resolveSync("@zed-industries/claude-code-acp/package.json", import.meta.dir);
+      const pkgJson = Bun.resolveSync("@agentclientprotocol/claude-agent-acp/package.json", import.meta.dir);
       const bin = JSON.parse(readFileSync(pkgJson, "utf8")).bin;
-      const entry = typeof bin === "string" ? bin : bin?.["claude-code-acp"];
+      const entry = typeof bin === "string" ? bin : bin?.["claude-agent-acp"];
       if (entry && existsSync(join(dirname(pkgJson), entry))) return [process.execPath, join(dirname(pkgJson), entry)];
     } catch {
       /* not installed next to codemax */
     }
   }
-  const onPath = Bun.which("claude-code-acp");
+  const onPath = Bun.which("claude-agent-acp");
   if (onPath) return [onPath];
   const bun = Bun.which("bun") ?? (runningOnBun ? process.execPath : null);
   const bunx = Bun.which("bunx") ? [Bun.which("bunx")!] : bun ? [bun, "x"] : null;

package/src/engines/types.ts

@@ -27,6 +27,8 @@ export type EngineEvent =
       costUsd?: number;
       /** Rate-limit window consumption, when the agent exposes it. */
       usedPercent?: number;
+      /** Subscription plan limits the agent reported (Claude: 5-hour, weekly…), one entry per window. */
+      planLimits?: PlanLimit[];
       /** Context window fill, when reported (tokens used / size). */
       contextUsed?: number;
       contextSize?: number;
@@ -36,6 +38,15 @@ export type EngineEvent =
   | { type: "error"; kind: ErrorKind; message: string }
   | { type: "log"; level: "info" | "warn" | "error"; message: string };
 
+export interface PlanLimit {
+  /** e.g. "five_hour", "seven_day", "seven_day_opus". */
+  window: string;
+  usedPercent?: number;
+  resetsAt?: number;
+  /** "allowed" | "allowed_warning" | "rejected" (out of this window's quota). */
+  status?: string;
+}
+
 export type ToolStatus = "pending" | "in_progress" | "completed" | "failed";
 export type StopReason = "end_turn" | "max_tokens" | "cancelled" | "refusal" | "error" | "other";
 export type ErrorKind = "quota" | "auth" | "protocol" | "crashed" | "other";

package/src/tui/app.ts

@@ -68,10 +68,15 @@ export class App {
     this.setStatus("");
   }
 
-  async start(agent: AgentId, fresh: boolean) {
+  /** `explicit`: the user named this agent (--agent), so never start a different one. */
+  async start(agent: AgentId, fresh: boolean, o: { explicit?: boolean } = {}) {
     await this.refreshDetect();
-    const first = this.detect.get(agent)?.installed ? agent : this.firstInstalled();
+    const installed = this.detect.get(agent)?.installed;
+    if (!installed && o.explicit) throw new Error(`${agent} is not installed. Installed: ${this.installedList() || "none"}`);
+    const first = installed ? agent : this.firstInstalled();
     if (!first) throw new Error("no supported agent CLI found on PATH");
+    // Under tests a fallback must never reach a real agent (no logins, no quota).
+    if (first !== agent && process.env.NODE_ENV === "test") throw new Error(`test asked for ${agent}, which is not available; refusing to fall back to ${first}`);
     if (first !== agent) this.setStatus(`${agent} not found, starting ${first}`);
     await this.launch(getAdapter(first), { fresh });
     return this.done;
@@ -282,6 +287,10 @@ export class App {
     );
   }
 
+  private installedList(): string {
+    return [...this.detect.entries()].filter(([, d]) => d.installed).map(([id]) => id).join(", ");
+  }
+
   private firstInstalled(): AgentId | undefined {
     return listAdapters(this.config.order).find((a) => this.detect.get(a.id)?.installed)?.id;
   }
@@ -360,11 +369,11 @@ export class App {
 }
 
 /** Run codemax on the real terminal until the user quits. */
-export async function runApp(config: Config, ledger: Ledger, cwd: string, agent: AgentId, fresh: boolean) {
+export async function runApp(config: Config, ledger: Ledger, cwd: string, agent: AgentId, fresh: boolean, explicit = false) {
   const renderer = await createCliRenderer({ exitOnCtrlC: false, exitSignals: ["SIGTERM", "SIGHUP"], useMouse: true, targetFps: 60 });
   const app = new App(renderer, config, ledger, cwd);
   try {
-    await app.start(agent, fresh);
+    await app.start(agent, fresh, { explicit });
   } finally {
     renderer.destroy();
     try {