@beignet/cli 0.0.37 → 0.0.39

package/src/mcp.ts

@@ -78,13 +78,13 @@ const makeInputSchema = {
     .string()
     .optional()
     .describe(
-      "Artifact name. Required except for inbox, outbox, payments, and tenancy. Feature-owned artifacts use feature-scoped paths such as posts/backfill.",
+      "Artifact name. Required except for inbox, outbox, payments, and tenancy. Feature-owned artifacts use identities such as posts.backfill.",
     ),
   with: z
     .array(z.enum(makeFeatureAddonChoices))
     .optional()
     .describe(
-      "feature only: add feature-owned artifacts such as policy, factories, seeds, events, listeners, jobs, notifications, schedules, tasks, ui, and uploads.",
+      "feature only: add feature-owned artifacts such as policy, factory, seed, event, listener, job, notification, schedule, task, ui, and upload.",
     ),
   recipe: z
     .enum(makeFeatureRecipeChoices)
@@ -94,7 +94,7 @@ const makeInputSchema = {
     .string()
     .optional()
     .describe(
-      "listener only (required): event to listen to, for example posts/published.",
+      "listener only (required): event to listen to, for example posts.published.",
     ),
   cron: z
     .string()
@@ -108,13 +108,19 @@ const makeInputSchema = {
     .boolean()
     .optional()
     .describe("schedule only: generate a Next.js cron route for the schedule."),
-  auth: z
+  ui: z
+    .boolean()
+    .optional()
+    .describe(
+      "upload only: generate a typed React upload client and component.",
+    ),
+  authorization: z
     .boolean()
     .optional()
     .describe(
       "resource only: generate policy metadata and use-case authorization checks for mutating routes.",
     ),
-  tenant: z
+  tenantScoped: z
     .boolean()
     .optional()
     .describe(
@@ -163,8 +169,9 @@ type MakeToolInput = {
   cron?: string;
   timezone?: string;
   route?: boolean;
-  auth?: boolean;
-  tenant?: boolean;
+  ui?: boolean;
+  authorization?: boolean;
+  tenantScoped?: boolean;
   events?: boolean;
   softDelete?: boolean;
   force?: boolean;
@@ -268,7 +275,7 @@ async function runMakeTool(
     case "listener":
       if (!input.event) {
         throw new Error(
-          "make listener requires an event, for example event: posts/published.",
+          "make listener requires an event, for example event: posts.published.",
         );
       }
       return makeListener({ ...base, event: input.event });
@@ -281,8 +288,8 @@ async function runMakeTool(
     case "resource":
       return makeResource({
         ...base,
-        auth: input.auth,
-        tenant: input.tenant,
+        authorization: input.authorization,
+        tenantScoped: input.tenantScoped,
         events: input.events,
         softDelete: input.softDelete,
       });
@@ -300,7 +307,7 @@ async function runMakeTool(
     case "test":
       return makeTest(base);
     case "upload":
-      return makeUpload(base);
+      return makeUpload({ ...base, ui: input.ui });
     case "use-case":
       return makeUseCase(base);
   }
@@ -418,7 +425,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
     "make",
     {
       description:
-        "Generate Beignet app files for one artifact: adapter, contract, event, factory, feature, inbox, job, listener, notification, outbox, payments, policy, port, resource, schedule, seed, task, tenancy, test, upload, or use-case. Generators auto-register artifacts, so doctor stays clean. Options by artifact: feature accepts with (addons); resource accepts auth, tenant, events, softDelete; listener requires event; schedule accepts cron, timezone, route. All artifacts accept force and dryRun. Returns created, updated, and skipped files as JSON.",
+        "Generate Beignet app files for one artifact: adapter, contract, event, factory, feature, inbox, job, listener, notification, outbox, payments, policy, port, resource, schedule, seed, task, tenancy, test, upload, or use-case. Generators auto-register artifacts, so doctor stays clean. Options by artifact: feature accepts with (addons); resource accepts authorization, tenantScoped, events, softDelete; listener requires event; schedule accepts cron, timezone, route; upload accepts ui. All artifacts accept force and dryRun. Returns created, updated, and skipped files as JSON.",
       inputSchema: makeInputSchema,
     },
     async (input) =>
@@ -430,7 +437,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
   server.registerTool(
     "provider_add",
     {
-      description: `Add a Beignet provider setup preset to this app. Updates dependencies, provider registration, app port wiring, .env.example, and docs/integrations.md. Presets: ${providerPresetDescription}. Supports dryRun.`,
+      description: `Add a Beignet provider setup preset to this app. Updates dependencies, provider registration, app port wiring, .env.example, and docs/providers.md. Presets: ${providerPresetDescription}. Supports dryRun.`,
       inputSchema: providerAddInputSchema,
     },
     async (input) =>

package/src/operational-error-reporting.ts

@@ -0,0 +1,60 @@
+import type {
+  ErrorReporterPort,
+  ErrorReportOptions,
+} from "@beignet/core/error-reporting";
+
+export type OperationalErrorReportingContext = {
+  requestId?: string;
+  traceId?: string;
+  ports?: {
+    errorReporter?: ErrorReporterPort;
+  };
+};
+
+export async function reportOperationalFailure(args: {
+  ctx: OperationalErrorReportingContext;
+  error: unknown;
+  reportOptions: ErrorReportOptions;
+}): Promise<void> {
+  const reporter = args.ctx.ports?.errorReporter;
+  if (!reporter) return;
+
+  try {
+    const { tryReportException } = await import(
+      "@beignet/core/error-reporting"
+    );
+    await tryReportException({
+      reporter,
+      error: args.error,
+      reportOptions: {
+        requestId: args.ctx.requestId,
+        traceId: args.ctx.traceId,
+        ...args.reportOptions,
+      },
+    });
+  } catch {
+    // Reporting must not replace the operational command failure.
+  }
+}
+
+export async function flushOperationalErrorReporter(
+  ctx: OperationalErrorReportingContext,
+  timeoutMs = 1000,
+): Promise<void> {
+  const reporter = ctx.ports?.errorReporter;
+  if (!reporter) return;
+
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    await Promise.race([
+      reporter.flush({ timeoutMs }),
+      new Promise<boolean>((resolve) => {
+        timeout = setTimeout(() => resolve(false), timeoutMs);
+      }),
+    ]);
+  } catch {
+    // Reporting shutdown must not replace the operational command result.
+  } finally {
+    if (timeout !== undefined) clearTimeout(timeout);
+  }
+}

package/src/outbox.ts

@@ -1,5 +1,6 @@
 import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
+import type { ErrorReporterPort } from "@beignet/core/error-reporting";
 import type {
   DrainOutboxOptions,
   DrainOutboxResult,
@@ -11,6 +12,10 @@ import type {
 } from "@beignet/core/outbox";
 import { createJiti } from "jiti";
 import { loadBeignetConfig, normalizePath } from "./config.js";
+import {
+  flushOperationalErrorReporter,
+  reportOperationalFailure,
+} from "./operational-error-reporting.js";
 
 /**
  * Options for running one bounded outbox drain pass.
@@ -159,6 +164,7 @@ type OutboxDrainPorts = {
   logger?: OutboxDrainLogger;
   devtools?: OutboxDrainInstrumentation;
   instrumentation?: OutboxDrainInstrumentation;
+  errorReporter?: ErrorReporterPort;
 };
 
 type OutboxDrainContext = {
@@ -240,6 +246,60 @@ export async function runOutboxDrain(
           attempts: message.attempts,
         });
       },
+      onDeadLetter(error, message) {
+        return reportOperationalFailure({
+          ctx,
+          error,
+          reportOptions: {
+            level: "error",
+            mechanism: "beignet.outbox.cli",
+            handled: false,
+            tags: {
+              "beignet.kind": "outbox",
+              "beignet.outbox.kind": message.kind,
+              "beignet.outbox.name": message.name,
+              "beignet.outbox.outcome": "deadLettered",
+            },
+            contexts: {
+              outbox: {
+                messageId: message.id,
+                kind: message.kind,
+                name: message.name,
+                attempts: message.attempts,
+                maxAttempts: message.maxAttempts,
+                outcome: "deadLettered",
+              },
+            },
+          },
+        });
+      },
+      onSettlementError(settlementError, message) {
+        return reportOperationalFailure({
+          ctx,
+          error: settlementError,
+          reportOptions: {
+            level: "error",
+            mechanism: "beignet.outbox.cli",
+            handled: false,
+            tags: {
+              "beignet.kind": "outbox",
+              "beignet.outbox.kind": message.kind,
+              "beignet.outbox.name": message.name,
+              "beignet.outbox.outcome": "settlementFailed",
+            },
+            contexts: {
+              outbox: {
+                messageId: message.id,
+                kind: message.kind,
+                name: message.name,
+                attempts: message.attempts,
+                maxAttempts: message.maxAttempts,
+                outcome: "settlementFailed",
+              },
+            },
+          },
+        });
+      },
     });
 
     await recordOutboxDrain(ctx, result);
@@ -251,7 +311,24 @@ export async function runOutboxDrain(
       result,
       durationMs: Math.round(performance.now() - startedAt),
     };
+  } catch (error) {
+    await reportOperationalFailure({
+      ctx,
+      error,
+      reportOptions: {
+        level: "error",
+        mechanism: "beignet.outbox.cli",
+        handled: false,
+        tags: {
+          "beignet.kind": "outbox",
+          "beignet.outbox.outcome": "drainFailed",
+        },
+        contexts: { outbox: { outcome: "drainFailed" } },
+      },
+    });
+    throw error;
   } finally {
+    await flushOperationalErrorReporter(ctx);
     await outboxModule.stopOutboxDrainContext?.(ctx, contextArgs);
   }
 }