niahere 0.2.17 → 0.2.18

package/package.json

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

package/src/channels/index.ts

@@ -12,33 +12,60 @@ export function registerAllChannels(): void {
   registerChannel(() => createSlackChannel());
 }
 
-export async function startChannels(): Promise<Channel[]> {
-  const channels: Channel[] = [];
+export interface StartResult {
+  started: Channel[];
+  failed: string[];
+}
+
+export async function startChannels(): Promise<StartResult> {
+  const pending = getFactories()
+    .map((factory) => factory())
+    .filter((ch): ch is Channel => ch !== null);
 
-  for (const factory of getFactories()) {
-    const channel = factory();
-    if (!channel) continue;
+  if (pending.length === 0) return { started: [], failed: [] };
 
-    try {
+  const results = await Promise.allSettled(
+    pending.map(async (channel) => {
       await channel.start();
-      channels.push(channel);
-      trackStarted(channel);
-      log.info({ channel: channel.name }, "channel started");
-    } catch (err) {
-      log.error({ err, channel: channel.name }, "channel failed to start");
+      return channel;
+    }),
+  );
+
+  const started: Channel[] = [];
+  const failed: string[] = [];
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    if (result.status === "fulfilled") {
+      started.push(result.value);
+      trackStarted(result.value);
+      log.info({ channel: result.value.name }, "channel started");
+    } else {
+      failed.push(pending[i].name);
+      log.error({ err: result.reason, channel: pending[i].name }, "channel failed to start");
     }
   }
 
-  return channels;
+  if (failed.length > 0) {
+    log.warn({ failed }, "some channels failed to start");
+  }
+
+  return { started, failed };
 }
 
 export async function stopChannels(channels: Channel[]): Promise<void> {
-  for (const channel of channels) {
-    try {
+  const results = await Promise.allSettled(
+    channels.map(async (channel) => {
       await channel.stop();
-      log.info({ channel: channel.name }, "channel stopped");
-    } catch (err) {
-      log.error({ err, channel: channel.name }, "channel failed to stop");
+      return channel;
+    }),
+  );
+
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    if (result.status === "fulfilled") {
+      log.info({ channel: result.value.name }, "channel stopped");
+    } else {
+      log.error({ err: result.reason, channel: channels[i].name }, "channel failed to stop");
     }
   }
   clearStarted();

package/src/channels/slack.ts

@@ -94,9 +94,11 @@ class SlackChannel implements Channel {
       // daemon restarts (otherwise getState falls back to the old room).
       await Session.create(`placeholder-${room}`, room);
 
+      log.info({ key, room }, "slack: creating chat engine");
       const engine = await createChatEngine({ room, channel: "slack", resume: false, mcpServers: getMcpServers() });
       const state: ChatState = { engine, roomIndex: newIdx, lock: Promise.resolve() };
       chats.set(key, state);
+      log.info({ key, room, activeSessions: chats.size }, "slack: engine ready");
       return state;
     }
 
@@ -106,6 +108,8 @@ class SlackChannel implements Channel {
         fn().catch((err) => log.error({ err, key }, "unhandled error in locked handler"));
         return;
       }
+      const queued = state.lock !== Promise.resolve();
+      if (queued) log.debug({ key }, "slack: message queued behind active lock");
       state.lock = state.lock.then(fn, fn);
     }
 
@@ -345,10 +349,11 @@ class SlackChannel implements Channel {
 
       const state = await getState(key);
 
-      // Add thinking reaction while processing
-      await client.reactions.add({ channel: msg.channel, timestamp: msg.ts, name: "thinking_face" }).catch(() => {});
-
       withLock(key, async () => {
+        // Add thinking reaction inside the lock so cleanup is guaranteed
+        await client.reactions.add({ channel: msg.channel, timestamp: msg.ts, name: "thinking_face" })
+          .catch((err) => log.debug({ err, channel: msg.channel }, "slack: failed to add thinking reaction"));
+
         try {
           const { result } = await state.engine.send(text, {
             onActivity(status) {
@@ -356,8 +361,6 @@ class SlackChannel implements Channel {
             },
           }, attachments);
 
-          await client.reactions.remove({ channel: msg.channel, timestamp: msg.ts, name: "thinking_face" }).catch(() => {});
-
           const reply = result.trim();
 
           // [NO_REPLY] or empty = agent chose not to respond (thread judgement)
@@ -378,7 +381,6 @@ class SlackChannel implements Channel {
 
           log.info({ channel: msg.channel, key, chars: reply.length }, "slack reply sent");
         } catch (err) {
-          await client.reactions.remove({ channel: msg.channel, timestamp: msg.ts, name: "thinking_face" }).catch(() => {});
 
           const errText = err instanceof Error ? err.message : String(err);
           log.error({ err, channel: msg.channel }, "slack message processing failed");
@@ -392,6 +394,9 @@ class SlackChannel implements Channel {
           } else {
             await say(`[error] ${errText}`);
           }
+        } finally {
+          await client.reactions.remove({ channel: msg.channel, timestamp: msg.ts, name: "thinking_face" })
+            .catch((err) => log.debug({ err, channel: msg.channel }, "slack: failed to remove thinking reaction"));
         }
       });
     });

package/src/channels/telegram.ts

@@ -68,9 +68,11 @@ class TelegramChannel implements Channel {
         const prefix = roomPrefix(chatId);
         const idx = await Session.getLatestRoomIndex(prefix);
         const room = roomName(chatId, idx);
+        log.info({ chatId, room }, "telegram: creating chat engine");
         const engine = await createChatEngine({ room, channel: "telegram", resume: true, mcpServers: getMcpServers() });
         state = { engine, roomIndex: idx, lock: Promise.resolve() };
         chats.set(chatId, state);
+        log.info({ chatId, room, activeSessions: chats.size }, "telegram: engine ready");
       }
       return state;
     }
@@ -100,6 +102,8 @@ class TelegramChannel implements Channel {
         fn().catch((err) => log.error({ err, chatId }, "unhandled error in locked handler"));
         return;
       }
+      const queued = state.lock !== Promise.resolve();
+      if (queued) log.debug({ chatId }, "telegram: message queued behind active lock");
       state.lock = state.lock.then(fn, fn);
     }
 
@@ -134,8 +138,6 @@ class TelegramChannel implements Channel {
       try {
         const { result } = await state.engine.send(text, {}, attachments);
 
-        clearInterval(typingInterval);
-
         const reply = result.trim() || "(no response)";
         try {
           await bot.api.sendMessage(chatId, reply, { parse_mode: "MarkdownV2" });
@@ -145,11 +147,11 @@ class TelegramChannel implements Channel {
 
         log.info({ chatId, chars: result.length }, "telegram reply sent");
       } catch (err) {
-        clearInterval(typingInterval);
-
         const errText = err instanceof Error ? err.message : String(err);
         log.error({ err, chatId }, "telegram message processing failed");
         await bot.api.sendMessage(chatId, `[error] ${errText}`).catch(() => {});
+      } finally {
+        clearInterval(typingInterval);
       }
     }
 

package/src/chat/identity.ts

@@ -4,6 +4,7 @@ import { homedir } from "os";
 import yaml from "js-yaml";
 import { getNiaHome, getPaths } from "../utils/paths";
 import { getEnvironmentPrompt, getModePrompt, getChannelPrompt } from "../prompts";
+import { log } from "../utils/log";
 import type { Mode } from "../types";
 
 // niahere project root (resolved from this file's location)
@@ -51,7 +52,12 @@ function scanSkills(): { name: string; description: string }[] {
       if (!fmMatch) continue;
 
       let meta: Record<string, unknown> = {};
-      try { meta = (yaml.load(fmMatch[1]) as Record<string, unknown>) || {}; } catch { continue; }
+      try {
+        meta = (yaml.load(fmMatch[1]) as Record<string, unknown>) || {};
+      } catch (err) {
+        log.warn({ err, skill: entry.name, path: skillFile }, "failed to parse skill metadata, skipping");
+        continue;
+      }
       const name = (typeof meta.name === "string" ? meta.name : "") || entry.name;
 
       if (seen.has(name)) continue;

package/src/chat/repl.ts

@@ -112,7 +112,7 @@ async function pickSession(): Promise<string | null> {
 
 export type ChatMode = "continue" | "new" | "pick";
 
-export async function startRepl(mode: ChatMode = "continue"): Promise<void> {
+export async function startRepl(mode: ChatMode = "continue", simulateChannel?: string): Promise<void> {
   try {
     await runMigrations();
   } catch (err) {
@@ -142,12 +142,14 @@ export async function startRepl(mode: ChatMode = "continue"): Promise<void> {
     resume = true;
   }
 
-  const engine = await createChatEngine({ room: "terminal", channel: "terminal", resume, mcpServers: getMcpServers() });
+  const channel = simulateChannel || "terminal";
+  const engine = await createChatEngine({ room: "terminal", channel, resume, mcpServers: getMcpServers() });
 
   // Welcome
   const isResumed = engine.sessionId && resume;
   const sessionNote = isResumed ? "resumed" : "new session";
-  console.log(`\n${DIM}nia chat${RESET} ${DIM}(${sessionNote})${RESET}`);
+  const channelNote = simulateChannel ? ` as ${simulateChannel}` : "";
+  console.log(`\n${DIM}nia chat${channelNote}${RESET} ${DIM}(${sessionNote})${RESET}`);
   console.log(`${DIM}type /exit to quit${RESET}\n`);
 
   const rl = readline.createInterface({

package/src/cli/index.ts

@@ -115,6 +115,12 @@ switch (command) {
     break;
   }
 
+  case "health": {
+    const { healthCommand } = await import("../commands/health");
+    await healthCommand();
+    break;
+  }
+
   case "restart": {
     const { isServiceInstalled, restartService } = await import("../commands/service");
     if (isServiceInstalled()) {
@@ -227,10 +233,23 @@ switch (command) {
   case "logs": {
     const { daemonLog } = getPaths();
     if (!existsSync(daemonLog)) fail("No daemon log found. Is nia running?");
-    const follow = process.argv[3] === "-f" || process.argv[3] === "--follow";
-    const args = follow ? ["tail", "-f", daemonLog] : ["tail", "-50", daemonLog];
-    const proc = Bun.spawn(args, { stdio: ["ignore", "inherit", "inherit"] });
-    await proc.exited;
+    const logArgs = process.argv.slice(3);
+    const follow = logArgs.includes("-f") || logArgs.includes("--follow");
+    // --channel <name> filters logs by channel/component via grep
+    const chIdx = logArgs.indexOf("--channel");
+    const channelFilter = chIdx !== -1 && logArgs[chIdx + 1] ? logArgs[chIdx + 1] : null;
+
+    if (channelFilter) {
+      // Pipe through grep to filter by channel name in structured logs
+      const tailArgs = follow ? ["tail", "-f", daemonLog] : ["tail", "-200", daemonLog];
+      const tail = Bun.spawn(tailArgs, { stdio: ["ignore", "pipe", "inherit"] });
+      const grep = Bun.spawn(["grep", "-i", channelFilter], { stdio: [tail.stdout, "inherit", "inherit"] });
+      await grep.exited;
+    } else {
+      const args = follow ? ["tail", "-f", daemonLog] : ["tail", "-50", daemonLog];
+      const proc = Bun.spawn(args, { stdio: ["ignore", "inherit", "inherit"] });
+      await proc.exited;
+    }
     break;
   }
 
@@ -240,13 +259,15 @@ switch (command) {
   }
 
   case "chat": {
-    const arg = process.argv[3];
-    const mode = (arg === "--new" || arg === "-n")
+    const chatArgs = process.argv.slice(3);
+    const mode = (chatArgs.includes("--new") || chatArgs.includes("-n"))
       ? "new" as const
-      : (arg === "--resume" || arg === "-r")
+      : (chatArgs.includes("--resume") || chatArgs.includes("-r"))
         ? "pick" as const
         : "continue" as const;
-    await startRepl(mode);
+    const chIdx = chatArgs.indexOf("--channel");
+    const simChannel = chIdx !== -1 && chatArgs[chIdx + 1] ? chatArgs[chIdx + 1] : undefined;
+    await startRepl(mode, simChannel);
     break;
   }
 
@@ -392,10 +413,11 @@ switch (command) {
     console.log("  start / stop        — daemon + service control");
     console.log("  restart             — restart daemon");
     console.log("  status [--json --rooms N --all]  — show daemon, jobs, channels");
-    console.log("  chat                — interactive chat (auto-continues last session)");
+    console.log("  health              — check daemon, db, channels, config");
+    console.log("  chat [--channel ch] — interactive chat (--channel simulates a channel)");
     console.log("  run <prompt>        — one-shot execution");
     console.log("  history [room]      — recent messages");
-    console.log("  logs [-f]           — daemon logs");
+    console.log("  logs [-f] [--channel ch]  — daemon logs (filter by channel)");
     console.log("  job <sub>           — manage jobs");
     console.log("  db <sub>            — database setup/status/migrate");
     console.log("  skills              — list available skills");

package/src/commands/health-db.ts

@@ -0,0 +1,12 @@
+import postgres from "postgres";
+
+/** Quick DB connectivity check. Returns true if SELECT 1 succeeds. */
+export async function checkDbHealth(url: string): Promise<boolean> {
+  const db = postgres(url, { onnotice: () => {}, connect_timeout: 5 });
+  try {
+    const [row] = await db`SELECT 1 as ok`;
+    return row?.ok === 1;
+  } finally {
+    await db.end();
+  }
+}

package/src/commands/health.ts

@@ -0,0 +1,119 @@
+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 });
+}
+
+export async function healthCommand(): Promise<void> {
+  const checks: Check[] = [];
+  const paths = getPaths();
+
+  // 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 = "\x1b[32m";
+  const YELLOW = "\x1b[33m";
+  const RED = "\x1b[31m";
+  const RST = "\x1b[0m";
+  const icons: Record<string, string> = {
+    ok: GREEN + "\u2713" + RST,
+    warn: YELLOW + "!" + RST,
+    fail: RED + "\u2717" + RST,
+  };
+
+  console.log();
+  for (const c of checks) {
+    console.log("  " + icons[c.status] + " " + c.name.padEnd(12) + " " + c.detail);
+  }
+  console.log();
+
+  const failCount = checks.filter((c) => c.status === "fail").length;
+  if (failCount > 0) process.exit(1);
+}

package/src/core/daemon.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from "fs";
 import { dirname } from "path";
 import { getPaths } from "../utils/paths";
 import { getConfig } from "../utils/config";
@@ -46,6 +46,7 @@ export function isRunning(): boolean {
     process.kill(pid, 0);
     return true;
   } catch {
+    log.warn({ stalePid: pid }, "removing stale pid file (process not running)");
     removePid();
     return false;
   }
@@ -73,6 +74,7 @@ export function startDaemon(): number {
   });
 
   proc.unref();
+  closeSync(logFd); // Child owns the fd now; close parent's copy to prevent leak
   const pid = proc.pid;
   writePid(pid);
   return pid;
@@ -211,7 +213,8 @@ export async function runDaemon(): Promise<void> {
   let channels: Channel[] = [];
   const config = getConfig();
   if (config.channels.enabled) {
-    channels = await startChannels();
+    const result = await startChannels();
+    channels = result.started;
   } else {
     log.info("channels disabled (channels_enabled: false)");
   }

package/src/db/connection.ts

@@ -1,11 +1,18 @@
 import postgres from "postgres";
 import { getConfig } from "../utils/config";
+import { log } from "../utils/log";
 
 let _sql: ReturnType<typeof postgres> | null = null;
 
 export function getSql(): ReturnType<typeof postgres> {
   if (!_sql) {
-    _sql = postgres(getConfig().database_url, { onnotice: () => {} });
+    const url = getConfig().database_url;
+    if (!url || !url.startsWith("postgres")) {
+      const msg = `Invalid database_url: "${url || "(empty)"}". Expected a postgres:// connection string.`;
+      log.error(msg);
+      throw new Error(msg);
+    }
+    _sql = postgres(url, { onnotice: () => {} });
   }
   return _sql;
 }

package/src/utils/config.ts

@@ -1,5 +1,5 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { dirname } from "path";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
 import yaml from "js-yaml";
 import { getPaths } from "./paths";
 import { log } from "./log";
@@ -179,12 +179,20 @@ function deepMerge(target: Record<string, unknown>, source: Record<string, unkno
   }
 }
 
-/** Deep-merge fields into config.yaml and write back. */
+/** Deep-merge fields into config.yaml and write back atomically. */
 export function updateRawConfig(fields: Record<string, unknown>): void {
   const { config } = getPaths();
   const raw = readRawConfig();
   deepMerge(raw, fields);
-  mkdirSync(dirname(config), { recursive: true });
-  writeFileSync(config, yaml.dump(raw, { lineWidth: -1 }));
+  const dir = dirname(config);
+  mkdirSync(dir, { recursive: true });
+  // Back up current config before overwriting
+  if (existsSync(config)) {
+    copyFileSync(config, join(dir, "config.yaml.bak"));
+  }
+  // Write to temp file then rename for atomic update (prevents corruption on crash)
+  const tmp = join(dir, `.config.yaml.tmp.${process.pid}`);
+  writeFileSync(tmp, yaml.dump(raw, { lineWidth: -1 }));
+  renameSync(tmp, config);
   resetConfig();
 }