waypoi 0.0.0

package/dist/src/mcp/client.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpClient = exports.McpError = void 0;
+exports.createMcpClient = createMcpClient;
+class McpError extends Error {
+    code;
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = "McpError";
+    }
+}
+exports.McpError = McpError;
+class McpClient {
+    url;
+    timeout;
+    requestId = 0;
+    sessionId = null;
+    constructor(options) {
+        this.url = options.url;
+        this.timeout = options.timeout ?? 30000;
+    }
+    /**
+     * Initialize the MCP connection.
+     */
+    async initialize() {
+        const response = await this.sendRequest("initialize", {
+            protocolVersion: "2024-11-05",
+            capabilities: {
+                tools: {},
+            },
+            clientInfo: {
+                name: "waypoi",
+                version: "0.2.0",
+            },
+        });
+        // Store session ID if provided
+        const initResponse = response;
+        if (initResponse._meta?.sessionId) {
+            this.sessionId = initResponse._meta.sessionId;
+        }
+        // Send initialized notification
+        await this.sendNotification("notifications/initialized");
+    }
+    /**
+     * List available tools from the MCP server.
+     */
+    async listTools() {
+        const result = await this.sendRequest("tools/list", {});
+        const toolsResult = result;
+        return toolsResult.tools ?? [];
+    }
+    /**
+     * Call a tool on the MCP server.
+     */
+    async callTool(name, args) {
+        const result = await this.sendRequest("tools/call", {
+            name,
+            arguments: args,
+        });
+        return result;
+    }
+    /**
+     * Close the MCP connection.
+     */
+    async close() {
+        try {
+            await this.sendNotification("notifications/cancelled", {
+                requestId: "session",
+                reason: "Client closing",
+            });
+        }
+        catch {
+            // Ignore errors during close
+        }
+        this.sessionId = null;
+    }
+    /**
+     * Send a JSON-RPC request and wait for response.
+     */
+    async sendRequest(method, params) {
+        const id = ++this.requestId;
+        const request = {
+            jsonrpc: "2.0",
+            id,
+            method,
+            params,
+        };
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            // MCP Streamable HTTP spec requires accepting both JSON and SSE
+            const headers = {
+                "Content-Type": "application/json",
+                "Accept": "application/json, text/event-stream",
+            };
+            if (this.sessionId) {
+                headers["Mcp-Session-Id"] = this.sessionId;
+            }
+            const response = await fetch(this.url, {
+                method: "POST",
+                headers,
+                body: JSON.stringify(request),
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                throw new McpError(-32000, `HTTP error: ${response.status} ${response.statusText}`);
+            }
+            // Check for session ID in response headers
+            const newSessionId = response.headers.get("Mcp-Session-Id");
+            if (newSessionId) {
+                this.sessionId = newSessionId;
+            }
+            // Handle both JSON and SSE responses per MCP Streamable HTTP spec
+            const contentType = response.headers.get("Content-Type") ?? "";
+            if (contentType.includes("text/event-stream")) {
+                // Parse SSE response - collect events and find our response
+                return await this.parseSSEResponse(response, id);
+            }
+            const jsonResponse = await response.json();
+            if (jsonResponse.error) {
+                throw new McpError(jsonResponse.error.code, jsonResponse.error.message, jsonResponse.error.data);
+            }
+            return jsonResponse.result;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    /**
+     * Parse Server-Sent Events response to extract JSON-RPC response.
+     * MCP Streamable HTTP can return SSE for streaming responses.
+     */
+    async parseSSEResponse(response, expectedId) {
+        const text = await response.text();
+        const lines = text.split("\n");
+        let currentData = "";
+        for (const line of lines) {
+            if (line.startsWith("data:")) {
+                currentData += line.slice(5).trim();
+            }
+            else if (line === "" && currentData) {
+                // End of event, try to parse
+                try {
+                    const jsonResponse = JSON.parse(currentData);
+                    // Check if this is the response to our request
+                    if (jsonResponse.id === expectedId) {
+                        if (jsonResponse.error) {
+                            throw new McpError(jsonResponse.error.code, jsonResponse.error.message, jsonResponse.error.data);
+                        }
+                        return jsonResponse.result;
+                    }
+                }
+                catch (e) {
+                    if (e instanceof McpError)
+                        throw e;
+                    // Ignore parsing errors, continue to next event
+                }
+                currentData = "";
+            }
+        }
+        // Try parsing any remaining data
+        if (currentData) {
+            try {
+                const jsonResponse = JSON.parse(currentData);
+                if (jsonResponse.id === expectedId) {
+                    if (jsonResponse.error) {
+                        throw new McpError(jsonResponse.error.code, jsonResponse.error.message, jsonResponse.error.data);
+                    }
+                    return jsonResponse.result;
+                }
+            }
+            catch (e) {
+                if (e instanceof McpError)
+                    throw e;
+            }
+        }
+        throw new McpError(-32000, "No response found in SSE stream");
+    }
+    /**
+     * Send a JSON-RPC notification (no response expected).
+     */
+    async sendNotification(method, params) {
+        const headers = {
+            "Content-Type": "application/json",
+        };
+        if (this.sessionId) {
+            headers["Mcp-Session-Id"] = this.sessionId;
+        }
+        const notification = {
+            jsonrpc: "2.0",
+            method,
+            params,
+        };
+        await fetch(this.url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(notification),
+        });
+    }
+    get serverUrl() {
+        return this.url;
+    }
+}
+exports.McpClient = McpClient;
+/**
+ * Create and initialize an MCP client.
+ */
+async function createMcpClient(url) {
+    const client = new McpClient({ url });
+    await client.initialize();
+    return client;
+}

package/dist/src/mcp/discovery.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILTIN_SERVER_ID = void 0;
+exports.discoverBuiltinTools = discoverBuiltinTools;
+exports.getBuiltinVirtualServer = getBuiltinVirtualServer;
+exports.discoverServerTools = discoverServerTools;
+exports.discoverAllTools = discoverAllTools;
+exports.summarizeMcpError = summarizeMcpError;
+exports.getCachedTools = getCachedTools;
+exports.getCachedToolsForServer = getCachedToolsForServer;
+exports.findTool = findTool;
+exports.executeTool = executeTool;
+exports.disconnectServer = disconnectServer;
+exports.disconnectAllServers = disconnectAllServers;
+exports.isServerConnected = isServerConnected;
+const registry_1 = require("./registry");
+const client_1 = require("./client");
+// In-memory cache of discovered tools
+const toolsCache = new Map();
+// Active client connections
+const activeClients = new Map();
+// ─────────────────────────────────────────────────────────────────────────────
+// Built-in server (the waypoi /mcp endpoint itself)
+// ─────────────────────────────────────────────────────────────────────────────
+/** Reserved ID for the built-in waypoi MCP server. */
+exports.BUILTIN_SERVER_ID = "builtin";
+/** URL of the built-in MCP server (set once after app.listen). */
+let builtinUrl = null;
+/**
+ * Connect to the built-in /mcp endpoint and cache its tools.
+ * Called once in src/index.ts after app.listen().
+ */
+async function discoverBuiltinTools(paths, serverUrl) {
+    builtinUrl = serverUrl;
+    const now = new Date();
+    const server = {
+        id: exports.BUILTIN_SERVER_ID,
+        name: "waypoi",
+        url: serverUrl,
+        enabled: true,
+        status: "unknown",
+        createdAt: now,
+        updatedAt: now,
+    };
+    return discoverServerTools(paths, server);
+}
+/**
+ * Return virtual server metadata for the built-in server.
+ * Returns null if discoverBuiltinTools hasn't been called yet.
+ */
+function getBuiltinVirtualServer() {
+    if (!builtinUrl)
+        return null;
+    const now = new Date();
+    const connected = isServerConnected(exports.BUILTIN_SERVER_ID);
+    return {
+        id: exports.BUILTIN_SERVER_ID,
+        name: "waypoi",
+        url: builtinUrl,
+        enabled: true,
+        status: connected ? "connected" : "error",
+        toolCount: getCachedToolsForServer(exports.BUILTIN_SERVER_ID).length,
+        createdAt: now,
+        updatedAt: now,
+        connected,
+    };
+}
+/**
+ * Connect to a single MCP server and discover its tools.
+ */
+async function discoverServerTools(paths, server) {
+    if (!server.enabled) {
+        return [];
+    }
+    try {
+        // Create client and connect
+        const client = await (0, client_1.createMcpClient)(server.url);
+        activeClients.set(server.id, client);
+        // Discover tools
+        const toolSchemas = await client.listTools();
+        const tools = toolSchemas.map((schema) => ({
+            name: schema.name,
+            description: schema.description,
+            inputSchema: schema.inputSchema,
+            serverId: server.id,
+            serverName: server.name,
+            serverUrl: server.url,
+        }));
+        // Update server status
+        await (0, registry_1.updateMcpServerStatus)(paths, server.id, "connected", tools.length);
+        // Cache tools
+        toolsCache.set(server.id, tools);
+        return tools;
+    }
+    catch (error) {
+        const summary = summarizeMcpError(error);
+        console.error(`[waypoi] MCP discovery failed for ${server.name}: ${summary}`);
+        if (process.env.WAYPOI_DEBUG_ERRORS === "1") {
+            console.error(error);
+        }
+        await (0, registry_1.updateMcpServerStatus)(paths, server.id, "error");
+        toolsCache.delete(server.id);
+        return [];
+    }
+}
+/**
+ * Discover tools from all enabled MCP servers.
+ */
+async function discoverAllTools(paths) {
+    const servers = await (0, registry_1.listMcpServers)(paths);
+    const enabledServers = servers.filter((s) => s.enabled);
+    // Discover tools from all servers in parallel
+    const results = await Promise.allSettled(enabledServers.map((server) => discoverServerTools(paths, server)));
+    // Collect all successful discoveries
+    const allTools = [];
+    for (const result of results) {
+        if (result.status === "fulfilled") {
+            allTools.push(...result.value);
+        }
+    }
+    return allTools;
+}
+function summarizeMcpError(error) {
+    if (error instanceof client_1.McpError) {
+        return error.message;
+    }
+    const err = error;
+    if (err?.code) {
+        return err.code;
+    }
+    const cause = err?.cause;
+    if (cause?.code) {
+        return cause.code;
+    }
+    const message = err?.message;
+    if (typeof message === "string" && message.trim().length > 0) {
+        return message;
+    }
+    return "unknown error";
+}
+/**
+ * Get all cached tools (does not re-discover).
+ */
+function getCachedTools() {
+    const allTools = [];
+    for (const tools of toolsCache.values()) {
+        allTools.push(...tools);
+    }
+    return allTools;
+}
+/**
+ * Get tools for a specific server.
+ */
+function getCachedToolsForServer(serverId) {
+    return toolsCache.get(serverId) ?? [];
+}
+/**
+ * Find a tool by name across all servers.
+ */
+function findTool(name) {
+    for (const tools of toolsCache.values()) {
+        const tool = tools.find((t) => t.name === name);
+        if (tool)
+            return tool;
+    }
+    return undefined;
+}
+/**
+ * Execute a tool on its source MCP server.
+ */
+async function executeTool(toolName, args) {
+    const tool = findTool(toolName);
+    if (!tool) {
+        return { content: `Tool not found: ${toolName}`, isError: true };
+    }
+    const client = activeClients.get(tool.serverId);
+    if (!client) {
+        return { content: `Server not connected: ${tool.serverName}`, isError: true };
+    }
+    try {
+        const result = await client.callTool(toolName, args);
+        // Extract text content from result
+        const textParts = result.content
+            .filter((c) => c.type === "text" && c.text)
+            .map((c) => c.text);
+        return {
+            content: textParts.join("\n") || "Tool executed successfully (no output)",
+            isError: result.isError,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof client_1.McpError
+            ? error.message
+            : error.message;
+        return { content: `Tool execution failed: ${errorMessage}`, isError: true };
+    }
+}
+/**
+ * Disconnect from a specific server.
+ */
+async function disconnectServer(serverId) {
+    const client = activeClients.get(serverId);
+    if (client) {
+        await client.close();
+        activeClients.delete(serverId);
+    }
+    toolsCache.delete(serverId);
+}
+/**
+ * Disconnect from all servers.
+ */
+async function disconnectAllServers() {
+    const closePromises = [];
+    for (const [serverId, client] of activeClients) {
+        closePromises.push(client.close());
+        activeClients.delete(serverId);
+        toolsCache.delete(serverId);
+    }
+    await Promise.allSettled(closePromises);
+}
+/**
+ * Check if a server is currently connected.
+ */
+function isServerConnected(serverId) {
+    return activeClients.has(serverId);
+}

package/dist/src/mcp/policy.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typedError = typedError;
+exports.resolveBinaryOutputPolicy = resolveBinaryOutputPolicy;
+exports.validateSingleImageInput = validateSingleImageInput;
+exports.validateAtMostOneImageInput = validateAtMostOneImageInput;
+const path_1 = __importDefault(require("path"));
+function typedError(type, message) {
+    const error = new Error(message);
+    error.type = type;
+    return error;
+}
+function resolveBinaryOutputPolicy(input, options = {}) {
+    const env = options.env ?? process.env;
+    const defaultBaseDir = options.defaultBaseDir ?? process.cwd();
+    const strict = parseBooleanEnv(env.WAYPOI_MCP_STRICT_OUTPUT_ROOT);
+    const configuredRoot = env.WAYPOI_MCP_OUTPUT_ROOT?.trim();
+    if (strict && !configuredRoot) {
+        throw typedError("invalid_request", "WAYPOI_MCP_STRICT_OUTPUT_ROOT=true requires WAYPOI_MCP_OUTPUT_ROOT to be set.");
+    }
+    let baseRoot = defaultBaseDir;
+    if (configuredRoot) {
+        if (!path_1.default.isAbsolute(configuredRoot)) {
+            if (strict) {
+                throw typedError("invalid_request", `WAYPOI_MCP_OUTPUT_ROOT must be an absolute path, got '${configuredRoot}'.`);
+            }
+        }
+        else {
+            baseRoot = path_1.default.resolve(configuredRoot);
+        }
+    }
+    const configuredSubdir = env.WAYPOI_MCP_OUTPUT_SUBDIR?.trim();
+    if (configuredSubdir && path_1.default.isAbsolute(configuredSubdir)) {
+        throw typedError("invalid_request", `WAYPOI_MCP_OUTPUT_SUBDIR must be relative, got '${configuredSubdir}'.`);
+    }
+    const outputDir = configuredSubdir
+        ? path_1.default.resolve(baseRoot, configuredSubdir)
+        : path_1.default.join(baseRoot, "generated-images");
+    return {
+        outputDir,
+        includeData: input.include_data ?? false,
+        outputBaseRoot: baseRoot,
+    };
+}
+function parseBooleanEnv(value) {
+    if (!value) {
+        return false;
+    }
+    return value === "1" || value.toLowerCase() === "true";
+}
+function validateSingleImageInput(input) {
+    const hasPath = Boolean(input.image_path);
+    const hasUrl = Boolean(input.image_url);
+    if ((hasPath && hasUrl) || (!hasPath && !hasUrl)) {
+        throw typedError("invalid_request", "Exactly one image source is required: provide either image_path or image_url.");
+    }
+}
+function validateAtMostOneImageInput(input) {
+    if (input.image_path && input.image_url) {
+        throw typedError("invalid_request", "Provide either image_path or image_url, not both.");
+    }
+}

package/dist/src/mcp/registry.js

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listMcpServers = listMcpServers;
+exports.getMcpServer = getMcpServer;
+exports.addMcpServer = addMcpServer;
+exports.updateMcpServer = updateMcpServer;
+exports.removeMcpServer = removeMcpServer;
+exports.updateMcpServerStatus = updateMcpServerStatus;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const yaml_1 = __importDefault(require("yaml"));
+const files_1 = require("../storage/files");
+function mcpServersPath(paths) {
+    return path_1.default.join(paths.baseDir, "mcp-servers.yaml");
+}
+async function ensureMcpDir(paths) {
+    await (0, files_1.ensureStorageDir)(paths);
+}
+async function loadServersFile(paths) {
+    await ensureMcpDir(paths);
+    const filePath = mcpServersPath(paths);
+    try {
+        const raw = await fs_1.promises.readFile(filePath, "utf8");
+        const doc = yaml_1.default.parse(raw);
+        if (doc?.servers) {
+            return doc;
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+    return { servers: [] };
+}
+async function saveServersFile(paths, data) {
+    const filePath = mcpServersPath(paths);
+    const yaml = yaml_1.default.stringify(data, { indent: 2 });
+    await fs_1.promises.writeFile(filePath, yaml, "utf8");
+}
+/**
+ * List all registered MCP servers.
+ */
+async function listMcpServers(paths) {
+    const file = await loadServersFile(paths);
+    return file.servers;
+}
+/**
+ * Get a single MCP server by ID.
+ */
+async function getMcpServer(paths, id) {
+    const servers = await listMcpServers(paths);
+    return servers.find((s) => s.id === id) ?? null;
+}
+/**
+ * Add a new MCP server to the registry.
+ */
+async function addMcpServer(paths, input) {
+    const file = await loadServersFile(paths);
+    // Check for duplicate URL
+    if (file.servers.some((s) => s.url === input.url)) {
+        throw new Error(`Server with URL ${input.url} already exists`);
+    }
+    const now = new Date();
+    const server = {
+        id: crypto_1.default.randomUUID(),
+        name: input.name,
+        url: input.url,
+        enabled: input.enabled ?? true,
+        status: "unknown",
+        createdAt: now,
+        updatedAt: now,
+    };
+    file.servers.push(server);
+    await saveServersFile(paths, file);
+    return server;
+}
+/**
+ * Update an existing MCP server.
+ */
+async function updateMcpServer(paths, id, patch) {
+    const file = await loadServersFile(paths);
+    const index = file.servers.findIndex((s) => s.id === id);
+    if (index === -1) {
+        return null;
+    }
+    const server = file.servers[index];
+    const updated = {
+        ...server,
+        ...patch,
+        updatedAt: new Date(),
+    };
+    file.servers[index] = updated;
+    await saveServersFile(paths, file);
+    return updated;
+}
+/**
+ * Remove an MCP server from the registry.
+ */
+async function removeMcpServer(paths, id) {
+    const file = await loadServersFile(paths);
+    const index = file.servers.findIndex((s) => s.id === id);
+    if (index === -1) {
+        return false;
+    }
+    file.servers.splice(index, 1);
+    await saveServersFile(paths, file);
+    return true;
+}
+/**
+ * Update server status after connection attempt.
+ */
+async function updateMcpServerStatus(paths, id, status, toolCount) {
+    const file = await loadServersFile(paths);
+    const server = file.servers.find((s) => s.id === id);
+    if (server) {
+        server.status = status;
+        if (toolCount !== undefined) {
+            server.toolCount = toolCount;
+        }
+        server.lastConnectedAt = status === "connected" ? new Date() : server.lastConnectedAt;
+        server.updatedAt = new Date();
+        await saveServersFile(paths, file);
+    }
+}