@inetafrica/open-claudia 1.20.0 → 2.0.0

package/core/handlers.js

@@ -0,0 +1,995 @@
+// All slash-command handlers. Each registers itself into the registry so
+// adapters can advertise the slash menu and the router can dispatch
+// inbound text uniformly across channels.
+
+const fs = require("fs");
+const path = require("path");
+const cronLib = require("node-cron");
+const { execSync } = require("child_process");
+const {
+  WORKSPACE, FULL_PATH, AUTO_COMPACT_TOKENS, CONFIG_DIR,
+  config, saveEnvKey,
+  CHAT_ID, resolvedCursorPath, resolvedCodexPath, SOUL_FILE,
+} = require("./config");
+const { register } = require("./commands");
+const { send, deleteMessage } = require("./io");
+const { currentState, resetSettings, resetSessionUsage, saveState, getProjectSessions, getLastProjectSession, recordSession, linkIdentity } = require("./state");
+const { canonicalForChannel, normalizeCanonicalUserId, channelKey, identities } = require("./identity");
+const { isChatAuthorized, isChatOwner, recordPendingAuthRequest, authRequestLabel, hasOwner, bootstrapOwner } = require("./access");
+const { isOnboarded, startOnboarding } = require("./onboarding");
+const { listProjects, findProject, projectKeyboard, workspacePath } = require("./projects");
+const { vault } = require("./vault-store");
+const { redactSensitive } = require("./redact");
+const { runDoctorChecks, formatDoctorReport } = require("./doctor");
+const {
+  loadCrons, saveCrons, scheduleCron, activeCrons,
+} = require("./cron");
+const {
+  runClaude, compactActiveSession, getActiveSessionId,
+} = require("./runner");
+const {
+  getClaudeOAuthToken, claudeSubprocessEnv, saveClaudeOAuthToken,
+  clearClaudeOAuthToken, looksLikeClaudeToken, looksLikeClaudeAuthReply,
+  looksLikeOpenAIKey,
+  isClaudeAuthErrorText,
+  summarizeClaudeAuthStatus,
+  sendClaudeAuthStatusSummary,
+  runClaudeAuthCommand, clearPendingClaudeAuth,
+  sendCodexAuthStatusSummary, runCodexDeviceLogin, clearPendingCodexAuth,
+  saveCodexApiKeyWithCli,
+} = require("./auth-flow");
+
+const CURRENT_VERSION = require(path.join(__dirname, "..", "package.json")).version;
+
+function authorized(envelope) {
+  return isChatAuthorized(envelope.channelId);
+}
+
+function ownerEnv(envelope) {
+  return isChatOwner(envelope.channelId);
+}
+
+function requireSession() {
+  if (!currentState().currentSession) {
+    send("Pick a project first:", { keyboard: projectKeyboard() });
+    return false;
+  }
+  return true;
+}
+
+function startSession(name, resumeSessionId) {
+  const state = currentState();
+  let projectName, projectDir;
+  if (name === "__workspace__") {
+    projectName = "Workspace";
+    projectDir = WORKSPACE;
+  } else {
+    const result = findProject(name);
+    if (!result) return send(`No match for "${name}".`, { keyboard: projectKeyboard() });
+    if (Array.isArray(result)) return send("Multiple matches:", { keyboard: { inline_keyboard: result.map((p) => [{ text: p, callback_data: `s:${p}` }]) } });
+    projectName = result;
+    projectDir = path.join(WORKSPACE, result);
+  }
+
+  state.currentSession = { name: projectName, dir: projectDir };
+  state.messageQueue = []; resetSettings(state);
+
+  if (resumeSessionId) {
+    state.lastSessionId = resumeSessionId;
+    const sessions = getProjectSessions(state.userId, projectName);
+    const s = sessions.find((x) => x.id === resumeSessionId);
+    const title = s ? s.title : "";
+    state.isFirstMessage = false;
+    saveState();
+    send(`Session: ${projectName}\nResumed: ${title || resumeSessionId.slice(0, 8)}\n\nSend text, voice, or images.\n\n/sessions — switch conversation\n/session — switch project`);
+  } else {
+    const last = getLastProjectSession(state.userId, projectName);
+    if (last) {
+      state.lastSessionId = last.id;
+      state.isFirstMessage = false;
+      saveState();
+      send(`Session: ${projectName}\nResumed: ${last.title}\n\nSend text, voice, or images.\n\n/sessions — switch conversation\n/session — switch project`, {
+        keyboard: { inline_keyboard: [[{ text: "New conversation", callback_data: `new:${projectName}` }]] },
+      });
+    } else {
+      state.lastSessionId = null;
+      state.isFirstMessage = true;
+      saveState();
+      send(`Session: ${projectName}\n\nSend text, voice, or images.\n\n/sessions — switch conversation\n/session — switch project`);
+    }
+  }
+}
+
+// Make startSession reachable for the action router.
+module.exports.startSession = startSession;
+
+// ── Registry ────────────────────────────────────────────────────────
+
+register({
+  name: "start", description: "Start the bot",
+  handler: async (env) => {
+    if (!authorized(env)) return;
+    if (!isOnboarded()) return startOnboarding();
+    send("Pick a project to start:", { keyboard: { inline_keyboard: [[{ text: "Pick a project", callback_data: "show:projects" }]] } });
+  },
+});
+
+register({
+  name: "help", description: "Show all commands",
+  handler: async (env) => {
+    if (!authorized(env)) return;
+    send([
+      "Session: /session /sessions /projects /continue /status /stop /end",
+      "Settings: /model /effort /budget /plan /compact /worktree /mode",
+      "Identity: /whoami /link",
+      "Automation: /cron /vault /soul",
+      "Claude auth: /auth_status /login /setup_token /use_oauth_token /clear_oauth_token",
+      "Codex auth: /codex_auth_status /codex_login /codex_setup_token",
+      "System: /doctor /requirements /restart /upgrade",
+      "",
+      "Send text, voice, photos, or files.",
+      "Reply to any message for context.",
+    ].join("\n"));
+  },
+});
+
+register({
+  name: "auth", description: "Request access to this bot",
+  authRequired: false,
+  handler: async (env) => {
+    if (authorized(env)) {
+      send("You're already authorized.");
+      return;
+    }
+    if (!hasOwner()) {
+      bootstrapOwner({
+        chatId: env.channelId,
+        name: env.from?.name || "",
+        username: env.from?.username || "",
+      });
+      send("Owner registered — you now have full access.\n\nSend /start to begin.");
+      return;
+    }
+    const result = recordPendingAuthRequest({
+      chatId: env.channelId,
+      name: env.from?.name || "",
+      username: env.from?.username || "",
+    });
+    if (result.status === "already_pending") {
+      send("Your request is already pending. The bot owner will review it.");
+      return;
+    }
+    send("Access requested! The bot owner will review your request.");
+    // Notify the owner via their preferred channel.
+    const ownerNote = `New auth request from ${authRequestLabel({
+      chatId: env.channelId, name: env.from?.name, username: env.from?.username,
+    })} (${env.channelId}).`;
+    // Only send the inline-keyboard prompt back through the same adapter so
+    // the buttons resolve correctly. Cross-channel notifications would need
+    // identities lookup — this stays simple for the v1 cutover.
+    if (String(env.channelId) !== String(CHAT_ID)) {
+      send(ownerNote, {
+        keyboard: { inline_keyboard: [[
+          { text: "Approve", callback_data: `auth:approve:${env.channelId}` },
+          { text: "Deny", callback_data: `auth:deny:${env.channelId}` },
+        ]] },
+        chatId: CHAT_ID, // owner; same adapter
+      });
+    }
+  },
+});
+
+register({
+  name: "whoami", description: "Show your canonical user id",
+  handler: async (env) => {
+    if (!authorized(env)) return;
+    const transport = env.adapter?.type || "telegram";
+    const key = channelKey(transport, env.channelId);
+    const userId = canonicalForChannel(transport, env.channelId);
+    const preferred = identities.preferred[userId];
+    send([
+      `Channel: ${key}`,
+      `User: ${userId}`,
+      preferred ? `Preferred: ${preferred.transport}:${preferred.channelId}` : "Preferred: this channel",
+    ].join("\n"));
+  },
+});
+
+register({
+  name: "links", description: "List identity links (owner)",
+  ownerOnly: true,
+  handler: async (env) => {
+    if (!ownerEnv(env)) return;
+    const rows = Object.entries(identities.channels)
+      .sort(([a], [b]) => a.localeCompare(b))
+      .map(([channel, userId]) => `${channel} -> ${userId}`);
+    send(rows.length ? rows.join("\n") : "No explicit identity links. Unlinked chats use <transport>:<channelId>.");
+  },
+});
+
+register({
+  name: "link", description: "Link this chat to a canonical user id", args: "[<chat-id>] <email-or-id>",
+  handler: async (env, { tail }) => {
+    if (!authorized(env)) return;
+    if (!tail) {
+      send(ownerEnv(env)
+        ? "Usage:\n/link <email-or-user-id>\n/link <chat-id> <email-or-user-id>\n/link <transport>:<chat-id> <email-or-user-id>\n\nOwner can link any chat; other users can link only their current chat."
+        : "Usage:\n/link <email-or-user-id>\n\nThis links your chat to a canonical user id.");
+      return;
+    }
+    const parts = tail.split(/\s+/).filter(Boolean);
+    if (parts.length === 0 || parts.length > 2) return send("Usage: /link <email-or-user-id>");
+
+    let targetTransport = env.adapter?.type || "telegram";
+    let targetChatId = String(env.channelId);
+    let userId = parts[0];
+    if (parts.length === 2) {
+      if (!ownerEnv(env)) return send("Only the owner can link another chat.");
+      const channel = parts[0];
+      if (channel.includes(":")) {
+        const [t, id] = channel.split(":");
+        targetTransport = t || targetTransport;
+        targetChatId = id;
+      } else {
+        targetChatId = channel;
+      }
+      userId = parts[1];
+    }
+    const normalizedUserId = normalizeCanonicalUserId(userId);
+    if (!normalizedUserId || /\s/.test(normalizedUserId)) return send("Canonical user id cannot be empty or contain spaces.");
+    const result = linkIdentity(targetTransport, targetChatId, normalizedUserId);
+    send([
+      `Linked ${result.key} -> ${result.userId}`,
+      result.migrated ? `Migrated state from ${result.previousUserId}.` : "Existing canonical state was left in place.",
+    ].join("\n"));
+  },
+});
+
+register({
+  name: "version", description: "Show current version",
+  handler: async (env) => {
+    if (!authorized(env)) return;
+    send(`Open Claudia v${CURRENT_VERSION}`);
+  },
+});
+
+register({
+  name: "restart", description: "Restart the bot", ownerOnly: true,
+  handler: async (env) => {
+    if (!ownerEnv(env)) return;
+    await send("Going offline for a quick restart — back in a moment.");
+    setTimeout(() => process.exit(0), 1000);
+  },
+});
+
+register({
+  name: "upgrade", description: "Upgrade and restart", ownerOnly: true,
+  handler: async (env) => {
+    if (!ownerEnv(env)) return;
+    try { process.chdir(process.env.HOME || require("os").homedir()); } catch (e) {}
+    let latest = null;
+    try {
+      latest = execSync("npm view @inetafrica/open-claudia version", {
+        encoding: "utf-8", timeout: 15000,
+        env: { ...process.env, PATH: FULL_PATH, HOME: process.env.HOME || require("os").homedir() },
+      }).trim();
+      if (latest === CURRENT_VERSION) {
+        await send(`Already on the latest version (v${CURRENT_VERSION}).`);
+        return;
+      }
+      await send(`Upgrading v${CURRENT_VERSION} → v${latest}...`);
+    } catch (e) {
+      await send("Upgrading...");
+    }
+    const installTarget = latest || "latest";
+    try {
+      execSync(`npm install -g @inetafrica/open-claudia@${installTarget} 2>&1`, {
+        encoding: "utf-8", timeout: 120000,
+        cwd: process.env.HOME || require("os").homedir(),
+        env: { ...process.env, PATH: FULL_PATH, HOME: process.env.HOME || require("os").homedir() },
+      });
+      try {
+        const { ensureSetup: postUpgradeSetup } = require("../health");
+        postUpgradeSetup();
+      } catch (e) {}
+      const root = execSync("npm root -g", { encoding: "utf-8", cwd: process.env.HOME || require("os").homedir(), env: { ...process.env, PATH: FULL_PATH } }).trim();
+      const newPkg = JSON.parse(fs.readFileSync(path.join(root, "@inetafrica", "open-claudia", "package.json"), "utf-8"));
+      let whatsNew = "";
+      try {
+        const changelog = fs.readFileSync(path.join(root, "@inetafrica", "open-claudia", "CHANGELOG.md"), "utf-8");
+        let versionHeader = `## v${newPkg.version}`;
+        let start = changelog.indexOf(versionHeader);
+        if (start < 0) { versionHeader = `## ${newPkg.version}`; start = changelog.indexOf(versionHeader); }
+        if (start >= 0) {
+          const afterHeader = changelog.slice(start + versionHeader.length);
+          const nextVersion = afterHeader.indexOf("\n## ");
+          const section = nextVersion >= 0 ? afterHeader.slice(0, nextVersion) : afterHeader;
+          whatsNew = section.trim();
+        }
+      } catch (e) {}
+      const doctorReport = formatDoctorReport(runDoctorChecks());
+      const msg = `Installed v${newPkg.version}.${whatsNew ? `\n\nWhat's new:\n${whatsNew}` : ""}\n\nPost-upgrade requirements check:\n${doctorReport}\n\nGoing offline to restart...`;
+      await send(msg.length > 3900 ? msg.slice(0, 3900) : msg);
+    } catch (e) {
+      const errOutput = (e.stdout || e.stderr || e.message || "").slice(-500);
+      await send(`Upgrade failed:\n${errOutput}`);
+      return;
+    }
+    setTimeout(() => process.exit(0), 2000);
+  },
+});
+
+register({
+  name: "projects", description: "Browse all workspace projects",
+  handler: async (env) => { if (authorized(env)) send("Pick:", { keyboard: projectKeyboard() }); },
+});
+
+register({
+  name: "session", description: "Pick a project to work on", args: "[<project>]",
+  handler: async (env, { tail }) => {
+    if (!authorized(env)) return;
+    if (tail) return startSession(tail);
+    const cs = currentState().currentSession;
+    if (cs) send(`Active: ${cs.name}\n\nSwitch?`, { keyboard: projectKeyboard() });
+    else send("Pick:", { keyboard: projectKeyboard() });
+  },
+});
+
+register({
+  name: "sessions", description: "List conversations for this project",
+  handler: async (env) => {
+    if (!authorized(env)) return;
+    if (!requireSession()) return;
+    const state = currentState();
+    const sessions = getProjectSessions(state.userId, state.currentSession.name);
+    if (sessions.length === 0) return send("No past conversations for this project.");
+    const rows = sessions.slice(0, 10).map((s) => {
+      const date = new Date(s.lastUsed).toLocaleDateString();
+      const active = state.lastSessionId === s.id ? " (active)" : "";
+      return [{ text: `${s.title}${active} — ${date}`, callback_data: `ss:${s.id}` }];
+    });
+    rows.push([{ text: "New conversation", callback_data: `new:${state.currentSession.name}` }]);
+    send(`Conversations in ${state.currentSession.name}:`, { keyboard: { inline_keyboard: rows } });
+  },
+});
+
+register({
+  name: "model", description: "Switch model (opus/sonnet/haiku)", args: "[<model>]",
+  handler: async (env, { tail }) => {
+    if (!authorized(env)) return;
+    if (tail) {
+      const { settings } = currentState();
+      settings.model = tail.toLowerCase();
+      if (settings.model === "default") settings.model = null;
+      return send(`Model: ${settings.model || "default"}`);
+    }
+    const { settings } = currentState();
+    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 } });
+  },
+});
+
+register({
+  name: "effort", description: "Set effort level", args: "[low|medium|high|max]",
+  handler: async (env, { tail }) => {
+    if (!authorized(env)) return;
+    const { settings } = currentState();
+    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.");
+    if (tail) {
+      const e = tail.toLowerCase();
+      settings.effort = ["low", "medium", "high", "max"].includes(e) ? e : null;
+      return send(`Effort: ${settings.effort || "default"}`);
+    }
+    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" }],
+      ] },
+    });
+  },
+});
+
+register({
+  name: "budget", description: "Set max spend for next task", args: "[$N]",
+  handler: async (env, { tail }) => {
+    if (!authorized(env)) return;
+    const { settings } = currentState();
+    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.");
+    if (tail) {
+      const v = parseFloat(tail.replace("$", ""));
+      settings.budget = v > 0 ? v : null;
+      return send(`Budget: ${settings.budget ? "$" + settings.budget : "none"}`);
+    }
+    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" }],
+      ] },
+    });
+  },
+});
+
+register({
+  name: "plan", description: "Toggle plan mode",
+  handler: async (env) => {
+    if (!authorized(env)) return;
+    const state = currentState();
+    const { settings } = state;
+    const p = settings.permissionMode === "plan";
+    settings.permissionMode = p ? null : "plan";
+    const label = settings.backend === "cursor" ? "read-only planning, no edits"
+      : settings.backend === "codex" ? "read-only sandbox, no edits"
+      : "plan permission mode";
+    if (p) {
+      if (settings.backend === "cursor") state.cursorSessionId = null;
+      else if (settings.backend === "codex") state.codexSessionId = null;
+    }
+    send(p ? "Plan mode off (session reset)." : `Plan mode on (${label}).`);
+  },
+});
+
+register({
+  name: "ask", description: "Toggle ask mode (Cursor only)",
+  handler: async (env) => {
+    if (!authorized(env)) return;
+    const { settings } = currentState();
+    if (settings.backend !== "cursor") return send("Ask mode is only available on Cursor Agent.\nUse /cursor to switch.");
+    const a = settings.permissionMode === "ask";
+    settings.permissionMode = a ? null : "ask";
+    send(a ? "Ask mode off." : "Ask mode on (read-only Q&A, no edits).");
+  },
+});
+
+register({
+  name: "compact", description: "Summarize conversation context",
+  handler: async (env) => {
+    if (!authorized(env)) return;
+    if (!requireSession()) return;
+    if (!getActiveSessionId()) return send("No conversation.");
+    try {
+      const result = await compactActiveSession(currentState().currentSession.dir, {
+        notify: true,
+        message: "Compacting this conversation into a fresh session…",
+      });
+      if (result.compacted) await send(`Compacted into a fresh session${result.newSessionId ? ` (${result.newSessionId.slice(0, 8)}…)` : ""}. Continue normally.`, { replyTo: env.messageId });
+      else await send(result.reason || "Could not compact.", { replyTo: env.messageId });
+    } catch (e) {
+      await send(`Compaction failed: ${redactSensitive(e.message)}`, { replyTo: env.messageId });
+    }
+  },
+});
+
+register({
+  name: "continue", description: "Resume last conversation",
+  handler: async (env) => {
+    if (!authorized(env)) return;
+    if (!requireSession()) return;
+    if (!getActiveSessionId()) return send("No conversation to continue.");
+    await runClaude("continue where we left off", currentState().currentSession.dir, env.messageId);
+  },
+});
+
+register({
+  name: "worktree", description: "Toggle isolated git branch",
+  handler: async (env) => {
+    if (!authorized(env)) return;
+    const { settings } = currentState();
+    settings.worktree = !settings.worktree;
+    send(settings.worktree ? "Worktree on." : "Worktree off.");
+  },
+});
+
+register({
+  name: "cursor", description: "Switch to Cursor Agent backend",
+  handler: async (env) => {
+    if (!authorized(env)) return;
+    if (!resolvedCursorPath) return send("Cursor Agent CLI not found.\nSet CURSOR_PATH in .env or install: https://docs.cursor.com/agent");
+    const state = currentState();
+    state.settings.backend = "cursor";
+    state.settings.model = null;
+    saveState();
+    const sid = state.cursorSessionId ? `\nSession: ${state.cursorSessionId.slice(0, 8)}...` : "\nNew session.";
+    send(`Switched to Cursor Agent.${sid}\n\n/claude — switch back · /codex — Codex`);
+  },
+});
+
+register({
+  name: "claude", description: "Switch to Claude Code backend",
+  handler: async (env) => {
+    if (!authorized(env)) return;
+    const state = currentState();
+    state.settings.backend = "claude";
+    state.settings.model = null;
+    saveState();
+    const sid = state.lastSessionId ? `\nSession: ${state.lastSessionId.slice(0, 8)}...` : "\nNew session.";
+    send(`Switched to Claude Code.${sid}\n\n/cursor — Cursor · /codex — Codex`);
+  },
+});
+
+register({
+  name: "codex", description: "Switch to OpenAI Codex backend",
+  handler: async (env) => {
+    if (!authorized(env)) return;
+    if (!resolvedCodexPath) return send("Codex CLI not found.\nInstall: npm install -g @openai/codex\nThen run `codex login` to authenticate.");
+    const state = currentState();
+    state.settings.backend = "codex";
+    state.settings.model = null;
+    saveState();
+    const sid = state.codexSessionId ? `\nSession: ${state.codexSessionId.slice(0, 8)}...` : "\nNew session.";
+    send(`Switched to Codex.${sid}\n\n/claude — Claude · /cursor — Cursor`);
+  },
+});
+
+register({
+  name: "backend", description: "Show/switch active backend",
+  handler: async (env) => {
+    if (!authorized(env)) return;
+    const { settings } = currentState();
+    const label = settings.backend === "cursor" ? "Cursor Agent" : settings.backend === "codex" ? "Codex" : "Claude Code";
+    const cursorAvail = resolvedCursorPath ? "available" : "not found";
+    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" }],
+      ] },
+    });
+  },
+});
+
+register({
+  name: "mode", description: "Bot mode (direct/agent)",
+  handler: async (env) => {
+    if (!authorized(env)) return;
+    await send("Bot mode: *direct* (default)\n\nSwitch to agent mode for non-blocking execution.\nIn agent mode, heavy tasks run in the background and you can keep chatting.", {
+      parseMode: "Markdown",
+      keyboard: { inline_keyboard: [[{ text: "Switch to Agent Mode", callback_data: "mode:agent" }]] },
+    });
+  },
+});
+
+register({
+  name: "stop", description: "Cancel running task",
+  handler: async (env) => {
+    if (!authorized(env)) return;
+    const state = currentState();
+    if (state.runningProcess) {
+      const pid = state.runningProcess.pid;
+      const { killProcessTree } = require("./process-tree");
+      killProcessTree(pid, "SIGTERM");
+      setTimeout(() => killProcessTree(pid, "SIGKILL"), 3000);
+      state.runningProcess = null;
+      if (state.streamInterval) clearTimeout(state.streamInterval);
+      state.messageQueue = [];
+      await send("Cancelled.");
+    } else await send("Nothing running.");
+  },
+});
+
+register({
+  name: "doctor", aliases: ["requirements"], description: "Check CLI requirements",
+  handler: async (env) => {
+    if (!authorized(env)) return;
+    await send(formatDoctorReport(runDoctorChecks()));
+  },
+});
+
+register({
+  name: "status", description: "Session & settings info",
+  handler: async (env) => {
+    if (!authorized(env)) return;
+    const state = currentState();
+    if (!state.currentSession) return send("No session.", { keyboard: { inline_keyboard: [[{ text: "Pick", callback_data: "show:projects" }]] } });
+    const { settings } = state;
+    const backendLabel = settings.backend === "cursor" ? "Cursor Agent" : settings.backend === "codex" ? "Codex" : "Claude Code";
+    send([
+      `Project: ${state.currentSession.name}`,
+      `Backend: ${backendLabel}`,
+      `Model: ${settings.model || "default"} | Effort: ${settings.effort || "default"}`,
+      `Vault: ${vault.isUnlocked() ? "unlocked" : "locked"} | Crons: ${activeCrons.size}`,
+      state.runningProcess ? "Working..." : "Ready.",
+    ].join("\n"));
+  },
+});
+
+register({
+  name: "end", description: "End current session",
+  handler: async (env) => {
+    if (!authorized(env)) return;
+    const state = currentState();
+    if (state.currentSession) {
+      const n = state.currentSession.name;
+      state.currentSession = null;
+      state.lastSessionId = null;
+      state.messageQueue = [];
+      resetSettings(state);
+      resetSessionUsage(state);
+      saveState();
+      send(`Ended: ${n}`, { keyboard: { inline_keyboard: [[{ text: "New session", callback_data: "show:projects" }]] } });
+    } else send("No session.");
+  },
+});
+
+register({
+  name: "usage", description: "Show token usage & cost for this session",
+  handler: async (env) => {
+    if (!authorized(env)) return;
+    const u = currentState().sessionUsage;
+    if (u.turns === 0) return send("No usage yet in this session.");
+    const fmt = (n) => n >= 1000 ? (n / 1000).toFixed(1) + "k" : String(n);
+    const lines = [
+      `*Session usage* (${u.turns} turn${u.turns === 1 ? "" : "s"})`,
+      `Input: ${fmt(u.inputTokens)} · Output: ${fmt(u.outputTokens)}`,
+      `Cache read: ${fmt(u.cacheReadTokens)} · Cache write: ${fmt(u.cacheCreationTokens)}`,
+      `Cost: $${u.costUsd.toFixed(4)}`,
+      `Last turn context: ${fmt(u.lastInputTokens)}`,
+    ];
+    if (u.lastInputTokens > 200000) lines.push(`\nTip: context is large. The bot auto-compacts after the next reply at ${fmt(AUTO_COMPACT_TOKENS)} tokens; /compact does it now.`);
+    send(lines.join("\n"), { parseMode: "Markdown" });
+  },
+});
+
+register({
+  name: "soul", description: "View/edit assistant identity",
+  handler: async (env) => {
+    if (!authorized(env)) return;
+    let soul;
+    try { soul = fs.readFileSync(SOUL_FILE, "utf-8"); } catch (e) { soul = ""; }
+    const preview = soul.length > 3000 ? soul.slice(0, 3000) + "\n..." : (soul || "(empty)");
+    await send(preview);
+    await send(`Edit: ${SOUL_FILE}\nOr tell me what to change and I'll update it.`);
+  },
+});
+
+// ── Claude auth ─────────────────────────────────────────────────────
+
+register({
+  name: "auth_status", aliases: ["auth status"], description: "Check Claude Code auth",
+  handler: async (env) => {
+    if (!authorized(env)) return;
+    const { spawn } = require("child_process");
+    const { CLAUDE_PATH } = require("./config");
+    const tokenInfo = getClaudeOAuthToken();
+    const proc = spawn(CLAUDE_PATH, ["auth", "status"], {
+      cwd: process.env.HOME || require("os").homedir(),
+      env: claudeSubprocessEnv(),
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    let output = "";
+    proc.stdout.on("data", (d) => { output += d.toString(); });
+    proc.stderr.on("data", (d) => { output += d.toString(); });
+    await new Promise((resolve) => {
+      proc.on("close", async (code) => {
+        const clean = redactSensitive(output.trim()) || "(no output)";
+        await send([
+          `Claude auth status: exit ${code}`,
+          ...summarizeClaudeAuthStatus(output, code, tokenInfo),
+          `Bot OAuth token: ${tokenInfo.value ? "configured via " + tokenInfo.source : "not configured"}`,
+          `Vault: ${vault.isUnlocked() ? "unlocked" : "locked"}`,
+          "",
+          clean.slice(-2500),
+        ].join("\n"));
+        resolve();
+      });
+      proc.on("error", async (err) => { await send(`Claude auth status failed: ${redactSensitive(err.message)}`); resolve(); });
+    });
+  },
+});
+
+register({
+  name: "cancel_auth", description: "Cancel a pending Claude login flow", ownerOnly: true,
+  handler: async (env) => {
+    if (!ownerEnv(env)) return send("Owner only — Claude auth is shared across users.");
+    const state = currentState();
+    if (!state.pendingClaudeAuthProcess) return send("No Claude auth flow is pending.");
+    clearPendingClaudeAuth(state);
+    await send("Claude auth flow cancelled. Normal messages will go to the assistant again.");
+  },
+});
+
+register({
+  name: "auth_code", description: "Send a Claude login code", args: "<code>", ownerOnly: true,
+  handler: async (env, { tail }) => {
+    if (!ownerEnv(env)) return send("Owner only — Claude auth is shared across users.");
+    const state = currentState();
+    const code = (tail || "").trim();
+    await deleteMessage(env.messageId);
+    if (!state.pendingClaudeAuthProcess || state.pendingClaudeAuthLabel === "manual OAuth token save") {
+      return send("No Claude login flow is waiting for an auth code. Start with /login, or use /use_oauth_token for tokens.");
+    }
+    if (!code || !looksLikeClaudeAuthReply(code)) {
+      return send("That does not look like a Claude auth code/callback. Use /cancel_auth to cancel the login flow.");
+    }
+    try {
+      state.pendingClaudeAuthProcess.stdin.write(code + "\n");
+      await send("Auth code sent to Claude. I'll confirm with auth status when Claude finishes.");
+    } catch (e) {
+      clearPendingClaudeAuth(state);
+      await send(`Could not send auth code to Claude: ${redactSensitive(e.message)}`);
+    }
+  },
+});
+
+register({
+  name: "login", description: "Start Claude Code login", ownerOnly: true,
+  handler: async (env) => {
+    if (!ownerEnv(env)) return send("Owner only — Claude auth is shared across users.");
+    await runClaudeAuthCommand(["auth", "login", "--claudeai", "--email", "sumeet@inet.africa"], "Claude login");
+  },
+});
+
+register({
+  name: "setup_token", description: "Create Claude OAuth token", ownerOnly: true,
+  handler: async (env) => {
+    if (!ownerEnv(env)) return send("Owner only — Claude auth is shared across users.");
+    await runClaudeAuthCommand(["setup-token"], "Claude setup-token", { captureToken: true });
+  },
+});
+
+register({
+  name: "use_oauth_token", description: "Paste a Claude OAuth token", args: "[<token>]", ownerOnly: true,
+  handler: async (env, { tail }) => {
+    if (!ownerEnv(env)) return send("Owner only — Claude auth is shared across users.");
+    const state = currentState();
+    const token = (tail || "").trim();
+    await deleteMessage(env.messageId);
+    if (!token) {
+      state.pendingClaudeAuthProcess = { stdin: { write: (value) => saveClaudeOAuthToken(value.trim()) } };
+      state.pendingClaudeAuthLabel = "manual OAuth token save";
+      await send("Send the Claude OAuth token in your next message. I'll delete it and store it without echoing it.");
+      return;
+    }
+    if (!looksLikeClaudeToken(token)) return send("That doesn't look like a Claude OAuth token. Not saved.");
+    saveClaudeOAuthToken(token);
+    await send(`Claude OAuth token stored in .env${vault.isUnlocked() ? " and vault" : ""}. Restart the bot so launchd picks it up, or use /restart.`);
+    await sendClaudeAuthStatusSummary("Stored token. Current Claude auth status:");
+  },
+});
+
+register({
+  name: "clear_oauth_token", description: "Clear stored Claude OAuth token", ownerOnly: true,
+  handler: async (env) => {
+    if (!ownerEnv(env)) return send("Owner only — Claude auth is shared across users.");
+    clearClaudeOAuthToken();
+    await send("Claude OAuth token cleared from .env/process" + (vault.isUnlocked() ? " and vault." : ". Unlock vault and run again if you also stored it there."));
+  },
+});
+
+register({
+  name: "codex_auth_status", aliases: ["codex auth status"], description: "Check Codex auth",
+  handler: async (env) => {
+    if (!authorized(env)) return;
+    await sendCodexAuthStatusSummary();
+  },
+});
+
+register({
+  name: "codex_login", description: "Start Codex device login", ownerOnly: true,
+  handler: async (env) => {
+    if (!ownerEnv(env)) return send("Owner only — Codex auth is shared across users.");
+    await runCodexDeviceLogin();
+  },
+});
+
+register({
+  name: "cancel_codex_auth", description: "Cancel a pending Codex login flow", ownerOnly: true,
+  handler: async (env) => {
+    if (!ownerEnv(env)) return send("Owner only — Codex auth is shared across users.");
+    const state = currentState();
+    if (!state.pendingCodexAuthProcess) return send("No Codex auth flow is pending.");
+    clearPendingCodexAuth(state);
+    await send("Codex auth flow cancelled. Normal messages will go to the assistant again.");
+  },
+});
+
+register({
+  name: "codex_setup_token", aliases: ["codex_use_api_key"], description: "Save an OpenAI API key", args: "[<key>]", ownerOnly: true,
+  handler: async (env, { tail }) => {
+    if (!ownerEnv(env)) return send("Owner only — Codex auth is shared across users.");
+    if (!resolvedCodexPath) return send("Codex CLI not found. Install: npm install -g @openai/codex");
+    const key = (tail || "").trim();
+    await deleteMessage(env.messageId);
+    if (!key) {
+      const state = currentState();
+      state.pendingCodexAuthProcess = { kill: () => {} };
+      state.pendingCodexAuthLabel = "manual OpenAI API key save";
+      await send("Send the OpenAI API key in your next message. I'll delete it and pass it to `codex login --with-api-key` without echoing it.");
+      return;
+    }
+    if (!looksLikeOpenAIKey(key)) return send("That does not look like an OpenAI API key. Not saved.");
+    const result = await saveCodexApiKeyWithCli(key);
+    await send(result.ok ? "Codex API key stored by the Codex CLI. I did not print it." : `Codex CLI could not store the API key: ${redactSensitive(result.output).slice(-800)}`);
+    await sendCodexAuthStatusSummary("Current Codex auth status:");
+  },
+});
+
+// ── Vault ──────────────────────────────────────────────────────────
+
+register({
+  name: "vault", description: "Manage credentials (password required)", args: "[set|remove|lock] ...",
+  handler: async (env, { tail }) => {
+    if (!authorized(env)) return;
+    const state = currentState();
+
+    if (!tail) {
+      if (!vault.exists()) return send("No vault found. Run setup first: node setup.js");
+      if (vault.isUnlocked()) {
+        const entries = vault.list();
+        const keys = Object.keys(entries);
+        if (keys.length === 0) await send("Vault is unlocked but empty.\n\nUse /vault set <name> <value>");
+        else await send("Vault (unlocked):\n\n" + keys.map((k) => `${k}: ${entries[k]}`).join("\n") + "\n\nLocks automatically in 5 min.");
+      } else {
+        state.pendingVaultUnlock = true;
+        state.pendingVaultAction = { type: "list" };
+        await send("Vault is locked. Send your vault password.\n(Message will be deleted after reading)");
+      }
+      return;
+    }
+
+    if (tail === "lock") {
+      vault.lock();
+      return send("Vault locked.");
+    }
+
+    const setMatch = tail.match(/^set\s+(\S+)\s+(.+)$/);
+    if (setMatch) {
+      await deleteMessage(env.messageId);
+      if (vault.isUnlocked()) {
+        vault.set(setMatch[1], setMatch[2].trim());
+        return send(`Saved: ${setMatch[1]}`);
+      }
+      state.pendingVaultUnlock = true;
+      state.pendingVaultAction = { type: "set", key: setMatch[1], value: setMatch[2].trim() };
+      return send("Vault locked. Send password to unlock.");
+    }
+
+    const removeMatch = tail.match(/^remove\s+(\S+)$/);
+    if (removeMatch) {
+      if (vault.isUnlocked()) {
+        vault.remove(removeMatch[1]);
+        return send(`Removed: ${removeMatch[1]}`);
+      }
+      state.pendingVaultUnlock = true;
+      state.pendingVaultAction = { type: "remove", key: removeMatch[1] };
+      return send("Vault locked. Send password to unlock.");
+    }
+
+    send("Usage: /vault | /vault set <name> <value> | /vault remove <name> | /vault lock");
+  },
+});
+
+// ── Cron ───────────────────────────────────────────────────────────
+
+register({
+  name: "cron", description: "Manage scheduled tasks", args: "[add|remove ...]",
+  handler: async (env, { tail }) => {
+    if (!authorized(env)) return;
+    if (!tail) {
+      const list = loadCrons();
+      if (list.length === 0) {
+        return send("No crons.\n\nAdd: /cron add \"<schedule>\" <project> \"<prompt>\"\n\nOr pick a preset:", {
+          keyboard: { inline_keyboard: [
+            [{ text: "Standup 9am", callback_data: "cp:standup" }, { text: "Git digest 6pm", callback_data: "cp:git" }],
+            [{ text: "Dep check Mon", callback_data: "cp:deps" }, { text: "Health 30min", callback_data: "cp:health" }],
+          ] },
+        });
+      }
+      return send("Crons:\n\n" + list.map((c, i) => `${i + 1}. ${c.label} (${c.schedule}) — ${c.project}`).join("\n") + "\n\nRemove: /cron remove <#>");
+    }
+
+    const addMatch = tail.match(/^add\s+"(.+)"\s+(\S+)\s+"(.+)"$/);
+    if (addMatch) {
+      if (!cronLib.validate(addMatch[1])) return send("Invalid cron schedule.");
+      const proj = findProject(addMatch[2]);
+      if (!proj || Array.isArray(proj)) return send("Project not found.");
+      const c = { id: `cron_${Date.now()}`, schedule: addMatch[1], project: proj, prompt: addMatch[3], label: addMatch[3].slice(0, 50) };
+      const list = loadCrons(); list.push(c); saveCrons(list); scheduleCron(c);
+      return send(`Added: ${c.label} (${c.schedule}) for ${proj}`);
+    }
+
+    const removeMatch = tail.match(/^remove\s+(\d+)$/);
+    if (removeMatch) {
+      const list = loadCrons();
+      const idx = parseInt(removeMatch[1], 10) - 1;
+      if (idx < 0 || idx >= list.length) return send("Invalid number.");
+      const removed = list.splice(idx, 1)[0]; saveCrons(list);
+      if (activeCrons.has(removed.id)) { activeCrons.get(removed.id).task.stop(); activeCrons.delete(removed.id); }
+      return send(`Removed: ${removed.label}`);
+    }
+
+    send('Usage: /cron | /cron add "<schedule>" <project> "<prompt>" | /cron remove <#>');
+  },
+});
+
+// ── Channels ───────────────────────────────────────────────────────
+
+register({
+  name: "channel", description: "Add or remove channels (Kazee, etc.)", args: "[add kazee | remove <id>]", ownerOnly: true,
+  handler: async (env, { tail }) => {
+    if (!ownerEnv(env)) return send("Owner only — channels are bot-wide.");
+    const registry = require("./adapter-registry");
+    const wizard = require("./channel-wizard");
+
+    if (!tail) {
+      const live = registry.getAdapters();
+      const lines = ["Active channels:"];
+      for (const a of live) lines.push(`  ${a.id} (${a.type})`);
+      if (live.length === 0) lines.push("  (none)");
+      lines.push("", "Add Kazee with /channel add kazee.");
+      const buttons = [[{ text: "Add Kazee", callback_data: "chn:add:kazee" }]];
+      const removable = live.filter((a) => a.type !== "telegram");
+      for (const a of removable) {
+        buttons.push([{ text: `Remove ${a.id}`, callback_data: `chn:rm:${a.id}` }]);
+      }
+      return send(lines.join("\n"), { keyboard: { inline_keyboard: buttons } });
+    }
+
+    const addMatch = tail.match(/^add\s+(\S+)$/i);
+    if (addMatch) {
+      const kind = addMatch[1].toLowerCase();
+      if (kind !== "kazee") return send(`Channel type "${kind}" not supported.`);
+      await wizard.start(env.canonicalUserId, "kazee");
+      return;
+    }
+
+    const removeMatch = tail.match(/^remove\s+(\S+)$/i);
+    if (removeMatch) {
+      const id = removeMatch[1];
+      if (id === "telegram") return send("Refusing to remove the Telegram adapter from a /channel command — that's your own connection.");
+      const result = await registry.removeAdapter(id);
+      if (!result.ok) return send(result.error);
+      // Strip from .env so the change survives restart.
+      const channels = (config.CHANNELS || "telegram").split(",").map((s) => s.trim()).filter(Boolean);
+      const kept = channels.filter((c) => c !== id && !c.startsWith(id + ":") && c !== id.split(":")[0]);
+      const next = kept.join(",") || "telegram";
+      saveEnvKey("CHANNELS", next);
+      config.CHANNELS = next;
+      if (id === "kazee") {
+        saveEnvKey("KAZEE_URL", "");
+        saveEnvKey("KAZEE_BOT_TOKEN", "");
+        saveEnvKey("KAZEE_OWNER_USER_ID", "");
+        config.KAZEE_URL = "";
+        config.KAZEE_BOT_TOKEN = "";
+        config.KAZEE_OWNER_USER_ID = "";
+      }
+      return send(`Removed channel: ${id}`);
+    }
+
+    send("Usage: /channel | /channel add kazee | /channel remove <id>");
+  },
+});
+
+module.exports.startSession = startSession;