niahere 0.2.30 → 0.2.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.2.30",
+  "version": "0.2.31",
   "description": "A personal AI assistant daemon — scheduled jobs, chat across Telegram and Slack, persona system, and visual identity.",
   "type": "module",
   "scripts": {

package/src/cli/index.ts

@@ -424,6 +424,38 @@ switch (command) {
     process.exit(result.ok ? 0 : 1);
   }
 
+  case "update": {
+    const { version: currentVersion } = await import("../../package.json");
+    console.log(`Current: v${currentVersion}`);
+    console.log("Updating...");
+    const install = Bun.spawn(["npm", "i", "-g", "niahere@latest"], { stdio: ["ignore", "inherit", "inherit"] });
+    const installExit = await install.exited;
+    if (installExit !== 0) {
+      fail("Update failed.");
+    }
+    // Get new version
+    const check = Bun.spawn(["npm", "view", "niahere", "version"], { stdout: "pipe", stderr: "pipe" });
+    const newVersion = (await new Response(check.stdout).text()).trim();
+    await check.exited;
+    if (newVersion === currentVersion) {
+      console.log("Already on latest.");
+    } else {
+      console.log(`Updated: v${currentVersion} → v${newVersion}`);
+      if (isRunning()) {
+        console.log("Restarting daemon...");
+        const { isServiceInstalled, restartService } = await import("../commands/service");
+        if (isServiceInstalled()) {
+          await restartService();
+        } else {
+          stopDaemon();
+          startDaemon();
+        }
+        console.log("Restarted.");
+      }
+    }
+    break;
+  }
+
   case "init": {
     const { runInit } = await import("../commands/init");
     await runInit();
@@ -432,6 +464,7 @@ switch (command) {
 
   default:
     console.log("Usage: nia <command>\n");
+    console.log("  update              — update to latest version and restart");
     console.log("  init                — setup nia");
     console.log("  start / stop        — daemon + service control");
     console.log("  restart             — restart daemon");

package/src/commands/health.ts

@@ -1,107 +1,6 @@
-import { existsSync, statSync } from "fs";
-import { join } from "path";
-import { isRunning, readPid } from "../core/daemon";
-import { getConfig, readRawConfig } from "../utils/config";
-import { getPaths } from "../utils/paths";
-import { errMsg } from "../utils/errors";
-import { localTime } from "../utils/time";
-
-type Check = { name: string; status: "ok" | "warn" | "fail"; detail: string };
-
-function push(checks: Check[], name: string, status: Check["status"], detail: string): void {
-  checks.push({ name, status, detail });
-}
+import { runHealthChecks } from "../core/health";
 
 export async function healthCommand(): Promise<void> {
-  const checks: Check[] = [];
-  const paths = getPaths();
-
-  // 0. Version
-  const { version } = await import("../../package.json");
-  push(checks, "nia", "ok", "v" + version);
-
-  // 1. Daemon
-  const pid = readPid();
-  if (isRunning()) {
-    push(checks, "daemon", "ok", "running (pid: " + pid + ")");
-  } else if (pid) {
-    push(checks, "daemon", "fail", "stale pid file (pid: " + pid + ", not running)");
-  } else {
-    push(checks, "daemon", "warn", "not running");
-  }
-
-  // 2. Config
-  if (existsSync(paths.config)) {
-    const raw = readRawConfig();
-    push(checks, "config", "ok", Object.keys(raw).length + " keys loaded");
-  } else {
-    push(checks, "config", "fail", "missing (" + paths.config + ")");
-  }
-
-  // 3. Database
-  try {
-    const config = getConfig();
-    if (!config.database_url || !config.database_url.startsWith("postgres")) {
-      push(checks, "database", "fail", 'invalid url: "' + (config.database_url || "(empty)") + '"');
-    } else {
-      const { checkDbHealth } = await import("./health-db");
-      const ok = await checkDbHealth(config.database_url);
-      push(checks, "database", ok ? "ok" : "fail", config.database_url.replace(/\/\/.*@/, "//***@"));
-    }
-  } catch (err) {
-    push(checks, "database", "fail", errMsg(err));
-  }
-
-  // 4. Channels
-  const config = getConfig();
-  if (!config.channels.enabled) {
-    push(checks, "channels", "warn", "disabled");
-  } else {
-    const chans: string[] = [];
-    if (config.channels.telegram.bot_token) chans.push("telegram");
-    if (config.channels.slack.bot_token && config.channels.slack.app_token) chans.push("slack");
-    if (chans.length > 0) {
-      push(checks, "channels", "ok", "configured: " + chans.join(", "));
-    } else {
-      push(checks, "channels", "warn", "enabled but no tokens configured");
-    }
-  }
-
-  // 5. API keys
-  const geminiKey = config.gemini_api_key;
-  const rawConfig = readRawConfig();
-  const openaiKey = typeof rawConfig.openai_api_key === "string" ? rawConfig.openai_api_key : null;
-  const apiKeys: string[] = [];
-  if (geminiKey) apiKeys.push("gemini");
-  if (openaiKey) apiKeys.push("openai");
-  push(checks, "api keys", apiKeys.length > 0 ? "ok" : "warn",
-    apiKeys.length > 0 ? apiKeys.join(", ") : "none configured");
-
-  // 6. Persona files
-  const personaFiles = ["identity.md", "owner.md", "soul.md"];
-  const missing = personaFiles.filter((f) => !existsSync(join(paths.selfDir, f)));
-  if (missing.length === 0) {
-    push(checks, "persona", "ok", "all files present");
-  } else {
-    push(checks, "persona", "warn", "missing: " + missing.join(", "));
-  }
-
-  // 7. Daemon log
-  if (existsSync(paths.daemonLog)) {
-    const stat = statSync(paths.daemonLog);
-    const sizeMb = (stat.size / 1024 / 1024).toFixed(1);
-    const lastMod = localTime(stat.mtime);
-    push(checks, "logs", stat.size > 100 * 1024 * 1024 ? "warn" : "ok",
-      sizeMb + " MB, last write: " + lastMod);
-  } else {
-    push(checks, "logs", "warn", "no log file");
-  }
-
-  // 8. Bun version
-  const bunVersion = typeof Bun !== "undefined" ? Bun.version : "unknown";
-  push(checks, "bun", "ok", "v" + bunVersion);
-
-  // Output
   const { GREEN, YELLOW, RED, RESET, ICON_PASS, ICON_FAIL, ICON_WARN } = await import("../utils/cli");
   const icons: Record<string, string> = {
     ok: GREEN + ICON_PASS + RESET,
@@ -109,6 +8,8 @@ export async function healthCommand(): Promise<void> {
     fail: RED + ICON_FAIL + RESET,
   };
 
+  const checks = await runHealthChecks();
+
   console.log();
   for (const c of checks) {
     console.log("  " + icons[c.status] + " " + c.name.padEnd(12) + " " + c.detail);

package/src/core/alive.ts

@@ -1,24 +1,15 @@
 import { log } from "../utils/log";
 import { getConfig } from "../utils/config";
 import { getSql, closeDb } from "../db/connection";
+import { getFailures, type Check } from "./health";
 
 const HEARTBEAT_INTERVAL = 60_000; // 60s
 
 let timer: ReturnType<typeof setInterval> | null = null;
-let consecutiveFailures = 0;
+let lastFailures: string[] = [];
 let recoveryAttempted = false;
 
-async function checkDb(): Promise<boolean> {
-  try {
-    const sql = getSql();
-    await sql`SELECT 1`;
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function attemptReconnect(): Promise<boolean> {
+async function attemptDbReconnect(): Promise<boolean> {
   try {
     await closeDb();
     const sql = getSql();
@@ -33,7 +24,6 @@ async function attemptReconnect(): Promise<boolean> {
 async function notifyUser(message: string): Promise<void> {
   const config = getConfig();
 
-  // Try Telegram first
   const tgToken = config.channels.telegram.bot_token;
   const tgChatId = config.channels.telegram.chat_id;
   if (tgToken && tgChatId) {
@@ -48,7 +38,6 @@ async function notifyUser(message: string): Promise<void> {
     }
   }
 
-  // Fall back to Slack
   const slToken = config.channels.slack.bot_token;
   const slRecipient = config.channels.slack.dm_user_id || config.channels.slack.channel_id;
   if (slToken && slRecipient) {
@@ -70,37 +59,39 @@ async function notifyUser(message: string): Promise<void> {
   log.error("alive: could not notify user — no channel available");
 }
 
-/** Run an LLM recovery agent to diagnose and fix the issue. */
-async function runRecoveryAgent(error: string): Promise<{ recovered: boolean; report: string }> {
+/** Run LLM recovery agent for failures it can fix (e.g. DB down). */
+async function runRecoveryAgent(failures: Check[]): Promise<{ recovered: boolean; report: string }> {
   try {
     const { runJobWithClaude } = await import("./runner");
     const { homedir } = await import("os");
 
+    const failureSummary = failures.map((f) => `- ${f.name}: ${f.detail}`).join("\n");
+
     const systemPrompt = [
       "You are a system recovery agent for the Nia daemon.",
-      "The database connection just failed and reconnect didn't work.",
-      "Your job: diagnose the issue, attempt to fix it, and report the outcome.",
+      "Health checks detected failures. Diagnose and fix what you can.",
+      "",
+      "For database issues:",
+      "1. Check: pg_isready, brew services list (macOS), systemctl status postgresql (Linux)",
+      "2. Fix: brew services start postgresql@17 (macOS) or systemctl start postgresql (Linux)",
+      "3. Verify: psql -d niahere -c 'SELECT 1'",
       "",
-      "Steps:",
-      "1. Check if PostgreSQL is running: pg_isready, brew services list (macOS), systemctl status postgresql (Linux)",
-      "2. If stopped, try to start it: brew services start postgresql@17 (macOS) or systemctl start postgresql (Linux)",
-      "3. Wait a few seconds, then verify connectivity: psql -d niahere -c 'SELECT 1'",
-      "4. If it's a different issue (disk space, permissions, etc), diagnose and report",
+      "For other issues: diagnose, attempt fix if safe, report findings.",
       "",
       "Respond with a brief postmortem:",
       "- What was wrong",
-      "- What you did to fix it",
-      "- Whether it's recovered or still failing",
-      "- Any recommendations",
+      "- What you did",
+      "- Current status",
     ].join("\n");
 
-    const jobPrompt = `Database is unreachable. Reconnect failed.\nError: ${error}\n\nDiagnose and fix.`;
+    const jobPrompt = `Health check failures:\n${failureSummary}\n\nDiagnose and fix.`;
 
     const result = await runJobWithClaude(systemPrompt, jobPrompt, homedir());
-    const recovered = await checkDb();
 
+    // Re-check after recovery attempt
+    const remaining = await getFailures();
     return {
-      recovered,
+      recovered: remaining.length === 0,
       report: result.agentText || "Recovery agent returned no output.",
     };
   } catch (err) {
@@ -112,58 +103,60 @@ async function runRecoveryAgent(error: string): Promise<{ recovered: boolean; re
 }
 
 async function heartbeat(): Promise<void> {
-  const ok = await checkDb();
-
-  if (ok) {
-    if (consecutiveFailures > 0) {
-      log.info({ previousFailures: consecutiveFailures }, "alive: database recovered");
-      await notifyUser(`Database recovered after ~${consecutiveFailures} min of downtime.`);
+  const failures = await getFailures();
+  const failureNames = failures.map((f) => f.name);
+
+  // All clear
+  if (failures.length === 0) {
+    if (lastFailures.length > 0) {
+      log.info({ recovered: lastFailures }, "alive: all checks passing");
+      await notifyUser(`Recovered: ${lastFailures.join(", ")} back to normal.`);
     }
-    consecutiveFailures = 0;
+    lastFailures = [];
     recoveryAttempted = false;
     return;
   }
 
-  consecutiveFailures++;
-  log.warn({ consecutiveFailures }, "alive: database unreachable");
+  // New failures detected
+  const newFailures = failureNames.filter((f) => !lastFailures.includes(f));
+  if (newFailures.length > 0) {
+    log.warn({ failures: failureNames }, "alive: health check failures detected");
+  }
 
-  // Try reconnect
-  const reconnected = await attemptReconnect();
-  if (reconnected) {
-    log.info("alive: reconnected to database");
-    if (consecutiveFailures > 1) {
-      await notifyUser(`Database reconnected after ~${consecutiveFailures} min.`);
+  // Try DB reconnect if database is failing
+  if (failureNames.includes("database")) {
+    const reconnected = await attemptDbReconnect();
+    if (reconnected) {
+      log.info("alive: database reconnected");
+      // Re-check everything
+      const remaining = await getFailures();
+      if (remaining.length === 0) {
+        lastFailures = [];
+        recoveryAttempted = false;
+        return;
+      }
     }
-    consecutiveFailures = 0;
-    recoveryAttempted = false;
-    return;
   }
 
-  // Reconnect failed — run recovery agent immediately (once per outage)
+  // Run recovery agent once per outage
   if (!recoveryAttempted) {
     recoveryAttempted = true;
-    log.info("alive: reconnect failed, running recovery agent");
+    log.info({ failures: failureNames }, "alive: running recovery agent");
 
-    const { recovered, report } = await runRecoveryAgent(
-      "PostgreSQL unreachable, reconnect failed after " + consecutiveFailures + " heartbeat(s)"
-    );
+    const { recovered, report } = await runRecoveryAgent(failures);
 
     if (recovered) {
-      log.info("alive: recovery agent succeeded");
-      await notifyUser(`Database was down. Recovery agent fixed it.\n\n${report}`);
-      consecutiveFailures = 0;
+      log.info({ report }, "alive: recovery agent succeeded");
+      await notifyUser(report);
+      lastFailures = [];
       recoveryAttempted = false;
     } else {
-      log.error("alive: recovery failed, notifying user");
-      await notifyUser(
-        `Database is down and auto-recovery failed.\n\n` +
-        `Recovery report:\n${report}\n\n` +
-        `Run \`nia health\` to check status.`
-      );
+      log.error({ report }, "alive: recovery failed, notifying user");
+      await notifyUser(report);
     }
   }
-  // After recovery attempted: just log failures, don't spam user or agent.
-  // When DB comes back, the ok branch above will notify.
+
+  lastFailures = failureNames;
 }
 
 export function startAlive(): void {

package/src/core/health.ts

@@ -0,0 +1,145 @@
+import { existsSync, statSync } from "fs";
+import { join } from "path";
+import { getConfig, readRawConfig } from "../utils/config";
+import { getPaths } from "../utils/paths";
+import { isRunning, readPid } from "./daemon";
+import { errMsg } from "../utils/errors";
+import { localTime } from "../utils/time";
+
+export type CheckStatus = "ok" | "warn" | "fail";
+export type Check = { name: string; status: CheckStatus; detail: string };
+
+/** Run all health checks. Returns structured results usable by CLI and alive monitor. */
+export async function runHealthChecks(): Promise<Check[]> {
+  const checks: Check[] = [];
+  const paths = getPaths();
+  const config = getConfig();
+
+  // Version
+  const { version } = await import("../../package.json");
+  checks.push({ name: "nia", status: "ok", detail: "v" + version });
+
+  // Daemon
+  const pid = readPid();
+  if (isRunning()) {
+    checks.push({ name: "daemon", status: "ok", detail: "running (pid: " + pid + ")" });
+  } else if (pid) {
+    checks.push({ name: "daemon", status: "fail", detail: "stale pid file (pid: " + pid + ", not running)" });
+  } else {
+    checks.push({ name: "daemon", status: "warn", detail: "not running" });
+  }
+
+  // Config
+  if (existsSync(paths.config)) {
+    const raw = readRawConfig();
+    checks.push({ name: "config", status: "ok", detail: Object.keys(raw).length + " keys loaded" });
+  } else {
+    checks.push({ name: "config", status: "fail", detail: "missing (" + paths.config + ")" });
+  }
+
+  // Database
+  try {
+    if (!config.database_url || !config.database_url.startsWith("postgres")) {
+      checks.push({ name: "database", status: "fail", detail: 'invalid url: "' + (config.database_url || "(empty)") + '"' });
+    } else {
+      const { checkDbHealth } = await import("../commands/health-db");
+      const ok = await checkDbHealth(config.database_url);
+      checks.push({ name: "database", status: ok ? "ok" : "fail", detail: ok ? "connected" : "unreachable" });
+    }
+  } catch (err) {
+    checks.push({ name: "database", status: "fail", detail: errMsg(err) });
+  }
+
+  // Channels — check actual connectivity, not just config
+  if (!config.channels.enabled) {
+    checks.push({ name: "channels", status: "warn", detail: "disabled" });
+  } else {
+    const results: string[] = [];
+
+    // Telegram
+    const tgToken = config.channels.telegram.bot_token;
+    if (tgToken) {
+      try {
+        const resp = await fetch(`https://api.telegram.org/bot${tgToken}/getMe`);
+        const data = await resp.json() as { ok: boolean };
+        results.push(data.ok ? "telegram: connected" : "telegram: auth failed");
+        if (!data.ok) checks.push({ name: "telegram", status: "fail", detail: "auth failed" });
+      } catch {
+        results.push("telegram: unreachable");
+        checks.push({ name: "telegram", status: "fail", detail: "unreachable" });
+      }
+    }
+
+    // Slack
+    const slToken = config.channels.slack.bot_token;
+    if (slToken) {
+      try {
+        const resp = await fetch("https://slack.com/api/auth.test", {
+          method: "POST",
+          headers: { Authorization: `Bearer ${slToken}`, "Content-Type": "application/json" },
+        });
+        const data = await resp.json() as { ok: boolean; error?: string };
+        results.push(data.ok ? "slack: connected" : `slack: ${data.error || "auth failed"}`);
+        if (!data.ok) checks.push({ name: "slack", status: "fail", detail: data.error || "auth failed" });
+      } catch {
+        results.push("slack: unreachable");
+        checks.push({ name: "slack", status: "fail", detail: "unreachable" });
+      }
+    }
+
+    if (results.length === 0) {
+      checks.push({ name: "channels", status: "warn", detail: "enabled but no tokens configured" });
+    } else {
+      const allOk = results.every((r) => r.includes("connected"));
+      checks.push({ name: "channels", status: allOk ? "ok" : "warn", detail: results.join(", ") });
+    }
+  }
+
+  // API keys
+  const geminiKey = config.gemini_api_key;
+  const rawConfig = readRawConfig();
+  const openaiKey = typeof rawConfig.openai_api_key === "string" ? rawConfig.openai_api_key : null;
+  const apiKeys: string[] = [];
+  if (geminiKey) apiKeys.push("gemini");
+  if (openaiKey) apiKeys.push("openai");
+  checks.push({
+    name: "api keys",
+    status: apiKeys.length > 0 ? "ok" : "warn",
+    detail: apiKeys.length > 0 ? apiKeys.join(", ") : "none configured",
+  });
+
+  // Persona files
+  const personaFiles = ["identity.md", "owner.md", "soul.md"];
+  const missing = personaFiles.filter((f) => !existsSync(join(paths.selfDir, f)));
+  checks.push({
+    name: "persona",
+    status: missing.length === 0 ? "ok" : "warn",
+    detail: missing.length === 0 ? "all files present" : "missing: " + missing.join(", "),
+  });
+
+  // Daemon log
+  if (existsSync(paths.daemonLog)) {
+    const stat = statSync(paths.daemonLog);
+    const sizeMb = (stat.size / 1024 / 1024).toFixed(1);
+    const lastMod = localTime(stat.mtime);
+    checks.push({
+      name: "logs",
+      status: stat.size > 100 * 1024 * 1024 ? "warn" : "ok",
+      detail: sizeMb + " MB, last write: " + lastMod,
+    });
+  } else {
+    checks.push({ name: "logs", status: "warn", detail: "no log file" });
+  }
+
+  // Bun version
+  const bunVersion = typeof Bun !== "undefined" ? Bun.version : "unknown";
+  checks.push({ name: "bun", status: "ok", detail: "v" + bunVersion });
+
+  return checks;
+}
+
+/** Quick check — returns just the failures. Used by alive monitor. */
+export async function getFailures(): Promise<Check[]> {
+  const checks = await runHealthChecks();
+  return checks.filter((c) => c.status === "fail");
+}