npm - @malloy-publisher/server - Versions diffs - 0.0.91 → 0.0.92 - Mend

@malloy-publisher/server 0.0.91 → 0.0.92

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (306) hide show

package/dist/app/index.html CHANGED Viewed

@@ -12,9 +12,9 @@
          href="https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;500;700&display=swap"
       />
       <title>Malloy Publisher</title>
-     <script type="module" crossorigin src="/assets/index-CwH8v8Pf.js"></script>
+     <script type="module" crossorigin src="/assets/index-DYO_URL-.js"></script>
      <link rel="modulepreload" crossorigin href="/assets/vendor-c5ypKtDW.js">
-     <link rel="modulepreload" crossorigin href="/assets/mui-Bcj8oDBR.js">
+     <link rel="modulepreload" crossorigin href="/assets/mui-UpaxdnvH.js">
      <link rel="stylesheet" crossorigin href="/assets/index-CcIq0aEZ.css">
    </head>
    <body>

package/dist/server.js CHANGED Viewed

@@ -231303,7 +231303,7 @@ var ROW_LIMIT = 1000;
 var publisherPath = "/etc/publisher";
 try {
   import_fs.default.accessSync(publisherPath, import_fs.default.constants.W_OK);
-} catch (e) {
+} catch {
   publisherPath = "/tmp/publisher";
 }
@@ -231718,7 +231718,7 @@ async function getSnowflakeSchemas(connection) {
   return new Promise((resolve, reject) => {
     connection.execute({
       sqlText: "SHOW SCHEMAS",
-      complete: (err, stmt, rows) => {
+      complete: (err, _stmt, rows) => {
         if (err) {
           reject(err);
         } else {
@@ -231966,7 +231966,7 @@ class PackageController {
       if (packageLocation.endsWith(".zip")) {
         packageLocation = await this.projectStore.unzipProject(packageLocation);
       }
-      await this.projectStore.mountLocalDirectory(packageLocation, absoluteTargetPath, projectName);
+      await this.projectStore.mountLocalDirectory(packageLocation, absoluteTargetPath, projectName, packageName);
     }
   }
 }
@@ -233583,9 +233583,9 @@ var import_path4 = __toESM(require("path"));
 // src/service/project_store.ts
 var import_client_s3 = __toESM(require_dist_cjs72());
 var import_storage = require("@google-cloud/storage");
+var import_adm_zip = __toESM(require_adm_zip());
 var fs9 = __toESM(require("fs"));
 var path7 = __toESM(require("path"));
-var import_adm_zip = __toESM(require_adm_zip());
 // ../../node_modules/simple-git/dist/esm/index.js
 var import_node_buffer = require("node:buffer");
@@ -237575,7 +237575,11 @@ var import_fs5 = __toESM(require("fs"));
 var import_path2 = __toESM(require("path"));
 var getPublisherConfig = (serverRoot) => {
   const publisherConfigPath = import_path2.default.join(serverRoot, PUBLISHER_CONFIG_NAME);
-  return JSON.parse(import_fs5.default.readFileSync(publisherConfigPath, "utf8"));
+  const rawConfig = JSON.parse(import_fs5.default.readFileSync(publisherConfigPath, "utf8"));
+  if (rawConfig.projects && typeof rawConfig.projects === "object" && !Array.isArray(rawConfig.projects)) {
+    throw new Error("Config has changed. Please update your config to the new format.");
+  }
+  return rawConfig;
 };
 var isPublisherConfigFrozen = (serverRoot) => {
   const publisherConfig = getPublisherConfig(serverRoot);
@@ -237815,13 +237819,20 @@ async function readConnectionConfig(basePath) {
 async function createConnections(basePath, defaultConnections = []) {
   const connectionMap = new Map;
   const connectionConfig = await readConnectionConfig(basePath);
-  for (const connection of [...defaultConnections, ...connectionConfig]) {
+  const allConnections = [...defaultConnections, ...connectionConfig];
+  const processedConnections = new Set;
+  const apiConnections = [];
+  for (const connection of allConnections) {
+    if (connection.name && processedConnections.has(connection.name)) {
+      continue;
+    }
     logger2.info(`Adding connection ${connection.name}`, {
       connection
     });
     if (!connection.name) {
       throw "Invalid connection configuration.  No name.";
     }
+    processedConnections.add(connection.name);
     switch (connection.type) {
       case "postgres": {
         const configReader = async () => {
@@ -237933,10 +237944,11 @@ async function createConnections(basePath, defaultConnections = []) {
         throw new Error(`Unsupported connection type: ${connection.type}`);
       }
     }
+    apiConnections.push(connection);
   }
   return {
     malloyConnections: connectionMap,
-    apiConnections: connectionConfig
+    apiConnections
   };
 }
 function getConnectionAttributes(connection) {
@@ -238748,6 +238760,7 @@ class Package {
 class Project {
   packages = new Map;
   packageMutexes = new Map;
+  packageStatuses = new Map;
   malloyConnections;
   apiConnections;
   internalConnections;
@@ -238768,28 +238781,33 @@ class Project {
     this.reloadProjectMetadata();
   }
   async update(payload) {
-    if (payload.name) {
-      this.projectName = payload.name;
-      this.packages.forEach((_package) => {
-        _package.setProjectName(this.projectName);
-      });
-      this.metadata.name = this.projectName;
+    if (payload.readme !== undefined) {
+      this.metadata.readme = payload.readme;
     }
-    if (payload.resource) {
-      this.projectPath = payload.resource.replace(`${API_PREFIX}/projects/`, "");
-      if (!await fs8.promises.exists(this.projectPath)) {
-        throw new ProjectNotFoundError(`Project path "${this.projectPath}" not found`);
-      }
-      this.metadata.resource = payload.resource;
+    if (payload.connections) {
+      logger2.info(`Updating ${payload.connections.length} connections for project ${this.projectName}`);
+      const { malloyConnections, apiConnections } = await createConnections(this.projectPath, payload.connections);
+      this.malloyConnections = malloyConnections;
+      this.apiConnections = apiConnections;
+      this.internalConnections = apiConnections;
+      logger2.info(`Successfully updated connections for project ${this.projectName}`, {
+        malloyConnections: malloyConnections.size,
+        apiConnections: apiConnections.length,
+        internalConnections: apiConnections.length
+      });
     }
-    this.metadata.readme = payload.readme;
     return this;
   }
   static async create(projectName, projectPath, defaultConnections) {
     if (!(await fs8.promises.stat(projectPath)).isDirectory()) {
       throw new ProjectNotFoundError(`Project path ${projectPath} not found`);
     }
-    const { malloyConnections, apiConnections } = await createConnections(projectPath, defaultConnections);
+    let malloyConnections = new Map;
+    let apiConnections = [];
+    logger2.info(`Creating project with connection configuration`);
+    const result = await createConnections(projectPath, defaultConnections);
+    malloyConnections = result.malloyConnections;
+    apiConnections = result.apiConnections;
     logger2.info(`Loaded ${malloyConnections.size + apiConnections.length} connections for project ${projectName}`, {
       malloyConnections,
       apiConnections
@@ -238848,14 +238866,18 @@ class Project {
       const packageDirectories = files.filter((file) => file.isDirectory() && fs8.existsSync(path6.join(this.projectPath, file.name, PACKAGE_MANIFEST_NAME)));
       const packageMetadata = await Promise.all(packageDirectories.map(async (directory) => {
         try {
-          return (await this.getPackage(directory.name, false)).getPackageMetadata();
+          return (this.packageStatuses.get(directory.name)?.status === "loading" /* LOADING */ ? undefined : await this.getPackage(directory.name, false))?.getPackageMetadata();
         } catch (error) {
           logger2.error(`Failed to load package: ${directory.name} due to : ${error}`);
           return;
         }
       }));
       const filteredMetadata = packageMetadata.filter((metadata) => metadata);
-      return filteredMetadata;
+      const finalMetadata = filteredMetadata.filter((metadata) => {
+        const packageStatus = this.packageStatuses.get(metadata.name || "");
+        return packageStatus?.status !== "unloading" /* UNLOADING */;
+      });
+      return finalMetadata;
     } catch (error) {
       logger2.error("Error listing packages", { error });
       console.error(error);
@@ -238863,41 +238885,56 @@ class Project {
     }
   }
   async getPackage(packageName, reload = false) {
+    const _package = this.packages.get(packageName);
+    if (_package !== undefined && !reload) {
+      return _package;
+    }
     let packageMutex = this.packageMutexes.get(packageName);
     if (packageMutex?.isLocked()) {
       await packageMutex.waitForUnlock();
-      return this.packages.get(packageName);
+      const existingPackage = this.packages.get(packageName);
+      if (existingPackage) {
+        return existingPackage;
+      }
     }
     packageMutex = new Mutex;
     this.packageMutexes.set(packageName, packageMutex);
     return packageMutex.runExclusive(async () => {
-      const _package = this.packages.get(packageName);
-      if (_package !== undefined && !reload) {
-        return _package;
+      const existingPackage = this.packages.get(packageName);
+      if (existingPackage !== undefined && !reload) {
+        return existingPackage;
       }
+      this.setPackageStatus(packageName, "loading" /* LOADING */);
       try {
         const _package2 = await Package.create(this.projectName, packageName, path6.join(this.projectPath, packageName), this.malloyConnections);
         this.packages.set(packageName, _package2);
+        this.setPackageStatus(packageName, "serving" /* SERVING */);
         return _package2;
       } catch (error) {
         this.packages.delete(packageName);
+        this.packageStatuses.delete(packageName);
         throw error;
-      } finally {
-        packageMutex.release();
-        this.packageMutexes.delete(packageName);
       }
     });
   }
   async addPackage(packageName) {
     const packagePath = path6.join(this.projectPath, packageName);
-    if (!await fs8.promises.exists(packagePath) || !(await fs8.promises.stat(packagePath)).isDirectory()) {
+    if (!await fs8.promises.access(packagePath).then(() => true).catch(() => false) || !(await fs8.promises.stat(packagePath)).isDirectory()) {
       throw new PackageNotFoundError(`Package ${packageName} not found`);
     }
     logger2.info(`Adding package ${packageName} to project ${this.projectName}`, {
       packagePath,
       malloyConnections: this.malloyConnections
     });
-    this.packages.set(packageName, await Package.create(this.projectName, packageName, packagePath, this.malloyConnections));
+    this.setPackageStatus(packageName, "loading" /* LOADING */);
+    try {
+      this.packages.set(packageName, await Package.create(this.projectName, packageName, packagePath, this.malloyConnections));
+    } catch (error) {
+      logger2.error("Error adding package", { error });
+      this.deletePackageStatus(packageName);
+      throw error;
+    }
+    this.setPackageStatus(packageName, "serving" /* SERVING */);
     return this.packages.get(packageName);
   }
   async updatePackage(packageName, body) {
@@ -238916,15 +238953,45 @@ class Project {
     });
     return _package.getPackageMetadata();
   }
+  getPackageStatus(packageName) {
+    return this.packageStatuses.get(packageName);
+  }
+  setPackageStatus(packageName, status) {
+    const currentStatus = this.packageStatuses.get(packageName);
+    this.packageStatuses.set(packageName, {
+      name: packageName,
+      loadTimestamp: currentStatus?.loadTimestamp || Date.now(),
+      status
+    });
+  }
+  deletePackageStatus(packageName) {
+    this.packageStatuses.delete(packageName);
+  }
   async deletePackage(packageName) {
     const _package = this.packages.get(packageName);
     if (!_package) {
       return;
     }
-    await fs8.promises.rm(path6.join(this.projectPath, packageName), {
-      recursive: true
-    });
+    const packageStatus = this.packageStatuses.get(packageName);
+    if (packageStatus?.status === "loading" /* LOADING */) {
+      logger2.error("Package loading. Can't unload.", {
+        projectName: this.projectName,
+        packageName
+      });
+      throw new Error("Package loading. Can't unload. " + this.projectName + " " + packageName);
+    } else if (packageStatus?.status === "serving" /* SERVING */) {
+      this.setPackageStatus(packageName, "unloading" /* UNLOADING */);
+    }
+    try {
+      await fs8.promises.rm(path6.join(this.projectPath, packageName), {
+        recursive: true,
+        force: true
+      });
+    } catch (err) {
+      logger2.error("Error removing package directory while unloading package", { error: err, projectName: this.projectName, packageName });
+    }
     this.packages.delete(packageName);
+    this.packageStatuses.delete(packageName);
   }
   async serialize() {
     return {
@@ -238941,12 +239008,14 @@ class ProjectStore {
   projects = new Map;
   publisherConfigIsFrozen;
   finishedInitialization;
+  isInitialized = false;
   s3Client = new import_client_s3.S3({
     followRegionRedirects: true
   });
-  gcsClient = new import_storage.Storage;
+  gcsClient;
   constructor(serverRootPath) {
     this.serverRootPath = serverRootPath;
+    this.gcsClient = new import_storage.Storage;
     this.finishedInitialization = this.initialize();
   }
   async initialize() {
@@ -238955,15 +239024,15 @@ class ProjectStore {
       this.publisherConfigIsFrozen = isPublisherConfigFrozen(this.serverRootPath);
       const projectManifest = await ProjectStore.reloadProjectManifest(this.serverRootPath);
       logger2.info(`Initializing project store.`);
-      await Promise.all(Object.keys(projectManifest.projects).map(async (projectName) => {
-        logger2.info(`Adding project "${projectName}"`);
-        const project = await this.addProject({
-          name: projectName,
-          resource: `${API_PREFIX}/projects/${projectName}`,
-          location: projectManifest.projects[projectName]
+      await Promise.all(projectManifest.projects.map(async (project) => {
+        logger2.info(`Adding project "${project.name}"`);
+        const projectInstance = await this.addProject({
+          name: project.name,
+          resource: `${API_PREFIX}/projects/${project.name}`
         }, true);
-        return project.listPackages();
+        return projectInstance.listPackages();
       }));
+      this.isInitialized = true;
       logger2.info(`Project store successfully initialized in ${performance.now() - initialTime}ms`);
     } catch (error) {
       logger2.error("Error initializing project store", { error });
@@ -238971,16 +239040,55 @@ class ProjectStore {
       process.exit(1);
     }
   }
-  async listProjects() {
-    await this.finishedInitialization;
+  async listProjects(skipInitializationCheck = false) {
+    if (!skipInitializationCheck) {
+      await this.finishedInitialization;
+    }
     return Promise.all(Array.from(this.projects.values()).map((project) => project.serialize()));
   }
+  async getStatus() {
+    const status = {
+      timestamp: Date.now(),
+      projects: [],
+      initialized: this.isInitialized
+    };
+    const projects = await this.listProjects(true);
+    await Promise.all(projects.map(async (project) => {
+      try {
+        const packages = project.packages;
+        const connections = project.connections;
+        logger2.info(`Project ${project.name} status:`, {
+          connectionsCount: project.connections?.length || 0,
+          packagesCount: packages?.length || 0
+        });
+        const _connections = connections?.map((connection) => {
+          return {
+            ...connection,
+            attributes: undefined
+          };
+        });
+        const _project = {
+          ...project,
+          connections: _connections
+        };
+        project.connections = _connections;
+        status.projects.push(_project);
+      } catch (error) {
+        logger2.error("Error listing packages and connections", {
+          error
+        });
+        throw new Error("Error listing packages and connections: " + error);
+      }
+    }));
+    return status;
+  }
   async getProject(projectName, reload = false) {
     await this.finishedInitialization;
     let project = this.projects.get(projectName);
     if (project === undefined || reload) {
       const projectManifest = await ProjectStore.reloadProjectManifest(this.serverRootPath);
-      const projectPath = project?.metadata.location || projectManifest.projects[projectName];
+      const projectConfig = projectManifest.projects.find((p) => p.name === projectName);
+      const projectPath = project?.metadata.location || projectConfig?.packages[0]?.location;
       if (!projectPath) {
         throw new ProjectNotFoundError(`Project "${projectName}" could not be resolved to a path.`);
       }
@@ -239002,11 +239110,20 @@ class ProjectStore {
     if (!projectName) {
       throw new Error("Project name is required");
     }
+    const existingProject = this.projects.get(projectName);
+    if (existingProject) {
+      logger2.info(`Project ${projectName} already exists, updating it`);
+      const updatedProject = await existingProject.update(project);
+      this.projects.set(projectName, updatedProject);
+      return updatedProject;
+    }
     const projectManifest = await ProjectStore.reloadProjectManifest(this.serverRootPath);
-    const projectPath = project.location || projectManifest.projects[projectName];
+    const projectConfig = projectManifest.projects.find((p) => p.name === projectName);
+    const hasPackages = project?.packages && project.packages.length > 0 || projectConfig?.packages && projectConfig.packages.length > 0;
     let absoluteProjectPath;
-    if (projectPath) {
-      absoluteProjectPath = await this.loadProjectIntoDisk(projectName, projectPath);
+    if (hasPackages) {
+      const packagesToProcess = project?.packages || projectConfig?.packages || [];
+      absoluteProjectPath = await this.loadProjectIntoDisk(projectName, projectName, packagesToProcess);
       if (absoluteProjectPath.endsWith(".zip")) {
         absoluteProjectPath = await this.unzipProject(absoluteProjectPath);
       }
@@ -239064,16 +239181,24 @@ class ProjectStore {
     } catch (error) {
       if (error.code !== "ENOENT") {
         logger2.error(`Error reading ${PUBLISHER_CONFIG_NAME}. Generating from directory`, { error });
-        return { projects: {} };
+        return { projects: [] };
       } else {
         try {
           const entries = await fs9.promises.readdir(serverRootPath, {
             withFileTypes: true
           });
-          const projects = {};
+          const projects = [];
           for (const entry of entries) {
             if (entry.isDirectory()) {
-              projects[entry.name] = entry.name;
+              projects.push({
+                name: entry.name,
+                packages: [
+                  {
+                    name: entry.name,
+                    location: entry.name
+                  }
+                ]
+              });
             }
           }
           return { projects };
@@ -239081,7 +239206,7 @@ class ProjectStore {
           logger2.error(`Error listing directories in ${serverRootPath}`, {
             error: lsError
           });
-          return { projects: {} };
+          return { projects: [] };
         }
       }
     }
@@ -239098,59 +239223,125 @@ class ProjectStore {
     }
     return absoluteProjectPath;
   }
-  async loadProjectIntoDisk(projectName, projectPath) {
-    const absoluteTargetPath = `${publisherPath}/${projectName}`;
-    if (projectPath.startsWith("/") || projectPath.startsWith("./")) {
+  async loadProjectIntoDisk(projectName, projectPath, packages) {
+    const absoluteTargetPath = `${publisherPath}/${projectPath}`;
+    if (!packages || packages.length === 0) {
+      throw new PackageNotFoundError(`No packages found for project ${projectName}`);
+    }
+    const locationGroups = new Map;
+    for (const _package of packages) {
+      if (!_package.name) {
+        throw new PackageNotFoundError(`Package has no name specified`);
+      }
+      if (!_package.location) {
+        throw new PackageNotFoundError(`Package ${_package.name} has no location specified`);
+      }
+      const location = _package.location;
+      const packageName = _package.name;
+      if (!locationGroups.has(location)) {
+        locationGroups.set(location, []);
+      }
+      locationGroups.get(location).push({ name: packageName, location });
+    }
+    for (const [location, packagesForLocation] of locationGroups) {
+      const tempDownloadPath = `${absoluteTargetPath}/.temp_${Buffer.from(location).toString("base64").replace(/[^a-zA-Z0-9]/g, "")}`;
+      await fs9.promises.mkdir(tempDownloadPath, { recursive: true });
+      try {
+        await this.downloadOrMountLocation(location, tempDownloadPath, projectName, "shared");
+        for (const _package of packagesForLocation) {
+          const packageDir = _package.name;
+          const absolutePackagePath = `${absoluteTargetPath}/${packageDir}`;
+          const packagePathInDownload = path7.join(tempDownloadPath, packageDir);
+          const packageExists = await fs9.promises.access(packagePathInDownload).then(() => true).catch(() => false);
+          if (packageExists) {
+            await fs9.promises.mkdir(absolutePackagePath, {
+              recursive: true
+            });
+            await fs9.promises.cp(packagePathInDownload, absolutePackagePath, { recursive: true });
+            logger2.info(`Extracted package "${packageDir}" from shared download`);
+          } else {
+            await fs9.promises.mkdir(absolutePackagePath, {
+              recursive: true
+            });
+            await fs9.promises.cp(tempDownloadPath, absolutePackagePath, {
+              recursive: true
+            });
+            logger2.info(`Copied entire download as package "${packageDir}"`);
+          }
+        }
+        const connectionsFileInDownload = path7.join(tempDownloadPath, CONNECTIONS_MANIFEST_NAME);
+        const connectionsFileInProject = path7.join(absoluteTargetPath, CONNECTIONS_MANIFEST_NAME);
+        try {
+          await fs9.promises.access(connectionsFileInDownload, fs9.constants.F_OK);
+          await fs9.promises.cp(connectionsFileInDownload, connectionsFileInProject);
+          logger2.info(`Copied ${CONNECTIONS_MANIFEST_NAME} to project directory`);
+        } catch (error) {
+          console.error(error);
+          logger2.info(`No ${CONNECTIONS_MANIFEST_NAME} found`);
+        }
+      } finally {
+        await fs9.promises.rm(tempDownloadPath, {
+          recursive: true,
+          force: true
+        });
+      }
+    }
+    return absoluteTargetPath;
+  }
+  async downloadOrMountLocation(location, targetPath, projectName, packageName) {
+    if (location.startsWith("/")) {
       try {
-        logger2.info(`Mounting local directory at "${projectPath}"`);
-        await this.mountLocalDirectory(projectPath, absoluteTargetPath, projectName);
-        return absoluteTargetPath;
+        logger2.info(`Mounting local directory at "${location}" to "${targetPath}"`);
+        await this.mountLocalDirectory(location, targetPath, projectName, packageName);
+        return;
       } catch (error) {
-        logger2.error(`Failed to mount local directory "${projectPath}"`, {
+        logger2.error(`Failed to mount local directory "${location}"`, {
           error
         });
-        throw error;
+        throw new PackageNotFoundError(`Failed to mount local directory: ${location}`);
       }
     }
-    if (projectPath.startsWith("gs://")) {
+    if (location.startsWith("gs://")) {
       try {
-        logger2.info(`Downloading GCS path "${projectPath}" to "${absoluteTargetPath}"`);
-        await this.downloadGcsDirectory(projectPath, projectName, absoluteTargetPath);
+        logger2.info(`Downloading GCS directory from "${location}" to "${targetPath}"`);
+        await this.downloadGcsDirectory(location, projectName, targetPath);
+        return;
       } catch (error) {
-        logger2.error(`Failed to download GCS path "${projectPath}"`, {
+        logger2.error(`Failed to download GCS directory "${location}"`, {
           error
         });
-        throw error;
+        throw new PackageNotFoundError(`Failed to download GCS directory: ${location}`);
       }
-      return absoluteTargetPath;
     }
-    if (projectPath.startsWith("s3://")) {
+    if (location.startsWith("https://github.com/") || location.startsWith("git@")) {
       try {
-        logger2.info(`Mounting S3 path "${projectPath}"`);
-        await this.downloadS3Directory(projectPath, projectName, absoluteTargetPath);
-        return absoluteTargetPath;
+        logger2.info(`Cloning GitHub repository from "${location}" to "${targetPath}"`);
+        await this.downloadGitHubDirectory(location, targetPath);
+        return;
       } catch (error) {
-        logger2.error(`Failed to mount S3 path "${projectPath}"`, { error });
-        throw error;
+        logger2.error(`Failed to clone GitHub repository "${location}"`, {
+          error
+        });
+        throw new PackageNotFoundError(`Failed to clone GitHub repository: ${location}`);
       }
     }
-    if (projectPath.startsWith("https://github.com/") || projectPath.startsWith("git@")) {
+    if (location.startsWith("s3://")) {
       try {
-        logger2.info(`Mounting GitHub path "${projectPath}"`);
-        await this.downloadGitHubDirectory(projectPath, absoluteTargetPath);
-        return absoluteTargetPath;
+        logger2.info(`Downloading S3 directory from "${location}" to "${targetPath}"`);
+        await this.downloadS3Directory(location, projectName, targetPath);
+        return;
       } catch (error) {
-        logger2.error(`Failed to mount GitHub path "${projectPath}"`, {
+        logger2.error(`Failed to download S3 directory "${location}"`, {
           error
         });
-        throw error;
+        throw new PackageNotFoundError(`Failed to download S3 directory: ${location}`);
       }
     }
-    const errorMsg = `Invalid project path: "${projectPath}". Paths must start with "/" or "./" or a GCS/S3/GitHub URI.`;
-    logger2.error(errorMsg, { projectName, projectPath });
-    throw new ProjectNotFoundError(errorMsg);
+    const errorMsg = `Invalid package path: "${location}". Must be an absolute mounted path or a GCS/S3/GitHub URI.`;
+    logger2.error(errorMsg, { projectName, location });
+    throw new PackageNotFoundError(errorMsg);
   }
-  async mountLocalDirectory(projectPath, absoluteTargetPath, projectName) {
+  async mountLocalDirectory(projectPath, absoluteTargetPath, projectName, packageName) {
     if (projectPath.endsWith(".zip")) {
       projectPath = await this.unzipProject(projectPath);
     }
@@ -239165,7 +239356,7 @@ class ProjectStore {
         recursive: true
       });
     } else {
-      throw new ProjectNotFoundError(`Project ${projectName} not found in "${projectPath}"`);
+      throw new PackageNotFoundError(`Package ${packageName} for project ${projectName} not found in "${projectPath}"`);
     }
   }
   async downloadGcsDirectory(gcsPath, projectName, absoluteDirPath) {
@@ -239273,14 +239464,21 @@ class WatchModeController {
   startWatching = async (req, res) => {
     const projectManifest = await ProjectStore.reloadProjectManifest(this.projectStore.serverRootPath);
     this.watchingProjectName = req.body.projectName;
-    this.watchingPath = import_path4.default.join(this.projectStore.serverRootPath, projectManifest.projects[req.body.projectName]);
+    const project = projectManifest.projects.find((p) => p.name === req.body.projectName);
+    if (!project || !project.packages || project.packages.length === 0) {
+      res.status(404).json({
+        error: `Project ${req.body.projectName} not found or has no packages`
+      });
+      return;
+    }
+    this.watchingPath = import_path4.default.join(this.projectStore.serverRootPath, req.body.projectName);
     this.watcher = esm_default.watch(this.watchingPath, {
       ignored: (path9, stats) => !!stats?.isFile() && !path9.endsWith(".malloy") && !path9.endsWith(".md"),
       ignoreInitial: true
     });
     const reloadProject = async () => {
-      const project = await this.projectStore.getProject(req.body.projectName, true);
-      await this.projectStore.addProject(project.metadata);
+      const project2 = await this.projectStore.getProject(req.body.projectName, true);
+      await this.projectStore.addProject(project2.metadata);
       logger2.info(`Reloaded ${req.body.projectName}`);
     };
     this.watcher.on("add", async (path9) => {
@@ -242428,7 +242626,7 @@ async function handleGetPackageContents(uri, params, projectStore) {
     }
     const project = await projectStore.getProject(projectName, false);
     const packageInstance = await project.getPackage(packageName, false);
-    const entries = packageInstance.listModels();
+    const entries = await packageInstance.listModels();
     const resourceDefinitions = [];
     for (const entry of entries) {
       const entryPath = entry.path;
@@ -243271,10 +243469,14 @@ var setVersionIdError = (res) => {
 app.use(import_cors.default());
 app.use(bodyParser.json());
 app.get(`${API_PREFIX2}/status`, async (_req, res) => {
-  res.status(200).json({
-    timestamp: Date.now(),
-    projects: await projectStore.listProjects()
-  });
+  try {
+    const status = await projectStore.getStatus();
+    res.status(200).json(status);
+  } catch (error) {
+    logger2.error("Error getting status", { error });
+    const { json: json2, status } = internalErrorToHttpError(error);
+    res.status(status).json(json2);
+  }
 });
 app.get(`${API_PREFIX2}/watch-mode/status`, watchModeController.getWatchStatus);
 app.post(`${API_PREFIX2}/watch-mode/start`, watchModeController.startWatching);