arisa 2.0.0

package/src/daemon/channels/telegram.ts

@@ -0,0 +1,306 @@
+/**
+ * @module daemon/channels/telegram
+ * @role Telegram channel adapter using grammy.
+ * @responsibilities
+ *   - Connect to Telegram Bot API
+ *   - Receive text, voice, and photo messages
+ *   - Download media from Telegram servers as buffers
+ *   - Send text (HTML) and file messages back
+ *   - Extract commands from text and forward to Core
+ * @dependencies grammy, shared/config
+ * @effects Network (Telegram API), spawns long-polling connection
+ * @contract Implements Channel interface
+ */
+
+import { Bot, GrammyError, HttpError, InputFile } from "grammy";
+import type { Channel, IncomingMessage } from "./base";
+import { config } from "../../shared/config";
+import { createLogger } from "../../shared/logger";
+
+const log = createLogger("telegram");
+
+export class TelegramChannel implements Channel {
+  name = "telegram";
+  private bot: Bot;
+  private handler: ((msg: IncomingMessage) => void) | null = null;
+
+  constructor() {
+    if (!config.telegramBotToken) {
+      throw new Error("TELEGRAM_BOT_TOKEN not configured");
+    }
+    this.bot = new Bot(config.telegramBotToken);
+
+    this.bot.catch((err) => {
+      const e = err.error;
+      if (e instanceof GrammyError) {
+        log.error(`Telegram API error: ${e.description}`);
+      } else if (e instanceof HttpError) {
+        log.error(`Telegram HTTP error: ${e}`);
+      } else {
+        log.error(`Telegram unknown error: ${e}`);
+      }
+    });
+  }
+
+  async connect(): Promise<void> {
+    // All text messages — commands are extracted and forwarded to Core
+    this.bot.on("message:text", async (ctx) => {
+      if (ctx.chat.type !== "private") return;
+      const text = ctx.message.text;
+      if (!text?.trim()) return;
+
+      // Extract command if message starts with /
+      let command: string | undefined;
+      if (text.startsWith("/")) {
+        const match = text.match(/^\/(\w+)/);
+        if (match) command = `/${match[1].toLowerCase()}`;
+      }
+
+      log.info(`${command ? `Cmd ${command}` : "Text"} from ${ctx.from!.first_name}: ${text.substring(0, 60)}`);
+      if (!command) await ctx.api.sendChatAction(ctx.chat.id, "typing");
+
+      // Capture reply_to_message if present
+      let replyTo: IncomingMessage["replyTo"];
+      if (ctx.message.reply_to_message) {
+        const reply = ctx.message.reply_to_message;
+        replyTo = {
+          messageId: reply.message_id,
+          text: "text" in reply ? reply.text : undefined,
+          sender: reply.from ? this.getSenderName({ from: reply.from }) : "Unknown",
+          timestamp: reply.date * 1000,
+        };
+      }
+
+      this.handler?.({
+        chatId: String(ctx.chat.id),
+        sender: this.getSenderName(ctx),
+        senderId: String(ctx.from!.id),
+        text,
+        command,
+        messageId: ctx.message.message_id,
+        timestamp: Date.now(),
+        replyTo,
+      });
+    });
+
+    // Voice messages
+    this.bot.on("message:voice", async (ctx) => {
+      if (ctx.chat.type !== "private") return;
+
+      const voice = ctx.message.voice;
+      log.info(`Voice from ${ctx.from!.first_name} (${voice.duration}s)`);
+      await ctx.api.sendChatAction(ctx.chat.id, "typing");
+
+      // Capture reply_to_message if present
+      let replyTo: IncomingMessage["replyTo"];
+      if (ctx.message.reply_to_message) {
+        const reply = ctx.message.reply_to_message;
+        replyTo = {
+          messageId: reply.message_id,
+          text: "text" in reply ? reply.text : undefined,
+          sender: reply.from ? this.getSenderName({ from: reply.from }) : "Unknown",
+          timestamp: reply.date * 1000,
+        };
+      }
+
+      try {
+        const file = await ctx.api.getFile(voice.file_id);
+        if (!file.file_path) {
+          await ctx.reply("No se pudo descargar el audio.");
+          return;
+        }
+        const buffer = await this.downloadFile(file.file_path);
+        this.handler?.({
+          chatId: String(ctx.chat.id),
+          sender: this.getSenderName(ctx),
+          senderId: String(ctx.from!.id),
+          audio: { base64: buffer.toString("base64"), filename: `voice_${Date.now()}.ogg` },
+          messageId: ctx.message.message_id,
+          timestamp: Date.now(),
+          replyTo,
+        });
+      } catch (error) {
+        log.error(`Voice download error: ${error}`);
+        await ctx.reply("Could not download the audio. Try again.");
+      }
+    });
+
+    // Photo messages
+    this.bot.on("message:photo", async (ctx) => {
+      if (ctx.chat.type !== "private") return;
+
+      const photos = ctx.message.photo;
+      const photo = photos[photos.length - 1];
+      const caption = ctx.message.caption || "";
+
+      log.info(`Photo from ${ctx.from!.first_name} (${photo.width}x${photo.height})`);
+      await ctx.api.sendChatAction(ctx.chat.id, "typing");
+
+      // Capture reply_to_message if present
+      let replyTo: IncomingMessage["replyTo"];
+      if (ctx.message.reply_to_message) {
+        const reply = ctx.message.reply_to_message;
+        replyTo = {
+          messageId: reply.message_id,
+          text: "text" in reply ? reply.text : undefined,
+          sender: reply.from ? this.getSenderName({ from: reply.from }) : "Unknown",
+          timestamp: reply.date * 1000,
+        };
+      }
+
+      try {
+        const file = await ctx.api.getFile(photo.file_id);
+        if (!file.file_path) {
+          await ctx.reply("No se pudo descargar la imagen.");
+          return;
+        }
+        const buffer = await this.downloadFile(file.file_path);
+        this.handler?.({
+          chatId: String(ctx.chat.id),
+          sender: this.getSenderName(ctx),
+          senderId: String(ctx.from!.id),
+          image: { base64: buffer.toString("base64"), caption: caption || undefined },
+          messageId: ctx.message.message_id,
+          timestamp: Date.now(),
+          replyTo,
+        });
+      } catch (error) {
+        log.error(`Photo download error: ${error}`);
+        await ctx.reply("Could not download the image. Try again.");
+      }
+    });
+
+    // Document messages (PDFs, files, etc.)
+    this.bot.on("message:document", async (ctx) => {
+      if (ctx.chat.type !== "private") return;
+
+      const doc = ctx.message.document;
+      const caption = ctx.message.caption || "";
+
+      log.info(`Document from ${ctx.from!.first_name}: ${doc.file_name} (${doc.mime_type})`);
+      await ctx.api.sendChatAction(ctx.chat.id, "typing");
+
+      // Capture reply_to_message if present
+      let replyTo: IncomingMessage["replyTo"];
+      if (ctx.message.reply_to_message) {
+        const reply = ctx.message.reply_to_message;
+        replyTo = {
+          messageId: reply.message_id,
+          text: "text" in reply ? reply.text : undefined,
+          sender: reply.from ? this.getSenderName({ from: reply.from }) : "Unknown",
+          timestamp: reply.date * 1000,
+        };
+      }
+
+      try {
+        const file = await ctx.api.getFile(doc.file_id);
+        if (!file.file_path) {
+          await ctx.reply("Could not download the document.");
+          return;
+        }
+        const buffer = await this.downloadFile(file.file_path);
+        this.handler?.({
+          chatId: String(ctx.chat.id),
+          sender: this.getSenderName(ctx),
+          senderId: String(ctx.from!.id),
+          document: {
+            base64: buffer.toString("base64"),
+            filename: doc.file_name || `file_${Date.now()}`,
+            mimeType: doc.mime_type || "application/octet-stream",
+            caption: caption || undefined,
+          },
+          messageId: ctx.message.message_id,
+          timestamp: Date.now(),
+          replyTo,
+        });
+      } catch (error) {
+        log.error(`Document download error: ${error}`);
+        await ctx.reply("Could not download the document. Try again.");
+      }
+    });
+
+    await this.bot.start({
+      onStart: (botInfo) => {
+        log.info(`Telegram bot connected as @${botInfo.username}`);
+      },
+    });
+  }
+
+  onMessage(handler: (msg: IncomingMessage) => void): void {
+    this.handler = handler;
+  }
+
+  async send(chatId: string, text: string, parseMode: "HTML" | "plain" = "HTML"): Promise<number | undefined> {
+    try {
+      if (parseMode === "HTML") {
+        try {
+          const sent = await this.bot.api.sendMessage(chatId, text, { parse_mode: "HTML" });
+          return sent.message_id;
+        } catch (error) {
+          if (error instanceof GrammyError && error.description?.includes("can't parse entities")) {
+            log.warn("HTML parse failed, falling back to plain text");
+          } else {
+            throw error;
+          }
+        }
+      }
+      // Strip HTML tags and unescape entities for plain text
+      const plain = text
+        .replace(/<[^>]+>/g, "")
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"');
+      const sent = await this.bot.api.sendMessage(chatId, plain);
+      return sent.message_id;
+    } catch (error) {
+      log.error(`Send error to ${chatId}: ${error}`);
+      throw error;
+    }
+  }
+
+  async sendFile(chatId: string, filePath: string): Promise<void> {
+    try {
+      await this.bot.api.sendDocument(chatId, new InputFile(filePath));
+      log.info(`Sent file to ${chatId}: ${filePath}`);
+    } catch (error) {
+      log.error(`File send error: ${error}`);
+      throw error;
+    }
+  }
+
+  async sendAudio(chatId: string, filePath: string): Promise<void> {
+    try {
+      await this.bot.api.sendVoice(chatId, new InputFile(filePath));
+      log.info(`Sent audio to ${chatId}: ${filePath}`);
+    } catch (error) {
+      log.error(`Audio send error: ${error}`);
+      throw error;
+    }
+  }
+
+  async sendTyping(chatId: string): Promise<void> {
+    try {
+      await this.bot.api.sendChatAction(chatId, "typing");
+    } catch {
+      // Non-critical — ignore
+    }
+  }
+
+  private getSenderName(ctx: { from?: { first_name: string; last_name?: string; username?: string; id: number } }): string {
+    if (!ctx.from) return "Unknown";
+    return (
+      ctx.from.first_name + (ctx.from.last_name ? " " + ctx.from.last_name : "") ||
+      ctx.from.username ||
+      String(ctx.from.id)
+    );
+  }
+
+  private async downloadFile(filePath: string): Promise<Buffer> {
+    const url = `https://api.telegram.org/file/bot${config.telegramBotToken}/${filePath}`;
+    const response = await fetch(url);
+    if (!response.ok) throw new Error(`Download failed: ${response.status}`);
+    const arrayBuffer = await response.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+  }
+}

package/src/daemon/fallback.ts

@@ -0,0 +1,49 @@
+/**
+ * @module daemon/fallback
+ * @role Direct AI CLI invocation when Core is down.
+ * @responsibilities
+ *   - Call claude/codex CLI directly as emergency fallback
+ *   - Include Core error context so the model can help diagnose
+ * @dependencies shared/config
+ * @effects Spawns AI CLI process
+ * @contract fallbackClaude(message, coreError?) => Promise<string>
+ */
+
+import { config } from "../shared/config";
+import { createLogger } from "../shared/logger";
+import { getAgentCliLabel, runWithCliFallback } from "./agent-cli";
+
+const log = createLogger("daemon");
+
+export async function fallbackClaude(message: string, coreError?: string): Promise<string> {
+  const systemContext = coreError
+    ? `[System: Core process is down. Error: ${coreError}. You are running in fallback mode from Daemon. The user's project is at ${config.projectDir}. Respond to the user normally. If they ask about the error, explain what you see.]\n\n`
+    : `[System: Core process is down. You are running in fallback mode from Daemon. The user's project is at ${config.projectDir}. Respond to the user normally.]\n\n`;
+
+  const prompt = systemContext + message;
+
+  try {
+    const outcome = await runWithCliFallback(prompt, config.claudeTimeout);
+    const result = outcome.result;
+
+    if (!result) {
+      if (outcome.attempted.length === 0) {
+        return "[Fallback mode] Neither Claude nor Codex CLI is available. Core is down and fallback is unavailable.";
+      }
+      log.error(`Fallback failed: ${outcome.failures.join(" | ").slice(0, 500)}`);
+      return "[Fallback mode] Claude and Codex fallback both failed. Core is down and fallback is unavailable. Please check server logs.";
+    }
+
+    const cli = getAgentCliLabel(result.cli);
+    if (result.partial) {
+      log.warn(`Fallback ${cli} returned output but exited with code ${result.exitCode}`);
+    } else {
+      log.warn(`Using fallback ${cli} CLI`);
+    }
+
+    return result.output || `[Fallback mode] Empty response from ${cli} CLI.`;
+  } catch (error) {
+    log.error(`Fallback CLI error: ${error}`);
+    return "[Fallback mode] Could not reach fallback CLI. Core is down and fallback is unavailable. Please check server logs.";
+  }
+}

package/src/daemon/index.ts

@@ -0,0 +1,213 @@
+/**
+ * @module daemon/index
+ * @role Entry point for the Daemon process.
+ * @responsibilities
+ *   - Run interactive setup if config is missing
+ *   - Start the Telegram channel adapter
+ *   - Spawn Core process with --watch
+ *   - Run HTTP server on :7778 for Core → Daemon pushes (scheduler)
+ *   - Route incoming messages to Core via bridge
+ *   - Route Core responses back to channel
+ * @dependencies All daemon/* modules, shared/*
+ * @effects Network (Telegram, HTTP servers), spawns Core process
+ */
+
+// Setup runs first — no config dependency, writes .env if needed
+import { runSetup } from "./setup";
+const ready = await runSetup();
+if (!ready) process.exit(1);
+
+// Dynamic imports so config loads AFTER setup has written .env
+const { config } = await import("../shared/config");
+
+// Initialize encrypted secrets
+await config.secrets.initialize();
+const { createLogger } = await import("../shared/logger");
+const { serveWithRetry, claimProcess, releaseProcess } = await import("../shared/ports");
+const { TelegramChannel } = await import("./channels/telegram");
+const { sendToCore } = await import("./bridge");
+const { startCore, stopCore, setLifecycleNotify } = await import("./lifecycle");
+const { setAutoFixNotify } = await import("./autofix");
+const { chunkMessage, markdownToTelegramHtml } = await import("../core/format");
+const { saveMessageRecord } = await import("../shared/db");
+
+const log = createLogger("daemon");
+
+// --- Claim process: kill previous daemon, write our PID ---
+claimProcess("daemon");
+
+// --- Track known chatIds in memory (no deepbase dependency) ---
+const knownChatIds = new Set<string>();
+
+// Pre-seed from DB (best-effort — won't crash if DB is corrupt)
+try {
+  const { getAuthorizedUsers } = await import("../shared/db");
+  const chatIds = await getAuthorizedUsers();
+  for (const id of chatIds) knownChatIds.add(id);
+} catch {
+  log.warn("Could not pre-load authorized chatIds (DB may be corrupt)");
+}
+
+// --- Channel setup ---
+const telegram = new TelegramChannel();
+
+// --- Wire up notifications (lifecycle + autofix → Telegram) ---
+const sendToAllChats = async (text: string) => {
+  for (const chatId of knownChatIds) {
+    await telegram.send(chatId, text).catch(() => {});
+  }
+};
+
+setLifecycleNotify(sendToAllChats);
+setAutoFixNotify(sendToAllChats);
+
+telegram.onMessage(async (msg) => {
+  knownChatIds.add(msg.chatId);
+  // Keep typing indicator alive while Core processes (expires every ~5s)
+  const typingInterval = setInterval(() => telegram.sendTyping(msg.chatId), 4000);
+
+  try {
+    const response = await sendToCore(msg, async (statusText) => {
+      try {
+        await telegram.send(msg.chatId, statusText);
+      } catch (e) {
+        log.error(`Failed to send status message: ${e}`);
+      }
+    });
+    clearInterval(typingInterval);
+
+    const raw = response.text || "";
+    const messageParts = raw.split(/\n---CHUNK---\n/g);
+    let sentText = false;
+
+    // Send audio first if present (voice messages should arrive before text)
+    if (response.audio) {
+      try {
+        await telegram.sendAudio(msg.chatId, response.audio);
+      } catch (error) {
+        log.error(`Audio send failed: ${error}`);
+      }
+    }
+
+    // Convert markdown to HTML first, then chunk the HTML
+    // (chunking must happen after HTML conversion so tag-aware splitting works)
+    for (const part of messageParts) {
+      if (!part.trim()) continue;
+      const html = markdownToTelegramHtml(part);
+      const chunks = chunkMessage(html);
+
+      log.info(`Format | rawChars: ${part.length} | htmlChars: ${html.length} | chunks: ${chunks.length}`);
+      log.debug(`Format raw >>>>\n${part}\n<<<<`);
+      log.debug(`Format html >>>>\n${html}\n<<<<`);
+
+      for (const chunk of chunks) {
+        log.debug(`Sending chunk (${chunk.length} chars) >>>>\n${chunk}\n<<<<`);
+        const sentId = await telegram.send(msg.chatId, chunk);
+        if (sentId) {
+          saveMessageRecord({
+            id: `${msg.chatId}_${sentId}`,
+            chatId: msg.chatId,
+            messageId: sentId,
+            direction: "out",
+            sender: "Arisa",
+            timestamp: Date.now(),
+            text: chunk,
+          }).catch((e) => log.error(`Failed to save outgoing message record: ${e}`));
+        }
+      }
+      sentText = true;
+    }
+
+    if (response.files) {
+      for (const filePath of response.files) {
+        await telegram.sendFile(msg.chatId, filePath);
+      }
+    }
+
+    // If neither text nor audio was sent, don't leave the user hanging
+    if (!sentText && !response.audio) {
+      log.warn("Empty response from Core — no text or audio to send");
+    }
+  } catch (error) {
+    clearInterval(typingInterval);
+    const errMsg = error instanceof Error ? error.message : String(error);
+    log.error(`Failed to process message from ${msg.sender}: ${errMsg}`);
+    try {
+      const summary = errMsg.length > 200 ? errMsg.slice(0, 200) + "..." : errMsg;
+      await telegram.send(msg.chatId, `Error: ${summary}`, "plain");
+    } catch {
+      log.error("Failed to send error message back to user");
+    }
+  }
+});
+
+// --- HTTP server for Core → Daemon pushes (scheduler) ---
+const pushServer = await serveWithRetry({
+  port: config.daemonPort,
+  async fetch(req) {
+    const url = new URL(req.url);
+
+    if (url.pathname === "/send" && req.method === "POST") {
+      try {
+        const body = await req.json() as { chatId: string; text: string; files?: string[] };
+        if (!body.chatId || !body.text) {
+          return Response.json({ error: "Missing chatId or text" }, { status: 400 });
+        }
+
+        const html = markdownToTelegramHtml(body.text);
+        const chunks = chunkMessage(html);
+        for (const chunk of chunks) {
+          const sentId = await telegram.send(body.chatId, chunk);
+          if (sentId) {
+            saveMessageRecord({
+              id: `${body.chatId}_${sentId}`,
+              chatId: body.chatId,
+              messageId: sentId,
+              direction: "out",
+              sender: "Arisa",
+              timestamp: Date.now(),
+              text: chunk,
+            }).catch((e) => log.error(`Failed to save outgoing message record: ${e}`));
+          }
+        }
+
+        if (body.files) {
+          for (const filePath of body.files) {
+            await telegram.sendFile(body.chatId, filePath);
+          }
+        }
+
+        return Response.json({ ok: true });
+      } catch (error) {
+        log.error(`Push send error: ${error}`);
+        return Response.json({ error: "Send failed" }, { status: 500 });
+      }
+    }
+
+    return Response.json({ error: "Not found" }, { status: 404 });
+  },
+});
+
+log.info(`Daemon push server listening on port ${config.daemonPort}`);
+
+// --- Start Core process ---
+startCore();
+
+// --- Connect Telegram ---
+telegram.connect().catch((error) => {
+  log.error(`Telegram connection failed: ${error}`);
+  process.exit(1);
+});
+
+// --- Graceful shutdown ---
+function shutdown() {
+  log.info("Shutting down Daemon...");
+  stopCore();
+  releaseProcess("daemon");
+  process.exit(0);
+}
+
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+
+log.info("Daemon started");