agent-relay-server 0.101.1 → 0.102.0

package/src/mcp-ntfy-tools.ts

@@ -1,35 +0,0 @@
-import { MAX_BODY_BYTES } from "./config";
-import { sendNtfyNotification, NTFY_PRIORITIES, type NtfyNotificationResult, type NtfyPriority } from "./ntfy";
-import { optionalEnum } from "./validation";
-import type { ToolDefinition } from "./mcp/types";
-import { optionalString, optionalStringArray, stringField } from "./mcp/validation";
-
-export const NTFY_TOOLS: ToolDefinition[] = [
-  {
-    name: "relay_notify_ntfy",
-    description: "Send an egress-only ntfy notification to the configured operator topic. Supports title, body, priority min→urgent, optional tags, and click-through link.",
-    requiredScopes: ["notifications:write"],
-    inputSchema: {
-      type: "object",
-      properties: {
-        title: { type: "string" },
-        body: { type: "string" },
-        priority: { type: "string", enum: NTFY_PRIORITIES },
-        tags: { type: "array", items: { type: "string" } },
-        click: { type: "string" },
-      },
-      required: ["title", "body"],
-      additionalProperties: false,
-    },
-  },
-];
-
-export async function relayNotifyNtfy(args: Record<string, unknown>): Promise<NtfyNotificationResult> {
-  return sendNtfyNotification({
-    title: stringField(args.title, "title", { required: true, max: 200 }),
-    body: stringField(args.body, "body", { required: true, maxBytes: MAX_BODY_BYTES }),
-    priority: optionalEnum(args.priority, "priority", NTFY_PRIORITIES) as NtfyPriority | undefined,
-    tags: optionalStringArray(args.tags, "tags"),
-    click: optionalString(args.click, "click", 1000),
-  });
-}

package/src/ntfy.ts

@@ -1,222 +0,0 @@
-import { Buffer } from "node:buffer";
-import { MAX_BODY_BYTES } from "./config";
-import { getConfig } from "./config-store";
-import { upsertAgent, ValidationError } from "./db";
-import { registerChannelTypeSetting } from "./settings/modules";
-import { cleanString, cleanStringArray } from "./validation";
-import { errMessage, isRecord, type JSONSchema } from "agent-relay-sdk";
-
-export const NTFY_CONFIG_NAMESPACE = "channel-type";
-export const NTFY_CONFIG_KEY = "ntfy";
-export const NTFY_CHANNEL_ID = "ntfy:default";
-
-export const NTFY_PRIORITIES = ["min", "low", "default", "high", "urgent"] as const;
-export type NtfyPriority = (typeof NTFY_PRIORITIES)[number];
-
-export interface NtfyChannelConfig {
-  enabled: boolean;
-  serverUrl: string;
-  topic: string;
-  tokenEnv?: string;
-  username?: string;
-  passwordEnv?: string;
-  defaultTags: string[];
-  defaultClick?: string;
-  timeoutMs: number;
-}
-
-export interface NtfyNotificationInput {
-  title: string;
-  body: string;
-  priority?: NtfyPriority;
-  tags?: string[];
-  click?: string;
-}
-
-export interface NtfyNotificationResult {
-  ok: true;
-  status: number;
-  channelId: string;
-  topic: string;
-  priority: NtfyPriority;
-  tags: string[];
-}
-
-const DEFAULT_NTFY_CONFIG: NtfyChannelConfig = {
-  enabled: false,
-  serverUrl: "",
-  topic: "",
-  defaultTags: [],
-  timeoutMs: 15_000,
-};
-
-const NTFY_CONFIG_SCHEMA: JSONSchema = {
-  type: "object",
-  additionalProperties: false,
-  required: ["enabled", "serverUrl", "topic"],
-  properties: {
-    enabled: { type: "boolean" },
-    serverUrl: { type: "string", maxLength: 500 },
-    topic: { type: "string", maxLength: 200 },
-    tokenEnv: { type: "string", maxLength: 120, pattern: "^[A-Z0-9_]+$" },
-    username: { type: "string", maxLength: 120 },
-    passwordEnv: { type: "string", maxLength: 120, pattern: "^[A-Z0-9_]+$" },
-    defaultTags: { type: "array", maxItems: 20, items: { type: "string", maxLength: 40 } },
-    defaultClick: { type: "string", maxLength: 1000 },
-    timeoutMs: { type: "integer", minimum: 1_000, maximum: 60_000 },
-  },
-};
-
-registerChannelTypeSetting({
-  type: NTFY_CONFIG_KEY,
-  schema: NTFY_CONFIG_SCHEMA,
-  defaults: DEFAULT_NTFY_CONFIG,
-  display: {
-    label: "ntfy outgoing channel",
-    description: "Configures the built-in egress-only ntfy notification channel.",
-    order: 121,
-  },
-});
-
-export function getNtfyConfig(): NtfyChannelConfig {
-  const stored = getConfig<Partial<NtfyChannelConfig>>(NTFY_CONFIG_NAMESPACE, NTFY_CONFIG_KEY)?.value;
-  return normalizeNtfyConfig({ ...DEFAULT_NTFY_CONFIG, ...(isRecord(stored) ? stored : {}) });
-}
-
-export async function sendNtfyNotification(input: NtfyNotificationInput): Promise<NtfyNotificationResult> {
-  const config = getNtfyConfig();
-  validateSendConfig(config);
-  const title = cleanString(input.title, "title", { required: true, max: 200 })!;
-  const body = cleanString(input.body, "body", { required: true, max: MAX_BODY_BYTES })!;
-  const priority = input.priority ?? "default";
-  const tags = [...new Set([...(config.defaultTags ?? []), ...(input.tags ?? [])].map((tag) => tag.trim()).filter(Boolean))];
-  const click = cleanString(input.click ?? config.defaultClick, "click", { max: 1000 });
-  const url = ntfyTopicUrl(config);
-  const headers = ntfyHeaders({ config, title, priority, tags, click });
-
-  ensureNtfyChannelRegistered(config);
-
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), config.timeoutMs);
-  let response: Response;
-  try {
-    response = await fetch(url, {
-      method: "POST",
-      headers,
-      body,
-      signal: controller.signal,
-    });
-  } catch (error) {
-    if (controller.signal.aborted) throw new Error(`ntfy notify timed out after ${config.timeoutMs}ms`);
-    throw new Error(`ntfy notify failed: ${errMessage(error)}`);
-  } finally {
-    clearTimeout(timeout);
-  }
-
-  if (!response.ok) {
-    const text = await response.text().catch(() => "");
-    throw new Error(`ntfy notify failed: HTTP ${response.status}${text ? `: ${text.slice(0, 300)}` : ""}`);
-  }
-
-  return { ok: true, status: response.status, channelId: NTFY_CHANNEL_ID, topic: config.topic, priority, tags };
-}
-
-function normalizeNtfyConfig(value: unknown): NtfyChannelConfig {
-  if (!isRecord(value)) throw new ValidationError("ntfy channel config must be an object");
-  const timeoutMs = value.timeoutMs === undefined ? DEFAULT_NTFY_CONFIG.timeoutMs : value.timeoutMs;
-  if (typeof value.enabled !== "boolean") throw new ValidationError("ntfy.enabled must be a boolean");
-  if (typeof timeoutMs !== "number" || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1_000 || timeoutMs > 60_000) {
-    throw new ValidationError("ntfy.timeoutMs must be an integer between 1000 and 60000");
-  }
-  return {
-    enabled: value.enabled,
-    serverUrl: cleanString(value.serverUrl, "ntfy.serverUrl", { max: 500 }) ?? "",
-    topic: cleanString(value.topic, "ntfy.topic", { max: 200 }) ?? "",
-    tokenEnv: cleanString(value.tokenEnv, "ntfy.tokenEnv", { max: 120 }),
-    username: cleanString(value.username, "ntfy.username", { max: 120 }),
-    passwordEnv: cleanString(value.passwordEnv, "ntfy.passwordEnv", { max: 120 }),
-    defaultTags: cleanStringArray(value.defaultTags, "ntfy.defaultTags", { itemMax: 40, maxItems: 20 }) ?? [],
-    defaultClick: cleanString(value.defaultClick, "ntfy.defaultClick", { max: 1000 }),
-    timeoutMs,
-  };
-}
-
-function validateSendConfig(config: NtfyChannelConfig): void {
-  if (!config.enabled) throw new ValidationError("ntfy channel is disabled");
-  if (!config.serverUrl || !config.topic) {
-    throw new ValidationError("ntfy channel requires channel-type/ntfy serverUrl and topic");
-  }
-  if (config.topic.includes("/") || config.topic.includes("?") || config.topic.includes("#")) {
-    throw new ValidationError("ntfy.topic must be a single topic name, not a path or URL");
-  }
-  if (config.tokenEnv && (config.username || config.passwordEnv)) {
-    throw new ValidationError("ntfy auth must use tokenEnv or username/passwordEnv, not both");
-  }
-  if (config.passwordEnv && !config.username) throw new ValidationError("ntfy.username required when passwordEnv is set");
-}
-
-function ntfyTopicUrl(config: NtfyChannelConfig): string {
-  let base: URL;
-  try {
-    base = new URL(config.serverUrl.endsWith("/") ? config.serverUrl : `${config.serverUrl}/`);
-  } catch {
-    throw new ValidationError("ntfy.serverUrl must be a valid URL");
-  }
-  return new URL(encodeURIComponent(config.topic), base).toString();
-}
-
-function ntfyHeaders(input: {
-  config: NtfyChannelConfig;
-  title: string;
-  priority: NtfyPriority;
-  tags: string[];
-  click?: string;
-}): Record<string, string> {
-  const headers: Record<string, string> = {
-    Title: input.title,
-    Priority: String(priorityValue(input.priority)),
-  };
-  if (input.tags.length) headers.Tags = input.tags.join(",");
-  if (input.click) headers.Click = input.click;
-  const authorization = authHeader(input.config);
-  if (authorization) headers.Authorization = authorization;
-  return headers;
-}
-
-function authHeader(config: NtfyChannelConfig): string | undefined {
-  if (config.tokenEnv) {
-    const token = cleanString(process.env[config.tokenEnv], config.tokenEnv, { required: true, max: 4_000 })!;
-    return `Bearer ${token}`;
-  }
-  if (config.username && config.passwordEnv) {
-    const password = cleanString(process.env[config.passwordEnv], config.passwordEnv, { required: true, max: 4_000 })!;
-    return `Basic ${Buffer.from(`${config.username}:${password}`).toString("base64")}`;
-  }
-  return undefined;
-}
-
-function priorityValue(priority: NtfyPriority): number {
-  return NTFY_PRIORITIES.indexOf(priority) + 1;
-}
-
-function ensureNtfyChannelRegistered(config: NtfyChannelConfig): void {
-  upsertAgent({
-    id: NTFY_CHANNEL_ID,
-    name: "ntfy",
-    kind: "channel",
-    tags: ["channel", "ntfy", "channel:ntfy"],
-    capabilities: ["channel", "ntfy", "notify"],
-    status: "online",
-    ready: true,
-    meta: {
-      kind: "channel",
-      provider: "ntfy",
-      accountId: "default",
-      channelType: "ntfy",
-      transport: "ntfy",
-      direction: "outbound",
-      displayName: "ntfy",
-      topicChannels: [config.topic],
-    },
-  });
-}