run-dmcp 0.1.0

package/dist/index.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { initializeSchema } from "./db/schema.js";
+import { closeDatabase } from "./db/connection.js";
+import { startHttpServer } from "./http/server.js";
+import { setHttpPort } from "./utils/webui.js";
+// Import registration functions
+import { registerCoreTools } from "./register/core.js";
+import { registerWorldTools } from "./register/world.js";
+import { registerCharacterTools } from "./register/character.js";
+import { registerCombatTools } from "./register/combat.js";
+import { registerInventoryTools } from "./register/inventory.js";
+import { registerQuestTools } from "./register/quests.js";
+import { registerNarrativeTools } from "./register/narrative.js";
+import { registerResourceTools } from "./register/resources.js";
+import { registerTimeTools } from "./register/time.js";
+import { registerTableTools } from "./register/tables.js";
+import { registerSecretTools } from "./register/secrets.js";
+import { registerRelationshipTools } from "./register/relationships.js";
+import { registerTagTools } from "./register/tags.js";
+import { registerStatusTools } from "./register/status.js";
+import { registerFactionTools } from "./register/factions.js";
+import { registerAbilityTools } from "./register/abilities.js";
+import { registerNoteTools } from "./register/notes.js";
+import { registerPauseTools } from "./register/pause.js";
+import { registerImageTools } from "./register/images.js";
+import { registerAudioTools } from "./register/audio.js";
+import { registerDisplayTools } from "./register/display.js";
+import { registerBatchTools } from "./register/batch.js";
+import { registerMcpResources } from "./register/mcp-resources.js";
+import { registerMcpPrompts } from "./register/mcp-prompts.js";
+// Initialize database
+initializeSchema();
+// Create MCP server
+const server = new McpServer({
+    name: "dmcp",
+    version: "0.1.0",
+});
+// Register all tools by domain
+registerCoreTools(server); // Game, Interview, Rules
+registerWorldTools(server); // Locations, Connections, Map
+registerCharacterTools(server); // Characters (PC/NPC)
+registerCombatTools(server); // Combat, Dice, Checks
+registerInventoryTools(server); // Items
+registerQuestTools(server); // Quests, Objectives
+registerNarrativeTools(server); // Events, History, Export, Player Choices
+registerResourceTools(server); // Custom Resources
+registerTimeTools(server); // Calendar, Time, Timers
+registerTableTools(server); // Random Tables
+registerSecretTools(server); // Secrets, Knowledge
+registerRelationshipTools(server); // Relationships
+registerTagTools(server); // Tags
+registerStatusTools(server); // Status Effects
+registerFactionTools(server); // Factions
+registerAbilityTools(server); // Abilities/Powers
+registerNoteTools(server); // Game Notes
+registerPauseTools(server); // Pause/Resume, Context Snapshots, External Updates
+registerImageTools(server); // Stored Images
+registerAudioTools(server); // Stored Audio (TTS, Voice References)
+registerDisplayTools(server); // Display/Theme Configuration
+registerBatchTools(server); // Batch Operations (multi-entity, workflows)
+// Register MCP Resources and Prompts
+registerMcpResources(server); // Read-only data access via URI
+registerMcpPrompts(server); // Reusable prompt templates
+// ============================================================================
+// START SERVER
+// ============================================================================
+// HTTP server port (configurable via environment variable)
+const HTTP_PORT = parseInt(process.env.DMCP_HTTP_PORT || "3456", 10);
+async function main() {
+    // Start HTTP server for web UI (runs alongside MCP)
+    const actualPort = await startHttpServer(HTTP_PORT);
+    setHttpPort(actualPort);
+    // Start MCP server with stdio transport
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+// Handle cleanup
+process.on("SIGINT", () => {
+    closeDatabase();
+    process.exit(0);
+});
+process.on("SIGTERM", () => {
+    closeDatabase();
+    process.exit(0);
+});
+main().catch((error) => {
+    console.error("Server error:", error);
+    closeDatabase();
+    process.exit(1);
+});

package/dist/register/abilities.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerAbilityTools(server: McpServer): void;

package/dist/register/abilities.js

@@ -0,0 +1,165 @@
+import { z } from "zod";
+import * as abilityTools from "../tools/ability.js";
+import { LIMITS } from "../utils/validation.js";
+import { ANNOTATIONS } from "../utils/tool-annotations.js";
+export function registerAbilityTools(server) {
+    server.registerTool("create_ability", {
+        description: "Create an ability template or character-owned ability",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            ownerType: z.enum(["template", "character"]).describe("'template' for reusable, 'character' for owned"),
+            ownerId: z.string().max(100).optional().describe("Character ID if ownerType is 'character'"),
+            name: z.string().min(1).max(LIMITS.NAME_MAX).describe("Ability name"),
+            description: z.string().max(LIMITS.DESCRIPTION_MAX).optional().describe("Ability description"),
+            category: z.string().max(100).optional().describe("Category (e.g., 'spell', 'skill', 'power')"),
+            cost: z.record(z.number()).optional().describe("Resource costs (e.g., {mana: 10, stamina: 5})"),
+            cooldown: z.number().optional().describe("Cooldown in rounds"),
+            effects: z.array(z.string().max(LIMITS.DESCRIPTION_MAX)).max(LIMITS.ARRAY_MAX).optional().describe("Effect descriptions"),
+            requirements: z.record(z.number()).optional().describe("Requirements (e.g., {level: 5, strength: 10})"),
+            tags: z.array(z.string().max(LIMITS.NAME_MAX)).max(LIMITS.ARRAY_MAX).optional().describe("Tags for categorization"),
+        },
+        annotations: ANNOTATIONS.CREATE,
+    }, async (params) => {
+        const ability = abilityTools.createAbility(params);
+        return {
+            content: [{ type: "text", text: JSON.stringify(ability, null, 2) }],
+        };
+    });
+    server.registerTool("get_ability", {
+        description: "Get an ability by ID",
+        inputSchema: {
+            abilityId: z.string().max(100).describe("The ability ID"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ abilityId }) => {
+        const ability = abilityTools.getAbility(abilityId);
+        if (!ability) {
+            return {
+                content: [{ type: "text", text: "Ability not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(ability, null, 2) }],
+        };
+    });
+    server.registerTool("update_ability", {
+        description: "Update an ability's details",
+        inputSchema: {
+            abilityId: z.string().max(100).describe("The ability ID"),
+            name: z.string().max(LIMITS.NAME_MAX).optional().describe("New name"),
+            description: z.string().max(LIMITS.DESCRIPTION_MAX).optional().describe("New description"),
+            category: z.string().max(100).nullable().optional().describe("New category"),
+            cost: z.record(z.number()).optional().describe("New cost"),
+            cooldown: z.number().nullable().optional().describe("New cooldown"),
+            effects: z.array(z.string().max(LIMITS.DESCRIPTION_MAX)).max(LIMITS.ARRAY_MAX).optional().describe("New effects"),
+            requirements: z.record(z.number()).optional().describe("New requirements"),
+            tags: z.array(z.string().max(LIMITS.NAME_MAX)).max(LIMITS.ARRAY_MAX).optional().describe("New tags"),
+        },
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ abilityId, ...updates }) => {
+        const ability = abilityTools.updateAbility(abilityId, updates);
+        if (!ability) {
+            return {
+                content: [{ type: "text", text: "Ability not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(ability, null, 2) }],
+        };
+    });
+    server.registerTool("delete_ability", {
+        description: "Delete an ability",
+        inputSchema: {
+            abilityId: z.string().max(100).describe("The ability ID"),
+        },
+        annotations: ANNOTATIONS.DESTRUCTIVE,
+    }, async ({ abilityId }) => {
+        const success = abilityTools.deleteAbility(abilityId);
+        return {
+            content: [{ type: "text", text: success ? "Ability deleted" : "Ability not found" }],
+            isError: !success,
+        };
+    });
+    server.registerTool("list_abilities", {
+        description: "List abilities with optional filters",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            ownerType: z.enum(["template", "character"]).optional().describe("Filter by owner type"),
+            ownerId: z.string().max(100).optional().describe("Filter by owner ID"),
+            category: z.string().max(100).optional().describe("Filter by category"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ gameId, ...filter }) => {
+        const abilities = abilityTools.listAbilities(gameId, filter);
+        return {
+            content: [{ type: "text", text: JSON.stringify(abilities, null, 2) }],
+        };
+    });
+    server.registerTool("learn_ability", {
+        description: "Copy a template ability to a character",
+        inputSchema: {
+            templateId: z.string().max(100).describe("The template ability ID"),
+            characterId: z.string().max(100).describe("The character ID to learn the ability"),
+        },
+        annotations: ANNOTATIONS.CREATE,
+    }, async ({ templateId, characterId }) => {
+        const ability = abilityTools.learnAbility(templateId, characterId);
+        if (!ability) {
+            return {
+                content: [{ type: "text", text: "Template not found or is not a template" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(ability, null, 2) }],
+        };
+    });
+    server.registerTool("use_ability", {
+        description: "Use an ability (checks cooldown, sets new cooldown)",
+        inputSchema: {
+            abilityId: z.string().max(100).describe("The ability ID"),
+            characterId: z.string().max(100).describe("The character using the ability"),
+        },
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ abilityId, characterId }) => {
+        const result = abilityTools.useAbility(abilityId, characterId);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            isError: !result.success,
+        };
+    });
+    server.registerTool("tick_ability_cooldowns", {
+        description: "Reduce all ability cooldowns (call at end of round)",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            amount: z.number().optional().describe("Rounds to tick (default: 1)"),
+        },
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ gameId, amount }) => {
+        const updated = abilityTools.tickCooldowns(gameId, amount);
+        return {
+            content: [{ type: "text", text: JSON.stringify({ updatedCount: updated.length, abilities: updated }, null, 2) }],
+        };
+    });
+    server.registerTool("check_ability_requirements", {
+        description: "Check if a character meets an ability's requirements",
+        inputSchema: {
+            abilityId: z.string().max(100).describe("The ability ID"),
+            characterId: z.string().max(100).describe("The character ID"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ abilityId, characterId }) => {
+        const result = abilityTools.checkRequirements(abilityId, characterId);
+        if (!result) {
+            return {
+                content: [{ type: "text", text: "Ability or character not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+}

package/dist/register/audio.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerAudioTools(server: McpServer): void;

package/dist/register/audio.js

@@ -0,0 +1,326 @@
+import { z } from "zod";
+import * as audioTools from "../tools/audio.js";
+import { LIMITS } from "../utils/validation.js";
+import { ANNOTATIONS } from "../utils/tool-annotations.js";
+export function registerAudioTools(server) {
+    server.registerTool("store_audio", {
+        description: "Store an audio file for an entity. Provide either a URL to fetch from or a local file path. Useful for TTS-generated narration, character dialogue, or voice reference clips for voice cloning.",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            entityId: z
+                .string()
+                .max(100)
+                .describe("ID of the entity (character, location, game, scene, etc.)"),
+            entityType: z
+                .string()
+                .max(50)
+                .describe("Type of entity (e.g., character, location, game, scene, narration, dialogue)"),
+            url: z
+                .string()
+                .max(2000)
+                .optional()
+                .describe("URL to fetch the audio from (provide url OR filePath)"),
+            filePath: z
+                .string()
+                .max(1000)
+                .optional()
+                .describe("Local file path to copy from (provide url OR filePath)"),
+            label: z
+                .string()
+                .max(LIMITS.NAME_MAX)
+                .optional()
+                .describe("Label for the audio (e.g., 'Greeting', 'Battle Cry', 'Voice Sample')"),
+            description: z
+                .string()
+                .max(LIMITS.DESCRIPTION_MAX)
+                .optional()
+                .describe("Description of the audio content"),
+            mimeType: z
+                .string()
+                .max(100)
+                .optional()
+                .describe("MIME type (e.g., 'audio/mp3'). Inferred if not provided."),
+            ttsEngine: z
+                .string()
+                .max(100)
+                .optional()
+                .describe("TTS engine used to generate (e.g., 'maya1', 'chatterbox', 'kokoro', 'xtts', 'mira', 'cosyvoice')"),
+            ttsVoice: z
+                .string()
+                .max(200)
+                .optional()
+                .describe("Voice name/ID used for TTS generation"),
+            ttsText: z
+                .string()
+                .max(LIMITS.CONTENT_MAX)
+                .optional()
+                .describe("The text that was synthesized (for TTS audio)"),
+            ttsSettings: z
+                .record(z.unknown())
+                .optional()
+                .describe("Engine-specific TTS settings (temperature, exaggeration, etc.)"),
+            isVoiceReference: z
+                .boolean()
+                .optional()
+                .describe("Mark this as a voice reference clip for voice cloning. These clips can be used as reference audio for TTS engines that support voice cloning."),
+            voiceName: z
+                .string()
+                .max(LIMITS.NAME_MAX)
+                .optional()
+                .describe("Name for this voice (for voice cloning reference clips)"),
+            voiceDescription: z
+                .string()
+                .max(LIMITS.DESCRIPTION_MAX)
+                .optional()
+                .describe("Description of voice characteristics (accent, tone, pitch, etc.) for voice cloning"),
+            setAsPrimary: z
+                .boolean()
+                .optional()
+                .describe("Set this as the primary audio for the entity"),
+        },
+        annotations: ANNOTATIONS.EXTERNAL,
+    }, async (params) => {
+        try {
+            if (!params.url && !params.filePath) {
+                return {
+                    content: [
+                        { type: "text", text: "Error: Either url or filePath must be provided" },
+                    ],
+                    isError: true,
+                };
+            }
+            const audio = await audioTools.storeAudio(params);
+            return {
+                content: [{ type: "text", text: JSON.stringify(audio, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error storing audio: ${error}` }],
+                isError: true,
+            };
+        }
+    });
+    server.registerTool("get_audio", {
+        description: "Get audio file metadata by ID",
+        inputSchema: {
+            audioId: z.string().max(100).describe("The audio ID"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ audioId }) => {
+        const audio = audioTools.getAudio(audioId);
+        if (!audio) {
+            return {
+                content: [{ type: "text", text: "Audio not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(audio, null, 2) }],
+        };
+    });
+    server.registerTool("get_audio_file_path", {
+        description: "Get the full local file path for an audio file. Useful when you need to pass the audio file to another tool (like TTS voice cloning).",
+        inputSchema: {
+            audioId: z.string().max(100).describe("The audio ID"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ audioId }) => {
+        const filePath = audioTools.getAudioFilePath(audioId);
+        if (!filePath) {
+            return {
+                content: [{ type: "text", text: "Audio file not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ audioId, filePath }, null, 2),
+                },
+            ],
+        };
+    });
+    server.registerTool("get_audio_data", {
+        description: "Get audio with base64 data included (for playback or processing)",
+        inputSchema: {
+            audioId: z.string().max(100).describe("The audio ID"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ audioId }) => {
+        const result = audioTools.getAudioData(audioId);
+        if (!result) {
+            return {
+                content: [{ type: "text", text: "Audio not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("list_entity_audio", {
+        description: "List all audio files for an entity",
+        inputSchema: {
+            entityId: z.string().max(100).describe("ID of the entity"),
+            entityType: z
+                .string()
+                .max(50)
+                .describe("Type of entity (e.g., character, location, game, scene)"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ entityId, entityType }) => {
+        const result = audioTools.listEntityAudio(entityId, entityType);
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("list_game_audio", {
+        description: "List all audio files in a game",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ gameId }) => {
+        const audioFiles = audioTools.listGameAudio(gameId);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ gameId, count: audioFiles.length, audioFiles }, null, 2),
+                },
+            ],
+        };
+    });
+    server.registerTool("list_voice_references", {
+        description: "List voice reference clips for voice cloning. These are audio samples that can be used as reference audio for TTS engines that support voice cloning (like Chatterbox, XTTS, CosyVoice).",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            characterId: z
+                .string()
+                .max(100)
+                .optional()
+                .describe("Filter by character ID (optional, returns all if not specified)"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ gameId, characterId }) => {
+        const voiceRefs = audioTools.listVoiceReferences(gameId, characterId);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        gameId,
+                        characterId: characterId || "all",
+                        count: voiceRefs.length,
+                        voiceReferences: voiceRefs,
+                    }, null, 2),
+                },
+            ],
+        };
+    });
+    server.registerTool("get_character_voice_references", {
+        description: "Get all voice reference clips for a specific character, along with character info. Returns file paths ready to use with voice cloning TTS engines.",
+        inputSchema: {
+            gameId: z.string().max(100).describe("The game ID"),
+            characterId: z.string().max(100).describe("The character ID"),
+        },
+        annotations: ANNOTATIONS.READ_ONLY,
+    }, async ({ gameId, characterId }) => {
+        const result = audioTools.getCharacterVoiceReferences(gameId, characterId);
+        if (!result) {
+            return {
+                content: [{ type: "text", text: "Character not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool("delete_audio", {
+        description: "Delete a stored audio file (removes file and database record)",
+        inputSchema: {
+            audioId: z.string().max(100).describe("The audio ID"),
+        },
+        annotations: ANNOTATIONS.DESTRUCTIVE,
+    }, async ({ audioId }) => {
+        const success = audioTools.deleteAudio(audioId);
+        return {
+            content: [
+                { type: "text", text: success ? "Audio deleted" : "Audio not found" },
+            ],
+            isError: !success,
+        };
+    });
+    server.registerTool("set_primary_audio", {
+        description: "Set an audio file as the primary audio for its entity",
+        inputSchema: {
+            audioId: z.string().max(100).describe("The audio ID to set as primary"),
+        },
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ audioId }) => {
+        const audio = audioTools.setPrimaryAudio(audioId);
+        if (!audio) {
+            return {
+                content: [{ type: "text", text: "Audio not found" }],
+                isError: true,
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(audio, null, 2) }],
+        };
+    });
+    server.registerTool("update_audio_metadata", {
+        description: "Update metadata for an audio file (label, description, voice reference info)",
+        inputSchema: {
+            audioId: z.string().max(100).describe("The audio ID"),
+            label: z.string().max(LIMITS.NAME_MAX).optional().describe("New label"),
+            description: z
+                .string()
+                .max(LIMITS.DESCRIPTION_MAX)
+                .optional()
+                .describe("New description"),
+            ttsText: z
+                .string()
+                .max(LIMITS.CONTENT_MAX)
+                .optional()
+                .describe("Update the TTS text transcript"),
+            voiceName: z
+                .string()
+                .max(LIMITS.NAME_MAX)
+                .optional()
+                .describe("New voice name (for voice references)"),
+            voiceDescription: z
+                .string()
+                .max(LIMITS.DESCRIPTION_MAX)
+                .optional()
+                .describe("New voice description (for voice references)"),
+            isVoiceReference: z
+                .boolean()
+                .optional()
+                .describe("Mark/unmark as voice reference clip"),
+        },
+        annotations: ANNOTATIONS.UPDATE,
+    }, async ({ audioId, ...updates }) => {
+        try {
+            const audio = audioTools.updateAudioMetadata(audioId, updates);
+            if (!audio) {
+                return {
+                    content: [{ type: "text", text: "Audio not found" }],
+                    isError: true,
+                };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(audio, null, 2) }],
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: "text", text: `Error updating audio: ${error}` }],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/register/batch.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerBatchTools(server: McpServer): void;