niahere 0.3.1 → 0.3.3

package/src/channels/slack.ts

@@ -1,18 +1,14 @@
 import { App } from "@slack/bolt";
-import { existsSync, mkdirSync, readFileSync, writeFileSync, statSync } from "fs";
-import { join } from "path";
-import { createHash } from "crypto";
-import { createChatEngine } from "../chat/engine";
-import type { Channel, ChatState, Attachment, AttachmentType } from "../types";
-import { getConfig, updateRawConfig, resetConfig } from "../utils/config";
+import type { Channel, ChatState, Attachment, Outbound, Recipient } from "../types";
+import { getConfig, updateRawConfig } from "../utils/config";
 import { relativeTime } from "../utils/format";
 import { runMigrations } from "../db/migrate";
 import { Session, Message } from "../db/models";
 import { log } from "../utils/log";
 import { getMcpServers } from "../mcp";
-import { getNiaHome, getPaths } from "../utils/paths";
-import { classifyMime, validateAttachment, prepareImage } from "../utils/attachment";
-import { resolveWatchBehavior } from "../utils/watches";
+import { chainLock, openChatEngine, rotateRoom } from "./common/chat-session";
+import { SlackAttachmentCache } from "./slack/attachments";
+import { SlackWatchReloader } from "./slack/watch";
 
 /** Strip markdown backticks so sentinel tokens like [NO_REPLY] match even when the LLM wraps them. */
 function cleanSentinel(text: string): string {
@@ -20,47 +16,39 @@ function cleanSentinel(text: string): string {
 }
 
 class SlackChannel implements Channel {
-  name = "slack";
+  name = "slack" as const;
   private app: App | null = null;
   private dmUserId: string | null = null;
   /** Timestamps of messages Nia posted proactively (used to detect replies to our own messages) */
   private outboundTs = new Set<string>();
 
-  async sendMessage(text: string): Promise<void> {
+  async deliver(out: Outbound): Promise<void> {
     if (!this.app) throw new Error("Slack not started");
-    const target = this.dmUserId;
-    if (!target) throw new Error("No Slack recipient — set dm_user_id in config");
-    const result = await this.app.client.chat.postMessage({ channel: target, text });
-    if (result.ts) this.outboundTs.add(result.ts);
-  }
-
-  async sendToThread(channelId: string, text: string, threadTs?: string): Promise<void> {
-    if (!this.app) throw new Error("Slack not started");
-    const opts: Record<string, unknown> = { channel: channelId, text };
-    if (threadTs) opts.thread_ts = threadTs;
-    const result = await this.app.client.chat.postMessage(opts as any);
-    if (result.ts) this.outboundTs.add(result.ts);
-  }
+    const dest = this.resolveDest(out.to);
+
+    if (out.media) {
+      const buffer = Buffer.from(out.media.data);
+      const filename = out.media.filename || `file.${out.media.mimeType.split("/")[1] || "bin"}`;
+      await this.app.client.filesUploadV2({
+        channel_id: dest.channel,
+        file: buffer,
+        filename,
+        ...(dest.threadTs ? { thread_ts: dest.threadTs } : {}),
+      } as any);
+    }
 
-  async sendMedia(data: Buffer, mimeType: string, filename?: string): Promise<void> {
-    if (!this.app) throw new Error("Slack not started");
-    const target = this.dmUserId;
-    if (!target) throw new Error("No Slack recipient — set dm_user_id in config");
-    await this.app.client.filesUploadV2({
-      channel_id: target,
-      file: data,
-      filename: filename || `file.${mimeType.split("/")[1] || "bin"}`,
-    });
+    if (out.text) {
+      const opts: Record<string, unknown> = { channel: dest.channel, text: out.text };
+      if (dest.threadTs) opts.thread_ts = dest.threadTs;
+      const result = await this.app.client.chat.postMessage(opts as any);
+      if (result.ts) this.outboundTs.add(result.ts);
+    }
   }
 
-  async sendMediaToThread(channelId: string, data: Buffer, mimeType: string, filename?: string, threadTs?: string): Promise<void> {
-    if (!this.app) throw new Error("Slack not started");
-    await this.app.client.filesUploadV2({
-      channel_id: channelId,
-      file: data,
-      filename: filename || `file.${mimeType.split("/")[1] || "bin"}`,
-      ...(threadTs ? { thread_ts: threadTs } : {}),
-    } as any);
+  private resolveDest(to: Recipient | undefined): { channel: string; threadTs?: string } {
+    if (to?.kind === "thread") return { channel: to.channelId, threadTs: to.threadTs };
+    if (!this.dmUserId) throw new Error("No Slack recipient — set dm_user_id in config");
+    return { channel: this.dmUserId };
   }
 
   async start(): Promise<void> {
@@ -87,62 +75,46 @@ class SlackChannel implements Channel {
       return name;
     }
 
-    function roomPrefix(key: string): string {
-      return `slack-${key}`;
-    }
-
-    function roomName(key: string, index: number): string {
-      return `slack-${key}-${index}`;
-    }
-
     interface SlackContext {
       slackChannelId?: string;
       slackThreadTs?: string;
     }
 
-    async function getState(key: string, watchBehavior?: { channel: string; behavior: string }, slackCtx?: SlackContext): Promise<ChatState> {
-      let state = chats.get(key);
-      if (!state) {
-        const prefix = roomPrefix(key);
-        const idx = await Session.getLatestRoomIndex(prefix);
-        const room = roomName(key, idx);
-        const engine = await createChatEngine({
-          room,
-          channel: "slack",
-          resume: true,
-          mcpServers: getMcpServers({ channel: "slack", room, ...slackCtx }),
-          watchBehavior,
-        });
-        state = { engine, roomIndex: idx, lock: Promise.resolve() };
-        chats.set(key, state);
-      }
-      return state;
+    function roomPrefix(k: string): string {
+      return `slack-${k}`;
     }
 
-    async function restartChat(key: string, watchBehavior?: { channel: string; behavior: string }, slackCtx?: SlackContext): Promise<ChatState> {
-      const old = chats.get(key);
-      if (old) old.engine.close();
-
-      const prefix = roomPrefix(key);
-      const prevIdx = await Session.getLatestRoomIndex(prefix);
-      const newIdx = prevIdx + 1;
-      const room = roomName(key, newIdx);
-
-      // Persist a placeholder session immediately so the room index survives
-      // daemon restarts (otherwise getState falls back to the old room).
-      await Session.create(`placeholder-${room}`, room);
+    function roomName(k: string, index: number): string {
+      return `slack-${k}-${index}`;
+    }
 
-      log.info({ key, room }, "slack: creating chat engine");
-      const engine = await createChatEngine({
-        room,
+    function buildEngineOpts(watchBehavior?: { channel: string; behavior: string }, slackCtx?: SlackContext) {
+      return (room: string) => ({
         channel: "slack",
-        resume: false,
         mcpServers: getMcpServers({ channel: "slack", room, ...slackCtx }),
         watchBehavior,
       });
-      const state: ChatState = { engine, roomIndex: newIdx, lock: Promise.resolve() };
+    }
+
+    async function getState(
+      key: string,
+      watchBehavior?: { channel: string; behavior: string },
+      slackCtx?: SlackContext,
+    ): Promise<ChatState> {
+      let state = chats.get(key);
+      if (state) return state;
+      state = await openChatEngine(roomPrefix(key), buildEngineOpts(watchBehavior, slackCtx));
+      chats.set(key, state);
+      return state;
+    }
+
+    async function restartChat(
+      key: string,
+      watchBehavior?: { channel: string; behavior: string },
+      slackCtx?: SlackContext,
+    ): Promise<ChatState> {
+      const state = await rotateRoom(roomPrefix(key), chats.get(key), buildEngineOpts(watchBehavior, slackCtx));
       chats.set(key, state);
-      log.info({ key, room, activeSessions: chats.size }, "slack: engine ready");
       return state;
     }
 
@@ -152,9 +124,7 @@ 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).catch((err) => log.error({ err, key }, "unhandled error in locked handler"));
+      chainLock(state, fn);
     }
 
     const self = this;
@@ -167,59 +137,8 @@ class SlackChannel implements Channel {
 
     let botUserId: string | undefined;
 
-    // Watch channels: mtime-based hot-reload from config.yaml AND any watch
-    // behavior files referenced by that config. Keys are channel_id#channel_name.
-    let watchCache: Map<string, { name: string; behavior: string }> = new Map();
-    let watchFilePaths: string[] = [];
-    let lastReloadMtime = 0;
-
-    function maxMtime(paths: string[]): number {
-      let max = 0;
-      for (const p of paths) {
-        try {
-          const m = statSync(p).mtimeMs;
-          if (m > max) max = m;
-        } catch {
-          // ignore missing files
-        }
-      }
-      return max;
-    }
-
-    function reloadWatchChannels(): Map<string, { name: string; behavior: string }> {
-      const configPath = getPaths().config;
-      const mtime = maxMtime([configPath, ...watchFilePaths]);
-      if (mtime === 0) return watchCache;
-      if (mtime === lastReloadMtime) return watchCache;
-
-      resetConfig(); // clear cached config so getConfig() re-reads from disk
-      const cfg = getConfig();
-      const watch = cfg.channels.slack.watch;
-      const fresh = new Map<string, { name: string; behavior: string }>();
-      const freshFiles: string[] = [];
-      if (watch) {
-        for (const [key, entry] of Object.entries(watch)) {
-          if (!entry.enabled) continue;
-          const hashIdx = key.indexOf("#");
-          if (hashIdx === -1) {
-            log.warn({ channel: key }, "slack: watch key must use channel_id#name format, skipping");
-            continue;
-          }
-          const id = key.slice(0, hashIdx);
-          const name = key.slice(hashIdx + 1);
-          const resolved = resolveWatchBehavior(entry.behavior, name);
-          if (resolved.filePath) freshFiles.push(resolved.filePath);
-          fresh.set(id, { name, behavior: resolved.behavior });
-        }
-      }
-      if (fresh.size !== watchCache.size) {
-        log.info({ count: fresh.size }, "slack: watch channels reloaded");
-      }
-      watchCache = fresh;
-      watchFilePaths = freshFiles;
-      lastReloadMtime = maxMtime([configPath, ...freshFiles]);
-      return watchCache;
-    }
+    const watchReloader = new SlackWatchReloader();
+    const attachmentCache = new SlackAttachmentCache(botToken);
 
     // Slash command: /nia
     app.command("/nia", async ({ command, ack, respond }) => {
@@ -268,129 +187,6 @@ class SlackChannel implements Channel {
       await respond("New conversation started.");
     });
 
-    // Disk-backed file cache: download once, read from disk on subsequent requests
-    const attachRoot = join(getNiaHome(), "tmp", "attachments");
-    mkdirSync(attachRoot, { recursive: true });
-
-    interface CachedFile {
-      path: string;
-      type: AttachmentType;
-      mimeType: string;
-      filename?: string;
-    }
-    const fileIndex = new Map<string, CachedFile>();
-
-    function urlHash(url: string): string {
-      return createHash("sha256").update(url).digest("hex").slice(0, 16);
-    }
-
-    function loadCached(entry: CachedFile): Attachment {
-      return {
-        type: entry.type,
-        data: readFileSync(entry.path),
-        mimeType: entry.mimeType,
-        filename: entry.filename,
-        sourcePath: entry.path,
-      };
-    }
-
-    async function downloadSlackFile(url: string): Promise<Buffer> {
-      const resp = await fetch(url, {
-        headers: { Authorization: `Bearer ${botToken}` },
-      });
-      if (!resp.ok) throw new Error(`Slack file download failed: ${resp.status}`);
-      return Buffer.from(await resp.arrayBuffer());
-    }
-
-    function cacheDirForScope(scope: string): string {
-      const safeScope = scope.replace(/[^a-zA-Z0-9._-]/g, "_");
-      const dir = join(attachRoot, safeScope);
-      mkdirSync(dir, { recursive: true });
-      return dir;
-    }
-
-    function cacheKey(scope: string, url: string): string {
-      return `${scope}:${url}`;
-    }
-
-    function safeExtension(filename?: string): string {
-      const ext = filename?.split(".").pop();
-      return ext && /^[a-zA-Z0-9]{1,16}$/.test(ext) ? ext : "bin";
-    }
-
-    function cacheExtension(filename: string | undefined, mime: string, attType: AttachmentType): string {
-      if (attType === "image" && mime !== "image/gif") return "jpg";
-      return safeExtension(filename);
-    }
-
-    async function extractSlackAttachments(files: any[], scope: string): Promise<Attachment[]> {
-      const attachments: Attachment[] = [];
-      const scopedAttachDir = cacheDirForScope(scope);
-      for (const file of files) {
-        const mime = file.mimetype || "application/octet-stream";
-        const attType = classifyMime(mime);
-        if (!attType) continue;
-        if (!file.url_private_download) continue;
-
-        // Check in-memory index first
-        const indexedKey = cacheKey(scope, file.url_private_download);
-        const cached = fileIndex.get(indexedKey);
-        if (cached && existsSync(cached.path)) {
-          attachments.push(loadCached(cached));
-          continue;
-        }
-
-        // Check disk (survives daemon restarts) — scoped by Slack room/thread.
-        const hash = urlHash(file.url_private_download);
-        const ext = cacheExtension(file.name, mime, attType);
-        const diskPath = join(scopedAttachDir, `${hash}.${ext}`);
-        const metaPath = join(scopedAttachDir, `${hash}.meta.json`);
-        if (existsSync(diskPath) && existsSync(metaPath)) {
-          try {
-            const meta = JSON.parse(readFileSync(metaPath, "utf8"));
-            const entry: CachedFile = {
-              path: diskPath,
-              type: meta.type || attType,
-              mimeType: meta.mimeType || mime,
-              filename: meta.filename || file.name,
-            };
-            fileIndex.set(indexedKey, entry);
-            attachments.push(loadCached(entry));
-            continue;
-          } catch {
-            // Corrupt meta — re-download
-          }
-        }
-
-        try {
-          const data = await downloadSlackFile(file.url_private_download);
-          const error = validateAttachment(data, mime);
-          if (error) {
-            log.warn({ file: file.name, error }, "skipping slack attachment");
-            continue;
-          }
-          let finalData = data;
-          let finalMime = mime;
-          if (attType === "image") {
-            const prepared = await prepareImage(data, mime);
-            finalData = prepared.data;
-            finalMime = prepared.mimeType;
-          }
-
-          // Save file + metadata to disk
-          writeFileSync(diskPath, finalData);
-          writeFileSync(metaPath, JSON.stringify({ type: attType, mimeType: finalMime, filename: file.name }));
-          const entry: CachedFile = { path: diskPath, type: attType, mimeType: finalMime, filename: file.name };
-          fileIndex.set(indexedKey, entry);
-
-          attachments.push({ type: attType, data: finalData, mimeType: finalMime, filename: file.name, sourcePath: diskPath });
-        } catch (err) {
-          log.warn({ err, file: file.name }, "failed to download slack file");
-        }
-      }
-      return attachments;
-    }
-
     // Handle messages (DMs + @mentions)
     app.message(async ({ message, say, client }) => {
       if (message.subtype && message.subtype !== "file_share") return;
@@ -455,7 +251,7 @@ class SlackChannel implements Channel {
       }
 
       // Check if this is a watched channel (hot-reloads from config.yaml via mtime)
-      const currentWatch = reloadWatchChannels();
+      const currentWatch = watchReloader.reload();
       const watchConfig = currentWatch.get(msg.channel);
       const isWatched = !!watchConfig;
 
@@ -517,7 +313,7 @@ class SlackChannel implements Channel {
       // Download any file attachments
       let attachments: Attachment[] | undefined;
       if (hasFiles) {
-        attachments = await extractSlackAttachments(msg.files!, roomPrefix(key));
+        attachments = await attachmentCache.extract(msg.files!, roomPrefix(key));
       }
 
       if (!text && (!attachments || attachments.length === 0)) return;
@@ -554,7 +350,7 @@ class SlackChannel implements Channel {
           const messagesWithFiles = priorMessages.filter((m: any) => m.files?.length > 0);
           let threadFilesAdded = 0;
           for (const m of messagesWithFiles) {
-            const extracted = await extractSlackAttachments(m.files || [], roomPrefix(key));
+            const extracted = await attachmentCache.extract(m.files || [], roomPrefix(key));
             for (const att of extracted) {
               attachments.push(att);
               threadFilesAdded++;
@@ -693,7 +489,7 @@ class SlackChannel implements Channel {
     }
 
     // Initial watch channel load
-    reloadWatchChannels();
+    watchReloader.reload();
 
     log.info("slack bot started (Socket Mode)");
     this.app = app;

package/src/channels/sms.ts

@@ -14,29 +14,26 @@
  * variable deliverability under TRAI scrubbing rules. Test empirically;
  * if outbound fails, the inbound leg (Aman → Nia) is more reliable.
  */
-import { createChatEngine } from "../chat/engine";
 import { getMcpServers } from "../mcp";
-import { Session } from "../db/models";
 import { runMigrations } from "../db/migrate";
-import type { Channel, ChatState, PhoneConfig, SmsConfig, TwilioConfig } from "../types";
+import type { Channel, ChatState, Outbound, TwilioConfig } from "../types";
 import { getConfig } from "../utils/config";
 import { log } from "../utils/log";
 import { sendMessage as twilioSendMessage } from "./twilio/rest";
 import { getTwilioServer } from "./twilio/server";
+import { chainLock, openChatEngine } from "./common/chat-session";
 
 const EMPTY_TWIML = '<?xml version="1.0" encoding="UTF-8"?><Response></Response>';
 
 class SmsChannel implements Channel {
-  name = "sms";
+  name = "sms" as const;
   private readonly twilio: TwilioConfig;
-  private readonly sms: SmsConfig;
   /** Cached resolved "from" number: sms.from_number || phone.from_number */
   private readonly fromNumber: string;
   private readonly chats = new Map<string, ChatState>();
 
-  constructor(twilio: TwilioConfig, sms: SmsConfig, fromNumber: string) {
+  constructor(twilio: TwilioConfig, fromNumber: string) {
     this.twilio = twilio;
-    this.sms = sms;
     this.fromNumber = fromNumber;
   }
 
@@ -77,10 +74,16 @@ class SmsChannel implements Channel {
     this.chats.clear();
   }
 
-  /** Outbound to the owner — used by send_message MCP tool. */
-  async sendMessage(text: string): Promise<void> {
+  /** Outbound — used by send_message MCP tool. SMS is text-only; media is dropped with a warning. */
+  async deliver(out: Outbound): Promise<void> {
     if (!this.twilio.owner_number) throw new Error("sms: owner_number not set");
-    await this.sendTo(this.twilio.owner_number, text);
+    // SMS has no threading; recipient kind is ignored.
+    if (out.media) {
+      log.warn({ filename: out.media.filename }, "sms: media payload dropped (channel is text-only)");
+    }
+    if (out.text) {
+      await this.sendTo(this.twilio.owner_number, out.text);
+    }
   }
 
   // --- Inbound webhook ---
@@ -97,19 +100,16 @@ class SmsChannel implements Channel {
     const state = await this.getState(from);
     // Ack the webhook immediately; reply via REST asynchronously to avoid
     // Twilio's ~15s webhook timeout when the engine takes longer.
-    state.lock = state.lock.then(
-      async () => {
-        try {
-          const { result } = await state.engine.send(body);
-          const reply = result.trim() || "(no response)";
-          await this.sendTo(from, reply);
-        } catch (err) {
-          log.error({ err, from }, "sms: engine error");
-          await this.sendTo(from, `[error] ${err instanceof Error ? err.message : String(err)}`).catch(() => {});
-        }
-      },
-      (err) => log.error({ err, from }, "sms: lock chain error"),
-    );
+    chainLock(state, async () => {
+      try {
+        const { result } = await state.engine.send(body);
+        const reply = result.trim() || "(no response)";
+        await this.sendTo(from, reply);
+      } catch (err) {
+        log.error({ err, from }, "sms: engine error");
+        await this.sendTo(from, `[error] ${err instanceof Error ? err.message : String(err)}`).catch(() => {});
+      }
+    });
 
     return new Response(EMPTY_TWIML, { status: 200, headers: { "Content-Type": "text/xml" } });
   }
@@ -160,17 +160,7 @@ class SmsChannel implements Channel {
   private async getState(remoteE164: string): Promise<ChatState> {
     let state = this.chats.get(remoteE164);
     if (state) return state;
-    const prefix = `sms-${remoteE164}`;
-    const idx = await Session.getLatestRoomIndex(prefix);
-    const room = `${prefix}-${idx}`;
-    log.info({ remoteE164, room }, "sms: creating chat engine");
-    const engine = await createChatEngine({
-      room,
-      channel: "sms",
-      resume: true,
-      mcpServers: getMcpServers(),
-    });
-    state = { engine, roomIndex: idx, lock: Promise.resolve() };
+    state = await openChatEngine(`sms-${remoteE164}`, () => ({ channel: "sms", mcpServers: getMcpServers() }));
     this.chats.set(remoteE164, state);
     return state;
   }
@@ -183,7 +173,7 @@ export function createSmsChannel(): SmsChannel | null {
   // sms.from_number falls back to phone.from_number (same number for voice + SMS).
   const fromNumber = sms.from_number ?? phone.from_number;
   if (!fromNumber) return null;
-  return new SmsChannel(twilio, sms, fromNumber);
+  return new SmsChannel(twilio, fromNumber);
 }
 
 export type { SmsChannel };