niahere 0.4.6 → 0.5.1

package/src/channels/telegram.ts

@@ -7,10 +7,11 @@ import { getConfig, updateRawConfig } from "../utils/config";
 import { runMigrations } from "../db/migrate";
 import { Message } from "../db/models";
 import { log } from "../utils/log";
+import { errMsg, ignore } from "../utils/errors";
 import { getMcpServers } from "../mcp";
 import { classifyMime, validateAttachment, prepareImage } from "../utils/attachment";
 import { getNiaHome } from "../utils/paths";
-import { chainLock, openChatEngine, rotateRoom } from "./common/chat-session";
+import { ChatSessions, chainLock } from "./common/chat-session";
 
 function safeExtension(filename?: string): string {
   const ext = filename?.split(".").pop();
@@ -27,7 +28,10 @@ class TelegramChannel implements Channel {
   private bot: Bot | null = null;
   private outboundChatId: number | null = null;
   private isOpen = false;
-  private readonly chats = new Map<number, ChatState>();
+  private readonly chats = new ChatSessions<number>(
+    (chatId) => this.keyOf(chatId),
+    () => ({ channel: "telegram", mcpServers: getMcpServers() }),
+  );
 
   async start(): Promise<void> {
     const config = getConfig();
@@ -51,6 +55,7 @@ class TelegramChannel implements Channel {
   }
 
   async stop(): Promise<void> {
+    this.chats.closeAll();
     if (this.bot) {
       this.bot.stop();
       this.bot = null;
@@ -82,14 +87,14 @@ class TelegramChannel implements Channel {
   private async handleStart(ctx: Context): Promise<void> {
     if (!ctx.chatId || !this.gate(ctx)) return;
     this.registerOutbound(ctx.chatId);
-    const state = await this.getState(ctx.chatId);
+    const state = await this.chats.get(ctx.chatId);
     this.withLock(ctx.chatId, () => this.processMessage(ctx, state, "hi"));
   }
 
   private async handleRestart(ctx: Context): Promise<void> {
     if (!ctx.chatId || !this.gate(ctx)) return;
     this.registerOutbound(ctx.chatId);
-    const state = await this.restartChat(ctx.chatId);
+    const state = await this.chats.rotate(ctx.chatId);
     log.info({ chatId: ctx.chatId, room: `tg-${ctx.chatId}-${state.roomIndex}` }, "new telegram conversation");
     await ctx.reply("New conversation started.");
   }
@@ -97,7 +102,7 @@ class TelegramChannel implements Channel {
   private async handleText(ctx: Context): Promise<void> {
     if (!ctx.chatId || !ctx.message?.text || !this.gate(ctx)) return;
     this.registerOutbound(ctx.chatId);
-    const state = await this.getState(ctx.chatId);
+    const state = await this.chats.get(ctx.chatId);
     const text = ctx.message.text;
     this.withLock(ctx.chatId, () => this.processMessage(ctx, state, text));
   }
@@ -105,7 +110,7 @@ class TelegramChannel implements Channel {
   private async handlePhoto(ctx: Context): Promise<void> {
     if (!ctx.chatId || !ctx.message?.photo || !this.gate(ctx)) return;
     this.registerOutbound(ctx.chatId);
-    const state = await this.getState(ctx.chatId);
+    const state = await this.chats.get(ctx.chatId);
     const chatId = ctx.chatId;
     this.withLock(chatId, async () => {
       try {
@@ -118,7 +123,7 @@ class TelegramChannel implements Channel {
         await this.processMessage(ctx, state, caption, [attachment]);
       } catch (err) {
         log.error({ err, chatId }, "failed to process photo");
-        await ctx.reply("Failed to process image.").catch(() => {});
+        await ignore(ctx.reply("Failed to process image."), "reply image failure");
       }
     });
   }
@@ -126,7 +131,7 @@ class TelegramChannel implements Channel {
   private async handleDocument(ctx: Context): Promise<void> {
     if (!ctx.chatId || !ctx.message?.document || !this.gate(ctx)) return;
     this.registerOutbound(ctx.chatId);
-    const state = await this.getState(ctx.chatId);
+    const state = await this.chats.get(ctx.chatId);
     const chatId = ctx.chatId;
     this.withLock(chatId, async () => {
       try {
@@ -157,7 +162,7 @@ class TelegramChannel implements Channel {
         await this.processMessage(ctx, state, caption, [attachment]);
       } catch (err) {
         log.error({ err, chatId }, "failed to process document");
-        await ctx.reply("Failed to process document.").catch(() => {});
+        await ignore(ctx.reply("Failed to process document."), "reply document failure");
       }
     });
   }
@@ -176,25 +181,25 @@ class TelegramChannel implements Channel {
     log.info({ chatId, text: text.slice(0, 100), attachments: attachments?.length || 0 }, "telegram message received");
 
     const typingInterval = setInterval(() => {
-      bot.api.sendChatAction(chatId, "typing").catch(() => {});
+      void ignore(bot.api.sendChatAction(chatId, "typing"), "send typing indicator");
     }, 4000);
-    bot.api.sendChatAction(chatId, "typing").catch(() => {});
+    void ignore(bot.api.sendChatAction(chatId, "typing"), "send typing indicator");
 
     try {
       const { result, messageId } = await state.engine.send(text, {}, attachments);
       const reply = result.trim() || "(no response)";
       try {
         await bot.api.sendMessage(chatId, reply);
-        if (messageId) await Message.updateDeliveryStatus(messageId, "sent").catch(() => {});
+        if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "sent"), "record sent delivery status");
         log.info({ chatId, chars: result.length }, "telegram reply sent");
       } catch (sendErr) {
-        if (messageId) await Message.updateDeliveryStatus(messageId, "failed").catch(() => {});
+        if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "failed"), "record failed delivery status");
         throw sendErr;
       }
     } catch (err) {
-      const errText = err instanceof Error ? err.message : String(err);
+      const errText = errMsg(err);
       log.error({ err, chatId }, "telegram message processing failed");
-      await bot.api.sendMessage(chatId, `[error] ${errText}`).catch(() => {});
+      await ignore(bot.api.sendMessage(chatId, `[error] ${errText}`), "reply engine error");
     } finally {
       clearInterval(typingInterval);
     }
@@ -202,25 +207,8 @@ class TelegramChannel implements Channel {
 
   // --- Session / state helpers ---
 
-  private async getState(chatId: number): Promise<ChatState> {
-    let state = this.chats.get(chatId);
-    if (state) return state;
-    state = await openChatEngine(this.keyOf(chatId), () => ({ channel: "telegram", mcpServers: getMcpServers() }));
-    this.chats.set(chatId, state);
-    return state;
-  }
-
-  private async restartChat(chatId: number): Promise<ChatState> {
-    const state = await rotateRoom(this.keyOf(chatId), this.chats.get(chatId), () => ({
-      channel: "telegram",
-      mcpServers: getMcpServers(),
-    }));
-    this.chats.set(chatId, state);
-    return state;
-  }
-
   private withLock(chatId: number, fn: () => Promise<void>): void {
-    const state = this.chats.get(chatId);
+    const state = this.chats.peek(chatId);
     if (!state) {
       fn().catch((err) => log.error({ err, chatId }, "unhandled error in locked handler"));
       return;
@@ -238,7 +226,7 @@ class TelegramChannel implements Channel {
   private gate(ctx: Context): boolean {
     if (!ctx.chatId) return false;
     if (this.isAllowed(ctx.chatId)) return true;
-    ctx.reply("Unauthorized.").catch(() => {});
+    void ignore(ctx.reply("Unauthorized."), "reply unauthorized");
     return false;
   }
 

package/src/channels/twilio/media-cache.ts

@@ -16,6 +16,7 @@ import { createHash } from "crypto";
 import { join } from "path";
 import { getNiaHome } from "../../utils/paths";
 import { log } from "../../utils/log";
+import { ignore } from "../../utils/errors";
 
 const MAX_FILES = 100;
 const MAX_BYTES = 10 * 1024 * 1024;
@@ -85,7 +86,7 @@ async function evict(): Promise<void> {
   let alive: typeof stats = [];
   for (const s of stats) {
     if (now - s.mtime > MAX_AGE_MS) {
-      await unlink(s.path).catch(() => {});
+      await ignore(unlink(s.path), "prune cached media");
     } else {
       alive.push(s);
     }
@@ -95,13 +96,13 @@ async function evict(): Promise<void> {
 
   while (alive.length > MAX_FILES) {
     const victim = alive.shift()!;
-    await unlink(victim.path).catch(() => {});
+    await ignore(unlink(victim.path), "prune cached media");
   }
 
   let totalBytes = alive.reduce((sum, f) => sum + f.size, 0);
   while (totalBytes > MAX_BYTES && alive.length > 0) {
     const victim = alive.shift()!;
     totalBytes -= victim.size;
-    await unlink(victim.path).catch(() => {});
+    await ignore(unlink(victim.path), "prune cached media");
   }
 }

package/src/channels/twilio/rest.ts

@@ -73,16 +73,6 @@ export async function placeCall(opts: PlaceCallOpts): Promise<PlaceCallResult> {
   return { callSid: data.sid, status: data.status };
 }
 
-export async function updateCallUrl(opts: TwilioCreds & { callSid: string; url: string }): Promise<void> {
-  const body = new URLSearchParams({ Url: opts.url, Method: "POST" });
-  await twilioPost(opts, `/Calls/${encodeURIComponent(opts.callSid)}.json`, body);
-}
-
-export async function hangupCall(opts: TwilioCreds & { callSid: string }): Promise<void> {
-  const body = new URLSearchParams({ Status: "completed" });
-  await twilioPost(opts, `/Calls/${encodeURIComponent(opts.callSid)}.json`, body);
-}
-
 // --- Messages (SMS / WhatsApp) ---
 
 export interface SendMessageOpts extends TwilioCreds {
@@ -111,24 +101,3 @@ export async function sendMessage(opts: SendMessageOpts): Promise<SendMessageRes
 }
 
 // --- Phone number config (update inbound webhook on a number) ---
-
-export async function updateIncomingPhoneNumber(
-  opts: TwilioCreds & {
-    phoneNumberSid: string;
-    voiceUrl?: string;
-    voiceMethod?: "GET" | "POST";
-    smsUrl?: string;
-    smsMethod?: "GET" | "POST";
-    statusCallback?: string;
-    statusCallbackMethod?: "GET" | "POST";
-  },
-): Promise<void> {
-  const body = new URLSearchParams();
-  if (opts.voiceUrl !== undefined) body.set("VoiceUrl", opts.voiceUrl);
-  if (opts.voiceMethod) body.set("VoiceMethod", opts.voiceMethod);
-  if (opts.smsUrl !== undefined) body.set("SmsUrl", opts.smsUrl);
-  if (opts.smsMethod) body.set("SmsMethod", opts.smsMethod);
-  if (opts.statusCallback !== undefined) body.set("StatusCallback", opts.statusCallback);
-  if (opts.statusCallbackMethod) body.set("StatusCallbackMethod", opts.statusCallbackMethod);
-  await twilioPost(opts, `/IncomingPhoneNumbers/${encodeURIComponent(opts.phoneNumberSid)}.json`, body);
-}

package/src/channels/twilio/server.ts

@@ -248,8 +248,3 @@ export function getTwilioServer(): TwilioServer {
   if (!_instance) _instance = new TwilioServerImpl();
   return _instance;
 }
-
-/** Test-only: drop the singleton so tests get a fresh server. */
-export function resetTwilioServer(): void {
-  _instance = null;
-}

package/src/channels/twilio/shared.ts

@@ -0,0 +1,36 @@
+import type { TwilioConfig } from "../../types";
+import { log } from "../../utils/log";
+
+/** Bits every Twilio-backed channel (sms, whatsapp) needs identically. */
+
+const EMPTY_TWIML = '<?xml version="1.0" encoding="UTF-8"?><Response></Response>';
+
+/** Ack an inbound webhook immediately. Replies go out over REST instead, so a
+ *  slow engine cannot blow Twilio's ~15s webhook budget. */
+export function ackTwiml(): Response {
+  return new Response(EMPTY_TWIML, { status: 200, headers: { "Content-Type": "text/xml" } });
+}
+
+export function isAllowedSender(twilio: TwilioConfig, remoteE164: string): boolean {
+  if (twilio.owner_number && remoteE164 === twilio.owner_number) return true;
+  return twilio.allowlist.includes(remoteE164);
+}
+
+type StatusLogger = (label: string, fields: Record<string, unknown>) => void;
+
+const logStatus: StatusLogger = (label, fields) => log.info(fields, `${label}: delivery status`);
+
+/** Record a delivery-status callback and ack it. */
+export function deliveryStatusAck(
+  label: string,
+  params: Record<string, string>,
+  record: StatusLogger = logStatus,
+): Response {
+  record(label, {
+    messageSid: params.MessageSid,
+    status: params.MessageStatus,
+    errorCode: params.ErrorCode,
+    to: params.To,
+  });
+  return new Response("", { status: 204 });
+}

package/src/channels/whatsapp.ts

@@ -20,10 +20,12 @@
 import { getMcpServers } from "../mcp";
 import { Message } from "../db/models";
 import { runMigrations } from "../db/migrate";
-import { chainLock, openChatEngine, rotateRoom } from "./common/chat-session";
+import { ChatSessions, chainLock } from "./common/chat-session";
+import { ackTwiml, deliveryStatusAck, isAllowedSender } from "./twilio/shared";
 import type { Attachment, Channel, ChatState, Outbound, TwilioConfig, WhatsappConfig, PhoneConfig } from "../types";
 import { getConfig } from "../utils/config";
 import { log } from "../utils/log";
+import { errMsg, ignore } from "../utils/errors";
 import { classifyMime, prepareImage, validateAttachment } from "../utils/attachment";
 import { sendMessage as twilioSendMessage } from "./twilio/rest";
 import { getTwilioServer } from "./twilio/server";
@@ -32,7 +34,6 @@ import { transcribeAudio } from "./twilio/transcribe";
 
 const TWENTY_FOUR_HOURS_MS = 24 * 60 * 60 * 1000;
 const WA_PREFIX = "whatsapp:";
-const EMPTY_TWIML = '<?xml version="1.0" encoding="UTF-8"?><Response></Response>';
 const CHUNK_LIMIT = 4096;
 const RESET_RE = /^\s*\/(reset|new)\s*$/i;
 const VOICE_MIME_PREFIX = "audio/";
@@ -42,13 +43,14 @@ class WhatsAppChannel implements Channel {
   private readonly twilio: TwilioConfig;
   private readonly whatsapp: WhatsappConfig;
   private readonly phone: PhoneConfig;
-  private readonly chats = new Map<string, ChatState>();
+  private readonly chats: ChatSessions<string>;
   private readonly lastInboundAt = new Map<string, number>();
 
   constructor(twilio: TwilioConfig, whatsapp: WhatsappConfig, phone: PhoneConfig) {
     this.twilio = twilio;
     this.whatsapp = whatsapp;
     this.phone = phone;
+    this.chats = new ChatSessions(roomPrefix, () => ({ channel: "whatsapp", mcpServers: getMcpServers() }));
   }
 
   async start(): Promise<void> {
@@ -86,8 +88,7 @@ class WhatsAppChannel implements Channel {
   }
 
   async stop(): Promise<void> {
-    for (const state of this.chats.values()) state.engine.close();
-    this.chats.clear();
+    this.chats.closeAll();
   }
 
   /** Outbound to the owner — used by send_message MCP tool. WhatsApp has no threading. */
@@ -108,9 +109,9 @@ class WhatsAppChannel implements Channel {
     const from = (params.From || "").replace(/^whatsapp:/, "");
     const body = (params.Body || "").trim();
 
-    if (!this.isAllowed(from)) {
+    if (!isAllowedSender(this.twilio, from)) {
       log.warn({ from }, "whatsapp: rejecting non-allowlisted sender");
-      return new Response(EMPTY_TWIML, { status: 200, headers: { "Content-Type": "text/xml" } });
+      return ackTwiml();
     }
 
     this.lastInboundAt.set(from, Date.now());
@@ -118,20 +119,20 @@ class WhatsAppChannel implements Channel {
     if (RESET_RE.test(body)) {
       // Serialize through the same lock so a /reset chasing an in-flight
       // engine.send() waits its turn instead of yanking the engine away.
-      const state = await this.getState(from);
+      const state = await this.chats.get(from);
       chainLock(state, async () => {
-        const newState = await this.restartChat(from);
+        const newState = await this.chats.rotate(from);
         await this.sendTextTo(
           from,
-          `New conversation started (room ${this.roomPrefix(from)}-${newState.roomIndex}).`,
+          `New conversation started (room ${roomPrefix(from)}-${newState.roomIndex}).`,
         ).catch((err) => log.warn({ err, from }, "whatsapp: failed to send reset confirmation"));
       });
-      return new Response(EMPTY_TWIML, { status: 200, headers: { "Content-Type": "text/xml" } });
+      return ackTwiml();
     }
 
     const descriptors = extractMedia(params);
 
-    const state = await this.getState(from);
+    const state = await this.chats.get(from);
     chainLock(state, async () => {
       let userText = body;
       let attachments: Attachment[] | undefined;
@@ -162,7 +163,7 @@ class WhatsAppChannel implements Channel {
             } catch (err) {
               log.error({ err, from }, "whatsapp: voice transcription failed");
               voiceParts.push(
-                `[voice note: transcription failed — ${err instanceof Error ? err.message : String(err)}]`,
+                `[voice note: transcription failed — ${errMsg(err)}]`,
               );
             }
             continue;
@@ -171,7 +172,7 @@ class WhatsAppChannel implements Channel {
           const error = validateAttachment(item.data);
           if (error) {
             log.warn({ from, mime: item.mime, error }, "whatsapp: rejecting attachment");
-            await this.sendTextTo(from, `[error] ${error}`).catch(() => {});
+            await ignore(this.sendTextTo(from, `[error] ${error}`), "reply engine error");
             continue;
           }
 
@@ -203,32 +204,23 @@ class WhatsAppChannel implements Channel {
         const reply = result.trim() || "(no response)";
         try {
           await this.sendTextTo(from, reply);
-          if (messageId) await Message.updateDeliveryStatus(messageId, "sent").catch(() => {});
+          if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "sent"), "record sent delivery status");
         } catch (sendErr) {
-          if (messageId) await Message.updateDeliveryStatus(messageId, "failed").catch(() => {});
+          if (messageId) await ignore(Message.updateDeliveryStatus(messageId, "failed"), "record failed delivery status");
           throw sendErr;
         }
       } catch (err) {
         log.error({ err, from }, "whatsapp: engine error");
-        const errText = err instanceof Error ? err.message : String(err);
-        await this.sendTextTo(from, `[error] ${errText}`).catch(() => {});
+        const errText = errMsg(err);
+        await ignore(this.sendTextTo(from, `[error] ${errText}`), "reply engine error");
       }
     });
 
-    return new Response(EMPTY_TWIML, { status: 200, headers: { "Content-Type": "text/xml" } });
+    return ackTwiml();
   }
 
   private handleStatus(params: Record<string, string>): Response {
-    log.info(
-      {
-        messageSid: params.MessageSid,
-        status: params.MessageStatus,
-        errorCode: params.ErrorCode,
-        to: params.To,
-      },
-      "whatsapp: delivery status",
-    );
-    return new Response("", { status: 204 });
+    return deliveryStatusAck("whatsapp", params);
   }
 
   // --- Outbound ---
@@ -301,36 +293,10 @@ class WhatsAppChannel implements Channel {
     return true;
   }
 
-  // --- Helpers ---
-
-  private isAllowed(remoteE164: string): boolean {
-    if (this.twilio.owner_number && remoteE164 === this.twilio.owner_number) return true;
-    return this.twilio.allowlist.includes(remoteE164);
-  }
-
-  private roomPrefix(remoteE164: string): string {
-    return `wa-${remoteE164}`;
-  }
-
-  private async getState(remoteE164: string): Promise<ChatState> {
-    let state = this.chats.get(remoteE164);
-    if (state) return state;
-    state = await openChatEngine(this.roomPrefix(remoteE164), () => ({
-      channel: "whatsapp",
-      mcpServers: getMcpServers(),
-    }));
-    this.chats.set(remoteE164, state);
-    return state;
-  }
+}
 
-  private async restartChat(remoteE164: string): Promise<ChatState> {
-    const state = await rotateRoom(this.roomPrefix(remoteE164), this.chats.get(remoteE164), () => ({
-      channel: "whatsapp",
-      mcpServers: getMcpServers(),
-    }));
-    this.chats.set(remoteE164, state);
-    return state;
-  }
+function roomPrefix(remoteE164: string): string {
+  return `wa-${remoteE164}`;
 }
 
 /**