arisa 2.3.16 → 2.3.18

package/src/daemon/codex-login.ts

@@ -0,0 +1,172 @@
+/**
+ * @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"]), {
+      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

@@ -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,262 @@
+/**
+ * @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
+ */
+
+// 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
+const { config } = await import("../shared/config");
+
+// Initialize encrypted secrets
+await config.secrets.initialize();
+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");
+const { startCore, stopCore, setLifecycleNotify } = await import("./lifecycle");
+const { setAutoFixNotify } = await import("./autofix");
+const { maybeStartCodexDeviceAuth, setCodexLoginNotify } = await import("./codex-login");
+const { maybeStartClaudeSetupToken, maybeFeedClaudeCode, setClaudeLoginNotify, isClaudeLoginPending } = await import("./claude-login");
+const { autoInstallMissingClis, setAutoInstallNotify, setAuthProbeCallback } = await import("./auto-install");
+const { chunkMessage, markdownToTelegramHtml } = await import("../core/format");
+const { saveMessageRecord } = await import("../shared/db");
+
+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(() => {});
+  }
+};
+
+setLifecycleNotify(sendToAllChats);
+setAutoFixNotify(sendToAllChats);
+setAutoInstallNotify(sendToAllChats);
+setAuthProbeCallback((cli, errorText) => {
+  if (cli === "claude") {
+    // Start Claude setup-token for all known chats
+    for (const chatId of knownChatIds) {
+      maybeStartClaudeSetupToken(errorText, chatId);
+    }
+  } else if (cli === "codex") {
+    // Start Codex device-auth for all known chats
+    for (const chatId of knownChatIds) {
+      maybeStartCodexDeviceAuth(errorText, chatId);
+    }
+  }
+});
+setCodexLoginNotify(async (chatId, text) => {
+  await telegram.send(chatId, text);
+});
+setClaudeLoginNotify(async (chatId, text) => {
+  await telegram.send(chatId, text);
+});
+
+telegram.onMessage(async (msg) => {
+  knownChatIds.add(msg.chatId);
+
+  // If Claude login is pending and user sends what looks like an OAuth code, feed it
+  if (isClaudeLoginPending() && msg.text && maybeFeedClaudeCode(msg.chatId, msg.text)) {
+    await telegram.send(msg.chatId, "Code received, authenticating...");
+    return;
+  }
+
+  // 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 || "";
+    maybeStartCodexDeviceAuth(raw, msg.chatId);
+    maybeStartClaudeSetupToken(raw, msg.chatId);
+    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({
+  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) {
+            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 ${config.daemonSocket}`);
+
+// --- Auto-install missing CLIs (non-blocking) ---
+void autoInstallMissingClis();
+
+// --- 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();
+  cleanupSocket(config.daemonSocket);
+  cleanupSocket(config.coreSocket);
+  releaseProcess("daemon");
+  process.exit(0);
+}
+
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+
+log.info("Daemon started");