niahere 0.5.12 → 0.5.14

package/package.json

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

package/src/channels/index.ts

@@ -1,6 +1,7 @@
 import type { Channel } from "../types";
-import { registerChannel, getFactories, trackStarted, clearStarted, getStarted } from "./registry";
+import { registerChannel, getFactories, trackStarted, clearStarted, getStarted, untrackStarted } from "./registry";
 import { log } from "../utils/log";
+import { ignore } from "../utils/errors";
 import { getConfig } from "../utils/config";
 import { createTelegramChannel } from "./telegram";
 import { createSlackChannel } from "./slack";
@@ -20,6 +21,8 @@ export function registerAllChannels(): void {
   registerChannel(() => createWhatsAppChannel());
 }
 
+let reconciling = false;
+
 export interface StartResult {
   started: Channel[];
   failed: string[];
@@ -72,8 +75,26 @@ export async function startChannels(only?: readonly string[]): Promise<StartResu
  * `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.
+ *
+ * It also covers the reverse case, where a channel is tracked as running but
+ * its transport has died underneath it. Being in the registry was the only
+ * liveness anyone checked, so such a channel was never retried; `healthy()`
+ * lets a channel say otherwise and get rebuilt.
  */
 export async function reconcileChannels(): Promise<StartResult> {
+  // Bringing a channel up can block for as long as its transport takes to
+  // connect. Without this, a slow start would let the next heartbeat reconcile
+  // the same channel again and leave two of them running.
+  if (reconciling) return { started: [], failed: [] };
+  reconciling = true;
+  try {
+    return await reconcile();
+  } finally {
+    reconciling = false;
+  }
+}
+
+async function reconcile(): Promise<StartResult> {
   const wanted = getConfiguredChannelNames();
   const running = getStarted();
   const runningNames = new Set(running.map((ch) => ch.name));
@@ -81,9 +102,11 @@ export async function reconcileChannels(): Promise<StartResult> {
 
   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: [] };
+  const dead = running.filter((ch) => wantedSet.has(ch.name) && ch.healthy?.() === false);
+  if (missing.length === 0 && extra.length === 0 && dead.length === 0) return { started: [], failed: [] };
 
-  log.warn({ missing, extra: extra.map((ch) => ch.name) }, "channels out of sync, reconciling");
+  const deadNames = dead.map((ch) => ch.name);
+  log.warn({ missing, extra: extra.map((ch) => ch.name), dead: deadNames }, "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
@@ -93,9 +116,16 @@ export async function reconcileChannels(): Promise<StartResult> {
     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);
+  // Tear the dead ones down individually so healthy channels stay connected. A
+  // stop that fails must not block the restart — the point is to replace them.
+  for (const channel of dead) {
+    await ignore(channel.stop(), `stopping dead channel ${channel.name}`);
+    untrackStarted(channel.name);
+  }
+
+  // Start just the channels that need it so healthy ones stay connected and one
+  // persistently-failing channel can't thrash the rest.
+  return startChannels([...missing, ...deadNames]);
 }
 
 export function getConfiguredChannelNames(): string[] {

package/src/channels/registry.ts

@@ -11,6 +11,10 @@ export function getFactories(): readonly ChannelFactory[] {
   return factories;
 }
 
+export function clearFactories(): void {
+  factories.length = 0;
+}
+
 export function trackStarted(channel: Channel): void {
   started.set(channel.name, channel);
 }
@@ -23,6 +27,10 @@ export function getStarted(): Channel[] {
   return [...started.values()];
 }
 
+export function untrackStarted(name: string): void {
+  started.delete(name);
+}
+
 export function clearStarted(): void {
   started.clear();
 }

package/src/channels/slack.ts

@@ -1,4 +1,4 @@
-import { App } from "@slack/bolt";
+import { App, SocketModeReceiver } from "@slack/bolt";
 import type { WebClient } from "@slack/web-api";
 import type { Channel, ChatState, Attachment, Outbound, Recipient } from "../types";
 import { getConfig, updateRawConfig } from "../utils/config";
@@ -17,6 +17,45 @@ import { createTurnPump } from "./common/coalesce";
 
 const logActivity = (status: string) => log.debug({ status }, "slack engine activity");
 
+/** A healthy reconnect lands in seconds, so a gap this long is not one in progress. */
+const SOCKET_STALL_MS = 3 * 60_000;
+
+/** Every Socket Mode state that is not "carrying events right now". */
+const DISCONNECTED_STATES = ["connecting", "reconnecting", "disconnecting", "disconnected"] as const;
+
+interface SocketStateEmitter {
+  on(event: string, listener: () => void): unknown;
+}
+
+/**
+ * Whether Socket Mode is actually carrying events, as opposed to merely having
+ * been started.
+ *
+ * Socket Mode can stop trying without saying so: a transport-level failure of
+ * `apps.connections.open` is classed unrecoverable, and the resulting rejection
+ * escapes an unawaited reconnect chain. The process stays up and the tokens stay
+ * valid, so nothing outside the socket can tell it is never coming back.
+ */
+export class SocketLiveness {
+  private downSince: number | null = null;
+
+  constructor(client: SocketStateEmitter) {
+    client.on("connected", () => {
+      if (this.downSince !== null) log.info("slack: socket connected");
+      this.downSince = null;
+    });
+    for (const state of DISCONNECTED_STATES) {
+      client.on(state, () => {
+        this.downSince ??= Date.now();
+      });
+    }
+  }
+
+  stalled(now = Date.now()): boolean {
+    return this.downSince !== null && now - this.downSince >= SOCKET_STALL_MS;
+  }
+}
+
 /** What answering a Slack message needs, carried per message so a coalesced
  *  turn can still reply in the right thread and clear every reaction. */
 interface SlackTurnCtx {
@@ -51,6 +90,11 @@ class SlackChannel implements Channel {
   private dmUserId: string | null = null;
   /** Timestamps of messages Nia posted proactively (used to detect replies to our own messages) */
   private outboundTs = new Set<string>();
+  private liveness: SocketLiveness | null = null;
+
+  healthy(): boolean {
+    return !this.liveness?.stalled();
+  }
 
   async deliver(out: Outbound): Promise<void> {
     if (!this.app) throw new Error("Slack not started");
@@ -275,10 +319,14 @@ class SlackChannel implements Channel {
 
     const self = this;
 
+    const receiver = new SocketModeReceiver({ appToken });
+    this.liveness = new SocketLiveness(receiver.client);
+
     const app = new App({
       token: botToken,
       appToken,
       socketMode: true,
+      receiver,
     });
 
     let botUserId: string | undefined;
@@ -572,6 +620,7 @@ class SlackChannel implements Channel {
     if (this.app) {
       await this.app.stop();
       this.app = null;
+      this.liveness = null;
     }
   }
 }

package/src/channels/telegram.ts

@@ -13,6 +13,7 @@ import { classifyMime, validateAttachment, prepareImage } from "../utils/attachm
 import { getNiaHome } from "../utils/paths";
 import { ChatSessions, chainLock } from "./common/chat-session";
 import { shouldSuppressReply } from "./common/reply";
+import { transcribeAudio } from "./twilio/transcribe";
 
 function safeExtension(filename?: string): string {
   const ext = filename?.split(".").pop();
@@ -51,10 +52,24 @@ class TelegramChannel implements Channel {
     bot.on("message:text", (ctx) => this.handleText(ctx));
     bot.on("message:photo", (ctx) => this.handlePhoto(ctx));
     bot.on("message:document", (ctx) => this.handleDocument(ctx));
+    bot.on(["message:voice", "message:audio"], (ctx) => this.handleVoice(ctx));
+
+    // Without a handler grammY rethrows, and an error thrown while polling
+    // takes the whole loop down rather than the one update that caused it.
+    bot.catch((err) => log.error({ err: err.error, chatId: err.ctx.chatId }, "telegram handler failed"));
 
     bot.start({ onStart: () => log.info("telegram bot polling started") });
   }
 
+  /**
+   * grammY stops polling for good if the loop crashes, and the process carries
+   * on regardless. `isRunning()` is its own account of whether that has
+   * happened, so ask it rather than inferring from the outside.
+   */
+  healthy(): boolean {
+    return !this.bot || this.bot.isRunning();
+  }
+
   async stop(): Promise<void> {
     this.chats.closeAll();
     if (this.bot) {
@@ -168,6 +183,39 @@ class TelegramChannel implements Channel {
     });
   }
 
+  private async handleVoice(ctx: Context): Promise<void> {
+    const media = ctx.message?.voice ?? ctx.message?.audio;
+    if (!ctx.chatId || !media || !this.gate(ctx)) return;
+    this.registerOutbound(ctx.chatId);
+    const state = await this.chats.get(ctx.chatId);
+    const chatId = ctx.chatId;
+    this.withLock(chatId, async () => {
+      try {
+        const apiKey = getConfig().channels.phone.openai_api_key;
+        if (!apiKey) {
+          await ctx.reply("Can't transcribe voice notes — channels.phone.openai_api_key isn't set.");
+          return;
+        }
+        const data = await this.downloadFile(media.file_id);
+        const error = validateAttachment(data);
+        if (error) {
+          await ctx.reply(error);
+          return;
+        }
+        const transcript = await transcribeAudio({ apiKey, data, mime: media.mime_type || "audio/ogg" });
+        if (!transcript) {
+          await ctx.reply("Couldn't make out anything in that voice note.");
+          return;
+        }
+        const caption = ctx.message!.caption;
+        await this.processMessage(ctx, state, caption ? `${caption}\n\n${transcript}` : transcript);
+      } catch (err) {
+        log.error({ err, chatId }, "failed to process voice note");
+        await ignore(ctx.reply(`Failed to transcribe that voice note — ${errMsg(err)}`), "reply voice failure");
+      }
+    });
+  }
+
   // --- Core message loop ---
 
   private async processMessage(

package/src/types/channel.ts

@@ -31,6 +31,13 @@ export interface Channel {
   name: string;
   start(): Promise<void>;
   stop(): Promise<void>;
+  /**
+   * Whether the channel can still receive. Implement it wherever having started
+   * is not the same as being connected — a transport can die under a process
+   * that stays up, and no caller above this seam can tell. Omit it and the
+   * channel is assumed healthy for as long as it is running.
+   */
+  healthy?(): boolean;
   /**
    * Deliver an outbound payload. Channels are expected to handle either
    * a text-only, media-only, or text+media payload; format details (chunking,