@beignet/cli 0.0.48 → 0.0.49

package/src/make/inbox.ts

@@ -518,9 +518,9 @@ export const inboxNotificationSchema = z.object({
 });
 
 export const listInboxQuerySchema = z.object({
-\tlimit: z.coerce.number().int().min(1).max(50).default(20),
+\tlimit: z.number().int().min(1).max(50).default(20),
 \tcursor: z.string().min(1).optional(),
-\tunread: z.coerce.boolean().default(false),
+\tunread: z.boolean().default(false),
 });
 
 export const listInboxOutputSchema = z.object({
@@ -659,7 +659,7 @@ export function inboxContractsFile(config: ResolvedBeignetConfig): string {
   );
   const errorsModule = aliasModule(resourceSharedErrorsPath(config));
 
-  return `import { defineContractGroup } from "@beignet/core/contracts";
+  return `import { defineContractGroup, defineQueryTransport, query } from "@beignet/core/contracts";
 import {
 \tinboxNotificationSchema,
 \tlistInboxOutputSchema,
@@ -674,7 +674,14 @@ const inbox = defineContractGroup().namespace("inbox").prefix("/api/inbox");
 
 export const listInbox = inbox
 \t.get("/")
-\t.query(listInboxQuerySchema)
+\t.query(
+\t\tlistInboxQuerySchema,
+\t\tdefineQueryTransport({
+\t\t\tlimit: query.integer(),
+\t\t\tcursor: query.string(),
+\t\t\tunread: query.boolean(),
+\t\t}),
+\t)
 \t.meta({ auth: "required" })
 \t.errors({ Unauthorized: errors.Unauthorized })
 \t.responses({

package/src/make/payments.ts

@@ -862,7 +862,7 @@ export function isBillingAccountActive(
 export function billingContractsFile(
   idempotencyScope: "actor" | "actor-tenant" = "actor",
 ): string {
-  return `import { defineContractGroup } from "@beignet/core/contracts";
+  return `import { defineContractGroup, defineQueryTransport } from "@beignet/core/contracts";
 import { z } from "zod";
 import {
 \tbillingStatusOutputSchema,
@@ -882,7 +882,7 @@ const checkoutBilling = billing.headers(checkoutHeadersSchema);
 
 export const getBillingStatus = billing
 \t.get("/")
-\t.query(z.object({}))
+\t.query(z.object({}), defineQueryTransport({}))
 \t.meta({ auth: "required" })
 \t.errors({ Unauthorized: errors.Unauthorized })
 \t.responses({

package/src/make.ts

@@ -2,6 +2,8 @@ import { randomBytes } from "node:crypto";
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import ts from "typescript";
+import { analyzePortWiringFiles } from "./analysis/port-wiring.js";
+import { listProjectFiles } from "./analysis/workspace.js";
 import type { MakeFeatureAddon, MakeFeatureRecipe } from "./choices.js";
 import {
   type BeignetConfig,
@@ -1084,6 +1086,10 @@ export async function makeJob(options: MakeJobOptions): Promise<MakeJobResult> {
   await assertFeatureArtifactApp(targetDir, config, "job");
   await assertServerRuntimeApp(targetDir, config, "job");
   await updateOutboxPortWiring(targetDir, config, { dryRun: true });
+  const jobDispatcherPlan = await planInlineJobDispatcherWiring(
+    targetDir,
+    config,
+  );
   const outboxDrainPlan = await planOutboxDrainWiring(targetDir, config, {
     force: Boolean(options.force),
   });
@@ -1114,6 +1120,9 @@ export async function makeJob(options: MakeJobOptions): Promise<MakeJobResult> {
   await applyOutboxDrainWiring(result, targetDir, outboxDrainPlan, {
     dryRun: Boolean(options.dryRun),
   });
+  await applyInlineJobDispatcherWiring(result, targetDir, jobDispatcherPlan, {
+    dryRun: Boolean(options.dryRun),
+  });
   await applyOutboxPortWiring(result, targetDir, config, {
     dryRun: Boolean(options.dryRun),
   });
@@ -1124,6 +1133,201 @@ export async function makeJob(options: MakeJobOptions): Promise<MakeJobResult> {
   return result;
 }
 
+type InlineJobDispatcherWiringPlan = {
+  changes: { path: string; before: string; after: string }[];
+};
+
+async function planInlineJobDispatcherWiring(
+  targetDir: string,
+  config: ResolvedBeignetConfig,
+): Promise<InlineJobDispatcherWiringPlan> {
+  const portsFile = config.paths.ports;
+  const portWiringFile = config.paths.portWiring;
+  const providersFile = providersFilePath(config);
+  const ports = await readFile(path.join(targetDir, portsFile), "utf8");
+  const portWiring = await readFile(
+    path.join(targetDir, portWiringFile),
+    "utf8",
+  );
+  const analysis = await analyzePortWiringFiles({
+    targetDir,
+    files: await listProjectFiles(targetDir),
+    config,
+  });
+  const declaresJobs = analysis.declared.has("jobs");
+  const wiresJobs = analysis.bound.has("jobs") || analysis.deferred.has("jobs");
+
+  if (declaresJobs && wiresJobs) {
+    return { changes: [] };
+  }
+  if (!declaresJobs && analysis.declarationIndeterminate) {
+    throw new Error(
+      `Could not prove whether AppPorts in ${portsFile} declares the jobs port. Preserve the app's custom port type and add jobs: JobDispatcherPort manually before running make job.`,
+    );
+  }
+  if (!wiresJobs && analysis.indeterminate) {
+    throw new Error(
+      `Could not prove how the jobs port is wired in ${portWiringFile}. Preserve the app's custom dispatcher by binding or deferring "jobs" in a statically inspectable definePorts(...) object before running make job.`,
+    );
+  }
+
+  let nextPorts = ports;
+  if (!declaresJobs && !analysis.appPortsInferredFromWiring) {
+    nextPorts = addNamedTypeImport(
+      nextPorts,
+      "JobDispatcherPort",
+      "@beignet/core/ports",
+    );
+    nextPorts = insertTypeProperty(
+      nextPorts,
+      "AppPorts",
+      "jobs: JobDispatcherPort;",
+      `Could not find AppPorts in ${portsFile}. Add jobs: JobDispatcherPort manually and wire a dispatcher, or restore the generated ports file before running make job.`,
+    );
+  }
+
+  if (wiresJobs) {
+    return {
+      changes:
+        ports === nextPorts
+          ? []
+          : [{ path: portsFile, before: ports, after: nextPorts }],
+    };
+  }
+
+  const nextPortWiring = appendDeferredPortKey(portWiring, "jobs");
+  if (nextPortWiring === portWiring) {
+    throw new Error(
+      `Could not find the deferred port list in ${portWiringFile}. Add "jobs" manually and wire a dispatcher, or restore the generated port wiring file before running make job.`,
+    );
+  }
+
+  const providersPath = path.join(targetDir, providersFile);
+  const providers = await readOptionalFile(providersPath);
+  if (providers === undefined) {
+    throw new Error(
+      `Could not find ${providersFile}. Register an inline or provider-backed jobs dispatcher manually, or restore the generated providers file before running make job.`,
+    );
+  }
+  let nextProviders = addNamedImport(
+    providers,
+    "createInlineJobDispatcher",
+    "@beignet/core/jobs",
+  );
+  nextProviders = addNamedImport(
+    nextProviders,
+    "createProvider",
+    "@beignet/core/providers",
+  );
+  nextProviders = addNamedTypeImport(
+    nextProviders,
+    "AppContext",
+    aliasModule(config.paths.appContext),
+  );
+  nextProviders = addNamedTypeImport(
+    nextProviders,
+    "AppPorts",
+    aliasModule(config.paths.ports),
+  );
+  nextProviders = addNamedTypeImport(
+    nextProviders,
+    "AppServiceContextInput",
+    aliasModule(path.join(path.dirname(config.paths.server), "context.ts")),
+  );
+
+  const providerName = "inlineJobsProvider";
+  const generatedProviderMarker = "// beignet:generated-inline-jobs-provider";
+  const providersSourceFile = ts.createSourceFile(
+    providersFile,
+    nextProviders,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.TS,
+  );
+  const providerDeclaration = providersSourceFile.statements
+    .filter(ts.isVariableStatement)
+    .flatMap((statement) => [...statement.declarationList.declarations])
+    .find(
+      (declaration) =>
+        ts.isIdentifier(declaration.name) &&
+        declaration.name.text === providerName,
+    );
+  const providerDeclarationExists = providerDeclaration !== undefined;
+  const providerIsGenerated = providerDeclaration
+    ? nextProviders
+        .slice(0, providerDeclaration.getStart(providersSourceFile))
+        .trimEnd()
+        .endsWith(generatedProviderMarker)
+    : false;
+  if (providerDeclarationExists && !providerIsGenerated) {
+    throw new Error(
+      `Could not install the generated inline jobs dispatcher because ${providerName} already exists in ${providersFile}. Rename the app-owned declaration or wire its jobs port explicitly before running make job.`,
+    );
+  }
+  if (!providerDeclarationExists) {
+    const definition = `// beignet:generated-inline-jobs-provider
+const ${providerName} = createProvider<
+	{},
+	AppContext,
+	AppServiceContextInput
+>()({
+	name: "inline-jobs",
+	setup({ createServiceContext }): { ports: Pick<AppPorts, "jobs"> } {
+		return {
+			ports: {
+				jobs: createInlineJobDispatcher<AppContext>({
+					ctx: () => createServiceContext(undefined),
+				}),
+			},
+		};
+	},
+});
+`;
+    const inserted = nextProviders.replace(
+      /\nexport const providers = \[/,
+      `\n${definition}\nexport const providers = [`,
+    );
+    if (inserted === nextProviders) {
+      throw new Error(
+        `Could not find the exported providers array in ${providersFile}. Register an inline or provider-backed jobs dispatcher manually, or restore the generated providers file before running make job.`,
+      );
+    }
+    nextProviders = inserted;
+  }
+  const appended = appendToNamedArray(nextProviders, "providers", providerName);
+  if (appended.kind === "missing") {
+    throw new Error(
+      `Could not find the exported providers array in ${providersFile}. Register ${providerName} manually, or restore the generated providers file before running make job.`,
+    );
+  }
+  if (appended.kind === "updated") nextProviders = appended.source;
+
+  return {
+    changes: [
+      { path: portsFile, before: ports, after: nextPorts },
+      { path: portWiringFile, before: portWiring, after: nextPortWiring },
+      { path: providersFile, before: providers, after: nextProviders },
+    ].filter((change) => change.before !== change.after),
+  };
+}
+
+async function applyInlineJobDispatcherWiring(
+  result: MakeResult,
+  targetDir: string,
+  plan: InlineJobDispatcherWiringPlan,
+  options: { dryRun: boolean },
+): Promise<void> {
+  for (const change of plan.changes) {
+    if (!options.dryRun) {
+      await writeFile(path.join(targetDir, change.path), change.after);
+    }
+    if (!result.updatedFiles.includes(change.path)) {
+      result.updatedFiles.push(change.path);
+    }
+    if (!result.files.includes(change.path)) result.files.push(change.path);
+  }
+}
+
 export async function makeTask(
   options: MakeTaskOptions,
 ): Promise<MakeTaskResult> {
@@ -3983,8 +4187,8 @@ export function decode${names.singularPascal}Cursor(cursor: string): ${names.sin
 
 export const List${names.pluralPascal}InputSchema = z
 	.object({
-		limit: z.coerce.number().int().min(1).max(100).default(20),
-		cursor: z.string().nullable().default(null),
+		limit: z.number().int().min(1).max(100).default(20),
+		cursor: z.string().optional().transform((value) => value ?? null),
 		name: z.string().trim().min(1).max(120).optional(),
 		sortBy: ${names.singularPascal}SortBySchema.default("createdAt"),
 		sortDirection: ${names.singularPascal}SortDirectionSchema.default("desc"),
@@ -4840,7 +5044,7 @@ function contractFile(
   mode: ResourceGenerationMode,
   options: ResourceGenerationOptions,
 ): string {
-  return `import { defineContractGroup } from "@beignet/core/contracts";
+  return `import { defineContractGroup, defineQueryTransport, query } from "@beignet/core/contracts";
 import { z } from "zod";
 ${mode === "resource" ? `import { errors } from "${aliasModule(resourceSharedErrorsPath(config))}";\n` : ""}import {
 	Create${names.singularPascal}InputSchema,
@@ -4863,7 +5067,16 @@ const ${names.pluralCamel} = defineContractGroup()
 
 export const list${names.pluralPascal} = ${names.pluralCamel}
 	.get("/api/${names.pluralKebab}")
-	.query(List${names.pluralPascal}InputSchema)
+	.query(
+		List${names.pluralPascal}InputSchema,
+		defineQueryTransport({
+			limit: query.integer(),
+			cursor: query.string(),
+			name: query.string(),
+			sortBy: query.string(),
+			sortDirection: query.string(),
+		}),
+	)
 	.responses({
 		200: List${names.pluralPascal}OutputSchema,
 	});
@@ -4908,7 +5121,7 @@ ${options.authorization ? `\t.meta({\n\t\tauth: "required",\n\t\tauthorization:
 }
 
 function standaloneContractFile(names: ResourceNames): string {
-  return `import { defineContractGroup } from "@beignet/core/contracts";
+  return `import { defineContractGroup, defineQueryTransport, query } from "@beignet/core/contracts";
 import { z } from "zod";
 
 const ErrorResponseSchema = z.object({
@@ -4932,8 +5145,12 @@ export const list${names.pluralPascal} = ${names.pluralCamel}
 	.get("/api/${names.pluralKebab}")
 	.query(
 		z.object({
-			limit: z.coerce.number().int().min(1).max(100).default(20),
-			offset: z.coerce.number().int().min(0).default(0),
+			limit: z.number().int().min(1).max(100).default(20),
+			offset: z.number().int().min(0).default(0),
+		}),
+		defineQueryTransport({
+			limit: query.integer(),
+			offset: query.integer(),
 		}),
 	)
 	.responses({
@@ -6038,7 +6255,7 @@ ${options.authorization ? `\t\t\t\tgate: initialPorts.gate,\n` : ""}
 		);
 		const secondPage = await tester.run(
 			list${names.pluralPascal}UseCase,
-			{ limit: 2, cursor: firstPage.page.nextCursor },
+			{ limit: 2, cursor: firstPage.page.nextCursor! },
 			{ ctx },
 		);
 		const nameAscendingPage = await tester.run(

package/src/mcp.ts

@@ -1,11 +1,8 @@
 import { open, realpath } from "node:fs/promises";
 import path from "node:path";
-import {
-  McpServer,
-  ResourceTemplate,
-} from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/server";
+import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
+import { z } from "zod/v4";
 import { mapApp, projectAppMap } from "./app-map.js";
 import { appMapNodeKinds } from "./app-map-schema.js";
 import { checkApp } from "./check.js";
@@ -680,7 +677,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
         openWorldHint: true,
       },
     },
-    async (input, extra) =>
+    async (input, ctx) =>
       safeToolResult(async () =>
         jsonResult(
           await checkApp({
@@ -689,7 +686,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
             preflightConnect: input.preflightConnect ?? false,
             connectTimeoutMs: input.connectTimeoutMs,
             scriptTimeoutMs: input.timeoutMs ?? defaultMcpCheckTimeoutMs,
-            signal: extra.signal,
+            signal: ctx.mcpReq.signal,
           }),
         ),
       ),
@@ -727,7 +724,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
         openWorldHint: true,
       },
     },
-    async (input, extra) =>
+    async (input, ctx) =>
       safeToolResult(async () =>
         jsonResult(
           await runDatabaseCommand({
@@ -735,7 +732,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
             cwd,
             captureOutput: true,
             maxOutputBytes: defaultDatabaseCommandMaxOutputBytes,
-            signal: extra.signal,
+            signal: ctx.mcpReq.signal,
             timeoutMs: input.timeoutMs ?? defaultDatabaseCommandTimeoutMs,
             dryRun: input.dryRun,
           }),
@@ -766,14 +763,14 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
         openWorldHint: true,
       },
     },
-    async (input, extra) =>
+    async (input, ctx) =>
       safeToolResult(async () =>
         jsonResult(
           await runDatabaseStatus({
             cwd,
             captureOutput: true,
             maxOutputBytes: defaultDatabaseCommandMaxOutputBytes,
-            signal: extra.signal,
+            signal: ctx.mcpReq.signal,
             timeoutMs: input.timeoutMs ?? defaultDatabaseCommandTimeoutMs,
           }),
         ),
@@ -818,7 +815,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
         openWorldHint: false,
       },
     },
-    async (input, extra) =>
+    async (input, ctx) =>
       safeToolResult(async () =>
         jsonResult(
           await syncDatabaseSchema({
@@ -827,7 +824,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
             tables: input.tables,
             output: input.output,
             dryRun: input.dryRun,
-            signal: extra.signal,
+            signal: ctx.mcpReq.signal,
           }),
         ),
       ),
@@ -846,7 +843,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
         openWorldHint: true,
       },
     },
-    async (input, extra) =>
+    async (input, ctx) =>
       safeToolResult(async () =>
         operationalJsonResult(
           await runIsolatedOperationalCommand({
@@ -858,7 +855,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
               tenant: input.tenant,
               modulePath: input.module,
             },
-            signal: extra.signal,
+            signal: ctx.mcpReq.signal,
             timeoutMs: input.timeoutMs ?? defaultOperationalCommandTimeoutMs,
           }),
         ),
@@ -878,7 +875,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
         openWorldHint: true,
       },
     },
-    async (input, extra) =>
+    async (input, ctx) =>
       safeToolResult(async () =>
         operationalJsonResult(
           await runIsolatedOperationalCommand({
@@ -894,7 +891,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
               source: input.source,
               modulePath: input.module,
             },
-            signal: extra.signal,
+            signal: ctx.mcpReq.signal,
             timeoutMs: input.timeoutMs ?? defaultOperationalCommandTimeoutMs,
           }),
         ),
@@ -914,7 +911,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
         openWorldHint: true,
       },
     },
-    async (input, extra) =>
+    async (input, ctx) =>
       safeToolResult(async () =>
         operationalJsonResult(
           await runIsolatedOperationalCommand({
@@ -934,7 +931,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
                     id: input.id,
                     modulePath: input.module,
                   },
-            signal: extra.signal,
+            signal: ctx.mcpReq.signal,
             timeoutMs: input.timeoutMs ?? defaultOperationalCommandTimeoutMs,
           }),
         ),
@@ -954,7 +951,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
         openWorldHint: true,
       },
     },
-    async (input, extra) =>
+    async (input, ctx) =>
       safeToolResult(async () => {
         const request =
           input.operation === "drain"
@@ -991,7 +988,7 @@ export function buildBeignetMcpServer(options: McpServerOptions): McpServer {
           await runIsolatedOperationalCommand({
             cwd,
             request,
-            signal: extra.signal,
+            signal: ctx.mcpReq.signal,
             timeoutMs: input.timeoutMs ?? defaultOperationalCommandTimeoutMs,
           }),
         );