@base44-preview/cli 0.0.55-pr.545.e6bf97b → 0.0.55-pr.545.ea3e030

package/dist/cli/index.js

@@ -218285,6 +218285,7 @@ var PROJECT_CONFIG_PATTERNS = [
   `${PROJECT_SUBDIR}/config.${CONFIG_FILE_EXTENSION_GLOB}`,
   `config.${CONFIG_FILE_EXTENSION_GLOB}`
 ];
+var BASE44_APP_ID_ENV_VAR = "BASE44_APP_ID";
 var TYPES_OUTPUT_SUBDIR = ".types";
 var TYPES_FILENAME = "types.d.ts";
 var AUTH_CLIENT_ID = "base44_cli";
@@ -233980,7 +233981,7 @@ async function parseEnvFile(filePath) {
 }
 var STRIPE_ENV_PREFIX = "BASE44_PROJECTS_";
 var BASE44_ENV_KEYS = [
-  "BASE44_APP_ID",
+  BASE44_APP_ID_ENV_VAR,
   "BASE44_ACCESS_TOKEN",
   "BASE44_REFRESH_TOKEN",
   "BASE44_API_URL"
@@ -234017,7 +234018,7 @@ function normalizeBase44Env() {
 loadProjectEnvFiles();
 
 // src/cli/index.ts
-import { dirname as dirname23, join as join29 } from "node:path";
+import { dirname as dirname23, join as join28 } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 
 // ../../node_modules/@clack/core/dist/index.mjs
@@ -241694,18 +241695,35 @@ function loadFromTestOverrides() {
   }
   return null;
 }
-async function initAppContext() {
+async function initAppContext(options = {}) {
   const testConfig = loadFromTestOverrides();
   if (testConfig) {
     cache2 = testConfig;
     return cache2;
   }
+  const projectRoot = findProjectRoot();
+  if (options.appId !== undefined) {
+    const id = options.appId.trim();
+    if (!id) {
+      throw new InvalidInputError("App id cannot be empty.");
+    }
+    cache2 = { id };
+    return cache2;
+  }
   if (cache2) {
     return cache2;
   }
-  const projectRoot = findProjectRoot();
   if (!projectRoot) {
-    throw new ConfigNotFoundError("No Base44 project found. Run this command from a project directory with a config.jsonc file.");
+    throw new ConfigNotFoundError(`No Base44 app ID found. Pass --app-id, set ${BASE44_APP_ID_ENV_VAR}, or run this command from a linked project with base44/.app.jsonc.`, {
+      hints: [
+        { message: "Pass an app ID explicitly with --app-id <id>" },
+        { message: `Set ${BASE44_APP_ID_ENV_VAR} in your environment` },
+        {
+          message: "Run from a linked Base44 project with base44/.app.jsonc, or run 'base44 link'",
+          command: "base44 link"
+        }
+      ]
+    });
   }
   const config3 = await readAppConfig(projectRoot.root);
   const appConfigPath = await findAppConfigPath(projectRoot.root);
@@ -244433,8 +244451,8 @@ async function ensureAuth(ctx) {
     });
   } catch {}
 }
-async function ensureAppContext(ctx) {
-  const appContext = await initAppContext();
+async function ensureAppContext(ctx, options = {}) {
+  const appContext = await initAppContext(options);
   ctx.app = appContext;
   ctx.errorReporter.setContext({ appId: appContext.id });
 }
@@ -251100,7 +251118,8 @@ class Base44Command extends Command {
           await ensureAuth(this.context);
         }
         if (this._commandOptions.requireAppContext) {
-          await ensureAppContext(this.context);
+          const { appId } = this.optsWithGlobals();
+          await ensureAppContext(this.context, { appId });
         }
         const result = await fn(this.context, ...args) ?? {};
         if (!quiet) {
@@ -253069,7 +253088,11 @@ function printProjectSummary({ name: name2, dashboardUrl, appUrl }, log) {
 }
 
 // src/cli/commands/project/create.ts
-function validateNonInteractiveFlags(command2) {
+function validateCreateOptions(command2) {
+  const { appId } = command2.optsWithGlobals();
+  if (appId !== undefined) {
+    command2.error(`base44 create cannot be used with --app-id or ${BASE44_APP_ID_ENV_VAR}.`);
+  }
   const { path: path17 } = command2.opts();
   if (path17 && !command2.args.length) {
     command2.error("--path requires a project name argument. Usage: base44 create <name> --path <path>");
@@ -253186,7 +253209,7 @@ function getCreateCommand() {
 Examples:
   $ base44 create my-app                                         Creates a base44 project at ./my-app
   $ base44 create my-todo-app --template backend-and-client      Creates a base44 backend-and-client project at ./my-todo-app
-  $ base44 create my-app --path ./projects/my-app --deploy       Creates a base44 project at ./project/my-app and deploys it`).hook("preAction", validateNonInteractiveFlags).action(createAction);
+  $ base44 create my-app --path ./projects/my-app --deploy       Creates a base44 project at ./project/my-app and deploys it`).hook("preAction", validateCreateOptions).action(createAction);
 }
 
 // src/cli/commands/project/deploy.ts
@@ -253282,11 +253305,32 @@ function printStripeResult(r, log) {
   log.info(`  Connectors dashboard: ${theme.colors.links(getConnectorsUrl())}`);
 }
 
+// src/cli/commands/project/app-id-options.ts
+function readExplicitAppId(command2) {
+  const { appId } = command2.optsWithGlobals();
+  const { projectId } = command2.opts();
+  const explicitAppId = command2.getOptionValueSourceWithGlobals("appId") === "cli" ? appId : undefined;
+  const legacyProjectId = command2.getOptionValueSource("projectId") === "cli" ? projectId : undefined;
+  return {
+    appId: explicitAppId,
+    legacyProjectId,
+    value: explicitAppId ?? legacyProjectId
+  };
+}
+
 // src/cli/commands/project/link.ts
-function validateNonInteractiveFlags2(command2) {
-  const { create: create4, name: name2, projectId } = command2.opts();
-  if (create4 && projectId) {
-    command2.error("--create and --projectId cannot be used together");
+function validateNonInteractiveFlags(command2) {
+  const { create: create4, name: name2 } = command2.opts();
+  const {
+    appId,
+    legacyProjectId,
+    value: selectedAppId
+  } = readExplicitAppId(command2);
+  if (appId && legacyProjectId) {
+    command2.error("--app-id and --project-id cannot be used together");
+  }
+  if (create4 && selectedAppId) {
+    command2.error("--create and --app-id cannot be used together");
   }
   if (create4 && !name2) {
     command2.error("--name is required when using --create");
@@ -253355,11 +253399,12 @@ async function promptForExistingProject(linkableProjects) {
   }
   return selectedProject;
 }
-async function link(ctx, options) {
+async function link(ctx, options, command2) {
   const { log, runTask: runTask2, isNonInteractive } = ctx;
-  const skipPrompts = !!options.create || !!options.projectId;
+  const appId = readExplicitAppId(command2).value;
+  const skipPrompts = !!options.create || !!appId;
   if (!skipPrompts && isNonInteractive) {
-    throw new InvalidInputError("--create with --name, or --projectId, is required in non-interactive mode");
+    throw new InvalidInputError("--create with --name, or --app-id, is required in non-interactive mode");
   }
   const projectRoot = findProjectRoot();
   if (!projectRoot) {
@@ -253374,8 +253419,8 @@ async function link(ctx, options) {
       ]
     });
   }
-  let finalProjectId;
-  const action = options.projectId ? "choose" : options.create ? "create" : await promptForLinkAction();
+  let finalAppId;
+  const action = appId ? "choose" : options.create ? "create" : await promptForLinkAction();
   if (action === "choose") {
     const projects = await runTask2("Fetching projects...", async () => listProjects(), {
       successMessage: "Projects fetched",
@@ -253385,32 +253430,32 @@ async function link(ctx, options) {
     if (!linkableProjects.length) {
       return { outroMessage: "No projects available for linking" };
     }
-    let projectId;
-    if (options.projectId) {
-      const project2 = linkableProjects.find((p) => p.id === options.projectId);
+    let linkedAppId;
+    if (appId) {
+      const project2 = linkableProjects.find((p) => p.id === appId);
       if (!project2) {
-        throw new InvalidInputError(`Project with ID "${options.projectId}" not found or not available for linking.`, {
+        throw new InvalidInputError(`App with ID "${appId}" not found or not available for linking.`, {
           hints: [
-            { message: "Check the project ID is correct" },
+            { message: "Check the app ID is correct" },
             {
-              message: "Use 'base44 link' without --projectId to see available projects"
+              message: "Use 'base44 link' without --app-id to see available projects"
             }
           ]
         });
       }
-      projectId = options.projectId;
+      linkedAppId = appId;
     } else {
       const selectedProject = await promptForExistingProject(linkableProjects);
-      projectId = selectedProject.id;
+      linkedAppId = selectedProject.id;
     }
     await runTask2("Linking project...", async () => {
-      await writeAppConfig(projectRoot.root, projectId);
-      setAppContext({ id: projectId, projectRoot: projectRoot.root });
+      await writeAppConfig(projectRoot.root, linkedAppId);
+      setAppContext({ id: linkedAppId, projectRoot: projectRoot.root });
     }, {
       successMessage: "Project linked successfully",
       errorMessage: "Failed to link project"
     });
-    finalProjectId = projectId;
+    finalAppId = linkedAppId;
   }
   if (action === "create") {
     const { name: name2, description } = options.create ? { name: options.name.trim(), description: options.description?.trim() } : await promptForNewProjectDetails();
@@ -253422,13 +253467,15 @@ async function link(ctx, options) {
     });
     await writeAppConfig(projectRoot.root, projectId);
     setAppContext({ id: projectId, projectRoot: projectRoot.root });
-    finalProjectId = projectId;
+    finalAppId = projectId;
   }
-  log.message(`${theme.styles.header("Dashboard")}: ${theme.colors.links(getDashboardUrl(finalProjectId))}`);
+  log.message(`${theme.styles.header("Dashboard")}: ${theme.colors.links(getDashboardUrl(finalAppId))}`);
   return { outroMessage: "Project linked" };
 }
 function getLinkCommand() {
-  return new Base44Command("link", { requireAppContext: false }).description("Link a local project to a Base44 project (create new or link existing)").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("-p, --projectId <id>", "Project ID to link to an existing project (skips selection prompt)").hook("preAction", validateNonInteractiveFlags2).action(link);
+  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").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
@@ -253518,8 +253565,12 @@ async function fetchLogsForFunctions(functionNames, options, availableFunctionNa
   }
   return allEntries;
 }
-async function getAllFunctionNames() {
-  const { functions } = await readProjectConfig();
+async function getProjectFunctionNames(projectRoot) {
+  const { functions } = await readProjectConfig(projectRoot);
+  return functions.map((fn) => fn.name);
+}
+async function getRemoteFunctionNames() {
+  const { functions } = await listDeployedFunctions();
   return functions.map((fn) => fn.name);
 }
 function validateLimit(limit) {
@@ -253530,15 +253581,18 @@ function validateLimit(limit) {
     throw new InvalidInputError(`Invalid limit: "${limit}". Must be a number between 1 and 1000.`);
   }
 }
-async function logsAction(_ctx, options) {
+async function logsAction(ctx, options) {
   validateLimit(options.limit);
   const specifiedFunctions = parseFunctionNames(options.function);
-  const allProjectFunctions = await getAllFunctionNames();
-  const functionNames = specifiedFunctions.length > 0 ? specifiedFunctions : allProjectFunctions;
+  const localProjectRoot = ctx.app?.projectRoot;
+  const availableFunctionNames = localProjectRoot ? await getProjectFunctionNames(localProjectRoot) : await getRemoteFunctionNames();
+  const functionNames = specifiedFunctions.length > 0 ? specifiedFunctions : availableFunctionNames;
   if (functionNames.length === 0) {
-    return { outroMessage: "No functions found in this project." };
+    return {
+      outroMessage: localProjectRoot ? "No functions found in this project." : "No functions found in this app."
+    };
   }
-  let entries = await fetchLogsForFunctions(functionNames, options, allProjectFunctions);
+  let entries = await fetchLogsForFunctions(functionNames, options, availableFunctionNames);
   const limit = options.limit ? Number.parseInt(options.limit, 10) : undefined;
   if (limit !== undefined && entries.length > limit) {
     entries = entries.slice(0, limit);
@@ -253554,17 +253608,20 @@ function getLogsCommand() {
 // src/cli/commands/project/scaffold.ts
 import { basename as basename5, resolve as resolve6 } from "node:path";
 function resolveAppId(options) {
-  const appId = options.appId ?? process.env.BASE44_APP_ID;
+  const appId = options.appId;
   if (!appId) {
     throw new InvalidInputError("No app ID found. `base44 scaffold` sets up a local project for an existing Base44 app.", {
-      hints: [{ message: "Pass it explicitly with --app-id <id>" }]
+      hints: [
+        { message: "Pass it explicitly with --app-id <id>" },
+        { message: `Set ${BASE44_APP_ID_ENV_VAR} in your environment` }
+      ]
     });
   }
   return appId;
 }
-async function scaffoldAction(ctx, name2, options) {
+async function scaffoldAction(ctx, name2, options, command2) {
   const { log, runTask: runTask2 } = ctx;
-  const appId = resolveAppId(options);
+  const appId = resolveAppId(command2.optsWithGlobals());
   const resolvedPath = resolve6("./");
   const projectName = (name2 ?? basename5(resolvedPath)).trim();
   const template2 = await getTemplateById("backend-only");
@@ -253596,7 +253653,7 @@ function getScaffoldCommand() {
   return new Base44Command("scaffold", {
     requireAppContext: false,
     fullBanner: true
-  }).description("Scaffold a local project for an existing Base44 app").addArgument(new Argument("name", "Project name").argOptional()).option("--app-id <id>", "Existing Base44 app ID").option("--no-skills", "Skip AI agent skills installation").addHelpText("after", `
+  }).description("Scaffold a local project for an existing Base44 app").addArgument(new Argument("name", "Project name").argOptional()).option("--no-skills", "Skip AI agent skills installation").addHelpText("after", `
 Examples:
   $ base44 scaffold --app-id app_123         Scaffolds the current dir for the given app
   $ base44 scaffold my-app --app-id app_123  Scaffolds the current dir, named "my-app"`).action(scaffoldAction);
@@ -253896,9 +253953,6 @@ function getTypesCommand() {
   return new Command("types").description("Manage TypeScript type generation").addCommand(getTypesGenerateCommand());
 }
 
-// src/cli/commands/dev.ts
-import { join as join28 } from "node:path";
-
 // src/cli/dev/dev-server/main.ts
 var import_cors = __toESM(require_lib4(), 1);
 var import_express6 = __toESM(require_express(), 1);
@@ -255447,12 +255501,13 @@ class ServeRunner {
     if (this.child) {
       return;
     }
+    const stdin2 = process21.platform === "win32" ? "ignore" : "inherit";
     const child = spawn3(this.command, {
       cwd: this.cwd,
       shell: true,
       detached: process21.platform !== "win32",
       env: { ...process21.env, ...this.env },
-      stdio: ["inherit", "pipe", "pipe"]
+      stdio: [stdin2, "pipe", "pipe"]
     });
     this.child = child;
     this.setupHandlers(child);
@@ -257239,12 +257294,12 @@ async function createDevServer(options8) {
   const functionRoutes = createFunctionRouter(functionManager, devLogger);
   app.use("/api/apps/:appId/functions", functionRoutes);
   if (functionManager.getFunctionNames().length > 0) {
-    options8.log.info(`Loaded functions: ${functionManager.getFunctionNames().join(", ")}`);
+    devLogger.log(`Loaded functions: ${functionManager.getFunctionNames().join(", ")}`);
   }
   const db2 = new Database;
   await db2.load(entities);
   if (db2.getCollectionNames().length > 0) {
-    options8.log.info(`Loaded entities: ${db2.getCollectionNames().join(", ")}`);
+    devLogger.log(`Loaded entities: ${db2.getCollectionNames().join(", ")}`);
   }
   let emitEntityEvent = () => {};
   const entityRoutes = await createEntityRoutes(db2, devLogger, (...args) => emitEntityEvent(...args));
@@ -257332,13 +257387,14 @@ async function createDevServer(options8) {
     }
   });
   await base44ConfigWatcher.start();
+  const serveCommand = project2.site?.serveCommand;
   let serveRunner;
-  if (options8.serve && project2.site?.serveCommand) {
+  if (options8.appId && serveCommand) {
     serveRunner = new ServeRunner({
-      command: project2.site.serveCommand,
+      command: serveCommand,
       cwd: project2.root,
       env: {
-        VITE_BASE44_APP_ID: options8.serve.appId,
+        VITE_BASE44_APP_ID: options8.appId,
         VITE_BASE44_APP_BASE_URL: baseUrl
       },
       logger: createDevLogger("frontend", theme.colors.base44Orange)
@@ -257356,46 +257412,45 @@ async function createDevServer(options8) {
   serveRunner?.onExit(() => {
     shutdown().finally(() => process.exit(1));
   });
-  serveRunner?.start();
-  return { port, server };
+  if (serveRunner) {
+    devLogger.log(`Backend running on ${baseUrl}`);
+    serveRunner.start();
+  }
+  return { port, server, isServingFrontend: serveRunner !== undefined };
 }
 
 // src/cli/commands/dev.ts
 function localServerUrl(port) {
   return `http://localhost:${port}`;
 }
-async function writeEnvLocal(projectRoot, port, appId, log) {
-  const envLocalPath = join28(projectRoot, ".env.local");
-  await writeFile(envLocalPath, `VITE_BASE44_APP_ID=${appId}
-VITE_BASE44_APP_BASE_URL=${localServerUrl(port)}
-`);
-  log.info("Wrote .env.local with app ID and dev server URL");
+function validateDevOptions(command2) {
+  const { appId } = command2.optsWithGlobals();
+  if (appId !== undefined) {
+    command2.error(`base44 dev cannot be used with --app-id or ${BASE44_APP_ID_ENV_VAR}.`);
+  }
 }
-async function devAction({ log }, options8) {
+async function devAction(ctx, options8) {
+  const { log, app } = ctx;
+  if (!app?.projectRoot) {
+    throw new ConfigInvalidError("base44 dev requires a linked local project. Run it from a project with base44/.app.jsonc.");
+  }
   const port = options8.port ? Number(options8.port) : undefined;
-  const serveEnabled = options8.serve !== false;
-  let projectRoot;
-  const appId = serveEnabled || options8.writeEnv ? (await initAppContext()).id : undefined;
-  const { port: resolvedPort } = await createDevServer({
+  const appId = app.id;
+  const { port: resolvedPort, isServingFrontend } = await createDevServer({
     log,
     port,
+    appId,
     denoWrapperPath: getDenoWrapperPath(),
-    serve: serveEnabled && appId ? { appId } : undefined,
     loadResources: async () => {
       const { functions, entities, project: project2 } = await readProjectConfig();
-      projectRoot = project2.root;
       return { functions, entities, project: project2 };
     }
   });
-  if (options8.writeEnv && projectRoot && appId) {
-    await writeEnvLocal(projectRoot, resolvedPort, appId, log);
-  }
-  return {
-    outroMessage: `Dev server is available at ${theme.colors.links(localServerUrl(resolvedPort))}`
-  };
+  const outroMessage = isServingFrontend ? "Open your app using the frontend dev server URL" : `Dev server is available at ${theme.colors.links(localServerUrl(resolvedPort))}`;
+  return { outroMessage };
 }
 function getDevCommand() {
-  return new Base44Command("dev").description("Start the development server").option("-p, --port <number>", "Port for the development server").option("--no-serve", "Do not start the frontend dev server (serveCommand)").option("--write-env", "Write the app ID and dev server URL to .env.local").action(devAction);
+  return new Base44Command("dev").description("Start the development server").option("-p, --port <number>", "Port for the development server").hook("preAction", validateDevOptions).action(devAction);
 }
 
 // src/core/exec/run-script.ts
@@ -257451,7 +257506,10 @@ function readStdin2() {
     process.stdin.on("error", reject);
   });
 }
-async function execAction(isNonInteractive) {
+async function execAction({
+  app,
+  isNonInteractive
+}) {
   const noInputError = new InvalidInputError("No input provided. Pipe a script to stdin.", {
     hints: [
       { message: "File:  cat ./script.ts | base44 exec" },
@@ -257467,7 +257525,7 @@ async function execAction(isNonInteractive) {
   if (!code2.trim()) {
     throw noInputError;
   }
-  const { exitCode } = await runScript({ appId: getAppContext().id, code: code2 });
+  const { exitCode } = await runScript({ appId: app.id, code: code2 });
   if (exitCode !== 0) {
     process.exitCode = exitCode;
   }
@@ -257480,18 +257538,26 @@ Examples:
     $ cat ./script.ts | base44 exec
 
   Inline script:
-    $ echo "const users = await base44.entities.User.list()" | base44 exec`).action(async ({ isNonInteractive }) => {
-    return await execAction(isNonInteractive);
+    $ echo "const users = await base44.entities.User.list()" | base44 exec`).action(async (ctx) => {
+    return await execAction(ctx);
   });
 }
 
 // src/cli/commands/project/eject.ts
 import { resolve as resolve12 } from "node:path";
 var import_kebabCase2 = __toESM(require_kebabCase(), 1);
-async function eject(ctx, options8) {
+async function eject(ctx, options8, command2) {
   const { log, runTask: runTask2, isNonInteractive } = ctx;
-  if (isNonInteractive && !options8.projectId) {
-    throw new InvalidInputError("--project-id is required in non-interactive mode");
+  const {
+    appId,
+    legacyProjectId,
+    value: selectedAppId
+  } = readExplicitAppId(command2);
+  if (appId && legacyProjectId) {
+    throw new InvalidInputError("--app-id and --project-id cannot be used together");
+  }
+  if (isNonInteractive && !selectedAppId) {
+    throw new InvalidInputError("--app-id is required in non-interactive mode");
   }
   if (isNonInteractive && !options8.path) {
     throw new InvalidInputError("--path is required in non-interactive mode");
@@ -257499,13 +257565,13 @@ async function eject(ctx, options8) {
   const projects = await listProjects();
   const ejectableProjects = projects.filter((p4) => p4.isManagedSourceCode !== false);
   let selectedProject;
-  if (options8.projectId) {
-    const foundProject = ejectableProjects.find((p4) => p4.id === options8.projectId);
+  if (selectedAppId) {
+    const foundProject = ejectableProjects.find((p4) => p4.id === selectedAppId);
     if (!foundProject) {
-      throw new InvalidInputError(`Project with ID "${options8.projectId}" not found or not ejectable`, {
+      throw new InvalidInputError(`App with ID "${selectedAppId}" not found or not ejectable`, {
         hints: [
           {
-            message: "Run 'base44 eject' without --project-id to see available projects"
+            message: "Run 'base44 eject' without --app-id to see available projects"
           }
         ]
       });
@@ -257581,13 +257647,15 @@ async function eject(ctx, options8) {
   return { outroMessage: "Your new project is set and ready to use" };
 }
 function getEjectCommand() {
-  return new Base44Command("eject", { requireAppContext: false }).description("Download the code for an existing Base44 project").option("-p, --path <path>", "Path where to write the project").option("--project-id <id>", "Project ID to eject (skips interactive selection)").option("-y, --yes", "Skip confirmation prompts").action(eject);
+  return new Base44Command("eject", {
+    requireAppContext: false
+  }).description("Download the code for an existing Base44 project").configureHelp({ showGlobalOptions: true }).option("-p, --path <path>", "Path where to write the project").option("-y, --yes", "Skip confirmation prompts").addOption(new Option("--project-id <id>", "Project ID to eject (skips interactive selection)").hideHelp()).action(eject);
 }
 
 // src/cli/program.ts
 function createProgram(context) {
   const program2 = new Command;
-  program2.name("base44").description("Base44 CLI - Unified interface for managing Base44 applications").version(package_default.version);
+  program2.name("base44").description("Base44 CLI - Unified interface for managing Base44 applications").version(package_default.version).addOption(new Option("--app-id <id>", "Base44 app ID to use").env(BASE44_APP_ID_ENV_VAR));
   program2.configureHelp({
     sortSubcommands: true
   });
@@ -257614,7 +257682,7 @@ function createProgram(context) {
   program2.addCommand(getSiteCommand());
   program2.addCommand(getTypesCommand());
   program2.addCommand(getExecCommand());
-  program2.addCommand(getDevCommand(), { hidden: true });
+  program2.addCommand(getDevCommand());
   program2.addCommand(getLogsCommand());
   return program2;
 }
@@ -261824,7 +261892,7 @@ function addCommandInfoToErrorReporter(program2, errorReporter) {
 // src/cli/index.ts
 var __dirname4 = dirname23(fileURLToPath6(import.meta.url));
 async function runCLI(options8) {
-  ensureNpmAssets(join29(__dirname4, "../assets"));
+  ensureNpmAssets(join28(__dirname4, "../assets"));
   const errorReporter = new ErrorReporter;
   errorReporter.registerProcessErrorHandlers();
   const isNonInteractive = !process.stdin.isTTY || !process.stdout.isTTY;
@@ -261861,4 +261929,4 @@ export {
   CLIExitError
 };
 
-//# debugId=A582415BD965E2EA64756E2164756E21
+//# debugId=FB17A69F9601DE6464756E2164756E21