niahere 0.3.1 → 0.3.3

package/src/mcp/tools.ts

@@ -1,497 +0,0 @@
-import { readFileSync, writeFileSync, appendFileSync, existsSync } from "fs";
-import type { ScheduleType } from "../types";
-import { basename, join } from "path";
-import { randomUUID } from "crypto";
-import { Job, Message, Session } from "../db/models";
-import { computeInitialNextRun } from "../core/scheduler";
-import { getConfig, readRawConfig, updateRawConfig, writeRawConfig } from "../utils/config";
-import { getPaths } from "../utils/paths";
-import { getChannel } from "../channels/registry";
-import { log } from "../utils/log";
-import { classifyMime } from "../utils/attachment";
-import { scanAgents } from "../core/agents";
-import { listEmployeesForMcp } from "../core/employees";
-import { resolveJobPrompt } from "../core/job-prompt";
-import { readMemory as readMemoryUtil, addMemory as addMemoryUtil } from "../utils/memory";
-import type { McpSourceContext } from "./index";
-
-export async function listJobs(): Promise<string> {
-  const jobs = await Job.list();
-  if (jobs.length === 0) return "No jobs found.";
-  const withPromptSource = jobs.map((job) => {
-    const resolvedPrompt = resolveJobPrompt(job);
-    return {
-      ...job,
-      prompt: resolvedPrompt.prompt,
-      promptSource: resolvedPrompt.source,
-      promptPath: resolvedPrompt.filePath,
-    };
-  });
-  return JSON.stringify(withPromptSource, null, 2);
-}
-
-export async function addJob(args: {
-  name: string;
-  schedule: string;
-  prompt: string;
-  schedule_type?: ScheduleType;
-  always?: boolean;
-  agent?: string;
-  employee?: string;
-  model?: string;
-  stateless?: boolean;
-}): Promise<string> {
-  const scheduleType = args.schedule_type || "cron";
-  const always = args.always || false;
-  const stateless = args.stateless || false;
-  const config = getConfig();
-
-  const nextRunAt = computeInitialNextRun(scheduleType, args.schedule, config.timezone);
-  await Job.create(
-    args.name,
-    args.schedule,
-    args.prompt,
-    always,
-    scheduleType,
-    nextRunAt,
-    args.agent,
-    stateless,
-    args.model,
-    args.employee,
-  );
-  const agentNote = args.agent ? ` [agent: ${args.agent}]` : "";
-  const employeeNote = args.employee ? ` [employee: ${args.employee}]` : "";
-  const modelNote = args.model ? ` [model: ${args.model}]` : "";
-  return `Job "${args.name}" created (${scheduleType}: ${args.schedule})${agentNote}${employeeNote}${modelNote}. Next run: ${nextRunAt.toISOString()}`;
-}
-
-export async function updateJob(args: {
-  name: string;
-  schedule?: string;
-  prompt?: string;
-  always?: boolean;
-  agent?: string | null;
-  employee?: string | null;
-  model?: string | null;
-  stateless?: boolean;
-  schedule_type?: "cron" | "interval" | "once";
-}): Promise<string> {
-  const fields: Partial<{
-    schedule: string;
-    prompt: string;
-    always: boolean;
-    stateless: boolean;
-    model: string | null;
-    agent: string | null;
-    employee: string | null;
-    scheduleType: "cron" | "interval" | "once";
-  }> = {};
-  if (args.schedule) fields.schedule = args.schedule;
-  if (args.prompt) fields.prompt = args.prompt;
-  if (args.always !== undefined) fields.always = args.always;
-  if (args.stateless !== undefined) fields.stateless = args.stateless;
-  if (args.model !== undefined) fields.model = args.model;
-  if (args.agent !== undefined) fields.agent = args.agent;
-  if (args.employee !== undefined) fields.employee = args.employee;
-  if (args.schedule_type) fields.scheduleType = args.schedule_type;
-
-  if (Object.keys(fields).length === 0)
-    return "Nothing to update. Pass at least one field (schedule, prompt, always, stateless, model, agent, employee, or schedule_type).";
-
-  const updated = await Job.update(args.name, fields);
-  if (!updated) return `Job "${args.name}" not found.`;
-  if (fields.prompt !== undefined) {
-    const job = await Job.get(args.name);
-    if (job) {
-      const resolvedPrompt = resolveJobPrompt(job);
-      if (resolvedPrompt.source === "file") {
-        return `Job "${args.name}" updated. Note: runtime prompt is still overridden by ${resolvedPrompt.filePath}.`;
-      }
-    }
-  }
-  return `Job "${args.name}" updated.`;
-}
-
-export async function removeJob(name: string): Promise<string> {
-  const removed = await Job.remove(name);
-  return removed ? `Job "${name}" removed.` : `Job "${name}" not found.`;
-}
-
-export async function enableJob(name: string): Promise<string> {
-  const updated = await Job.update(name, { status: "active" });
-  if (!updated) return `Job "${name}" not found.`;
-
-  const job = await Job.get(name);
-  if (job) {
-    const config = getConfig();
-    const nextRun = computeInitialNextRun(job.scheduleType, job.schedule, config.timezone);
-    const { getSql } = await import("../db/connection");
-    await getSql()`UPDATE jobs SET next_run_at = ${nextRun} WHERE name = ${name}`;
-  }
-  return `Job "${name}" enabled.`;
-}
-
-export async function disableJob(name: string): Promise<string> {
-  const updated = await Job.update(name, { status: "disabled" });
-  return updated ? `Job "${name}" disabled.` : `Job "${name}" not found.`;
-}
-
-export async function archiveJob(name: string): Promise<string> {
-  const updated = await Job.update(name, { status: "archived" });
-  return updated ? `Job "${name}" archived.` : `Job "${name}" not found.`;
-}
-
-export async function unarchiveJob(name: string): Promise<string> {
-  const updated = await Job.update(name, { status: "disabled" });
-  return updated ? `Job "${name}" unarchived (disabled). Enable with enable_job.` : `Job "${name}" not found.`;
-}
-
-export async function runJobNow(name: string): Promise<string> {
-  const job = await Job.get(name);
-  if (!job) return `Job "${name}" not found.`;
-
-  const { getSql } = await import("../db/connection");
-  await getSql()`UPDATE jobs SET next_run_at = NOW() WHERE name = ${name}`;
-  return `Job "${name}" queued for immediate execution.`;
-}
-
-/** 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 {
-    // Handle media attachment if provided
-    if (mediaPath) {
-      if (!existsSync(mediaPath)) {
-        if (messageId) await Message.updateDeliveryStatus(messageId, "failed").catch(() => {});
-        return `Failed to send: file not found: ${mediaPath}`;
-      }
-      const data = readFileSync(mediaPath);
-      const mimeType = guessMime(mediaPath);
-      const filename = basename(mediaPath);
-
-      if (useThread && channel?.sendMediaToThread) {
-        await channel.sendMediaToThread(sourceCtx!.slackChannelId!, data, mimeType, filename, sourceCtx!.slackThreadTs);
-      } else if (channel?.sendMedia) {
-        await channel.sendMedia(data, mimeType, filename);
-      } else {
-        await sendMediaDirect(channelTarget, data, mimeType, filename);
-      }
-
-      // Also send text if provided (as a separate message)
-      if (text) {
-        if (useThread && channel?.sendToThread) {
-          await channel.sendToThread(sourceCtx!.slackChannelId!, text, sourceCtx!.slackThreadTs);
-        } else if (channel?.sendMessage) {
-          await channel.sendMessage(text);
-        } else {
-          await sendDirect(channelTarget, text);
-        }
-      }
-    } else {
-      if (useThread && channel?.sendToThread) {
-        await channel.sendToThread(sourceCtx!.slackChannelId!, text, sourceCtx!.slackThreadTs);
-      } else if (channel?.sendMessage) {
-        await channel.sendMessage(text);
-      } else {
-        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) {
-    // Mark as failed
-    if (messageId) {
-      await Message.updateDeliveryStatus(messageId, "failed").catch(() => {});
-    }
-    const msg = err instanceof Error ? err.message : String(err);
-    return `Failed to send: ${msg}`;
-  }
-}
-
-export async function listMessages(limit = 20, room?: string): Promise<string> {
-  const messages = await Message.getRecent(limit, room);
-  if (messages.length === 0) return "No messages found.";
-  return JSON.stringify(messages, null, 2);
-}
-
-export async function listSessions(limit = 10, room?: string): Promise<string> {
-  const sessions = await Session.listRecent(limit, room);
-  if (sessions.length === 0) return "No sessions found.";
-  return JSON.stringify(sessions, null, 2);
-}
-
-export async function searchMessages(query: string, limit = 20, room?: string): Promise<string> {
-  const results = await Message.search(query, limit, room);
-  if (results.length === 0) return "No matching messages found.";
-  return JSON.stringify(results, null, 2);
-}
-
-export async function readSession(sessionId: string): Promise<string> {
-  const messages = await Message.getBySession(sessionId);
-  if (messages.length === 0) return "Session not found or has no messages.";
-  return JSON.stringify(messages, null, 2);
-}
-
-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 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.`;
-}
-
-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 a channels.phone block to ~/.niahere/config.yaml with twilio_sid, twilio_secret, from_number, public_base_url, openai_api_key (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)}`;
-  }
-}