@base44-preview/cli 0.0.32-pr.249.fc3089a → 0.0.32-pr.251.2056a80

package/dist/cli/index.js

@@ -17468,7 +17468,7 @@ var require_lodash2 = __commonJS((exports, module) => {
       function nth(array2, n2) {
         return array2 && array2.length ? baseNth(array2, toInteger(n2)) : undefined2;
       }
-      var pull = baseRest(pullAll);
+      var pull2 = baseRest(pullAll);
       function pullAll(array2, values2) {
         return array2 && array2.length && values2 && values2.length ? basePullAll(array2, values2) : array2;
       }
@@ -19233,7 +19233,7 @@ __p += '`;
       lodash.pickBy = pickBy;
       lodash.property = property;
       lodash.propertyOf = propertyOf;
-      lodash.pull = pull;
+      lodash.pull = pull2;
       lodash.pullAll = pullAll;
       lodash.pullAllBy = pullAllBy;
       lodash.pullAllWith = pullAllWith;
@@ -185051,6 +185051,10 @@ var TikTokConnectorSchema = exports_external.object({
   type: exports_external.literal("tiktok"),
   scopes: exports_external.array(exports_external.string()).default([])
 });
+var StripeConnectorSchema = exports_external.object({
+  type: exports_external.literal("stripe"),
+  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,
@@ -185069,6 +185073,7 @@ var ConnectorResourceSchema = exports_external.union([
   HubspotConnectorSchema,
   LinkedInConnectorSchema,
   TikTokConnectorSchema,
+  StripeConnectorSchema,
   GenericConnectorSchema
 ]);
 var KnownIntegrationTypes = [
@@ -185083,7 +185088,8 @@ var KnownIntegrationTypes = [
   "salesforce",
   "hubspot",
   "linkedin",
-  "tiktok"
+  "tiktok",
+  "stripe"
 ];
 var IntegrationTypeSchema = exports_external.union([
   exports_external.enum(KnownIntegrationTypes),
@@ -185136,6 +185142,18 @@ var RemoveConnectorResponseSchema = exports_external.object({
   status: data.status,
   integrationType: data.integration_type
 }));
+var STRIPE_CONNECTOR_TYPE = "stripe";
+var InstallStripeResponseSchema = exports_external.object({
+  already_installed: exports_external.boolean(),
+  claim_url: exports_external.string().nullable()
+});
+var StripeStatusResponseSchema = exports_external.object({
+  stripe_mode: exports_external.enum(["sandbox", "live"]).nullable(),
+  sandbox_claim_url: exports_external.string().nullable().optional()
+});
+var RemoveStripeResponseSchema = exports_external.object({
+  success: exports_external.boolean()
+});
 
 // src/core/resources/connector/api.ts
 async function listConnectors() {
@@ -185203,6 +185221,54 @@ async function removeConnector(integrationType) {
   }
   return result.data;
 }
+async function installStripe() {
+  const appClient = getAppClient();
+  let response;
+  try {
+    response = await appClient.post("payments/stripe/install", {
+      timeout: 60000
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "installing Stripe");
+  }
+  const result = InstallStripeResponseSchema.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid response from server", result.error);
+  }
+  return result.data;
+}
+async function getStripeStatus() {
+  const appClient = getAppClient();
+  let response;
+  try {
+    response = await appClient.get("payments/stripe/status", {
+      timeout: 60000
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "checking Stripe integration status");
+  }
+  const result = StripeStatusResponseSchema.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid response from server", result.error);
+  }
+  return result.data;
+}
+async function removeStripe() {
+  const appClient = getAppClient();
+  let response;
+  try {
+    response = await appClient.delete("payments/stripe", {
+      timeout: 60000
+    });
+  } catch (error48) {
+    throw await ApiError.fromHttpError(error48, "removing Stripe integration");
+  }
+  const result = RemoveStripeResponseSchema.safeParse(await response.json());
+  if (!result.success) {
+    throw new SchemaValidationError("Invalid response from server", result.error);
+  }
+  return result.data;
+}
 // src/core/resources/connector/config.ts
 import { join as join4 } from "node:path";
 import { isDeepStrictEqual } from "node:util";
@@ -185251,7 +185317,7 @@ async function readAllConnectors(connectorsDir) {
 async function writeConnectors(connectorsDir, remoteConnectors) {
   const entries = await readConnectorFiles(connectorsDir);
   const typeToEntry = buildTypeToEntryMap(entries);
-  const newTypes = new Set(remoteConnectors.map((c) => c.integrationType));
+  const newTypes = new Set(remoteConnectors.map((c) => c.type));
   const deleted = [];
   for (const [type, entry] of typeToEntry) {
     if (!newTypes.has(type)) {
@@ -185261,22 +185327,44 @@ async function writeConnectors(connectorsDir, remoteConnectors) {
   }
   const written = [];
   for (const connector of remoteConnectors) {
-    const existing = typeToEntry.get(connector.integrationType);
-    const localConnector = {
-      type: connector.integrationType,
-      scopes: connector.scopes
-    };
-    if (existing && isDeepStrictEqual(existing.data, localConnector)) {
+    const existing = typeToEntry.get(connector.type);
+    if (existing && isDeepStrictEqual(existing.data, connector)) {
       continue;
     }
-    const filePath = existing?.filePath ?? join4(connectorsDir, `${connector.integrationType}.${CONFIG_FILE_EXTENSION}`);
-    await writeJsonFile(filePath, localConnector);
-    written.push(connector.integrationType);
+    const filePath = existing?.filePath ?? join4(connectorsDir, `${connector.type}.${CONFIG_FILE_EXTENSION}`);
+    await writeJsonFile(filePath, connector);
+    written.push(connector.type);
   }
   return { written, deleted };
 }
+// src/core/resources/connector/pull.ts
+async function pullAllConnectors() {
+  const [oauthResponse, stripeStatus] = await Promise.all([
+    listConnectors(),
+    getStripeStatus()
+  ]);
+  const connectors = oauthResponse.integrations.map((i) => ({
+    type: i.integrationType,
+    scopes: i.scopes
+  }));
+  if (stripeStatus.stripe_mode !== null) {
+    connectors.push({ type: STRIPE_CONNECTOR_TYPE, scopes: [] });
+  }
+  return connectors;
+}
 // src/core/resources/connector/push.ts
 async function pushConnectors(connectors) {
+  const stripeConnector = connectors.find((c) => c.type === STRIPE_CONNECTOR_TYPE);
+  const oauthConnectors = connectors.filter((c) => c.type !== STRIPE_CONNECTOR_TYPE);
+  const oauthResults = await syncOAuthConnectors(oauthConnectors);
+  const stripeResult = await syncStripeConnector(stripeConnector);
+  const results = [...oauthResults];
+  if (stripeResult) {
+    results.push(stripeResult);
+  }
+  return { results };
+}
+async function syncOAuthConnectors(connectors) {
   const results = [];
   const upstream = await listConnectors();
   const localTypes = new Set(connectors.map((c) => c.type));
@@ -185309,7 +185397,69 @@ async function pushConnectors(connectors) {
       }
     }
   }
-  return { results };
+  return results;
+}
+async function syncStripeConnector(localStripe) {
+  const remoteStatus = await fetchStripeRemoteStatus();
+  if (remoteStatus === "error") {
+    return localStripe ? stripeError("Failed to check Stripe integration status") : null;
+  }
+  const isRemoteInstalled = remoteStatus.stripe_mode !== null;
+  const needsInstall = localStripe && !isRemoteInstalled;
+  const alreadySynced = localStripe && isRemoteInstalled;
+  const needsRemoval = !localStripe && isRemoteInstalled;
+  if (needsInstall) {
+    return handleStripeInstall();
+  }
+  if (alreadySynced) {
+    const mode = remoteStatus.stripe_mode;
+    const hasUnclaimedSandbox = mode === "sandbox" && remoteStatus.sandbox_claim_url;
+    return hasUnclaimedSandbox ? stripeProvisioned(mode, remoteStatus.sandbox_claim_url ?? undefined) : stripeSynced();
+  }
+  if (needsRemoval) {
+    return handleStripeRemoval();
+  }
+  return null;
+}
+async function fetchStripeRemoteStatus() {
+  try {
+    const status = await getStripeStatus();
+    if (!status)
+      return "error";
+    return status;
+  } catch {
+    return "error";
+  }
+}
+async function handleStripeInstall() {
+  try {
+    const result = await installStripe();
+    const status = await fetchStripeRemoteStatus();
+    const mode = status !== "error" && status.stripe_mode ? status.stripe_mode : "sandbox";
+    return stripeProvisioned(mode, result.claim_url ?? undefined);
+  } catch (err) {
+    return stripeError(err instanceof Error ? err.message : String(err));
+  }
+}
+async function handleStripeRemoval() {
+  try {
+    await removeStripe();
+    return stripeRemoved();
+  } catch (err) {
+    return stripeError(err instanceof Error ? err.message : String(err));
+  }
+}
+function stripeSynced() {
+  return { type: STRIPE_CONNECTOR_TYPE, action: "synced" };
+}
+function stripeProvisioned(mode, claimUrl) {
+  return { type: STRIPE_CONNECTOR_TYPE, action: "provisioned", mode, claimUrl };
+}
+function stripeRemoved() {
+  return { type: STRIPE_CONNECTOR_TYPE, action: "removed" };
+}
+function stripeError(error48) {
+  return { type: STRIPE_CONNECTOR_TYPE, action: "error", error: error48 };
 }
 function getConnectorSyncResult(type, response) {
   if (response.error === "different_user") {
@@ -185327,7 +185477,7 @@ function getConnectorSyncResult(type, response) {
       type,
       action: "needs_oauth",
       redirectUrl: response.redirectUrl,
-      connectionId: response.connectionId ?? undefined
+      connectionId: response.connectionId ?? ""
     };
   }
   return { type, action: "synced" };
@@ -186024,7 +186174,7 @@ async function handleUnauthorized(request, _options, response) {
     return;
   }
   retriedRequests.add(request);
-  return distribution_default(request, {
+  return distribution_default(request.clone(), {
     headers: { Authorization: `Bearer ${newAccessToken}` }
   });
 }
@@ -193486,7 +193636,6 @@ 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",
@@ -193637,6 +193786,10 @@ function getDashboardUrl(projectId) {
   const id = projectId ?? getAppConfig().id;
   return `${getBase44ApiUrl()}/apps/${id}/editor/workspace/overview`;
 }
+function getConnectorsUrl(projectId) {
+  const id = projectId ?? getAppConfig().id;
+  return `${getBase44ApiUrl()}/apps/${id}/editor/workspace/app-connections`;
+}
 // src/cli/commands/agents/pull.ts
 async function pullAgentsAction() {
   const { project: project2 } = await readProjectConfig();
@@ -193741,13 +193894,13 @@ async function pullConnectorsAction() {
   const configDir = dirname8(project2.configPath);
   const connectorsDir = join10(configDir, project2.connectorsDir);
   const remoteConnectors = await runTask("Fetching connectors from Base44", async () => {
-    return await listConnectors();
+    return await pullAllConnectors();
   }, {
     successMessage: "Connectors fetched successfully",
     errorMessage: "Failed to fetch connectors"
   });
   const { written, deleted } = await runTask("Syncing connector files", async () => {
-    return await writeConnectors(connectorsDir, remoteConnectors.integrations);
+    return await writeConnectors(connectorsDir, remoteConnectors);
   }, {
     successMessage: "Connector files synced successfully",
     errorMessage: "Failed to sync connector files"
@@ -193762,7 +193915,7 @@ async function pullConnectorsAction() {
     M2.info("All connectors are already up to date");
   }
   return {
-    outroMessage: `Pulled ${remoteConnectors.integrations.length} connectors to ${connectorsDir}`
+    outroMessage: `Pulled ${remoteConnectors.length} connectors to ${connectorsDir}`
   };
 }
 function getConnectorsPullCommand(context) {
@@ -194381,7 +194534,7 @@ var open_default = open;
 var POLL_INTERVAL_MS = 2000;
 var POLL_TIMEOUT_MS = 2 * 60 * 1000;
 function filterPendingOAuth(results) {
-  return results.filter((r2) => r2.action === "needs_oauth" && !!r2.redirectUrl && !!r2.connectionId);
+  return results.filter((r2) => r2.action === "needs_oauth");
 }
 async function runOAuthFlowWithSkip(connector2) {
   await open_default(connector2.redirectUrl);
@@ -194463,32 +194616,49 @@ Opening browser for ${connector2.type}...`);
 function printSummary(results, oauthOutcomes) {
   const synced = [];
   const added = [];
+  const provisioned = [];
   const removed = [];
   const skipped = [];
   const failed = [];
   for (const r2 of results) {
-    const oauthStatus = oauthOutcomes.get(r2.type);
-    if (r2.action === "synced") {
-      synced.push(r2.type);
-    } else if (r2.action === "removed") {
-      removed.push(r2.type);
-    } else if (r2.action === "error") {
-      failed.push({ type: r2.type, error: r2.error });
-    } else if (r2.action === "needs_oauth") {
-      if (oauthStatus === "ACTIVE") {
-        added.push(r2.type);
-      } else if (oauthStatus === "SKIPPED") {
-        skipped.push(r2.type);
-      } else if (oauthStatus === "PENDING") {
-        failed.push({ type: r2.type, error: "authorization timed out" });
-      } else if (oauthStatus === "FAILED") {
-        failed.push({ type: r2.type, error: "authorization failed" });
-      } else {
-        failed.push({ type: r2.type, error: "needs authorization" });
+    switch (r2.action) {
+      case "provisioned":
+        provisioned.push(r2);
+        break;
+      case "synced":
+        synced.push(r2.type);
+        break;
+      case "removed":
+        removed.push(r2.type);
+        break;
+      case "error":
+        failed.push({ type: r2.type, error: r2.error });
+        break;
+      case "needs_oauth": {
+        const oauthStatus = oauthOutcomes.get(r2.type);
+        if (oauthStatus === "ACTIVE") {
+          added.push(r2.type);
+        } else if (oauthStatus === "SKIPPED") {
+          skipped.push(r2.type);
+        } else if (oauthStatus === "PENDING") {
+          failed.push({ type: r2.type, error: "authorization timed out" });
+        } else if (oauthStatus === "FAILED") {
+          failed.push({ type: r2.type, error: "authorization failed" });
+        } else {
+          failed.push({ type: r2.type, error: "needs authorization" });
+        }
+        break;
       }
     }
   }
   M2.info(theme.styles.bold("Summary:"));
+  for (const i2 of provisioned) {
+    M2.success(`Provisioned: ${i2.type} (${i2.mode})`);
+    if (i2.claimUrl) {
+      M2.info(`  Claim your Stripe account: ${theme.colors.links(i2.claimUrl)}`);
+    }
+    M2.info(`  Connectors dashboard: ${theme.colors.links(getConnectorsUrl())}`);
+  }
   if (synced.length > 0) {
     M2.success(`Synced: ${synced.join(", ")}`);
   }
@@ -194502,7 +194672,7 @@ function printSummary(results, oauthOutcomes) {
     M2.warn(`Skipped: ${skipped.join(", ")}`);
   }
   for (const r2 of failed) {
-    M2.error(`Failed: ${r2.type}${r2.error ? ` - ${r2.error}` : ""}`);
+    M2.error(`Failed: ${r2.type} - ${r2.error}`);
   }
 }
 async function pushConnectorsAction() {
@@ -194536,7 +194706,7 @@ function getConnectorsPushCommand(context) {
 
 // src/cli/commands/connectors/index.ts
 function getConnectorsCommand(context) {
-  return new Command("connectors").description("Manage project connectors (OAuth integrations)").addCommand(getConnectorsPullCommand(context)).addCommand(getConnectorsPushCommand(context));
+  return new Command("connectors").description("Manage project connectors").addCommand(getConnectorsPullCommand(context)).addCommand(getConnectorsPushCommand(context));
 }
 
 // src/cli/commands/dashboard/open.ts
@@ -194852,15 +195022,11 @@ ${summaryLines.join(`
     successMessage: theme.colors.base44Orange("Deployment completed"),
     errorMessage: "Deployment failed"
   });
-  const needsOAuth = filterPendingOAuth(result.connectorResults ?? []);
-  if (needsOAuth.length > 0) {
-    const oauthOutcomes = await promptOAuthFlows(needsOAuth, {
-      skipPrompt: options.yes || !!process.env.CI
-    });
-    const allAuthorized = oauthOutcomes.size > 0 && [...oauthOutcomes.values()].every((s) => s === "ACTIVE");
-    if (!allAuthorized) {
-      M2.info("Some connectors still require authorization. Run 'base44 connectors push' or open the links above in your browser.");
-    }
+  const connectorResults = result.connectorResults ?? [];
+  await handleOAuthConnectors(connectorResults, options);
+  const stripeResult = connectorResults.find((r2) => r2.action === "provisioned");
+  if (stripeResult) {
+    printStripeResult(stripeResult);
   }
   M2.message(`${theme.styles.header("Dashboard")}: ${theme.colors.links(getDashboardUrl())}`);
   if (result.appUrl) {
@@ -194873,6 +195039,25 @@ function getDeployCommand(context) {
     await runCommand(() => deployAction(options), { requireAuth: true }, context);
   });
 }
+async function handleOAuthConnectors(connectorResults, options) {
+  const needsOAuth = filterPendingOAuth(connectorResults);
+  if (needsOAuth.length === 0)
+    return;
+  const oauthOutcomes = await promptOAuthFlows(needsOAuth, {
+    skipPrompt: options.yes || !!process.env.CI
+  });
+  const allAuthorized = oauthOutcomes.size > 0 && [...oauthOutcomes.values()].every((s) => s === "ACTIVE");
+  if (!allAuthorized) {
+    M2.info("Some connectors still require authorization. Run 'base44 connectors push' or open the links above in your browser.");
+  }
+}
+function printStripeResult(r2) {
+  M2.success(`Provisioned: Stripe (${r2.mode})`);
+  if (r2.claimUrl) {
+    M2.info(`  Claim your Stripe account: ${theme.colors.links(r2.claimUrl)}`);
+  }
+  M2.info(`  Connectors dashboard: ${theme.colors.links(getConnectorsUrl())}`);
+}
 
 // src/cli/commands/project/link.ts
 function validateNonInteractiveFlags2(command) {
@@ -195206,62 +195391,9 @@ function getTypesCommand(context) {
   return new Command("types").description("Manage TypeScript type generation").addCommand(getTypesGenerateCommand(context));
 }
 
-// src/cli/dev/createDevLogger.ts
-var dateTimeFormat = new Intl.DateTimeFormat([], {
-  hour: "2-digit",
-  minute: "2-digit",
-  second: "2-digit",
-  hour12: false
-});
-var colorByType = {
-  error: source_default.red,
-  warn: source_default.yellow,
-  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(`${source_default.gray(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/main.ts
 var import_cors = __toESM(require_lib4(), 1);
-var import_express2 = __toESM(require_express(), 1);
-import { dirname as dirname12, join as join16 } from "node:path";
+var import_express = __toESM(require_express(), 1);
 
 // node_modules/get-port/index.js
 import net from "node:net";
@@ -195379,220 +195511,11 @@ async function getPorts(options8) {
 
 // src/cli/dev/dev-server/main.ts
 var import_http_proxy_middleware = __toESM(require_dist2(), 1);
-
-// src/cli/dev/dev-server/function-manager.ts
-import { spawn as spawn2 } 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;
-  logger;
-  constructor(functions, logger) {
-    this.functions = new Map(functions.map((f7) => [f7.name, f7]));
-    this.logger = logger;
-  }
-  getFunction(name2) {
-    return this.functions.get(name2);
-  }
-  async ensureRunning(name2) {
-    const existing = this.running.get(name2);
-    if (existing?.ready) {
-      return existing.port;
-    }
-    const backendFunction = this.functions.get(name2);
-    if (!backendFunction) {
-      throw new Error(`Function "${name2}" not found`);
-    }
-    if (existing && !existing.ready) {
-      return this.waitForReady(name2, existing);
-    }
-    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();
-  }
-  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(() => {
-        reject(new Error(`Function "${name2}" failed to start within timeout`));
-      }, 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 Error(`Function "${name2}" exited with code ${code2}`));
-        }
-      });
-    });
-  }
-}
-
-// 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
-        });
-      }
-      resolve5();
-    });
-    if (req.body && Object.keys(req.body).length > 0) {
-      const bodyString = JSON.stringify(req.body);
-      proxyReq.setHeader("Content-Type", "application/json");
-      proxyReq.setHeader("Content-Length", Buffer.byteLength(bodyString));
-      proxyReq.write(bodyString);
-    }
-    proxyReq.end();
-  });
-}
-
-// src/cli/dev/dev-server/main.ts
 var DEFAULT_PORT = 4400;
 var BASE44_APP_URL = "https://base44.app";
-async function createDevServer(options8) {
-  const { logger, 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();
+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({
     target: BASE44_APP_URL,
     changeOrigin: true
@@ -195609,17 +195532,9 @@ async function createDevServer(options8) {
     }
     next();
   });
-  const [functions] = await Promise.all([
-    functionResource.readAll(join16(configDir, project2.functionsDir))
-  ]);
-  const functionManager = new FunctionManager(functions, logger);
-  logger.log(`Loaded functions: ${functions.map((f7) => f7.name).join(", ") || "(none)"}`);
-  const functionRoutes = createFunctionRoutes(functionManager, logger);
-  app.use("/api/apps/:appId/functions", functionRoutes);
   app.use((req, res, next) => {
     return remoteProxy(req, res, next);
   });
-  app.use(import_express2.default.json());
   return new Promise((resolve5, reject) => {
     const server = app.listen(port, "127.0.0.1", (err) => {
       if (err) {
@@ -195641,10 +195556,7 @@ 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,
-    logger: createDevLogger()
-  });
+  const { port: resolvedPort } = await createDevServer({ port });
   return {
     outroMessage: `Dev server is available at ${theme.colors.links(`http://localhost:${resolvedPort}`)}`
   };
@@ -195806,7 +195718,7 @@ function nanoid3(size = 21) {
 }
 
 // node_modules/posthog-node/dist/extensions/error-tracking/modifiers/module.node.mjs
-import { dirname as dirname13, posix, sep } from "path";
+import { dirname as dirname11, posix, sep } from "path";
 function createModulerModifier() {
   const getModuleFromFileName = createGetModuleFromFilename();
   return async (frames) => {
@@ -195815,7 +195727,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] ? dirname11(process.argv[1]) : process.cwd(), isWindows4 = sep === "\\") {
   const normalizedBase = isWindows4 ? normalizeWindowsPath2(basePath) : basePath;
   return (filename) => {
     if (!filename)
@@ -200034,4 +199946,4 @@ export {
   CLIExitError
 };
 
-//# debugId=8F3746945013573D64756E2164756E21
+//# debugId=52C00CE37DAE994264756E2164756E21