@malloy-publisher/server 0.0.85 → 0.0.86

package/dist/server.js

@@ -228489,14 +228489,14 @@ var require_brace_expansion2 = __commonJS((exports2, module2) => {
 var require_minimatch = __commonJS((exports2, module2) => {
   module2.exports = minimatch;
   minimatch.Minimatch = Minimatch;
-  var path3 = function() {
+  var path4 = function() {
     try {
       return require("path");
     } catch (e) {}
   }() || {
     sep: "/"
   };
-  minimatch.sep = path3.sep;
+  minimatch.sep = path4.sep;
   var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {};
   var expand = require_brace_expansion2();
   var plTypes = {
@@ -228587,8 +228587,8 @@ var require_minimatch = __commonJS((exports2, module2) => {
     if (!options)
       options = {};
     pattern = pattern.trim();
-    if (!options.allowWindowsEscape && path3.sep !== "/") {
-      pattern = pattern.split(path3.sep).join("/");
+    if (!options.allowWindowsEscape && path4.sep !== "/") {
+      pattern = pattern.split(path4.sep).join("/");
     }
     this.options = options;
     this.set = [];
@@ -228965,8 +228965,8 @@ var require_minimatch = __commonJS((exports2, module2) => {
     if (f === "/" && partial)
       return true;
     var options = this.options;
-    if (path3.sep !== "/") {
-      f = f.split(path3.sep).join("/");
+    if (path4.sep !== "/") {
+      f = f.split(path4.sep).join("/");
     }
     f = f.split(slashSplit);
     this.debug(this.pattern, "split", f);
@@ -229077,9 +229077,9 @@ var require_recursive_readdir = __commonJS((exports2, module2) => {
   var p = require("path");
   var minimatch = require_minimatch();
   function patternMatcher(pattern) {
-    return function(path3, stats) {
+    return function(path4, stats) {
       var minimatcher = new minimatch.Minimatch(pattern, { matchBase: true });
-      return (!minimatcher.negate || stats.isFile()) && minimatcher.match(path3);
+      return (!minimatcher.negate || stats.isFile()) && minimatcher.match(path4);
     };
   }
   function toMatcherFunction(ignoreEntry) {
@@ -229089,14 +229089,14 @@ var require_recursive_readdir = __commonJS((exports2, module2) => {
       return patternMatcher(ignoreEntry);
     }
   }
-  function readdir(path3, ignores, callback) {
+  function readdir(path4, ignores, callback) {
     if (typeof ignores == "function") {
       callback = ignores;
       ignores = [];
     }
     if (!callback) {
       return new Promise(function(resolve, reject) {
-        readdir(path3, ignores || [], function(err, data) {
+        readdir(path4, ignores || [], function(err, data) {
           if (err) {
             reject(err);
           } else {
@@ -229107,7 +229107,7 @@ var require_recursive_readdir = __commonJS((exports2, module2) => {
     }
     ignores = ignores.map(toMatcherFunction);
     var list = [];
-    fs4.readdir(path3, function(err, files) {
+    fs4.readdir(path4, function(err, files) {
       if (err) {
         return callback(err);
       }
@@ -229116,7 +229116,7 @@ var require_recursive_readdir = __commonJS((exports2, module2) => {
         return callback(null, list);
       }
       files.forEach(function(file) {
-        var filePath = p.join(path3, file);
+        var filePath = p.join(path4, file);
         fs4.stat(filePath, function(_err, stats) {
           if (_err) {
             return callback(_err);
@@ -230033,7 +230033,7 @@ var require_scheduled_task = __commonJS((exports2, module2) => {
 var require_background_scheduled_task = __commonJS((exports2, module2) => {
   var __dirname = "/home/runner/work/publisher/publisher/node_modules/node-cron/src/background-scheduled-task";
   var EventEmitter = require("events");
-  var path4 = require("path");
+  var path5 = require("path");
   var { fork } = require("child_process");
   var uuid = require_dist19();
   var daemonPath = `${__dirname}/daemon.js`;
@@ -230069,7 +230069,7 @@ var require_background_scheduled_task = __commonJS((exports2, module2) => {
       options.scheduled = true;
       this.forkProcess.send({
         type: "register",
-        path: path4.resolve(this.taskPath),
+        path: path5.resolve(this.taskPath),
         cron: this.cronExpression,
         options
       });
@@ -235134,16 +235134,23 @@ var import_cors = __toESM(require_lib4());
 var import_express = __toESM(require_express2());
 var http = __toESM(require("http"));
 var import_http_proxy_middleware = __toESM(require_dist());
-var path7 = __toESM(require("path"));
+var path8 = __toESM(require("path"));
 
 // src/errors.ts
+var import_malloy = require("@malloydata/malloy");
 function internalErrorToHttpError(error) {
   if (error instanceof BadRequestError) {
     return httpError(400, error.message);
+  } else if (error instanceof FrozenConfigError) {
+    return httpError(403, error.message);
+  } else if (error instanceof ProjectNotFoundError) {
+    return httpError(404, error.message);
   } else if (error instanceof PackageNotFoundError) {
     return httpError(404, error.message);
   } else if (error instanceof ModelNotFoundError) {
     return httpError(404, error.message);
+  } else if (error instanceof import_malloy.MalloyError) {
+    return httpError(400, error.message);
   } else if (error instanceof ConnectionNotFoundError) {
     return httpError(404, error.message);
   } else if (error instanceof ModelCompilationError) {
@@ -235212,10 +235219,17 @@ class ModelCompilationError extends Error {
   }
 }
 
+class FrozenConfigError extends Error {
+  constructor(message = "Publisher config can't be updated when publisher.config.json has `frozenConfig: true`") {
+    super(message);
+  }
+}
+
 // src/logger.ts
 var import_winston = __toESM(require_winston());
+var isTelemetryEnabled = Boolean(process.env.OTEL_EXPORTER_OTLP_ENDPOINT);
 var logger = import_winston.default.createLogger({
-  format: import_winston.default.format.combine(import_winston.default.format.uncolorize(), import_winston.default.format.timestamp(), import_winston.default.format.json()),
+  format: isTelemetryEnabled ? import_winston.default.format.combine(import_winston.default.format.uncolorize(), import_winston.default.format.timestamp(), import_winston.default.format.json()) : import_winston.default.format.combine(import_winston.default.format.colorize(), import_winston.default.format.simple()),
   transports: [new import_winston.default.transports.Console]
 });
 var loggerMiddleware = (req, res, next) => {
@@ -235352,9 +235366,9 @@ async function getSchemasForConnection(connection) {
     }
     try {
       const bigquery = getBigqueryConnection(connection);
-      const [datasets] = await bigquery.getDatasets({
-        ...connection.bigqueryConnection.defaultProjectId ? { projectId: connection.bigqueryConnection.defaultProjectId } : {}
-      });
+      const projectId = connection.bigqueryConnection.defaultProjectId;
+      const options = projectId ? { projectId } : {};
+      const [datasets] = await bigquery.getDatasets(options);
       return datasets.filter((dataset) => dataset.id).map((dataset) => {
         return {
           name: dataset.id,
@@ -235699,6 +235713,30 @@ class PackageController {
     const p = await project.getPackage(packageName, reload);
     return p.getPackageMetadata();
   }
+  async addPackage(projectName, body) {
+    if (this.projectStore.publisherConfigIsFrozen) {
+      throw new FrozenConfigError;
+    }
+    if (!body.name) {
+      throw new BadRequestError("Package name is required");
+    }
+    const project = await this.projectStore.getProject(projectName, false);
+    return project.addPackage(body.name);
+  }
+  async deletePackage(projectName, packageName) {
+    if (this.projectStore.publisherConfigIsFrozen) {
+      throw new FrozenConfigError;
+    }
+    const project = await this.projectStore.getProject(projectName, false);
+    return project.deletePackage(packageName);
+  }
+  async updatePackage(projectName, packageName, body) {
+    if (this.projectStore.publisherConfigIsFrozen) {
+      throw new FrozenConfigError;
+    }
+    const project = await this.projectStore.getProject(projectName, false);
+    return project.updatePackage(packageName, body);
+  }
 }
 
 // src/constants.ts
@@ -243179,7 +243217,7 @@ function registerTools(mcpServer, projectStore) {
     const mappedResources = await Promise.all(allProjects.map(async (project) => {
       const name = project.name;
       const projectInstance = await project.project;
-      const metadata = await projectInstance.getProjectMetadata();
+      const metadata = await projectInstance.reloadProjectMetadata();
       const readme = metadata.readme;
       return {
         name,
@@ -243480,7 +243518,34 @@ function initializeMcpServer(projectStore) {
 
 // src/service/project_store.ts
 var fs7 = __toESM(require("fs/promises"));
-var path6 = __toESM(require("path"));
+var path7 = __toESM(require("path"));
+
+// src/utils.ts
+var fs2 = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+var import_url = require("url");
+var PACKAGE_MANIFEST_NAME = "publisher.json";
+var CONNECTIONS_MANIFEST_NAME = "publisher.connections.json";
+var MODEL_FILE_SUFFIX = ".malloy";
+var NOTEBOOK_FILE_SUFFIX = ".malloynb";
+var ROW_LIMIT = 1000;
+var URL_READER = {
+  readURL: (url) => {
+    let path3 = url.toString();
+    if (url.protocol == "file:") {
+      path3 = import_url.fileURLToPath(url);
+    }
+    return fs2.promises.readFile(path3, "utf8");
+  }
+};
+var isPublisherConfigFrozen = (serverRoot) => {
+  const publisherConfigPath = import_path2.default.join(serverRoot, "publisher.config.json");
+  if (!fs2.existsSync(publisherConfigPath)) {
+    return false;
+  }
+  const publisherConfig = JSON.parse(fs2.readFileSync(publisherConfigPath, "utf8"));
+  return Boolean(publisherConfig.frozenConfig);
+};
 
 // ../../node_modules/async-mutex/index.mjs
 var E_TIMEOUT = new Error("timeout while waiting for mutex to become available");
@@ -243692,7 +243757,7 @@ class Mutex {
 
 // src/service/project.ts
 var fs6 = __toESM(require("fs/promises"));
-var path5 = __toESM(require("path"));
+var path6 = __toESM(require("path"));
 
 // src/service/connection.ts
 var import_db_postgres = require("@malloydata/db-postgres");
@@ -243700,30 +243765,10 @@ var import_db_bigquery = require("@malloydata/db-bigquery");
 var import_db_snowflake = require("@malloydata/db-snowflake");
 var import_db_trino = require("@malloydata/db-trino");
 var import_db_mysql = require("@malloydata/db-mysql");
-var import_path2 = __toESM(require("path"));
+var import_path3 = __toESM(require("path"));
 var import_promises = __toESM(require("fs/promises"));
-
-// src/utils.ts
-var import_fs2 = require("fs");
-var import_url = require("url");
-var PACKAGE_MANIFEST_NAME = "publisher.json";
-var CONNECTIONS_MANIFEST_NAME = "publisher.connections.json";
-var MODEL_FILE_SUFFIX = ".malloy";
-var NOTEBOOK_FILE_SUFFIX = ".malloynb";
-var ROW_LIMIT = 1000;
-var URL_READER = {
-  readURL: (url) => {
-    let path2 = url.toString();
-    if (url.protocol == "file:") {
-      path2 = import_url.fileURLToPath(url);
-    }
-    return import_fs2.promises.readFile(path2, "utf8");
-  }
-};
-
-// src/service/connection.ts
 async function readConnectionConfig(basePath) {
-  const fullPath = import_path2.default.join(basePath, CONNECTIONS_MANIFEST_NAME);
+  const fullPath = import_path3.default.join(basePath, CONNECTIONS_MANIFEST_NAME);
   try {
     await import_promises.default.stat(fullPath);
   } catch {
@@ -243782,7 +243827,7 @@ async function createConnections(basePath) {
           }
           let serviceAccountKeyPath = undefined;
           if (connection.bigqueryConnection.serviceAccountKeyJson) {
-            serviceAccountKeyPath = import_path2.default.join("/tmp", `${connection.name}-${v4_default()}-service-account-key.json`);
+            serviceAccountKeyPath = import_path3.default.join("/tmp", `${connection.name}-${v4_default()}-service-account-key.json`);
             await import_promises.default.writeFile(serviceAccountKeyPath, connection.bigqueryConnection.serviceAccountKeyJson);
           }
           const bigqueryConnectionOptions = {
@@ -243873,19 +243918,19 @@ function getConnectionAttributes(connection) {
 
 // src/service/package.ts
 var fs5 = __toESM(require("fs/promises"));
-var path4 = __toESM(require("path"));
+var path5 = __toESM(require("path"));
 var import_db_duckdb = require("@malloydata/db-duckdb");
-var import_malloy2 = require("@malloydata/malloy");
+var import_malloy3 = require("@malloydata/malloy");
 var import_api2 = __toESM(require_src25());
 var import_recursive_readdir = __toESM(require_recursive_readdir());
 
 // src/service/model.ts
-var import_malloy = require("@malloydata/malloy");
+var import_malloy2 = require("@malloydata/malloy");
 var import_malloy_sql = require("@malloydata/malloy-sql");
 var import__package = __toESM(require("@malloydata/malloy/package.json"));
 var import_api = __toESM(require_src25());
 var fs4 = __toESM(require("fs/promises"));
-var path3 = __toESM(require("path"));
+var path4 = __toESM(require("path"));
 
 // src/data_styles.ts
 function compileDataStyles(styles) {
@@ -243965,7 +244010,7 @@ class Model {
     this.queries = queries;
     this.runnableNotebookCells = runnableNotebookCells;
     this.compilationError = compilationError;
-    this.modelInfo = this.modelDef ? import_malloy.modelDefToModelInfo(this.modelDef) : undefined;
+    this.modelInfo = this.modelDef ? import_malloy2.modelDefToModelInfo(this.modelDef) : undefined;
   }
   static async create(packageName, packagePath, modelPath, connections) {
     const { runtime, modelURL, importBaseURL, dataStyles, modelType } = await Model.getModelRuntime(packagePath, modelPath, connections);
@@ -243982,7 +244027,7 @@ class Model {
       return new Model(packageName, modelPath, dataStyles, modelType, modelMaterializer, modelDef, sources, queries, runnableNotebookCells, undefined);
     } catch (error) {
       let computedError = error;
-      if (error instanceof import_malloy.MalloyError) {
+      if (error instanceof import_malloy2.MalloyError) {
         computedError = new ModelCompilationError(error);
       }
       return new Model(packageName, modelPath, dataStyles, modelType, undefined, undefined, undefined, undefined, undefined, computedError);
@@ -243998,7 +244043,7 @@ class Model {
     return this.sources;
   }
   getSourceInfos() {
-    return this.modelDef ? import_malloy.modelDefToModelInfo(this.modelDef).entries.filter((entry) => {
+    return this.modelDef ? import_malloy2.modelDefToModelInfo(this.modelDef).entries.filter((entry) => {
       return entry.kind === "source";
     }) : undefined;
   }
@@ -244070,7 +244115,7 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`);
       "malloy.model.query.status": "success"
     });
     return {
-      result: import_malloy.API.util.wrapResult(queryResults),
+      result: import_malloy2.API.util.wrapResult(queryResults),
       modelInfo: this.modelInfo,
       dataStyles: this.dataStyles
     };
@@ -244083,7 +244128,7 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`);
       malloyVersion: MALLOY_VERSION,
       dataStyles: JSON.stringify(this.dataStyles),
       modelDef: JSON.stringify(this.modelDef),
-      modelInfo: JSON.stringify(this.modelDef ? import_malloy.modelDefToModelInfo(this.modelDef) : {}),
+      modelInfo: JSON.stringify(this.modelDef ? import_malloy2.modelDefToModelInfo(this.modelDef) : {}),
       sourceInfos: this.getSourceInfos()?.map((sourceInfo) => JSON.stringify(sourceInfo)),
       sources: this.sources,
       queries: this.queries
@@ -244099,7 +244144,7 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`);
           const result = await cell.runnable.run({ rowLimit });
           const query = (await cell.runnable.getPreparedQuery())._query;
           queryName = query.as || query.name;
-          queryResult = result?._queryResult && this.modelInfo && JSON.stringify(import_malloy.API.util.wrapResult(result));
+          queryResult = result?._queryResult && this.modelInfo && JSON.stringify(import_malloy2.API.util.wrapResult(result));
         } catch {}
       }
       return {
@@ -244115,14 +244160,14 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`);
       packageName: this.packageName,
       modelPath: this.modelPath,
       malloyVersion: MALLOY_VERSION,
-      modelInfo: JSON.stringify(this.modelDef ? import_malloy.modelDefToModelInfo(this.modelDef) : {}),
+      modelInfo: JSON.stringify(this.modelDef ? import_malloy2.modelDefToModelInfo(this.modelDef) : {}),
       sources: this.modelDef && this.sources,
       queries: this.modelDef && this.queries,
       notebookCells
     };
   }
   static async getModelRuntime(packagePath, modelPath, connections) {
-    const fullModelPath = path3.join(packagePath, modelPath);
+    const fullModelPath = path4.join(packagePath, modelPath);
     try {
       if (!(await fs4.stat(fullModelPath)).isFile()) {
         throw new ModelNotFoundError(`${modelPath} is not a file.`);
@@ -244138,12 +244183,12 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`);
     } else {
       throw new ModelNotFoundError(`${modelPath} is not a valid model name.  Model files must end in .malloy or .malloynb.`);
     }
-    const importBaseURL = new URL("file://" + path3.dirname(fullModelPath) + "/");
+    const importBaseURL = new URL("file://" + path4.dirname(fullModelPath) + "/");
     const modelURL = new URL("file://" + fullModelPath);
     const urlReader = new HackyDataStylesAccumulator(URL_READER);
-    const runtime = new import_malloy.Runtime({
+    const runtime = new import_malloy2.Runtime({
       urlReader,
-      connections: new import_malloy.FixedConnectionMap(connections, "duckdb")
+      connections: new import_malloy2.FixedConnectionMap(connections, "duckdb")
     });
     const dataStyles = urlReader.getHackyAccumulatedDataStyles();
     return { runtime, modelURL, importBaseURL, dataStyles, modelType };
@@ -244157,7 +244202,7 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`);
     }));
   }
   static getSources(modelPath, modelDef) {
-    return Object.values(modelDef.contents).filter((obj) => import_malloy.isSourceDef(obj)).map((sourceObj) => ({
+    return Object.values(modelDef.contents).filter((obj) => import_malloy2.isSourceDef(obj)).map((sourceObj) => ({
       name: sourceObj.as || sourceObj.name,
       annotations: sourceObj.annotation?.blockNotes?.filter((note) => note.at.url.includes(modelPath)).map((note) => note.text),
       views: sourceObj.fields.filter((turtleObj) => turtleObj.type === "turtle").filter((turtleObj) => turtleObj.pipeline.map((stage) => stage.type).every((type) => type == "reduce")).map((turtleObj) => ({
@@ -244231,12 +244276,12 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`);
             const importModel = (await runtime.loadModel(modelString, {
               importBaseURL
             }).getModel())._modelDef;
-            const importModelInfo = import_malloy.modelDefToModelInfo(importModel);
+            const importModelInfo = import_malloy2.modelDefToModelInfo(importModel);
             newSources = importModelInfo.entries.filter((entry) => entry.kind === "source").filter((source) => !(source.name in oldSources));
             oldImports.push(importLocation.importURL.toString());
           }));
         }
-        const currentModelInfo = import_malloy.modelDefToModelInfo(currentModelDef);
+        const currentModelInfo = import_malloy2.modelDefToModelInfo(currentModelDef);
         newSources = newSources.concat(currentModelInfo.entries.filter((entry) => entry.kind === "source").filter((source) => !(source.name in oldSources)));
         for (const source of newSources) {
           oldSources[source.name] = source;
@@ -244266,7 +244311,7 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`);
     return this.modelType;
   }
   async getFileText(packagePath) {
-    const fullPath = path3.join(packagePath, this.modelPath);
+    const fullPath = path4.join(packagePath, this.modelPath);
     try {
       return await fs4.readFile(fullPath, "utf8");
     } catch {
@@ -244577,11 +244622,11 @@ class Package {
       throw new PackageNotFoundError(`Package config for ${packagePath} does not exist.`);
     }
     return files.map((fullPath) => {
-      return path4.relative(packagePath, fullPath).replace(/\\/g, "/");
+      return path5.relative(packagePath, fullPath).replace(/\\/g, "/");
     }).filter((modelPath) => modelPath.endsWith(MODEL_FILE_SUFFIX) || modelPath.endsWith(NOTEBOOK_FILE_SUFFIX));
   }
   static async validatePackageManifestExistsOrThrowError(packagePath) {
-    const packageConfigPath = path4.join(packagePath, PACKAGE_MANIFEST_NAME);
+    const packageConfigPath = path5.join(packagePath, PACKAGE_MANIFEST_NAME);
     try {
       await fs5.stat(packageConfigPath);
     } catch {
@@ -244589,7 +244634,7 @@ class Package {
     }
   }
   static async readPackageConfig(packagePath) {
-    const packageConfigPath = path4.join(packagePath, PACKAGE_MANIFEST_NAME);
+    const packageConfigPath = path5.join(packagePath, PACKAGE_MANIFEST_NAME);
     const packageConfigContents = await fs5.readFile(packageConfigPath);
     const packageManifest = JSON.parse(packageConfigContents.toString());
     return {
@@ -244611,13 +244656,13 @@ class Package {
     let files = undefined;
     files = await import_recursive_readdir.default(packagePath);
     return files.map((fullPath) => {
-      return path4.relative(packagePath, fullPath).replace(/\\/g, "/");
+      return path5.relative(packagePath, fullPath).replace(/\\/g, "/");
     }).filter((modelPath) => modelPath.endsWith(".parquet") || modelPath.endsWith(".csv"));
   }
   static async getDatabaseInfo(packagePath, databasePath) {
-    const fullPath = path4.join(packagePath, databasePath);
-    const runtime = new import_malloy2.ConnectionRuntime({
-      urlReader: new import_malloy2.EmptyURLReader,
+    const fullPath = path5.join(packagePath, databasePath);
+    const runtime = new import_malloy3.ConnectionRuntime({
+      urlReader: new import_malloy3.EmptyURLReader,
       connections: [new import_db_duckdb.DuckDBConnection("duckdb")]
     });
     const model = runtime.loadModel(`source: temp is duckdb.table('${fullPath}')`);
@@ -244631,6 +244676,15 @@ class Package {
     const rowCount = result.data.value[0].row_count?.valueOf();
     return { name: databasePath, rowCount, columns: schema };
   }
+  setName(name) {
+    this.packageName = name;
+  }
+  setProjectName(projectName) {
+    this.projectName = projectName;
+  }
+  setPackageMetadata(packageMetadata) {
+    this.packageMetadata = packageMetadata;
+  }
 }
 
 // src/service/project.ts
@@ -244642,12 +244696,36 @@ class Project {
   internalConnections;
   projectPath;
   projectName;
+  metadata;
   constructor(projectName, projectPath, malloyConnections, internalConnections, apiConnections) {
     this.projectName = projectName;
     this.projectPath = projectPath;
     this.malloyConnections = malloyConnections;
     this.internalConnections = internalConnections;
     this.apiConnections = apiConnections;
+    this.metadata = {
+      resource: `${API_PREFIX}/projects/${this.projectName}`,
+      name: this.projectName
+    };
+    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.resource) {
+      this.projectPath = payload.resource.replace(`${API_PREFIX}/projects/`, "");
+      if (!await fs6.exists(this.projectPath)) {
+        throw new ProjectNotFoundError(`Project path "${this.projectPath}" not found`);
+      }
+      this.metadata.resource = payload.resource;
+    }
+    this.metadata.readme = payload.readme;
+    return this;
   }
   static async create(projectName, projectPath) {
     if (!(await fs6.stat(projectPath)).isDirectory()) {
@@ -244663,16 +244741,17 @@ class Project {
       };
     }));
   }
-  async getProjectMetadata() {
+  async reloadProjectMetadata() {
     let readme = "";
     try {
-      readme = (await fs6.readFile(path5.join(this.projectPath, README_NAME))).toString();
+      readme = (await fs6.readFile(path6.join(this.projectPath, README_NAME))).toString();
     } catch {}
-    return {
+    this.metadata = {
       resource: `${API_PREFIX}/projects/${this.projectName}`,
       name: this.projectName,
       readme
     };
+    return this.metadata;
   }
   listApiConnections() {
     return this.apiConnections;
@@ -244729,7 +244808,7 @@ class Project {
         return _package;
       }
       try {
-        const _package2 = await Package.create(this.projectName, packageName, path5.join(this.projectPath, packageName), this.malloyConnections);
+        const _package2 = await Package.create(this.projectName, packageName, path6.join(this.projectPath, packageName), this.malloyConnections);
         this.packages.set(packageName, _package2);
         return _package2;
       } catch (error) {
@@ -244738,41 +244817,131 @@ class Project {
       }
     });
   }
+  async addPackage(packageName) {
+    const packagePath = path6.join(this.projectPath, packageName);
+    if (!await fs6.exists(packagePath) || !(await fs6.stat(packagePath)).isDirectory()) {
+      throw new PackageNotFoundError(`Package ${packageName} not found`);
+    }
+    this.packages.set(packageName, await Package.create(this.projectName, packageName, packagePath, this.malloyConnections));
+    return this.packages.get(packageName);
+  }
+  async updatePackage(packageName, body) {
+    const _package = this.packages.get(packageName);
+    if (!_package) {
+      throw new PackageNotFoundError(`Package ${packageName} not found`);
+    }
+    if (body.name) {
+      _package.setName(body.name);
+    }
+    _package.setPackageMetadata({
+      name: body.name,
+      description: body.description,
+      resource: body.resource
+    });
+    return _package.getPackageMetadata();
+  }
+  async deletePackage(packageName) {
+    const _package = this.packages.get(packageName);
+    if (!_package) {
+      throw new PackageNotFoundError(`Package ${packageName} not found`);
+    }
+    this.packages.delete(packageName);
+  }
 }
 
 // src/service/project_store.ts
 class ProjectStore {
   serverRootPath;
   projects = new Map;
+  publisherConfigIsFrozen;
   constructor(serverRootPath) {
     this.serverRootPath = serverRootPath;
+    this.initialize();
   }
-  async listProjects() {
-    const projectManifest = await ProjectStore.getProjectManifest(this.serverRootPath);
-    if (!projectManifest.projects) {
-      return [];
-    } else {
-      return Object.keys(projectManifest.projects).map((projectName) => ({
-        name: projectName,
-        resource: `${API_PREFIX}/projects/${projectName}`
-      }));
+  async initialize() {
+    try {
+      this.publisherConfigIsFrozen = isPublisherConfigFrozen(this.serverRootPath);
+      const projectManifest = await ProjectStore.reloadProjectManifest(this.serverRootPath);
+      for (const projectName of Object.keys(projectManifest.projects)) {
+        const projectPath = projectManifest.projects[projectName];
+        const absoluteProjectPath = path7.join(this.serverRootPath, projectPath);
+        const project = await Project.create(projectName, absoluteProjectPath);
+        this.projects.set(projectName, project);
+      }
+      logger.info("Project store successfully initialized");
+    } catch (error) {
+      logger.error("Error initializing project store", { error });
+      process.exit(1);
     }
   }
+  listProjects() {
+    return Array.from(this.projects.values()).map((project) => project.metadata);
+  }
   async getProject(projectName, reload) {
     let project = this.projects.get(projectName);
     if (project === undefined || reload) {
-      const projectManifest = await ProjectStore.getProjectManifest(this.serverRootPath);
+      const projectManifest = await ProjectStore.reloadProjectManifest(this.serverRootPath);
       if (!projectManifest.projects || !projectManifest.projects[projectName]) {
-        throw new ProjectNotFoundError(`Project ${projectName} not found in publisher.config.json`);
+        throw new ProjectNotFoundError(`Project "${projectName}" not found in publisher`);
       }
-      project = await Project.create(projectName, path6.join(this.serverRootPath, projectManifest.projects[projectName]));
-      this.projects.set(projectName, project);
+      project = await this.addProject({
+        name: projectName,
+        resource: `${API_PREFIX}/projects/${projectName}`
+      });
     }
     return project;
   }
-  static async getProjectManifest(serverRootPath) {
+  async addProject(project) {
+    if (this.publisherConfigIsFrozen) {
+      throw new FrozenConfigError;
+    }
+    const projectName = project.name;
+    if (!projectName) {
+      throw new Error("Project name is required");
+    }
+    const projectManifest = await ProjectStore.reloadProjectManifest(this.serverRootPath);
+    const projectPath = projectManifest.projects[projectName];
+    if (!projectPath) {
+      throw new ProjectNotFoundError(`Project "${projectName}" not found in publisher.config.json`);
+    }
+    const absoluteProjectPath = path7.join(this.serverRootPath, projectPath);
+    if (!(await fs7.stat(absoluteProjectPath)).isDirectory()) {
+      throw new ProjectNotFoundError(`Project ${projectName} not found in ${absoluteProjectPath}`);
+    }
+    const newProject = await Project.create(projectName, absoluteProjectPath);
+    this.projects.set(projectName, newProject);
+    return newProject;
+  }
+  async updateProject(project) {
+    if (this.publisherConfigIsFrozen) {
+      throw new FrozenConfigError;
+    }
+    const projectName = project.name;
+    if (!projectName) {
+      throw new Error("Project name is required");
+    }
+    const existingProject = this.projects.get(projectName);
+    if (!existingProject) {
+      throw new ProjectNotFoundError(`Project ${projectName} not found`);
+    }
+    const updatedProject = await existingProject.update(project);
+    this.projects.set(projectName, updatedProject);
+    return updatedProject;
+  }
+  async deleteProject(projectName) {
+    if (this.publisherConfigIsFrozen) {
+      throw new FrozenConfigError;
+    }
+    const project = this.projects.get(projectName);
+    if (!project) {
+      throw new ProjectNotFoundError(`Project ${projectName} not found`);
+    }
+    this.projects.delete(projectName);
+    return project;
+  }
+  static async reloadProjectManifest(serverRootPath) {
     try {
-      const projectManifestContent = await fs7.readFile(path6.join(serverRootPath, "publisher.config.json"), "utf8");
+      const projectManifestContent = await fs7.readFile(path7.join(serverRootPath, "publisher.config.json"), "utf8");
       return JSON.parse(projectManifestContent);
     } catch (error) {
       if (error.code !== "ENOENT") {
@@ -244841,11 +245010,11 @@ var MCP_PORT = Number(process.env.MCP_PORT || 4040);
 var MCP_ENDPOINT = "/mcp";
 var ROOT;
 if (require.main) {
-  ROOT = path7.join(path7.dirname(require.main.filename), "app");
+  ROOT = path8.join(path8.dirname(require.main.filename), "app");
 } else {
-  ROOT = path7.join(path7.dirname(process.argv[1] || __filename), "app");
+  ROOT = path8.join(path8.dirname(process.argv[1] || __filename), "app");
 }
-var SERVER_ROOT = path7.resolve(process.cwd(), process.env.SERVER_ROOT || ".");
+var SERVER_ROOT = path8.resolve(process.cwd(), process.env.SERVER_ROOT || ".");
 var API_PREFIX2 = "/api/v0";
 var isDevelopment = process.env["NODE_ENV"] === "development";
 var app = import_express.default();
@@ -244859,7 +245028,6 @@ var databaseController = new DatabaseController(projectStore);
 var queryController = new QueryController(projectStore);
 var scheduleController = new ScheduleController(projectStore);
 var mcpApp = import_express.default();
-initProjects();
 mcpApp.use(MCP_ENDPOINT, import_express.default.json());
 mcpApp.use(MCP_ENDPOINT, import_cors.default());
 mcpApp.all(MCP_ENDPOINT, async (req, res) => {
@@ -244921,14 +245089,14 @@ mcpApp.all(MCP_ENDPOINT, async (req, res) => {
 });
 if (!isDevelopment) {
   app.use("/", import_express.default.static(ROOT));
-  app.use("/api-doc.html", import_express.default.static(path7.join(ROOT, "api-doc.html")));
+  app.use("/api-doc.html", import_express.default.static(path8.join(ROOT, "api-doc.html")));
 } else {
   app.use(`${API_PREFIX2}`, loggerMiddleware);
   app.use(import_http_proxy_middleware.createProxyMiddleware({
     target: "http://localhost:5173",
     changeOrigin: true,
     ws: true,
-    pathFilter: (path8) => !path8.startsWith("/api")
+    pathFilter: (path9) => !path9.startsWith("/api/")
   }));
 }
 var setVersionIdError = (res) => {
@@ -244946,10 +245114,37 @@ app.get(`${API_PREFIX2}/projects`, async (_req, res) => {
     res.status(status).json(json2);
   }
 });
+app.post(`${API_PREFIX2}/projects`, async (req, res) => {
+  try {
+    res.status(200).json(await projectStore.addProject(req.body));
+  } catch (error) {
+    logger.error(error);
+    const { json: json2, status } = internalErrorToHttpError(error);
+    res.status(status).json(json2);
+  }
+});
 app.get(`${API_PREFIX2}/projects/:projectName`, async (req, res) => {
   try {
     const project = await projectStore.getProject(req.params.projectName, req.query.reload === "true");
-    res.status(200).json(await project.getProjectMetadata());
+    res.status(200).json(project.metadata);
+  } catch (error) {
+    logger.error(error);
+    const { json: json2, status } = internalErrorToHttpError(error);
+    res.status(status).json(json2);
+  }
+});
+app.patch(`${API_PREFIX2}/projects/:projectName`, async (req, res) => {
+  try {
+    res.status(200).json(await projectStore.updateProject(req.body));
+  } catch (error) {
+    logger.error(error);
+    const { json: json2, status } = internalErrorToHttpError(error);
+    res.status(status).json(json2);
+  }
+});
+app.delete(`${API_PREFIX2}/projects/:projectName`, async (req, res) => {
+  try {
+    res.status(200).json(await projectStore.deleteProject(req.params.projectName));
   } catch (error) {
     logger.error(error);
     const { json: json2, status } = internalErrorToHttpError(error);
@@ -245053,6 +245248,15 @@ app.get(`${API_PREFIX2}/projects/:projectName/packages`, async (req, res) => {
     res.status(status).json(json2);
   }
 });
+app.post(`${API_PREFIX2}/projects/:projectName/packages`, async (req, res) => {
+  try {
+    res.status(200).json(await packageController.addPackage(req.params.projectName, req.body));
+  } catch (error) {
+    logger.error(error);
+    const { json: json2, status } = internalErrorToHttpError(error);
+    res.status(status).json(json2);
+  }
+});
 app.get(`${API_PREFIX2}/projects/:projectName/packages/:packageName`, async (req, res) => {
   if (req.query.versionId) {
     setVersionIdError(res);
@@ -245066,6 +245270,24 @@ app.get(`${API_PREFIX2}/projects/:projectName/packages/:packageName`, async (req
     res.status(status).json(json2);
   }
 });
+app.patch(`${API_PREFIX2}/projects/:projectName/packages/:packageName`, async (req, res) => {
+  try {
+    res.status(200).json(await packageController.updatePackage(req.params.projectName, req.params.packageName, req.body));
+  } catch (error) {
+    logger.error(error);
+    const { json: json2, status } = internalErrorToHttpError(error);
+    res.status(status).json(json2);
+  }
+});
+app.delete(`${API_PREFIX2}/projects/:projectName/packages/:packageName`, async (req, res) => {
+  try {
+    res.status(200).json(await packageController.deletePackage(req.params.projectName, req.params.packageName));
+  } catch (error) {
+    logger.error(error);
+    const { json: json2, status } = internalErrorToHttpError(error);
+    res.status(status).json(json2);
+  }
+});
 app.get(`${API_PREFIX2}/projects/:projectName/packages/:packageName/models`, async (req, res) => {
   if (req.query.versionId) {
     setVersionIdError(res);
@@ -245161,9 +245383,9 @@ app.get(`${API_PREFIX2}/projects/:projectName/packages/:packageName/databases`,
   }
 });
 if (!isDevelopment) {
-  app.get("*", (_req, res) => res.sendFile(path7.resolve(ROOT, "index.html")));
+  app.get("*", (_req, res) => res.sendFile(path8.resolve(ROOT, "index.html")));
 }
-app.use((err, _req, res) => {
+app.use((err, _req, res, _next) => {
   logger.error("Unhandled error:", err);
   const { json: json2, status } = internalErrorToHttpError(err);
   res.status(status).json(json2);
@@ -245179,12 +245401,3 @@ mainServer.listen(PUBLISHER_PORT, PUBLISHER_HOST, () => {
 var mcpHttpServer = mcpApp.listen(MCP_PORT, PUBLISHER_HOST, () => {
   logger.info(`MCP server listening at http://${PUBLISHER_HOST}:${MCP_PORT}`);
 });
-function initProjects() {
-  projectStore.listProjects().then((projects) => {
-    projects.forEach((project) => {
-      projectStore.getProject(project.name, false).then((project2) => {
-        project2.listPackages();
-      });
-    });
-  });
-}