@fudrouter/fsrouter 0.6.63 → 0.6.64

package/open-sse/mcp-server/tools/memoryTools.js

@@ -1,118 +0,0 @@
-import { z } from "zod";
-import { retrieveMemories } from '../../../dist/lib/memory/retrieval.js';
-import { createMemory, deleteMemory, listMemories } from '../../../dist/lib/memory/store.js';
-import {
-  getMemorySettings,
-  toMemoryRetrievalConfig,
-  DEFAULT_MEMORY_SETTINGS
-} from '../../../dist/lib/memory/settings.js';
-const MemorySearchSchema = z.object({
-  apiKeyId: z.string(),
-  query: z.string().optional(),
-  type: z.enum(["factual", "episodic", "procedural", "semantic"]).optional(),
-  maxTokens: z.number().int().positive().max(8e3).optional(),
-  limit: z.number().int().positive().max(100).optional()
-});
-const MemoryAddSchema = z.object({
-  apiKeyId: z.string(),
-  sessionId: z.string().optional(),
-  type: z.enum(["factual", "episodic", "procedural", "semantic"]),
-  key: z.string().min(1),
-  content: z.string().min(1),
-  metadata: z.record(z.string(), z.unknown()).optional()
-});
-const MemoryClearSchema = z.object({
-  apiKeyId: z.string(),
-  type: z.enum(["factual", "episodic", "procedural", "semantic"]).optional(),
-  olderThan: z.string().optional()
-});
-const memoryTools = {
-  omniroute_memory_search: {
-    name: "omniroute_memory_search",
-    description: "Search memories by query, type, or API key with token budget enforcement",
-    scopes: ["read:memory"],
-    inputSchema: MemorySearchSchema,
-    handler: async (args) => {
-      const memorySettings = await getMemorySettings().catch(() => null) ?? DEFAULT_MEMORY_SETTINGS;
-      const baseConfig = toMemoryRetrievalConfig(memorySettings, {
-        query: args.query
-      });
-      const config = {
-        ...baseConfig,
-        enabled: true,
-        maxTokens: args.maxTokens ?? (memorySettings.enabled ? memorySettings.maxTokens : DEFAULT_MEMORY_SETTINGS.maxTokens)
-      };
-      const memories = await retrieveMemories(args.apiKeyId, config);
-      const filtered = args.type ? memories.filter((m) => m.type === args.type) : memories;
-      const limited = args.limit ? filtered.slice(0, args.limit) : filtered;
-      return {
-        success: true,
-        data: {
-          memories: limited,
-          count: limited.length,
-          totalTokens: limited.reduce((sum, m) => sum + Math.ceil(m.content.length / 4), 0)
-        }
-      };
-    }
-  },
-  omniroute_memory_add: {
-    name: "omniroute_memory_add",
-    description: "Add a new memory entry",
-    scopes: ["write:memory"],
-    inputSchema: MemoryAddSchema,
-    handler: async (args) => {
-      const memory = await createMemory({
-        apiKeyId: args.apiKeyId,
-        sessionId: args.sessionId || "",
-        type: args.type,
-        key: args.key,
-        content: args.content,
-        metadata: args.metadata || {},
-        expiresAt: null
-      });
-      return {
-        success: true,
-        data: {
-          memory,
-          message: "Memory created successfully"
-        }
-      };
-    }
-  },
-  omniroute_memory_clear: {
-    name: "omniroute_memory_clear",
-    description: "Clear memories for an API key, optionally filtered by type or age",
-    scopes: ["write:memory"],
-    inputSchema: MemoryClearSchema,
-    handler: async (args) => {
-      const result = await listMemories({
-        apiKeyId: args.apiKeyId,
-        type: args.type
-      });
-      const existingMemories = Array.isArray(result) ? result : Array.isArray(result?.data) ? result.data : [];
-      let toDelete = existingMemories;
-      if (args.olderThan) {
-        const cutoff = new Date(args.olderThan);
-        toDelete = existingMemories.filter((m) => new Date(m.createdAt) < cutoff);
-      }
-      let deletedCount = 0;
-      for (const memory of toDelete) {
-        await deleteMemory(memory.id);
-        deletedCount++;
-      }
-      return {
-        success: true,
-        data: {
-          deletedCount,
-          message: `Cleared ${deletedCount} memories`
-        }
-      };
-    }
-  }
-};
-export {
-  MemoryAddSchema,
-  MemoryClearSchema,
-  MemorySearchSchema,
-  memoryTools
-};

package/open-sse/mcp-server/tools/notionTools.js

@@ -1,101 +0,0 @@
-import { z } from "zod";
-import { createNotionClient } from '../../../dist/lib/notion/api.ts.js';
-import { getNotionToken } from '../../../dist/lib/db/notion.ts.js';
-function requireToken() {
-  const token = getNotionToken();
-  if (!token) throw new Error("Notion integration token not configured. Set it in Settings > Context Sources.");
-  return token;
-}
-const notionTools = [
-  {
-    name: "notion_search",
-    description: "Search pages and databases in Notion by text query. Returns matching page titles, IDs, and URL.",
-    scopes: ["read:notion"],
-    inputSchema: z.object({
-      query: z.string().min(1).max(500).describe("Search query text"),
-      pageSize: z.number().min(1).max(100).default(20).describe("Results per page (max 100)"),
-      startCursor: z.string().optional().describe("Pagination cursor")
-    }),
-    handler: async (args) => {
-      const client = createNotionClient(requireToken());
-      return client.searchPagesAndDatabases(args.query, args.startCursor, args.pageSize);
-    }
-  },
-  {
-    name: "notion_get_page",
-    description: "Get the content and metadata of a Notion page by its ID.",
-    scopes: ["read:notion"],
-    inputSchema: z.object({
-      pageId: z.string().min(1).describe("Notion page ID (32-char hex or UUID)")
-    }),
-    handler: async (args) => {
-      const client = createNotionClient(requireToken());
-      return client.getPage(args.pageId);
-    }
-  },
-  {
-    name: "notion_list_block_children",
-    description: "List all block children of a Notion block or page. Returns the block tree structure.",
-    scopes: ["read:notion"],
-    inputSchema: z.object({
-      blockId: z.string().min(1).describe("Block ID to fetch children from"),
-      pageSize: z.number().min(1).max(100).default(50).describe("Blocks per page (max 100)"),
-      startCursor: z.string().optional().describe("Pagination cursor")
-    }),
-    handler: async (args) => {
-      const client = createNotionClient(requireToken());
-      return client.listBlockChildren(args.blockId, args.startCursor, args.pageSize);
-    }
-  },
-  {
-    name: "notion_query_database",
-    description: "Query a Notion database with optional filters and sorts. Returns matching entries.",
-    scopes: ["read:notion"],
-    inputSchema: z.object({
-      databaseId: z.string().min(1).describe("Notion database ID (32-char hex or UUID)"),
-      filter: z.unknown().optional().describe("Optional filter object (Notion API filter format)"),
-      sorts: z.array(z.unknown()).optional().describe("Optional sort array (Notion API sort format)"),
-      pageSize: z.number().min(1).max(100).default(50).describe("Results per page (max 100)"),
-      startCursor: z.string().optional().describe("Pagination cursor")
-    }),
-    handler: async (args) => {
-      const client = createNotionClient(requireToken());
-      return client.queryDatabase(
-        args.databaseId,
-        args.filter,
-        args.sorts,
-        args.startCursor,
-        args.pageSize
-      );
-    }
-  },
-  {
-    name: "notion_get_database",
-    description: "Get metadata and schema of a Notion database by its ID.",
-    scopes: ["read:notion"],
-    inputSchema: z.object({
-      databaseId: z.string().min(1).describe("Notion database ID (32-char hex or UUID)")
-    }),
-    handler: async (args) => {
-      const client = createNotionClient(requireToken());
-      return client.getDatabase(args.databaseId);
-    }
-  },
-  {
-    name: "notion_append_blocks",
-    description: "Append block children to an existing Notion block or page. Maximum 100 blocks per request.",
-    scopes: ["write:notion"],
-    inputSchema: z.object({
-      blockId: z.string().min(1).describe("Target block or page ID to append to"),
-      children: z.array(z.unknown()).describe("Array of block objects to append"),
-      after: z.string().optional().describe("Block ID to append after (position parameter)")
-    }),
-    handler: async (args) => {
-      const client = createNotionClient(requireToken());
-      return client.appendBlocks(args.blockId, args.children, args.after);
-    }
-  }
-];
-export {
-  notionTools
-};

package/open-sse/mcp-server/tools/obsidianTools.js

@@ -1,307 +0,0 @@
-import { z } from "zod";
-import { createObsidianClient, createSyncServerClient, getSyncToken } from '../../../dist/lib/obsidian/api.ts.js';
-import {
-  getObsidianConfigForApiKey
-} from '../../../dist/lib/db/obsidian.ts.js';
-function extractApiKeyId(extra) {
-  const id = extra?.authInfo?.clientId;
-  return typeof id === "string" && id.length > 0 && id !== "anonymous" && id !== "env-key" ? id : void 0;
-}
-function requireToken(apiKeyId) {
-  const config = getObsidianConfigForApiKey(apiKeyId);
-  if (!config.token) {
-    throw new Error(
-      "Obsidian API token not configured. Set it in Settings > Context Sources" + (apiKeyId ? " or in your API key's context source settings" : "") + "."
-    );
-  }
-  return config.token;
-}
-function getClient(apiKeyId) {
-  const config = getObsidianConfigForApiKey(apiKeyId);
-  const token = requireToken(apiKeyId);
-  return createObsidianClient(token, config.baseUrl);
-}
-const obsidianTools = [
-  {
-    name: "obsidian_check_status",
-    description: "Check whether the Obsidian Local REST API is reachable and authenticated. Returns connection status.",
-    scopes: ["read:obsidian"],
-    inputSchema: z.object({}),
-    handler: async (_args, extra) => {
-      const client = getClient(extractApiKeyId(extra));
-      return client.checkStatus();
-    }
-  },
-  {
-    name: "obsidian_search_simple",
-    description: "Search note content in Obsidian vault by text query. Returns matching snippets with file paths.",
-    scopes: ["read:obsidian"],
-    inputSchema: z.object({
-      query: z.string().min(1).max(500).describe("Search query text"),
-      contextLength: z.number().min(20).max(500).default(100).describe("Characters of context around each match")
-    }),
-    handler: async (args, extra) => {
-      const client = getClient(extractApiKeyId(extra));
-      return client.searchSimple(args.query, args.contextLength);
-    }
-  },
-  {
-    name: "obsidian_search_structured",
-    description: "Search Obsidian vault using a JSON Logic expression for complex queries (and, or, regex, path filters, etc.).",
-    scopes: ["read:obsidian"],
-    inputSchema: z.object({
-      jsonLogic: z.unknown().describe("JSON Logic expression for the search query")
-    }),
-    handler: async (args, extra) => {
-      const client = getClient(extractApiKeyId(extra));
-      return client.searchStructured(args.jsonLogic);
-    }
-  },
-  {
-    name: "obsidian_read_note",
-    description: "Read the full content of a note in the Obsidian vault by its vault-relative path. Optionally target a specific heading or block.",
-    scopes: ["read:obsidian"],
-    inputSchema: z.object({
-      path: z.string().min(1).describe("Vault-relative path (e.g., 'notes/my-note.md')"),
-      targetType: z.enum(["heading", "block", "frontmatter"]).optional().describe("Scope the read to a specific type of target"),
-      target: z.string().optional().describe("Target identifier: heading text, block index (e.g., '^block-id'), or 'frontmatter'")
-    }),
-    handler: async (args, extra) => {
-      const client = getClient(extractApiKeyId(extra));
-      return client.readNote(args.path, args.targetType, args.target);
-    }
-  },
-  {
-    name: "obsidian_list_vault",
-    description: "List files and directories in the Obsidian vault. Returns a tree of file/folder entries.",
-    scopes: ["read:obsidian"],
-    inputSchema: z.object({
-      path: z.string().optional().default("").describe("Vault-relative directory path to list (empty for root)")
-    }),
-    handler: async (args, extra) => {
-      const client = getClient(extractApiKeyId(extra));
-      return client.listVault(args.path);
-    }
-  },
-  {
-    name: "obsidian_get_document_map",
-    description: "Get the document structure of a note as a map of headings and their line numbers.",
-    scopes: ["read:obsidian"],
-    inputSchema: z.object({
-      path: z.string().min(1).describe("Vault-relative path to the note")
-    }),
-    handler: async (args, extra) => {
-      const client = getClient(extractApiKeyId(extra));
-      return client.getDocumentMap(args.path);
-    }
-  },
-  {
-    name: "obsidian_get_note_metadata",
-    description: "Get metadata (frontmatter, tags, links, char/word count) for a note without reading its full content.",
-    scopes: ["read:obsidian"],
-    inputSchema: z.object({
-      path: z.string().min(1).describe("Vault-relative path to the note")
-    }),
-    handler: async (args, extra) => {
-      const client = getClient(extractApiKeyId(extra));
-      return client.getNoteMetadata(args.path);
-    }
-  },
-  {
-    name: "obsidian_get_active_file",
-    description: "Get the path and content of the currently active file in Obsidian.",
-    scopes: ["read:obsidian"],
-    inputSchema: z.object({}),
-    handler: async (_args, extra) => {
-      const client = getClient(extractApiKeyId(extra));
-      return client.getActiveFile();
-    }
-  },
-  {
-    name: "obsidian_get_periodic_note",
-    description: "Get the daily, weekly, or monthly periodic note for a given date (or today if no date specified).",
-    scopes: ["read:obsidian"],
-    inputSchema: z.object({
-      period: z.enum(["daily", "weekly", "monthly"]).describe("Period type"),
-      year: z.number().int().optional().describe("Year (required if month/day provided)"),
-      month: z.number().int().min(1).max(12).optional().describe("Month"),
-      day: z.number().int().min(1).max(31).optional().describe("Day")
-    }),
-    handler: async (args, extra) => {
-      const client = getClient(extractApiKeyId(extra));
-      return client.getPeriodicNote(args.period, args.year, args.month, args.day);
-    }
-  },
-  {
-    name: "obsidian_get_tags",
-    description: "List all tags used across the Obsidian vault with their frequencies.",
-    scopes: ["read:obsidian"],
-    inputSchema: z.object({}),
-    handler: async (_args, extra) => {
-      const client = getClient(extractApiKeyId(extra));
-      return client.getTags();
-    }
-  },
-  {
-    name: "obsidian_list_commands",
-    description: "List all available Obsidian commands with their IDs and names. Use IDs with obsidian_execute_command.",
-    scopes: ["read:obsidian"],
-    inputSchema: z.object({}),
-    handler: async (_args, extra) => {
-      const client = getClient(extractApiKeyId(extra));
-      return client.commandList();
-    }
-  },
-  {
-    name: "obsidian_write_note",
-    description: "Create or overwrite a note in the Obsidian vault with the given markdown content.",
-    scopes: ["write:obsidian"],
-    inputSchema: z.object({
-      path: z.string().min(1).describe("Vault-relative path to write to (e.g., 'notes/new-note.md')"),
-      content: z.string().min(1).describe("Full markdown content to write")
-    }),
-    handler: async (args, extra) => {
-      const client = getClient(extractApiKeyId(extra));
-      await client.writeNote(args.path, args.content);
-      return { success: true, message: `Note written to ${args.path}` };
-    }
-  },
-  {
-    name: "obsidian_append_note",
-    description: "Append content to an existing note. Optionally append to a specific heading or block.",
-    scopes: ["write:obsidian"],
-    inputSchema: z.object({
-      path: z.string().min(1).describe("Vault-relative path to the note"),
-      content: z.string().min(1).describe("Markdown content to append"),
-      targetType: z.enum(["heading", "block", "frontmatter"]).optional().describe("Target type to append to"),
-      target: z.string().optional().describe("Target identifier (heading text, block index, or 'frontmatter')")
-    }),
-    handler: async (args, extra) => {
-      const client = getClient(extractApiKeyId(extra));
-      await client.appendNote(args.path, args.content, args.targetType, args.target);
-      return { success: true, message: `Content appended to ${args.path}` };
-    }
-  },
-  {
-    name: "obsidian_patch_note",
-    description: "Surgically patch a note \u2014 append, prepend, or replace content at a specific heading, block, or frontmatter field.",
-    scopes: ["write:obsidian"],
-    inputSchema: z.object({
-      path: z.string().min(1).describe("Vault-relative path to the note"),
-      operation: z.enum(["append", "prepend", "replace"]).describe("Patch operation"),
-      targetType: z.enum(["heading", "block", "frontmatter"]).describe("Target type"),
-      target: z.string().min(1).describe("Target identifier: heading text, block ID, or frontmatter key"),
-      content: z.string().min(1).describe("Content to apply with the patch operation"),
-      createTargetIfMissing: z.boolean().optional().default(false).describe("Create the target heading/block if it does not exist")
-    }),
-    handler: async (args, extra) => {
-      const client = getClient(extractApiKeyId(extra));
-      return client.patchNote(args.path, args.operation, args.targetType, args.target, args.content, args.createTargetIfMissing);
-    }
-  },
-  {
-    name: "obsidian_delete_note",
-    description: "Permanently delete a note from the Obsidian vault.",
-    scopes: ["write:obsidian"],
-    inputSchema: z.object({
-      path: z.string().min(1).describe("Vault-relative path to the note to delete")
-    }),
-    handler: async (args, extra) => {
-      const client = getClient(extractApiKeyId(extra));
-      await client.deleteNote(args.path);
-      return { success: true, message: `Deleted ${args.path}` };
-    }
-  },
-  {
-    name: "obsidian_move_note",
-    description: "Move or rename a note within the Obsidian vault.",
-    scopes: ["write:obsidian"],
-    inputSchema: z.object({
-      path: z.string().min(1).describe("Current vault-relative path"),
-      destination: z.string().min(1).describe("New vault-relative path (can include new parent directory)")
-    }),
-    handler: async (args, extra) => {
-      const client = getClient(extractApiKeyId(extra));
-      await client.moveNote(args.path, args.destination);
-      return { success: true, message: `Moved ${args.path} to ${args.destination}` };
-    }
-  },
-  {
-    name: "obsidian_execute_command",
-    description: "Execute an Obsidian command by its command ID. Use obsidian_list_commands to discover available command IDs.",
-    scopes: ["write:obsidian"],
-    inputSchema: z.object({
-      commandId: z.string().min(1).describe("Obsidian command ID (e.g., 'editor:insert-link')")
-    }),
-    handler: async (args, extra) => {
-      const client = getClient(extractApiKeyId(extra));
-      await client.executeCommand(args.commandId);
-      return { success: true, message: `Executed command: ${args.commandId}` };
-    }
-  },
-  {
-    name: "obsidian_open_file",
-    description: "Open a file in Obsidian. If the file exists it opens in the editor; if not, it creates a new file.",
-    scopes: ["write:obsidian"],
-    inputSchema: z.object({
-      path: z.string().min(1).describe("Vault-relative path to the file to open")
-    }),
-    handler: async (args, extra) => {
-      const client = getClient(extractApiKeyId(extra));
-      await client.openFile(args.path);
-      return { success: true, message: `Opened ${args.path} in Obsidian` };
-    }
-  },
-  {
-    name: "obsidian_sync_status",
-    description: "Get the OmniRoute sync plugin status: whether the server is running, vault name, port, uptime, and last sync results. Requires the sync auth token to be configured in OmniRoute settings.",
-    scopes: ["read:obsidian"],
-    inputSchema: z.object({}),
-    handler: async (_args, extra) => {
-      const token = getSyncToken() || requireToken(extractApiKeyId(extra));
-      const syncClient = createSyncServerClient(token);
-      return syncClient.getStatus();
-    }
-  },
-  {
-    name: "obsidian_sync_trigger",
-    description: "Trigger an immediate bidirectional sync between desktop and mobile Obsidian vaults. Returns the sync result (files pulled, pushed, deleted, conflicts). Requires the sync auth token to be configured in OmniRoute settings.",
-    scopes: ["write:obsidian"],
-    inputSchema: z.object({}),
-    handler: async (_args, extra) => {
-      const token = getSyncToken() || requireToken(extractApiKeyId(extra));
-      const syncClient = createSyncServerClient(token);
-      const result = await syncClient.triggerSync();
-      return { success: true, ...result };
-    }
-  },
-  {
-    name: "obsidian_sync_conflicts",
-    description: "List unresolved sync conflicts. Each conflict shows the file path, conflict file path, and when it was detected. Requires the sync auth token to be configured in OmniRoute settings.",
-    scopes: ["read:obsidian"],
-    inputSchema: z.object({}),
-    handler: async (_args, extra) => {
-      const token = getSyncToken() || requireToken(extractApiKeyId(extra));
-      const syncClient = createSyncServerClient(token);
-      return syncClient.getConflicts();
-    }
-  },
-  {
-    name: "obsidian_sync_resolve_conflict",
-    description: "Resolve a sync conflict by choosing which version to keep. Use 'local' for the mobile version, 'remote' for the desktop version, or 'keep-both' to preserve both. Requires the sync auth token to be configured in OmniRoute settings.",
-    scopes: ["write:obsidian"],
-    inputSchema: z.object({
-      path: z.string().min(1).describe("Vault-relative path of the conflicting file (without .conflict- suffix)"),
-      resolution: z.enum(["local", "remote", "keep-both"]).describe("Which version to keep: local (mobile), remote (desktop), or keep-both")
-    }),
-    handler: async (args, extra) => {
-      const token = getSyncToken() || requireToken(extractApiKeyId(extra));
-      const syncClient = createSyncServerClient(token);
-      const result = await syncClient.resolveConflict(args.path, args.resolution);
-      return { success: true, result };
-    }
-  }
-];
-export {
-  obsidianTools
-};