niahere 0.4.4 → 0.4.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niahere",
-  "version": "0.4.4",
+  "version": "0.4.6",
   "description": "A personal AI assistant daemon — chat, scheduled jobs, persona system, extensible via skills.",
   "type": "module",
   "scripts": {

package/src/agent/backends/codex.ts

@@ -6,6 +6,7 @@ import type { Attachment } from "../../types/attachment";
 import type { McpSourceContext } from "../../mcp";
 import { CodexNormalizer } from "./codex-normalize";
 import { mintRun, revokeRun } from "../mcp-endpoint";
+import { isCliProviderDownError } from "../../utils/retry";
 
 /**
  * Resolve the codex binary's absolute path. The daemon runs under launchd with a
@@ -188,7 +189,7 @@ class CodexSession implements AgentSession {
           type: "error",
           message: stderr.trim() || `codex exited ${exit}`,
           retryable: false,
-          providerDown: false,
+          providerDown: isCliProviderDownError(stderr),
         };
       }
     } finally {

package/src/channels/index.ts

@@ -1,5 +1,5 @@
 import type { Channel } from "../types";
-import { registerChannel, getFactories, trackStarted, clearStarted } from "./registry";
+import { registerChannel, getFactories, trackStarted, clearStarted, getStarted } from "./registry";
 import { log } from "../utils/log";
 import { getConfig } from "../utils/config";
 import { createTelegramChannel } from "./telegram";
@@ -25,10 +25,12 @@ export interface StartResult {
   failed: string[];
 }
 
-export async function startChannels(): Promise<StartResult> {
+export async function startChannels(only?: readonly string[]): Promise<StartResult> {
+  const onlySet = only ? new Set(only) : null;
   const pending = getFactories()
     .map((factory) => factory())
-    .filter((ch): ch is Channel => ch !== null);
+    .filter((ch): ch is Channel => ch !== null)
+    .filter((ch) => onlySet === null || onlySet.has(ch.name));
 
   if (pending.length === 0) return { started: [], failed: [] };
 
@@ -60,6 +62,42 @@ export async function startChannels(): Promise<StartResult> {
   return { started, failed };
 }
 
+/**
+ * Bring the running channel set back in line with configuration. Starts any
+ * configured-but-not-running channels and stops any running-but-unconfigured
+ * ones. A no-op when already in sync, so it is safe to call on a timer.
+ *
+ * This is the recovery path for the boot-time race where channels fail to
+ * start because Postgres isn't ready yet (channel `.start()` reads the DB):
+ * `startChannels` abandons the failed channels with no retry, so without
+ * reconciliation Nia stays alive but deaf on every channel until a manual
+ * restart. The alive monitor calls this every healthy heartbeat.
+ */
+export async function reconcileChannels(): Promise<StartResult> {
+  const wanted = getConfiguredChannelNames();
+  const running = getStarted();
+  const runningNames = new Set(running.map((ch) => ch.name));
+  const wantedSet = new Set(wanted);
+
+  const missing = wanted.filter((name) => !runningNames.has(name));
+  const extra = running.filter((ch) => !wantedSet.has(ch.name));
+  if (missing.length === 0 && extra.length === 0) return { started: [], failed: [] };
+
+  log.warn({ missing, extra: extra.map((ch) => ch.name) }, "channels out of sync, reconciling");
+
+  // A channel was removed from config. stopChannels() tears down the whole
+  // registry (it stops the shared Twilio server and clears all tracking), so a
+  // partial stop isn't possible — rebuild the full configured set instead.
+  if (extra.length > 0) {
+    await stopChannels(running);
+    return wanted.length > 0 ? startChannels() : { started: [], failed: [] };
+  }
+
+  // Only additions: start just the missing channels so healthy ones stay
+  // connected and one persistently-failing channel can't thrash the rest.
+  return startChannels(missing);
+}
+
 export function getConfiguredChannelNames(): string[] {
   const { channels } = getConfig();
   if (!channels.enabled) return [];

package/src/core/alive.ts

@@ -1,6 +1,7 @@
 import { log } from "../utils/log";
 import { getConfig } from "../utils/config";
 import { getSql, closeDb } from "../db/connection";
+import { reconcileChannels } from "../channels";
 import { getFailures, type Check } from "./health";
 
 const HEARTBEAT_INTERVAL = 60_000; // 60s
@@ -164,6 +165,23 @@ async function runRecoveryAgent(failures: Check[]): Promise<{ recovered: boolean
   }
 }
 
+/**
+ * Restart any configured channel that isn't currently running. Only acts when
+ * the running set drifts from config (the boot-time postgres race is the common
+ * cause), and notifies the user once when it recovers channels.
+ */
+async function reconcileDeadChannels(): Promise<void> {
+  try {
+    const { started } = await reconcileChannels();
+    if (started.length > 0) {
+      log.warn({ started }, "alive: restarted dead channels");
+      await notifyUser(`Channels were down and have been restarted: ${started.join(", ")}.`);
+    }
+  } catch (err) {
+    log.warn({ err }, "alive: channel reconcile failed");
+  }
+}
+
 async function heartbeat(): Promise<void> {
   const failures = await getFailures();
   const failureNames = failures.map((f) => f.name);
@@ -176,6 +194,10 @@ async function heartbeat(): Promise<void> {
     }
     lastFailures = [];
     recoveryAttempted = false;
+    // The DB is healthy, so any channel that failed to start (e.g. it lost the
+    // boot-time race against Postgres) can be brought back now. No-op when the
+    // running channels already match config.
+    await reconcileDeadChannels();
     return;
   }
 

package/src/core/daemon.ts

@@ -8,8 +8,7 @@ import { isRunning, readPid, removePid, writePid } from "../utils/pid";
 import { ActiveEngine, Job } from "../db/models";
 import { runMigrations } from "../db/migrate";
 import { closeDb, getSql } from "../db/connection";
-import { registerAllChannels, startChannels, stopChannels, getStarted, getConfiguredChannelNames } from "../channels";
-import type { Channel } from "../types";
+import { registerAllChannels, startChannels, stopChannels, getStarted, reconcileChannels } from "../channels";
 import { startScheduler, stopScheduler, recomputeAllNextRuns } from "./scheduler";
 import { startAlive, stopAlive } from "./alive";
 import { createNiaMcpServer } from "../mcp/server";
@@ -282,13 +281,13 @@ export async function runDaemon(): Promise<void> {
   // composition root) so the endpoint module stays free of the handler chain.
   await startMcpEndpoint(NIA_TOOLS);
 
-  // Register and start channels
+  // Register and start channels. The running set is tracked in the channel
+  // registry (getStarted()); the alive monitor reconciles it if any channel
+  // fails to start (e.g. it lost the boot-time race against Postgres).
   registerAllChannels();
-  let channels: Channel[] = [];
   const config = getConfig();
   if (config.channels.enabled) {
-    const result = await startChannels();
-    channels = result.started;
+    await startChannels();
   } else {
     log.info("channels disabled (channels_enabled: false)");
   }
@@ -353,32 +352,7 @@ export async function runDaemon(): Promise<void> {
   process.on("SIGHUP", async () => {
     log.info("received SIGHUP, reloading config");
     resetConfig();
-
-    const running = getStarted();
-    const wantedNames = getConfiguredChannelNames();
-    const runningNames = running.map((channel) => channel.name).sort();
-    const wantChannels = wantedNames.length > 0;
-    const haveChannels = running.length > 0;
-    const needsReconcile =
-      wantChannels &&
-      haveChannels &&
-      (wantedNames.length !== runningNames.length || wantedNames.sort().some((name, i) => name !== runningNames[i]));
-
-    if (wantChannels && !haveChannels) {
-      log.info("SIGHUP: starting channels");
-      const result = await startChannels();
-      channels = result.started;
-    } else if (!wantChannels && haveChannels) {
-      log.info("SIGHUP: stopping channels");
-      await stopChannels(running);
-      channels = [];
-    } else if (needsReconcile) {
-      log.info({ wantedNames, runningNames }, "SIGHUP: reconciling channels");
-      await stopChannels(running);
-      const result = await startChannels();
-      channels = result.started;
-    }
-
+    await reconcileChannels();
     await recomputeAllNextRuns().catch(() => {});
   });
 
@@ -394,7 +368,7 @@ export async function runDaemon(): Promise<void> {
     stopAlive();
     stopScheduler();
     stopMcpEndpoint();
-    await stopChannels(channels);
+    await stopChannels(getStarted());
 
     try {
       if (force) {

package/src/core/scheduler.ts

@@ -3,9 +3,25 @@ import { runJob } from "./runner";
 import { getConfig } from "../utils/config";
 import { log } from "../utils/log";
 import { computeInitialNextRun, computeNextRun } from "../utils/schedule";
+import type { JobResult } from "../types";
 
 export { computeInitialNextRun, computeNextRun };
 
+/**
+ * Log a finished job at a level matching its outcome. `runJob` resolves with
+ * `status: "error"` instead of throwing, so the caller's `.catch` only ever sees
+ * an infrastructure fault — a job that ran and failed must be branched on here
+ * or it is indistinguishable from success in the log.
+ */
+export function logJobOutcome(result: JobResult): void {
+  const fields = { job: result.job, status: result.status, duration: result.duration_ms };
+  if (result.status === "error") {
+    log.error({ ...fields, error: result.error, terminal_reason: result.terminal_reason }, "scheduler: job failed");
+    return;
+  }
+  log.info(fields, "scheduler: job completed");
+}
+
 function isWithinActiveHours(): boolean {
   const config = getConfig();
   const { start, end } = config.activeHours;
@@ -57,11 +73,9 @@ async function tick(): Promise<void> {
     runningJobs.add(job.name);
 
     runJob(job)
-      .then((result) => {
-        log.info({ job: job.name, status: result.status, duration: result.duration_ms }, "scheduler: job completed");
-      })
+      .then(logJobOutcome)
       .catch((err) => {
-        log.error({ err, job: job.name }, "scheduler: job failed");
+        log.error({ err, job: job.name }, "scheduler: job crashed");
       })
       .finally(() => {
         runningJobs.delete(job.name);

package/src/utils/retry.ts

@@ -31,6 +31,34 @@ export function isProviderDownError(error: string | null | undefined): boolean {
   return !trimmed || trimmed.toLowerCase() === "unknown error";
 }
 
+const CLI_PROVIDER_DOWN_PATTERNS = [
+  /authenticat/i,
+  /unauthoriz/i,
+  /\b(401|403)\b/,
+  /not logged in/i,
+  /\blogin\b/i,
+  /\bcredentials?\b/i,
+  /\bapi key\b/i,
+  /(session|token) expired/i,
+  /\b(econnrefused|enotfound|etimedout|econnreset)\b/i,
+  /connection (refused|reset|timed out)/i,
+  /network (error|unreachable)/i,
+  /failed to refresh available models/i,
+];
+
+/**
+ * Provider-down classification for CLI-subprocess backends (codex), whose
+ * failures surface as free-form stderr rather than the Claude SDK's structured
+ * error. Matches the ways a CLI reports "I could not reach or authenticate with
+ * the provider" — as opposed to a task that ran and genuinely failed, which must
+ * stay a real error so the chain does not burn a second backend replaying it.
+ */
+export function isCliProviderDownError(stderr: string | null | undefined): boolean {
+  const trimmed = stderr?.trim();
+  if (!trimmed) return true;
+  return CLI_PROVIDER_DOWN_PATTERNS.some((p) => p.test(trimmed));
+}
+
 /** Sleep for ms milliseconds. */
 export function sleep(ms: number): Promise<void> {
   return new Promise((r) => setTimeout(r, ms));