niahere 0.3.2 → 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.`;
+}