@base44-preview/cli 0.0.32-pr.248.70443e1 → 0.0.32-pr.249.063e424

package/dist/cli/index.js

@@ -178102,6 +178102,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;
@@ -178217,6 +178229,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";
   entityName;
@@ -185051,6 +185078,10 @@ var TikTokConnectorSchema = exports_external.object({
   type: exports_external.literal("tiktok"),
   scopes: exports_external.array(exports_external.string()).default([])
 });
+var GoogleBigQueryConnectorSchema = exports_external.object({
+  type: exports_external.literal("googlebigquery"),
+  scopes: exports_external.array(exports_external.string()).default([])
+});
 var CustomTypeSchema = exports_external.string().min(1).regex(/^[a-z0-9_-]+$/i);
 var GenericConnectorSchema = exports_external.object({
   type: CustomTypeSchema,
@@ -185063,6 +185094,7 @@ var ConnectorResourceSchema = exports_external.union([
   GoogleSheetsConnectorSchema,
   GoogleDocsConnectorSchema,
   GoogleSlidesConnectorSchema,
+  GoogleBigQueryConnectorSchema,
   SlackConnectorSchema,
   NotionConnectorSchema,
   SalesforceConnectorSchema,
@@ -185078,6 +185110,7 @@ var KnownIntegrationTypes = [
   "googlesheets",
   "googledocs",
   "googleslides",
+  "googlebigquery",
   "slack",
   "notion",
   "salesforce",
@@ -185340,7 +185373,10 @@ var connectorResource = {
 // src/core/resources/entity/schema.ts
 var FieldConditionSchema = exports_external.union([
   exports_external.string(),
-  exports_external.object({
+  exports_external.number(),
+  exports_external.boolean(),
+  exports_external.null(),
+  exports_external.looseObject({
     $in: exports_external.unknown().optional(),
     $nin: exports_external.unknown().optional(),
     $ne: exports_external.unknown().optional(),
@@ -185357,6 +185393,15 @@ var rlsConditionAllowedKeys = new Set([
   "user_condition",
   "created_by",
   "created_by_id",
+  "id",
+  "_id",
+  "created_date",
+  "updated_date",
+  "app_id",
+  "entity_name",
+  "is_deleted",
+  "deleted_date",
+  "environment",
   "$or",
   "$and",
   "$nor"
@@ -185385,60 +185430,33 @@ var isValidFieldCondition = (value) => {
   }
   return false;
 };
-var RefineRLSConditionSchema = RLSConditionSchema.refine((val) => Object.entries(val).every(([key, value]) => {
-  if (rlsConditionAllowedKeys.has(key)) {
-    return true;
-  }
-  if (!key.startsWith("data.")) {
-    return false;
-  }
-  return isValidFieldCondition(value);
-}), "Keys must be known RLS keys or match data.* pattern with valid value");
+var RefineRLSConditionSchema = RLSConditionSchema.refine((val) => Object.entries(val).every(([key, value]) => rlsConditionAllowedKeys.has(key) || isValidFieldCondition(value)), "Field condition values must be a primitive or an operator object ($in, $nin, $ne, $all)");
 var RLSRuleSchema = exports_external.union([exports_external.boolean(), RefineRLSConditionSchema]);
-var EntityRLSSchema = exports_external.strictObject({
+var EntityRLSSchema = exports_external.looseObject({
   create: RLSRuleSchema.optional(),
   read: RLSRuleSchema.optional(),
   update: RLSRuleSchema.optional(),
   delete: RLSRuleSchema.optional(),
   write: RLSRuleSchema.optional()
 });
-var FieldRLSSchema = exports_external.strictObject({
+var FieldRLSSchema = exports_external.looseObject({
   read: RLSRuleSchema.optional(),
   write: RLSRuleSchema.optional(),
   create: RLSRuleSchema.optional(),
   update: RLSRuleSchema.optional(),
   delete: RLSRuleSchema.optional()
 });
-var PropertyTypeSchema = exports_external.enum([
-  "string",
-  "number",
-  "integer",
-  "boolean",
-  "array",
-  "object"
-]);
-var StringFormatSchema = exports_external.enum([
-  "date",
-  "date-time",
-  "time",
-  "email",
-  "uri",
-  "hostname",
-  "ipv4",
-  "ipv6",
-  "uuid"
-]);
-var PropertyDefinitionSchema = exports_external.object({
-  type: PropertyTypeSchema,
+var PropertyDefinitionSchema = exports_external.looseObject({
+  type: exports_external.string().optional(),
   title: exports_external.string().optional(),
   description: exports_external.string().optional(),
   minLength: exports_external.number().int().min(0).optional(),
   maxLength: exports_external.number().int().min(0).optional(),
   pattern: exports_external.string().optional(),
-  format: StringFormatSchema.optional(),
+  format: exports_external.string().optional(),
   minimum: exports_external.number().optional(),
   maximum: exports_external.number().optional(),
-  enum: exports_external.array(exports_external.string()).optional(),
+  enum: exports_external.array(exports_external.unknown()).optional(),
   enumNames: exports_external.array(exports_external.string()).optional(),
   default: exports_external.unknown().optional(),
   $ref: exports_external.string().optional(),
@@ -185451,12 +185469,12 @@ var PropertyDefinitionSchema = exports_external.object({
     return exports_external.record(exports_external.string(), PropertyDefinitionSchema).optional();
   }
 });
-var EntitySchema = exports_external.object({
-  type: exports_external.literal("object"),
-  name: exports_external.string().regex(/^[a-zA-Z0-9]+$/, "Entity name must be alphanumeric only"),
+var EntitySchema = exports_external.looseObject({
+  type: exports_external.literal("object").default("object"),
+  name: exports_external.string().min(1).regex(/^[a-zA-Z0-9]+$/, "Entity name must be alphanumeric only"),
   title: exports_external.string().optional(),
   description: exports_external.string().optional(),
-  properties: exports_external.record(exports_external.string(), PropertyDefinitionSchema),
+  properties: exports_external.record(exports_external.string(), PropertyDefinitionSchema).default({}),
   required: exports_external.array(exports_external.string()).optional(),
   rls: EntityRLSSchema.optional()
 });
@@ -186024,7 +186042,7 @@ async function handleUnauthorized(request, _options, response) {
     return;
   }
   retriedRequests.add(request);
-  return distribution_default(request, {
+  return distribution_default(request.clone(), {
     headers: { Authorization: `Bearer ${newAccessToken}` }
   });
 }
@@ -186663,7 +186681,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) {
@@ -186765,12 +186785,12 @@ var BANNER_LINES = [
   "██████╔╝██║  ██║███████║███████╗      ██║     ██║",
   "╚═════╝ ╚═╝  ╚═╝╚══════╝╚══════╝      ╚═╝     ╚═╝"
 ];
-async function printBanner() {
-  if (process.stdout.isTTY) {
-    await printAnimatedLines(BANNER_LINES);
-  } else {
+async function printBanner(isNonInteractive) {
+  if (isNonInteractive) {
     console.log(theme.colors.base44Orange(BANNER_LINES.join(`
 `)));
+  } else {
+    await printAnimatedLines(BANNER_LINES);
   }
 }
 // src/cli/errors.ts
@@ -193486,6 +193506,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",
@@ -193574,7 +193595,7 @@ async function printUpgradeNotificationIfAvailable() {
 async function runCommand(commandFn, options, context) {
   console.log();
   if (options?.fullBanner) {
-    await printBanner();
+    await printBanner(context.isNonInteractive);
     Ie("");
   } else {
     Ie(theme.colors.base44OrangeBackground(" Base 44 "));
@@ -194504,7 +194525,7 @@ function printSummary(results, oauthOutcomes) {
     M2.error(`Failed: ${r2.type}${r2.error ? ` - ${r2.error}` : ""}`);
   }
 }
-async function pushConnectorsAction() {
+async function pushConnectorsAction(isNonInteractive) {
   const { connectors } = await readProjectConfig();
   if (connectors.length === 0) {
     M2.info("No local connectors found - checking for remote connectors to remove");
@@ -194518,18 +194539,18 @@ async function pushConnectorsAction() {
   const needsOAuth = filterPendingOAuth(results);
   let outroMessage = "Connectors pushed to Base44";
   const oauthOutcomes = await promptOAuthFlows(needsOAuth, {
-    skipPrompt: !!process.env.CI
+    skipPrompt: isNonInteractive
   });
   const allAuthorized = oauthOutcomes.size > 0 && [...oauthOutcomes.values()].every((s) => s === "ACTIVE");
   if (needsOAuth.length > 0 && !allAuthorized) {
-    outroMessage = process.env.CI ? "Skipped OAuth in CI. Run 'base44 connectors push' locally or open the links above to authorize." : "Some connectors still require authorization. Run 'base44 connectors push' or open the links above to authorize.";
+    outroMessage = isNonInteractive ? "Skipped OAuth in non-interactive mode. Run 'base44 connectors push' locally or open the links above to authorize." : "Some connectors still require authorization. Run 'base44 connectors push' or open the links above to authorize.";
   }
   printSummary(results, oauthOutcomes);
   return { outroMessage };
 }
 function getConnectorsPushCommand(context) {
   return new Command("push").description("Push local connectors to Base44 (overwrites connectors on Base44)").action(async () => {
-    await runCommand(pushConnectorsAction, { requireAuth: true }, context);
+    await runCommand(() => pushConnectorsAction(context.isNonInteractive), { requireAuth: true }, context);
   });
 }
 
@@ -194539,16 +194560,16 @@ function getConnectorsCommand(context) {
 }
 
 // src/cli/commands/dashboard/open.ts
-async function openDashboard() {
+async function openDashboard(isNonInteractive) {
   const dashboardUrl = getDashboardUrl();
-  if (!process.env.CI) {
+  if (!isNonInteractive) {
     await open_default(dashboardUrl);
   }
   return { outroMessage: `Dashboard opened at ${dashboardUrl}` };
 }
 function getDashboardOpenCommand(context) {
   return new Command("open").description("Open the app dashboard in your browser").action(async () => {
-    await runCommand(openDashboard, { requireAuth: true }, context);
+    await runCommand(() => openDashboard(context.isNonInteractive), { requireAuth: true }, context);
   });
 }
 
@@ -194854,7 +194875,7 @@ ${summaryLines.join(`
   const needsOAuth = filterPendingOAuth(result.connectorResults ?? []);
   if (needsOAuth.length > 0) {
     const oauthOutcomes = await promptOAuthFlows(needsOAuth, {
-      skipPrompt: options.yes || !!process.env.CI
+      skipPrompt: options.yes || options.isNonInteractive
     });
     const allAuthorized = oauthOutcomes.size > 0 && [...oauthOutcomes.values()].every((s) => s === "ACTIVE");
     if (!allAuthorized) {
@@ -194869,7 +194890,10 @@ ${summaryLines.join(`
 }
 function getDeployCommand(context) {
   return new Command("deploy").description("Deploy all project resources (entities, functions, agents, connectors, and site)").option("-y, --yes", "Skip confirmation prompt").action(async (options) => {
-    await runCommand(() => deployAction(options), { requireAuth: true }, context);
+    await runCommand(() => deployAction({
+      ...options,
+      isNonInteractive: context.isNonInteractive
+    }), { requireAuth: true }, context);
   });
 }
 
@@ -195051,21 +195075,24 @@ async function deployAction2(options) {
 }
 function getSiteDeployCommand(context) {
   return new Command("deploy").description("Deploy built site files to Base44 hosting").option("-y, --yes", "Skip confirmation prompt").action(async (options) => {
-    await runCommand(() => deployAction2(options), { requireAuth: true }, context);
+    await runCommand(() => deployAction2({
+      ...options,
+      isNonInteractive: context.isNonInteractive
+    }), { requireAuth: true }, context);
   });
 }
 
 // src/cli/commands/site/open.ts
-async function openAction() {
+async function openAction(isNonInteractive) {
   const siteUrl = await getSiteUrl();
-  if (!process.env.CI) {
+  if (!isNonInteractive) {
     await open_default(siteUrl);
   }
   return { outroMessage: `Site opened at ${siteUrl}` };
 }
 function getSiteOpenCommand(context) {
   return new Command("open").description("Open the published site in your browser").action(async () => {
-    await runCommand(openAction, { requireAuth: true }, context);
+    await runCommand(() => openAction(context.isNonInteractive), { requireAuth: true }, context);
   });
 }
 
@@ -195206,8 +195233,9 @@ 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_express = __toESM(require_express(), 1);
+var import_express2 = __toESM(require_express(), 1);
 
 // node_modules/get-port/index.js
 import net from "node:net";
@@ -195325,11 +195353,302 @@ async function getPorts(options8) {
 
 // src/cli/dev/dev-server/main.ts
 var import_http_proxy_middleware = __toESM(require_dist2(), 1);
+
+// src/cli/dev/createDevLogger.ts
+var dateTimeFormat = new Intl.DateTimeFormat([], {
+  hour: "2-digit",
+  minute: "2-digit",
+  second: "2-digit",
+  hour12: false
+});
+var colorByType = {
+  error: theme.styles.error,
+  warn: theme.styles.warn,
+  log: (text) => text
+};
+function createDevLogger(isPrefixed = true) {
+  const print = (type, msg) => {
+    const colorize = colorByType[type];
+    switch (type) {
+      case "error":
+        console.error(colorize(msg));
+        break;
+      case "warn":
+        console.warn(colorize(msg));
+        break;
+      default:
+        console.log(msg);
+    }
+  };
+  const prefixedLog = (type, msg) => {
+    const timestamp = dateTimeFormat.format(new Date);
+    const colorize = colorByType[type];
+    console.log(`${theme.styles.dim(timestamp)} ${colorize(msg)}`);
+  };
+  return isPrefixed ? {
+    log: (msg) => prefixedLog("log", msg),
+    error: (msg, err) => {
+      prefixedLog("error", msg);
+      if (err) {
+        prefixedLog("error", String(err));
+      }
+    },
+    warn: (msg) => prefixedLog("warn", msg)
+  } : {
+    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;
+  }
+  functionNames() {
+    return Array.from(this.functions.keys());
+  }
+  getFunction(name2) {
+    return this.functions.get(name2);
+  }
+  verifyDenoIsInstalled() {
+    if (this.functions.size > 0) {
+      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" }]
+        });
+      }
+    }
+  }
+  async ensureRunning(name2) {
+    const existing = this.running.get(name2);
+    if (existing?.ready) {
+      return existing.port;
+    }
+    const pending = this.starting.get(name2);
+    if (pending) {
+      return pending;
+    }
+    const backendFunction = this.functions.get(name2);
+    if (!backendFunction) {
+      throw new InvalidInputError(`Function "${name2}" not found`, {
+        hints: [{ message: "Check available functions in your project" }]
+      });
+    }
+    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);
+  }
+  getPort(name2) {
+    const running = this.running.get(name2);
+    return running?.ready ? running.port : undefined;
+  }
+  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();
+  }
+  stop(name2) {
+    const running = this.running.get(name2);
+    if (running) {
+      this.logger.log(`Stopping function: ${name2}`);
+      running.process.kill();
+      this.running.delete(name2);
+    }
+  }
+  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) => {
+      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);
+      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" }]
+          }));
+        }
+      });
+    });
+  }
+}
+
+// src/cli/dev/dev-server/routes/functions.ts
+var import_express = __toESM(require_express(), 1);
+import { request as httpRequest } from "node:http";
+function createFunctionRoutes(manager, logger) {
+  const router = import_express.Router({ mergeParams: true });
+  router.all("/:functionName", async (req, res) => {
+    const { functionName } = req.params;
+    try {
+      const func = manager.getFunction(functionName);
+      if (!func) {
+        res.status(404).json({
+          error: `Function "${functionName}" not found`
+        });
+        return;
+      }
+      const port = await manager.ensureRunning(functionName);
+      await proxyRequest(req, res, port, logger);
+    } catch (error48) {
+      logger.error(`Function error:`, error48);
+      const message = error48 instanceof Error ? error48.message : String(error48);
+      res.status(500).json({ error: message });
+    }
+  });
+  return router;
+}
+function proxyRequest(req, res, port, logger) {
+  return new Promise((resolve5, reject) => {
+    const headers = {
+      ...req.headers
+    };
+    delete headers.host;
+    if (headers["x-app-id"]) {
+      headers["Base44-App-Id"] = headers["x-app-id"];
+    }
+    headers["Base44-Api-Url"] = `${req.protocol}://${req.get("host")}`;
+    const options8 = {
+      hostname: "localhost",
+      port,
+      path: req.url,
+      method: req.method,
+      headers
+    };
+    const proxyReq = httpRequest(options8, (proxyRes) => {
+      res.status(proxyRes.statusCode || 200);
+      for (const [key2, value] of Object.entries(proxyRes.headers)) {
+        if (value !== undefined) {
+          res.setHeader(key2, value);
+        }
+      }
+      proxyRes.pipe(res);
+      proxyRes.on("end", () => {
+        resolve5();
+      });
+      proxyRes.on("error", (error48) => {
+        reject(error48);
+      });
+    });
+    proxyReq.on("error", (error48) => {
+      logger.error(`Function proxy error:`, error48);
+      if (!res.headersSent) {
+        res.status(502).json({
+          error: "Failed to proxy request to function",
+          details: error48.message
+        });
+        res.once("finish", resolve5);
+      } else {
+        resolve5();
+      }
+    });
+    req.pipe(proxyReq);
+  });
+}
+
+// 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();
+async function createDevServer(options8) {
+  const { port: userPort } = options8;
+  const port = userPort ?? await getPorts({ port: DEFAULT_PORT });
+  const { project: project2 } = await readProjectConfig();
+  const configDir = dirname12(project2.configPath);
+  const app = import_express2.default();
   const remoteProxy = import_http_proxy_middleware.createProxyMiddleware({
     target: BASE44_APP_URL,
     changeOrigin: true
@@ -195346,6 +195665,15 @@ async function createDevServer(options8 = {}) {
     }
     next();
   });
+  const functions = await functionResource.readAll(join16(configDir, project2.functionsDir));
+  const devLogger = createDevLogger(false);
+  const functionManager = new FunctionManager(functions, devLogger);
+  functionManager.verifyDenoIsInstalled();
+  if (functionManager.functionNames().length > 0) {
+    M2.info(`Loaded functions: ${functionManager.functionNames().join(", ")}`);
+  }
+  const functionRoutes = createFunctionRoutes(functionManager, devLogger);
+  app.use("/api/apps/:appId/functions", functionRoutes);
   app.use((req, res, next) => {
     return remoteProxy(req, res, next);
   });
@@ -195358,6 +195686,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
@@ -195370,7 +195704,9 @@ 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
+  });
   return {
     outroMessage: `Dev server is available at ${theme.colors.links(`http://localhost:${resolvedPort}`)}`
   };
@@ -195468,7 +195804,7 @@ async function eject(options8) {
 }
 function getEjectCommand(context) {
   return new Command("eject").description("Download the code for an existing Base44 project").option("-p, --path <path>", "Path where to write the project").option("--project-id <id>", "Project ID to eject (skips interactive selection)").option("-y, --yes", "Skip confirmation prompts").action(async (options8) => {
-    await runCommand(() => eject(options8), { requireAuth: true, requireAppConfig: false }, context);
+    await runCommand(() => eject({ ...options8, isNonInteractive: context.isNonInteractive }), { requireAuth: true, requireAppConfig: false }, context);
   });
 }
 
@@ -195532,7 +195868,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) => {
@@ -195541,7 +195877,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)
@@ -199735,7 +200071,8 @@ function addCommandInfoToErrorReporter(program2, errorReporter) {
 async function runCLI() {
   const errorReporter = new ErrorReporter;
   errorReporter.registerProcessErrorHandlers();
-  const context = { errorReporter };
+  const isNonInteractive = !process.stdin.isTTY || !process.stdout.isTTY;
+  const context = { errorReporter, isNonInteractive };
   const program2 = createProgram(context);
   try {
     const userInfo = await readAuth();
@@ -199760,4 +200097,4 @@ export {
   CLIExitError
 };
 
-//# debugId=BE87F2C8EFF5B4AD64756E2164756E21
+//# debugId=2A5B2FACE1F5C10F64756E2164756E21