@malloy-publisher/server 0.0.90 → 0.0.92

package/dist/server.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
@@ -231302,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";
 }
 
@@ -231562,13 +231563,16 @@ async function getSchemasForConnection(connection) {
       const projectId = connection.bigqueryConnection.defaultProjectId;
       const options = projectId ? { projectId } : {};
       const [datasets] = await bigquery.getDatasets(options);
-      return datasets.filter((dataset) => dataset.id).map((dataset) => {
+      const schemas = await Promise.all(datasets.filter((dataset) => dataset.id).map(async (dataset) => {
+        const [metadata] = await dataset.getMetadata();
         return {
           name: dataset.id,
           isHidden: false,
-          isDefault: false
+          isDefault: false,
+          description: metadata?.description
         };
-      });
+      }));
+      return schemas;
     } catch (error) {
       console.error(`Error getting schemas for BigQuery connection ${connection.name}:`, error);
       throw new Error(`Failed to get schemas for BigQuery connection ${connection.name}: ${error.message}`);
@@ -231714,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 {
@@ -231962,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);
     }
   }
 }
@@ -233579,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");
@@ -237571,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);
@@ -237811,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 () => {
@@ -237929,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) {
@@ -238744,6 +238760,7 @@ class Package {
 class Project {
   packages = new Map;
   packageMutexes = new Map;
+  packageStatuses = new Map;
   malloyConnections;
   apiConnections;
   internalConnections;
@@ -238764,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
@@ -238844,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);
@@ -238859,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) {
@@ -238912,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) {
-      throw new PackageNotFoundError(`Package ${packageName} not found`);
+      return;
+    }
+    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 });
     }
-    await fs8.promises.rm(path6.join(this.projectPath, packageName), {
-      recursive: true
-    });
     this.packages.delete(packageName);
+    this.packageStatuses.delete(packageName);
   }
   async serialize() {
     return {
@@ -238937,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() {
@@ -238951,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 });
@@ -238967,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.`);
       }
@@ -238998,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);
       }
@@ -239049,7 +239170,7 @@ class ProjectStore {
     }
     const project = this.projects.get(projectName);
     if (!project) {
-      throw new ProjectNotFoundError(`Project ${projectName} not found`);
+      return;
     }
     this.projects.delete(projectName);
     return project;
@@ -239060,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 };
@@ -239077,7 +239206,7 @@ class ProjectStore {
           logger2.error(`Error listing directories in ${serverRootPath}`, {
             error: lsError
           });
-          return { projects: {} };
+          return { projects: [] };
         }
       }
     }
@@ -239094,59 +239223,128 @@ class ProjectStore {
     }
     return absoluteProjectPath;
   }
-  async loadProjectIntoDisk(projectName, projectPath) {
-    const absoluteTargetPath = `${publisherPath}/${projectName}`;
-    if (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}". Must be an absolute mounted path 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);
+    }
     const projectDirExists = (await fs9.promises.stat(projectPath)).isDirectory();
     if (projectDirExists) {
       await fs9.promises.rm(absoluteTargetPath, {
@@ -239158,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) {
@@ -239266,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) => {
@@ -242421,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;
@@ -243264,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);
@@ -243315,7 +243524,7 @@ app.patch(`${API_PREFIX2}/projects/:projectName`, async (req, res) => {
 app.delete(`${API_PREFIX2}/projects/:projectName`, async (req, res) => {
   try {
     const project = await projectStore.deleteProject(req.params.projectName);
-    res.status(200).json(await project.serialize());
+    res.status(200).json(await project?.serialize());
   } catch (error) {
     logger2.error(error);
     const { json: json2, status } = internalErrorToHttpError(error);