@malloy-publisher/server 0.0.226 → 0.0.227

package/src/mcp/resources/package_resource.ts

@@ -1,373 +0,0 @@
-import {
-   McpServer,
-   ResourceTemplate,
-} from "@modelcontextprotocol/sdk/server/mcp.js";
-import { ReadResourceResult } from "@modelcontextprotocol/sdk/types.js";
-import { URL } from "url";
-import { PackageNotFoundError } from "../../errors";
-import { logger } from "../../logger";
-import { EnvironmentStore } from "../../service/environment_store";
-import {
-   getInternalError,
-   getNotFoundError,
-   type ErrorDetails,
-} from "../error_messages";
-import {
-   buildMalloyUri,
-   handleResourceGet,
-   McpGetResourceError,
-} from "../handler_utils";
-import { RESOURCE_METADATA } from "../resource_metadata";
-
-// *** Define handleGetPackageContents function ***
-async function handleGetPackageContents(
-   uri: URL,
-   params: { environmentName?: string; packageName?: string },
-   environmentStore: EnvironmentStore,
-) {
-   try {
-      const { environmentName, packageName } = params;
-      if (typeof environmentName !== "string" || environmentName === "") {
-         throw new Error("Invalid environment name parameter.");
-      }
-      if (typeof packageName !== "string" || packageName === "") {
-         throw new Error("Invalid package name parameter.");
-      }
-
-      const environment = await environmentStore.getEnvironment(
-         environmentName,
-         false,
-      );
-      const packageInstance = await environment.getPackage(packageName, false);
-
-      // Use listModels() which returns { path: string, type: 'source' | 'notebook' }[]
-      const entries = await packageInstance.listModels();
-
-      // Use a type that includes metadata explicitly
-      const resourceDefinitions: { uri: string; metadata: unknown }[] = [];
-
-      for (const entry of entries) {
-         const entryPath = entry.path; // e.g., "flights.malloy", "overview.malloynb"
-         // @ts-expect-error TODO: Fix missing type in API
-         const entryType = entry.type; // 'source' or 'notebook'
-
-         if (typeof entryPath !== "string" || entryPath === "") {
-            logger.warn(
-               `[MCP Server Warning] Skipping entry in package ${packageName} with invalid path:`,
-               entry,
-            );
-            continue;
-         }
-
-         // Common components for URI building
-         const baseUriComponents = {
-            environment: environmentName,
-            package: packageName,
-         };
-
-         switch (entryType) {
-            case "notebook": {
-               const resourceMetadata = RESOURCE_METADATA.notebook;
-               if (!resourceMetadata) {
-                  logger.warn(
-                     `[MCP Server Warning] No metadata found for entry type 'notebook' path ${entryPath} in package ${packageName}`,
-                  );
-                  continue;
-               }
-               const notebookUri = buildMalloyUri({
-                  ...baseUriComponents,
-                  resourceType: "notebooks",
-                  resourceName: entryPath,
-               });
-               resourceDefinitions.push({
-                  uri: notebookUri,
-                  metadata: resourceMetadata,
-               });
-               break;
-            }
-            case "source": {
-               // 1. Add the source file itself
-               const sourceResourceMetadata = RESOURCE_METADATA.source;
-               if (!sourceResourceMetadata) {
-                  logger.warn(
-                     `[MCP Server Warning] No metadata found for entry type 'source' path ${entryPath} in package ${packageName}`,
-                  );
-                  // Continue processing views even if source metadata is missing
-               } else {
-                  const sourceUri = buildMalloyUri({
-                     ...baseUriComponents,
-                     resourceType: "sources", // Use 'sources' type for the source file resource
-                     resourceName: entryPath,
-                  });
-                  resourceDefinitions.push({
-                     uri: sourceUri,
-                     metadata: sourceResourceMetadata,
-                  });
-               }
-
-               // 2. Try to load the model to find views within it
-               try {
-                  const model = await packageInstance.getModel(entryPath); // Await the promise
-                  if (model) {
-                     // Ensure model exists before proceeding
-                     const modelSources = model.getSources(); // This should be synchronous if model is loaded
-
-                     if (modelSources && Array.isArray(modelSources)) {
-                        for (const source of modelSources) {
-                           if (source.views && Array.isArray(source.views)) {
-                              for (const view of source.views) {
-                                 const viewResourceMetadata =
-                                    RESOURCE_METADATA.view;
-                                 if (!viewResourceMetadata) {
-                                    logger.warn(
-                                       `[MCP Server Warning] No metadata found for entry type 'view' named '${view.name}' in source '${source.name}'`,
-                                    );
-                                    continue;
-                                 }
-                                 // Build the nested view URI using the helper
-                                 const viewUri = buildMalloyUri({
-                                    ...baseUriComponents,
-                                    resourceType: "models", // Base is the model
-                                    resourceName: entryPath, // Model file path
-                                    subResourceType: "views",
-                                    subResourceName: view.name,
-                                 });
-                                 resourceDefinitions.push({
-                                    uri: viewUri,
-                                    metadata: viewResourceMetadata,
-                                 });
-                              }
-                           }
-                        }
-                     } else {
-                        logger.warn(
-                           `[MCP Server Warning] Could not retrieve sources or sources is not an array for model ${entryPath}`,
-                        );
-                     }
-                  } else {
-                     logger.warn(
-                        `[MCP Server Warning] Could not load model for path ${entryPath} to extract views.`,
-                     );
-                  }
-               } catch (modelLoadError) {
-                  // Log error if model loading fails, but continue processing other files
-                  logger.warn(
-                     `[MCP Server Warning] Failed to load model ${entryPath} to extract views: ${modelLoadError instanceof Error ? modelLoadError.message : String(modelLoadError)}`,
-                  );
-               }
-               break;
-            }
-            default:
-               logger.warn(
-                  `[MCP Server Warning] Unknown entry type '${entryType}' for path ${entryPath} in package ${packageName}`,
-               );
-               continue; // Skip unknown types
-         }
-      }
-
-      return resourceDefinitions; // handleResourceGet will stringify this
-   } catch (error) {
-      let errorDetails;
-      if (error instanceof PackageNotFoundError) {
-         errorDetails = getNotFoundError(
-            `Package for contents listing matching URI '${uri.href}'`,
-         );
-      } else if (
-         error instanceof Error &&
-         (error.message.includes("Invalid package name") ||
-            error.message.includes("Invalid environment name"))
-      ) {
-         errorDetails = getNotFoundError(
-            `Invalid environment/package identifier in URI '${uri.href}'`,
-         );
-      } else {
-         logger.error(
-            `[MCP Server Error] Error getting package contents for ${uri.href}:`,
-            { error },
-         );
-         errorDetails = getInternalError(
-            `GetResource (package contents: ${uri.href})`,
-            error,
-         );
-      }
-      throw new McpGetResourceError(errorDetails);
-   }
-}
-
-/**
- * Registers the Malloy Package resource type with the MCP server.
- * Handles listing models/notebooks/sources within packages and getting package details.
- */
-export function registerPackageResource(
-   mcpServer: McpServer,
-   environmentStore: EnvironmentStore,
-): void {
-   // Define the expected parameter type for the read callback
-   type ReadPackageParams = {
-      fsPath?: string; // Expect string
-      environmentName?: string; // Expect string
-      packageName?: string; // Expect string
-   };
-
-   mcpServer.resource(
-      "package",
-      new ResourceTemplate(
-         "malloy://environment/{environmentName}/package/{packageName}",
-         {
-            list: undefined, // TODO: Implement and add listAllPackages here if needed
-         },
-      ),
-      (uri, params) =>
-         handleResourceGet(
-            uri,
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            params as ReadPackageParams, // Cast params to the updated type
-            "package",
-            async ({
-               environmentName,
-               packageName,
-            }: {
-               // Keep unknown here as it reflects the raw input possibility
-               // before validation inside the async function
-               environmentName?: unknown;
-               packageName?: unknown;
-            }) => {
-               try {
-                  if (typeof environmentName !== "string") {
-                     throw new Error("Invalid environment name parameter.");
-                  }
-                  if (typeof packageName !== "string") {
-                     throw new Error("Invalid package name parameter.");
-                  }
-                  const environment = await environmentStore.getEnvironment(
-                     environmentName,
-                     false,
-                  );
-                  const pkg = await environment.getPackage(packageName, false);
-                  return pkg.getPackageMetadata();
-               } catch (error) {
-                  let errorDetails;
-                  if (error instanceof PackageNotFoundError) {
-                     errorDetails = getNotFoundError(
-                        `Package resource matching URI '${uri.href}'`,
-                     );
-                  } else if (
-                     error instanceof Error &&
-                     (error.message.includes("Invalid package name") ||
-                        error.message.includes("Invalid environment name"))
-                  ) {
-                     errorDetails = getNotFoundError(
-                        `Invalid environment/package identifier in URI '${uri.href}'`,
-                     );
-                  } else {
-                     errorDetails = getInternalError(
-                        `GetResource (package: ${uri.href})`,
-                        error,
-                     );
-                  }
-                  throw new McpGetResourceError(errorDetails);
-               }
-            },
-            RESOURCE_METADATA.package,
-         ),
-   );
-
-   // *** Register Package Contents Resource ***
-   mcpServer.resource(
-      "package-contents",
-      new ResourceTemplate(
-         "malloy://environment/{environmentName}/package/{packageName}/contents",
-         {
-            // Contents are listed via GetResource on this specific URI,
-            // so no general list callback needed here.
-            list: undefined,
-         },
-      ),
-      // Custom handler because the response format is just the array, not {definition, metadata}
-      async (
-         uri: URL,
-         params: ReadPackageParams,
-      ): Promise<ReadResourceResult> => {
-         try {
-            // Reuse param validation/typing
-            const validatedParams = params as ReadPackageParams;
-
-            // Get the array of resource definitions
-            const resourceDefinitions = await handleGetPackageContents(
-               uri,
-               validatedParams,
-               environmentStore,
-            );
-
-            // Return the array directly as JSON content
-            return {
-               contents: [
-                  {
-                     type: "application/json",
-                     uri: uri.href,
-                     text: JSON.stringify(resourceDefinitions, null, 2),
-                  },
-               ],
-            };
-         } catch (error) {
-            logger.error(
-               `[MCP Server Error] Error reading package contents ${uri.href}:`,
-               { error },
-            );
-
-            let errorDetails: ErrorDetails;
-
-            // Check if it's the specific error thrown by handleGetPackageContents
-            if (error instanceof McpGetResourceError) {
-               // Specifically check if it's a 'not found' error from the inner handler
-               if (error.message.includes("not found")) {
-                  // Re-use the not found details directly
-                  errorDetails = error.details;
-               } else {
-                  // It was a different McpGetResourceError (e.g., internal from inner handler)
-                  errorDetails = error.details;
-               }
-            } else if (error instanceof PackageNotFoundError) {
-               // Handle PackageNotFoundError specifically if it bubbles up here
-               errorDetails = getNotFoundError(
-                  `Package for contents listing matching URI '${uri.href}'`,
-               );
-            } else if (
-               error instanceof Error &&
-               (error.message.includes("Invalid package name") ||
-                  error.message.includes("Invalid environment name"))
-            ) {
-               // Handle invalid identifier errors specifically
-               errorDetails = getNotFoundError(
-                  `Invalid environment/package identifier in URI '${uri.href}'`,
-               );
-            } else {
-               // Handle other unexpected errors
-               errorDetails = getInternalError(
-                  `GetResource (package contents: ${uri.href})`,
-                  error,
-               );
-            }
-
-            // Format the error response
-            return {
-               isError: true,
-               contents: [
-                  {
-                     type: "application/json",
-                     uri: uri.href,
-                     text: JSON.stringify(
-                        {
-                           error: errorDetails.message,
-                           suggestions: errorDetails.suggestions,
-                        },
-                        null,
-                        2,
-                     ),
-                  },
-               ],
-            };
-         }
-      },
-   );
-}

package/src/mcp/resources/query_resource.ts

@@ -1,122 +0,0 @@
-import {
-   McpServer,
-   ResourceTemplate,
-} from "@modelcontextprotocol/sdk/server/mcp.js";
-import { URL } from "url";
-import type { components } from "../../api"; // Need this for Query definition type
-import { ModelCompilationError } from "../../errors";
-import { logger } from "../../logger";
-import { EnvironmentStore } from "../../service/environment_store";
-import {
-   getInternalError,
-   getMalloyErrorDetails,
-   getNotFoundError,
-} from "../error_messages";
-import {
-   getModelForQuery,
-   handleResourceGet,
-   McpGetResourceError,
-} from "../handler_utils";
-import { RESOURCE_METADATA } from "../resource_metadata";
-
-// Define the expected parameter types
-type QueryParams = {
-   environmentName?: unknown;
-   packageName?: unknown;
-   modelPath?: unknown;
-   queryName?: unknown;
-};
-
-/**
- * Registers the Malloy Query resource type (nested within a Model).
- */
-export function registerQueryResource(
-   mcpServer: McpServer,
-   environmentStore: EnvironmentStore,
-): void {
-   mcpServer.resource(
-      "query",
-      new ResourceTemplate(
-         "malloy://environment/{environmentName}/package/{packageName}/models/{modelPath}/queries/{queryName}",
-         { list: undefined }, // Listing queries is not supported via this template
-      ),
-      (uri, params) =>
-         handleResourceGet(
-            uri,
-            params as QueryParams,
-            "query",
-            async (
-               {
-                  environmentName,
-                  packageName,
-                  modelPath,
-                  queryName,
-               }: QueryParams,
-               uri: URL,
-            ) => {
-               if (
-                  typeof environmentName !== "string" ||
-                  typeof packageName !== "string" ||
-                  typeof modelPath !== "string" ||
-                  typeof queryName !== "string"
-               ) {
-                  throw new Error("Invalid parameters for query resource.");
-               }
-
-               try {
-                  const modelResult = await getModelForQuery(
-                     environmentStore,
-                     environmentName,
-                     packageName,
-                     modelPath,
-                  );
-                  if ("error" in modelResult) {
-                     throw new McpGetResourceError(modelResult.error);
-                  }
-                  const { model } = modelResult;
-
-                  // Attempt to get the query definition from the model
-                  const queries = await model.getQueries(); // Assuming this method exists
-                  if (!queries) {
-                     throw new Error("Could not retrieve queries from model.");
-                  }
-                  const query = queries.find(
-                     (q: components["schemas"]["Query"]) =>
-                        q.name === queryName,
-                  );
-
-                  if (!query) {
-                     // Specific "Query not found" error
-                     const errorDetails = getNotFoundError(
-                        `Query '${queryName}' in model '${modelPath}' package '${packageName}' environment '${environmentName}'`,
-                     );
-                     throw new McpGetResourceError(errorDetails);
-                  }
-                  return query;
-               } catch (error) {
-                  if (error instanceof McpGetResourceError) {
-                     throw error; // Re-throw already formatted
-                  }
-                  if (error instanceof ModelCompilationError) {
-                     const errorDetails = getMalloyErrorDetails(
-                        "GetResource (query - model compilation)",
-                        `${environmentName}/${packageName}/${modelPath}`,
-                        error,
-                     );
-                     throw new McpGetResourceError(errorDetails);
-                  }
-                  logger.error(
-                     `[MCP Server Error] Error fetching query '${queryName}' from ${uri.href}:`,
-                     { error },
-                  );
-                  const fallbackErrorDetails = getInternalError(
-                     `GetResource (query: ${uri.href})`,
-                     error,
-                  );
-                  throw new McpGetResourceError(fallbackErrorDetails);
-               }
-            },
-            RESOURCE_METADATA.query,
-         ),
-   );
-}

package/src/mcp/resources/source_resource.ts

@@ -1,141 +0,0 @@
-import {
-   McpServer,
-   ResourceTemplate,
-} from "@modelcontextprotocol/sdk/server/mcp.js";
-import { URL } from "url";
-import type { components } from "../../api";
-import { ModelCompilationError } from "../../errors";
-import { logger } from "../../logger";
-import { EnvironmentStore } from "../../service/environment_store";
-import {
-   getInternalError,
-   getMalloyErrorDetails,
-   getNotFoundError,
-} from "../error_messages";
-import {
-   getModelForQuery,
-   handleResourceGet,
-   McpGetResourceError,
-} from "../handler_utils";
-import { RESOURCE_METADATA } from "../resource_metadata";
-
-// Define the expected parameter types for this resource
-type SourceParams = {
-   environmentName?: unknown;
-   packageName?: unknown;
-   modelPath?: unknown;
-   sourceName?: unknown;
-};
-
-/**
- * Registers the Malloy Source resource type (nested within a Model).
- * Handles getting details for a specific source.
- */
-export function registerSourceResource(
-   mcpServer: McpServer,
-   environmentStore: EnvironmentStore,
-): void {
-   mcpServer.resource(
-      "source",
-      new ResourceTemplate(
-         "malloy://environment/{environmentName}/package/{packageName}/models/{modelPath}/sources/{sourceName}",
-         { list: undefined }, // Listing sources directly is not supported via this template
-      ),
-      /** Handles GetResource requests for specific Sources within a Model */
-      (uri, params) =>
-         handleResourceGet(
-            uri,
-            params as SourceParams, // Cast params
-            "source",
-            // Define the getData async callback
-            async (
-               {
-                  environmentName,
-                  packageName,
-                  modelPath,
-                  sourceName,
-               }: SourceParams, // Use defined type
-               // Add type for uri
-               uri: URL,
-            ) => {
-               // Input validation
-               if (
-                  typeof environmentName !== "string" ||
-                  typeof packageName !== "string" ||
-                  typeof modelPath !== "string" ||
-                  typeof sourceName !== "string"
-               ) {
-                  // Throw simple error, handleResourceGet will wrap it
-                  throw new Error("Invalid parameters for source resource.");
-               }
-
-               try {
-                  // Use the imported getModelForQuery
-                  const modelResult = await getModelForQuery(
-                     environmentStore,
-                     environmentName,
-                     packageName,
-                     modelPath,
-                  );
-
-                  // Handle error case from getModelForQuery
-                  if ("error" in modelResult) {
-                     throw new McpGetResourceError(modelResult.error);
-                  }
-                  const { model } = modelResult;
-
-                  const sources = await model.getSources();
-                  // Add check for undefined sources
-                  if (!sources) {
-                     throw new Error("Could not retrieve sources from model.");
-                  }
-                  const source = sources.find(
-                     (s: components["schemas"]["Source"]) =>
-                        s.name === sourceName,
-                  );
-
-                  if (!source) {
-                     const errorDetails = getNotFoundError(
-                        `Source '${sourceName}' in model '${modelPath}' package '${packageName}' environment '${environmentName}'`,
-                     );
-                     throw new McpGetResourceError(errorDetails);
-                  }
-
-                  // Strip implicit filters from agent-facing responses
-                  if (source.filters) {
-                     source.filters = source.filters.filter((f) => !f.implicit);
-                  }
-
-                  return source;
-               } catch (error) {
-                  // Catch errors from getModelForQuery or finding the source
-                  if (error instanceof McpGetResourceError) {
-                     throw error; // Re-throw already formatted errors
-                  }
-                  // Check if it's a compilation error (likely from getModel call within getModelForQuery)
-                  if (error instanceof ModelCompilationError) {
-                     const errorDetails = getMalloyErrorDetails(
-                        "GetResource (source - model compilation)",
-                        `${environmentName}/${packageName}/${modelPath}`,
-                        error,
-                     );
-                     throw new McpGetResourceError(errorDetails);
-                  }
-                  // Handle other potential errors (e.g., invalid params error from initial check)
-                  logger.error(
-                     `[MCP Server Error] Error fetching source '${sourceName}' from ${uri.href}:`,
-                     { error },
-                  );
-                  // Fallback: Use getInternalError for unexpected issues
-                  // Or getNotFoundError if it's likely a resource access issue
-                  const fallbackErrorDetails = getInternalError(
-                     `GetResource (source: ${uri.href})`,
-                     error,
-                  );
-                  throw new McpGetResourceError(fallbackErrorDetails);
-               }
-            },
-            RESOURCE_METADATA.source, // Use source-specific metadata
-         ),
-   );
-}