@base44-preview/cli 0.0.32-pr.269.2da16d6 → 0.0.33-pr.259.6920cd1

package/dist/cli/index.js

@@ -178514,6 +178514,18 @@ class InvalidInputError extends UserError {
   code = "INVALID_INPUT";
 }
 
+class DependencyNotFoundError extends UserError {
+  code = "DEPENDENCY_NOT_FOUND";
+  constructor(message, options) {
+    super(message, {
+      hints: options?.hints ?? [
+        { message: "Install the required dependency and try again" }
+      ],
+      cause: options?.cause
+    });
+  }
+}
+
 class ApiError extends SystemError {
   code = "API_ERROR";
   statusCode;
@@ -178629,6 +178641,21 @@ class FileReadError extends SystemError {
     });
   }
 }
+
+class InternalError extends SystemError {
+  code = "INTERNAL_ERROR";
+  constructor(message, options) {
+    super(message, {
+      hints: options?.hints ?? [
+        {
+          message: "This is an unexpected error. Please report it if it persists."
+        }
+      ],
+      cause: options?.cause
+    });
+  }
+}
+
 class TypeGenerationError extends SystemError {
   code = "TYPE_GENERATION_ERROR";
   constructor(message, entityName, cause) {
@@ -185915,6 +185942,118 @@ async function pushEntities(entities) {
   }
   return syncEntities(entities);
 }
+// src/core/resources/entity/records-schema.ts
+var EntityRecordSchema = exports_external.object({
+  id: exports_external.string(),
+  created_date: exports_external.string(),
+  updated_date: exports_external.string(),
+  created_by: exports_external.string().optional()
+}).passthrough();
+var DeleteRecordResponseSchema = exports_external.object({
+  success: exports_external.boolean()
+});
+
+// src/core/resources/entity/records-api.ts
+async function listRecords(entityName, options = {}) {
+  const appClient = getAppClient();
+  const searchParams = new URLSearchParams;
+  if (options.filter) {
+    searchParams.set("q", options.filter);
+  }
+  if (options.sort) {
+    searchParams.set("sort", options.sort);
+  }
+  if (options.limit !== undefined) {
+    searchParams.set("limit", String(options.limit));
+  }
+  if (options.skip !== undefined) {
+    searchParams.set("skip", String(options.skip));
+  }
+  if (options.fields) {
+    searchParams.set("fields", options.fields);
+  }
+  let response;
+  try {
+    response = await appClient.get(`admin/entities/${entityName}`, {
+      searchParams
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "listing records");
+  }
+  const json2 = await response.json();
+  const records = Array.isArray(json2) ? json2 : [];
+  return records.map((record2) => {
+    const result = EntityRecordSchema.safeParse(record2);
+    if (!result.success) {
+      throw new SchemaValidationError("Invalid record in response", result.error);
+    }
+    return result.data;
+  });
+}
+async function getRecord(entityName, recordId) {
+  const appClient = getAppClient();
+  let response;
+  try {
+    response = await appClient.get(`admin/entities/${entityName}/${recordId}`);
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "getting record");
+  }
+  const json2 = await response.json();
+  const result = EntityRecordSchema.safeParse(json2);
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid record response", result.error);
+  }
+  return result.data;
+}
+async function createRecord(entityName, data) {
+  const appClient = getAppClient();
+  let response;
+  try {
+    response = await appClient.post(`admin/entities/${entityName}`, {
+      json: data
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "creating record");
+  }
+  const json2 = await response.json();
+  const result = EntityRecordSchema.safeParse(json2);
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid record in create response", result.error);
+  }
+  return result.data;
+}
+async function updateRecord(entityName, recordId, data) {
+  const appClient = getAppClient();
+  let response;
+  try {
+    response = await appClient.put(`admin/entities/${entityName}/${recordId}`, {
+      json: data
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "updating record");
+  }
+  const json2 = await response.json();
+  const result = EntityRecordSchema.safeParse(json2);
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid record in update response", result.error);
+  }
+  return result.data;
+}
+async function deleteRecord(entityName, recordId) {
+  const appClient = getAppClient();
+  let response;
+  try {
+    response = await appClient.delete(`admin/entities/${entityName}/${recordId}`);
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "deleting record");
+  }
+  const json2 = await response.json();
+  const result = DeleteRecordResponseSchema.safeParse(json2);
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid delete response", result.error);
+  }
+  return result.data;
+}
 // src/core/resources/entity/resource.ts
 var entityResource = {
   readAll: readAllEntities,
@@ -187064,7 +187203,9 @@ var theme = {
   styles: {
     header: source_default.dim,
     bold: source_default.bold,
-    dim: source_default.dim
+    dim: source_default.dim,
+    error: source_default.red,
+    warn: source_default.yellow
   },
   format: {
     errorContext(ctx) {
@@ -193846,7 +193987,7 @@ var {
 // package.json
 var package_default = {
   name: "base44",
-  version: "0.0.32",
+  version: "0.0.33",
   description: "Base44 CLI - Unified interface for managing Base44 applications",
   type: "module",
   bin: {
@@ -193887,6 +194028,7 @@ var package_default = {
     "@types/bun": "^1.2.15",
     "@types/common-tags": "^1.8.4",
     "@types/cors": "^2.8.19",
+    "@types/deno": "^2.5.0",
     "@types/ejs": "^3.1.5",
     "@types/express": "^5.0.6",
     "@types/json-schema": "^7.0.15",
@@ -194982,9 +195124,189 @@ async function pushEntitiesAction() {
   return { outroMessage: "Entities pushed to Base44" };
 }
 function getEntitiesPushCommand(context) {
-  return new Command("entities").description("Manage project entities").addCommand(new Command("push").description("Push local entities to Base44").action(async () => {
+  return new Command("push").description("Push local entity schemas to Base44").action(async () => {
     await runCommand(pushEntitiesAction, { requireAuth: true }, context);
-  }));
+  });
+}
+
+// src/cli/commands/entities/records/create.ts
+var import_json52 = __toESM(require_lib(), 1);
+async function parseRecordData(options) {
+  if (options.data) {
+    try {
+      return import_json52.default.parse(options.data);
+    } catch {
+      throw new InvalidInputError("Invalid JSON in --data flag. Provide valid JSON.", {
+        hints: [
+          {
+            message: `Example: --data '{"name": "John", "email": "john@example.com"}'`
+          }
+        ]
+      });
+    }
+  }
+  if (options.file) {
+    const content = await readTextFile(options.file);
+    try {
+      return import_json52.default.parse(content);
+    } catch {
+      throw new InvalidInputError(`Invalid JSON in file ${options.file}. Provide a valid JSON/JSONC file.`);
+    }
+  }
+  throw new InvalidInputError("Provide record data with --data or --file flag", {
+    hints: [
+      {
+        message: `Example: --data '{"name": "John"}' or --file record.json`
+      }
+    ]
+  });
+}
+async function createRecordAction(entityName, options) {
+  const data = await parseRecordData(options);
+  const record2 = await runTask(`Creating ${entityName} record...`, async () => {
+    return await createRecord(entityName, data);
+  }, {
+    successMessage: `Created ${entityName} record`,
+    errorMessage: `Failed to create ${entityName} record`
+  });
+  R2.success(`Record created with ID: ${record2.id}`);
+  process.stdout.write(`${JSON.stringify(record2, null, 2)}
+`);
+  return {};
+}
+function getRecordsCreateCommand(context) {
+  return new Command("create").description("Create a new entity record").argument("<entity-name>", "Name of the entity (e.g. Users, Products)").option("-d, --data <json>", "JSON object with record data").option("--file <path>", "Read record data from a JSON/JSONC file").action(async (entityName, options) => {
+    await runCommand(() => createRecordAction(entityName, options), { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/entities/records/delete.ts
+async function deleteRecordAction(entityName, recordId, options) {
+  if (!options.yes) {
+    const confirmed = await Re({
+      message: `Delete ${entityName} record ${recordId}?`
+    });
+    if (confirmed !== true) {
+      throw new CLIExitError(0);
+    }
+  }
+  await runTask(`Deleting ${entityName} record...`, async () => {
+    return await deleteRecord(entityName, recordId);
+  }, {
+    successMessage: `Deleted ${entityName} record`,
+    errorMessage: `Failed to delete ${entityName} record`
+  });
+  R2.success(`Record ${recordId} deleted`);
+  return {};
+}
+function getRecordsDeleteCommand(context) {
+  return new Command("delete").description("Delete an entity record").argument("<entity-name>", "Name of the entity (e.g. Users, Products)").argument("<record-id>", "ID of the record to delete").option("-y, --yes", "Skip confirmation prompt").action(async (entityName, recordId, options) => {
+    await runCommand(() => deleteRecordAction(entityName, recordId, options), { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/entities/records/get.ts
+async function getRecordAction(entityName, recordId) {
+  const record2 = await runTask(`Fetching ${entityName} record...`, async () => {
+    return await getRecord(entityName, recordId);
+  }, {
+    successMessage: `Fetched ${entityName} record`,
+    errorMessage: `Failed to fetch ${entityName} record`
+  });
+  process.stdout.write(`${JSON.stringify(record2, null, 2)}
+`);
+  return {};
+}
+function getRecordsGetCommand(context) {
+  return new Command("get").description("Get a single entity record by ID").argument("<entity-name>", "Name of the entity (e.g. Users, Products)").argument("<record-id>", "ID of the record").action(async (entityName, recordId) => {
+    await runCommand(() => getRecordAction(entityName, recordId), { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/entities/records/list.ts
+async function listRecordsAction(entityName, options) {
+  const records = await runTask(`Fetching ${entityName} records...`, async () => {
+    return await listRecords(entityName, {
+      filter: options.filter,
+      sort: options.sort,
+      limit: options.limit ? Number(options.limit) : 50,
+      skip: options.skip ? Number(options.skip) : undefined,
+      fields: options.fields
+    });
+  }, {
+    successMessage: `Fetched ${entityName} records`,
+    errorMessage: `Failed to fetch ${entityName} records`
+  });
+  R2.info(`Found ${records.length} record(s)`);
+  process.stdout.write(`${JSON.stringify(records, null, 2)}
+`);
+  return {};
+}
+function getRecordsListCommand(context) {
+  return new Command("list").description("List entity records").argument("<entity-name>", "Name of the entity (e.g. Users, Products)").option("-f, --filter <json>", "JSON query filter").option("-s, --sort <field>", "Sort field (prefix with - for descending)").option("-l, --limit <n>", "Max records to return", "50").option("--skip <n>", "Number of records to skip").option("--fields <fields>", "Comma-separated fields to return").action(async (entityName, options) => {
+    await runCommand(() => listRecordsAction(entityName, options), { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/entities/records/update.ts
+var import_json53 = __toESM(require_lib(), 1);
+async function parseUpdateData(options) {
+  if (options.data) {
+    try {
+      return import_json53.default.parse(options.data);
+    } catch {
+      throw new InvalidInputError("Invalid JSON in --data flag. Provide valid JSON.", {
+        hints: [
+          {
+            message: `Example: --data '{"status": "active"}'`
+          }
+        ]
+      });
+    }
+  }
+  if (options.file) {
+    const content = await readTextFile(options.file);
+    try {
+      return import_json53.default.parse(content);
+    } catch {
+      throw new InvalidInputError(`Invalid JSON in file ${options.file}. Provide a valid JSON/JSONC file.`);
+    }
+  }
+  throw new InvalidInputError("Provide update data with --data or --file flag", {
+    hints: [
+      {
+        message: `Example: --data '{"status": "active"}' or --file update.json`
+      }
+    ]
+  });
+}
+async function updateRecordAction(entityName, recordId, options) {
+  const data = await parseUpdateData(options);
+  const record2 = await runTask(`Updating ${entityName} record...`, async () => {
+    return await updateRecord(entityName, recordId, data);
+  }, {
+    successMessage: `Updated ${entityName} record`,
+    errorMessage: `Failed to update ${entityName} record`
+  });
+  R2.success(`Record ${recordId} updated`);
+  process.stdout.write(`${JSON.stringify(record2, null, 2)}
+`);
+  return {};
+}
+function getRecordsUpdateCommand(context) {
+  return new Command("update").description("Update an entity record").argument("<entity-name>", "Name of the entity (e.g. Users, Products)").argument("<record-id>", "ID of the record to update").option("-d, --data <json>", "JSON object with fields to update").option("--file <path>", "Read update data from a JSON/JSONC file").action(async (entityName, recordId, options) => {
+    await runCommand(() => updateRecordAction(entityName, recordId, options), { requireAuth: true }, context);
+  });
+}
+
+// src/cli/commands/entities/records/index.ts
+function getRecordsCommand(context) {
+  return new Command("records").description("CRUD operations on entity records").addCommand(getRecordsListCommand(context)).addCommand(getRecordsGetCommand(context)).addCommand(getRecordsCreateCommand(context)).addCommand(getRecordsUpdateCommand(context)).addCommand(getRecordsDeleteCommand(context));
+}
+
+// src/cli/commands/entities/index.ts
+function getEntitiesCommand(context) {
+  return new Command("entities").description("Manage project entities").addCommand(getEntitiesPushCommand(context)).addCommand(getRecordsCommand(context));
 }
 
 // src/cli/commands/functions/deploy.ts
@@ -195610,9 +195932,12 @@ function getTypesCommand(context) {
   return new Command("types").description("Manage TypeScript type generation").addCommand(getTypesGenerateCommand(context));
 }
 
+// src/cli/commands/dev.ts
+import { dirname as dirname12, join as join16 } from "node:path";
+
 // src/cli/dev/dev-server/main.ts
 var import_cors = __toESM(require_lib4(), 1);
-var import_express = __toESM(require_express(), 1);
+var import_express2 = __toESM(require_express(), 1);
 
 // node_modules/get-port/index.js
 import net from "node:net";
@@ -195729,13 +196054,232 @@ async function getPorts(options8) {
 }
 
 // src/cli/dev/dev-server/main.ts
+var import_http_proxy_middleware2 = __toESM(require_dist2(), 1);
+
+// src/cli/dev/createDevLogger.ts
+var colorByType = {
+  error: theme.styles.error,
+  warn: theme.styles.warn,
+  log: (text) => text
+};
+function createDevLogger() {
+  const print = (type, msg) => {
+    const colorize = colorByType[type];
+    console[type](colorize(msg));
+  };
+  return {
+    log: (msg) => print("log", msg),
+    error: (msg, err) => {
+      print("error", msg);
+      if (err) {
+        print("error", String(err));
+      }
+    },
+    warn: (msg) => print("warn", msg)
+  };
+}
+
+// src/cli/dev/dev-server/function-manager.ts
+import { spawn as spawn2, spawnSync as spawnSync2 } from "node:child_process";
+import { dirname as dirname11, join as join15 } from "node:path";
+import { fileURLToPath as fileURLToPath7 } from "node:url";
+var __dirname5 = dirname11(fileURLToPath7(import.meta.url));
+var WRAPPER_PATH = join15(__dirname5, "../deno-runtime/main.js");
+var READY_TIMEOUT = 30000;
+
+class FunctionManager {
+  functions;
+  running = new Map;
+  starting = new Map;
+  logger;
+  constructor(functions, logger) {
+    this.functions = new Map(functions.map((f7) => [f7.name, f7]));
+    this.logger = logger;
+    if (functions.length > 0) {
+      this.verifyDenoIsInstalled();
+    }
+  }
+  verifyDenoIsInstalled() {
+    const result = spawnSync2("deno", ["--version"]);
+    if (result.error) {
+      throw new DependencyNotFoundError("Deno is required to run functions", {
+        hints: [{ message: "Install Deno from https://deno.com/download" }]
+      });
+    }
+  }
+  getFunctionNames() {
+    return Array.from(this.functions.keys());
+  }
+  async ensureRunning(name2) {
+    const backendFunction = this.functions.get(name2);
+    if (!backendFunction) {
+      throw new InvalidInputError(`Function "${name2}" not found`, {
+        hints: [{ message: "Check available functions in your project" }]
+      });
+    }
+    const existing = this.running.get(name2);
+    if (existing?.ready) {
+      return existing.port;
+    }
+    const pending = this.starting.get(name2);
+    if (pending) {
+      return pending;
+    }
+    const promise2 = this.startFunction(name2, backendFunction);
+    this.starting.set(name2, promise2);
+    try {
+      return await promise2;
+    } finally {
+      this.starting.delete(name2);
+    }
+  }
+  async startFunction(name2, backendFunction) {
+    const port = await this.allocatePort();
+    const process21 = this.spawnFunction(backendFunction, port);
+    const runningFunc = {
+      process: process21,
+      port,
+      ready: false
+    };
+    this.running.set(name2, runningFunc);
+    this.setupProcessHandlers(name2, process21);
+    return this.waitForReady(name2, runningFunc);
+  }
+  stopAll() {
+    for (const [name2, { process: process21 }] of this.running) {
+      this.logger.log(`[dev-server] Stopping function: ${name2}`);
+      process21.kill();
+    }
+    this.running.clear();
+    this.starting.clear();
+  }
+  async allocatePort() {
+    const usedPorts = Array.from(this.running.values()).map((r5) => r5.port);
+    return getPorts({ exclude: usedPorts });
+  }
+  spawnFunction(func, port) {
+    this.logger.log(`[dev-server] Spawning function "${func.name}" on port ${port}`);
+    const process21 = spawn2("deno", ["run", "--allow-all", WRAPPER_PATH], {
+      env: {
+        ...globalThis.process.env,
+        FUNCTION_PATH: func.entryPath,
+        FUNCTION_PORT: String(port),
+        FUNCTION_NAME: func.name
+      },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return process21;
+  }
+  setupProcessHandlers(name2, process21) {
+    process21.stdout?.on("data", (data) => {
+      const lines = data.toString().trim().split(`
+`);
+      for (const line3 of lines) {
+        this.logger.log(line3);
+      }
+    });
+    process21.stderr?.on("data", (data) => {
+      const lines = data.toString().trim().split(`
+`);
+      for (const line3 of lines) {
+        this.logger.error(line3);
+      }
+    });
+    process21.on("exit", (code2) => {
+      this.logger.log(`[dev-server] Function "${name2}" exited with code ${code2}`);
+      this.running.delete(name2);
+    });
+    process21.on("error", (error48) => {
+      this.logger.error(`[dev-server] Function "${name2}" error:`, error48);
+      this.running.delete(name2);
+    });
+  }
+  waitForReady(name2, runningFunc) {
+    return new Promise((resolve5, reject) => {
+      runningFunc.process.on("exit", (code2) => {
+        if (!runningFunc.ready) {
+          clearTimeout(timeout3);
+          reject(new InternalError(`Function "${name2}" exited with code ${code2}`, {
+            hints: [{ message: "Check the function code for errors" }]
+          }));
+        }
+      });
+      const timeout3 = setTimeout(() => {
+        runningFunc.process.kill();
+        reject(new InternalError(`Function "${name2}" failed to start within ${READY_TIMEOUT / 1000}s timeout`, {
+          hints: [
+            { message: "Check the function code for startup errors" }
+          ]
+        }));
+      }, READY_TIMEOUT);
+      const onData = (data) => {
+        const output = data.toString();
+        if (output.includes("Listening on")) {
+          runningFunc.ready = true;
+          clearTimeout(timeout3);
+          runningFunc.process.stdout?.off("data", onData);
+          resolve5(runningFunc.port);
+        }
+      };
+      runningFunc.process.stdout?.on("data", onData);
+    });
+  }
+}
+
+// src/cli/dev/dev-server/routes/functions.ts
+var import_express = __toESM(require_express(), 1);
 var import_http_proxy_middleware = __toESM(require_dist2(), 1);
+import { ServerResponse } from "node:http";
+function createFunctionRouter(manager, logger) {
+  const router = import_express.Router({ mergeParams: true });
+  const portsByRequest = new WeakMap;
+  const proxy = import_http_proxy_middleware.createProxyMiddleware({
+    router: (req) => `http://localhost:${portsByRequest.get(req)}`,
+    changeOrigin: true,
+    on: {
+      proxyReq: (proxyReq, req) => {
+        const xAppId = req.headers["x-app-id"];
+        if (xAppId) {
+          proxyReq.setHeader("Base44-App-Id", xAppId);
+        }
+        proxyReq.setHeader("Base44-Api-Url", `${req.protocol}://${req.headers.host}`);
+      },
+      error: (err, _req, res) => {
+        logger.error("Function proxy error:", err);
+        if (res instanceof ServerResponse && !res.headersSent) {
+          res.writeHead(502, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            error: "Failed to proxy request to function",
+            details: err.message
+          }));
+        }
+      }
+    }
+  });
+  router.all("/:functionName", async (req, res, next) => {
+    const { functionName } = req.params;
+    try {
+      const port = await manager.ensureRunning(functionName);
+      portsByRequest.set(req, port);
+      next();
+    } catch (error48) {
+      logger.error("Function error:", error48);
+      const message = error48 instanceof Error ? error48.message : String(error48);
+      res.status(500).json({ error: message });
+    }
+  }, proxy);
+  return router;
+}
+
+// src/cli/dev/dev-server/main.ts
 var DEFAULT_PORT = 4400;
 var BASE44_APP_URL = "https://base44.app";
-async function createDevServer(options8 = {}) {
-  const port = options8.port ?? await getPorts({ port: DEFAULT_PORT });
-  const app = import_express.default();
-  const remoteProxy = import_http_proxy_middleware.createProxyMiddleware({
+async function createDevServer(options8) {
+  const { port: userPort } = options8;
+  const port = userPort ?? await getPorts({ port: DEFAULT_PORT });
+  const { functions } = await options8.loadResources();
+  const app = import_express2.default();
+  const remoteProxy = import_http_proxy_middleware2.createProxyMiddleware({
     target: BASE44_APP_URL,
     changeOrigin: true
   });
@@ -195751,6 +196295,13 @@ async function createDevServer(options8 = {}) {
     }
     next();
   });
+  const devLogger = createDevLogger();
+  const functionManager = new FunctionManager(functions, devLogger);
+  if (functionManager.getFunctionNames().length > 0) {
+    R2.info(`Loaded functions: ${functionManager.getFunctionNames().join(", ")}`);
+    const functionRoutes = createFunctionRouter(functionManager, devLogger);
+    app.use("/api/apps/:appId/functions", functionRoutes);
+  }
   app.use((req, res, next) => {
     return remoteProxy(req, res, next);
   });
@@ -195763,6 +196314,12 @@ async function createDevServer(options8 = {}) {
           reject(err);
         }
       } else {
+        const shutdown = () => {
+          functionManager.stopAll();
+          server.close();
+        };
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
         resolve5({
           port,
           server
@@ -195775,7 +196332,15 @@ async function createDevServer(options8 = {}) {
 // src/cli/commands/dev.ts
 async function devAction(options8) {
   const port = options8.port ? Number(options8.port) : undefined;
-  const { port: resolvedPort } = await createDevServer({ port });
+  const { port: resolvedPort } = await createDevServer({
+    port,
+    loadResources: async () => {
+      const { project: project2 } = await readProjectConfig();
+      const configDir = dirname12(project2.configPath);
+      const functions = await functionResource.readAll(join16(configDir, project2.functionsDir));
+      return { functions };
+    }
+  });
   return {
     outroMessage: `Dev server is available at ${theme.colors.links(`http://localhost:${resolvedPort}`)}`
   };
@@ -195892,7 +196457,7 @@ function createProgram(context) {
   program2.addCommand(getDeployCommand(context));
   program2.addCommand(getLinkCommand(context));
   program2.addCommand(getEjectCommand(context));
-  program2.addCommand(getEntitiesPushCommand(context));
+  program2.addCommand(getEntitiesCommand(context));
   program2.addCommand(getAgentsCommand(context));
   program2.addCommand(getConnectorsCommand(context));
   program2.addCommand(getFunctionsDeployCommand(context));
@@ -195937,7 +196502,7 @@ function nanoid3(size = 21) {
 }
 
 // node_modules/posthog-node/dist/extensions/error-tracking/modifiers/module.node.mjs
-import { dirname as dirname11, posix, sep } from "path";
+import { dirname as dirname13, posix, sep } from "path";
 function createModulerModifier() {
   const getModuleFromFileName = createGetModuleFromFilename();
   return async (frames) => {
@@ -195946,7 +196511,7 @@ function createModulerModifier() {
     return frames;
   };
 }
-function createGetModuleFromFilename(basePath = process.argv[1] ? dirname11(process.argv[1]) : process.cwd(), isWindows4 = sep === "\\") {
+function createGetModuleFromFilename(basePath = process.argv[1] ? dirname13(process.argv[1]) : process.cwd(), isWindows4 = sep === "\\") {
   const normalizedBase = isWindows4 ? normalizeWindowsPath2(basePath) : basePath;
   return (filename) => {
     if (!filename)
@@ -200163,4 +200728,4 @@ export {
   CLIExitError
 };
 
-//# debugId=8FF06F66318A4ACC64756E2164756E21
+//# debugId=4D663D484D24768B64756E2164756E21