@inetafrica/open-claudia 1.20.0 → 2.0.0

package/core/actions.js

@@ -0,0 +1,180 @@
+// Button-press router. Handles callback_data from Telegram and the same
+// strings from Kazee's interactive buttons. The payload format is the
+// same on both: short prefix-coded strings already in use today.
+
+const fs = require("fs");
+const path = require("path");
+const { CONFIG_DIR, WORKSPACE, CHAT_ID, resolvedCursorPath, resolvedCodexPath } = require("./config");
+const { send } = require("./io");
+const { currentState, resetSettings, resetSessionUsage, saveState } = require("./state");
+const { runClaude, getActiveSessionId } = require("./runner");
+const { listProjects, projectKeyboard, workspacePath } = require("./projects");
+const { isChatOwner, approveAuthRequest, denyAuthRequest, authRequestLabel } = require("./access");
+const { finishOnboarding } = require("./onboarding");
+const { startSession } = require("./handlers");
+const { activeCrons, loadCrons, saveCrons, scheduleCron } = require("./cron");
+
+async function handleAction(envelope) {
+  const adapter = envelope.adapter;
+  const d = envelope.action?.payload || envelope.action?.buttonId || "";
+  // Telegram needs us to ack the callback so the client stops spinning.
+  if (adapter && adapter.type === "telegram" && envelope.action?.callbackId) {
+    try { await adapter.bot.answerCallbackQuery(envelope.action.callbackId); } catch (e) {}
+  }
+  const state = currentState();
+
+  if (d.startsWith("auth:")) {
+    if (!isChatOwner(envelope.channelId)) return send("Owner only — auth approvals are restricted.");
+    const [, action, chatId] = d.split(":");
+    if (!chatId || !["approve", "deny"].includes(action)) return;
+    const result = action === "approve" ? approveAuthRequest(chatId) : denyAuthRequest(chatId);
+
+    if (result.status === "not_found") return send(`No pending auth request found for ${chatId}.`);
+    if (result.status === "already_authorized") return send(`Chat ${chatId} is already authorized.`);
+
+    const label = authRequestLabel(result.request);
+    if (result.status === "approved") {
+      try { await adapter.send(chatId, "Your access has been approved! You can now use the bot. Send /start to begin."); } catch (e) {}
+      if (envelope.action.sourceMessageId) {
+        await adapter.edit(envelope.channelId, envelope.action.sourceMessageId, `Approved auth request from ${label} (${chatId}).`, {});
+      } else {
+        await send(`Approved ${label} (${chatId}).`);
+      }
+      return;
+    }
+    try { await adapter.send(chatId, "Your access request was denied."); } catch (e) {}
+    if (envelope.action.sourceMessageId) {
+      await adapter.edit(envelope.channelId, envelope.action.sourceMessageId, `Denied auth request from ${label} (${chatId}).`, {});
+    } else {
+      await send(`Denied ${label} (${chatId}).`);
+    }
+    return;
+  }
+
+  if (d.startsWith("ob:")) { finishOnboarding(d.slice(3)); return; }
+
+  if (d === "show:projects") { await send("Pick:", { keyboard: projectKeyboard() }); return; }
+  if (d.startsWith("s:")) { startSession(d.slice(2)); return; }
+  if (d.startsWith("ss:")) { if (state.currentSession) startSession(state.currentSession.name, d.slice(3)); return; }
+  if (d.startsWith("new:")) {
+    const proj = d.slice(4);
+    state.currentSession = { name: proj === "__workspace__" ? "Workspace" : proj, dir: workspacePath(proj) };
+    state.lastSessionId = null;
+    state.isFirstMessage = true;
+    state.messageQueue = [];
+    resetSettings(state);
+    resetSessionUsage(state);
+    saveState();
+    await send(`Session: ${state.currentSession.name}\nNew conversation\n\nSend text, voice, or images.\n\n/sessions — switch conversation\n/session — switch project`);
+    return;
+  }
+  if (d === "a:continue") { if (state.currentSession && getActiveSessionId()) await runClaude("continue", state.currentSession.dir); else send("No session to continue."); return; }
+  if (d === "a:end") {
+    if (state.currentSession) {
+      const n = state.currentSession.name;
+      state.currentSession = null;
+      state.lastSessionId = null;
+      state.messageQueue = [];
+      resetSettings(state);
+      resetSessionUsage(state);
+      saveState();
+      await send(`Ended: ${n}`, { keyboard: { inline_keyboard: [[{ text: "New", callback_data: "show:projects" }]] } });
+    }
+    return;
+  }
+  if (d === "noop") return;
+  if (d.startsWith("mb:")) {
+    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 = state.settings.backend !== be;
+    state.settings.backend = be;
+    state.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:")) { state.settings.model = d.slice(2) === "default" ? null : d.slice(2); await send(`Model: ${state.settings.model || "default"}`); return; }
+  if (d.startsWith("e:")) { const e = d.slice(2); state.settings.effort = e === "default" ? null : e; await send(`Effort: ${state.settings.effort || "default"}`); return; }
+  if (d.startsWith("b:")) { const b = d.slice(2); state.settings.budget = b === "none" ? null : parseFloat(b); await send(`Budget: ${state.settings.budget ? "$" + state.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; }
+    state.settings.backend = be;
+    state.settings.model = null;
+    saveState();
+    const label = be === "cursor" ? "Cursor Agent" : be === "codex" ? "Codex" : "Claude Code";
+    await send(`Switched to ${label}.`);
+    return;
+  }
+
+  if (d.startsWith("mode:")) {
+    if (!isChatOwner(envelope.channelId)) { await send("Owner only — mode switch restarts the bot."); return; }
+    const newMode = d.slice(5);
+    const modeFile = path.join(CONFIG_DIR, ".bot-mode");
+    fs.writeFileSync(modeFile, newMode);
+    await send(`Switching to ${newMode} mode... restarting.`);
+    setTimeout(() => process.exit(0), 500);
+    return;
+  }
+
+  if (d.startsWith("cp:") && d !== "cp:clear") {
+    if (!state.currentSession) return send("Start a session first.");
+    const presets = {
+      standup: { schedule: "0 9 * * 1-5", prompt: "Morning standup: recent commits, failing tests, open TODOs, what to focus on today. Brief.", label: "Morning standup" },
+      git: { schedule: "0 18 * * 1-5", prompt: "Git digest: today's commits, changed files, uncommitted changes. Flag concerns.", label: "Git digest" },
+      deps: { schedule: "0 10 * * 1", prompt: "Check outdated/vulnerable dependencies. Brief — just what needs attention.", label: "Dep check" },
+      health: { schedule: "*/30 * * * *", prompt: "Quick health: can the project build? Run build/lint, report pass/fail.", label: "Health check" },
+    };
+    const p = presets[d.slice(3)];
+    if (!p) return;
+    const c = { id: `cron_${Date.now()}`, ...p, project: state.currentSession.name };
+    const list = loadCrons(); list.push(c); saveCrons(list); scheduleCron(c);
+    await send(`Added: ${c.label} for ${state.currentSession.name}`);
+    return;
+  }
+  if (d === "cp:clear") {
+    for (const [, v] of activeCrons) v.task.stop();
+    activeCrons.clear();
+    saveCrons([]);
+    await send("All crons cleared.");
+    return;
+  }
+
+  if (d.startsWith("chn:")) {
+    if (!isChatOwner(envelope.channelId)) { await send("Owner only."); return; }
+    const wizard = require("./channel-wizard");
+    const registry = require("./adapter-registry");
+    if (d === "chn:add:kazee") { await wizard.start(envelope.canonicalUserId, "kazee"); return; }
+    if (d.startsWith("chn:rm:")) {
+      const id = d.slice("chn:rm:".length);
+      if (id === "telegram") { await send("Refusing to remove the Telegram adapter."); return; }
+      const result = await registry.removeAdapter(id);
+      if (!result.ok) { await send(result.error); return; }
+      const { config, saveEnvKey } = require("./config");
+      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 = "";
+      }
+      await send(`Removed channel: ${id}`);
+      return;
+    }
+  }
+}
+
+module.exports = { handleAction };

package/core/adapter-registry.js

@@ -0,0 +1,113 @@
+// Runtime registry of live ChannelAdapter instances.
+//
+// bot.js used to construct, boot, and tear down adapters in-line. That
+// worked for a static CHANNELS=telegram,kazee list at startup, but the
+// /channel command needs to add and remove adapters while the bot keeps
+// running. This module owns those mechanics — including the cron
+// dispatch hookup — so callers add/remove without each one having to
+// remember to re-wire everything.
+
+const { loadChannels } = require("./config");
+const { setAdapters } = require("./cron");
+
+const { TelegramAdapter } = require("../channels/telegram/adapter");
+const { KazeeAdapter } = require("../channels/kazee/adapter");
+
+const adapters = [];
+let messageHandler = null;
+let actionHandler = null;
+
+function createAdapter(spec) {
+  if (spec.type === "telegram") return new TelegramAdapter({ id: spec.id, ...spec.opts });
+  if (spec.type === "kazee") return new KazeeAdapter({ id: spec.id, ...spec.opts });
+  console.error(`Unknown adapter type: ${spec.type}`);
+  return null;
+}
+
+function notifyCron() {
+  setAdapters(adapters);
+}
+
+function wireAdapter(adapter) {
+  if (messageHandler) adapter.on("message", messageHandler);
+  if (actionHandler) adapter.on("action", actionHandler);
+}
+
+function setHandlers({ onMessage, onAction }) {
+  messageHandler = onMessage;
+  actionHandler = onAction;
+  for (const a of adapters) wireAdapter(a);
+}
+
+// Construct (but do not start) every adapter declared in CHANNELS.
+// Returns the array of constructed adapters so bot.js can keep its
+// boot-failure messaging in one place.
+function bootstrap() {
+  adapters.length = 0;
+  for (const spec of loadChannels()) {
+    try {
+      const a = createAdapter(spec);
+      if (a) {
+        adapters.push(a);
+        wireAdapter(a);
+      }
+    } catch (e) {
+      console.error(`Adapter ${spec.type} failed to construct:`, e.message);
+    }
+  }
+  notifyCron();
+  return adapters;
+}
+
+function getAdapters() {
+  return adapters.slice();
+}
+
+function findAdapter(id) {
+  return adapters.find((a) => a.id === id) || null;
+}
+
+// Add a freshly-validated channel and boot it. The caller is responsible
+// for having already written its credentials to .env. On start failure
+// we tear the adapter back down and return the error so the caller can
+// roll the .env edit back.
+async function addAdapter(spec, { publicCommands } = {}) {
+  if (findAdapter(spec.id)) {
+    return { ok: false, error: `Adapter ${spec.id} already exists` };
+  }
+  const adapter = createAdapter(spec);
+  if (!adapter) return { ok: false, error: `Unknown adapter type: ${spec.type}` };
+  adapters.push(adapter);
+  wireAdapter(adapter);
+  notifyCron();
+  try {
+    await adapter.start();
+    if (publicCommands) {
+      try { await adapter.registerCommands(publicCommands); } catch (e) { /* non-fatal */ }
+    }
+    return { ok: true, adapter };
+  } catch (e) {
+    const idx = adapters.indexOf(adapter);
+    if (idx >= 0) adapters.splice(idx, 1);
+    notifyCron();
+    return { ok: false, error: e.message || String(e) };
+  }
+}
+
+async function removeAdapter(id) {
+  const idx = adapters.findIndex((a) => a.id === id);
+  if (idx < 0) return { ok: false, error: `No adapter ${id}` };
+  const [adapter] = adapters.splice(idx, 1);
+  notifyCron();
+  try { await adapter.stop(); } catch (e) {}
+  return { ok: true };
+}
+
+module.exports = {
+  bootstrap,
+  setHandlers,
+  getAdapters,
+  findAdapter,
+  addAdapter,
+  removeAdapter,
+};