@base44-preview/cli 0.2.3-pr.659.75c0aac → 0.2.3-pr.659.96b3a00

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/cli/index.js CHANGED
@@ -233661,6 +233661,9 @@ var AppDetailSchema = looseObject({
233661
233661
  name: data.name,
233662
233662
  organizationId: data.organization_id ?? undefined
233663
233663
  }));
233664
+ var AppPublicSettingsSchema = looseObject({
233665
+ public_settings: string2().nullish()
233666
+ });
233664
233667
  var ProjectSchema = object({
233665
233668
  id: string2(),
233666
233669
  name: string2(),
@@ -239542,6 +239545,22 @@ async function listProjects() {
239542
239545
  }
239543
239546
  return result.data;
239544
239547
  }
239548
+ async function getAppVisibility(appId) {
239549
+ let response;
239550
+ try {
239551
+ response = await base44Client.get(`api/apps/${appId}`, {
239552
+ searchParams: { fields: "id,public_settings" }
239553
+ });
239554
+ } catch (error) {
239555
+ throw await ApiError.fromHttpError(error, "fetching app visibility");
239556
+ }
239557
+ const result = AppPublicSettingsSchema.safeParse(await response.json());
239558
+ if (!result.success) {
239559
+ throw new SchemaValidationError("Invalid response from server", result.error);
239560
+ }
239561
+ const settings = result.data.public_settings;
239562
+ return Object.keys(PUBLIC_SETTINGS).find((visibility) => PUBLIC_SETTINGS[visibility] === settings) ?? "public";
239563
+ }
239545
239564
  async function getApp(appId) {
239546
239565
  let response;
239547
239566
  try {
@@ -268580,9 +268599,22 @@ function getWorkspaceCommand() {
268580
268599
  return new Command2("workspace").description("List workspaces, inspect one, and move apps between them").addCommand(getWorkspaceListCommand()).addCommand(getWorkspaceGetCommand()).addCommand(getWorkspaceMoveCommand());
268581
268600
  }
268582
268601
 
268602
+ // src/cli/dev/dev-server/auth/tokens.ts
268603
+ var import_jsonwebtoken2 = __toESM(require_jsonwebtoken(), 1);
268604
+ var LOCAL_DEV_SECRET = "LOCAL_DEV_SECRET";
268605
+ var SERVICE_ROLE_EMAIL = "server@server.com";
268606
+ var createJwtToken = (email) => {
268607
+ return import_jsonwebtoken2.default.sign({ sub: email }, LOCAL_DEV_SECRET, {
268608
+ expiresIn: "360d"
268609
+ });
268610
+ };
268611
+ var createServiceToken = () => createJwtToken(SERVICE_ROLE_EMAIL);
268612
+ var createServiceAuthorizationHeader = () => `Bearer ${createServiceToken()}`;
268613
+ var isServiceSubject = (subject) => subject === SERVICE_ROLE_EMAIL;
268614
+
268583
268615
  // src/cli/dev/dev-server/main.ts
268584
268616
  var import_cors = __toESM(require_lib4(), 1);
268585
- var import_express6 = __toESM(require_express(), 1);
268617
+ var import_express7 = __toESM(require_express(), 1);
268586
268618
  import { dirname as dirname28, join as join39 } from "node:path";
268587
268619
 
268588
268620
  // ../../node_modules/get-port/index.js
@@ -269279,19 +269311,6 @@ var import_subprotocol = __toESM(require_subprotocol(), 1);
269279
269311
  var import_websocket = __toESM(require_websocket(), 1);
269280
269312
  var import_websocket_server = __toESM(require_websocket_server(), 1);
269281
269313
 
269282
- // src/cli/dev/dev-server/auth/tokens.ts
269283
- var import_jsonwebtoken2 = __toESM(require_jsonwebtoken(), 1);
269284
- var LOCAL_DEV_SECRET = "LOCAL_DEV_SECRET";
269285
- var SERVICE_ROLE_EMAIL = "server@server.com";
269286
- var createJwtToken = (email) => {
269287
- return import_jsonwebtoken2.default.sign({ sub: email }, LOCAL_DEV_SECRET, {
269288
- expiresIn: "360d"
269289
- });
269290
- };
269291
- var createServiceToken = () => createJwtToken(SERVICE_ROLE_EMAIL);
269292
- var createServiceAuthorizationHeader = () => `Bearer ${createServiceToken()}`;
269293
- var isServiceSubject = (subject) => subject === SERVICE_ROLE_EMAIL;
269294
-
269295
269314
  // src/cli/dev/dev-server/routes/app-server.ts
269296
269315
  var PLATFORM_OWNED_SDK_HEADERS = [
269297
269316
  "base44-app-id",
@@ -269308,11 +269327,11 @@ var PROXY_LOOP_MESSAGE = [
269308
269327
  "Its Vite proxy is forwarding all of /api; only /api/apps and /api/app-logs belong to the backend.",
269309
269328
  "Update @base44/vite-plugin, or narrow the proxy in vite.config.js to those paths."
269310
269329
  ].join(" ");
269311
- function sdkHeaders(appId, host) {
269330
+ function sdkHeaders(target, host) {
269312
269331
  return {
269313
- "Base44-App-Id": appId,
269332
+ "Base44-App-Id": target.appId,
269314
269333
  "Base44-Api-Url": `http://${host}`,
269315
- "Base44-Service-Authorization": createServiceAuthorizationHeader(),
269334
+ ...target.serviceRole === false ? {} : { "Base44-Service-Authorization": createServiceAuthorizationHeader() },
269316
269335
  [FORWARDED_HEADER]: "1"
269317
269336
  };
269318
269337
  }
@@ -269326,7 +269345,7 @@ function createAppServerProxy(target, logger) {
269326
269345
  for (const header of PLATFORM_OWNED_SDK_HEADERS) {
269327
269346
  proxyReq.removeHeader(header);
269328
269347
  }
269329
- for (const [name, value] of Object.entries(sdkHeaders(target.appId, req.headers.host))) {
269348
+ for (const [name, value] of Object.entries(sdkHeaders(target, req.headers.host))) {
269330
269349
  proxyReq.setHeader(name, value);
269331
269350
  }
269332
269351
  },
@@ -269383,7 +269402,7 @@ function createAppServerProxy(target, logger) {
269383
269402
  const upstream = new import_websocket.default(`${origin.replace(/^http/, "ws")}${req.url}`, client.protocol || undefined, {
269384
269403
  headers: {
269385
269404
  ...forwarded,
269386
- ...sdkHeaders(target.appId, req.headers.host)
269405
+ ...sdkHeaders(target, req.headers.host)
269387
269406
  }
269388
269407
  });
269389
269408
  const pending = [];
@@ -269456,6 +269475,113 @@ function createFunctionRouter(manager, logger) {
269456
269475
  return router;
269457
269476
  }
269458
269477
 
269478
+ // src/cli/dev/dev-server/routes/login-gate.ts
269479
+ var import_express2 = __toESM(require_express(), 1);
269480
+ var SESSION_COOKIE = "base44_dev_session";
269481
+ var LOGIN_PATH = "/login";
269482
+ var LOGOUT_PATH = "/api/apps/auth/logout";
269483
+ function createLoginGate({ email, dataSource, mintToken }, logger) {
269484
+ const router = import_express2.Router();
269485
+ router.get(LOGIN_PATH, (req, res) => {
269486
+ const fromUrl = sameOriginTarget(req, req.query.from_url).toString();
269487
+ res.type("html").send(loginPage(email, dataSource, fromUrl));
269488
+ });
269489
+ router.post(LOGIN_PATH, import_express2.urlencoded({ extended: false }), async (req, res) => {
269490
+ let token;
269491
+ try {
269492
+ token = await mintToken();
269493
+ } catch (error) {
269494
+ const message = error instanceof Error ? error.message : String(error);
269495
+ logger.error(`Sign-in failed: ${message}`);
269496
+ res.status(502).type("text").send(`Sign-in failed: ${message}`);
269497
+ return;
269498
+ }
269499
+ const target = sameOriginTarget(req, req.body?.from_url);
269500
+ target.searchParams.set("access_token", token);
269501
+ res.setHeader("Set-Cookie", `${SESSION_COOKIE}=${encodeURIComponent(token)}; Path=/; HttpOnly; SameSite=Lax`);
269502
+ res.redirect(303, target.toString());
269503
+ });
269504
+ router.get(LOGOUT_PATH, (req, res) => {
269505
+ res.setHeader("Set-Cookie", `${SESSION_COOKIE}=; Path=/; HttpOnly; SameSite=Lax; Max-Age=0`);
269506
+ res.redirect(sameOriginTarget(req, req.query.from_url).toString());
269507
+ });
269508
+ router.use((req, res, next) => {
269509
+ const token = sessionToken(req);
269510
+ if (!token) {
269511
+ if (isPageLoad(req)) {
269512
+ redirectToLogin(req, res);
269513
+ return;
269514
+ }
269515
+ } else if (!req.headers.authorization) {
269516
+ req.headers.authorization = `Bearer ${token}`;
269517
+ }
269518
+ next();
269519
+ });
269520
+ return router;
269521
+ }
269522
+ var UNGATED_PATH_PATTERN = /^\/(api|media)\//;
269523
+ function isPageLoad(req) {
269524
+ return req.method === "GET" && !UNGATED_PATH_PATTERN.test(req.path) && (req.headers.accept ?? "").includes("text/html");
269525
+ }
269526
+ function sessionToken(req) {
269527
+ for (const cookie of (req.headers.cookie ?? "").split(";")) {
269528
+ const [name, ...value] = cookie.trim().split("=");
269529
+ if (name === SESSION_COOKIE && value.length > 0) {
269530
+ return decodeURIComponent(value.join("=")) || undefined;
269531
+ }
269532
+ }
269533
+ return;
269534
+ }
269535
+ function redirectToLogin(req, res) {
269536
+ const login = new URL(LOGIN_PATH, origin(req));
269537
+ login.searchParams.set("from_url", new URL(req.originalUrl, origin(req)).href);
269538
+ res.redirect(login.toString());
269539
+ }
269540
+ function origin(req) {
269541
+ return `http://${req.headers.host}`;
269542
+ }
269543
+ function sameOriginTarget(req, fromUrl) {
269544
+ const base = origin(req);
269545
+ if (typeof fromUrl === "string") {
269546
+ try {
269547
+ const target = new URL(fromUrl, base);
269548
+ if (target.origin === base && target.pathname !== LOGIN_PATH) {
269549
+ return target;
269550
+ }
269551
+ } catch {}
269552
+ }
269553
+ return new URL("/", base);
269554
+ }
269555
+ var escapeHtml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
269556
+ function loginPage(email, dataSource, fromUrl) {
269557
+ return `<!doctype html>
269558
+ <html lang="en">
269559
+ <head>
269560
+ <meta charset="utf-8">
269561
+ <meta name="viewport" content="width=device-width, initial-scale=1">
269562
+ <title>Sign in</title>
269563
+ <style>
269564
+ :root { color-scheme: light dark; font-family: system-ui, sans-serif; }
269565
+ body { margin: 0; min-height: 100vh; display: grid; place-items: center; background: Canvas; color: CanvasText; }
269566
+ main { max-width: 22rem; padding: 2rem; border: 1px solid color-mix(in srgb, CanvasText 15%, transparent); border-radius: 0.75rem; }
269567
+ h1 { margin: 0 0 0.5rem; font-size: 1.25rem; }
269568
+ p { margin: 0 0 1.25rem; line-height: 1.5; opacity: 0.8; }
269569
+ button { width: 100%; padding: 0.6rem 1rem; font: inherit; border: 0; border-radius: 0.5rem; background: CanvasText; color: Canvas; cursor: pointer; }
269570
+ </style>
269571
+ </head>
269572
+ <body>
269573
+ <main>
269574
+ <h1>Sign in to this private app</h1>
269575
+ <p>In local development you sign in as the Base44 account the CLI is signed in with. The app uses ${escapeHtml(dataSource)}.</p>
269576
+ <form method="post" action="${LOGIN_PATH}">
269577
+ <input type="hidden" name="from_url" value="${escapeHtml(fromUrl)}">
269578
+ <button type="submit" data-testid="dev-login-continue">Continue as ${escapeHtml(email)}</button>
269579
+ </form>
269580
+ </main>
269581
+ </body>
269582
+ </html>`;
269583
+ }
269584
+
269459
269585
  // src/cli/dev/dev-server/db/database.ts
269460
269586
  var import_nedb = __toESM(require_nedb(), 1);
269461
269587
 
@@ -269772,6 +269898,9 @@ class Database {
269772
269898
  }
269773
269899
  }
269774
269900
 
269901
+ // src/cli/dev/dev-server/platform-paths.ts
269902
+ var PLATFORM_PATH_PATTERN = /^\/api\/(apps|app-logs)(\/|$)/;
269903
+
269775
269904
  // ../../node_modules/socket.io/wrapper.mjs
269776
269905
  var import_dist = __toESM(require_dist4(), 1);
269777
269906
  var { Server, Namespace, Socket } = import_dist.default;
@@ -269806,7 +269935,7 @@ function broadcastEntityEvent(io, appId, entityName, event) {
269806
269935
  }
269807
269936
 
269808
269937
  // src/cli/dev/dev-server/routes/auth-router.ts
269809
- var import_express2 = __toESM(require_express(), 1);
269938
+ var import_express3 = __toESM(require_express(), 1);
269810
269939
  import { randomInt } from "node:crypto";
269811
269940
  var TEN_MINUTES = 10 * 60 * 1000;
269812
269941
  var generateCode = () => {
@@ -269815,8 +269944,8 @@ var generateCode = () => {
269815
269944
  var LoginBody = object({ email: email2(), password: string2() });
269816
269945
  var VerifyOtpBody = object({ email: email2(), otp_code: string2() });
269817
269946
  function createAuthRouter(db, logger) {
269818
- const router = import_express2.Router({ mergeParams: true });
269819
- const parseBody = import_express2.json();
269947
+ const router = import_express3.Router({ mergeParams: true });
269948
+ const parseBody = import_express3.json();
269820
269949
  router.post("/login", parseBody, async (req, res) => {
269821
269950
  const { email, password } = LoginBody.parse(req.body);
269822
269951
  const result = await db.getCollection(USER_COLLECTION)?.findOneAsync({ email });
@@ -269956,7 +270085,7 @@ In order to complete registration use this verification code: ${otpCode}
269956
270085
  }
269957
270086
 
269958
270087
  // src/cli/dev/dev-server/routes/entities/entities-router.ts
269959
- var import_express4 = __toESM(require_express(), 1);
270088
+ var import_express5 = __toESM(require_express(), 1);
269960
270089
 
269961
270090
  // src/cli/dev/dev-server/db/rls.ts
269962
270091
  import { isDeepStrictEqual as isDeepStrictEqual5 } from "node:util";
@@ -270216,10 +270345,10 @@ async function resolveCurrentUser(db, req) {
270216
270345
  }
270217
270346
 
270218
270347
  // src/cli/dev/dev-server/routes/entities/entities-user-router.ts
270219
- var import_express3 = __toESM(require_express(), 1);
270348
+ var import_express4 = __toESM(require_express(), 1);
270220
270349
  function createUserRouter(db, logger) {
270221
- const router = import_express3.Router({ mergeParams: true });
270222
- const parseBody = import_express3.json();
270350
+ const router = import_express4.Router({ mergeParams: true });
270351
+ const parseBody = import_express4.json();
270223
270352
  function withAuth(handler) {
270224
270353
  return async (req, res) => {
270225
270354
  const currentUserResult = await resolveCurrentUser(db, req);
@@ -270336,8 +270465,8 @@ function createUserRouter(db, logger) {
270336
270465
 
270337
270466
  // src/cli/dev/dev-server/routes/entities/entities-router.ts
270338
270467
  async function createEntityRoutes(db, logger, broadcast) {
270339
- const router = import_express4.Router({ mergeParams: true });
270340
- const parseBody = import_express4.json();
270468
+ const router = import_express5.Router({ mergeParams: true });
270469
+ const parseBody = import_express5.json();
270341
270470
  function withCollection(handler) {
270342
270471
  return async (req, res) => {
270343
270472
  const { entityName } = req.params;
@@ -270587,7 +270716,7 @@ async function createEntityRoutes(db, logger, broadcast) {
270587
270716
  }
270588
270717
 
270589
270718
  // src/cli/dev/dev-server/routes/integrations.ts
270590
- var import_express5 = __toESM(require_express(), 1);
270719
+ var import_express6 = __toESM(require_express(), 1);
270591
270720
  var import_multer = __toESM(require_multer(), 1);
270592
270721
  import { createHash as createHash4, randomUUID as randomUUID6 } from "node:crypto";
270593
270722
  import fs28 from "node:fs";
@@ -270596,8 +270725,8 @@ function createFileToken(fileUri) {
270596
270725
  return createHash4("sha256").update(fileUri).digest("hex");
270597
270726
  }
270598
270727
  function createIntegrationRoutes(mediaFilesDir, baseUrl, remoteProxy, logger) {
270599
- const router = import_express5.Router({ mergeParams: true });
270600
- const parseBody = import_express5.json();
270728
+ const router = import_express6.Router({ mergeParams: true });
270729
+ const parseBody = import_express6.json();
270601
270730
  const privateFilesDir = path24.join(mediaFilesDir, "private");
270602
270731
  fs28.mkdirSync(mediaFilesDir, { recursive: true });
270603
270732
  fs28.mkdirSync(privateFilesDir, { recursive: true });
@@ -270667,7 +270796,7 @@ function createIntegrationRoutes(mediaFilesDir, baseUrl, remoteProxy, logger) {
270667
270796
  return router;
270668
270797
  }
270669
270798
  function createCustomIntegrationRoutes(remoteProxy, logger) {
270670
- const router = import_express5.Router({ mergeParams: true });
270799
+ const router = import_express6.Router({ mergeParams: true });
270671
270800
  router.post("/:slug/:operationId", (req, res, next) => {
270672
270801
  logger.warn(`"${req.originalUrl}" is not supported in local development, passing call to production`);
270673
270802
  req.url = req.originalUrl;
@@ -272375,7 +272504,6 @@ class WatchBase44 extends EventEmitter4 {
272375
272504
  // src/cli/dev/dev-server/main.ts
272376
272505
  var DEFAULT_PORT = 4400;
272377
272506
  var BASE44_APP_URL = "https://base44.app";
272378
- var PLATFORM_PATH_PATTERN = /^\/api\/(apps|app-logs)(\/|$)/;
272379
272507
  async function createDevServer(options) {
272380
272508
  const { port: userPort } = options;
272381
272509
  const port = userPort ?? await getPorts({
@@ -272383,7 +272511,7 @@ async function createDevServer(options) {
272383
272511
  });
272384
272512
  const baseUrl = `http://localhost:${port}`;
272385
272513
  const { functions, entities, project, siteUrl } = await options.loadResources();
272386
- const app = import_express6.default();
272514
+ const app = import_express7.default();
272387
272515
  const remoteProxy = import_http_proxy_middleware3.createProxyMiddleware({
272388
272516
  target: BASE44_APP_URL,
272389
272517
  changeOrigin: true
@@ -272392,6 +272520,10 @@ async function createDevServer(options) {
272392
272520
  origin: /^http:\/\/localhost(:\d+)?$/,
272393
272521
  credentials: true
272394
272522
  }));
272523
+ const devLogger = createDevLogger("backend", theme.styles.info);
272524
+ if (options.loginGate) {
272525
+ app.use(createLoginGate(options.loginGate, devLogger));
272526
+ }
272395
272527
  const AUTH_ROUTE_PATTERN = /^\/api\/apps\/auth(\/|$)/;
272396
272528
  app.use((req, res, next) => {
272397
272529
  if (AUTH_ROUTE_PATTERN.test(req.path)) {
@@ -272400,7 +272532,6 @@ async function createDevServer(options) {
272400
272532
  }
272401
272533
  next();
272402
272534
  });
272403
- const devLogger = createDevLogger("backend", theme.styles.info);
272404
272535
  app.use("/api/apps/:appId/actors", (_req, res) => {
272405
272536
  const message = "Actors are not available in local development";
272406
272537
  devLogger.error(message);
@@ -272441,7 +272572,7 @@ async function createDevServer(options) {
272441
272572
  }
272442
272573
  next();
272443
272574
  });
272444
- app.use("/media", import_express6.default.static(mediaFilesDir));
272575
+ app.use("/media", import_express7.default.static(mediaFilesDir));
272445
272576
  const integrationRoutes = createIntegrationRoutes(mediaFilesDir, baseUrl, remoteProxy, devLogger);
272446
272577
  app.use("/api/apps/:appId/integration-endpoints", integrationRoutes);
272447
272578
  const customIntegrationRoutes = createCustomIntegrationRoutes(remoteProxy, devLogger);
@@ -272554,6 +272685,40 @@ async function createDevServer(options) {
272554
272685
  return { port, server, shutdown };
272555
272686
  }
272556
272687
 
272688
+ // src/cli/dev/dev-server/remote-front-door.ts
272689
+ var import_cors2 = __toESM(require_lib4(), 1);
272690
+ var import_express8 = __toESM(require_express(), 1);
272691
+ var import_http_proxy_middleware4 = __toESM(require_dist2(), 1);
272692
+ var DEFAULT_PORT2 = 4400;
272693
+ async function createRemoteFrontDoor(options) {
272694
+ const port = options.port ?? await getPorts({
272695
+ port: process.env.IS_TEST === "true" ? undefined : DEFAULT_PORT2
272696
+ });
272697
+ const logger = createDevLogger("front door", theme.styles.info);
272698
+ const app = import_express8.default();
272699
+ app.use(import_cors2.default({ origin: /^http:\/\/localhost(:\d+)?$/, credentials: true }));
272700
+ if (options.loginGate) {
272701
+ app.use(createLoginGate(options.loginGate, logger));
272702
+ }
272703
+ const liveApp = import_http_proxy_middleware4.createProxyMiddleware({
272704
+ target: options.siteUrl,
272705
+ changeOrigin: true
272706
+ });
272707
+ const appServerProxy = createAppServerProxy({ ...options.appServer, serviceRole: false }, logger);
272708
+ app.use((req, res, next) => PLATFORM_PATH_PATTERN.test(req.path) ? liveApp(req, res, next) : appServerProxy.middleware(req, res, next));
272709
+ const server = await new Promise((resolve, reject) => {
272710
+ const s = app.listen(port, "127.0.0.1", (err) => err ? reject(err) : resolve(s));
272711
+ });
272712
+ server.on("upgrade", (req, socket, head) => {
272713
+ if (req.url?.startsWith(REALTIME_PATH)) {
272714
+ liveApp.upgrade(req, socket, head);
272715
+ } else {
272716
+ appServerProxy.upgrade(req, socket, head);
272717
+ }
272718
+ });
272719
+ return { port };
272720
+ }
272721
+
272557
272722
  // src/cli/commands/dev.ts
272558
272723
  var APP_SERVER_START_TIMEOUT_MS = 120000;
272559
272724
  function localServerUrl(port) {
@@ -272578,10 +272743,6 @@ function validateDevOptions(command) {
272578
272743
  if (appId !== undefined) {
272579
272744
  command.error(`base44 dev cannot be used with --app-id or ${BASE44_APP_ID_ENV_VAR}.`);
272580
272745
  }
272581
- const { port, remote } = command.opts();
272582
- if (remote && port !== undefined) {
272583
- command.error("--port applies to the local backend, which --remote does not start.");
272584
- }
272585
272746
  }
272586
272747
  function requireLinkedProject({ app }) {
272587
272748
  if (!app?.projectRoot) {
@@ -272592,7 +272753,22 @@ function requireLinkedProject({ app }) {
272592
272753
  async function resolveConfiguredSite(app) {
272593
272754
  const { project } = await readProjectConfig(app.projectRoot);
272594
272755
  const serveCommand = project.site?.serveCommand;
272595
- return serveCommand ? { serveCommand, projectRoot: project.root } : undefined;
272756
+ return {
272757
+ site: serveCommand ? { serveCommand, projectRoot: project.root } : undefined,
272758
+ visibility: project.visibility
272759
+ };
272760
+ }
272761
+ async function resolveLoginGate(app, visibility, gate) {
272762
+ const resolved = visibility ?? await getAppVisibility(app.id).catch(() => "public");
272763
+ if (resolved === "public") {
272764
+ return;
272765
+ }
272766
+ const { email } = await readAuth();
272767
+ return {
272768
+ email,
272769
+ dataSource: gate.dataSource,
272770
+ mintToken: () => gate.mintToken(email)
272771
+ };
272596
272772
  }
272597
272773
  function startServeCommand(runner, backend) {
272598
272774
  stopRunnerOnProcessSignals(runner);
@@ -272602,35 +272778,56 @@ function startServeCommand(runner, backend) {
272602
272778
  createDevLogger("backend", theme.styles.info).log(`Backend running on ${backend.url}`);
272603
272779
  runner.start();
272604
272780
  }
272605
- async function remoteDevAction(app) {
272606
- const site = await resolveConfiguredSite(app);
272781
+ async function remoteDevAction(app, options) {
272782
+ const { site, visibility } = await resolveConfiguredSite(app);
272607
272783
  if (!site) {
272608
272784
  throw new ConfigInvalidError("base44 dev --remote serves the frontend against the production backend, but this project has no site.serveCommand in base44/config.jsonc.");
272609
272785
  }
272610
- const appBaseUrl = await getSiteUrl();
272786
+ const siteUrl = await getSiteUrl();
272787
+ const loginGate = await resolveLoginGate(app, visibility, {
272788
+ dataSource: `your live app's data (${siteUrl})`,
272789
+ mintToken: () => getAppUserToken()
272790
+ });
272791
+ const appServerOrigin = createAppServerOrigin();
272792
+ const frontDoor = await createRemoteFrontDoor({
272793
+ port: options.port ? Number(options.port) : undefined,
272794
+ siteUrl,
272795
+ appServer: { appId: app.id, waitForOrigin: appServerOrigin.waitForOrigin },
272796
+ loginGate
272797
+ });
272798
+ const frontDoorUrl = localServerUrl(frontDoor.port);
272611
272799
  const runner = createServeCommandRunner({
272612
272800
  ...site,
272613
272801
  appId: app.id,
272614
- appBaseUrl
272802
+ appBaseUrl: frontDoorUrl,
272803
+ onOrigin: appServerOrigin.report,
272804
+ ignorePort: frontDoor.port
272615
272805
  });
272616
- stopRunnerOnProcessSignals(runner);
272806
+ const stopAndExit = () => void runner.stop().finally(() => process.exit(0));
272807
+ process.on("SIGINT", stopAndExit);
272808
+ process.on("SIGTERM", stopAndExit);
272617
272809
  runner.onExit((code) => process.exit(code ?? 1));
272618
272810
  runner.start();
272619
272811
  return {
272620
- outroMessage: `Frontend dev server targets ${theme.styles.bold(appBaseUrl)} — every write hits your live app`
272812
+ outroMessage: `Your app is available at ${theme.colors.links(frontDoorUrl)} — it runs on the data of ${theme.styles.bold(siteUrl)}, so every write hits your live app`
272621
272813
  };
272622
272814
  }
272623
272815
  async function localDevAction(ctx, app, options) {
272624
- const site = await resolveConfiguredSite(app);
272816
+ const { site, visibility } = await resolveConfiguredSite(app);
272625
272817
  const siteUrlPromise = getSiteUrl().catch(() => {
272626
272818
  return;
272627
272819
  });
272820
+ const loginGate = site ? await resolveLoginGate(app, visibility, {
272821
+ dataSource: "a local database where your account is an admin",
272822
+ mintToken: async (email) => createJwtToken(email)
272823
+ }) : undefined;
272628
272824
  const appServerOrigin = createAppServerOrigin();
272629
272825
  const backend = await createDevServer({
272630
272826
  log: ctx.log,
272631
272827
  port: options.port ? Number(options.port) : undefined,
272632
272828
  denoWrapperPath: getDenoWrapperPath(),
272633
272829
  appServer: site ? { appId: app.id, waitForOrigin: appServerOrigin.waitForOrigin } : undefined,
272830
+ loginGate,
272634
272831
  loadResources: async () => {
272635
272832
  const { functions, entities, project } = await readProjectConfig();
272636
272833
  const siteUrl = await siteUrlPromise;
@@ -272653,10 +272850,10 @@ async function localDevAction(ctx, app, options) {
272653
272850
  }
272654
272851
  async function devAction(ctx, options) {
272655
272852
  const app = requireLinkedProject(ctx);
272656
- return options.remote ? remoteDevAction(app) : localDevAction(ctx, app, options);
272853
+ return options.remote ? remoteDevAction(app, options) : localDevAction(ctx, app, options);
272657
272854
  }
272658
272855
  function getDevCommand() {
272659
- return new Base44Command("dev").description("Start the development server").option("-p, --port <number>", "Port for the development server").option("--remote", "Serve the frontend against the production backend instead of a local one").hook("preAction", validateDevOptions).action(devAction);
272856
+ return new Base44Command("dev").description("Start the development server").option("-p, --port <number>", "Port for the development server").option("--remote", "Serve the app against your live app's data instead of a local backend").hook("preAction", validateDevOptions).action(devAction);
272660
272857
  }
272661
272858
 
272662
272859
  // src/core/exec/env-target.ts
@@ -277076,4 +277273,4 @@ export {
277076
277273
  runCLI
277077
277274
  };
277078
277275
 
277079
- //# debugId=319D69906789140664756E2164756E21
277276
+ //# debugId=E94308DBFBDA3B0664756E2164756E21