arisa 2.3.55 → 3.0.0

package/src/daemon/codex-login.ts

@@ -1,172 +0,0 @@
-/**
- * @module daemon/codex-login
- * @role Trigger Codex device auth flow from Daemon when auth errors are detected.
- * @responsibilities
- *   - Detect codex auth-required signals in Core responses
- *   - Run `codex login --device-auth` (wrapped via Bun) in background from daemon process
- *   - Avoid duplicate runs with in-progress lock + cooldown
- * @effects Spawns codex 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 = [
-  /codex login is required/i,
-  /codex.*login --device-auth/i,
-  /codex is not authenticated on this server/i,
-  /missing bearer authentication in header/i,
-];
-
-const RETRY_COOLDOWN_MS = 30_000;
-
-let loginInProgress = false;
-let lastLoginAttemptAt = 0;
-const pendingChatIds = new Set<string>();
-
-type NotifyFn = (chatId: string, text: string) => Promise<void>;
-let notifyFn: NotifyFn | null = null;
-
-export function setCodexLoginNotify(fn: NotifyFn) {
-  notifyFn = fn;
-}
-
-function needsCodexLogin(text: string): boolean {
-  return AUTH_HINT_PATTERNS.some((pattern) => pattern.test(text));
-}
-
-export function maybeStartCodexDeviceAuth(rawCoreText: string, chatId?: string): void {
-  if (!rawCoreText || !needsCodexLogin(rawCoreText)) return;
-  if (chatId) pendingChatIds.add(chatId);
-
-  if (loginInProgress) {
-    log.info("Codex device auth already in progress; skipping duplicate trigger");
-    return;
-  }
-
-  const now = Date.now();
-  if (now - lastLoginAttemptAt < RETRY_COOLDOWN_MS) {
-    log.info("Codex device auth trigger ignored (cooldown active)");
-    return;
-  }
-
-  lastLoginAttemptAt = now;
-  loginInProgress = true;
-  void runCodexDeviceAuth().finally(() => {
-    loginInProgress = false;
-  });
-}
-
-async function readStreamAndEcho(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); // Echo to console for server admins
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  return chunks.join("");
-}
-
-function parseAuthInfo(output: string): { url: string; code: string } | null {
-  const urlMatch = output.match(/(https:\/\/auth\.openai\.com\/\S+)/);
-  const codeMatch = output.match(/([A-Z0-9]{4}-[A-Z0-9]{5})/);
-  if (urlMatch && codeMatch) return { url: urlMatch[1], code: codeMatch[1] };
-  return null;
-}
-
-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}`);
-      }
-    }),
-  );
-}
-
-let authInfoSent = false;
-
-async function runCodexDeviceAuth(): Promise<void> {
-  log.warn("Codex auth required. Starting `bun --bun <path-to-codex> login --device-auth` now.");
-  authInfoSent = false;
-
-  let proc: ReturnType<typeof Bun.spawn>;
-  try {
-    proc = Bun.spawn(buildBunWrappedAgentCliCommand("codex", ["login", "--device-auth"], { skipPreload: true }), {
-      cwd: config.projectDir,
-      stdin: "inherit",
-      stdout: "pipe",
-      stderr: "pipe",
-      env: { ...process.env },
-    });
-  } catch (error) {
-    log.error(`Failed to start codex login: ${error}`);
-    return;
-  }
-
-  // Read stdout and stderr in parallel, echoing to console
-  const [stdoutText, stderrText] = await Promise.all([
-    readStreamAndEcho(proc.stdout, process.stdout),
-    readStreamAndEcho(proc.stderr, process.stderr),
-  ]);
-
-  // Parse auth info from combined output and send to Telegram
-  const combined = stdoutText + "\n" + stderrText;
-  if (!authInfoSent) {
-    const auth = parseAuthInfo(combined);
-    if (auth) {
-      authInfoSent = true;
-      const msg = [
-        "<b>Codex login required</b>\n",
-        `1. Open: ${auth.url}`,
-        `2. Enter code: <code>${auth.code}</code>`,
-      ].join("\n");
-      await notifyPending(msg);
-    }
-  }
-
-  const exitCode = await proc.exited;
-  if (exitCode === 0) {
-    log.info("Codex device auth finished successfully.");
-    await notifySuccess();
-  } else {
-    log.error(`Codex device auth finished with exit code ${exitCode}`);
-    pendingChatIds.clear();
-  }
-}
-
-async function notifySuccess(): Promise<void> {
-  if (!notifyFn || pendingChatIds.size === 0) return;
-
-  const text = [
-    "<b>Codex login completed successfully.</b>",
-    "Then try again.",
-  ].join("\n");
-
-  const chats = Array.from(pendingChatIds);
-  pendingChatIds.clear();
-
-  await Promise.all(
-    chats.map(async (chatId) => {
-      try {
-        await notifyFn?.(chatId, text);
-      } catch (error) {
-        log.error(`Failed to send Codex login success notice to ${chatId}: ${error}`);
-      }
-    }),
-  );
-}

package/src/daemon/fallback.ts

@@ -1,73 +0,0 @@
-/**
- * @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");
-
-/** Detect CLI output that is an error message, not a real response */
-function looksLikeCliError(output: string): boolean {
-  const lower = output.toLowerCase();
-  const errorPatterns = [
-    "authentication_error",
-    "invalid bearer token",
-    "invalid api key",
-    "api error: 401",
-    "api error: 403",
-    "failed to authenticate",
-    "permission_error",
-    "rate_limit_error",
-    "overloaded_error",
-    "api error: 429",
-    "api error: 529",
-  ];
-  return errorPatterns.some(p => lower.includes(p));
-}
-
-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}`);
-      // Don't forward CLI error messages (auth failures, API errors) to the user
-      if (looksLikeCliError(result.output)) {
-        log.error(`Fallback ${cli} output is a CLI error, not forwarding to user: ${result.output.slice(0, 300)}`);
-        return `[Fallback mode] ${cli} CLI failed (exit ${result.exitCode}). Please check server logs.`;
-      }
-    } 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

@@ -1,272 +0,0 @@
-/**
- * @module daemon/index
- * @role Single-process entry point: Daemon + Core in one bun runtime.
- * @responsibilities
- *   - Run interactive setup if config is missing
- *   - Start the Telegram channel adapter
- *   - Load Core in-process (HTTP server, Claude CLI, scheduler)
- *   - Run HTTP server for Core → Daemon pushes (scheduler)
- *   - Route incoming messages to Core via bridge
- *   - Route Core responses back to channel
- * @dependencies All daemon/* modules, core/*, shared/*
- * @effects Network (Telegram, HTTP servers), spawns Claude CLI
- */
-
-// Log version at startup
-import { readFileSync } from "fs";
-import { join, dirname } from "path";
-const pkgPath = join(dirname(new URL(import.meta.url).pathname), "..", "package.json");
-try { const pkg = JSON.parse(readFileSync(pkgPath, "utf8")); console.log(`Arisa v${pkg.version}`); } catch {}
-
-// 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
-console.log("Loading configuration...");
-const { config } = await import("../shared/config");
-
-// Initialize encrypted secrets
-await config.secrets.initialize();
-console.log("Initializing modules...");
-const { createLogger } = await import("../shared/logger");
-const { serveWithRetry, claimProcess, releaseProcess, cleanupSocket } = await import("../shared/ports");
-const { TelegramChannel } = await import("./channels/telegram");
-const { sendToCore } = await import("./bridge");
-// lifecycle/autofix removed — Core runs in-process, --watch handles restarts
-const { autoInstallMissingClis, setAutoInstallNotify } = await import("./auto-install");
-const { chunkMessage, markdownToTelegramHtml } = await import("../core/format");
-console.log("Connecting to Telegram...");
-// Message records are saved via Core's /record endpoint to avoid dual-writer
-// conflicts (Daemon and Core sharing the same arisa.json through separate
-// in-memory DeepBase instances would cause one to overwrite the other's data).
-async function saveRecordViaCore(record: {
-  id: string;
-  chatId: string;
-  messageId: number;
-  direction: "in" | "out";
-  sender: string;
-  timestamp: number;
-  text: string;
-}) {
-  try {
-    await fetch("http://localhost/record", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(record),
-      unix: config.coreSocket,
-    } as any);
-  } catch (e) {
-    log.error(`Failed to save record via Core: ${e}`);
-  }
-}
-
-const log = createLogger("daemon");
-
-// Log version
-try {
-  const _pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-  log.info(`Arisa v${_pkg.version}`);
-} catch {}
-
-// --- 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(() => {});
-  }
-};
-
-setAutoInstallNotify(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) {
-          saveRecordViaCore({
-            id: `${msg.chatId}_${sentId}`,
-            chatId: msg.chatId,
-            messageId: sentId,
-            direction: "out",
-            sender: "Arisa",
-            timestamp: Date.now(),
-            text: chunk,
-          });
-        }
-      }
-      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({
-  unix: config.daemonSocket,
-  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) {
-            saveRecordViaCore({
-              id: `${body.chatId}_${sentId}`,
-              chatId: body.chatId,
-              messageId: sentId,
-              direction: "out",
-              sender: "Arisa",
-              timestamp: Date.now(),
-              text: chunk,
-            });
-          }
-        }
-
-        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 ${config.daemonSocket}`);
-
-// --- Load Core in-process (single bun process, no child spawn) ---
-log.info("Loading Core...");
-await import("../core/index.ts");
-const { setCoreState } = await import("./lifecycle");
-setCoreState("up");
-log.info("Core loaded");
-
-// --- Auto-install missing CLIs (delayed to avoid peak memory) ---
-setTimeout(() => void autoInstallMissingClis(), 5000);
-
-// --- Connect Telegram (with retry for 409 conflict from stale polling sessions) ---
-(async function connectTelegram(maxRetries = 5) {
-  for (let attempt = 1; attempt <= maxRetries; attempt++) {
-    try {
-      await telegram.connect();
-      return; // connected — polling continues in background
-    } catch (error) {
-      const is409 = String(error).includes("409");
-      if (is409 && attempt < maxRetries) {
-        const wait = attempt * 5;
-        log.warn(`Telegram 409 conflict (attempt ${attempt}/${maxRetries}), retrying in ${wait}s...`);
-        await new Promise((r) => setTimeout(r, wait * 1000));
-        continue;
-      }
-      log.error(`Telegram connection failed: ${error}`);
-      process.exit(1);
-    }
-  }
-})();
-
-// --- Graceful shutdown ---
-function shutdown() {
-  log.info("Shutting down...");
-  cleanupSocket(config.daemonSocket);
-  cleanupSocket(config.coreSocket);
-  releaseProcess("daemon");
-  process.exit(0);
-}
-
-process.on("SIGINT", shutdown);
-process.on("SIGTERM", shutdown);
-
-log.info("Daemon started");