@malloy-publisher/server 0.0.382-dev → 0.2.1

package/src/mcp/resources/package_resource.ts

@@ -1,370 +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 { ProjectStore } from "../../service/project_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: { projectName?: string; packageName?: string },
-   projectStore: ProjectStore,
-) {
-   try {
-      const { projectName, packageName } = params;
-      if (typeof projectName !== "string" || projectName === "") {
-         throw new Error("Invalid project name parameter.");
-      }
-      if (typeof packageName !== "string" || packageName === "") {
-         throw new Error("Invalid package name parameter.");
-      }
-
-      const project = await projectStore.getProject(projectName, false);
-      const packageInstance = await project.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 = {
-            project: projectName,
-            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 project name"))
-      ) {
-         errorDetails = getNotFoundError(
-            `Invalid project/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,
-   projectStore: ProjectStore,
-): void {
-   // Define the expected parameter type for the read callback
-   type ReadPackageParams = {
-      fsPath?: string; // Expect string
-      projectName?: string; // Expect string
-      packageName?: string; // Expect string
-   };
-
-   mcpServer.resource(
-      "package",
-      new ResourceTemplate(
-         "malloy://project/{projectName}/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 ({
-               projectName,
-               packageName,
-            }: {
-               // Keep unknown here as it reflects the raw input possibility
-               // before validation inside the async function
-               projectName?: unknown;
-               packageName?: unknown;
-            }) => {
-               try {
-                  if (typeof projectName !== "string") {
-                     throw new Error("Invalid project name parameter.");
-                  }
-                  if (typeof packageName !== "string") {
-                     throw new Error("Invalid package name parameter.");
-                  }
-                  const project = await projectStore.getProject(
-                     projectName,
-                     false,
-                  );
-                  const pkg = await project.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 project name"))
-                  ) {
-                     errorDetails = getNotFoundError(
-                        `Invalid project/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://project/{projectName}/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,
-               projectStore,
-            );
-
-            // 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 project name"))
-            ) {
-               // Handle invalid identifier errors specifically
-               errorDetails = getNotFoundError(
-                  `Invalid project/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/project_resource.ts

@@ -1,184 +0,0 @@
-import {
-   McpServer,
-   ResourceTemplate,
-} from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { ListResourcesResult } from "@modelcontextprotocol/sdk/types.js"; // Needed for list return type
-import { logger } from "../../logger";
-import { ProjectStore } from "../../service/project_store";
-import { getInternalError, getNotFoundError } from "../error_messages"; // Needed for error handling in list AND get
-import { handleResourceGet, McpGetResourceError } from "../handler_utils";
-import { RESOURCE_METADATA } from "../resource_metadata";
-
-// Define an interface for the package object augmented with project name
-interface PackageWithProject {
-   name?: string;
-   // Add other relevant package properties if needed
-   projectName: string;
-}
-
-/**
- * Registers the Malloy Project resource type with the MCP server.
- * Handles getting details for the hardcoded 'home' project and listing packages within it.
- */
-export function registerProjectResource(
-   mcpServer: McpServer,
-   projectStore: ProjectStore,
-): void {
-   mcpServer.resource(
-      "project",
-      new ResourceTemplate("malloy://project/{projectName}", {
-         /**
-          * Handles ListResources requests.
-          * If projectName is specified, lists packages for that project (only 'home' supported).
-          * If projectName is not specified (general ListResources call), lists packages for the default 'home' project.
-          */
-         list: async (/* extra: ListProjectExtra - Deleted */): Promise<ListResourcesResult> => {
-            logger.info(
-               "[MCP LOG] Entering ListResources (project) handler (listing ALL packages)...",
-            );
-            // Ignore parameters from 'extra' as URI path params aren't passed to list handlers.
-
-            try {
-               const allProjects = await projectStore.listProjects();
-               logger.info(
-                  `[MCP LOG] Found ${allProjects.length} projects defined.`,
-               );
-
-               const packagePromises = allProjects.map(async (proj) => {
-                  try {
-                     logger.info(
-                        `[MCP LOG] Getting project '${proj.name}' to list its packages...`,
-                     );
-                     const projectInstance = await projectStore.getProject(
-                        proj.name!,
-                        false,
-                     ); // Use proj.name
-                     const packages = await projectInstance.listPackages();
-                     logger.info(
-                        `[MCP LOG] Found ${packages.length} packages in project '${proj.name}'.`,
-                     );
-                     // Return packages along with their project name for URI construction
-                     return packages.map((pkg) => ({
-                        ...pkg,
-                        projectName: proj.name,
-                     }));
-                  } catch (projectError) {
-                     logger.error(
-                        `[MCP Server Error] Error getting/listing packages for project ${proj.name}:`,
-                        { error: projectError },
-                     );
-                     return []; // Return empty array for this project on error
-                  }
-               });
-
-               const results = await Promise.allSettled(packagePromises);
-               const allPackagesWithProjectName = results
-                  .filter((result) => result.status === "fulfilled")
-                  // Use the specific interface instead of any[]
-                  .flatMap(
-                     (result) =>
-                        (result as PromiseFulfilledResult<PackageWithProject[]>)
-                           .value,
-                  );
-
-               logger.info(
-                  `[MCP LOG] Total packages found across all projects: ${allPackagesWithProjectName.length}`,
-               );
-
-               const packageMetadata = RESOURCE_METADATA.package;
-               const mappedResources = allPackagesWithProjectName.map((pkg) => {
-                  const name = pkg.name || "unknown";
-                  // Construct URI using the package's specific projectName
-                  const uri = `malloy://project/${pkg.projectName}/package/${name}`;
-                  return {
-                     uri: uri,
-                     name: name,
-                     type: "package",
-                     description: packageMetadata?.description as
-                        | string
-                        | undefined,
-                     metadata: packageMetadata,
-                  };
-               });
-
-               logger.info(
-                  `[MCP LOG] ListResources (project): Returning ${mappedResources.length} package resources.`,
-               );
-               return {
-                  resources: mappedResources,
-               };
-            } catch (error) {
-               // Catch errors from projectStore.listProjects() itself
-               logger.error(`[MCP Server Error] Error listing projects:`, {
-                  error,
-               });
-               const errorDetails = getInternalError(
-                  `ListResources (project - initial list)`,
-                  error,
-               );
-               logger.error("MCP ListResources (project) error:", {
-                  error: errorDetails.message,
-               });
-               logger.info(
-                  "[MCP LOG] ListResources (project): Returning empty on error listing projects.",
-               );
-               return { resources: [] };
-            }
-         },
-      }),
-      /** Handles GetResource requests for Malloy Projects */
-      (uri, params) =>
-         handleResourceGet(
-            uri,
-            params,
-            "project",
-            async ({ projectName }: { projectName?: unknown }) => {
-               logger.info(
-                  `[MCP LOG] Entering GetResource (project) handler for projectName: ${projectName}`,
-               );
-               // Validate project name parameter
-               if (typeof projectName !== "string") {
-                  logger.error(
-                     "[MCP LOG] GetResource (project): Invalid project name param.",
-                  );
-                  throw new Error("Invalid project name parameter.");
-               }
-
-               try {
-                  logger.info(
-                     `[MCP LOG] GetResource: Getting project '${projectName}'...`,
-                  );
-                  // Get the project instance, but we might not need its metadata directly
-                  await projectStore.getProject(projectName, false);
-                  // Construct the definition object expected by the test
-                  const definition = { name: projectName };
-                  logger.info(
-                     `[MCP LOG] GetResource (project): Returning definition for '${projectName}'.`,
-                  );
-                  // Return the explicit definition structure
-                  return definition;
-               } catch (error) {
-                  logger.error(
-                     `[MCP LOG] GetResource (project): Error caught for '${projectName}':`,
-                     { error },
-                  );
-                  // Catch expected errors from this specific resource logic
-                  if (error instanceof Error) {
-                     // Use getNotFoundError for the specific project not found case
-                     // or a generic message for the invalid param case.
-                     const errorDetails = getNotFoundError(
-                        error.message.includes("not found")
-                           ? `Project '${projectName}'` // More specific context
-                           : `Invalid project identifier provided for URI ${uri.href}`, // Generic but informative
-                     );
-                     // Re-throw structured error for handleResourceGet to catch
-                     throw new McpGetResourceError(errorDetails);
-                  }
-                  // Re-throw unexpected errors to be caught by handleResourceGet's generic handler
-                  throw error;
-               }
-            },
-            RESOURCE_METADATA.project,
-         ),
-   );
-}

package/src/mcp/resources/query_resource.ts

@@ -1,117 +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 { ProjectStore } from "../../service/project_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 = {
-   projectName?: unknown;
-   packageName?: unknown;
-   modelPath?: unknown;
-   queryName?: unknown;
-};
-
-/**
- * Registers the Malloy Query resource type (nested within a Model).
- */
-export function registerQueryResource(
-   mcpServer: McpServer,
-   projectStore: ProjectStore,
-): void {
-   mcpServer.resource(
-      "query",
-      new ResourceTemplate(
-         "malloy://project/{projectName}/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 (
-               { projectName, packageName, modelPath, queryName }: QueryParams,
-               uri: URL,
-            ) => {
-               if (
-                  typeof projectName !== "string" ||
-                  typeof packageName !== "string" ||
-                  typeof modelPath !== "string" ||
-                  typeof queryName !== "string"
-               ) {
-                  throw new Error("Invalid parameters for query resource.");
-               }
-
-               try {
-                  const modelResult = await getModelForQuery(
-                     projectStore,
-                     projectName,
-                     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}' project '${projectName}'`,
-                     );
-                     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)",
-                        `${projectName}/${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,
-         ),
-   );
-}