arisa 2.3.16 → 2.3.17

package/src/core/scheduler.ts

@@ -0,0 +1,193 @@
+/**
+ * @module core/scheduler
+ * @role Manage cron and one-time scheduled tasks using croner.
+ * @responsibilities
+ *   - Persist tasks to tasks.json, restore on startup
+ *   - Execute tasks by processing through Claude, then sending result via Daemon
+ *   - Schedule one-time (setTimeout) and recurring (croner) tasks
+ * @dependencies croner, shared/config, shared/types
+ * @effects Disk I/O (tasks.json), network (POST to Daemon), timers
+ */
+
+import { Cron } from "croner";
+import { config } from "../shared/config";
+import { createLogger } from "../shared/logger";
+import { getTasks, updateTask, deleteTask, addTask as dbAddTask } from "../shared/db";
+import { processWithClaude, flushChatQueue } from "./processor";
+import type { ScheduledTask } from "../shared/types";
+
+const log = createLogger("scheduler");
+
+let tasks: ScheduledTask[] = [];
+const activeJobs = new Map<string, Cron | ReturnType<typeof setTimeout>>();
+const inFlight = new Set<string>(); // task IDs currently executing
+
+async function loadTasks(): Promise<ScheduledTask[]> {
+  try {
+    return await getTasks();
+  } catch (error) {
+    log.error(`Failed to load tasks from db: ${error}`);
+    return [];
+  }
+}
+
+async function saveTask(task: ScheduledTask) {
+  try {
+    await updateTask(task.id, task);
+  } catch (error) {
+    log.error(`Failed to save task ${task.id}: ${error}`);
+  }
+}
+
+async function executeTask(task: ScheduledTask) {
+  // Skip if previous execution is still in-flight (prevents queue buildup)
+  if (inFlight.has(task.id)) {
+    log.info(`Skipping task ${task.id}: previous execution still in-flight`);
+    return;
+  }
+
+  // Check task is still active (may have been cancelled)
+  if (!tasks.includes(task)) return;
+
+  log.info(`Executing task ${task.id}: ${task.message.substring(0, 60)}`);
+  inFlight.add(task.id);
+  try {
+    // Process through Claude to get a real response (source:"task" = low priority)
+    const result = await processWithClaude(task.message, task.chatId, "task");
+
+    // Re-check: task may have been cancelled while Claude was processing
+    if (!tasks.includes(task) || !result) return;
+
+    // Send the processed result to Telegram via Daemon
+    const response = await fetch("http://localhost/send", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        chatId: task.chatId,
+        text: result,
+      }),
+      unix: config.daemonSocket,
+    } as any);
+    if (!response.ok) {
+      log.error(`Daemon returned ${response.status} for task ${task.id}`);
+    }
+  } catch (error) {
+    log.error(`Failed to execute task ${task.id}: ${error}`);
+  } finally {
+    inFlight.delete(task.id);
+  }
+}
+
+function scheduleTask(task: ScheduledTask) {
+  if (task.type === "once") {
+    if (task.status === "done") return;
+    const delay = (task.runAt || 0) - Date.now();
+    if (delay <= 0) {
+      executeTask(task).then(async () => {
+        task.status = "done";
+        task.lastRunAt = Date.now();
+        await saveTask(task);
+      });
+      return;
+    }
+    const timer = setTimeout(() => {
+      executeTask(task).then(async () => {
+        task.status = "done";
+        task.lastRunAt = Date.now();
+        activeJobs.delete(task.id);
+        await saveTask(task);
+      });
+    }, delay);
+    activeJobs.set(task.id, timer);
+    log.info(`Scheduled one-time task ${task.id} in ${Math.round(delay / 1000)}s`);
+  } else if (task.type === "cron" && task.cron) {
+    const job = new Cron(task.cron, async () => {
+      task.lastRunAt = Date.now();
+      await saveTask(task);
+      executeTask(task);
+    });
+    activeJobs.set(task.id, job);
+    log.info(`Scheduled cron task ${task.id}: ${task.cron}`);
+  }
+}
+
+export async function initScheduler() {
+  tasks = await loadTasks();
+  log.info(`Loaded ${tasks.length} tasks`);
+
+  // Clean old completed one-time tasks (> 7 days)
+  const retentionMs = 7 * 24 * 60 * 60 * 1000;
+  const now = Date.now();
+
+  const tasksToDelete: string[] = [];
+  tasks = tasks.filter((t) => {
+    if (t.type === "once" && t.status === "done") {
+      const shouldKeep = now - (t.lastRunAt || t.runAt || now) < retentionMs;
+      if (!shouldKeep) {
+        tasksToDelete.push(t.id);
+      }
+      return shouldKeep;
+    }
+    return true;
+  });
+
+  // Delete old completed tasks from db
+  for (const id of tasksToDelete) {
+    await deleteTask(id);
+  }
+
+  const activeCron = tasks.filter((t) => t.type === "cron");
+  if (activeCron.length > 0) {
+    log.info(`Restoring ${activeCron.length} cron tasks: ${activeCron.map((t) => `"${t.message}" (${t.cron})`).join(", ")} — send /cancel to stop`);
+  }
+
+  for (const task of tasks) {
+    scheduleTask(task);
+  }
+}
+
+export async function addTask(task: ScheduledTask) {
+  // Deduplicate: if a cron with the same message already exists for this chat, skip
+  if (task.type === "cron") {
+    const duplicate = tasks.find(
+      (t) => t.chatId === task.chatId && t.type === "cron" && t.message === task.message,
+    );
+    if (duplicate) {
+      log.info(`Skipping duplicate cron task for chat ${task.chatId}: "${task.message}"`);
+      return;
+    }
+  }
+
+  tasks.push(task);
+  scheduleTask(task);
+  await dbAddTask(task);
+  log.info(`Added task ${task.id} (${task.type})`);
+}
+
+export async function cancelAllChatTasks(chatId: string): Promise<number> {
+  let removed = 0;
+  for (let i = tasks.length - 1; i >= 0; i -= 1) {
+    const task = tasks[i];
+    if (task.chatId !== chatId) continue;
+    // Skip already-completed one-time tasks
+    if (task.type === "once" && task.status === "done") continue;
+
+    const job = activeJobs.get(task.id);
+    if (job && "stop" in job && typeof job.stop === "function") {
+      job.stop();
+    } else if (job) {
+      clearTimeout(job as ReturnType<typeof setTimeout>);
+    }
+    activeJobs.delete(task.id);
+    inFlight.delete(task.id);
+    await deleteTask(task.id);
+    tasks.splice(i, 1);
+    removed += 1;
+  }
+
+  // Flush any queued processWithClaude calls for this chat
+  flushChatQueue(chatId);
+
+  log.info(`Cancelled ${removed} tasks for chat ${chatId}`);
+  return removed;
+}

package/src/daemon/agent-cli.ts

@@ -0,0 +1,129 @@
+/**
+ * @module daemon/agent-cli
+ * @role Run AI CLI commands directly from Daemon with local fallback order.
+ * @responsibilities
+ *   - Detect available CLIs (Claude, Codex)
+ *   - Execute prompt with timeout
+ *   - Fallback from Claude to Codex when needed
+ * @dependencies shared/config
+ * @effects Spawns external CLI processes
+ */
+
+import { config } from "../shared/config";
+import { createLogger } from "../shared/logger";
+import {
+  buildBunWrappedAgentCliCommand,
+  resolveAgentCliPath,
+  type AgentCliName,
+} from "../shared/ai-cli";
+
+const log = createLogger("daemon");
+
+export type AgentCli = AgentCliName;
+
+export interface CliExecutionResult {
+  cli: AgentCli;
+  output: string;
+  stderr: string;
+  exitCode: number;
+  partial: boolean;
+}
+
+export interface CliFallbackOutcome {
+  result: CliExecutionResult | null;
+  attempted: AgentCli[];
+  failures: string[];
+}
+
+export function getAvailableAgentCli(): AgentCli[] {
+  const order: AgentCli[] = [];
+  if (resolveAgentCliPath("claude") !== null) order.push("claude");
+  if (resolveAgentCliPath("codex") !== null) order.push("codex");
+  return order;
+}
+
+export function getAgentCliLabel(cli: AgentCli): string {
+  return cli === "claude" ? "Claude" : "Codex";
+}
+
+function buildCommand(cli: AgentCli, prompt: string): string[] {
+  if (cli === "claude") {
+    return buildBunWrappedAgentCliCommand(
+      "claude",
+      ["--dangerously-skip-permissions", "--model", "sonnet", "-p", prompt],
+    );
+  }
+  return buildBunWrappedAgentCliCommand(
+    "codex",
+    ["exec", "--dangerously-bypass-approvals-and-sandbox", "-C", config.projectDir, prompt],
+  );
+}
+
+async function runSingleCli(
+  cli: AgentCli,
+  prompt: string,
+  timeoutMs: number,
+): Promise<Omit<CliExecutionResult, "partial">> {
+  const cmd = buildCommand(cli, prompt);
+  log.info(`Daemon AI: trying ${getAgentCliLabel(cli)} CLI`);
+
+  const proc = Bun.spawn(cmd, {
+    cwd: config.projectDir,
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { ...process.env },
+  });
+
+  const timeout = setTimeout(() => proc.kill(), timeoutMs);
+  const stdoutPromise = new Response(proc.stdout).text();
+  const stderrPromise = new Response(proc.stderr).text();
+  const exitCode = await proc.exited;
+  clearTimeout(timeout);
+
+  const [output, stderr] = await Promise.all([stdoutPromise, stderrPromise]);
+  return { cli, output, stderr, exitCode };
+}
+
+export async function runWithCliFallback(prompt: string, timeoutMs: number): Promise<CliFallbackOutcome> {
+  const candidates = getAvailableAgentCli();
+  const attempted: AgentCli[] = [];
+  const failures: string[] = [];
+  let partial: CliExecutionResult | null = null;
+
+  for (const cli of candidates) {
+    attempted.push(cli);
+
+    try {
+      const result = await runSingleCli(cli, prompt, timeoutMs);
+      const output = result.output.trim();
+
+      if (result.exitCode === 0 && output) {
+        return {
+          result: { ...result, output, partial: false },
+          attempted,
+          failures,
+        };
+      }
+
+      if (result.exitCode !== 0 && output && partial === null) {
+        partial = { ...result, output, partial: true };
+      }
+
+      const reason = result.exitCode === 0
+        ? "empty output"
+        : `exit=${result.exitCode}: ${summarizeError(result.stderr || result.output)}`;
+      failures.push(`${getAgentCliLabel(cli)} ${reason}`);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      failures.push(`${getAgentCliLabel(cli)} error: ${summarizeError(msg)}`);
+    }
+  }
+
+  return { result: partial, attempted, failures };
+}
+
+function summarizeError(raw: string): string {
+  const clean = raw.replace(/\s+/g, " ").trim();
+  if (!clean) return "no details";
+  return clean.length > 200 ? `${clean.slice(0, 200)}...` : clean;
+}

package/src/daemon/auto-install.ts

@@ -0,0 +1,148 @@
+/**
+ * @module daemon/auto-install
+ * @role Auto-install missing AI CLIs at daemon startup.
+ * @responsibilities
+ *   - Check which CLIs (claude, codex) are missing
+ *   - Attempt `bun add -g <package>` for each missing CLI
+ *   - Log results, notify chats on success
+ * @dependencies shared/ai-cli
+ * @effects Spawns bun install processes, modifies global packages
+ */
+
+import { createLogger } from "../shared/logger";
+import { isAgentCliInstalled, buildBunWrappedAgentCliCommand, type AgentCliName } from "../shared/ai-cli";
+
+const log = createLogger("daemon");
+
+const CLI_PACKAGES: Record<AgentCliName, string> = {
+  claude: "@anthropic-ai/claude-code",
+  codex: "@openai/codex",
+};
+
+const INSTALL_TIMEOUT = 120_000; // 2min
+
+type NotifyFn = (text: string) => Promise<void>;
+let notifyFn: NotifyFn | null = null;
+
+export function setAutoInstallNotify(fn: NotifyFn) {
+  notifyFn = fn;
+}
+
+async function installCli(cli: AgentCliName): Promise<boolean> {
+  const pkg = CLI_PACKAGES[cli];
+  log.info(`Auto-install: installing ${cli} (${pkg})...`);
+
+  try {
+    const proc = Bun.spawn(["bun", "add", "-g", pkg], {
+      stdout: "pipe",
+      stderr: "pipe",
+      env: { ...process.env },
+    });
+
+    const timeout = setTimeout(() => proc.kill(), INSTALL_TIMEOUT);
+    const exitCode = await proc.exited;
+    clearTimeout(timeout);
+
+    if (exitCode === 0) {
+      log.info(`Auto-install: ${cli} installed successfully`);
+      return true;
+    } else {
+      const stderr = await new Response(proc.stderr).text();
+      log.error(`Auto-install: ${cli} install failed (exit ${exitCode}): ${stderr.slice(0, 300)}`);
+      return false;
+    }
+  } catch (error) {
+    log.error(`Auto-install: ${cli} install error: ${error}`);
+    return false;
+  }
+}
+
+export async function autoInstallMissingClis(): Promise<void> {
+  const missing: AgentCliName[] = [];
+
+  for (const cli of Object.keys(CLI_PACKAGES) as AgentCliName[]) {
+    if (!isAgentCliInstalled(cli)) {
+      missing.push(cli);
+    }
+  }
+
+  if (missing.length === 0) {
+    log.info("Auto-install: all CLIs already installed");
+    return;
+  }
+
+  log.info(`Auto-install: missing CLIs: ${missing.join(", ")}`);
+
+  const installed: string[] = [];
+  for (const cli of missing) {
+    const ok = await installCli(cli);
+    if (ok) installed.push(cli);
+  }
+
+  if (installed.length > 0) {
+    const msg = `Auto-installed: <b>${installed.join(", ")}</b>`;
+    log.info(msg);
+    await notifyFn?.(msg).catch((e) => log.error(`Auto-install notify failed: ${e}`));
+  }
+
+  // After install, probe auth for all installed CLIs
+  await probeCliAuth();
+}
+
+type AuthProbeFn = (cli: AgentCliName, errorText: string) => void;
+let authProbeFn: AuthProbeFn | null = null;
+
+export function setAuthProbeCallback(fn: AuthProbeFn) {
+  authProbeFn = fn;
+}
+
+const PROBE_TIMEOUT = 15_000;
+
+/**
+ * Run a minimal command with each installed CLI to detect auth errors early.
+ * Uses a real API call (cheap haiku / short exec) so auth errors surface.
+ * When an auth error is found, the callback triggers the appropriate login flow.
+ */
+export async function probeCliAuth(): Promise<void> {
+  for (const cli of ["claude", "codex"] as AgentCliName[]) {
+    if (!isAgentCliInstalled(cli)) continue;
+
+    log.info(`Auth probe: testing ${cli}...`);
+    if (cli === "claude") {
+      const hasToken = !!process.env.CLAUDE_CODE_OAUTH_TOKEN;
+      const tokenPreview = hasToken ? `${process.env.CLAUDE_CODE_OAUTH_TOKEN!.slice(0, 15)}...` : "NOT SET";
+      log.info(`Auth probe: CLAUDE_CODE_OAUTH_TOKEN=${tokenPreview}`);
+    }
+    try {
+      const args = cli === "claude"
+        ? ["-p", "say ok", "--model", "haiku", "--output-format", "text", "--dangerously-skip-permissions"]
+        : ["exec", "--dangerously-bypass-approvals-and-sandbox", "echo ok"];
+
+      const cmd = buildBunWrappedAgentCliCommand(cli, args);
+      log.info(`Auth probe cmd: ${cmd.map(c => c.length > 80 ? c.slice(0, 80) + "..." : c).join(" ")}`);
+
+      const proc = Bun.spawn(cmd, {
+        stdout: "pipe",
+        stderr: "pipe",
+        env: { ...process.env },
+      });
+
+      const timeout = setTimeout(() => proc.kill(), PROBE_TIMEOUT);
+      const exitCode = await proc.exited;
+      clearTimeout(timeout);
+
+      const stdout = await new Response(proc.stdout).text();
+      const stderr = await new Response(proc.stderr).text();
+
+      if (exitCode === 0) {
+        log.info(`Auth probe: ${cli} authenticated OK`);
+      } else {
+        const combined = stdout + "\n" + stderr;
+        log.warn(`Auth probe: ${cli} failed (exit ${exitCode}): ${combined.slice(0, 200)}`);
+        authProbeFn?.(cli, combined);
+      }
+    } catch (e) {
+      log.error(`Auth probe: ${cli} error: ${e}`);
+    }
+  }
+}

package/src/daemon/autofix.ts

@@ -0,0 +1,116 @@
+/**
+ * @module daemon/autofix
+ * @role Auto-diagnose and fix Core crashes using available AI CLI.
+ * @responsibilities
+ *   - Spawn Claude/Codex CLI to analyze crash errors and edit code
+ *   - Rate-limit attempts (cooldown + max attempts)
+ *   - Notify via callback (Telegram)
+ * @dependencies shared/config
+ * @effects Spawns AI CLI process which may edit project files
+ */
+
+import { config } from "../shared/config";
+import { createLogger } from "../shared/logger";
+import { getAgentCliLabel, runWithCliFallback } from "./agent-cli";
+
+const log = createLogger("daemon");
+
+let lastAttemptAt = 0;
+let attemptCount = 0;
+
+const COOLDOWN_MS = 120_000; // 2min between batches
+const MAX_ATTEMPTS = 3;
+const AUTOFIX_TIMEOUT = 180_000; // 3min for autofix
+
+type NotifyFn = (text: string) => Promise<void>;
+let notifyFn: NotifyFn | null = null;
+
+export function setAutoFixNotify(fn: NotifyFn) {
+  notifyFn = fn;
+}
+
+/**
+ * Attempt to auto-fix a Core crash. Returns true if any CLI produced a usable result.
+ */
+export async function attemptAutoFix(error: string): Promise<boolean> {
+  const now = Date.now();
+
+  // Reset attempts after cooldown
+  if (now - lastAttemptAt > COOLDOWN_MS) {
+    attemptCount = 0;
+  }
+
+  if (attemptCount >= MAX_ATTEMPTS) {
+    log.warn(`Auto-fix: max attempts (${MAX_ATTEMPTS}) reached, waiting for cooldown`);
+    return false;
+  }
+
+  attemptCount++;
+  lastAttemptAt = now;
+
+  log.info(`Auto-fix: attempt ${attemptCount}/${MAX_ATTEMPTS}`);
+  await notifyFn?.(`Auto-fix: intento ${attemptCount}/${MAX_ATTEMPTS}. Analizando error...`);
+
+  // Extract file paths from the error to help the fallback model focus
+  const projectPathPattern = new RegExp(`${escapeRegExp(config.projectDir)}[^\\s:)]+`, "g");
+  const fileRefs = error.match(projectPathPattern) || [];
+  const uniqueFiles = [...new Set(fileRefs)].slice(0, 5);
+  const fileHint = uniqueFiles.length > 0
+    ? `\nKey files from the stack trace: ${uniqueFiles.join(", ")}`
+    : "";
+
+  const prompt = `Arisa Core error on startup. Fix it.
+
+Error:
+\`\`\`
+${error.slice(-1500)}
+\`\`\`
+${fileHint}
+
+Rules:
+- If it's a corrupted JSON/data file: delete or recreate it
+- If it's a bad import: fix the import
+- If it's a code bug: fix the minimal code
+- Do NOT refactor, improve, or change anything beyond the fix
+- Be fast — read only the files mentioned in the error`;
+
+  try {
+    const outcome = await runWithCliFallback(prompt, AUTOFIX_TIMEOUT);
+    const result = outcome.result;
+
+    if (!result) {
+      if (outcome.attempted.length === 0) {
+        log.error("Auto-fix: no AI CLI available (claude/codex)");
+        await notifyFn?.("Auto-fix: no hay CLI disponible (Claude/Codex).");
+      } else {
+        const detail = outcome.failures.join(" | ").slice(0, 400);
+        log.error(`Auto-fix: all CLIs failed: ${detail}`);
+        await notifyFn?.("Auto-fix: both Claude and Codex failed. Check the logs.");
+      }
+      return false;
+    }
+
+    const cli = getAgentCliLabel(result.cli);
+    const summary = result.output.slice(0, 300);
+    if (result.partial) {
+      log.warn(`Auto-fix: ${cli} produced output but exited with code ${result.exitCode}`);
+    } else {
+      log.info(`Auto-fix: ${cli} completed successfully`);
+    }
+
+    await notifyFn?.(`Auto-fix applied with ${cli}. Core restarting...\n<pre>${escapeHtml(summary)}</pre>`);
+    return true;
+  } catch (err) {
+    log.error(`Auto-fix: error: ${err}`);
+    await notifyFn?.("Auto-fix: internal error. Check the logs.");
+    return false;
+  }
+}
+
+function escapeHtml(s: string): string {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+function escapeRegExp(s: string): string {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}