@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 +248 -51
- package/dist/cli/index.js.map +12 -9
- package/package.json +1 -1
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
|
|
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(
|
|
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
|
|
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
|
|
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("&", "&").replaceAll("<", "<").replaceAll(">", ">").replaceAll('"', """);
|
|
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
|
|
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 =
|
|
269819
|
-
const parseBody =
|
|
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
|
|
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
|
|
270348
|
+
var import_express4 = __toESM(require_express(), 1);
|
|
270220
270349
|
function createUserRouter(db, logger) {
|
|
270221
|
-
const router =
|
|
270222
|
-
const parseBody =
|
|
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 =
|
|
270340
|
-
const parseBody =
|
|
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
|
|
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 =
|
|
270600
|
-
const parseBody =
|
|
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 =
|
|
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 =
|
|
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",
|
|
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
|
|
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
|
|
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
|
-
|
|
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: `
|
|
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
|
|
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=
|
|
277276
|
+
//# debugId=E94308DBFBDA3B0664756E2164756E21
|