@base44-preview/cli 0.0.36-pr.339.1ae3acc → 0.0.36-pr.339.4ca0d22

package/dist/cli/index.js

@@ -4,25 +4,43 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
@@ -163119,6 +163137,389 @@ var require_dist2 = __commonJS((exports) => {
   __exportStar(require_legacy(), exports);
 });
 
+// node_modules/tmp/lib/tmp.js
+var require_tmp = __commonJS((exports, module) => {
+  /*!
+   * Tmp
+   *
+   * Copyright (c) 2011-2017 KARASZI Istvan <github@spam.raszi.hu>
+   *
+   * MIT Licensed
+   */
+  var fs28 = __require("fs");
+  var os10 = __require("os");
+  var path18 = __require("path");
+  var crypto = __require("crypto");
+  var _c3 = { fs: fs28.constants, os: os10.constants };
+  var RANDOM_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+  var TEMPLATE_PATTERN = /XXXXXX/;
+  var DEFAULT_TRIES = 3;
+  var CREATE_FLAGS = (_c3.O_CREAT || _c3.fs.O_CREAT) | (_c3.O_EXCL || _c3.fs.O_EXCL) | (_c3.O_RDWR || _c3.fs.O_RDWR);
+  var IS_WIN32 = os10.platform() === "win32";
+  var EBADF = _c3.EBADF || _c3.os.errno.EBADF;
+  var ENOENT = _c3.ENOENT || _c3.os.errno.ENOENT;
+  var DIR_MODE = 448;
+  var FILE_MODE = 384;
+  var EXIT = "exit";
+  var _removeObjects = [];
+  var FN_RMDIR_SYNC = fs28.rmdirSync.bind(fs28);
+  var _gracefulCleanup = false;
+  function rimraf(dirPath, callback) {
+    return fs28.rm(dirPath, { recursive: true }, callback);
+  }
+  function FN_RIMRAF_SYNC(dirPath) {
+    return fs28.rmSync(dirPath, { recursive: true });
+  }
+  function tmpName(options8, callback) {
+    const args = _parseArguments(options8, callback), opts = args[0], cb2 = args[1];
+    _assertAndSanitizeOptions(opts, function(err, sanitizedOptions) {
+      if (err)
+        return cb2(err);
+      let tries = sanitizedOptions.tries;
+      (function _getUniqueName() {
+        try {
+          const name2 = _generateTmpName(sanitizedOptions);
+          fs28.stat(name2, function(err2) {
+            if (!err2) {
+              if (tries-- > 0)
+                return _getUniqueName();
+              return cb2(new Error("Could not get a unique tmp filename, max tries reached " + name2));
+            }
+            cb2(null, name2);
+          });
+        } catch (err2) {
+          cb2(err2);
+        }
+      })();
+    });
+  }
+  function tmpNameSync(options8) {
+    const args = _parseArguments(options8), opts = args[0];
+    const sanitizedOptions = _assertAndSanitizeOptionsSync(opts);
+    let tries = sanitizedOptions.tries;
+    do {
+      const name2 = _generateTmpName(sanitizedOptions);
+      try {
+        fs28.statSync(name2);
+      } catch (e8) {
+        return name2;
+      }
+    } while (tries-- > 0);
+    throw new Error("Could not get a unique tmp filename, max tries reached");
+  }
+  function file2(options8, callback) {
+    const args = _parseArguments(options8, callback), opts = args[0], cb2 = args[1];
+    tmpName(opts, function _tmpNameCreated(err, name2) {
+      if (err)
+        return cb2(err);
+      fs28.open(name2, CREATE_FLAGS, opts.mode || FILE_MODE, function _fileCreated(err2, fd) {
+        if (err2)
+          return cb2(err2);
+        if (opts.discardDescriptor) {
+          return fs28.close(fd, function _discardCallback(possibleErr) {
+            return cb2(possibleErr, name2, undefined, _prepareTmpFileRemoveCallback(name2, -1, opts, false));
+          });
+        } else {
+          const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
+          cb2(null, name2, fd, _prepareTmpFileRemoveCallback(name2, discardOrDetachDescriptor ? -1 : fd, opts, false));
+        }
+      });
+    });
+  }
+  function fileSync(options8) {
+    const args = _parseArguments(options8), opts = args[0];
+    const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
+    const name2 = tmpNameSync(opts);
+    let fd = fs28.openSync(name2, CREATE_FLAGS, opts.mode || FILE_MODE);
+    if (opts.discardDescriptor) {
+      fs28.closeSync(fd);
+      fd = undefined;
+    }
+    return {
+      name: name2,
+      fd,
+      removeCallback: _prepareTmpFileRemoveCallback(name2, discardOrDetachDescriptor ? -1 : fd, opts, true)
+    };
+  }
+  function dir(options8, callback) {
+    const args = _parseArguments(options8, callback), opts = args[0], cb2 = args[1];
+    tmpName(opts, function _tmpNameCreated(err, name2) {
+      if (err)
+        return cb2(err);
+      fs28.mkdir(name2, opts.mode || DIR_MODE, function _dirCreated(err2) {
+        if (err2)
+          return cb2(err2);
+        cb2(null, name2, _prepareTmpDirRemoveCallback(name2, opts, false));
+      });
+    });
+  }
+  function dirSync(options8) {
+    const args = _parseArguments(options8), opts = args[0];
+    const name2 = tmpNameSync(opts);
+    fs28.mkdirSync(name2, opts.mode || DIR_MODE);
+    return {
+      name: name2,
+      removeCallback: _prepareTmpDirRemoveCallback(name2, opts, true)
+    };
+  }
+  function _removeFileAsync(fdPath, next) {
+    const _handler = function(err) {
+      if (err && !_isENOENT(err)) {
+        return next(err);
+      }
+      next();
+    };
+    if (0 <= fdPath[0])
+      fs28.close(fdPath[0], function() {
+        fs28.unlink(fdPath[1], _handler);
+      });
+    else
+      fs28.unlink(fdPath[1], _handler);
+  }
+  function _removeFileSync(fdPath) {
+    let rethrownException = null;
+    try {
+      if (0 <= fdPath[0])
+        fs28.closeSync(fdPath[0]);
+    } catch (e8) {
+      if (!_isEBADF(e8) && !_isENOENT(e8))
+        throw e8;
+    } finally {
+      try {
+        fs28.unlinkSync(fdPath[1]);
+      } catch (e8) {
+        if (!_isENOENT(e8))
+          rethrownException = e8;
+      }
+    }
+    if (rethrownException !== null) {
+      throw rethrownException;
+    }
+  }
+  function _prepareTmpFileRemoveCallback(name2, fd, opts, sync) {
+    const removeCallbackSync = _prepareRemoveCallback(_removeFileSync, [fd, name2], sync);
+    const removeCallback = _prepareRemoveCallback(_removeFileAsync, [fd, name2], sync, removeCallbackSync);
+    if (!opts.keep)
+      _removeObjects.unshift(removeCallbackSync);
+    return sync ? removeCallbackSync : removeCallback;
+  }
+  function _prepareTmpDirRemoveCallback(name2, opts, sync) {
+    const removeFunction = opts.unsafeCleanup ? rimraf : fs28.rmdir.bind(fs28);
+    const removeFunctionSync = opts.unsafeCleanup ? FN_RIMRAF_SYNC : FN_RMDIR_SYNC;
+    const removeCallbackSync = _prepareRemoveCallback(removeFunctionSync, name2, sync);
+    const removeCallback = _prepareRemoveCallback(removeFunction, name2, sync, removeCallbackSync);
+    if (!opts.keep)
+      _removeObjects.unshift(removeCallbackSync);
+    return sync ? removeCallbackSync : removeCallback;
+  }
+  function _prepareRemoveCallback(removeFunction, fileOrDirName, sync, cleanupCallbackSync) {
+    let called = false;
+    return function _cleanupCallback(next) {
+      if (!called) {
+        const toRemove = cleanupCallbackSync || _cleanupCallback;
+        const index = _removeObjects.indexOf(toRemove);
+        if (index >= 0)
+          _removeObjects.splice(index, 1);
+        called = true;
+        if (sync || removeFunction === FN_RMDIR_SYNC || removeFunction === FN_RIMRAF_SYNC) {
+          return removeFunction(fileOrDirName);
+        } else {
+          return removeFunction(fileOrDirName, next || function() {});
+        }
+      }
+    };
+  }
+  function _garbageCollector() {
+    if (!_gracefulCleanup)
+      return;
+    while (_removeObjects.length) {
+      try {
+        _removeObjects[0]();
+      } catch (e8) {}
+    }
+  }
+  function _randomChars(howMany) {
+    let value = [], rnd = null;
+    try {
+      rnd = crypto.randomBytes(howMany);
+    } catch (e8) {
+      rnd = crypto.pseudoRandomBytes(howMany);
+    }
+    for (let i5 = 0;i5 < howMany; i5++) {
+      value.push(RANDOM_CHARS[rnd[i5] % RANDOM_CHARS.length]);
+    }
+    return value.join("");
+  }
+  function _isUndefined(obj) {
+    return typeof obj === "undefined";
+  }
+  function _parseArguments(options8, callback) {
+    if (typeof options8 === "function") {
+      return [{}, options8];
+    }
+    if (_isUndefined(options8)) {
+      return [{}, callback];
+    }
+    const actualOptions = {};
+    for (const key2 of Object.getOwnPropertyNames(options8)) {
+      actualOptions[key2] = options8[key2];
+    }
+    return [actualOptions, callback];
+  }
+  function _resolvePath(name2, tmpDir, cb2) {
+    const pathToResolve = path18.isAbsolute(name2) ? name2 : path18.join(tmpDir, name2);
+    fs28.stat(pathToResolve, function(err) {
+      if (err) {
+        fs28.realpath(path18.dirname(pathToResolve), function(err2, parentDir) {
+          if (err2)
+            return cb2(err2);
+          cb2(null, path18.join(parentDir, path18.basename(pathToResolve)));
+        });
+      } else {
+        fs28.realpath(pathToResolve, cb2);
+      }
+    });
+  }
+  function _resolvePathSync(name2, tmpDir) {
+    const pathToResolve = path18.isAbsolute(name2) ? name2 : path18.join(tmpDir, name2);
+    try {
+      fs28.statSync(pathToResolve);
+      return fs28.realpathSync(pathToResolve);
+    } catch (_err) {
+      const parentDir = fs28.realpathSync(path18.dirname(pathToResolve));
+      return path18.join(parentDir, path18.basename(pathToResolve));
+    }
+  }
+  function _generateTmpName(opts) {
+    const tmpDir = opts.tmpdir;
+    if (!_isUndefined(opts.name)) {
+      return path18.join(tmpDir, opts.dir, opts.name);
+    }
+    if (!_isUndefined(opts.template)) {
+      return path18.join(tmpDir, opts.dir, opts.template).replace(TEMPLATE_PATTERN, _randomChars(6));
+    }
+    const name2 = [
+      opts.prefix ? opts.prefix : "tmp",
+      "-",
+      process.pid,
+      "-",
+      _randomChars(12),
+      opts.postfix ? "-" + opts.postfix : ""
+    ].join("");
+    return path18.join(tmpDir, opts.dir, name2);
+  }
+  function _assertOptionsBase(options8) {
+    if (!_isUndefined(options8.name)) {
+      const name2 = options8.name;
+      if (path18.isAbsolute(name2))
+        throw new Error(`name option must not contain an absolute path, found "${name2}".`);
+      const basename4 = path18.basename(name2);
+      if (basename4 === ".." || basename4 === "." || basename4 !== name2)
+        throw new Error(`name option must not contain a path, found "${name2}".`);
+    }
+    if (!_isUndefined(options8.template) && !options8.template.match(TEMPLATE_PATTERN)) {
+      throw new Error(`Invalid template, found "${options8.template}".`);
+    }
+    if (!_isUndefined(options8.tries) && isNaN(options8.tries) || options8.tries < 0) {
+      throw new Error(`Invalid tries, found "${options8.tries}".`);
+    }
+    options8.tries = _isUndefined(options8.name) ? options8.tries || DEFAULT_TRIES : 1;
+    options8.keep = !!options8.keep;
+    options8.detachDescriptor = !!options8.detachDescriptor;
+    options8.discardDescriptor = !!options8.discardDescriptor;
+    options8.unsafeCleanup = !!options8.unsafeCleanup;
+    options8.prefix = _isUndefined(options8.prefix) ? "" : options8.prefix;
+    options8.postfix = _isUndefined(options8.postfix) ? "" : options8.postfix;
+  }
+  function _getRelativePath(option, name2, tmpDir, cb2) {
+    if (_isUndefined(name2))
+      return cb2(null);
+    _resolvePath(name2, tmpDir, function(err, resolvedPath) {
+      if (err)
+        return cb2(err);
+      const relativePath = path18.relative(tmpDir, resolvedPath);
+      if (!resolvedPath.startsWith(tmpDir)) {
+        return cb2(new Error(`${option} option must be relative to "${tmpDir}", found "${relativePath}".`));
+      }
+      cb2(null, relativePath);
+    });
+  }
+  function _getRelativePathSync(option, name2, tmpDir) {
+    if (_isUndefined(name2))
+      return;
+    const resolvedPath = _resolvePathSync(name2, tmpDir);
+    const relativePath = path18.relative(tmpDir, resolvedPath);
+    if (!resolvedPath.startsWith(tmpDir)) {
+      throw new Error(`${option} option must be relative to "${tmpDir}", found "${relativePath}".`);
+    }
+    return relativePath;
+  }
+  function _assertAndSanitizeOptions(options8, cb2) {
+    _getTmpDir(options8, function(err, tmpDir) {
+      if (err)
+        return cb2(err);
+      options8.tmpdir = tmpDir;
+      try {
+        _assertOptionsBase(options8, tmpDir);
+      } catch (err2) {
+        return cb2(err2);
+      }
+      _getRelativePath("dir", options8.dir, tmpDir, function(err2, dir2) {
+        if (err2)
+          return cb2(err2);
+        options8.dir = _isUndefined(dir2) ? "" : dir2;
+        _getRelativePath("template", options8.template, tmpDir, function(err3, template2) {
+          if (err3)
+            return cb2(err3);
+          options8.template = template2;
+          cb2(null, options8);
+        });
+      });
+    });
+  }
+  function _assertAndSanitizeOptionsSync(options8) {
+    const tmpDir = options8.tmpdir = _getTmpDirSync(options8);
+    _assertOptionsBase(options8, tmpDir);
+    const dir2 = _getRelativePathSync("dir", options8.dir, tmpDir);
+    options8.dir = _isUndefined(dir2) ? "" : dir2;
+    options8.template = _getRelativePathSync("template", options8.template, tmpDir);
+    return options8;
+  }
+  function _isEBADF(error48) {
+    return _isExpectedError(error48, -EBADF, "EBADF");
+  }
+  function _isENOENT(error48) {
+    return _isExpectedError(error48, -ENOENT, "ENOENT");
+  }
+  function _isExpectedError(error48, errno, code2) {
+    return IS_WIN32 ? error48.code === code2 : error48.code === code2 && error48.errno === errno;
+  }
+  function setGracefulCleanup() {
+    _gracefulCleanup = true;
+  }
+  function _getTmpDir(options8, cb2) {
+    return fs28.realpath(options8 && options8.tmpdir || os10.tmpdir(), cb2);
+  }
+  function _getTmpDirSync(options8) {
+    return fs28.realpathSync(options8 && options8.tmpdir || os10.tmpdir());
+  }
+  process.addListener(EXIT, _garbageCollector);
+  Object.defineProperty(exports, "tmpdir", {
+    enumerable: true,
+    configurable: false,
+    get: function() {
+      return _getTmpDirSync();
+    }
+  });
+  exports.dir = dir;
+  exports.dirSync = dirSync;
+  exports.file = file2;
+  exports.fileSync = fileSync;
+  exports.tmpName = tmpName;
+  exports.tmpNameSync = tmpNameSync;
+  exports.setGracefulCleanup = setGracefulCleanup;
+});
+
 // node_modules/@seald-io/nedb/lib/utils.js
 var require_utils11 = __commonJS((exports, module) => {
   var uniq = (array3, iteratee) => {
@@ -175265,9 +175666,9 @@ var require_utf8 = __commonJS((exports, module) => {
     byteCount = byteArray.length;
     byteIndex = 0;
     var codePoints = [];
-    var tmp;
-    while ((tmp = decodeSymbol(strict)) !== false) {
-      codePoints.push(tmp);
+    var tmp2;
+    while ((tmp2 = decodeSymbol(strict)) !== false) {
+      codePoints.push(tmp2);
     }
     return ucs2encode(codePoints);
   }
@@ -209398,7 +209799,7 @@ var require_typedarray = __commonJS((exports) => {
       ctor.prototype.set = function(index, value) {
         if (arguments.length < 1)
           throw new SyntaxError("Not enough arguments");
-        var array3, sequence, offset, len, i5, s5, d5, byteOffset, byteLength, tmp;
+        var array3, sequence, offset, len, i5, s5, d5, byteOffset, byteLength, tmp2;
         if (typeof arguments[0] === "object" && arguments[0].constructor === this.constructor) {
           array3 = arguments[0];
           offset = ECMAScript.ToUint32(arguments[1]);
@@ -209408,12 +209809,12 @@ var require_typedarray = __commonJS((exports) => {
           byteOffset = this.byteOffset + offset * this.BYTES_PER_ELEMENT;
           byteLength = array3.length * this.BYTES_PER_ELEMENT;
           if (array3.buffer === this.buffer) {
-            tmp = [];
+            tmp2 = [];
             for (i5 = 0, s5 = array3.byteOffset;i5 < byteLength; i5 += 1, s5 += 1) {
-              tmp[i5] = array3.buffer._bytes[s5];
+              tmp2[i5] = array3.buffer._bytes[s5];
             }
             for (i5 = 0, d5 = byteOffset;i5 < byteLength; i5 += 1, d5 += 1) {
-              this.buffer._bytes[d5] = tmp[i5];
+              this.buffer._bytes[d5] = tmp2[i5];
             }
           } else {
             for (i5 = 0, s5 = array3.byteOffset, d5 = byteOffset;i5 < byteLength; i5 += 1, s5 += 1, d5 += 1) {
@@ -225623,6 +226024,7 @@ class ApiError extends SystemError {
   requestMethod;
   requestBody;
   responseBody;
+  requestId;
   constructor(message, options, parsedResponse) {
     const hints = options?.hints ?? ApiError.getReasonHints(parsedResponse) ?? ApiError.getDefaultHints(options?.statusCode);
     super(message, { hints, cause: options?.cause });
@@ -225631,6 +226033,7 @@ class ApiError extends SystemError {
     this.requestMethod = options?.requestMethod;
     this.requestBody = options?.requestBody;
     this.responseBody = options?.responseBody;
+    this.requestId = options?.requestId;
   }
   static async fromHttpError(error48, context) {
     if (error48 instanceof HTTPError) {
@@ -225649,12 +226052,14 @@ class ApiError extends SystemError {
       }
       const statusCode = ApiError.normalizeStatusCode(error48.response.status, responseBody);
       const requestBody = error48.options.context?.__requestBody;
+      const requestId = error48.response.headers.get("X-Request-ID") ?? undefined;
       return new ApiError(`Error ${context}: ${message}`, {
         statusCode,
         requestUrl: error48.request.url,
         requestMethod: error48.request.method,
         requestBody,
         responseBody,
+        requestId,
         cause: error48
       }, parsedErrorResponse);
     }
@@ -243108,7 +243513,6 @@ function getTypesCommand(context) {
 }
 
 // src/cli/dev/dev-server/main.ts
-import { dirname as dirname12, join as join16 } from "node:path";
 var import_cors = __toESM(require_lib4(), 1);
 var import_express4 = __toESM(require_express(), 1);
 
@@ -243229,6 +243633,19 @@ async function getPorts(options8) {
 // src/cli/dev/dev-server/main.ts
 var import_http_proxy_middleware2 = __toESM(require_dist2(), 1);
 
+// node_modules/tmp-promise/index.js
+var { promisify: promisify11 } = __require("util");
+var tmp = require_tmp();
+var $fileSync = tmp.fileSync;
+var fileWithOptions = promisify11((options8, cb2) => tmp.file(options8, (err, path18, fd, cleanup) => err ? cb2(err) : cb2(undefined, { path: path18, fd, cleanup: promisify11(cleanup) })));
+var $dirSync = tmp.dirSync;
+var dirWithOptions = promisify11((options8, cb2) => tmp.dir(options8, (err, path18, cleanup) => err ? cb2(err) : cb2(undefined, { path: path18, cleanup: promisify11(cleanup) })));
+var $dir = async (options8) => dirWithOptions(options8);
+var $tmpNameSync = tmp.tmpNameSync;
+var $tmpName = promisify11(tmp.tmpName);
+var $tmpdir = tmp.tmpdir;
+var $setGracefulCleanup = tmp.setGracefulCleanup;
+
 // src/cli/dev/createDevLogger.ts
 var colorByType = {
   error: theme.styles.error,
@@ -243746,7 +244163,7 @@ var import_multer = __toESM(require_multer(), 1);
 import { randomUUID as randomUUID2 } from "node:crypto";
 import fs28 from "node:fs";
 import path18 from "node:path";
-function createIntegrationRoutes(mediaFilesDir, baseUrl, logger) {
+function createIntegrationRoutes(mediaFilesDir, baseUrl, remoteProxy, logger) {
   const router = import_express3.Router({ mergeParams: true });
   const parseBody = import_express3.json();
   fs28.mkdirSync(mediaFilesDir, { recursive: true });
@@ -243785,13 +244202,22 @@ function createIntegrationRoutes(mediaFilesDir, baseUrl, logger) {
     const signed_url = `${baseUrl}/media/${file_uri}?signature=${signature}`;
     res.json({ signed_url });
   });
-  router.post("/Core/:endpointName", (req, res) => {
+  router.post("/Core/:endpointName", (req, res, next) => {
     logger.warn(`Core.${req.params.endpointName} is not supported in local development`);
-    res.json({});
+    req.url = req.originalUrl;
+    remoteProxy(req, res, next);
   });
-  router.post("/installable/:packageName/integration-endpoints/:endpointName", (req, res) => {
+  router.post("/installable/:packageName/integration-endpoints/:endpointName", (req, res, next) => {
     logger.warn(`${req.params.packageName}.${req.params.endpointName} is not supported in local development`);
-    res.json({});
+    req.url = req.originalUrl;
+    remoteProxy(req, res, next);
+  });
+  router.use((err, _req, res, next) => {
+    if (err instanceof import_multer.default.MulterError) {
+      res.status(err.code === "LIMIT_FILE_SIZE" ? 413 : 400).json({ error: err.message });
+      return;
+    }
+    next(err);
   });
   return router;
 }
@@ -243844,15 +244270,15 @@ async function createDevServer(options8) {
   let emitEntityEvent = () => {};
   const entityRoutes = createEntityRoutes(db2, devLogger, remoteProxy, (...args) => emitEntityEvent(...args));
   app.use("/api/apps/:appId/entities", entityRoutes);
-  const configDir = dirname12(project2.configPath);
-  const mediaFilesDir = join16(configDir, "tmp", "files");
+  const { path: mediaFilesDir } = await $dir();
   app.use("/media", import_express4.default.static(mediaFilesDir));
-  const integrationRoutes = createIntegrationRoutes(mediaFilesDir, baseUrl, devLogger);
+  const integrationRoutes = createIntegrationRoutes(mediaFilesDir, baseUrl, remoteProxy, devLogger);
   app.use("/api/apps/:appId/integration-endpoints", integrationRoutes);
   const customIntegrationRoutes = createCustomIntegrationRoutes(remoteProxy, devLogger);
   app.use("/api/apps/:appId/integrations/custom", customIntegrationRoutes);
   app.use((req, res, next) => {
-    return remoteProxy(req, res, next);
+    devLogger.warn(`"${req.originalUrl}" is not supported in local development, passing call to production`);
+    remoteProxy(req, res, next);
   });
   return new Promise((resolve6, reject) => {
     const server = app.listen(port, "127.0.0.1", (err) => {
@@ -244029,7 +244455,7 @@ var import_detect_agent = __toESM(require_dist5(), 1);
 import { release, type } from "node:os";
 
 // node_modules/posthog-node/dist/extensions/error-tracking/modifiers/module.node.mjs
-import { dirname as dirname13, posix, sep } from "path";
+import { dirname as dirname12, posix, sep } from "path";
 function createModulerModifier() {
   const getModuleFromFileName = createGetModuleFromFilename();
   return async (frames) => {
@@ -244038,7 +244464,7 @@ function createModulerModifier() {
     return frames;
   };
 }
-function createGetModuleFromFilename(basePath = process.argv[1] ? dirname13(process.argv[1]) : process.cwd(), isWindows4 = sep === "\\") {
+function createGetModuleFromFilename(basePath = process.argv[1] ? dirname12(process.argv[1]) : process.cwd(), isWindows4 = sep === "\\") {
   const normalizedBase = isWindows4 ? normalizeWindowsPath2(basePath) : basePath;
   return (filename) => {
     if (!filename)
@@ -248144,7 +248570,8 @@ class ErrorReporter {
       api_request_url: error48.requestUrl,
       api_request_method: error48.requestMethod,
       api_request_body: error48.requestBody,
-      api_response_body: error48.responseBody
+      api_response_body: error48.responseBody,
+      api_request_id: error48.requestId
     } : {};
     return {
       session_id: this.sessionId,
@@ -248255,4 +248682,4 @@ export {
   CLIExitError
 };
 
-//# debugId=06F31C5B0245F98264756E2164756E21
+//# debugId=81D3CE8AEC065B8B64756E2164756E21