@inetafrica/open-claudia 1.15.0 → 1.16.1

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## v1.16.1
+- `/model` is now a single unified picker — all Claude, Cursor, and Codex models in one keyboard, with section dividers per backend
+- Tapping any model auto-switches the active backend if needed (e.g. picking gpt-5 from Claude flips you to Codex). No more `/codex` + `/model` two-step
+- Only backends with a detected CLI binary appear in the picker (Cursor/Codex rows hidden if not installed)
+
+## v1.16.0
+- OpenAI Codex backend support: `/codex` to switch, `/backend` picker now has 3 options
+- Auto-detects `codex` binary via `which codex` at startup; opt-in via `CODEX_PATH` in .env
+- Codex sessions persist (`codexSessionId`) across restarts and resume via `codex exec resume <id>`
+- Per-backend session IDs maintained independently — switch freely without losing context
+- Stream parser handles Codex JSONL events: `thread.started`, `item.started`, `item.completed`, `turn.completed` (with usage)
+- Plan mode on Codex maps to `--sandbox read-only`; outside plan mode uses `--dangerously-bypass-approvals-and-sandbox` (bot is the sandbox)
+- `/model` picker shows Codex models (gpt-5, gpt-5-codex, o3, o4-mini) when on Codex
+- Effort/budget gracefully reject on Codex (not exposed as CLI flags); Claude auth preflight scoped strictly to the Claude backend
+- Codex auth errors in stderr produce an actionable "run `codex login`" recovery message
+
 ## v1.14.9
 - Fix `/upgrade`: `latest` was const-scoped to the version-check try
   block, so the install step ran with `latest` undefined and threw

package/README.md

@@ -1,12 +1,12 @@
 # Open Claudia
 
-Your always-on AI coding assistant — Claude Code and Cursor Agent via Telegram.
+Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram.
 
 Send text, voice notes, screenshots, and files from your phone. Your chosen AI agent works on your projects and reports back.
 
 ## Features
 
-- **Multi-backend** — switch between Claude Code and Cursor Agent on the fly (`/cursor`, `/claude`)
+- **Multi-backend** — switch between Claude Code, Cursor Agent, and OpenAI Codex on the fly (`/claude`, `/cursor`, `/codex`)
 - **Multi-project sessions** — switch between workspace projects
 - **Per-project conversation history** — auto-resumes last conversation, switch with `/sessions`
 - **Separate session persistence** — Claude and Cursor each maintain their own conversation state
@@ -55,6 +55,14 @@ agent login               # Opens browser to authenticate
 agent status              # Verify: should show your email and plan
 ```
 
+**OpenAI Codex** (optional — enables `/codex` backend):
+
+```bash
+npm install -g @openai/codex
+codex login               # Opens browser to authenticate
+codex --version           # Verify it works
+```
+
 > **Important**: Claude Code can use macOS Keychain when you log in interactively, but a launchd/background bot may not be able to read that Keychain session. Open Claudia v1.14.0 adds Telegram auth helpers and supports `CLAUDE_CODE_OAUTH_TOKEN` for non-interactive Claude runs. Prefer `/setup_token` then `/use_oauth_token` if Telegram shows Claude auth/keychain errors.
 
 ### 2. Install Open Claudia
@@ -103,6 +111,7 @@ If installed as a background service, the bot starts automatically on login and
 |---------|-------------|
 | `/cursor` | Switch to Cursor Agent backend |
 | `/claude` | Switch to Claude Code backend |
+| `/codex` | Switch to OpenAI Codex backend |
 | `/backend` | Show current backend with picker |
 
 Each backend keeps its own persistent session. Switching doesn't lose your place — you can go back and forth freely.
@@ -167,20 +176,20 @@ Tokens are redacted from Telegram output and logs. If the encrypted vault is unl
 
 ## Backend Comparison
 
-| | Claude Code | Cursor Agent |
-|---|---|---|
-| Binary | `claude` | `agent` |
-| Session flag | `--resume <id>` | `--resume <id>` |
-| Auth | `claude auth` | `agent login` |
-| Plan mode | Yes (`--permission-mode plan`) | Yes (`--mode plan`) |
-| Ask mode | No | Yes (`--mode ask`) |
-| Budget control | Yes (`--max-budget-usd`) | No |
-| Effort levels | Yes | No |
-| Worktree | Yes (`--worktree`) | Yes (`--worktree`) |
-| Model switching | Yes | Yes |
-| Dangerously skip permissions | Yes | Yes (`--trust`) |
-
-Both backends output `stream-json` which Open Claudia parses for real-time progress updates.
+| | Claude Code | Cursor Agent | OpenAI Codex |
+|---|---|---|---|
+| Binary | `claude` | `agent` | `codex` |
+| Session flag | `--resume <id>` | `--resume <id>` | `exec resume <id>` |
+| Auth | `claude auth` | `agent login` | `codex login` |
+| Plan mode | Yes (`--permission-mode plan`) | Yes (`--mode plan`) | Yes (`--sandbox read-only`) |
+| Ask mode | No | Yes (`--mode ask`) | No |
+| Budget control | Yes (`--max-budget-usd`) | No | No |
+| Effort levels | Yes | No | Via config.toml |
+| Worktree | Yes (`--worktree`) | Yes (`--worktree`) | No |
+| Model switching | Yes | Yes | Yes (`--model`) |
+| Dangerously skip permissions | Yes | Yes (`--trust`) | Yes (`--dangerously-bypass-approvals-and-sandbox`) |
+
+All three backends output structured JSON which Open Claudia parses for real-time progress updates (Claude/Cursor: `stream-json`; Codex: JSONL events).
 
 ## Sending Files
 
@@ -258,6 +267,7 @@ All stored in `~/.open-claudia/`:
 | `WORKSPACE` | Yes | Path to your projects directory |
 | `CLAUDE_PATH` | Yes | Path to Claude Code CLI binary |
 | `CURSOR_PATH` | No | Path to Cursor Agent CLI binary (auto-detected if in PATH) |
+| `CODEX_PATH` | No | Path to OpenAI Codex CLI binary (auto-detected if in PATH) |
 | `WHISPER_CLI` | No | Path to whisper.cpp binary |
 | `WHISPER_MODEL` | No | Whisper model to use |
 | `FFMPEG` | No | Path to ffmpeg binary |

package/bot.js

@@ -143,6 +143,7 @@ const CHAT_ID = CHAT_IDS[0]; // Primary owner chat for crons/notifications
 const WORKSPACE = config.WORKSPACE;
 const CLAUDE_PATH = config.CLAUDE_PATH;
 const CURSOR_PATH = config.CURSOR_PATH || null;
+const CODEX_PATH = config.CODEX_PATH || null;
 
 // Validate critical config at startup
 if (!TOKEN) { console.error("TELEGRAM_BOT_TOKEN not set"); process.exit(1); }
@@ -180,6 +181,15 @@ if (!resolvedCursorPath) {
   } catch (e) { resolvedCursorPath = null; }
 }
 if (resolvedCursorPath) console.log(`Cursor Agent CLI: ${resolvedCursorPath}`);
+
+// Resolve Codex CLI (optional — discovered at startup)
+let resolvedCodexPath = CODEX_PATH;
+if (!resolvedCodexPath) {
+  try {
+    resolvedCodexPath = execSync("which codex 2>/dev/null", { encoding: "utf-8" }).trim() || null;
+  } catch (e) { resolvedCodexPath = null; }
+}
+if (resolvedCodexPath) console.log(`Codex CLI: ${resolvedCodexPath}`);
 const WHISPER_CLI = config.WHISPER_CLI || "";
 const WHISPER_MODEL = config.WHISPER_MODEL || "";
 const FFMPEG = config.FFMPEG || "";
@@ -193,6 +203,7 @@ const BOT_DIR = __dirname;
 const FULL_PATH = [
   path.dirname(CLAUDE_PATH),
   resolvedCursorPath ? path.dirname(resolvedCursorPath) : null,
+  resolvedCodexPath ? path.dirname(resolvedCodexPath) : null,
   path.dirname(process.execPath),
   FFMPEG ? path.dirname(FFMPEG) : null,
   WHISPER_CLI ? path.dirname(WHISPER_CLI) : null,
@@ -283,6 +294,7 @@ bot.setMyCommands([
   { command: "status", description: "Session & settings info" },
   { command: "cursor", description: "Switch to Cursor Agent backend" },
   { command: "claude", description: "Switch to Claude Code backend" },
+  { command: "codex", description: "Switch to OpenAI Codex backend" },
   { command: "backend", description: "Show/switch active backend" },
   { command: "auth_status", description: "Check Claude Code auth" },
   { command: "login", description: "Start Claude Code login" },
@@ -325,6 +337,7 @@ function saveState() {
     currentSession,
     lastSessionId,
     cursorSessionId,
+    codexSessionId,
     settings,
     sessionUsage,
   };
@@ -395,6 +408,7 @@ let streamBuffer = "";
 let streamInterval = null;
 let lastSessionId = savedState.lastSessionId || null;
 let cursorSessionId = savedState.cursorSessionId || null;
+let codexSessionId = savedState.codexSessionId || null;
 let messageQueue = [];
 let activeCrons = new Map();
 let pendingVaultUnlock = false; // Waiting for password
@@ -965,7 +979,7 @@ function claudeAuthRecoveryMessage(reason = "Claude Code authentication failed")
 }
 
 function preflightClaudeAuthMessage() {
-  if (settings.backend === "cursor") return null;
+  if (settings.backend !== "claude") return null;
   if (getClaudeOAuthToken().value) return null;
   try {
     const output = execSync(`"${CLAUDE_PATH}" auth status`, {
@@ -1160,6 +1174,7 @@ function parseStreamEvents(data) {
 
 function buildClaudeArgs(prompt, opts = {}) {
   if (settings.backend === "cursor") return buildCursorArgs(prompt, opts);
+  if (settings.backend === "codex") return buildCodexArgs(prompt, opts);
   const args = ["-p", "--verbose", "--output-format", "stream-json",
     "--append-system-prompt", buildSystemPrompt()];
   if (opts.continueSession) args.push("--continue");
@@ -1186,13 +1201,40 @@ function buildCursorArgs(prompt, opts = {}) {
   return args;
 }
 
+function buildCodexArgs(prompt, opts = {}) {
+  // Codex uses `exec [SESSION] [PROMPT]` or `exec resume <SESSION> [PROMPT]`.
+  // Sandbox: bot runs headless, so bypass approvals (mirrors --dangerously-skip-permissions).
+  // Plan mode: drop to read-only sandbox so the model can't write.
+  const args = [];
+  const resumeId = (!opts.fresh && !opts.continueSession) ? codexSessionId : null;
+  if (opts.continueSession && codexSessionId) {
+    args.push("exec", "resume", codexSessionId);
+  } else if (resumeId) {
+    args.push("exec", "resume", resumeId);
+  } else {
+    args.push("exec");
+  }
+  args.push("--json", "--skip-git-repo-check");
+  if (settings.permissionMode === "plan") {
+    args.push("--sandbox", "read-only");
+  } else {
+    args.push("--dangerously-bypass-approvals-and-sandbox");
+  }
+  if (settings.model) args.push("--model", settings.model);
+  args.push(prompt);
+  return args;
+}
+
 function getActiveBinary() {
   if (settings.backend === "cursor") return resolvedCursorPath;
+  if (settings.backend === "codex") return resolvedCodexPath;
   return CLAUDE_PATH;
 }
 
 function getActiveSessionId() {
-  return settings.backend === "cursor" ? cursorSessionId : lastSessionId;
+  if (settings.backend === "cursor") return cursorSessionId;
+  if (settings.backend === "codex") return codexSessionId;
+  return lastSessionId;
 }
 
 async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
@@ -1337,6 +1379,45 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
           currentToolDetail = "";
         }
       }
+      // Codex stream events
+      if (evt.type === "thread.started" && evt.thread_id) {
+        codexSessionId = evt.thread_id;
+        saveState();
+      }
+      if (evt.type === "item.started" && evt.item) {
+        const it = evt.item;
+        if (it.type === "command_execution" && it.command) {
+          currentTool = "Shell"; toolUses.push("Shell");
+          currentToolDetail = String(it.command).slice(0, 80);
+        } else if (it.type === "file_change" && (it.path || it.file_path)) {
+          currentTool = "Edit"; toolUses.push("Edit");
+          const p = it.path || it.file_path;
+          currentToolDetail = String(p).split("/").slice(-2).join("/");
+        } else if (it.type === "web_search" && it.query) {
+          currentTool = "Web"; toolUses.push("Web");
+          currentToolDetail = String(it.query).slice(0, 60);
+        } else if (it.type) {
+          currentTool = it.type; toolUses.push(it.type);
+          currentToolDetail = "";
+        }
+      }
+      if (evt.type === "item.completed" && evt.item) {
+        const it = evt.item;
+        if (it.type === "agent_message" && typeof it.text === "string") {
+          assistantText += (assistantText ? "\n" : "") + it.text;
+        }
+      }
+      if (evt.type === "turn.completed" && evt.usage && settings.backend === "codex") {
+        sessionUsage.turns += 1;
+        const input = evt.usage.input_tokens || 0;
+        const cached = evt.usage.cached_input_tokens || 0;
+        const output = evt.usage.output_tokens || 0;
+        sessionUsage.inputTokens += input;
+        sessionUsage.outputTokens += output;
+        sessionUsage.cacheReadTokens += cached;
+        sessionUsage.lastInputTokens = input + cached;
+        saveState();
+      }
       if (evt.type === "result" && evt.session_id) {
         if (settings.backend === "cursor") { cursorSessionId = evt.session_id; }
         else { lastSessionId = evt.session_id; }
@@ -1370,7 +1451,7 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
     clearTimeout(processTimeout);
 
     // Check for auth errors in stderr and give actionable Telegram recovery steps.
-    if (settings.backend !== "cursor" && isClaudeAuthErrorText(stderrBuffer)) {
+    if (settings.backend === "claude" && isClaudeAuthErrorText(stderrBuffer)) {
       await send(claudeAuthRecoveryMessage(stderrBuffer.trim().slice(-800)), { replyTo: replyToMsgId });
       return;
     }
@@ -1378,6 +1459,10 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
       await send("Cursor authentication error. Run `agent login` on this machine, then retry.", { replyTo: replyToMsgId });
       return;
     }
+    if (settings.backend === "codex" && /not (?:logged in|authenticated)|please (?:log|sign) in|401 unauthorized|invalid api key/i.test(stderrBuffer)) {
+      await send("Codex authentication error. Run `codex login` on this machine, then retry.", { replyTo: replyToMsgId });
+      return;
+    }
 
     try {
       if (code !== 0 && code !== null && !assistantText.trim()) {
@@ -1665,23 +1750,50 @@ bot.onText(/\/sessions$/, (msg) => {
 
 bot.onText(/\/model$/, (msg) => {
   if (!isAuthorized(msg)) return;
-  const keyboard = settings.backend === "cursor" ? [
-    [{ text: "Composer 2", callback_data: "m:composer-2" }, { text: "Composer 2 Fast", callback_data: "m:composer-2-fast" }],
-    [{ text: "Opus 4.6 Thinking", callback_data: "m:claude-4.6-opus-high-thinking" }, { text: "Sonnet 4.6", callback_data: "m:claude-4.6-sonnet-medium" }],
-    [{ text: "GPT-5.4", callback_data: "m:gpt-5.4-medium" }, { text: "GPT-5.4 High", callback_data: "m:gpt-5.4-high" }],
-    [{ text: "Auto", callback_data: "m:auto" }, { text: "Default", callback_data: "m:default" }],
-  ] : [
-    [{ text: "Opus 4.7", callback_data: "m:claude-opus-4-7" }, { text: "Opus 4.6", callback_data: "m:claude-opus-4-6" }, { text: "Sonnet 4.6", callback_data: "m:claude-sonnet-4-6" }, { text: "Haiku", callback_data: "m:claude-haiku-4-5-20251001" }],
-    [{ text: "Default", callback_data: "m:default" }],
-  ];
-  const label = settings.backend === "cursor" ? "Cursor Agent" : "Claude Code";
-  send(`${label} model: ${settings.model || "default"}\n\nOr type /model <name> for any model.`, { keyboard: { inline_keyboard: keyboard } });
+  // Unified picker: every model from every available backend in one keyboard.
+  // Tapping a button switches backend (if needed) and sets the model.
+  // Callback format: `mb:<backend>:<model>` (model may itself contain `-`).
+  const rows = [];
+  rows.push([{ text: "── Claude ──", callback_data: "noop" }]);
+  rows.push([
+    { text: "Opus 4.7", callback_data: "mb:claude:claude-opus-4-7" },
+    { text: "Opus 4.6", callback_data: "mb:claude:claude-opus-4-6" },
+    { text: "Sonnet 4.6", callback_data: "mb:claude:claude-sonnet-4-6" },
+    { text: "Haiku", callback_data: "mb:claude:claude-haiku-4-5-20251001" },
+  ]);
+  if (resolvedCursorPath) {
+    rows.push([{ text: "── Cursor ──", callback_data: "noop" }]);
+    rows.push([
+      { text: "Composer 2", callback_data: "mb:cursor:composer-2" },
+      { text: "Composer 2 Fast", callback_data: "mb:cursor:composer-2-fast" },
+      { text: "Auto", callback_data: "mb:cursor:auto" },
+    ]);
+    rows.push([
+      { text: "Opus 4.6 Thinking", callback_data: "mb:cursor:claude-4.6-opus-high-thinking" },
+      { text: "GPT-5.4", callback_data: "mb:cursor:gpt-5.4-medium" },
+    ]);
+  }
+  if (resolvedCodexPath) {
+    rows.push([{ text: "── Codex ──", callback_data: "noop" }]);
+    rows.push([
+      { text: "gpt-5", callback_data: "mb:codex:gpt-5" },
+      { text: "gpt-5-codex", callback_data: "mb:codex:gpt-5-codex" },
+    ]);
+    rows.push([
+      { text: "o3", callback_data: "mb:codex:o3" },
+      { text: "o4-mini", callback_data: "mb:codex:o4-mini" },
+    ]);
+  }
+  rows.push([{ text: "Default (current backend)", callback_data: "m:default" }]);
+  const beLabel = settings.backend === "cursor" ? "Cursor" : settings.backend === "codex" ? "Codex" : "Claude";
+  send(`Current: ${beLabel} · ${settings.model || "default"}\n\nPick a model — backend switches automatically.\nOr type /model <name>.`, { keyboard: { inline_keyboard: rows } });
 });
 bot.onText(/\/model (.+)/, (msg, match) => { if (!isAuthorized(msg)) return; settings.model = match[1].trim().toLowerCase(); if (settings.model === "default") settings.model = null; send(`Model: ${settings.model || "default"}`); });
 
 bot.onText(/\/effort$/, (msg) => {
   if (!isAuthorized(msg)) return;
   if (settings.backend === "cursor") return send("Effort levels are not supported on Cursor Agent.\nSwitch to Claude with /claude to use this.");
+  if (settings.backend === "codex") return send("Effort levels are not exposed as a flag on Codex.\nSet `model_reasoning_effort` in ~/.codex/config.toml, or switch to /claude.");
   send(`Effort: ${settings.effort || "default"}`, { keyboard: { inline_keyboard: [
     [{ text: "Low", callback_data: "e:low" }, { text: "Med", callback_data: "e:medium" }, { text: "High", callback_data: "e:high" }, { text: "Max", callback_data: "e:max" }],
     [{ text: "Default", callback_data: "e:default" }],
@@ -1690,12 +1802,14 @@ bot.onText(/\/effort$/, (msg) => {
 bot.onText(/\/effort (.+)/, (msg, match) => {
   if (!isAuthorized(msg)) return;
   if (settings.backend === "cursor") return send("Effort levels are not supported on Cursor Agent.");
+  if (settings.backend === "codex") return send("Effort levels are not exposed as a flag on Codex.");
   const e = match[1].trim().toLowerCase(); settings.effort = ["low","medium","high","max"].includes(e) ? e : null; send(`Effort: ${settings.effort || "default"}`);
 });
 
 bot.onText(/\/budget$/, (msg) => {
   if (!isAuthorized(msg)) return;
   if (settings.backend === "cursor") return send("Budget limits are not supported on Cursor Agent.\nSwitch to Claude with /claude to use this.");
+  if (settings.backend === "codex") return send("Budget limits are not supported on Codex.\nSwitch to Claude with /claude to use this.");
   send(`Budget: ${settings.budget ? "$" + settings.budget : "none"}`, { keyboard: { inline_keyboard: [
     [{ text: "$1", callback_data: "b:1" }, { text: "$5", callback_data: "b:5" }, { text: "$10", callback_data: "b:10" }, { text: "$25", callback_data: "b:25" }],
     [{ text: "No limit", callback_data: "b:none" }],
@@ -1704,6 +1818,7 @@ bot.onText(/\/budget$/, (msg) => {
 bot.onText(/\/budget (.+)/, (msg, match) => {
   if (!isAuthorized(msg)) return;
   if (settings.backend === "cursor") return send("Budget limits are not supported on Cursor Agent.");
+  if (settings.backend === "codex") return send("Budget limits are not supported on Codex.");
   const v = parseFloat(match[1].replace("$","")); settings.budget = v > 0 ? v : null; send(`Budget: ${settings.budget ? "$"+settings.budget : "none"}`);
 });
 
@@ -1711,8 +1826,14 @@ bot.onText(/\/plan$/, (msg) => {
   if (!isAuthorized(msg)) return;
   const p = settings.permissionMode === "plan";
   settings.permissionMode = p ? null : "plan";
-  const label = settings.backend === "cursor" ? "read-only planning, no edits" : "plan permission mode";
-  if (p) cursorSessionId = null; // reset session so next message doesn't resume plan-mode session
+  const label = settings.backend === "cursor" ? "read-only planning, no edits"
+    : settings.backend === "codex" ? "read-only sandbox, no edits"
+    : "plan permission mode";
+  if (p) {
+    // Reset session so next message doesn't resume in plan-mode for the active backend.
+    if (settings.backend === "cursor") cursorSessionId = null;
+    else if (settings.backend === "codex") codexSessionId = null;
+  }
   send(p ? "Plan mode off (session reset)." : `Plan mode on (${label}).`);
 });
 bot.onText(/\/ask$/, (msg) => {
@@ -1733,7 +1854,7 @@ bot.onText(/\/cursor$/, async (msg) => {
   settings.model = null;
   saveState();
   const sid = cursorSessionId ? `\nSession: ${cursorSessionId.slice(0, 8)}...` : "\nNew session.";
-  send(`Switched to Cursor Agent.${sid}\n\n/claude — switch back`);
+  send(`Switched to Cursor Agent.${sid}\n\n/claude — switch back · /codex — Codex`);
 });
 
 bot.onText(/\/claude$/, async (msg) => {
@@ -1742,15 +1863,26 @@ bot.onText(/\/claude$/, async (msg) => {
   settings.model = null;
   saveState();
   const sid = lastSessionId ? `\nSession: ${lastSessionId.slice(0, 8)}...` : "\nNew session.";
-  send(`Switched to Claude Code.${sid}\n\n/cursor — switch to Cursor`);
+  send(`Switched to Claude Code.${sid}\n\n/cursor — Cursor · /codex — Codex`);
+});
+
+bot.onText(/\/codex$/, async (msg) => {
+  if (!isAuthorized(msg)) return;
+  if (!resolvedCodexPath) return send("Codex CLI not found.\nInstall: npm install -g @openai/codex\nThen run `codex login` to authenticate.");
+  settings.backend = "codex";
+  settings.model = null;
+  saveState();
+  const sid = codexSessionId ? `\nSession: ${codexSessionId.slice(0, 8)}...` : "\nNew session.";
+  send(`Switched to Codex.${sid}\n\n/claude — Claude · /cursor — Cursor`);
 });
 
 bot.onText(/\/backend$/, async (msg) => {
   if (!isAuthorized(msg)) return;
-  const label = settings.backend === "cursor" ? "Cursor Agent" : "Claude Code";
+  const label = settings.backend === "cursor" ? "Cursor Agent" : settings.backend === "codex" ? "Codex" : "Claude Code";
   const cursorAvail = resolvedCursorPath ? "available" : "not found";
-  send(`Backend: ${label}\n\nClaude Code: available\nCursor Agent: ${cursorAvail}`, { keyboard: { inline_keyboard: [
-    [{ text: "Claude Code", callback_data: "be:claude" }, { text: "Cursor Agent", callback_data: "be:cursor" }],
+  const codexAvail = resolvedCodexPath ? "available" : "not found";
+  send(`Backend: ${label}\n\nClaude Code: available\nCursor Agent: ${cursorAvail}\nCodex: ${codexAvail}`, { keyboard: { inline_keyboard: [
+    [{ text: "Claude Code", callback_data: "be:claude" }, { text: "Cursor Agent", callback_data: "be:cursor" }, { text: "Codex", callback_data: "be:codex" }],
   ] } });
 });
 
@@ -1783,7 +1915,7 @@ bot.onText(/\/stop/, async (msg) => {
 bot.onText(/\/status/, (msg) => {
   if (!isAuthorized(msg)) return;
   if (!currentSession) return send("No session.", { keyboard: { inline_keyboard: [[{ text: "Pick", callback_data: "show:projects" }]] } });
-  const backendLabel = settings.backend === "cursor" ? "Cursor Agent" : "Claude Code";
+  const backendLabel = settings.backend === "cursor" ? "Cursor Agent" : settings.backend === "codex" ? "Codex" : "Claude Code";
   send([
     `Project: ${currentSession.name}`,
     `Backend: ${backendLabel}`,
@@ -2024,16 +2156,36 @@ bot.on("callback_query", async (q) => {
   }
   if (d === "a:continue") { if (currentSession) await runClaude("continue", currentSession.dir); else send("No session."); return; }
   if (d === "a:end") { if (currentSession) { const n = currentSession.name; currentSession = null; lastSessionId = null; messageQueue = []; resetSettings(); resetSessionUsage(); saveState(); await send(`Ended: ${n}`, { keyboard: { inline_keyboard: [[{ text: "New", callback_data: "show:projects" }]] } }); } return; }
+  if (d === "noop") { return; }
+  if (d.startsWith("mb:")) {
+    // Unified picker: switch backend + set model in one tap.
+    // Format: mb:<backend>:<model>. Model may contain `:` itself (unlikely), so split on first two.
+    const rest = d.slice(3);
+    const colon = rest.indexOf(":");
+    if (colon < 0) return;
+    const be = rest.slice(0, colon);
+    const model = rest.slice(colon + 1);
+    if (be === "cursor" && !resolvedCursorPath) { await send("Cursor Agent CLI not found."); return; }
+    if (be === "codex" && !resolvedCodexPath) { await send("Codex CLI not found. Install: npm install -g @openai/codex"); return; }
+    const switched = settings.backend !== be;
+    settings.backend = be;
+    settings.model = model;
+    saveState();
+    const beLabel = be === "cursor" ? "Cursor Agent" : be === "codex" ? "Codex" : "Claude Code";
+    await send(switched ? `Switched to ${beLabel}.\nModel: ${model}` : `Model: ${model}`);
+    return;
+  }
   if (d.startsWith("m:")) { settings.model = d.slice(2) === "default" ? null : d.slice(2); await send(`Model: ${settings.model || "default"}`); return; }
   if (d.startsWith("e:")) { const e = d.slice(2); settings.effort = e === "default" ? null : e; await send(`Effort: ${settings.effort || "default"}`); return; }
   if (d.startsWith("b:")) { const b = d.slice(2); settings.budget = b === "none" ? null : parseFloat(b); await send(`Budget: ${settings.budget ? "$"+settings.budget : "none"}`); return; }
   if (d.startsWith("be:")) {
     const be = d.slice(3);
     if (be === "cursor" && !resolvedCursorPath) { await send("Cursor Agent CLI not found."); return; }
+    if (be === "codex" && !resolvedCodexPath) { await send("Codex CLI not found. Install: npm install -g @openai/codex"); return; }
     settings.backend = be;
     settings.model = null;
     saveState();
-    const label = be === "cursor" ? "Cursor Agent" : "Claude Code";
+    const label = be === "cursor" ? "Cursor Agent" : be === "codex" ? "Codex" : "Claude Code";
     await send(`Switched to ${label}.`);
     return;
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "1.15.0",
-  "description": "Your always-on AI coding assistant — Claude Code via Telegram",
+  "version": "1.16.1",
+  "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram",
   "main": "bot.js",
   "bin": {
     "open-claudia": "./bin/cli.js"