niahere 0.3.1 → 0.3.3

package/package.json

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

package/src/channels/common/chat-session.ts

@@ -0,0 +1,56 @@
+/**
+ * Shared chat-engine lifecycle helpers used by the message-driven
+ * channels (telegram, slack, sms, whatsapp). Each channel keeps its
+ * own `Map<senderKey, ChatState>`; these helpers cover the bits that
+ * were copy-pasted between them:
+ *
+ *   - resolve the latest room index for a prefix and open a fresh engine
+ *   - rotate to a new room (for `/reset` / `/new` / `/restart`), persisting
+ *     a placeholder session so the new index survives daemon restarts
+ *   - chain work onto a per-sender lock so messages from the same sender
+ *     don't race
+ *
+ * The caller supplies a builder lambda for the EngineOptions so channels
+ * that need room-aware fields (e.g. Slack's per-room `mcpServers`) can
+ * compute them with the resolved room name. Channels with static options
+ * just ignore the `room` argument in their builder.
+ */
+import { createChatEngine } from "../../chat/engine";
+import { Session } from "../../db/models";
+import { log } from "../../utils/log";
+import type { ChatState } from "../../types";
+import type { EngineOptions } from "../../types/engine";
+
+type EngineFactory = (room: string) => Omit<EngineOptions, "room" | "resume">;
+
+/** Open (or resume) a chat engine for `prefix`. The resulting ChatState is the caller's to cache. */
+export async function openChatEngine(prefix: string, buildOpts: EngineFactory): Promise<ChatState> {
+  const roomIndex = await Session.getLatestRoomIndex(prefix);
+  const room = `${prefix}-${roomIndex}`;
+  const opts = buildOpts(room);
+  log.info({ channel: opts.channel, room }, "chat-session: opening engine");
+  const engine = await createChatEngine({ ...opts, room, resume: true });
+  return { engine, roomIndex, lock: Promise.resolve() };
+}
+
+/** Rotate to a fresh room. Closes `prev` if supplied, persists a placeholder Session so the index survives restarts. */
+export async function rotateRoom(
+  prefix: string,
+  prev: ChatState | undefined,
+  buildOpts: EngineFactory,
+): Promise<ChatState> {
+  if (prev) prev.engine.close();
+  const prevIdx = await Session.getLatestRoomIndex(prefix);
+  const roomIndex = prevIdx + 1;
+  const room = `${prefix}-${roomIndex}`;
+  await Session.create(`placeholder-${room}`, room);
+  const opts = buildOpts(room);
+  log.info({ channel: opts.channel, room }, "chat-session: rotated room");
+  const engine = await createChatEngine({ ...opts, room, resume: false });
+  return { engine, roomIndex, lock: Promise.resolve() };
+}
+
+/** Serialize `fn` onto `state.lock`. Both success and failure forward so a thrown error doesn't poison the chain. */
+export function chainLock(state: ChatState, fn: () => Promise<void>): void {
+  state.lock = state.lock.then(fn, fn);
+}

package/src/channels/phone/index.ts

@@ -22,7 +22,7 @@
  *   - consult.ts           — escape hatch to Claude for memory-aware reasoning
  */
 import type { ServerWebSocket } from "bun";
-import type { Channel, PhoneConfig, TwilioConfig } from "../../types";
+import type { Channel, Outbound, PhoneConfig, TwilioConfig } from "../../types";
 import { getConfig } from "../../utils/config";
 import { log } from "../../utils/log";
 import { getChannel } from "../registry";
@@ -66,7 +66,7 @@ const HARD_MAX_MINUTES = 30;
 const WS_PATH = "/twilio/voice/stream";
 
 class PhoneChannel implements Channel {
-  name = "phone";
+  name = "phone" as const;
   private readonly phone: PhoneConfig;
   private readonly twilio: TwilioConfig;
   private readonly pending = new Map<string, PendingCall>();
@@ -92,7 +92,7 @@ class PhoneChannel implements Channel {
 
     server.registerHttp("/twilio/voice/incoming", (req, ctx) => this.handleIncoming(req, ctx.params));
     server.registerHttp("/twilio/voice/outbound", (req, ctx) => this.handleOutboundTwiml(req, ctx.params));
-    server.registerHttp("/twilio/voice/status", (req, ctx) => this.handleStatus(ctx.params), {
+    server.registerHttp("/twilio/voice/status", (_req, ctx) => this.handleStatus(ctx.params), {
       dedupOn: "CallSid",
     });
 
@@ -127,6 +127,15 @@ class PhoneChannel implements Channel {
     // it running here would block SMS/WhatsApp if they're also bound to it.
   }
 
+  /**
+   * Phone is voice-only — agent-initiated text/media doesn't have a sensible
+   * delivery shape over Twilio Voice. Callers that want a text notification
+   * about a call should target a text channel (telegram, slack, whatsapp).
+   */
+  async deliver(_out: Outbound): Promise<void> {
+    throw new Error("phone: text/media delivery is not supported — use a text channel or placeCall() for voice");
+  }
+
   // --- Outbound entrypoint (used by the place_call MCP tool and CLI test) ---
 
   async placeCall(opts: {
@@ -186,7 +195,7 @@ class PhoneChannel implements Channel {
     if (!allowed) {
       log.warn({ from, callSid }, "phone: rejecting unauthorized caller");
       getChannel("telegram")
-        ?.sendMessage?.(`Phone: rejected call from ${from} (CallSid ${callSid})`)
+        ?.deliver({ text: `Phone: rejected call from ${from} (CallSid ${callSid})` })
         .catch(() => {});
       return twimlResponse(sayAndHangupTwiML("Sorry, this line is not currently accepting calls. Goodbye."));
     }

package/src/channels/phone/tools.ts

@@ -47,8 +47,8 @@ export function buildPhoneTools(ctx: ToolContextOpts): PhoneToolDefinition[] {
       handler: async (args) => {
         const text = String(args.text || "").slice(0, 1000);
         const tg = getChannel("telegram");
-        if (!tg || !tg.sendMessage) return "telegram unavailable";
-        await tg.sendMessage(`[Phone] ${text}`);
+        if (!tg) return "telegram unavailable";
+        await tg.deliver({ text: `[Phone] ${text}` });
         return "sent";
       },
     },

package/src/channels/slack/attachments.ts

@@ -0,0 +1,142 @@
+/**
+ * Disk-backed cache for Slack file attachments. Slack file URLs expire and
+ * require Authorization on download, so we fetch once per (scope, url),
+ * write the bytes + metadata to `~/.niahere/tmp/attachments/<scope>/`, and
+ * read from disk on subsequent references. Survives daemon restarts via
+ * the metadata sidecar.
+ */
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import type { Attachment, AttachmentType } from "../../types";
+import { classifyMime, prepareImage, validateAttachment } from "../../utils/attachment";
+import { getNiaHome } from "../../utils/paths";
+import { log } from "../../utils/log";
+
+interface CachedFile {
+  path: string;
+  type: AttachmentType;
+  mimeType: string;
+  filename?: string;
+}
+
+function urlHash(url: string): string {
+  return createHash("sha256").update(url).digest("hex").slice(0, 16);
+}
+
+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);
+}
+
+function loadCached(entry: CachedFile): Attachment {
+  return {
+    type: entry.type,
+    data: readFileSync(entry.path),
+    mimeType: entry.mimeType,
+    filename: entry.filename,
+    sourcePath: entry.path,
+  };
+}
+
+export class SlackAttachmentCache {
+  private readonly attachRoot: string;
+  private readonly fileIndex = new Map<string, CachedFile>();
+
+  constructor(private readonly botToken: string) {
+    this.attachRoot = join(getNiaHome(), "tmp", "attachments");
+    mkdirSync(this.attachRoot, { recursive: true });
+  }
+
+  async extract(files: any[], scope: string): Promise<Attachment[]> {
+    const attachments: Attachment[] = [];
+    const scopedDir = this.dirForScope(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;
+
+      const indexedKey = `${scope}:${file.url_private_download}`;
+      const cached = this.fileIndex.get(indexedKey);
+      if (cached && existsSync(cached.path)) {
+        attachments.push(loadCached(cached));
+        continue;
+      }
+
+      const hash = urlHash(file.url_private_download);
+      const ext = cacheExtension(file.name, mime, attType);
+      const diskPath = join(scopedDir, `${hash}.${ext}`);
+      const metaPath = join(scopedDir, `${hash}.meta.json`);
+
+      // Re-load from disk if a prior daemon run already wrote this file.
+      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,
+          };
+          this.fileIndex.set(indexedKey, entry);
+          attachments.push(loadCached(entry));
+          continue;
+        } catch {
+          // Corrupt meta — re-download.
+        }
+      }
+
+      try {
+        const raw = await this.download(file.url_private_download);
+        const error = validateAttachment(raw);
+        if (error) {
+          log.warn({ file: file.name, error }, "skipping slack attachment");
+          continue;
+        }
+        let data = raw;
+        let finalMime = mime;
+        if (attType === "image") {
+          const prepared = await prepareImage(raw, mime);
+          data = prepared.data;
+          finalMime = prepared.mimeType;
+        }
+
+        writeFileSync(diskPath, data);
+        writeFileSync(metaPath, JSON.stringify({ type: attType, mimeType: finalMime, filename: file.name }));
+        const entry: CachedFile = { path: diskPath, type: attType, mimeType: finalMime, filename: file.name };
+        this.fileIndex.set(indexedKey, entry);
+
+        attachments.push({
+          type: attType,
+          data,
+          mimeType: finalMime,
+          filename: file.name,
+          sourcePath: diskPath,
+        });
+      } catch (err) {
+        log.warn({ err, file: file.name }, "failed to download slack file");
+      }
+    }
+    return attachments;
+  }
+
+  private dirForScope(scope: string): string {
+    const safeScope = scope.replace(/[^a-zA-Z0-9._-]/g, "_");
+    const dir = join(this.attachRoot, safeScope);
+    mkdirSync(dir, { recursive: true });
+    return dir;
+  }
+
+  private async download(url: string): Promise<Buffer> {
+    const resp = await fetch(url, { headers: { Authorization: `Bearer ${this.botToken}` } });
+    if (!resp.ok) throw new Error(`Slack file download failed: ${resp.status}`);
+    return Buffer.from(await resp.arrayBuffer());
+  }
+}

package/src/channels/slack/watch.ts

@@ -0,0 +1,73 @@
+/**
+ * Slack watch channels: hot-reloads `channels.slack.watch` entries from
+ * config.yaml (plus any behavior files they reference) on each inbound
+ * message, gated by an mtime check so we don't re-parse config on every
+ * call. Keyed by `channel_id` (the part before `#` in the config key).
+ */
+import { statSync } from "fs";
+import { getConfig, resetConfig } from "../../utils/config";
+import { getPaths } from "../../utils/paths";
+import { log } from "../../utils/log";
+import { resolveWatchBehavior } from "../../utils/watches";
+
+export interface WatchEntry {
+  name: string;
+  behavior: string;
+}
+
+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 {
+      // missing file — ignore
+    }
+  }
+  return max;
+}
+
+export class SlackWatchReloader {
+  private cache = new Map<string, WatchEntry>();
+  private filePaths: string[] = [];
+  private lastReloadMtime = 0;
+
+  /** Re-parse config + behavior files if any have been modified since the last read. */
+  reload(): Map<string, WatchEntry> {
+    const configPath = getPaths().config;
+    const mtime = maxMtime([configPath, ...this.filePaths]);
+    if (mtime === 0) return this.cache;
+    if (mtime === this.lastReloadMtime) return this.cache;
+
+    resetConfig();
+    const watch = getConfig().channels.slack.watch;
+    const fresh = new Map<string, WatchEntry>();
+    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 !== this.cache.size) {
+      log.info({ count: fresh.size }, "slack: watch channels reloaded");
+    }
+
+    this.cache = fresh;
+    this.filePaths = freshFiles;
+    this.lastReloadMtime = maxMtime([configPath, ...freshFiles]);
+    return this.cache;
+  }
+}