arisa 2.0.0

package/src/daemon/lifecycle.ts

@@ -0,0 +1,288 @@
+/**
+ * @module daemon/lifecycle
+ * @role Spawn and manage the Core process with --watch for hot reload.
+ * @responsibilities
+ *   - Start Core as a child process with `bun --watch`
+ *   - Capture stdout+stderr, detect errors in real-time
+ *   - When errors detected: notify via Telegram, trigger autofix
+ *   - Track Core state: starting → up → down
+ *   - Health-check loop to detect when Core is ready
+ * @dependencies shared/config, daemon/autofix
+ * @effects Spawns child process, manages process lifecycle
+ */
+
+import { config } from "../shared/config";
+import { createLogger } from "../shared/logger";
+import { attemptAutoFix } from "./autofix";
+import { join } from "path";
+
+const log = createLogger("daemon");
+
+export type CoreState = "starting" | "up" | "down";
+
+let coreProcess: ReturnType<typeof Bun.spawn> | null = null;
+let shouldRun = true;
+let coreState: CoreState = "down";
+let lastError: string | null = null;
+let crashCount = 0;
+let lastCrashAt = 0;
+let healthCheckTimer: ReturnType<typeof setInterval> | null = null;
+let autofixInProgress = false;
+
+const BUF_MAX = 2000;
+const HEALTH_CHECK_INTERVAL = 1000;
+
+// Patterns that indicate real errors in Core STDERR output
+const ERROR_PATTERNS = [
+  /error:/i,
+  /SyntaxError/,
+  /TypeError/,
+  /ReferenceError/,
+  /ENOENT/,
+  /EACCES/,
+  /JSON Parse error/,
+  /Cannot find module/,
+  /Module not found/,
+];
+
+// --- Notification callback (set by index.ts) ---
+type NotifyFn = (text: string) => Promise<void>;
+let notifyFn: NotifyFn | null = null;
+
+export function setLifecycleNotify(fn: NotifyFn) {
+  notifyFn = fn;
+}
+
+// --- State getters ---
+
+export function getCoreState(): CoreState {
+  return coreState;
+}
+
+export function getCoreError(): string | null {
+  return lastError;
+}
+
+export function waitForCoreReady(timeoutMs: number): Promise<boolean> {
+  if (coreState === "up") return Promise.resolve(true);
+  if (coreState === "down") return Promise.resolve(false);
+
+  return new Promise((resolve) => {
+    const start = Date.now();
+    const check = setInterval(() => {
+      if (coreState === "up") {
+        clearInterval(check);
+        resolve(true);
+      } else if (coreState === "down" || Date.now() - start > timeoutMs) {
+        clearInterval(check);
+        resolve(false);
+      }
+    }, 500);
+  });
+}
+
+// --- Health check ---
+
+function startHealthCheck() {
+  stopHealthCheck();
+  healthCheckTimer = setInterval(async () => {
+    if (coreState !== "starting") {
+      stopHealthCheck();
+      return;
+    }
+    try {
+      const res = await fetch(`http://localhost:${config.corePort}/health`, {
+        signal: AbortSignal.timeout(2000),
+      });
+      if (res.ok) {
+        coreState = "up";
+        log.info("Core is ready (health check passed)");
+        stopHealthCheck();
+      }
+    } catch {
+      // Still starting
+    }
+  }, HEALTH_CHECK_INTERVAL);
+}
+
+function stopHealthCheck() {
+  if (healthCheckTimer) {
+    clearInterval(healthCheckTimer);
+    healthCheckTimer = null;
+  }
+}
+
+// --- Core process management ---
+
+export function startCore() {
+  if (!shouldRun) return;
+
+  const coreEntry = join(config.projectDir, "src", "core", "index.ts");
+  log.info(`Starting Core: bun --watch ${coreEntry}`);
+
+  if (crashCount > 3) {
+    coreState = "down";
+  } else {
+    coreState = "starting";
+  }
+
+  // Output buffers
+  const stdoutBuf = { data: "" };
+  const stderrBuf = { data: "" };
+
+  // Error detection state (per spawn — resets each time Core restarts)
+  let errorHandled = false;
+  let errorDebounce: ReturnType<typeof setTimeout> | null = null;
+
+  // Called when an error pattern is detected in the output stream
+  function onErrorDetected() {
+    if (errorHandled || autofixInProgress || !shouldRun) return;
+    errorHandled = true;
+
+    // Wait 3s for full stack trace to accumulate, then act
+    if (errorDebounce) clearTimeout(errorDebounce);
+    errorDebounce = setTimeout(() => {
+      const combined = (stderrBuf.data + "\n" + stdoutBuf.data).trim();
+      lastError = combined.slice(-BUF_MAX);
+      handleError(lastError);
+    }, 3000);
+  }
+
+  coreProcess = Bun.spawn(["bun", "--watch", coreEntry], {
+    cwd: config.projectDir,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { ...process.env },
+    onExit(proc, exitCode, signalCode) {
+      log.warn(`Core exited (code=${exitCode}, signal=${signalCode})`);
+      coreProcess = null;
+      coreState = "down";
+      stopHealthCheck();
+      if (errorDebounce) clearTimeout(errorDebounce);
+
+      // Save last error
+      const combined = (stderrBuf.data + "\n" + stdoutBuf.data).trim();
+      if (combined) lastError = combined.slice(-BUF_MAX);
+
+      const now = Date.now();
+      if (now - lastCrashAt < 10_000) {
+        crashCount++;
+      } else {
+        crashCount = 1;
+      }
+      lastCrashAt = now;
+
+      if (!shouldRun) return;
+
+      // On 2nd+ rapid crash and error not yet handled: autofix
+      if (crashCount >= 2 && !autofixInProgress && !errorHandled) {
+        log.error(`Core crash loop (${crashCount}x). Triggering auto-fix...`);
+        errorHandled = true;
+        handleError(lastError || `Core crashed with exit code ${exitCode}`);
+      } else if (!autofixInProgress) {
+        log.info("Restarting Core in 2s...");
+        setTimeout(() => startCore(), 2000);
+      }
+    },
+  });
+
+  // Capture streams: print to console + accumulate + detect errors
+  if (coreProcess.stdout && typeof coreProcess.stdout !== "number") {
+    pipeAndWatch(coreProcess.stdout, process.stdout, stdoutBuf, onErrorDetected, false);
+  }
+  if (coreProcess.stderr && typeof coreProcess.stderr !== "number") {
+    pipeAndWatch(coreProcess.stderr, process.stderr, stderrBuf, onErrorDetected, true);
+  }
+
+  if (coreState === "starting") {
+    startHealthCheck();
+  }
+
+  log.info(`Core spawned (pid=${coreProcess.pid})`);
+}
+
+/**
+ * Pipe a stream to a target, accumulate into buffer, call onError when error patterns detected.
+ */
+function pipeAndWatch(
+  stream: ReadableStream<Uint8Array>,
+  target: NodeJS.WriteStream,
+  buf: { data: string },
+  onError: () => void,
+  watchErrors: boolean,
+) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+
+  (async () => {
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        const chunk = decoder.decode(value, { stream: true });
+        target.write(chunk);
+        buf.data += chunk;
+        if (buf.data.length > BUF_MAX) {
+          buf.data = buf.data.slice(-BUF_MAX);
+        }
+
+        // Check for fatal/runtime-like patterns only when explicitly watching this stream.
+        if (watchErrors && ERROR_PATTERNS.some((p) => p.test(chunk))) {
+          onError();
+        }
+      }
+    } catch {
+      // stream closed
+    }
+  })();
+}
+
+/**
+ * Central error handler: notify user via Telegram, then try autofix.
+ */
+async function handleError(error: string) {
+  autofixInProgress = true;
+
+  try {
+    // 1. Notify immediately
+    const preview = error.length > 500 ? error.slice(-500) : error;
+    log.warn("Core error detected, notifying and attempting auto-fix...");
+    await notifyFn?.(
+      `Error en Core detectado:\n<pre>${escapeHtml(preview)}</pre>\nIntentando arreglar...`
+    );
+
+    // 2. Run autofix
+    const fixed = await attemptAutoFix(error);
+
+    // 3. Notify result
+    if (fixed) {
+      await notifyFn?.("Auto-fix aplicado. Core se reiniciará automáticamente.");
+    } else {
+      await notifyFn?.("Auto-fix no pudo resolver el error. Revisalo manualmente.");
+    }
+  } catch (err) {
+    log.error(`handleError threw: ${err}`);
+  } finally {
+    autofixInProgress = false;
+    // If Core exited while we were fixing, restart it
+    if (shouldRun && coreProcess === null) {
+      log.info("Restarting Core after auto-fix...");
+      startCore();
+    }
+  }
+}
+
+function escapeHtml(s: string): string {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+export function stopCore() {
+  shouldRun = false;
+  stopHealthCheck();
+  if (coreProcess) {
+    log.info("Stopping Core...");
+    coreProcess.kill();
+    coreProcess = null;
+  }
+  coreState = "down";
+}

package/src/daemon/setup.ts

@@ -0,0 +1,79 @@
+/**
+ * @module daemon/setup
+ * @role Interactive first-run setup. Prompts for missing config via stdin.
+ * @responsibilities
+ *   - Check required config (TELEGRAM_BOT_TOKEN)
+ *   - Check optional config (OPENAI_API_KEY)
+ *   - Prompt user interactively and save to runtime .env
+ * @dependencies shared/paths (avoids importing config to prevent module caching issues)
+ * @effects Reads stdin, writes runtime .env
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+import { dataDir } from "../shared/paths";
+
+const ENV_PATH = join(dataDir, ".env");
+
+function loadExistingEnv(): Record<string, string> {
+  if (!existsSync(ENV_PATH)) return {};
+  const vars: Record<string, string> = {};
+  for (const line of readFileSync(ENV_PATH, "utf8").split("\n")) {
+    const match = line.match(/^([A-Z_][A-Z0-9_]*)=(.+)$/);
+    if (match) vars[match[1]] = match[2].trim();
+  }
+  return vars;
+}
+
+function saveEnv(vars: Record<string, string>) {
+  const dir = dirname(ENV_PATH);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const content = Object.entries(vars)
+    .map(([k, v]) => `${k}=${v}`)
+    .join("\n") + "\n";
+  writeFileSync(ENV_PATH, content);
+}
+
+async function prompt(question: string): Promise<string> {
+  process.stdout.write(question);
+  for await (const line of console) {
+    return line.trim();
+  }
+  return "";
+}
+
+export async function runSetup(): Promise<boolean> {
+  const vars = loadExistingEnv();
+  let changed = false;
+
+  // Required: TELEGRAM_BOT_TOKEN
+  if (!vars.TELEGRAM_BOT_TOKEN && !process.env.TELEGRAM_BOT_TOKEN) {
+    console.log("\n🔧 Arisa Setup\n");
+    console.log("Telegram Bot Token required. Get one from @BotFather on Telegram.");
+    const token = await prompt("TELEGRAM_BOT_TOKEN: ");
+    if (!token) {
+      console.log("No token provided. Cannot start without Telegram Bot Token.");
+      return false;
+    }
+    vars.TELEGRAM_BOT_TOKEN = token;
+    changed = true;
+  }
+
+  // Optional: OPENAI_API_KEY
+  if (!vars.OPENAI_API_KEY && !process.env.OPENAI_API_KEY) {
+    if (!changed) console.log("\n🔧 Arisa Setup\n");
+    console.log("\nOpenAI API Key (optional — enables voice transcription + image analysis).");
+    const key = await prompt("OPENAI_API_KEY (enter to skip): ");
+    if (key) {
+      vars.OPENAI_API_KEY = key;
+      changed = true;
+    }
+  }
+
+  if (changed) {
+    saveEnv(vars);
+    console.log(`\nConfig saved to ${ENV_PATH}\n`);
+  }
+
+  return true;
+}

package/src/shared/config.ts

@@ -0,0 +1,130 @@
+/**
+ * @module shared/config
+ * @role Centralized configuration from encrypted secrets + env vars fallback
+ * @responsibilities
+ *   - Load API keys from encrypted secrets DB (with .env fallback)
+ *   - Define ports, paths, timeouts
+ * @dependencies secrets.ts
+ * @effects Reads encrypted secrets on first access
+ */
+
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { secrets } from "./secrets";
+import { dataDir, legacyDataDir, preferredDataDir, projectDir } from "./paths";
+
+const ENV_PATH_CANDIDATES = Array.from(new Set([
+  join(dataDir, ".env"),
+  join(preferredDataDir, ".env"),
+  join(legacyDataDir, ".env"),
+]));
+
+function loadEnvFile(): Record<string, string> {
+  for (const envPath of ENV_PATH_CANDIDATES) {
+    if (!existsSync(envPath)) continue;
+
+    const content = readFileSync(envPath, "utf8");
+    const vars: Record<string, string> = {};
+    for (const line of content.split("\n")) {
+      const match = line.match(/^([A-Z_][A-Z0-9_]*)=(.+)$/);
+      if (match) {
+        vars[match[1]] = match[2].trim();
+      }
+    }
+    return vars;
+  }
+
+  return {};
+}
+
+const envFile = loadEnvFile();
+
+function env(key: string): string | undefined {
+  return process.env[key] || envFile[key];
+}
+
+/**
+ * Lazy-loaded API keys from encrypted secrets with fallback to .env
+ */
+class SecureConfig {
+  private _telegramBotToken?: string;
+  private _openaiApiKey?: string;
+  private _elevenlabsApiKey?: string;
+  private _initialized = false;
+
+  async initialize(): Promise<void> {
+    if (this._initialized) return;
+
+    // Load all secrets in parallel
+    const [telegram, openai, elevenlabs] = await Promise.all([
+      secrets.telegram(),
+      secrets.openai(),
+      secrets.elevenlabs(),
+    ]);
+
+    this._telegramBotToken = telegram || env("TELEGRAM_BOT_TOKEN") || "";
+    this._openaiApiKey = openai || env("OPENAI_API_KEY") || "";
+    this._elevenlabsApiKey = elevenlabs || env("ELEVENLABS_API_KEY") || "";
+    this._initialized = true;
+  }
+
+  async getTelegramBotToken(): Promise<string> {
+    await this.initialize();
+    return this._telegramBotToken!;
+  }
+
+  async getOpenaiApiKey(): Promise<string> {
+    await this.initialize();
+    return this._openaiApiKey!;
+  }
+
+  async getElevenlabsApiKey(): Promise<string> {
+    await this.initialize();
+    return this._elevenlabsApiKey!;
+  }
+
+  // Synchronous getters for backwards compatibility (will use cached values)
+  get telegramBotToken(): string {
+    return this._telegramBotToken || "";
+  }
+
+  get openaiApiKey(): string {
+    return this._openaiApiKey || "";
+  }
+
+  get elevenlabsApiKey(): string {
+    return this._elevenlabsApiKey || "";
+  }
+}
+
+const secureConfig = new SecureConfig();
+
+export const config = {
+  projectDir,
+  arisaDir: dataDir,
+  // Backward-compatible alias for existing modules.
+  tinyclawDir: dataDir,
+
+  corePort: 51777,
+  daemonPort: 51778,
+
+  // API keys - use async getters for first load
+  get telegramBotToken() { return secureConfig.telegramBotToken; },
+  get openaiApiKey() { return secureConfig.openaiApiKey; },
+  get elevenlabsApiKey() { return secureConfig.elevenlabsApiKey; },
+
+  elevenlabsVoiceId: "BpjGufoPiobT79j2vtj4",
+
+  logsDir: join(dataDir, "logs"),
+  tasksFile: join(dataDir, "scheduler", "tasks.json"),
+  resetFlagPath: join(dataDir, "reset_flag"),
+  voiceTempDir: join(dataDir, "voice_temp"),
+  attachmentsDir: join(dataDir, "attachments"),
+  attachmentMaxAgeDays: 30,
+
+  claudeTimeout: 120_000,
+  maxResponseLength: 4000,
+
+  // Async API key loaders
+  secrets: secureConfig,
+} as const;