arisa 2.3.55 → 3.0.0

package/src/daemon/bridge.ts

@@ -1,166 +0,0 @@
-/**
- * @module daemon/bridge
- * @role HTTP client from Daemon to Core with smart fallback to local AI CLI.
- * @responsibilities
- *   - POST messages to Core via Unix socket
- *   - Respect Core lifecycle state (starting/up/down)
- *   - Wait for Core during startup, fallback only when truly down
- *   - Serialize fallback calls (one CLI process at a time)
- * @dependencies shared/config, shared/types, daemon/fallback, daemon/lifecycle
- * @effects Network (HTTP to Core), may spawn AI CLI process
- */
-
-import { config } from "../shared/config";
-import { createLogger } from "../shared/logger";
-import type { IncomingMessage, CoreResponse } from "../shared/types";
-import { fallbackClaude } from "./fallback";
-import { getCoreState, getCoreError, waitForCoreReady } from "./lifecycle";
-
-const log = createLogger("daemon");
-
-const CORE_URL = "http://localhost";
-const STARTUP_WAIT_MS = 15_000;
-const RETRY_DELAY = 3000;
-
-type StatusCallback = (text: string) => Promise<void>;
-
-// Serialize fallback calls — only one fallback CLI process at a time
-let fallbackQueue: Promise<string> = Promise.resolve("");
-
-export async function sendToCore(
-  message: IncomingMessage,
-  onStatus?: StatusCallback,
-): Promise<CoreResponse> {
-  const state = getCoreState();
-
-  if (state === "starting") {
-    return await handleStarting(message, onStatus);
-  }
-
-  if (state === "up") {
-    return await handleUp(message, onStatus);
-  }
-
-  // state === "down" — go straight to fallback
-  log.warn("Core is down, using fallback");
-  return await runFallback(message, onStatus);
-}
-
-/**
- * Core is starting — wait for it, then send.
- */
-async function handleStarting(
-  message: IncomingMessage,
-  onStatus?: StatusCallback,
-): Promise<CoreResponse> {
-  log.info("Core is starting, waiting for it to be ready...");
-  await onStatus?.("Core starting, please wait...");
-
-  const ready = await waitForCoreReady(STARTUP_WAIT_MS);
-
-  if (ready) {
-    try {
-      return await postToCore(message);
-    } catch {
-      log.warn("Core ready but request failed, retrying...");
-      await sleep(RETRY_DELAY);
-      try {
-        return await postToCore(message);
-      } catch {
-        // Fall through to fallback
-      }
-    }
-  }
-
-  log.warn("Core didn't start in time, using fallback");
-  return await runFallback(message, onStatus);
-}
-
-/**
- * Core is up — normal path with one retry.
- */
-async function handleUp(
-  message: IncomingMessage,
-  onStatus?: StatusCallback,
-): Promise<CoreResponse> {
-  try {
-    return await postToCore(message);
-  } catch {
-    // First failure
-  }
-
-  log.warn("Core unreachable, retrying in 3s...");
-  await onStatus?.("Core not responding, retrying...");
-  await sleep(RETRY_DELAY);
-
-  try {
-    return await postToCore(message);
-  } catch {
-    // Still down
-  }
-
-  log.warn("Core still unreachable after retry, using fallback");
-  return await runFallback(message, onStatus);
-}
-
-/**
- * Fallback: call local CLI directly (Claude -> Codex). Serialized so only one runs at a time.
- */
-async function runFallback(
-  message: IncomingMessage,
-  onStatus?: StatusCallback,
-): Promise<CoreResponse> {
-  const coreError = getCoreError();
-
-  if (coreError) {
-    const preview = coreError.length > 300 ? coreError.slice(-300) : coreError;
-    await onStatus?.(`Core is down. Error:\n<pre>${escapeHtml(preview)}</pre>\nFalling back to direct CLI (Claude/Codex)...`);
-  } else {
-    await onStatus?.("Core is down. Falling back to direct CLI (Claude/Codex)...");
-  }
-
-  const text = message.text || "[non-text message — media not available in fallback mode]";
-
-  // Chain onto the queue so only one fallback CLI runs at a time
-  const result = fallbackQueue.then(() => fallbackClaude(text, coreError ?? undefined));
-  fallbackQueue = result.catch(() => "");
-
-  const response = await result;
-  return { text: response };
-}
-
-async function postToCore(message: IncomingMessage): Promise<CoreResponse> {
-  const response = await fetch(`${CORE_URL}/message`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ message }),
-    signal: AbortSignal.timeout(config.claudeTimeout + 5000),
-    unix: config.coreSocket,
-  } as any);
-
-  if (!response.ok) {
-    throw new Error(`Core returned ${response.status}`);
-  }
-
-  return (await response.json()) as CoreResponse;
-}
-
-function escapeHtml(s: string): string {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-export async function isCoreHealthy(): Promise<boolean> {
-  try {
-    const response = await fetch(`${CORE_URL}/health`, {
-      signal: AbortSignal.timeout(2000),
-      unix: config.coreSocket,
-    } as any);
-    return response.ok;
-  } catch {
-    return false;
-  }
-}

package/src/daemon/channels/base.ts

@@ -1,10 +0,0 @@
-/**
- * @module daemon/channels/base
- * @role Re-export the Channel interface from shared types.
- * @responsibilities
- *   - Provide the Channel contract that all adapters must implement
- * @dependencies shared/types
- * @effects None
- */
-
-export type { Channel, IncomingMessage } from "../../shared/types";

package/src/daemon/channels/telegram.ts

@@ -1,306 +0,0 @@
-/**
- * @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/claude-login.ts

@@ -1,218 +0,0 @@
-/**
- * @module daemon/claude-login
- * @role Trigger Claude setup-token (OAuth) flow from Daemon when auth errors are detected.
- * @responsibilities
- *   - Detect Claude auth-required signals in Core responses
- *   - Run `claude setup-token` with piped I/O
- *   - Parse OAuth URL from output, send to pending Telegram chats
- *   - Accept OAuth code from user message and pipe it to the waiting process stdin
- * @effects Spawns claude CLI process, writes to daemon logs/terminal
- */
-
-import { config } from "../shared/config";
-import { createLogger } from "../shared/logger";
-import { buildBunWrappedAgentCliCommand } from "../shared/ai-cli";
-
-const log = createLogger("daemon");
-
-const AUTH_HINT_PATTERNS = [
-  /not logged in/i,
-  /please run \/login/i,
-  /invalid.*api.?key/i,
-  /authentication.*failed/i,
-  /failed to authenticat/i,
-  /not authenticated/i,
-  /authentication_error/i,
-  /invalid.*bearer.*token/i,
-  /ANTHROPIC_API_KEY/,
-  /api key not found/i,
-  /invalid x-api-key/i,
-];
-
-const RETRY_COOLDOWN_MS = 30_000;
-
-let loginInProgress = false;
-let lastLoginAttemptAt = 0;
-const pendingChatIds = new Set<string>();
-
-// The running setup-token process, so we can pipe the code to stdin
-let pendingProc: ReturnType<typeof Bun.spawn> | null = null;
-let urlSent = false;
-
-type NotifyFn = (chatId: string, text: string) => Promise<void>;
-let notifyFn: NotifyFn | null = null;
-
-export function setClaudeLoginNotify(fn: NotifyFn) {
-  notifyFn = fn;
-}
-
-function needsClaudeLogin(text: string): boolean {
-  return AUTH_HINT_PATTERNS.some((pattern) => pattern.test(text));
-}
-
-export function maybeStartClaudeSetupToken(rawCoreText: string, chatId?: string): void {
-  if (!rawCoreText || !needsClaudeLogin(rawCoreText)) return;
-  if (chatId) pendingChatIds.add(chatId);
-
-  if (loginInProgress) {
-    log.info("Claude setup-token already in progress; skipping duplicate trigger");
-    return;
-  }
-
-  const now = Date.now();
-  if (now - lastLoginAttemptAt < RETRY_COOLDOWN_MS) {
-    log.info("Claude setup-token trigger ignored (cooldown active)");
-    return;
-  }
-
-  lastLoginAttemptAt = now;
-  loginInProgress = true;
-  void runClaudeSetupToken().finally(() => {
-    loginInProgress = false;
-    pendingProc = null;
-  });
-}
-
-/**
- * Start Claude setup-token proactively (e.g. during onboarding).
- */
-export function startClaudeSetupToken(chatId: string): void {
-  pendingChatIds.add(chatId);
-
-  if (loginInProgress) {
-    log.info("Claude setup-token already in progress");
-    return;
-  }
-
-  loginInProgress = true;
-  lastLoginAttemptAt = Date.now();
-  void runClaudeSetupToken().finally(() => {
-    loginInProgress = false;
-    pendingProc = null;
-  });
-}
-
-/**
- * Check if we're waiting for an OAuth code from this chat.
- * If the message looks like a code, pipe it to the waiting setup-token process.
- * Returns true if the message was consumed as a code.
- */
-export function maybeFeedClaudeCode(chatId: string, text: string): boolean {
-  if (!pendingProc || !pendingChatIds.has(chatId)) return false;
-
-  const trimmed = text.trim();
-  // OAuth codes are typically short alphanumeric strings or URL params
-  // Reject obvious non-codes (long messages, commands, etc.)
-  if (trimmed.length > 200 || trimmed.startsWith("/") || trimmed.includes(" ")) return false;
-
-  log.info("Feeding OAuth code to claude setup-token process");
-  try {
-    const writer = pendingProc.stdin as WritableStream<Uint8Array>;
-    const w = writer.getWriter();
-    void w.write(new TextEncoder().encode(trimmed + "\n")).then(() => w.releaseLock());
-  } catch (e) {
-    log.error(`Failed to write to claude setup-token stdin: ${e}`);
-  }
-  return true;
-}
-
-async function notifyPending(text: string): Promise<void> {
-  if (!notifyFn || pendingChatIds.size === 0) return;
-  const chats = Array.from(pendingChatIds);
-  await Promise.all(
-    chats.map(async (chatId) => {
-      try { await notifyFn?.(chatId, text); } catch (e) {
-        log.error(`Failed to notify ${chatId}: ${e}`);
-      }
-    }),
-  );
-}
-
-async function runClaudeSetupToken(): Promise<void> {
-  log.warn("Claude auth required. Starting `claude setup-token`.");
-  urlSent = false;
-
-  let proc: ReturnType<typeof Bun.spawn>;
-  try {
-    proc = Bun.spawn(buildBunWrappedAgentCliCommand("claude", ["setup-token"], { skipPreload: true }), {
-      cwd: config.projectDir,
-      stdin: "pipe",
-      stdout: "pipe",
-      stderr: "pipe",
-      env: { ...process.env, BROWSER: "echo" }, // Prevent browser auto-open on headless servers
-    });
-    pendingProc = proc;
-  } catch (error) {
-    log.error(`Failed to start claude setup-token: ${error}`);
-    return;
-  }
-
-  // Read stdout incrementally to detect URL early and send to Telegram
-  const readAndNotify = async (stream: ReadableStream<Uint8Array> | null, target: NodeJS.WriteStream): Promise<string> => {
-    if (!stream) return "";
-    const chunks: string[] = [];
-    const reader = stream.getReader();
-    const decoder = new TextDecoder();
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        const text = decoder.decode(value, { stream: true });
-        chunks.push(text);
-        target.write(text);
-
-        // Try to parse and send URL as soon as we see it
-        if (!urlSent) {
-          const allText = chunks.join("");
-          const urlMatch = allText.match(/(https:\/\/claude\.ai\/oauth\/authorize\S+)/);
-          if (urlMatch) {
-            urlSent = true;
-            const msg = [
-              "<b>Claude login required</b>\n",
-              `1. Open this link:\n${urlMatch[1]}\n`,
-              "2. Authorize and copy the code",
-              "3. Reply here with the code",
-            ].join("\n");
-            await notifyPending(msg);
-          }
-        }
-      }
-    } finally {
-      reader.releaseLock();
-    }
-    return chunks.join("");
-  };
-
-  await Promise.all([
-    readAndNotify(proc.stdout, process.stdout),
-    readAndNotify(proc.stderr, process.stderr),
-  ]);
-
-  const exitCode = await proc.exited;
-  if (exitCode === 0) {
-    log.info("Claude setup-token completed successfully.");
-    await notifySuccess();
-  } else {
-    log.error(`Claude setup-token finished with exit code ${exitCode}`);
-  }
-}
-
-async function notifySuccess(): Promise<void> {
-  if (!notifyFn || pendingChatIds.size === 0) return;
-
-  const text = "<b>Claude login completed.</b>\nTry again.";
-  const chats = Array.from(pendingChatIds);
-  pendingChatIds.clear();
-
-  await Promise.all(
-    chats.map(async (chatId) => {
-      try { await notifyFn?.(chatId, text); } catch (e) {
-        log.error(`Failed to send Claude login success notice to ${chatId}: ${e}`);
-      }
-    }),
-  );
-}
-
-export function isClaudeLoginPending(): boolean {
-  return loginInProgress;
-}