@base44-preview/cli 0.0.45-pr.425.a892fc8 → 0.0.45-pr.425.c43f1ad

package/dist/cli/index.js

@@ -238804,14 +238804,14 @@ async function getUserInfo(accessToken) {
   return result.data;
 }
 // src/cli/commands/auth/login-flow.ts
-async function generateAndDisplayDeviceCode(logger) {
+async function generateAndDisplayDeviceCode(log) {
   const deviceCodeResponse = await runTask("Generating device code...", async () => {
     return await generateDeviceCode();
   }, {
     successMessage: "Device code generated",
     errorMessage: "Failed to generate device code"
   });
-  logger.info(`Verification code: ${theme.styles.bold(deviceCodeResponse.userCode)}` + `
+  log.info(`Verification code: ${theme.styles.bold(deviceCodeResponse.userCode)}` + `
 Please confirm this code at: ${deviceCodeResponse.verificationUri}`);
   return deviceCodeResponse;
 }
@@ -238855,8 +238855,8 @@ async function saveAuthData(response, userInfo) {
     name: userInfo.name
   });
 }
-async function login(logger) {
-  const deviceCodeResponse = await generateAndDisplayDeviceCode(logger);
+async function login({ log }) {
+  const deviceCodeResponse = await generateAndDisplayDeviceCode(log);
   const token = await waitForAuthentication(deviceCodeResponse.deviceCode, deviceCodeResponse.expiresIn, deviceCodeResponse.interval);
   const userInfo = await getUserInfo(token.accessToken);
   await saveAuthData(token, userInfo);
@@ -238866,22 +238866,22 @@ async function login(logger) {
 }
 
 // src/cli/utils/command/middleware.ts
-async function ensureAuth(errorReporter, logger) {
+async function ensureAuth(ctx) {
   const loggedIn = await isLoggedIn();
   if (!loggedIn) {
-    logger.info("You need to login first to continue.");
-    await login(logger);
+    ctx.log.info("You need to login first to continue.");
+    await login(ctx);
   }
   try {
     const userInfo = await readAuth();
-    errorReporter.setContext({
+    ctx.errorReporter.setContext({
       user: { email: userInfo.email, name: userInfo.name }
     });
   } catch {}
 }
-async function ensureAppConfig(errorReporter) {
+async function ensureAppConfig(ctx) {
   const appConfig = await initAppConfig();
-  errorReporter.setContext({ appId: appConfig.id });
+  ctx.errorReporter.setContext({ appId: appConfig.id });
 }
 
 // ../../node_modules/@clack/core/dist/index.mjs
@@ -246611,12 +246611,6 @@ class Base44Command extends Command {
   setContext(context) {
     this._context = context;
   }
-  get isNonInteractive() {
-    return this._context?.isNonInteractive ?? false;
-  }
-  get logger() {
-    return this.context.logger;
-  }
   get context() {
     if (!this._context) {
       throw new Error("Base44Command context not set. Ensure the command is registered via createProgram().");
@@ -246632,12 +246626,12 @@ class Base44Command extends Command {
       const upgradeCheckPromise = startUpgradeCheck();
       try {
         if (this._commandOptions.requireAuth) {
-          await ensureAuth(this.context.errorReporter, this.context.logger);
+          await ensureAuth(this.context);
         }
         if (this._commandOptions.requireAppConfig) {
-          await ensureAppConfig(this.context.errorReporter);
+          await ensureAppConfig(this.context);
         }
-        const result = await fn(...args) ?? {};
+        const result = await fn(this.context, ...args) ?? {};
         if (!quiet) {
           await showCommandEnd(result, upgradeCheckPromise, this.context.distribution);
         } else {
@@ -246879,7 +246873,9 @@ async function parseEnvFile(filePath) {
   return import_dotenv.parse(content);
 }
 // src/cli/commands/agents/pull.ts
-async function pullAgentsAction(logger2) {
+async function pullAgentsAction({
+  log
+}) {
   const { project: project2 } = await readProjectConfig();
   const configDir = dirname7(project2.configPath);
   const agentsDir = join11(configDir, project2.agentsDir);
@@ -246896,26 +246892,28 @@ async function pullAgentsAction(logger2) {
     errorMessage: "Failed to sync agent files"
   });
   if (written.length > 0) {
-    logger2.success(`Written: ${written.join(", ")}`);
+    log.success(`Written: ${written.join(", ")}`);
   }
   if (deleted.length > 0) {
-    logger2.warn(`Deleted: ${deleted.join(", ")}`);
+    log.warn(`Deleted: ${deleted.join(", ")}`);
   }
   if (written.length === 0 && deleted.length === 0) {
-    logger2.info("All agents are already up to date");
+    log.info("All agents are already up to date");
   }
   return {
     outroMessage: `Pulled ${remoteAgents.total} agents to ${agentsDir}`
   };
 }
 function getAgentsPullCommand() {
-  return new Base44Command("pull").description("Pull agents from Base44 to local files (replaces all local agent configs)").action((_options, command2) => pullAgentsAction(command2.logger));
+  return new Base44Command("pull").description("Pull agents from Base44 to local files (replaces all local agent configs)").action(pullAgentsAction);
 }
 
 // src/cli/commands/agents/push.ts
-async function pushAgentsAction(logger2) {
+async function pushAgentsAction({
+  log
+}) {
   const { agents } = await readProjectConfig();
-  logger2.info(agents.length === 0 ? "No local agents found - this will delete all remote agents" : `Found ${agents.length} agents to push`);
+  log.info(agents.length === 0 ? "No local agents found - this will delete all remote agents" : `Found ${agents.length} agents to push`);
   const result = await runTask("Pushing agents to Base44", async () => {
     return await pushAgents(agents);
   }, {
@@ -246923,18 +246921,18 @@ async function pushAgentsAction(logger2) {
     errorMessage: "Failed to push agents"
   });
   if (result.created.length > 0) {
-    logger2.success(`Created: ${result.created.join(", ")}`);
+    log.success(`Created: ${result.created.join(", ")}`);
   }
   if (result.updated.length > 0) {
-    logger2.success(`Updated: ${result.updated.join(", ")}`);
+    log.success(`Updated: ${result.updated.join(", ")}`);
   }
   if (result.deleted.length > 0) {
-    logger2.warn(`Deleted: ${result.deleted.join(", ")}`);
+    log.warn(`Deleted: ${result.deleted.join(", ")}`);
   }
   return { outroMessage: "Agents pushed to Base44" };
 }
 function getAgentsPushCommand() {
-  return new Base44Command("push").description("Push local agents to Base44 (replaces all remote agent configs)").action((_options, command2) => pushAgentsAction(command2.logger));
+  return new Base44Command("push").description("Push local agents to Base44 (replaces all remote agent configs)").action(pushAgentsAction);
 }
 
 // src/cli/commands/agents/index.ts
@@ -246947,11 +246945,11 @@ function getLoginCommand() {
   return new Base44Command("login", {
     requireAuth: false,
     requireAppConfig: false
-  }).description("Authenticate with Base44").action((_options, command2) => login(command2.logger));
+  }).description("Authenticate with Base44").action(login);
 }
 
 // src/cli/commands/auth/logout.ts
-async function logout() {
+async function logout(_ctx) {
   await deleteAuth();
   return { outroMessage: "Logged out successfully" };
 }
@@ -246963,7 +246961,7 @@ function getLogoutCommand() {
 }
 
 // src/cli/commands/auth/whoami.ts
-async function whoami() {
+async function whoami(_ctx) {
   const auth2 = await readAuth();
   return { outroMessage: `Logged in as: ${theme.styles.bold(auth2.email)}` };
 }
@@ -246972,7 +246970,9 @@ function getWhoamiCommand() {
 }
 
 // src/cli/commands/connectors/list-available.ts
-async function listAvailableAction(logger2) {
+async function listAvailableAction({
+  log
+}) {
   const { integrations } = await runTask("Fetching available integrations from Base44", async () => {
     return await listAvailableIntegrations();
   }, {
@@ -246985,7 +246985,7 @@ async function listAvailableAction(logger2) {
   for (const { displayName, ...rest } of integrations) {
     const yaml2 = formatYaml(rest);
     const pad = " ".repeat(YAML_INDENT);
-    logger2.info(`${displayName}
+    log.info(`${displayName}
 ${pad}${yaml2.replace(/\n/g, `
 ${pad}`)}`);
   }
@@ -246994,12 +246994,14 @@ ${pad}`)}`);
   };
 }
 function getConnectorsListAvailableCommand() {
-  return new Base44Command("list-available").description("List all available integration types").action((_options, command2) => listAvailableAction(command2.logger));
+  return new Base44Command("list-available").description("List all available integration types").action(listAvailableAction);
 }
 
 // src/cli/commands/connectors/pull.ts
 import { dirname as dirname8, join as join12 } from "node:path";
-async function pullConnectorsAction(logger2) {
+async function pullConnectorsAction({
+  log
+}) {
   const { project: project2 } = await readProjectConfig();
   const configDir = dirname8(project2.configPath);
   const connectorsDir = join12(configDir, project2.connectorsDir);
@@ -247016,20 +247018,20 @@ async function pullConnectorsAction(logger2) {
     errorMessage: "Failed to sync connector files"
   });
   if (written.length > 0) {
-    logger2.success(`Written: ${written.join(", ")}`);
+    log.success(`Written: ${written.join(", ")}`);
   }
   if (deleted.length > 0) {
-    logger2.warn(`Deleted: ${deleted.join(", ")}`);
+    log.warn(`Deleted: ${deleted.join(", ")}`);
   }
   if (written.length === 0 && deleted.length === 0) {
-    logger2.info("All connectors are already up to date");
+    log.info("All connectors are already up to date");
   }
   return {
     outroMessage: `Pulled ${remoteConnectors.length} connectors to ${connectorsDir}`
   };
 }
 function getConnectorsPullCommand() {
-  return new Base44Command("pull").description("Pull connectors from Base44 to local files (replaces all local connector configs)").action((_options, command2) => pullConnectorsAction(command2.logger));
+  return new Base44Command("pull").description("Pull connectors from Base44 to local files (replaces all local connector configs)").action(pullConnectorsAction);
 }
 
 // ../../node_modules/open/index.js
@@ -247691,14 +247693,14 @@ async function runOAuthFlowWithSkip(connector2) {
   }
   return finalStatus;
 }
-async function promptOAuthFlows(pending, logger2, options) {
+async function promptOAuthFlows(pending, log, options) {
   const outcomes = new Map;
   if (pending.length === 0) {
     return outcomes;
   }
-  logger2.warn(`${pending.length} connector(s) require authorization in your browser:`);
+  log.warn(`${pending.length} connector(s) require authorization in your browser:`);
   for (const connector2 of pending) {
-    logger2.info(`  ${connector2.type}: ${theme.styles.dim(connector2.redirectUrl)}`);
+    log.info(`  ${connector2.type}: ${theme.styles.dim(connector2.redirectUrl)}`);
   }
   if (options?.skipPrompt) {
     return outcomes;
@@ -247711,11 +247713,11 @@ async function promptOAuthFlows(pending, logger2, options) {
   }
   for (const connector2 of pending) {
     try {
-      logger2.info(`Opening browser for ${connector2.type}...`);
+      log.info(`Opening browser for ${connector2.type}...`);
       const status = await runOAuthFlowWithSkip(connector2);
       outcomes.set(connector2.type, status);
     } catch (err) {
-      logger2.error(`Failed to authorize ${connector2.type}: ${err instanceof Error ? err.message : String(err)}`);
+      log.error(`Failed to authorize ${connector2.type}: ${err instanceof Error ? err.message : String(err)}`);
       outcomes.set(connector2.type, "FAILED");
     }
   }
@@ -247723,7 +247725,7 @@ async function promptOAuthFlows(pending, logger2, options) {
 }
 
 // src/cli/commands/connectors/push.ts
-function printSummary(results, oauthOutcomes, logger2) {
+function printSummary(results, oauthOutcomes, log) {
   const synced = [];
   const added = [];
   let provisioned;
@@ -247761,57 +247763,58 @@ function printSummary(results, oauthOutcomes, logger2) {
       }
     }
   }
-  logger2.info(theme.styles.bold("Summary:"));
+  log.info(theme.styles.bold("Summary:"));
   if (provisioned) {
-    logger2.success("Stripe sandbox provisioned");
+    log.success("Stripe sandbox provisioned");
     if (provisioned.claimUrl) {
-      logger2.info(`  Claim your Stripe sandbox: ${theme.colors.links(provisioned.claimUrl)}`);
+      log.info(`  Claim your Stripe sandbox: ${theme.colors.links(provisioned.claimUrl)}`);
     }
-    logger2.info(`  Connectors dashboard: ${theme.colors.links(getConnectorsUrl())}`);
+    log.info(`  Connectors dashboard: ${theme.colors.links(getConnectorsUrl())}`);
   }
   if (synced.length > 0) {
-    logger2.success(`Synced: ${synced.join(", ")}`);
+    log.success(`Synced: ${synced.join(", ")}`);
   }
   if (added.length > 0) {
-    logger2.success(`Added: ${added.join(", ")}`);
+    log.success(`Added: ${added.join(", ")}`);
   }
   if (removed.length > 0) {
-    logger2.info(theme.styles.dim(`Removed: ${removed.join(", ")}`));
+    log.info(theme.styles.dim(`Removed: ${removed.join(", ")}`));
   }
   if (skipped.length > 0) {
-    logger2.warn(`Skipped: ${skipped.join(", ")}`);
+    log.warn(`Skipped: ${skipped.join(", ")}`);
   }
   for (const r of failed) {
-    logger2.error(`Failed: ${r.type} - ${r.error}`);
+    log.error(`Failed: ${r.type} - ${r.error}`);
   }
 }
-async function pushConnectorsAction(isNonInteractive, logger2) {
+async function pushConnectorsAction({
+  isNonInteractive,
+  log
+}) {
   const { connectors } = await readProjectConfig();
   if (connectors.length === 0) {
-    logger2.info("No local connectors found - checking for remote connectors to remove");
+    log.info("No local connectors found - checking for remote connectors to remove");
   } else {
     const connectorNames = connectors.map((c3) => c3.type).join(", ");
-    logger2.info(`Found ${connectors.length} connectors to push: ${connectorNames}`);
+    log.info(`Found ${connectors.length} connectors to push: ${connectorNames}`);
   }
   const { results } = await runTask("Pushing connectors to Base44", async () => {
     return await pushConnectors(connectors);
   });
   const needsOAuth = filterPendingOAuth(results);
   let outroMessage = "Connectors pushed to Base44";
-  const oauthOutcomes = await promptOAuthFlows(needsOAuth, logger2, {
+  const oauthOutcomes = await promptOAuthFlows(needsOAuth, log, {
     skipPrompt: isNonInteractive
   });
   const allAuthorized = oauthOutcomes.size > 0 && [...oauthOutcomes.values()].every((s) => s === "ACTIVE");
   if (needsOAuth.length > 0 && !allAuthorized) {
     outroMessage = isNonInteractive ? "Skipped OAuth in non-interactive mode. Run 'base44 connectors push' locally or open the links above to authorize." : "Some connectors still require authorization. Run 'base44 connectors push' or open the links above to authorize.";
   }
-  printSummary(results, oauthOutcomes, logger2);
+  printSummary(results, oauthOutcomes, log);
   return { outroMessage };
 }
 function getConnectorsPushCommand() {
-  return new Base44Command("push").description("Push local connectors to Base44 (overwrites connectors on Base44)").action(async (_options, command2) => {
-    return await pushConnectorsAction(command2.isNonInteractive, command2.logger);
-  });
+  return new Base44Command("push").description("Push local connectors to Base44 (overwrites connectors on Base44)").action(pushConnectorsAction);
 }
 
 // src/cli/commands/connectors/index.ts
@@ -247820,7 +247823,9 @@ function getConnectorsCommand() {
 }
 
 // src/cli/commands/dashboard/open.ts
-async function openDashboard(isNonInteractive) {
+async function openDashboard({
+  isNonInteractive
+}) {
   const dashboardUrl = getDashboardUrl();
   if (!isNonInteractive) {
     await open_default(dashboardUrl);
@@ -247828,9 +247833,7 @@ async function openDashboard(isNonInteractive) {
   return { outroMessage: `Dashboard opened at ${dashboardUrl}` };
 }
 function getDashboardOpenCommand() {
-  return new Base44Command("open").description("Open the app dashboard in your browser").action(async (_options, command2) => {
-    return await openDashboard(command2.isNonInteractive);
-  });
+  return new Base44Command("open").description("Open the app dashboard in your browser").action(openDashboard);
 }
 
 // src/cli/commands/dashboard/index.ts
@@ -247839,13 +247842,15 @@ function getDashboardCommand() {
 }
 
 // src/cli/commands/entities/push.ts
-async function pushEntitiesAction(logger2) {
+async function pushEntitiesAction({
+  log
+}) {
   const { entities } = await readProjectConfig();
   if (entities.length === 0) {
     return { outroMessage: "No entities found in project" };
   }
   const entityNames = entities.map((e2) => e2.name).join(", ");
-  logger2.info(`Found ${entities.length} entities to push: ${entityNames}`);
+  log.info(`Found ${entities.length} entities to push: ${entityNames}`);
   const result = await runTask("Pushing entities to Base44", async () => {
     return await pushEntities(entities);
   }, {
@@ -247853,22 +247858,22 @@ async function pushEntitiesAction(logger2) {
     errorMessage: "Failed to push entities"
   });
   if (result.created.length > 0) {
-    logger2.success(`Created: ${result.created.join(", ")}`);
+    log.success(`Created: ${result.created.join(", ")}`);
   }
   if (result.updated.length > 0) {
-    logger2.success(`Updated: ${result.updated.join(", ")}`);
+    log.success(`Updated: ${result.updated.join(", ")}`);
   }
   if (result.deleted.length > 0) {
-    logger2.warn(`Deleted: ${result.deleted.join(", ")}`);
+    log.warn(`Deleted: ${result.deleted.join(", ")}`);
   }
   return { outroMessage: "Entities pushed to Base44" };
 }
 function getEntitiesPushCommand() {
-  return new Command("entities").description("Manage project entities").addCommand(new Base44Command("push").description("Push local entities to Base44").action((_options, command2) => pushEntitiesAction(command2.logger)));
+  return new Command("entities").description("Manage project entities").addCommand(new Base44Command("push").description("Push local entities to Base44").action(pushEntitiesAction));
 }
 
 // src/cli/commands/functions/delete.ts
-async function deleteFunctionsAction(names) {
+async function deleteFunctionsAction(_ctx, names) {
   let deleted = 0;
   let notFound = 0;
   let errors5 = 0;
@@ -247914,9 +247919,9 @@ function validateNames(command2) {
   }
 }
 function getDeleteCommand() {
-  return new Base44Command("delete").description("Delete deployed functions").argument("<names...>", "Function names to delete").hook("preAction", validateNames).action(async (rawNames) => {
+  return new Base44Command("delete").description("Delete deployed functions").argument("<names...>", "Function names to delete").hook("preAction", validateNames).action(async (ctx, rawNames) => {
     const names = parseNames(rawNames);
-    return deleteFunctionsAction(names);
+    return deleteFunctionsAction(ctx, names);
   });
 }
 
@@ -247924,15 +247929,15 @@ function getDeleteCommand() {
 function formatDuration(ms) {
   return `${(ms / 1000).toFixed(1)}s`;
 }
-function formatDeployResult(result, logger2) {
+function formatDeployResult(result, log) {
   const label = result.name.padEnd(25);
   if (result.status === "deployed") {
     const timing = result.durationMs ? theme.styles.dim(` (${formatDuration(result.durationMs)})`) : "";
-    logger2.success(`${label} deployed${timing}`);
+    log.success(`${label} deployed${timing}`);
   } else if (result.status === "unchanged") {
-    logger2.success(`${label} unchanged`);
+    log.success(`${label} unchanged`);
   } else {
-    logger2.error(`${label} error: ${result.error}`);
+    log.error(`${label} error: ${result.error}`);
   }
 }
 
@@ -247951,17 +247956,17 @@ function resolveFunctionsToDeploy(names, allFunctions) {
   }
   return allFunctions.filter((f) => names.includes(f.name));
 }
-function formatPruneResult(pruneResult, logger2) {
+function formatPruneResult(pruneResult, log) {
   if (pruneResult.deleted) {
-    logger2.success(`${pruneResult.name.padEnd(25)} deleted`);
+    log.success(`${pruneResult.name.padEnd(25)} deleted`);
   } else {
-    logger2.error(`${pruneResult.name.padEnd(25)} error: ${pruneResult.error}`);
+    log.error(`${pruneResult.name.padEnd(25)} error: ${pruneResult.error}`);
   }
 }
-function formatPruneSummary(pruneResults, logger2) {
+function formatPruneSummary(pruneResults, log) {
   if (pruneResults.length > 0) {
     const pruned = pruneResults.filter((r) => r.deleted).length;
-    logger2.info(`${pruned} deleted`);
+    log.info(`${pruned} deleted`);
   }
 }
 function buildDeploySummary(results) {
@@ -247977,7 +247982,7 @@ function buildDeploySummary(results) {
     parts.push(`${failed} error${failed !== 1 ? "s" : ""}`);
   return parts.join(", ") || "No functions deployed";
 }
-async function deployFunctionsAction(names, options, logger2) {
+async function deployFunctionsAction({ log }, names, options) {
   if (options.force && names.length > 0) {
     throw new InvalidInputError("--force cannot be used when specifying function names");
   }
@@ -247988,17 +247993,17 @@ async function deployFunctionsAction(names, options, logger2) {
       outroMessage: "No functions found. Create functions in the 'functions' directory."
     };
   }
-  logger2.info(`Found ${toDeploy.length} ${toDeploy.length === 1 ? "function" : "functions"} to deploy`);
+  log.info(`Found ${toDeploy.length} ${toDeploy.length === 1 ? "function" : "functions"} to deploy`);
   let completed = 0;
   const total = toDeploy.length;
   const results = await deployFunctionsSequentially(toDeploy, {
     onStart: (startNames) => {
       const label = startNames.length === 1 ? startNames[0] : `${startNames.length} functions`;
-      logger2.step(theme.styles.dim(`[${completed + 1}/${total}] Deploying ${label}...`));
+      log.step(theme.styles.dim(`[${completed + 1}/${total}] Deploying ${label}...`));
     },
     onResult: (result) => {
       completed++;
-      formatDeployResult(result, logger2);
+      formatDeployResult(result, log);
     }
   });
   if (options.force) {
@@ -248009,28 +248014,30 @@ async function deployFunctionsAction(names, options, logger2) {
       onStart: (total2) => {
         pruneTotal = total2;
         if (total2 > 0) {
-          logger2.info(`Found ${total2} remote ${total2 === 1 ? "function" : "functions"} to delete`);
+          log.info(`Found ${total2} remote ${total2 === 1 ? "function" : "functions"} to delete`);
         }
       },
       onBeforeDelete: (name2) => {
         pruneCompleted++;
-        logger2.step(theme.styles.dim(`[${pruneCompleted}/${pruneTotal}] Deleting ${name2}...`));
+        log.step(theme.styles.dim(`[${pruneCompleted}/${pruneTotal}] Deleting ${name2}...`));
       },
-      onResult: (r) => formatPruneResult(r, logger2)
+      onResult: (r) => formatPruneResult(r, log)
     });
-    formatPruneSummary(pruneResults, logger2);
+    formatPruneSummary(pruneResults, log);
   }
   return { outroMessage: buildDeploySummary(results) };
 }
 function getDeployCommand() {
-  return new Base44Command("deploy").description("Deploy functions to Base44").argument("[names...]", "Function names to deploy (deploys all if omitted)").option("--force", "Delete remote functions not found locally").action(async (rawNames, options, command2) => {
+  return new Base44Command("deploy").description("Deploy functions to Base44").argument("[names...]", "Function names to deploy (deploys all if omitted)").option("--force", "Delete remote functions not found locally").action(async (ctx, rawNames, options) => {
     const names = parseNames2(rawNames);
-    return deployFunctionsAction(names, options, command2.logger);
+    return deployFunctionsAction(ctx, names, options);
   });
 }
 
 // src/cli/commands/functions/list.ts
-async function listFunctionsAction(logger2) {
+async function listFunctionsAction({
+  log
+}) {
   const { functions } = await runTask("Fetching functions...", async () => listDeployedFunctions(), { errorMessage: "Failed to fetch functions" });
   if (functions.length === 0) {
     return { outroMessage: "No functions on remote" };
@@ -248038,19 +248045,19 @@ async function listFunctionsAction(logger2) {
   for (const fn of functions) {
     const automationCount = fn.automations.length;
     const automationLabel = automationCount > 0 ? theme.styles.dim(` (${automationCount} automation${automationCount > 1 ? "s" : ""})`) : "";
-    logger2.message(`  ${fn.name}${automationLabel}`);
+    log.message(`  ${fn.name}${automationLabel}`);
   }
   return {
     outroMessage: `${functions.length} function${functions.length !== 1 ? "s" : ""} on remote`
   };
 }
 function getListCommand() {
-  return new Base44Command("list").description("List all deployed functions").action((_options, command2) => listFunctionsAction(command2.logger));
+  return new Base44Command("list").description("List all deployed functions").action(listFunctionsAction);
 }
 
 // src/cli/commands/functions/pull.ts
 import { dirname as dirname9, join as join13 } from "node:path";
-async function pullFunctionsAction(name2, logger2) {
+async function pullFunctionsAction({ log }, name2) {
   const { project: project2 } = await readProjectConfig();
   const configDir = dirname9(project2.configPath);
   const functionsDir = join13(configDir, project2.functionsDir);
@@ -248077,19 +248084,17 @@ async function pullFunctionsAction(name2, logger2) {
     errorMessage: "Failed to write function files"
   });
   for (const name3 of written) {
-    logger2.success(`${name3.padEnd(25)} written`);
+    log.success(`${name3.padEnd(25)} written`);
   }
   for (const name3 of skipped) {
-    logger2.info(`${name3.padEnd(25)} unchanged`);
+    log.info(`${name3.padEnd(25)} unchanged`);
   }
   return {
     outroMessage: `Pulled ${toPull.length} function${toPull.length !== 1 ? "s" : ""} to ${functionsDir}`
   };
 }
 function getPullCommand() {
-  return new Base44Command("pull").description("Pull deployed functions from Base44").argument("[name]", "Function name to pull (pulls all if omitted)").action(async (name2, _options, command2) => {
-    return pullFunctionsAction(name2, command2.logger);
-  });
+  return new Base44Command("pull").description("Pull deployed functions from Base44").argument("[name]", "Function name to pull (pulls all if omitted)").action(pullFunctionsAction);
 }
 
 // src/cli/commands/functions/index.ts
@@ -248118,7 +248123,7 @@ function validateNonInteractiveFlags(command2) {
     command2.error("--path requires a project name argument. Usage: base44 create <name> --path <path>");
   }
 }
-async function createInteractive(options, logger2) {
+async function createInteractive(options, log) {
   const templates = await listTemplates();
   const templateOptions = templates.map((t) => ({
     value: t,
@@ -248160,10 +248165,10 @@ async function createInteractive(options, logger2) {
     deploy: options.deploy,
     skills: options.skills,
     isInteractive: true
-  }, logger2);
+  }, log);
 }
-async function createNonInteractive(options, logger2) {
-  logger2.info(`Creating a new project at ${resolve2(options.path)}`);
+async function createNonInteractive(options, log) {
+  log.info(`Creating a new project at ${resolve2(options.path)}`);
   const template2 = await getTemplateById(options.template ?? DEFAULT_TEMPLATE_ID);
   return await executeCreate({
     template: template2,
@@ -248172,7 +248177,7 @@ async function createNonInteractive(options, logger2) {
     deploy: options.deploy,
     skills: options.skills,
     isInteractive: false
-  }, logger2);
+  }, log);
 }
 async function executeCreate({
   template: template2,
@@ -248182,7 +248187,7 @@ async function executeCreate({
   deploy: deploy5,
   skills,
   isInteractive
-}, logger2) {
+}, log) {
   const name2 = rawName.trim();
   const resolvedPath = resolve2(projectPath);
   const { projectId } = await runTask("Setting up your project...", async () => {
@@ -248257,13 +248262,32 @@ async function executeCreate({
       });
     } catch {}
   }
-  logger2.message(`${theme.styles.header("Project")}: ${theme.colors.base44Orange(name2)}`);
-  logger2.message(`${theme.styles.header("Dashboard")}: ${theme.colors.links(getDashboardUrl(projectId))}`);
+  log.message(`${theme.styles.header("Project")}: ${theme.colors.base44Orange(name2)}`);
+  log.message(`${theme.styles.header("Dashboard")}: ${theme.colors.links(getDashboardUrl(projectId))}`);
   if (finalAppUrl) {
-    logger2.message(`${theme.styles.header("Site")}: ${theme.colors.links(finalAppUrl)}`);
+    log.message(`${theme.styles.header("Site")}: ${theme.colors.links(finalAppUrl)}`);
   }
   return { outroMessage: "Your project is set up and ready to use" };
 }
+async function createAction({ log, isNonInteractive }, name2, options) {
+  if (name2 && !options.path) {
+    options.path = `./${import_kebabCase.default(name2)}`;
+  }
+  const skipPrompts = !!(options.name ?? name2) && !!options.path;
+  if (!skipPrompts && isNonInteractive) {
+    throw new InvalidInputError("Project name and --path are required in non-interactive mode", {
+      hints: [
+        {
+          message: "Usage: base44 create <name> --path <path>"
+        }
+      ]
+    });
+  }
+  if (skipPrompts) {
+    return await createNonInteractive({ name: options.name ?? name2, ...options }, log);
+  }
+  return await createInteractive({ name: name2, ...options }, log);
+}
 function getCreateCommand() {
   return new Base44Command("create", {
     requireAppConfig: false,
@@ -248272,33 +248296,14 @@ 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(async (name2, options, command2) => {
-    if (name2 && !options.path) {
-      options.path = `./${import_kebabCase.default(name2)}`;
-    }
-    const skipPrompts = !!(options.name ?? name2) && !!options.path;
-    if (!skipPrompts && command2.isNonInteractive) {
-      throw new InvalidInputError("Project name and --path are required in non-interactive mode", {
-        hints: [
-          {
-            message: "Usage: base44 create <name> --path <path>"
-          }
-        ]
-      });
-    }
-    if (skipPrompts) {
-      return await createNonInteractive({
-        name: options.name ?? name2,
-        ...options
-      }, command2.logger);
-    }
-    return await createInteractive({ name: name2, ...options }, command2.logger);
-  });
+  $ 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);
 }
 
 // src/cli/commands/project/deploy.ts
-async function deployAction(options) {
-  const logger2 = options.logger;
+async function deployAction({ isNonInteractive, log }, options = {}) {
+  if (isNonInteractive && !options.yes) {
+    throw new InvalidInputError("--yes is required in non-interactive mode");
+  }
   const projectData = await readProjectConfig(options.projectRoot);
   if (!hasResourcesToDeploy(projectData)) {
     return {
@@ -248323,7 +248328,7 @@ async function deployAction(options) {
     summaryLines.push(`  - Site from ${project2.site.outputDirectory}`);
   }
   if (!options.yes) {
-    logger2.warn(`This will update your Base44 app with:
+    log.warn(`This will update your Base44 app with:
 ${summaryLines.join(`
 `)}`);
     const shouldDeploy = await Re({
@@ -248333,7 +248338,7 @@ ${summaryLines.join(`
       return { outroMessage: "Deployment cancelled" };
     }
   } else {
-    logger2.info(`Deploying:
+    log.info(`Deploying:
 ${summaryLines.join(`
 `)}`);
   }
@@ -248342,55 +248347,46 @@ ${summaryLines.join(`
   const result = await deployAll(projectData, {
     onFunctionStart: (names) => {
       const label = names.length === 1 ? names[0] : `${names.length} functions`;
-      logger2.step(theme.styles.dim(`[${functionCompleted + 1}/${functionTotal}] Deploying ${label}...`));
+      log.step(theme.styles.dim(`[${functionCompleted + 1}/${functionTotal}] Deploying ${label}...`));
     },
     onFunctionResult: (r) => {
       functionCompleted++;
-      formatDeployResult(r, logger2);
+      formatDeployResult(r, log);
     }
   });
   const connectorResults = result.connectorResults ?? [];
-  await handleOAuthConnectors(connectorResults, options, logger2);
+  await handleOAuthConnectors(connectorResults, isNonInteractive, options, log);
   const stripeResult = connectorResults.find((r) => r.type === "stripe");
   if (stripeResult?.action === "provisioned") {
-    printStripeResult(stripeResult, logger2);
+    printStripeResult(stripeResult, log);
   }
-  logger2.message(`${theme.styles.header("Dashboard")}: ${theme.colors.links(getDashboardUrl())}`);
+  log.message(`${theme.styles.header("Dashboard")}: ${theme.colors.links(getDashboardUrl())}`);
   if (result.appUrl) {
-    logger2.message(`${theme.styles.header("App URL")}: ${theme.colors.links(result.appUrl)}`);
+    log.message(`${theme.styles.header("App URL")}: ${theme.colors.links(result.appUrl)}`);
   }
   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(async (options, command2) => {
-    if (command2.isNonInteractive && !options.yes) {
-      throw new InvalidInputError("--yes is required in non-interactive mode");
-    }
-    return await deployAction({
-      ...options,
-      isNonInteractive: command2.isNonInteractive,
-      logger: command2.logger
-    });
-  });
+  return new Base44Command("deploy").description("Deploy all project resources (entities, functions, agents, connectors, and site)").option("-y, --yes", "Skip confirmation prompt").action(deployAction);
 }
-async function handleOAuthConnectors(connectorResults, options, logger2) {
+async function handleOAuthConnectors(connectorResults, isNonInteractive, options, log) {
   const needsOAuth = filterPendingOAuth(connectorResults);
   if (needsOAuth.length === 0)
     return;
-  const oauthOutcomes = await promptOAuthFlows(needsOAuth, logger2, {
-    skipPrompt: options.yes || options.isNonInteractive
+  const oauthOutcomes = await promptOAuthFlows(needsOAuth, log, {
+    skipPrompt: options.yes || isNonInteractive
   });
   const allAuthorized = oauthOutcomes.size > 0 && [...oauthOutcomes.values()].every((s) => s === "ACTIVE");
   if (!allAuthorized) {
-    logger2.info("Some connectors still require authorization. Run 'base44 connectors push' or open the links above in your browser.");
+    log.info("Some connectors still require authorization. Run 'base44 connectors push' or open the links above in your browser.");
   }
 }
-function printStripeResult(r, logger2) {
-  logger2.success("Stripe sandbox provisioned");
+function printStripeResult(r, log) {
+  log.success("Stripe sandbox provisioned");
   if (r.claimUrl) {
-    logger2.info(`  Claim your Stripe sandbox: ${theme.colors.links(r.claimUrl)}`);
+    log.info(`  Claim your Stripe sandbox: ${theme.colors.links(r.claimUrl)}`);
   }
-  logger2.info(`  Connectors dashboard: ${theme.colors.links(getConnectorsUrl())}`);
+  log.info(`  Connectors dashboard: ${theme.colors.links(getConnectorsUrl())}`);
 }
 
 // src/cli/commands/project/link.ts
@@ -248466,7 +248462,12 @@ async function promptForExistingProject(linkableProjects) {
   }
   return selectedProject;
 }
-async function link(options, logger2) {
+async function link(ctx, options) {
+  const { log, isNonInteractive } = ctx;
+  const skipPrompts = !!options.create || !!options.projectId;
+  if (!skipPrompts && isNonInteractive) {
+    throw new InvalidInputError("--create with --name, or --projectId, is required in non-interactive mode");
+  }
   const projectRoot = await findProjectRoot();
   if (!projectRoot) {
     throw new ConfigNotFoundError("No Base44 project found. Run this command from a project directory with a config.jsonc file.");
@@ -248530,17 +248531,11 @@ async function link(options, logger2) {
     setAppConfig({ id: projectId, projectRoot: projectRoot.root });
     finalProjectId = projectId;
   }
-  logger2.message(`${theme.styles.header("Dashboard")}: ${theme.colors.links(getDashboardUrl(finalProjectId))}`);
+  log.message(`${theme.styles.header("Dashboard")}: ${theme.colors.links(getDashboardUrl(finalProjectId))}`);
   return { outroMessage: "Project linked" };
 }
 function getLinkCommand() {
-  return new Base44Command("link", { requireAppConfig: 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(async (options, command2) => {
-    const skipPrompts = !!options.create || !!options.projectId;
-    if (!skipPrompts && command2.isNonInteractive) {
-      throw new InvalidInputError("--create with --name, or --projectId, is required in non-interactive mode");
-    }
-    return await link(options, command2.logger);
-  });
+  return new Base44Command("link", { requireAppConfig: 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);
 }
 
 // src/cli/commands/project/logs.ts
@@ -248642,7 +248637,7 @@ function validateLimit(limit) {
     throw new InvalidInputError(`Invalid limit: "${limit}". Must be a number between 1 and 1000.`);
   }
 }
-async function logsAction(options) {
+async function logsAction(_ctx, options) {
   validateLimit(options.limit);
   const specifiedFunctions = parseFunctionNames(options.function);
   const allProjectFunctions = await getAllFunctionNames();
@@ -248664,7 +248659,7 @@ function getLogsCommand() {
 }
 
 // src/cli/commands/secrets/delete.ts
-async function deleteSecretAction(key) {
+async function deleteSecretAction(_ctx, key) {
   await runTask(`Deleting secret "${key}"`, async () => {
     return await deleteSecret(key);
   }, {
@@ -248680,7 +248675,9 @@ function getSecretsDeleteCommand() {
 }
 
 // src/cli/commands/secrets/list.ts
-async function listSecretsAction(logger2) {
+async function listSecretsAction({
+  log
+}) {
   const secrets = await runTask("Fetching secrets from Base44", async () => {
     return await listSecrets();
   }, {
@@ -248692,14 +248689,14 @@ async function listSecretsAction(logger2) {
     return { outroMessage: "No secrets configured." };
   }
   for (const name2 of names) {
-    logger2.info(name2);
+    log.info(name2);
   }
   return {
     outroMessage: `Found ${names.length} secrets.`
   };
 }
 function getSecretsListCommand() {
-  return new Base44Command("list").description("List secret names").action((_options, command2) => listSecretsAction(command2.logger));
+  return new Base44Command("list").description("List secret names").action(listSecretsAction);
 }
 
 // src/cli/commands/secrets/set.ts
@@ -248730,7 +248727,7 @@ function validateInput(entries, options) {
     throw new InvalidInputError("Provide KEY=VALUE pairs or --env-file, but not both.");
   }
 }
-async function setSecretsAction(entries, options, logger2) {
+async function setSecretsAction({ log }, entries, options) {
   validateInput(entries, options);
   let secrets;
   if (options.envFile) {
@@ -248748,15 +248745,13 @@ async function setSecretsAction(entries, options, logger2) {
     successMessage: `${names.length} secrets set successfully`,
     errorMessage: "Failed to set secrets"
   });
-  logger2.info(`Set: ${names.join(", ")}`);
+  log.info(`Set: ${names.join(", ")}`);
   return {
     outroMessage: "Secrets set successfully."
   };
 }
 function getSecretsSetCommand() {
-  return new Base44Command("set").description("Set one or more secrets (KEY=VALUE format)").argument("[entries...]", "KEY=VALUE pairs (e.g. KEY1=VALUE1 KEY2=VALUE2)").option("--env-file <path>", "Path to .env file").action(async (entries, options, command2) => {
-    return await setSecretsAction(entries, options, command2.logger);
-  });
+  return new Base44Command("set").description("Set one or more secrets (KEY=VALUE format)").argument("[entries...]", "KEY=VALUE pairs (e.g. KEY1=VALUE1 KEY2=VALUE2)").option("--env-file <path>", "Path to .env file").action(setSecretsAction);
 }
 
 // src/cli/commands/secrets/index.ts
@@ -248766,7 +248761,10 @@ function getSecretsCommand() {
 
 // src/cli/commands/site/deploy.ts
 import { resolve as resolve4 } from "node:path";
-async function deployAction2(options) {
+async function deployAction2({ isNonInteractive }, options) {
+  if (isNonInteractive && !options.yes) {
+    throw new InvalidInputError("--yes is required in non-interactive mode");
+  }
   const { project: project2 } = await readProjectConfig();
   if (!project2.site?.outputDirectory) {
     throw new ConfigNotFoundError("No site configuration found.", {
@@ -248795,19 +248793,13 @@ async function deployAction2(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(async (options, command2) => {
-    if (command2.isNonInteractive && !options.yes) {
-      throw new InvalidInputError("--yes is required in non-interactive mode");
-    }
-    return await deployAction2({
-      ...options,
-      isNonInteractive: command2.isNonInteractive
-    });
-  });
+  return new Base44Command("deploy").description("Deploy built site files to Base44 hosting").option("-y, --yes", "Skip confirmation prompt").action(deployAction2);
 }
 
 // src/cli/commands/site/open.ts
-async function openAction(isNonInteractive) {
+async function openAction({
+  isNonInteractive
+}) {
   const siteUrl = await getSiteUrl();
   if (!isNonInteractive) {
     await open_default(siteUrl);
@@ -248815,9 +248807,7 @@ async function openAction(isNonInteractive) {
   return { outroMessage: `Site opened at ${siteUrl}` };
 }
 function getSiteOpenCommand() {
-  return new Base44Command("open").description("Open the published site in your browser").action(async (_options, command2) => {
-    return await openAction(command2.isNonInteractive);
-  });
+  return new Base44Command("open").description("Open the published site in your browser").action(openAction);
 }
 
 // src/cli/commands/site/index.ts
@@ -248935,7 +248925,7 @@ async function updateProjectConfig(projectRoot) {
 }
 // src/cli/commands/types/generate.ts
 var TYPES_FILE_PATH = "base44/.types/types.d.ts";
-async function generateTypesAction() {
+async function generateTypesAction(_ctx) {
   const { entities, functions, agents, connectors, project: project2 } = await readProjectConfig();
   await runTask("Generating types", async () => {
     await generateTypesFile({ entities, functions, agents, connectors });
@@ -248955,9 +248945,9 @@ function getTypesCommand() {
 }
 
 // src/cli/dev/dev-server/main.ts
-import { dirname as dirname14, join as join20 } from "node:path";
 var import_cors = __toESM(require_lib4(), 1);
 var import_express4 = __toESM(require_express(), 1);
+import { dirname as dirname14, join as join20 } from "node:path";
 
 // ../../node_modules/get-port/index.js
 import net from "node:net";
@@ -251618,12 +251608,12 @@ async function createDevServer(options8) {
   const functionRoutes = createFunctionRouter(functionManager, devLogger);
   app.use("/api/apps/:appId/functions", functionRoutes);
   if (functionManager.getFunctionNames().length > 0) {
-    R2.info(`Loaded functions: ${functionManager.getFunctionNames().join(", ")}`);
+    options8.log.info(`Loaded functions: ${functionManager.getFunctionNames().join(", ")}`);
   }
   const db2 = new Database;
   db2.load(entities);
   if (db2.getCollectionNames().length > 0) {
-    R2.info(`Loaded entities: ${db2.getCollectionNames().join(", ")}`);
+    options8.log.info(`Loaded entities: ${db2.getCollectionNames().join(", ")}`);
   }
   let emitEntityEvent = () => {};
   const entityRoutes = createEntityRoutes(db2, devLogger, remoteProxy, (...args) => emitEntityEvent(...args));
@@ -251719,9 +251709,10 @@ async function createDevServer(options8) {
 }
 
 // src/cli/commands/dev.ts
-async function devAction(options8) {
+async function devAction({ log }, options8) {
   const port = options8.port ? Number(options8.port) : undefined;
   const { port: resolvedPort } = await createDevServer({
+    log,
     port,
     denoWrapperPath: getDenoWrapperPath(),
     loadResources: async () => {
@@ -251740,7 +251731,14 @@ function getDevCommand() {
 // src/cli/commands/project/eject.ts
 import { resolve as resolve8 } from "node:path";
 var import_kebabCase2 = __toESM(require_kebabCase(), 1);
-async function eject(options8, logger2) {
+async function eject(ctx, options8) {
+  const { log, isNonInteractive } = ctx;
+  if (isNonInteractive && !options8.projectId) {
+    throw new InvalidInputError("--project-id is required in non-interactive mode");
+  }
+  if (isNonInteractive && !options8.path) {
+    throw new InvalidInputError("--path is required in non-interactive mode");
+  }
   const projects = await listProjects();
   const ejectableProjects = projects.filter((p4) => p4.isManagedSourceCode !== false);
   let selectedProject;
@@ -251756,7 +251754,7 @@ async function eject(options8, logger2) {
       });
     }
     selectedProject = foundProject;
-    logger2.info(`Selected project: ${theme.styles.bold(selectedProject.name)}`);
+    log.info(`Selected project: ${theme.styles.bold(selectedProject.name)}`);
   } else {
     if (ejectableProjects.length === 0) {
       return { outroMessage: "No projects available to eject." };
@@ -251820,21 +251818,13 @@ async function eject(options8, logger2) {
         successMessage: theme.colors.base44Orange("Project built successfully"),
         errorMessage: "Failed to build project"
       });
-      await deployAction({ yes: true, projectRoot: resolvedPath, logger: logger2 });
+      await deployAction(ctx, { yes: true, projectRoot: resolvedPath });
     }
   }
   return { outroMessage: "Your new project is set and ready to use" };
 }
 function getEjectCommand() {
-  return new Base44Command("eject", { requireAppConfig: 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(async (options8, command2) => {
-    if (command2.isNonInteractive && !options8.projectId) {
-      throw new InvalidInputError("--project-id is required in non-interactive mode");
-    }
-    if (command2.isNonInteractive && !options8.path) {
-      throw new InvalidInputError("--path is required in non-interactive mode");
-    }
-    return await eject({ ...options8, isNonInteractive: command2.isNonInteractive }, command2.logger);
-  });
+  return new Base44Command("eject", { requireAppConfig: 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);
 }
 
 // src/cli/program.ts
@@ -256078,12 +256068,12 @@ async function runCLI(options8) {
   const errorReporter = new ErrorReporter;
   errorReporter.registerProcessErrorHandlers();
   const isNonInteractive = !process.stdin.isTTY || !process.stdout.isTTY;
-  const logger3 = isNonInteractive ? new SimpleLogger : new ClackLogger;
+  const log = isNonInteractive ? new SimpleLogger : new ClackLogger;
   const context = {
     errorReporter,
     isNonInteractive,
     distribution: options8?.distribution ?? "npm",
-    logger: logger3
+    log
   };
   const program2 = createProgram(context);
   try {
@@ -256109,4 +256099,4 @@ export {
   CLIExitError
 };
 
-//# debugId=A30B6BD8DF21129764756E2164756E21
+//# debugId=C109B5AC280C561864756E2164756E21