niahere 0.3.1 → 0.3.3

package/src/mcp/tools/misc.ts

@@ -0,0 +1,63 @@
+import { appendFileSync } from "fs";
+import { join } from "path";
+import { getPaths } from "../../utils/paths";
+import { scanAgents } from "../../core/agents";
+import { listEmployeesForMcp } from "../../core/employees";
+import { readMemory as readMemoryUtil, addMemory as addMemoryUtil } from "../../utils/memory";
+
+export function addRule(rule: string): string {
+  const { selfDir } = getPaths();
+  const rulesPath = join(selfDir, "rules.md");
+  const line = `\n- ${rule}\n`;
+  appendFileSync(rulesPath, line, "utf8");
+  return `Rule added to rules.md. Takes effect on next new session.`;
+}
+
+export const readMemory = readMemoryUtil;
+export const addMemory = addMemoryUtil;
+
+export function listAgents(): string {
+  const agents = scanAgents();
+  if (agents.length === 0) return "No agents found.";
+  return JSON.stringify(
+    agents.map((a) => ({
+      name: a.name,
+      description: a.description,
+      model: a.model,
+      source: a.source,
+    })),
+    null,
+    2,
+  );
+}
+
+export function listEmployees(): string {
+  return listEmployeesForMcp();
+}
+
+export async function placeCall(args: {
+  number: string;
+  goal: string;
+  context?: string;
+  max_minutes?: number;
+  voice?: string;
+}): Promise<string> {
+  // Dynamic import avoids a static cycle with channels/phone -> mcp/tools.
+  const { getPhoneChannel } = await import("../../channels/phone");
+  const phone = getPhoneChannel();
+  if (!phone) {
+    return "Phone channel is not configured. Add channels.twilio.{sid, secret, public_base_url} and channels.phone.{from_number, openai_api_key} to ~/.niahere/config.yaml (or set the matching env vars in .env), then restart the daemon.";
+  }
+  try {
+    const result = await phone.placeCall({
+      number: args.number,
+      goal: args.goal,
+      context: args.context,
+      maxMinutes: args.max_minutes,
+      voice: args.voice,
+    });
+    return `Call placed. callSid=${result.callSid} status=${result.status}. Transcript will land in messages once the call completes.`;
+  } catch (err) {
+    return `place_call failed: ${err instanceof Error ? err.message : String(err)}`;
+  }
+}

package/src/mcp/tools/send.ts

@@ -0,0 +1,202 @@
+import { readFileSync, existsSync } from "fs";
+import { basename } from "path";
+import { randomUUID } from "crypto";
+import { Message, Session } from "../../db/models";
+import { getConfig } from "../../utils/config";
+import { getChannel } from "../../channels/registry";
+import { log } from "../../utils/log";
+import type { Recipient } from "../../types";
+import type { McpSourceContext } from "../index";
+
+/** Guess MIME type from file extension. */
+export function guessMime(filePath: string): string {
+  const ext = filePath.split(".").pop()?.toLowerCase();
+  const map: Record<string, string> = {
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    png: "image/png",
+    gif: "image/gif",
+    webp: "image/webp",
+    txt: "text/plain",
+    md: "text/markdown",
+    csv: "text/csv",
+    json: "application/json",
+    pdf: "application/pdf",
+    html: "text/html",
+  };
+  return map[ext || ""] || "application/octet-stream";
+}
+
+/** Send directly via API when no started channel is available (e.g. CLI `nia send`). */
+async function sendDirect(target: string, text: string): Promise<void> {
+  const config = getConfig();
+
+  if (target === "telegram") {
+    const token = config.channels.telegram.bot_token;
+    const chatId = config.channels.telegram.chat_id;
+    if (!token) throw new Error("Telegram not configured (no bot token)");
+    if (!chatId) throw new Error("No Telegram chat ID — send a message to the bot first");
+    const { Bot } = await import("grammy");
+    const bot = new Bot(token);
+    await bot.api.sendMessage(chatId, text);
+    return;
+  }
+
+  if (target === "slack") {
+    const token = config.channels.slack.bot_token;
+    const recipient = config.channels.slack.dm_user_id;
+    if (!token) throw new Error("Slack not configured (no bot token)");
+    if (!recipient) throw new Error("No Slack recipient — set dm_user_id in config");
+    const { App } = await import("@slack/bolt");
+    const app = new App({ token, signingSecret: "unused" });
+    await app.client.chat.postMessage({ token, channel: recipient, text });
+    return;
+  }
+
+  throw new Error(`Channel "${target}" not configured`);
+}
+
+/** Send media directly via API (no started channel). */
+async function sendMediaDirect(target: string, data: Buffer, mimeType: string, filename?: string): Promise<void> {
+  const config = getConfig();
+
+  if (target === "telegram") {
+    const token = config.channels.telegram.bot_token;
+    const chatId = config.channels.telegram.chat_id;
+    if (!token) throw new Error("Telegram not configured (no bot token)");
+    if (!chatId) throw new Error("No Telegram chat ID — send a message to the bot first");
+    const { Bot, InputFile } = await import("grammy");
+    const bot = new Bot(token);
+    const file = new InputFile(data, filename);
+    if (mimeType.startsWith("image/")) {
+      await bot.api.sendPhoto(chatId, file);
+    } else {
+      await bot.api.sendDocument(chatId, file);
+    }
+    return;
+  }
+
+  if (target === "slack") {
+    const token = config.channels.slack.bot_token;
+    const recipient = config.channels.slack.dm_user_id;
+    if (!token) throw new Error("Slack not configured (no bot token)");
+    if (!recipient) throw new Error("No Slack recipient — set dm_user_id in config");
+    const { App } = await import("@slack/bolt");
+    const app = new App({ token, signingSecret: "unused" });
+    await app.client.filesUploadV2({
+      channel_id: recipient,
+      file: data,
+      filename: filename || `file.${mimeType.split("/")[1] || "bin"}`,
+    });
+    return;
+  }
+
+  throw new Error(`Channel "${target}" not configured`);
+}
+
+export async function sendMessage(
+  text: string,
+  channelName?: string,
+  mediaPath?: string,
+  sourceCtx?: McpSourceContext,
+  target: "auto" | "dm" | "thread" = "auto",
+): Promise<string> {
+  const config = getConfig();
+  const channelTarget = channelName || config.channels.default;
+
+  // Use started channel if available (daemon), otherwise call API directly (CLI)
+  const channel = getChannel(channelTarget);
+
+  // Resolve send target: thread reply vs DM
+  // "auto" = if we have thread context, reply there; otherwise DM
+  // "dm" = always DM the owner
+  // "thread" = reply in current thread (falls back to DM if no thread context)
+  const hasThreadCtx = sourceCtx?.slackChannelId && sourceCtx?.slackThreadTs;
+  const useThread = (target === "auto" && hasThreadCtx) || (target === "thread" && hasThreadCtx);
+
+  // Compute room prefix for DB storage BEFORE sending
+  let roomPrefix: string | undefined;
+  if (channelTarget === "telegram") {
+    const chatId = config.channels.telegram.chat_id;
+    if (chatId) roomPrefix = `tg-${chatId}`;
+  } else if (channelTarget === "slack") {
+    if (useThread && sourceCtx?.room) {
+      // Replying in-thread: use the source session's room prefix
+      roomPrefix = sourceCtx.room.replace(/-\d+$/, "");
+    } else {
+      const dmUserId = config.channels.slack.dm_user_id;
+      if (dmUserId) {
+        roomPrefix = `slack-dm-${dmUserId}`;
+      }
+    }
+  }
+
+  // Save pending notification to DB before sending (avoids race with fast replies)
+  let messageId: number | undefined;
+  if (roomPrefix) {
+    try {
+      const idx = await Session.getLatestRoomIndex(roomPrefix);
+      const fullRoom = `${roomPrefix}-${idx}`;
+      let sessionId = await Session.getLatest(fullRoom);
+
+      // Auto-create a backing session if none exists (e.g. first proactive DM)
+      if (!sessionId) {
+        sessionId = randomUUID();
+        await Session.create(sessionId, fullRoom);
+      }
+
+      const content = mediaPath ? `${text} [media: ${basename(mediaPath)}]` : text;
+      const source = sourceCtx?.jobName ? `job:${sourceCtx.jobName}` : sourceCtx?.channel || undefined;
+      const metadata: Record<string, unknown> = { kind: useThread ? "thread_reply" : "notification" };
+      if (source) metadata.source = source;
+
+      messageId = await Message.save({
+        sessionId,
+        room: fullRoom,
+        sender: "nia",
+        content,
+        isFromAgent: true,
+        deliveryStatus: "pending",
+        metadata,
+      });
+    } catch (err) {
+      log.warn({ err, channelTarget, roomPrefix }, "sendMessage: failed to save pending notification to DB");
+    }
+  }
+
+  try {
+    let media: { data: Uint8Array; mimeType: string; filename: string } | undefined;
+    if (mediaPath) {
+      if (!existsSync(mediaPath)) {
+        if (messageId) await Message.updateDeliveryStatus(messageId, "failed").catch(() => {});
+        return `Failed to send: file not found: ${mediaPath}`;
+      }
+      const buf = readFileSync(mediaPath);
+      media = { data: new Uint8Array(buf), mimeType: guessMime(mediaPath), filename: basename(mediaPath) };
+    }
+
+    const recipient: Recipient = useThread
+      ? { kind: "thread", channelId: sourceCtx!.slackChannelId!, threadTs: sourceCtx!.slackThreadTs }
+      : { kind: "owner" };
+
+    if (channel) {
+      await channel.deliver({ text: text || undefined, media, to: recipient });
+    } else {
+      // No started channel in this process (e.g. CLI `nia send` outside the daemon).
+      // Fall back to API-direct send — text-only, no thread fan-out.
+      if (media) await sendMediaDirect(channelTarget, Buffer.from(media.data), media.mimeType, media.filename);
+      if (text) await sendDirect(channelTarget, text);
+    }
+
+    // Mark as sent
+    if (messageId) {
+      await Message.updateDeliveryStatus(messageId, "sent").catch(() => {});
+    }
+
+    return mediaPath ? "Message with media sent." : "Message sent.";
+  } catch (err) {
+    if (messageId) await Message.updateDeliveryStatus(messageId, "failed").catch(() => {});
+    const errText = err instanceof Error ? err.message : String(err);
+    return `Failed to send: ${errText}`;
+  }
+}

package/src/mcp/tools/watch.ts

@@ -0,0 +1,50 @@
+import { readRawConfig, updateRawConfig, writeRawConfig } from "../../utils/config";
+
+export function addWatchChannel(name: string, behavior?: string): string {
+  const raw = readRawConfig();
+  const channels = (raw.channels || {}) as Record<string, unknown>;
+  const slack = (channels.slack || {}) as Record<string, unknown>;
+  const entry: Record<string, unknown> = { enabled: true };
+  if (behavior !== undefined && behavior !== "") entry.behavior = behavior;
+  const watch = {
+    ...((slack.watch || {}) as Record<string, unknown>),
+    [name]: entry,
+  };
+  updateRawConfig({ channels: { slack: { watch } } });
+  return `Watch channel "${name}" added (enabled). Takes effect on next message.`;
+}
+
+export function removeWatchChannel(name: string): string {
+  const raw = readRawConfig();
+  const channels = (raw.channels || {}) as Record<string, unknown>;
+  const slack = (channels.slack || {}) as Record<string, unknown>;
+  const watch = (slack.watch || {}) as Record<string, unknown>;
+  if (!watch[name]) return `Watch channel "${name}" not found.`;
+  delete watch[name];
+  writeRawConfig(raw);
+  return `Watch channel "${name}" removed. Takes effect on next message.`;
+}
+
+export function enableWatchChannel(name: string): string {
+  const raw = readRawConfig();
+  const channels = (raw.channels || {}) as Record<string, unknown>;
+  const slack = (channels.slack || {}) as Record<string, unknown>;
+  const watch = (slack.watch || {}) as Record<string, unknown>;
+  if (!watch[name]) return `Watch channel "${name}" not found.`;
+  const entry = watch[name] as Record<string, unknown>;
+  entry.enabled = true;
+  updateRawConfig({ channels: { slack: { watch } } });
+  return `Watch channel "${name}" enabled. Takes effect on next message.`;
+}
+
+export function disableWatchChannel(name: string): string {
+  const raw = readRawConfig();
+  const channels = (raw.channels || {}) as Record<string, unknown>;
+  const slack = (channels.slack || {}) as Record<string, unknown>;
+  const watch = (slack.watch || {}) as Record<string, unknown>;
+  if (!watch[name]) return `Watch channel "${name}" not found.`;
+  const entry = watch[name] as Record<string, unknown>;
+  entry.enabled = false;
+  updateRawConfig({ channels: { slack: { watch } } });
+  return `Watch channel "${name}" disabled. Takes effect on next message.`;
+}

package/src/types/channel.ts

@@ -1,13 +1,42 @@
+/**
+ * Where an outbound payload is delivered.
+ *
+ * - `owner` → the channel's configured default recipient (DM user, owner
+ *   phone number, etc.). Always supported.
+ * - `thread` → reply in a specific Slack thread. Channels that don't
+ *   support threads fall back to `owner`.
+ */
+export type Recipient = { kind: "owner" } | { kind: "thread"; channelId: string; threadTs?: string };
+
+export interface OutboundMedia {
+  data: Uint8Array;
+  mimeType: string;
+  filename?: string;
+}
+
+/**
+ * Structured payload for agent-initiated outbound messages (`send_message`
+ * MCP tool, cross-channel notifications). Replaces the old optional
+ * sendMessage / sendMedia / sendToThread / sendMediaToThread surface.
+ */
+export interface Outbound {
+  text?: string;
+  media?: OutboundMedia;
+  /** Defaults to `{ kind: "owner" }`. */
+  to?: Recipient;
+}
+
 export interface Channel {
+  /** Channel identifier. Built-in channels use the `ChannelName` literals; test fixtures may use other strings. */
   name: string;
   start(): Promise<void>;
   stop(): Promise<void>;
-  sendMessage?(text: string): Promise<void>;
-  sendMedia?(data: Buffer, mimeType: string, filename?: string): Promise<void>;
-  /** Send media to a specific channel/thread when the channel supports it. */
-  sendMediaToThread?(channelId: string, data: Buffer, mimeType: string, filename?: string, threadTs?: string): Promise<void>;
-  /** Send a message to a specific channel/thread (e.g. reply back to a Slack thread). */
-  sendToThread?(channelId: string, text: string, threadTs?: string): Promise<void>;
+  /**
+   * Deliver an outbound payload. Channels are expected to handle either
+   * a text-only, media-only, or text+media payload; format details (chunking,
+   * markdown, attachment shape) are channel-specific.
+   */
+  deliver(out: Outbound): Promise<void>;
 }
 
 export type ChannelFactory = () => Channel | null;

package/src/types/index.ts

@@ -3,7 +3,7 @@ export type { JobStatus, JobStateStatus, JobLifecycle, ScheduleType, Mode, Attac
 export type { JobInput, JobPromptSource, JobResult, ResolvedJobPrompt } from "./job";
 export type { SendResult, StreamCallback, ActivityCallback, SendCallbacks, ChatEngine, EngineOptions } from "./engine";
 export type { AuditEntry, JobState, CronState } from "./audit";
-export type { Channel, ChannelFactory } from "./channel";
+export type { Channel, ChannelFactory, Outbound, OutboundMedia, Recipient } from "./channel";
 export type { ChatState } from "./chat-state";
 export type {
   Config,

package/src/utils/attachment.ts

@@ -1,5 +1,11 @@
 import type { AttachmentType } from "../types";
-import { IMAGE_MIMES, DOCUMENT_MIMES, MAX_ATTACHMENT_SIZE, MAX_IMAGE_DIMENSION, JPEG_QUALITY } from "../constants/attachment";
+import {
+  IMAGE_MIMES,
+  DOCUMENT_MIMES,
+  MAX_ATTACHMENT_SIZE,
+  MAX_IMAGE_DIMENSION,
+  JPEG_QUALITY,
+} from "../constants/attachment";
 
 export function classifyMime(mimeType: string): AttachmentType | null {
   if (IMAGE_MIMES.has(mimeType)) return "image";
@@ -8,7 +14,7 @@ export function classifyMime(mimeType: string): AttachmentType | null {
   return "file";
 }
 
-export function validateAttachment(data: Buffer, mimeType: string): string | null {
+export function validateAttachment(data: Buffer): string | null {
   if (data.length > MAX_ATTACHMENT_SIZE) {
     return `File too large (${(data.length / 1024 / 1024).toFixed(1)}MB, max ${MAX_ATTACHMENT_SIZE / 1024 / 1024}MB)`;
   }

package/src/utils/config.ts

@@ -146,14 +146,10 @@ export function loadConfig(): Config {
   const chSms = (ch.sms || {}) as Record<string, unknown>;
   const chWa = (ch.whatsapp || {}) as Record<string, unknown>;
 
-  // Helper: read a value from `channels.twilio.<newKey>`, falling back to
-  // legacy `channels.phone.<oldKey>` (the pre-refactor location), then env.
-  const twilioOrPhone = (newKey: string, oldKey: string, envKey: string | null): string | null => {
+  const twilioField = (key: string, envKey: string | null): string | null => {
     const envVal = envKey ? process.env[envKey] : undefined;
     if (envVal) return envVal;
-    if (typeof chTw[newKey] === "string") return chTw[newKey] as string;
-    if (typeof chPh[oldKey] === "string") return chPh[oldKey] as string;
-    return null;
+    return typeof chTw[key] === "string" ? (chTw[key] as string) : null;
   };
 
   const channelsEnabled = ch.enabled !== false;
@@ -174,11 +170,7 @@ export function loadConfig(): Config {
 
   const slAppToken = process.env.SLACK_APP_TOKEN || (typeof chSl.app_token === "string" ? chSl.app_token : null);
 
-  // Legacy: channel_id was removed in favor of dm_user_id. Fall back to channel_id if dm_user_id is not set.
-  const legacyChannelId =
-    process.env.SLACK_CHANNEL_ID || (typeof chSl.channel_id === "string" ? chSl.channel_id : null);
-  const slDmUserId =
-    process.env.SLACK_DM_USER_ID || (typeof chSl.dm_user_id === "string" ? chSl.dm_user_id : null) || legacyChannelId;
+  const slDmUserId = process.env.SLACK_DM_USER_ID || (typeof chSl.dm_user_id === "string" ? chSl.dm_user_id : null);
 
   const slBotUserId = typeof chSl.bot_user_id === "string" ? chSl.bot_user_id : null;
   const slBotName = typeof chSl.bot_name === "string" ? chSl.bot_name : null;
@@ -187,15 +179,12 @@ export function loadConfig(): Config {
   const slWorkspaceUrl = typeof chSl.workspace_url === "string" ? chSl.workspace_url : null;
 
   // --- Twilio shared config (used by phone, sms, whatsapp) ---
-  // New shape: channels.twilio.{sid,secret,auth_token,owner_number,allowlist,public_base_url,port}.
-  // Legacy shape kept for one release: channels.phone.{twilio_sid,twilio_secret,twilio_auth_token,
-  // owner_number,allowlist,public_base_url,port}. Env vars take precedence over both.
-  const twSid = twilioOrPhone("sid", "twilio_sid", "TWILIO_SID");
-  const twSecret = twilioOrPhone("secret", "twilio_secret", "TWILIO_SECRET");
-  const twAuthToken = twilioOrPhone("auth_token", "twilio_auth_token", "TWILIO_AUTH_TOKEN");
-  const twOwnerNumber = twilioOrPhone("owner_number", "owner_number", "PRIMARY_PHONE_USER");
-  const twPublicBaseUrl =
-    (twilioOrPhone("public_base_url", "public_base_url", "PUBLIC_BASE_URL") || "").replace(/\/$/, "") || null;
+  // Env vars take precedence over channels.twilio.* values.
+  const twSid = twilioField("sid", "TWILIO_SID");
+  const twSecret = twilioField("secret", "TWILIO_SECRET");
+  const twAuthToken = twilioField("auth_token", "TWILIO_AUTH_TOKEN");
+  const twOwnerNumber = twilioField("owner_number", "PRIMARY_PHONE_USER");
+  const twPublicBaseUrl = (twilioField("public_base_url", "PUBLIC_BASE_URL") || "").replace(/\/$/, "") || null;
 
   const twPortRaw = process.env.PHONE_PORT ? Number(process.env.PHONE_PORT) : null;
   const twPort =
@@ -203,23 +192,19 @@ export function loadConfig(): Config {
       ? twPortRaw
       : typeof chTw.port === "number"
         ? chTw.port
-        : typeof chPh.port === "number"
-          ? chPh.port
-          : DEFAULTS.channels.twilio.port;
+        : DEFAULTS.channels.twilio.port;
 
   const twAllowlistRaw =
     process.env.PHONE_ALLOWLIST ||
     (Array.isArray(chTw.allowlist)
       ? (chTw.allowlist as unknown[]).filter((x): x is string => typeof x === "string").join(",")
-      : Array.isArray(chPh.allowlist)
-        ? (chPh.allowlist as unknown[]).filter((x): x is string => typeof x === "string").join(",")
-        : "");
+      : "");
   const twAllowlist = twAllowlistRaw
     .split(",")
     .map((s) => s.trim())
     .filter((s) => s.length > 0);
 
-  // --- Phone (voice) — env vars and new keys override legacy ---
+  // --- Phone (voice) — env vars override config ---
   const phFromNumber =
     process.env.PHONE_FROM_NUMBER || (typeof chPh.from_number === "string" ? chPh.from_number : null);
   const phOpenAiKey =