@beignet/cli 0.0.26 → 0.0.28

package/src/index.ts

@@ -26,12 +26,15 @@ import {
   makeFeatureAddonChoices,
   makeFeatureRecipeChoices,
   type PackageManager,
+  type ProviderPresetName,
   packageManagerChoices,
+  providerPresetChoices,
   type TemplateName,
   templateChoices,
 } from "./choices.js";
 // Type-only: the runtime module stays behind the create command's lazy loader.
 import type { CreateSelections } from "./create-prompts.js";
+import type { AddProviderPresetResult } from "./provider-add.js";
 import { getCliVersion } from "./version.js";
 
 type CliContext = CommandContext & {
@@ -102,6 +105,12 @@ type LintFlags = {
   format?: OutputFormat;
 };
 
+type CheckFlags = {
+  json?: boolean;
+  fix?: boolean;
+  cwd?: string;
+};
+
 type DbFlags = {
   json?: boolean;
   dryRun?: boolean;
@@ -131,6 +140,7 @@ type DbSchemaGenerateFlags = DbFlags & {
 type TaskRunFlags = {
   json?: boolean;
   input?: string;
+  tenant?: string;
   module?: string;
 };
 
@@ -168,7 +178,24 @@ type ProviderAuditFlags = {
   cwd?: string;
 };
 
+type ProviderAddFlags = {
+  json?: boolean;
+  dryRun?: boolean;
+  cwd?: string;
+};
+
 const parseString = (input: string): string => input;
+const parseProviderPreset = (input: string): ProviderPresetName => {
+  if ((providerPresetChoices as readonly string[]).includes(input)) {
+    return input as ProviderPresetName;
+  }
+
+  throw new Error(
+    `Unknown provider preset "${input}". Available presets: ${providerPresetChoices.join(
+      ", ",
+    )}.`,
+  );
+};
 const parsePositiveInteger = (input: string): number => {
   const value = Number(input);
   if (!Number.isInteger(value) || value <= 0) {
@@ -240,6 +267,12 @@ const providerAuditFlagParameters = {
   cwd: cwdFlag,
 } satisfies FlagParametersForType<ProviderAuditFlags, CliContext>;
 
+const providerAddFlagParameters = {
+  json: jsonFlag,
+  dryRun: dryRunFlag,
+  cwd: cwdFlag,
+} satisfies FlagParametersForType<ProviderAddFlags, CliContext>;
+
 const dbFlagParameters = {
   json: jsonFlag,
   dryRun: dryRunFlag,
@@ -270,6 +303,9 @@ const dbSchemaGenerateFlagParameters = {
 const taskRunFlagParameters = {
   json: jsonFlag,
   input: parsedStringFlag("JSON input passed to the task schema."),
+  tenant: parsedStringFlag(
+    "Tenant id or slug passed to the app's createTaskContext, separate from task input.",
+  ),
   module: parsedStringFlag(
     "Task registry module. Defaults to server/tasks.ts.",
   ),
@@ -317,6 +353,19 @@ const namePositional = {
   ],
 } as const;
 
+const providerPresetPositional = {
+  kind: "tuple",
+  parameters: [
+    {
+      parse: parseProviderPreset,
+      placeholder: "preset",
+      brief: `Provider preset to add. Available: ${providerPresetChoices.join(
+        ", ",
+      )}.`,
+    },
+  ],
+} as const;
+
 function resolveOutputFormat(flags: {
   json?: boolean;
   format?: OutputFormat;
@@ -558,6 +607,55 @@ const doctorCommand = buildCommand<DoctorFlags, [], CliContext>({
   },
 });
 
+const checkCommand = buildCommand<CheckFlags, [], CliContext>({
+  docs: {
+    brief: "Run the full app validation loop as one command.",
+    fullDescription:
+      "Runs beignet lint, beignet doctor --strict, and the app's lint, typecheck, and test package scripts through the detected package manager. Every step runs even when an earlier one fails, so one run reports everything. Missing package scripts are skipped, not failed.",
+  },
+  parameters: {
+    flags: {
+      json: jsonFlag,
+      fix: {
+        kind: "boolean",
+        optional: true,
+        withNegated: false,
+        brief: "Apply low-risk doctor fixes before checking.",
+      },
+      cwd: cwdFlag,
+    } satisfies FlagParametersForType<CheckFlags, CliContext>,
+  },
+  loader: async () => {
+    const { checkApp, formatCheckStep, formatCheckSummary } = await import(
+      "./check.js"
+    );
+
+    return async function runCheck(this: CliContext, flags: CheckFlags) {
+      const color = useColor();
+      const result = await checkApp({
+        cwd: flags.cwd,
+        fix: flags.fix,
+        color,
+        ...(flags.json
+          ? {}
+          : {
+              onStep: (step) =>
+                writeOutput(this, formatCheckStep(step, { color })),
+            }),
+      });
+      writeOutput(
+        this,
+        flags.json
+          ? JSON.stringify(result, null, 2)
+          : `\n${formatCheckSummary(result, { color })}`,
+      );
+      if (!result.ok) {
+        this.process.exitCode = 1;
+      }
+    };
+  },
+});
+
 const lintCommand = buildCommand<LintFlags, [], CliContext>({
   docs: {
     brief: "Check Beignet dependency direction conventions.",
@@ -639,11 +737,50 @@ const providerAuditCommand = buildCommand<ProviderAuditFlags, [], CliContext>({
   },
 });
 
+const providerAddCommand = buildCommand<
+  ProviderAddFlags,
+  [ProviderPresetName],
+  CliContext
+>({
+  docs: {
+    brief: "Add a provider setup preset to a Beignet app.",
+    fullDescription: `Updates an existing Beignet app with provider package dependencies, server/provider registration, app port wiring, .env.example entries, and local setup notes.
+
+Available presets: ${providerPresetChoices.join(", ")}`,
+  },
+  parameters: {
+    flags: providerAddFlagParameters,
+    positional: providerPresetPositional,
+  },
+  loader: async () => {
+    const { addProviderPreset } = await import("./provider-add.js");
+
+    return async function runProviderAdd(
+      this: CliContext,
+      flags: ProviderAddFlags,
+      name: ProviderPresetName,
+    ) {
+      const result = await addProviderPreset({
+        name,
+        cwd: flags.cwd,
+        dryRun: Boolean(flags.dryRun),
+      });
+      writeOutput(
+        this,
+        flags.json
+          ? JSON.stringify(result, null, 2)
+          : providerAddNextSteps(result),
+      );
+    };
+  },
+});
+
 const providerRoutes = buildRouteMap({
   docs: {
-    brief: "Inspect Beignet provider setup.",
+    brief: "Manage Beignet provider setup.",
   },
   routes: {
+    add: providerAddCommand,
     audit: providerAuditCommand,
   },
 });
@@ -760,6 +897,7 @@ const taskRunCommand = buildCommand<TaskRunFlags, [string], CliContext>({
       const result = await runAppTask({
         name,
         input: flags.input,
+        tenant: flags.tenant,
         modulePath: flags.module,
       });
 
@@ -1215,7 +1353,9 @@ const makePaymentsCommand = buildCommand<MakeFlags, [], CliContext>({
     flags: makeFlagParameters,
   },
   loader: async () => {
-    const { makePayments } = await import("./make.js");
+    const { makePayments, makePaymentsNextStepLines } = await import(
+      "./make.js"
+    );
 
     return async function runMakePayments(this: CliContext, flags: MakeFlags) {
       const result = await makePayments({
@@ -1226,7 +1366,69 @@ const makePaymentsCommand = buildCommand<MakeFlags, [], CliContext>({
         this,
         flags.json
           ? JSON.stringify(result, null, 2)
-          : makePaymentsNextSteps(result),
+          : makeNextSteps(
+              result,
+              "billing slice",
+              makePaymentsNextStepLines(result),
+            ),
+      );
+    };
+  },
+});
+
+const makeTenancyCommand = buildCommand<MakeFlags, [], CliContext>({
+  docs: {
+    brief: "Generate a workspace tenancy slice.",
+  },
+  parameters: {
+    flags: makeFlagParameters,
+  },
+  loader: async () => {
+    const { makeTenancy, makeTenancyNextStepLines } = await import("./make.js");
+
+    return async function runMakeTenancy(this: CliContext, flags: MakeFlags) {
+      const result = await makeTenancy({
+        force: Boolean(flags.force),
+        dryRun: Boolean(flags.dryRun),
+      });
+      writeOutput(
+        this,
+        flags.json
+          ? JSON.stringify(result, null, 2)
+          : makeNextSteps(
+              result,
+              "workspace slice",
+              makeTenancyNextStepLines(),
+            ),
+      );
+    };
+  },
+});
+
+const makeInboxCommand = buildCommand<MakeFlags, [], CliContext>({
+  docs: {
+    brief: "Generate an in-app inbox notifications slice.",
+  },
+  parameters: {
+    flags: makeFlagParameters,
+  },
+  loader: async () => {
+    const { makeInbox, makeInboxNextStepLines } = await import("./make.js");
+
+    return async function runMakeInbox(this: CliContext, flags: MakeFlags) {
+      const result = await makeInbox({
+        force: Boolean(flags.force),
+        dryRun: Boolean(flags.dryRun),
+      });
+      writeOutput(
+        this,
+        flags.json
+          ? JSON.stringify(result, null, 2)
+          : makeNextSteps(
+              result,
+              "notifications slice",
+              makeInboxNextStepLines(),
+            ),
       );
     };
   },
@@ -1283,6 +1485,7 @@ const makeRoutes = buildRouteMap({
       makeFactoryNextSteps,
     ),
     feature: makeFeatureCommand,
+    inbox: makeInboxCommand,
     job: simpleMakeCommand(
       "makeJob",
       "Generate a feature job.",
@@ -1318,6 +1521,7 @@ const makeRoutes = buildRouteMap({
       "Generate a feature operational task.",
       makeTaskNextSteps,
     ),
+    tenancy: makeTenancyCommand,
     test: simpleMakeCommand(
       "makeTest",
       "Generate a use case test.",
@@ -1344,6 +1548,7 @@ const rootRoutes = buildRouteMap({
 Run npm create beignet@latest (or bun create beignet) to scaffold a new app.`,
   },
   routes: {
+    check: checkCommand,
     completion: completionRoutes,
     create: createCommand,
     db: dbRoutes,
@@ -1357,6 +1562,10 @@ Run npm create beignet@latest (or bun create beignet) to scaffold a new app.`,
     schedule: scheduleRoutes,
     task: taskRoutes,
   },
+  aliases: {
+    // The singular form is a common near-miss for the providers commands.
+    provider: "providers",
+  },
 });
 
 const cli = buildApplication(rootRoutes, {
@@ -1432,6 +1641,7 @@ type DatabaseSchemaGenerateNextStepsResult = {
 type AppTaskRunNextStepsResult = {
   name: string;
   durationMs: number;
+  tenant?: string;
   output: unknown;
 };
 
@@ -1463,7 +1673,9 @@ function appTaskRunNextSteps(result: AppTaskRunNextStepsResult): string {
       ? "undefined"
       : JSON.stringify(result.output, null, 2);
 
-  return `Ran task ${result.name} in ${result.durationMs}ms
+  const tenant = result.tenant ? `\nTenant: ${result.tenant}` : "";
+
+  return `Ran task ${result.name} in ${result.durationMs}ms${tenant}
 
 Output:
 ${output}`;
@@ -1545,19 +1757,13 @@ ${openStep}
 
 Inspect the app:
   ${cli} routes
-  ${run} lint
-  ${cli} lint
-  ${cli} doctor
+  ${cli} check
 
 Generate a feature:
   ${cli} make feature projects
   ${cli} db generate
   ${cli} db migrate
-  ${run} test
-  ${run} lint
-  ${run} typecheck
-  ${cli} lint
-  ${cli} doctor`;
+  ${cli} check`;
 }
 
 function packageRunnerFromPackageManager(pm: PackageManager): string {
@@ -1617,6 +1823,20 @@ Next steps:
 ${steps.map((step) => `  ${step}`).join("\n")}`;
 }
 
+function providerAddNextSteps(result: AddProviderPresetResult): string {
+  const { changedFiles, skippedFiles } = changedFileLines(result);
+  const prefix = result.dryRun ? "Would add" : "Added";
+
+  return `${prefix} ${result.name} provider preset in ${result.targetDir}
+
+Changed files:
+${changedFiles || "  none"}
+${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
+
+Next steps:
+${result.nextSteps.map((step) => `  ${step}`).join("\n")}`;
+}
+
 function makeResourceNextSteps(result: MakeNextStepsResult): string {
   return makeNextSteps(result, "resource", [
     "Use make resource when the feature maps cleanly to a REST resource with repository-backed persistence.",
@@ -1754,15 +1974,6 @@ function makeNotificationNextSteps(result: MakeNextStepsResult): string {
   ]);
 }
 
-function makePaymentsNextSteps(result: MakeNextStepsResult): string {
-  return makeNextSteps(result, "billing slice", [
-    "Set BILLING_TEAM_PRICE_ID in .env.local to the provider price ID for your team plan.",
-    "Run beignet db generate and beignet db migrate so billing_accounts exists before handling webhooks.",
-    "Use createMemoryPaymentsProvider() for local development, then swap server/providers.ts to stripePaymentsProvider when STRIPE_SECRET_KEY and STRIPE_WEBHOOK_SECRET are configured.",
-    "Run your app's test, lint, and typecheck commands, then beignet lint and beignet doctor.",
-  ]);
-}
-
 function makeOutboxNextSteps(result: MakeNextStepsResult): string {
   return makeNextSteps(result, "outbox runtime", [
     "Set CRON_SECRET in your deployment and call /api/cron/outbox/drain from a scheduler with Authorization: Bearer $CRON_SECRET.",

package/src/inspect.ts

@@ -19,6 +19,10 @@ import {
   formatGithubAnnotation,
   type GithubAnnotationSeverity,
 } from "./github-annotations.js";
+import {
+  providersFilePath,
+  wireListenersProviderSource,
+} from "./make/shared.js";
 import {
   detectedProviderVariants,
   diagnosticPackageJsonFile,
@@ -269,6 +273,14 @@ export async function applyDoctorFixes(
     ...(await fixUnregisteredOutboxEntries(targetDir, files, drift, config)),
   );
 
+  const listenerFix = await fixUnregisteredListeners(
+    targetDir,
+    files,
+    drift,
+    config,
+  );
+  if (listenerFix) fixes.push(listenerFix);
+
   const openApiFix = await fixDirectOpenApiArrayDrift(
     targetDir,
     files,
@@ -986,6 +998,24 @@ function parseRouteExports(
   const imports = parseNamedImports(source, config);
   const exportRegex =
     /export const\s+(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s*=\s*([^;\n]+)/g;
+  const apiRouteExportRegex =
+    /export const\s*\{([^}]+)\}\s*=\s*createApiRoute\s*\(/g;
+
+  for (const match of source.matchAll(apiRouteExportRegex)) {
+    for (const member of match[1].split(",")) {
+      const parts = member.split(":");
+      const method = (parts[1] ?? parts[0])?.trim();
+      if (!method || !isHttpMethod(method)) continue;
+
+      exports.push({
+        method,
+        handlerFile,
+        contractRef: routePath,
+        catchAllPrefix: catchAllRoutePrefix(routePath),
+        source: "next-route",
+      });
+    }
+  }
 
   for (const match of source.matchAll(exportRegex)) {
     const method = match[1] as HttpMethod;
@@ -1384,7 +1414,7 @@ async function inspectDiagnostics(
       convention,
       contracts,
     )),
-    ...(await inspectServerlessFootguns(targetDir, files)),
+    ...(await inspectServerlessFootguns(targetDir, files, config, convention)),
     ...(await inspectProductionReadiness(targetDir, files, config, convention)),
     ...(await inspectFeatureArtifactDrift(
       targetDir,
@@ -3773,6 +3803,8 @@ function isWorkflowTestFile(file: string): boolean {
 async function inspectServerlessFootguns(
   targetDir: string,
   files: string[],
+  config: ResolvedBeignetConfig,
+  convention: InspectConvention,
 ): Promise<InspectDiagnostic[]> {
   const diagnostics: InspectDiagnostic[] = [];
 
@@ -3792,6 +3824,19 @@ async function inspectServerlessFootguns(
       /(^|\/)[^/]*provider[^/]*\.ts$/.test(file);
     const source = await readFile(path.join(targetDir, file), "utf8");
 
+    if (
+      convention.resourceGenerator &&
+      isNextRouteFile(file, config) &&
+      importsEagerServer(source, file, files, config)
+    ) {
+      diagnostics.push({
+        severity: "warning",
+        code: "BEIGNET_NEXT_ROUTE_EAGER_SERVER_IMPORT",
+        file,
+        message: `${file} imports the eager server singleton. Next.js imports route modules during production builds, so use createNextServerLoader(...) in ${config.paths.server} and pass getServer to createApiRoute(...), createHealthRoute(...), or the focused route helper instead.`,
+      });
+    }
+
     if (
       isInfraOrServerFile &&
       isProviderFile &&
@@ -3850,6 +3895,37 @@ async function inspectServerlessFootguns(
   return diagnostics;
 }
 
+function isNextRouteFile(file: string, config: ResolvedBeignetConfig): boolean {
+  const routesPath = directoryPath(config.paths.routes);
+
+  return (
+    file.startsWith(`${routesPath}/`) &&
+    file.endsWith("/route.ts") &&
+    !file.endsWith(".test.ts")
+  );
+}
+
+function importsEagerServer(
+  source: string,
+  importerFile: string,
+  files: string[],
+  config: ResolvedBeignetConfig,
+): boolean {
+  const importRegex = /import\s+\{([^}]+)\}\s+from\s+["']([^"']+)["']/g;
+
+  for (const match of source.matchAll(importRegex)) {
+    const members = match[1]
+      .split(",")
+      .map((member) => parseImportMember(member));
+    if (!members.some((member) => member?.importedName === "server")) continue;
+
+    const sourceFile = sourceFileFromImport(match[2], importerFile, files);
+    if (sourceFile === config.paths.server) return true;
+  }
+
+  return false;
+}
+
 function hasOutboxRegistry(files: string[]): boolean {
   return files.some(isOutboxRegistryFile);
 }
@@ -4076,7 +4152,9 @@ async function inspectDatabaseLifecycleDrift(
     {
       script: "db:seed",
       command: "seed",
-      file: `${infrastructurePath}/db/seed.ts`,
+      // The seed entrypoint lives beside the server runtime because it boots
+      // the app through getServer(), which infra/ must not import.
+      file: `${directoryPath(path.dirname(config.paths.server))}/seed.ts`,
       code: "BEIGNET_DB_SEED_ENTRYPOINT_MISSING",
     },
     {
@@ -5396,6 +5474,94 @@ async function fixUnregisteredTasks(
   });
 }
 
+/**
+ * Wire fully unregistered feature listener registries into the providers
+ * file with the same `<registry>Provider` block `beignet make listener`
+ * generates, so both write paths stay byte-compatible.
+ *
+ * Bails without writing when the providers file or its exported array is
+ * missing or customized, when the app has no eventBus port to register
+ * against, or when the registry name is already imported from another file.
+ * The diagnostic stays in every bail case.
+ */
+async function fixUnregisteredListeners(
+  targetDir: string,
+  files: string[],
+  drift: WorkflowRegistrationDrift,
+  config: ResolvedBeignetConfig,
+): Promise<InspectFix | undefined> {
+  const candidates = drift.listeners.unregistered.filter(
+    (entry) => entry.fullyUnregistered,
+  );
+  if (candidates.length === 0) return undefined;
+
+  const providersFile = providersFilePath(config);
+  const contextFile = normalizePath(
+    path.join(path.dirname(config.paths.server), "context.ts"),
+  );
+  const wiringDependencies = [
+    providersFile,
+    contextFile,
+    config.paths.appContext,
+    config.paths.ports,
+  ];
+  if (wiringDependencies.some((file) => !files.includes(file))) {
+    return undefined;
+  }
+
+  // The generated wiring registers listeners on ports.eventBus; without the
+  // port the fix would produce code that cannot typecheck.
+  const portsSource = await readFile(
+    path.join(targetDir, config.paths.ports),
+    "utf8",
+  );
+  if (!/\beventBus\s*[:?]/.test(portsSource)) return undefined;
+
+  const providersPath = path.join(targetDir, providersFile);
+  const original = await readFile(providersPath, "utf8");
+  let next = original;
+  const registeredNames: string[] = [];
+
+  for (const { registry } of candidates) {
+    const imported = parseNamedImportSources(next).get(registry.registryName);
+    if (imported) {
+      const importedFile = sourceFileFromImport(
+        imported.sourcePath,
+        providersFile,
+        files,
+      );
+      if (importedFile !== registry.indexFile) return undefined;
+    }
+
+    const result = wireListenersProviderSource(next, {
+      registryName: registry.registryName,
+      featureKebab: listenerFeatureKebab(registry.indexFile),
+      listenerModule: `@/${modulePath(registry.indexFile)}`,
+      config,
+    });
+    if (result.kind === "missing") return undefined;
+    if (result.kind === "updated") {
+      next = result.source;
+      registeredNames.push(registry.registryName);
+    }
+  }
+
+  if (next === original || registeredNames.length === 0) return undefined;
+
+  await writeFile(providersPath, next);
+  return {
+    code: "BEIGNET_LISTENER_UNREGISTERED",
+    file: providersFile,
+    message: `Registered ${registeredNames.join(", ")} with registerListeners(...) in ${providersFile}.`,
+  };
+}
+
+function listenerFeatureKebab(indexFile: string): string {
+  return path.posix.basename(
+    path.posix.dirname(path.posix.dirname(normalizePath(indexFile))),
+  );
+}
+
 async function fixUnregisteredOutboxEntries(
   targetDir: string,
   files: string[],