@inetafrica/open-claudia 1.20.0 → 2.0.0

package/core/router.js

@@ -0,0 +1,309 @@
+// Inbound router. Takes a normalised envelope from any adapter, runs
+// the right scope (chat context, dedup, auth gates), and dispatches to
+// commands / media / runner.
+
+const fs = require("fs");
+const path = require("path");
+const { runInChat } = require("./context");
+const { dispatch } = require("./commands");
+const { handleAction } = require("./actions");
+const { isChatAuthorized } = require("./access");
+const { send, deleteMessage } = require("./io");
+const { currentState } = require("./state");
+const { runClaude } = require("./runner");
+const { transcribeAudio } = require("./media");
+const { vault } = require("./vault-store");
+const { isOnboarded, handleOnboarding } = require("./onboarding");
+const {
+  looksLikeOpenAIKey, looksLikeClaudeToken, looksLikeClaudeAuthReply,
+  saveClaudeOAuthToken, saveCodexApiKeyWithCli,
+  clearPendingClaudeAuth, clearPendingCodexAuth,
+  sendClaudeAuthStatusSummary, sendCodexAuthStatusSummary,
+} = require("./auth-flow");
+const { redactSensitive } = require("./redact");
+const { MAX_FILE_SIZE, MAX_VOICE_SIZE, FILES_DIR } = require("./config");
+const channelWizard = require("./channel-wizard");
+require("./handlers"); // side-effect: register slash commands
+
+// Per-adapter dedup. Telegram message_ids are unique per chat, not
+// globally; same goes for Kazee. Namespace by adapter:channel:msg.
+const processedMessages = new Set();
+function isDuplicate(envelope) {
+  const key = `${envelope.adapter?.id || envelope.adapter?.type}:${envelope.channelId}:${envelope.messageId}`;
+  if (processedMessages.has(key)) return true;
+  processedMessages.add(key);
+  if (processedMessages.size > 400) {
+    const arr = [...processedMessages];
+    processedMessages.clear();
+    arr.slice(-200).forEach((k) => processedMessages.add(k));
+  }
+  return false;
+}
+
+function scope(envelope, fn) {
+  return runInChat({
+    adapter: envelope.adapter,
+    channelId: envelope.channelId,
+    canonicalUserId: envelope.canonicalUserId,
+    raw: envelope.raw,
+  }, fn);
+}
+
+async function onMessage(envelope) {
+  return scope(envelope, async () => {
+    try {
+      // While a channel wizard is open, capture text input before slash
+      // dispatch — except for /cancel, which always bails out.
+      if (channelWizard.isAwaiting(envelope.canonicalUserId)) {
+        const raw = (envelope.text || "").trim();
+        if (raw.toLowerCase() === "/cancel") {
+          await channelWizard.cancel(envelope.canonicalUserId);
+          return;
+        }
+        if (envelope.type === "text" || envelope.type === "command") {
+          if (isDuplicate(envelope)) return;
+          await channelWizard.handleText(envelope);
+          return;
+        }
+      }
+
+      // Slash commands route through the registry first so the
+      // /auth handler can run for unauthorized users.
+      if (envelope.type === "command" || (envelope.text && envelope.text.startsWith("/"))) {
+        const result = await dispatch(envelope.text, envelope);
+        if (result.matched) return;
+        // Unknown slash: keep silent rather than spamming.
+        return;
+      }
+
+      if (!isChatAuthorized(envelope.channelId)) return;
+
+      if (envelope.type === "voice") return handleVoice(envelope);
+      if (envelope.type === "audio") return handleAudio(envelope);
+      if (envelope.type === "photo") return handlePhoto(envelope);
+      if (envelope.type === "document") return handleDocument(envelope);
+
+      if (envelope.type === "text") return handleText(envelope);
+    } catch (e) {
+      console.error("router:onMessage:", e.message);
+    }
+  });
+}
+
+async function onAction(envelope) {
+  return scope(envelope, async () => {
+    try {
+      if (await channelWizard.handleAction(envelope)) return;
+      await handleAction(envelope);
+    }
+    catch (e) { console.error("router:onAction:", e.message); }
+  });
+}
+
+async function handleVoice(envelope) {
+  if (isDuplicate(envelope)) return;
+  const state = currentState();
+  if (!state.currentSession) return send("Pick a project first.");
+  try {
+    const media = envelope.media?.[0];
+    if (!media) return;
+    if (media.size && media.size > MAX_VOICE_SIZE) {
+      return send(`Voice note too large (${Math.round(media.size / 1024 / 1024)}MB). Max: ${MAX_VOICE_SIZE / 1024 / 1024}MB`);
+    }
+    envelope.adapter.typing(envelope.channelId).catch(() => {});
+    const oggPath = await envelope.adapter.downloadMedia(media);
+    const transcript = transcribeAudio(oggPath);
+    try { fs.unlinkSync(oggPath); } catch (e) {}
+    if (!transcript) return send("Couldn't transcribe. Try typing it.");
+    await send(`Heard: "${transcript}"`, { replyTo: envelope.messageId });
+    state.lastInputWasVoice = true;
+    await runClaude(transcript, state.currentSession.dir, envelope.messageId);
+  } catch (err) { await send(`Voice failed: ${err.message}`); }
+}
+
+async function handleAudio(envelope) {
+  if (isDuplicate(envelope)) return;
+  const state = currentState();
+  if (!state.currentSession) return send("Pick a project first.");
+  try {
+    const media = envelope.media?.[0];
+    if (!media) return;
+    envelope.adapter.typing(envelope.channelId).catch(() => {});
+    const p = await envelope.adapter.downloadMedia(media);
+    const t = transcribeAudio(p);
+    try { fs.unlinkSync(p); } catch (e) {}
+    if (!t) return send("Couldn't transcribe.");
+    await send(`Heard: "${t}"`, { replyTo: envelope.messageId });
+    await runClaude(t, state.currentSession.dir, envelope.messageId);
+  } catch (err) { await send(`Audio failed: ${err.message}`); }
+}
+
+async function handlePhoto(envelope) {
+  if (isDuplicate(envelope)) return;
+  const state = currentState();
+  if (!state.currentSession) return send("Pick a project first.");
+  try {
+    const media = envelope.media?.[0];
+    if (!media) return;
+    const p = await envelope.adapter.downloadMedia(media);
+    const caption = envelope.caption || "Describe this image. If code/UI/error — explain and fix.";
+    await runClaude(`Image at ${p}\n\nView it, then: ${caption}`, state.currentSession.dir, envelope.messageId);
+  } catch (err) { await send(`Image failed: ${err.message}`); }
+}
+
+async function handleDocument(envelope) {
+  if (isDuplicate(envelope)) return;
+  const state = currentState();
+  if (!state.currentSession) return send("Pick a project first.");
+  try {
+    const media = envelope.media?.[0];
+    if (!media) return;
+    if (media.size && media.size > MAX_FILE_SIZE) {
+      return send(`File too large (${Math.round(media.size / 1024 / 1024)}MB). Max: ${MAX_FILE_SIZE / 1024 / 1024}MB`);
+    }
+    const savePath = await envelope.adapter.downloadMedia(media);
+    const fileName = media.fileName || path.basename(savePath);
+    const mime = media.mimeType || "";
+    const caption = envelope.caption || "";
+    const isImage = mime.startsWith("image/");
+    const prompt = isImage
+      ? `Image file saved at ${savePath}\n\nView it, then: ${caption || "Describe this image. If code/UI/error — explain and fix."}`
+      : `File received: ${fileName} (${mime})\nSaved at: ${savePath}\n\nRead this file and ${caption || "summarize its contents. If it's code, explain what it does. If it's a document, give key points."}`;
+    await send(`File saved: ${fileName}`, { replyTo: envelope.messageId });
+    await runClaude(prompt, state.currentSession.dir, envelope.messageId);
+  } catch (err) { await send(`Failed: ${err.message}`); }
+}
+
+async function handleText(envelope) {
+  if (isDuplicate(envelope)) return;
+  const state = currentState();
+
+  // Pending Codex API-key paste mode.
+  if (state.pendingCodexAuthProcess && state.pendingCodexAuthLabel === "manual OpenAI API key save") {
+    const text = (envelope.text || "").trim();
+    await deleteMessage(envelope.messageId);
+    if (!looksLikeOpenAIKey(text)) {
+      clearPendingCodexAuth(state);
+      await send("That did not look like an OpenAI API key. Not saved.");
+      return;
+    }
+    clearPendingCodexAuth(state);
+    const result = await saveCodexApiKeyWithCli(text);
+    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:");
+    return;
+  }
+
+  if (state.pendingCodexAuthProcess) {
+    await send("Codex login is still running. Complete the device flow in your browser, or send /cancel_codex_auth.");
+    return;
+  }
+
+  if (state.pendingClaudeAuthProcess && state.pendingClaudeAuthLabel === "manual OAuth token save") {
+    const text = (envelope.text || "").trim();
+    if (looksLikeClaudeToken(text)) {
+      await deleteMessage(envelope.messageId);
+      clearPendingClaudeAuth(state);
+      saveClaudeOAuthToken(text);
+      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:");
+      return;
+    }
+    await send("Token paste mode is active, but that does not look like a Claude OAuth token. I left your message visible and will handle it normally. Send /cancel_auth to stop token paste mode.");
+  }
+
+  if (state.pendingClaudeAuthProcess && state.pendingClaudeAuthLabel !== "manual OAuth token save") {
+    const text = (envelope.text || "").trim();
+    if (looksLikeClaudeAuthReply(text)) {
+      await send("That looks like a Claude login code/callback. I did not delete it or send it to Claude as a prompt. Please resend it as `/auth_code YOUR_CODE`, or use /cancel_auth to stop the login flow.");
+      return;
+    }
+    await send("Claude login is still waiting. I will not delete normal messages. If Claude gave you a code, send it as `/auth_code YOUR_CODE`, or use /cancel_auth.");
+  }
+
+  if (!isOnboarded() && state.onboardingStep) {
+    await handleOnboarding({ text: envelope.text });
+    return;
+  }
+
+  if (state.pendingVaultUnlock) {
+    const password = envelope.text;
+    await deleteMessage(envelope.messageId);
+    const ok = vault.unlock(password);
+    if (!ok) {
+      state.pendingVaultUnlock = false;
+      state.pendingVaultAction = null;
+      await send("Wrong password.");
+      return;
+    }
+    const action = state.pendingVaultAction;
+    state.pendingVaultUnlock = false;
+    state.pendingVaultAction = null;
+    if (action.type === "list") {
+      const entries = vault.list();
+      const keys = Object.keys(entries);
+      if (keys.length === 0) await send("Vault unlocked (empty).\n\nUse /vault set <name> <value>");
+      else await send("Vault unlocked:\n\n" + keys.map((k) => `${k}: ${entries[k]}`).join("\n") + "\n\nAuto-locks in 5 min.");
+    } else if (action.type === "set") {
+      vault.set(action.key, action.value);
+      await send(`Saved: ${action.key}`);
+    } else if (action.type === "remove") {
+      vault.remove(action.key);
+      await send(`Removed: ${action.key}`);
+    }
+    return;
+  }
+
+  if (!state.currentSession) {
+    const { projectKeyboard } = require("./projects");
+    return send("Pick a project first:", { keyboard: projectKeyboard() });
+  }
+
+  const text = envelope.text || "";
+  const credPatterns = [
+    /^(sk-ant-|sk-|glpat-|ghp_|gho_|github_pat_|xoxb-|xoxp-|AKIA|AIza)/,
+    /^[A-Za-z0-9_-]{20,}$/,
+    /^(Bearer |token:|key:|secret:|password:)/i,
+  ];
+  if (credPatterns.some((p) => p.test(text.trim()))) {
+    await deleteMessage(envelope.messageId);
+  }
+
+  let prompt = text;
+  const reply = envelope.reply;
+  const replyFromBot = reply?.from?.is_bot;
+  const skipReplyContext = replyFromBot && !reply.document && !reply.photo;
+  if (reply && !skipReplyContext) {
+    let ctx = "";
+    if (reply.text) ctx = reply.text;
+    if (reply.caption) ctx += (ctx ? "\n" : "") + reply.caption;
+    if (reply.document) {
+      const fileName = reply.document.file_name || reply.document.fileName || "unknown";
+      const filePath = path.join(FILES_DIR, fileName);
+      if (fs.existsSync(filePath)) {
+        ctx += (ctx ? "\n" : "") + `[Attached file: ${fileName} at ${filePath}]`;
+      } else if (reply.document.file_id) {
+        // Attempt to fetch via adapter so this works on every channel.
+        try {
+          const localPath = await envelope.adapter.downloadMedia({
+            type: "document",
+            fileId: reply.document.file_id,
+            fileName,
+            mimeType: reply.document.mime_type,
+          });
+          ctx += (ctx ? "\n" : "") + `[Attached file: ${fileName} at ${localPath}]`;
+        } catch (e) {
+          ctx += (ctx ? "\n" : "") + `[Attached file: ${fileName} — could not download]`;
+        }
+      } else {
+        ctx += (ctx ? "\n" : "") + `[Attached file: ${fileName}]`;
+      }
+    }
+    if (reply.photo) ctx += (ctx ? "\n" : "") + "[Attached photo]";
+    if (ctx) prompt = `Replying to message:\n---\n${ctx.length > 1000 ? ctx.slice(0, 1000) + "..." : ctx}\n---\n\n${text}`;
+  }
+
+  await runClaude(prompt, state.currentSession.dir, envelope.messageId);
+}
+
+module.exports = { onMessage, onAction };