@base44-preview/cli 0.1.7-pr.568.c08ba20 → 0.1.7-pr.580.688e1cd

package/dist/assets/templates/backend-and-client/package.json

@@ -9,7 +9,8 @@
     "preview": "vite preview"
   },
   "dependencies": {
-    "@base44/sdk": "^0.8.3",
+    "@base44/sdk": "^0.8.40",
+    "@base44/vite-plugin": "^1.0.30",
     "lucide-react": "^0.475.0",
     "react": "^18.2.0",
     "react-dom": "^18.2.0"

package/dist/assets/templates/backend-and-client/src/api/base44Client.js

@@ -0,0 +1,13 @@
+import { createClient } from '@base44/sdk';
+import { appParams } from '@/lib/app-params';
+
+const { appId, token, functionsVersion, appBaseUrl } = appParams;
+
+export const base44 = createClient({
+  appId,
+  token,
+  functionsVersion,
+  serverUrl: '',
+  requiresAuth: false,
+  appBaseUrl
+});

package/dist/assets/templates/backend-and-client/src/lib/app-params.js

@@ -0,0 +1,54 @@
+const isNode = typeof window === 'undefined';
+const windowObj = isNode ? { localStorage: new Map() } : window;
+const storage = windowObj.localStorage;
+
+const toSnakeCase = (str) => {
+	return str.replace(/([A-Z])/g, '_$1').toLowerCase();
+}
+
+const getAppParamValue = (paramName, { defaultValue = undefined, removeFromUrl = false } = {}) => {
+	if (isNode) {
+		return defaultValue;
+	}
+	const storageKey = `base44_${toSnakeCase(paramName)}`;
+	const urlParams = new URLSearchParams(window.location.search);
+	const searchParam = urlParams.get(paramName);
+	if (removeFromUrl) {
+		urlParams.delete(paramName);
+		const newUrl = `${window.location.pathname}${urlParams.toString() ? `?${urlParams.toString()}` : ""
+			}${window.location.hash}`;
+		window.history.replaceState({}, document.title, newUrl);
+	}
+	if (searchParam) {
+		storage.setItem(storageKey, searchParam);
+		return searchParam;
+	}
+	if (defaultValue) {
+		storage.setItem(storageKey, defaultValue);
+		return defaultValue;
+	}
+	const storedValue = storage.getItem(storageKey);
+	if (storedValue) {
+		return storedValue;
+	}
+	return null;
+}
+
+const getAppParams = () => {
+	if (getAppParamValue("clear_access_token") === 'true') {
+		storage.removeItem('base44_access_token');
+		storage.removeItem('token');
+	}
+	return {
+		appId: getAppParamValue("app_id", { defaultValue: import.meta.env.VITE_BASE44_APP_ID }),
+		token: getAppParamValue("access_token", { removeFromUrl: true }),
+		fromUrl: getAppParamValue("from_url", { defaultValue: window.location.href }),
+		functionsVersion: getAppParamValue("functions_version", { defaultValue: import.meta.env.VITE_BASE44_FUNCTIONS_VERSION }),
+		appBaseUrl: getAppParamValue("app_base_url", { defaultValue: import.meta.env.VITE_BASE44_APP_BASE_URL }),
+	}
+}
+
+
+export const appParams = {
+	...getAppParams()
+}

package/dist/assets/templates/backend-and-client/vite.config.js

@@ -1,12 +1,7 @@
-import { defineConfig } from 'vite';
+import base44 from '@base44/vite-plugin';
 import react from '@vitejs/plugin-react';
-import path from 'path';
+import { defineConfig } from 'vite';
 
 export default defineConfig({
-  plugins: [react()],
-  resolve: {
-    alias: {
-      '@': path.resolve(__dirname, './src'),
-    },
-  },
+  plugins: [base44(), react()],
 });

package/dist/cli/index.js

@@ -244912,15 +244912,14 @@ async function setAppVisibility(visibility) {
     throw await ApiError.fromHttpError(error48, "updating app visibility");
   }
 }
-async function listProjects(options = {}) {
+async function listProjects() {
   let response;
   try {
     response = await base44Client.get("api/apps", {
       searchParams: {
         sort: "-updated_date",
         fields: "id,name,user_description,is_managed_source_code",
-        limit: 50,
-        ...options.workspaceId ? { workspace_id: options.workspaceId } : {}
+        limit: 50
       }
     });
   } catch (error48) {
@@ -247480,7 +247479,9 @@ async function deploySite(siteOutputDir) {
   if (!await pathExists(siteOutputDir)) {
     throw new InvalidInputError(`Output directory does not exist: ${siteOutputDir}. Make sure to build your project first.`, {
       hints: [
-        { message: "Run your build command (e.g., 'npm run build') first" }
+        {
+          message: "Run 'base44 build' first (it injects your app id; a bare 'npm run build' does not)"
+        }
       ]
     });
   }
@@ -247488,7 +247489,9 @@ async function deploySite(siteOutputDir) {
   if (filePaths.length === 0) {
     throw new ConfigInvalidError(`No files found in output directory: ${siteOutputDir}. Make sure to build your project first.`, siteOutputDir, {
       hints: [
-        { message: "Run your build command (e.g., 'npm run build') first" }
+        {
+          message: "Run 'base44 build' first (it injects your app id; a bare 'npm run build' does not)"
+        }
       ]
     });
   }
@@ -256641,6 +256644,80 @@ function getFunctionsCommand() {
   return new Command("functions").description("Manage backend functions").addCommand(getDeployCommand()).addCommand(getDeleteCommand()).addCommand(getListCommand()).addCommand(getPullCommand());
 }
 
+// src/cli/commands/project/site-build.ts
+async function runSiteBuild({ runTask: runTask2 }, { root, buildCommand, appId }) {
+  if (!buildCommand) {
+    throw new ConfigNotFoundError("No site build command found.", {
+      hints: [
+        {
+          message: `Add 'site.buildCommand' to your config.jsonc (e.g., "site": { "buildCommand": "npm run build" })`
+        }
+      ]
+    });
+  }
+  await runTask2("Building site...", () => execa({
+    cwd: root,
+    shell: true,
+    env: { VITE_BASE44_APP_ID: appId }
+  })`${buildCommand}`, {
+    successMessage: "Site built successfully",
+    errorMessage: "Build failed"
+  });
+}
+async function maybeBuildBeforeDeploy(ctx, project2, build) {
+  if (!ctx.app) {
+    return;
+  }
+  if (build === true) {
+    await runSiteBuild(ctx, {
+      root: project2.root,
+      buildCommand: project2.site?.buildCommand,
+      appId: ctx.app.id
+    });
+    return;
+  }
+  if (build === false || !project2.site?.outputDirectory) {
+    return;
+  }
+  const shouldBuild = await shouldAskToBuild(ctx.isNonInteractive, project2.site.buildCommand);
+  if (shouldBuild) {
+    await runSiteBuild(ctx, {
+      root: project2.root,
+      buildCommand: project2.site.buildCommand,
+      appId: ctx.app.id
+    });
+  }
+}
+async function shouldAskToBuild(isNonInteractive, buildCommand) {
+  if (!buildCommand || isNonInteractive) {
+    return false;
+  }
+  const answer = await Re({
+    message: `Build the site first? (runs '${buildCommand}' with your app id)`
+  });
+  return !Ct(answer) && answer;
+}
+
+// src/cli/commands/project/build.ts
+async function buildAction(ctx) {
+  const { app } = ctx;
+  if (!app?.projectRoot) {
+    throw new ConfigInvalidError("base44 build requires a linked local project. Run it from a project with base44/.app.jsonc.");
+  }
+  const { project: project2 } = await readProjectConfig(app.projectRoot);
+  await runSiteBuild(ctx, {
+    root: project2.root,
+    buildCommand: project2.site?.buildCommand,
+    appId: app.id
+  });
+  return {
+    outroMessage: `Site built with app id ${theme.styles.bold(app.id)}`
+  };
+}
+function getBuildCommand() {
+  return new Base44Command("build").description("Build the site with the Base44 app id injected").action(buildAction);
+}
+
 // src/cli/commands/project/create.ts
 import { basename as basename4, resolve as resolve8 } from "node:path";
 var import_kebabCase = __toESM(require_kebabCase(), 1);
@@ -256703,7 +256780,11 @@ async function completeProjectSetup({
       const { appUrl } = await runTask2("Installing dependencies...", async (updateMessage) => {
         await execa({ cwd: resolvedPath, shell: true })`${installCommand}`;
         updateMessage("Building project...");
-        await execa({ cwd: resolvedPath, shell: true })`${buildCommand}`;
+        await execa({
+          cwd: resolvedPath,
+          shell: true,
+          env: { VITE_BASE44_APP_ID: projectId }
+        })`${buildCommand}`;
         updateMessage("Deploying site...");
         return await deploySite(join23(resolvedPath, outputDirectory));
       }, {
@@ -256751,7 +256832,7 @@ function workspaceLabel(workspace2) {
   const suffix = workspace2.isPersonal ? "personal" : workspace2.userRole ?? "member";
   return `${workspace2.name} (${suffix})`;
 }
-async function resolveWorkspaceId(ctx, flagWorkspaceId, isInteractive, options = {}) {
+async function resolveWorkspaceId(ctx, flagWorkspaceId, isInteractive) {
   if (flagWorkspaceId) {
     return flagWorkspaceId;
   }
@@ -256762,13 +256843,13 @@ async function resolveWorkspaceId(ctx, flagWorkspaceId, isInteractive, options =
   if (workspaces.length <= 1) {
     return;
   }
-  const promptOptions = workspaces.map((w) => ({
+  const options = workspaces.map((w) => ({
     value: w.id,
     label: workspaceLabel(w)
   }));
   const selected = await Je({
-    message: options.promptMessage ?? "Which workspace should this app belong to?",
-    options: promptOptions,
+    message: "Which workspace should this app belong to?",
+    options,
     initialValue: workspaces[0].id
   });
   if (Ct(selected)) {
@@ -256909,7 +256990,8 @@ Examples:
 }
 
 // src/cli/commands/project/deploy.ts
-async function deployAction({ isNonInteractive, log }, options = {}) {
+async function deployAction(ctx, options = {}) {
+  const { isNonInteractive, log } = ctx;
   if (isNonInteractive && !options.yes) {
     throw new InvalidInputError("--yes is required in non-interactive mode");
   }
@@ -256957,6 +257039,7 @@ ${summaryLines.join(`
 ${summaryLines.join(`
 `)}`);
   }
+  await maybeBuildBeforeDeploy(ctx, project2, options.build);
   let functionCompleted = 0;
   const functionTotal = functions.length;
   const result = await deployAll(projectData, {
@@ -256985,7 +257068,7 @@ ${summaryLines.join(`
   return { outroMessage: "App deployed successfully" };
 }
 function getDeployCommand2() {
-  return new Base44Command("deploy").description("Deploy all project resources (entities, functions, agents, connectors, and site)").option("-y, --yes", "Skip confirmation prompt").action(deployAction);
+  return new Base44Command("deploy").description("Deploy all project resources (entities, functions, agents, connectors, and site)").option("-y, --yes", "Skip confirmation prompt").option("--build", "Build the site before deploying (skips the prompt)").option("--no-build", "Deploy without building (skips the prompt)").action(deployAction);
 }
 async function handleOAuthConnectors(connectorResults, isNonInteractive, options, log) {
   const needsOAuth = filterPendingOAuth(connectorResults);
@@ -257101,36 +257184,6 @@ async function promptForExistingProject(projects) {
   }
   return selectedProject;
 }
-async function resolveExplicitAppId(ctx, appId) {
-  await ctx.runTask("Validating app...", () => getApp(appId), {
-    errorMessage: "Could not validate app"
-  }).catch((error48) => {
-    if (error48 instanceof ApiError && (error48.statusCode === 404 || error48.statusCode === 403)) {
-      throw new InvalidInputError(`App "${appId}" not found, or you don't have access to it.`, {
-        hints: [
-          { message: "Check the app ID is correct" },
-          {
-            message: "Run 'base44 link' without --app-id to browse apps by workspace"
-          }
-        ]
-      });
-    }
-    throw error48;
-  });
-  return appId;
-}
-async function chooseProjectInteractively(ctx, options) {
-  const workspaceId = await resolveWorkspaceId(ctx, options.workspace ?? options.org, !ctx.isNonInteractive, { promptMessage: "Which workspace is the app in?" });
-  const projects = await ctx.runTask("Fetching projects...", () => listProjects({ workspaceId }), {
-    successMessage: "Projects fetched",
-    errorMessage: "Failed to fetch projects"
-  });
-  if (!projects.length) {
-    return;
-  }
-  const selectedProject = await promptForExistingProject(projects);
-  return selectedProject.id;
-}
 async function link(ctx, options, command2) {
   const { log, runTask: runTask2, isNonInteractive } = ctx;
   const appId = readExplicitAppId(command2).value;
@@ -257154,10 +257207,31 @@ async function link(ctx, options, command2) {
   let finalAppId;
   const action = appId ? "choose" : options.create ? "create" : await promptForLinkAction();
   if (action === "choose") {
-    const linkedAppId = appId ? await resolveExplicitAppId(ctx, appId) : await chooseProjectInteractively(ctx, options);
-    if (!linkedAppId) {
+    const projects = await runTask2("Fetching projects...", async () => listProjects(), {
+      successMessage: "Projects fetched",
+      errorMessage: "Failed to fetch projects"
+    });
+    if (!projects.length) {
       return { outroMessage: "No projects available for linking" };
     }
+    let linkedAppId;
+    if (appId) {
+      const project2 = projects.find((p) => p.id === appId);
+      if (!project2) {
+        throw new InvalidInputError(`App with ID "${appId}" not found.`, {
+          hints: [
+            { message: "Check the app ID is correct" },
+            {
+              message: "Use 'base44 link' without --app-id to see available projects"
+            }
+          ]
+        });
+      }
+      linkedAppId = appId;
+    } else {
+      const selectedProject = await promptForExistingProject(projects);
+      linkedAppId = selectedProject.id;
+    }
     await runTask2("Linking project...", async () => {
       await writeAppConfig(projectRoot.root, linkedAppId);
       setAppContext({ id: linkedAppId, projectRoot: projectRoot.root });
@@ -257186,7 +257260,7 @@ async function link(ctx, options, command2) {
 function getLinkCommand() {
   return new Base44Command("link", {
     requireAppContext: false
-  }).description("Link a local project to a Base44 project (create new or link existing)").configureHelp({ showGlobalOptions: true }).option("-c, --create", "Create a new project (skip selection prompt)").option("-n, --name <name>", "Project name (required when --create is used)").option("-d, --description <description>", "Project description").option("-w, --workspace <id>", "Workspace (organization) ID to scope the app picker to (or create the app in, with --create). Defaults to your personal workspace").addOption(new Option("--org <id>", "Alias for --workspace").hideHelp()).addOption(new Option("-p, --project-id <id>", "Project ID to link to an existing project").hideHelp()).addOption(new Option("--projectId <id>", "Project ID to link to an existing project").hideHelp()).hook("preAction", validateNonInteractiveFlags).action(link);
+  }).description("Link a local project to a Base44 project (create new or link existing)").configureHelp({ showGlobalOptions: true }).option("-c, --create", "Create a new project (skip selection prompt)").option("-n, --name <name>", "Project name (required when --create is used)").option("-d, --description <description>", "Project description").option("-w, --workspace <id>", "Workspace (organization) ID to create the app in when using --create (defaults to your personal workspace)").addOption(new Option("--org <id>", "Alias for --workspace").hideHelp()).addOption(new Option("-p, --project-id <id>", "Project ID to link to an existing project").hideHelp()).addOption(new Option("--projectId <id>", "Project ID to link to an existing project").hideHelp()).hook("preAction", validateNonInteractiveFlags).action(link);
 }
 
 // src/cli/commands/project/logs.ts
@@ -257860,7 +257934,8 @@ function getSecretsCommand() {
 
 // src/cli/commands/site/deploy.ts
 import { resolve as resolve11 } from "node:path";
-async function deployAction2({ isNonInteractive, runTask: runTask2 }, options) {
+async function deployAction2(ctx, options) {
+  const { isNonInteractive, runTask: runTask2 } = ctx;
   if (isNonInteractive && !options.yes) {
     throw new InvalidInputError("--yes is required in non-interactive mode");
   }
@@ -257883,6 +257958,7 @@ async function deployAction2({ isNonInteractive, runTask: runTask2 }, options) {
       return { outroMessage: "Deployment cancelled" };
     }
   }
+  await maybeBuildBeforeDeploy(ctx, project2, options.build);
   const result = await runTask2("Creating archive and deploying site...", async () => {
     return await deploySite(outputDir);
   }, {
@@ -257892,7 +257968,7 @@ async function deployAction2({ isNonInteractive, runTask: runTask2 }, options) {
   return { outroMessage: `Visit your site at: ${result.appUrl}` };
 }
 function getSiteDeployCommand() {
-  return new Base44Command("deploy").description("Deploy built site files to Base44 hosting").option("-y, --yes", "Skip confirmation prompt").action(deployAction2);
+  return new Base44Command("deploy").description("Deploy built site files to Base44 hosting").option("-y, --yes", "Skip confirmation prompt").option("--build", "Build the site before deploying (skips the prompt)").option("--no-build", "Deploy without building (skips the prompt)").action(deployAction2);
 }
 
 // src/cli/commands/site/open.ts
@@ -262114,6 +262190,10 @@ function validateDevOptions(command2) {
   if (appId !== undefined) {
     command2.error(`base44 dev cannot be used with --app-id or ${BASE44_APP_ID_ENV_VAR}.`);
   }
+  const { port, remote } = command2.opts();
+  if (remote && port !== undefined) {
+    command2.error("--port applies to the local backend, which --remote does not start.");
+  }
 }
 function requireLinkedProject({ app }) {
   if (!app?.projectRoot) {
@@ -262121,31 +262201,44 @@ function requireLinkedProject({ app }) {
   }
   return { id: app.id, projectRoot: app.projectRoot };
 }
-async function createConfiguredServeRunner(app, backendUrl) {
+async function resolveConfiguredSite(app) {
   const { project: project2 } = await readProjectConfig(app.projectRoot);
   const serveCommand = project2.site?.serveCommand;
-  if (!serveCommand) {
-    return;
-  }
-  return createServeCommandRunner({
-    serveCommand,
-    projectRoot: project2.root,
-    appId: app.id,
-    appBaseUrl: backendUrl
-  });
+  return serveCommand ? { serveCommand, projectRoot: project2.root } : undefined;
 }
-function startServeCommand(runner, backend) {
+function stopRunnerOnProcessSignals(runner) {
   const stop2 = () => void runner.stop();
   process.on("SIGINT", stop2);
   process.on("SIGTERM", stop2);
+}
+function startServeCommand(runner, backend) {
+  stopRunnerOnProcessSignals(runner);
   runner.onExit(() => {
     backend.shutdown().finally(() => process.exit(1));
   });
   createDevLogger("backend", theme.styles.info).log(`Backend running on ${backend.url}`);
   runner.start();
 }
-async function devAction(ctx, options8) {
-  const app = requireLinkedProject(ctx);
+async function remoteDevAction(app) {
+  const site2 = await resolveConfiguredSite(app);
+  if (!site2) {
+    throw new ConfigInvalidError("base44 dev --remote serves the frontend against the production backend, but this project has no site.serveCommand in base44/config.jsonc.");
+  }
+  const appBaseUrl = await getSiteUrl();
+  const runner = createServeCommandRunner({
+    ...site2,
+    appId: app.id,
+    appBaseUrl
+  });
+  stopRunnerOnProcessSignals(runner);
+  runner.onExit((code2) => process.exit(code2 ?? 1));
+  runner.start();
+  return {
+    outroMessage: `Frontend dev server targets ${theme.styles.bold(appBaseUrl)} — every write hits your live app`
+  };
+}
+async function localDevAction(ctx, app, options8) {
+  const site2 = await resolveConfiguredSite(app);
   const siteUrlPromise = getSiteUrl().catch(() => {
     return;
   });
@@ -262160,15 +262253,23 @@ async function devAction(ctx, options8) {
     }
   });
   const backendUrl = localServerUrl(backend.port);
-  const runner = await createConfiguredServeRunner(app, backendUrl);
-  if (runner) {
+  if (site2) {
+    const runner = createServeCommandRunner({
+      ...site2,
+      appId: app.id,
+      appBaseUrl: backendUrl
+    });
     startServeCommand(runner, { url: backendUrl, shutdown: backend.shutdown });
   }
-  const outroMessage = runner ? "Open your app using the frontend dev server URL" : `Dev server is available at ${theme.colors.links(backendUrl)}`;
+  const outroMessage = site2 ? "Open your app using the frontend dev server URL" : `Dev server is available at ${theme.colors.links(backendUrl)}`;
   return { outroMessage };
 }
+async function devAction(ctx, options8) {
+  const app = requireLinkedProject(ctx);
+  return options8.remote ? remoteDevAction(app) : localDevAction(ctx, app, options8);
+}
 function getDevCommand() {
-  return new Base44Command("dev").description("Start the development server").option("-p, --port <number>", "Port for the development server").hook("preAction", validateDevOptions).action(devAction);
+  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);
 }
 
 // src/core/exec/run-script.ts
@@ -262387,7 +262488,11 @@ async function eject(ctx, options8, command2) {
         successMessage: theme.colors.base44Orange("Project built successfully"),
         errorMessage: "Failed to build project"
       });
-      await deployAction(ctx, { yes: true, projectRoot: resolvedPath });
+      await deployAction(ctx, {
+        yes: true,
+        build: false,
+        projectRoot: resolvedPath
+      });
     }
   }
   return { outroMessage: "Your new project is set and ready to use" };
@@ -262416,6 +262521,7 @@ function createProgram(context) {
   program2.addCommand(getCreateCommand());
   program2.addCommand(getScaffoldCommand());
   program2.addCommand(getDashboardCommand());
+  program2.addCommand(getBuildCommand());
   program2.addCommand(getDeployCommand2());
   program2.addCommand(getVisibilityCommand());
   program2.addCommand(getLinkCommand());
@@ -266681,4 +266787,4 @@ export {
   CLIExitError
 };
 
-//# debugId=14B1FDDCC926290964756E2164756E21
+//# debugId=8E70D966010C6D0264756E2164756E21