niahere 0.2.38 → 0.2.40

package/package.json

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

package/src/commands/service.ts

@@ -48,6 +48,8 @@ function buildPlist(): string {
     <key>SuccessfulExit</key>
     <false/>
   </dict>
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
   <key>StandardOutPath</key>
   <string>${paths.daemonLog}</string>
   <key>StandardErrorPath</key>
@@ -86,10 +88,10 @@ async function uninstallLaunchd(): Promise<void> {
   const path = plistPath();
   if (!existsSync(path)) return;
 
+  // Unload to stop the process and disable KeepAlive respawn.
+  // Keep the plist file so RunAtLoad starts the daemon on next login.
   const unload = Bun.spawn(["launchctl", "unload", path], { stdout: "pipe", stderr: "pipe" });
   await unload.exited;
-
-  try { unlinkSync(path); } catch { /* already gone */ }
 }
 
 function isLaunchdInstalled(): boolean {

package/src/core/alive.ts

@@ -4,11 +4,72 @@ import { getSql, closeDb } from "../db/connection";
 import { getFailures, type Check } from "./health";
 
 const HEARTBEAT_INTERVAL = 60_000; // 60s
+const PG_DATA_DIRS = [
+  "/opt/homebrew/var/postgresql@18",
+  "/opt/homebrew/var/postgresql@17",
+  "/opt/homebrew/var/postgres",
+];
 
 let timer: ReturnType<typeof setInterval> | null = null;
 let lastFailures: string[] = [];
 let recoveryAttempted = false;
 
+/** Deterministic Postgres recovery: remove stale PID file + restart service. */
+async function recoverPostgres(): Promise<boolean> {
+  const ready = Bun.spawnSync(["pg_isready"]);
+  if (ready.exitCode === 0) return true; // already up
+
+  log.info("alive: postgres not ready, attempting deterministic recovery");
+
+  // Find and remove stale postmaster.pid
+  const { existsSync, unlinkSync, readFileSync } = await import("fs");
+  for (const dir of PG_DATA_DIRS) {
+    const pidFile = `${dir}/postmaster.pid`;
+    if (!existsSync(pidFile)) continue;
+
+    // Read the PID from line 1 and check if it's actually a postgres process
+    try {
+      const pid = parseInt(readFileSync(pidFile, "utf8").split("\n")[0], 10);
+      if (!isNaN(pid)) {
+        const check = Bun.spawnSync(["ps", "-p", String(pid), "-o", "comm="]);
+        const comm = new TextDecoder().decode(check.stdout).trim();
+        if (check.exitCode !== 0 || !comm.includes("postgres")) {
+          log.info({ pidFile, stalePid: pid, actualProcess: comm || "dead" }, "alive: removing stale postmaster.pid");
+          unlinkSync(pidFile);
+        }
+      }
+    } catch (err) {
+      log.warn({ err, pidFile }, "alive: could not inspect postmaster.pid");
+    }
+  }
+
+  // Restart the service
+  if (process.platform === "darwin") {
+    // Try common brew postgresql service names
+    for (const svc of ["postgresql@18", "postgresql@17", "postgresql"]) {
+      const result = Bun.spawnSync(["brew", "services", "start", svc]);
+      if (result.exitCode === 0) {
+        log.info({ service: svc }, "alive: brew service start issued");
+        break;
+      }
+    }
+  } else {
+    Bun.spawnSync(["systemctl", "start", "postgresql"]);
+  }
+
+  // Wait briefly for postgres to come up
+  await new Promise((r) => setTimeout(r, 3000));
+
+  const check = Bun.spawnSync(["pg_isready"]);
+  if (check.exitCode === 0) {
+    log.info("alive: postgres recovered via deterministic fix");
+    return true;
+  }
+
+  log.warn("alive: deterministic postgres recovery failed");
+  return false;
+}
+
 async function attemptDbReconnect(): Promise<boolean> {
   try {
     await closeDb();
@@ -138,10 +199,28 @@ async function heartbeat(): Promise<void> {
     }
   }
 
-  // Run recovery agent once per outage
+  // Deterministic postgres recovery before LLM agent
+  if (failureNames.includes("database") && !recoveryAttempted) {
+    const pgFixed = await recoverPostgres();
+    if (pgFixed) {
+      const reconnected = await attemptDbReconnect();
+      if (reconnected) {
+        const remaining = await getFailures();
+        if (remaining.length === 0) {
+          log.info("alive: postgres recovered (deterministic fix, no LLM needed)");
+          await notifyUser("Postgres was down (stale PID). Fixed automatically — no LLM agent needed.");
+          lastFailures = [];
+          recoveryAttempted = false;
+          return;
+        }
+      }
+    }
+  }
+
+  // Run LLM recovery agent once per outage (fallback for non-trivial issues)
   if (!recoveryAttempted) {
     recoveryAttempted = true;
-    log.info({ failures: failureNames }, "alive: running recovery agent");
+    log.info({ failures: failureNames }, "alive: running LLM recovery agent");
 
     const { recovered, report } = await runRecoveryAgent(failures);
 

package/src/core/daemon.ts

@@ -121,7 +121,7 @@ function waitForExit(timeoutMs: number): void {
 /** Return PIDs of running daemon processes (excluding ourselves). */
 export function findDaemonPids(): number[] {
   try {
-    const result = Bun.spawnSync(["pgrep", "-f", "niahere/src/cli.* run$"]);
+    const result = Bun.spawnSync(["pgrep", "-f", "src/cli\\.ts run$"]);
     const stdout = new TextDecoder().decode(result.stdout).trim();
     if (!stdout) return [];
     return stdout.split("\n")
@@ -150,16 +150,19 @@ export async function runDaemon(): Promise<void> {
   delete process.env.CLAUDE_CODE_ENTRYPOINT;
   delete process.env.CLAUDE_AGENT_SDK_VERSION;
 
-  // Startup guard: if another daemon is alive, exit immediately
+  // Startup guard: if another nia daemon is alive, exit immediately.
+  // Use pgrep (via findDaemonPids) instead of kill(pid,0) to verify the
+  // PID is actually a nia process — not a recycled OS PID from something else.
   const existingPid = readPid();
   if (existingPid !== null && existingPid !== process.pid) {
-    try {
-      process.kill(existingPid, 0); // Check if alive
+    const aliveDaemons = findDaemonPids();
+    if (aliveDaemons.includes(existingPid)) {
       log.debug({ existingPid, myPid: process.pid }, "another daemon is already running, exiting");
       process.exit(0);
-    } catch {
-      // Dead PID in pidfile — safe to take over
     }
+    // PID in file is stale (dead or recycled by OS) — safe to take over
+    log.warn({ stalePid: existingPid }, "taking over from stale pid");
+    removePid();
   }
 
   // Crash handlers — ensure PID cleanup and logging on unhandled errors.

package/src/core/runner.ts

@@ -247,13 +247,15 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
     };
     appendAudit(auditEntry);
 
-    state[job.name] = {
+    // Re-read state to avoid clobbering concurrent job updates
+    const freshState = { ...readState() };
+    freshState[job.name] = {
       lastRun: timestamp,
       status: result.status,
       duration_ms: result.duration_ms,
       error: result.error,
     };
-    writeState(state);
+    writeState(freshState);
 
     return result;
   } catch (err) {
@@ -278,13 +280,15 @@ export async function runJob(job: JobInput, onActivity?: ActivityCallback): Prom
       error: errorMsg,
     });
 
-    state[job.name] = {
+    // Re-read state to avoid clobbering concurrent job updates
+    const freshState = { ...readState() };
+    freshState[job.name] = {
       lastRun: timestamp,
       status: "error",
       duration_ms,
       error: errorMsg,
     };
-    writeState(state);
+    writeState(freshState);
 
     return result;
   }