alepha 0.23.0 → 0.24.0

package/src/cli/platform/commands/SecretsCommand.ts

@@ -1,4 +1,4 @@
-import { $inject, $state, AlephaError, t } from "alepha";
+import { $inject, $state, AlephaError, z } from "alepha";
 import {
   GitHubSecretStore,
   NamingService,
@@ -20,13 +20,13 @@ export class SecretsCommand {
   protected readonly filter = $inject(SecretFilterService);
   protected readonly color = $inject(ConsoleColorProvider);
 
-  protected readonly envFlags = t.object({
-    env: t.optional(
-      t.text({
+  protected readonly envFlags = z.object({
+    env: z
+      .text({
         aliases: ["e"],
         description: "Target environment",
-      }),
-    ),
+      })
+      .optional(),
   });
 
   // -----------------------------------------------------------------------
@@ -38,19 +38,19 @@ export class SecretsCommand {
     aliases: ["ls"],
     description:
       "List secret names stored in the remote store for an environment (values are never returned). Use --format=gha to emit a ready-to-paste GitHub Actions env: block.",
-    flags: t.object({
-      env: t.optional(
-        t.text({
+    flags: z.object({
+      env: z
+        .text({
           aliases: ["e"],
           description: "Target environment",
-        }),
-      ),
-      format: t.optional(
-        t.text({
+        })
+        .optional(),
+      format: z
+        .text({
           aliases: ["f"],
           description: "Output format: table (default), gha",
-        }),
-      ),
+        })
+        .optional(),
     }),
     handler: async ({ flags, root, run }) => {
       const config = await this.inspector.resolveConfig(root);
@@ -182,18 +182,17 @@ export class SecretsCommand {
     name: "apply",
     description:
       "Push secrets from local .env.<env> to the remote store (one upsert per key). Use --dry-run to preview. Existing remote keys not present locally are left untouched — this command never deletes.",
-    flags: t.object({
-      env: t.optional(
-        t.text({
+    flags: z.object({
+      env: z
+        .text({
           aliases: ["e"],
           description: "Target environment",
-        }),
-      ),
-      "dry-run": t.optional(
-        t.boolean({
-          description: "Preview changes without pushing",
-        }),
-      ),
+        })
+        .optional(),
+      "dry-run": z
+        .boolean()
+        .describe("Preview changes without pushing")
+        .optional(),
     }),
     handler: async ({ flags, root, run }) => {
       const config = await this.inspector.resolveConfig(root);

package/src/cli/platform/commands/platform.ts

@@ -1,4 +1,4 @@
-import { $inject, $state, AlephaError, t } from "alepha";
+import { $inject, $state, AlephaError, z } from "alepha";
 import { type AppEntry, AppEntryProvider, ViteBuildProvider } from "alepha/cli";
 import {
   CloudflareAdapter,
@@ -32,30 +32,25 @@ export class PlatformCommand {
   /**
    * Common flags for env targeting.
    */
-  protected readonly envFlags = t.object({
-    env: t.optional(
-      t.text({
+  protected readonly envFlags = z.object({
+    env: z
+      .text({
         aliases: ["e"],
         description: "Target environment",
-      }),
-    ),
-    tenant: t.optional(
-      t.text({
+      })
+      .optional(),
+    tenant: z
+      .text({
         description:
           "Tenant slug (apps with tenancy: optional | required). Names resources <tenant>-<project>-<env> and serves <tenant>.<domain>.",
-      }),
-    ),
-    verbose: t.optional(
-      t.boolean({
-        aliases: ["v"],
-        description: "Verbose output",
-      }),
-    ),
-    json: t.optional(
-      t.boolean({
-        description: "Output as JSON",
-      }),
-    ),
+      })
+      .optional(),
+    verbose: z
+      .boolean()
+      .meta({ aliases: ["v"] })
+      .describe("Verbose output")
+      .optional(),
+    json: z.boolean().describe("Output as JSON").optional(),
   });
 
   // -----------------------------------------------------------------------
@@ -215,14 +210,14 @@ export class PlatformCommand {
     name: "up",
     mode: "production",
     description: "Build, migrate, and deploy",
-    flags: t.object({
+    flags: z.object({
       ...this.envFlags.properties,
-      prebuilt: t.optional(
-        t.boolean({
-          description:
-            "Pre-built mode. Skips the Vite bundle steps; only regenerates the target deploy config (wrangler.jsonc) so it reflects current bindings and per-tenant overrides. Use when `dist/` is already produced upstream (e.g. inside Alepha Rocket).",
-        }),
-      ),
+      prebuilt: z
+        .boolean()
+        .describe(
+          "Pre-built mode. Skips the Vite bundle steps; only regenerates the target deploy config (wrangler.jsonc) so it reflects current bindings and per-tenant overrides. Use when `dist/` is already produced upstream (e.g. inside Alepha Rocket).",
+        )
+        .optional(),
     }),
     handler: async ({ flags, root, run }) => {
       process.env.NODE_ENV = "production";
@@ -275,15 +270,15 @@ export class PlatformCommand {
   protected readonly down = $command({
     name: "down",
     description: "Tear down an environment",
-    flags: t.object({
+    flags: z.object({
       ...this.envFlags.properties,
-      yes: t.optional(
-        t.boolean({
-          aliases: ["y"],
-          description:
-            "Skip the interactive confirmation. Required for non-interactive callers (CI, Alepha Rocket). The caller is responsible for not invoking this accidentally — there's no second chance.",
-        }),
-      ),
+      yes: z
+        .boolean()
+        .meta({ aliases: ["y"] })
+        .describe(
+          "Skip the interactive confirmation. Required for non-interactive callers (CI, Alepha Rocket). The caller is responsible for not invoking this accidentally — there's no second chance.",
+        )
+        .optional(),
     }),
     handler: async ({ flags, root, run, ask }) => {
       if (!flags.env) {
@@ -635,19 +630,18 @@ export class PlatformCommand {
     name: "export",
     description:
       "Export the deployed database to a local snapshot (remote → local dev DB).",
-    flags: t.object({
+    flags: z.object({
       ...this.envFlags.properties,
-      output: t.optional(
-        t.text({
+      output: z
+        .text({
           description:
             "Destination SQLite file. Defaults to the dev DB path (node_modules/.alepha/sqlite.db).",
-        }),
-      ),
-      keepSql: t.optional(
-        t.boolean({
-          description: "Keep the intermediate .sql dump file.",
-        }),
-      ),
+        })
+        .optional(),
+      keepSql: z
+        .boolean()
+        .describe("Keep the intermediate .sql dump file.")
+        .optional(),
     }),
     handler: async ({ flags, root, run }) => {
       const config = await this.inspector.resolveConfig(root);

package/src/cli/platform/index.ts

@@ -64,7 +64,7 @@ export const platform = (options: PlatformOptions) => {
   // places. Honors an explicit env override and any non-production-only
   // setup (we don't override prod-set values).
   if (!process.env.PUBLIC_URL) {
-    const productionDomain = options.environments?.production?.domain;
+    const productionDomain = options?.environments?.production?.domain;
     if (productionDomain) {
       process.env.PUBLIC_URL = `https://${productionDomain}`;
     }

package/src/cli/platform-lib/__tests__/CloudflareAdapter.spec.ts

@@ -935,8 +935,6 @@ describe("CloudflareAdapter", () => {
       const run: any = async (cmd: any) => {
         if (typeof cmd === "string") commands.push(cmd);
       };
-      run.pause = () => {};
-      run.resume = () => {};
       run.end = () => {};
 
       await adapter.exportDb(ctx, run, {
@@ -977,8 +975,6 @@ function createMockRun(): any {
       await task.handler();
     }
   };
-  run.pause = () => {};
-  run.resume = () => {};
   run.end = () => {};
   return run;
 }

package/src/cli/platform-lib/__tests__/PlatformInspector.spec.ts

@@ -5,7 +5,7 @@ import { platformOptions } from "../atoms/platformOptions.ts";
 import { PlatformInspector } from "../services/PlatformInspector.ts";
 
 describe("PlatformInspector", () => {
-  const createTestEnv = (config: Record<string, any> = {}) => {
+  const createTestEnv = (config?: Record<string, any>) => {
     const alepha = Alepha.create().with({
       provide: FileSystemProvider,
       use: MemoryFileSystemProvider,
@@ -14,7 +14,14 @@ describe("PlatformInspector", () => {
     const fs = alepha.inject(MemoryFileSystemProvider);
     const inspector = alepha.inject(PlatformInspector);
 
-    alepha.set(platformOptions, config as any);
+    // Only write the atom when the test actually provides a config —
+    // `platformOptions.schema` requires `environments`, so an empty object
+    // is not a valid "configured" state. Leaving the atom unset is how a
+    // real "no platform config" run looks (falls through to the
+    // dist/manifest.json fallback in PlatformInspector.resolveConfig).
+    if (config) {
+      alepha.set(platformOptions, config as any);
+    }
 
     return { alepha, fs, inspector };
   };
@@ -22,7 +29,7 @@ describe("PlatformInspector", () => {
   test("throws when platform is not configured in CI", async ({ expect }) => {
     process.env.CI = "1";
     try {
-      const { inspector } = createTestEnv({});
+      const { inspector } = createTestEnv();
       await expect(inspector.resolveConfig("/project")).rejects.toThrowError(
         AlephaError,
       );

package/src/cli/platform-lib/__tests__/VercelAdapter.spec.ts

@@ -479,8 +479,6 @@ function createMockRun(): any {
       await task.handler();
     }
   };
-  run.pause = () => {};
-  run.resume = () => {};
   run.end = () => {};
   return run;
 }

package/src/cli/platform-lib/adapters/CloudflareAdapter.ts

@@ -82,13 +82,11 @@ export class CloudflareAdapter extends PlatformAdapter {
     command: string,
     options: Parameters<ShellProvider["run"]>[1] = {},
   ) {
-    const capture = options.capture;
-    const output = await this.shell.run(command, {
-      ...options,
-      capture: capture ?? this.runner.useDynamicLogger,
-    });
+    const output = await this.shell.run(command, options);
 
-    if (capture && !this.runner.useDynamicLogger) {
+    // When the caller captured the output, echo it to the log so the user
+    // still sees it (uncaptured commands stream straight to the terminal).
+    if (options.capture) {
       this.log.info(output);
     }
 
@@ -104,7 +102,7 @@ export class CloudflareAdapter extends PlatformAdapter {
     await run({
       name: "authenticate",
       handler: async () => {
-        await this.wrangler.ensureInstalled(ctx.root, run);
+        await this.wrangler.ensureInstalled(ctx.root);
 
         // Always validate the token — refresh tokens can expire between runs
         // even when the cache TTL hasn't elapsed.
@@ -117,9 +115,7 @@ export class CloudflareAdapter extends PlatformAdapter {
         }
 
         if (needsLogin) {
-          run.pause();
           await this.wrangler.login();
-          run.resume();
         }
 
         // Skip account resolution if cache is fresh
@@ -186,11 +182,9 @@ export class CloudflareAdapter extends PlatformAdapter {
     // via tenantDomain's third arg.)
     const host = tenantDomain(ctx.envConfig.domain, ctx.tenant);
     if (host) {
-      if (host.includes("*") && !ctx.envConfig.zone) {
-        throw new AlephaError(
-          `Wildcard domain "${host}" requires "zone" to be set in the environment config (the Cloudflare zone name, e.g. "alepha.dev").`,
-        );
-      }
+      // A wildcard host needs a CF zone for its Worker route, but `zone` is
+      // optional: when omitted the build derives it from the domain's last two
+      // labels (BuildCloudflareTask). Set it only to override that default.
       env.CLOUDFLARE_DOMAIN = host;
       if (ctx.envConfig.zone) {
         env.CLOUDFLARE_ZONE = ctx.envConfig.zone;
@@ -201,6 +195,11 @@ export class CloudflareAdapter extends PlatformAdapter {
       env.CLOUDFLARE_JURISDICTION = ctx.envConfig.jurisdiction;
     }
 
+    // Worker-to-worker service bindings (see EnvironmentConfig.services).
+    if (ctx.envConfig.services?.length) {
+      env.CLOUDFLARE_SERVICES = JSON.stringify(ctx.envConfig.services);
+    }
+
     // Two paths:
     //  - `--prebuilt`: in-process call to BuildCloudflareTask. Reads
     //    `dist/manifest.json` for resources/crons/containers, reads

package/src/cli/platform-lib/adapters/VercelAdapter.ts

@@ -1,6 +1,6 @@
 import { $inject, Alepha } from "alepha";
 import { AlephaCliUtils } from "alepha/cli";
-import { EnvUtils, Runner, type RunnerMethod } from "alepha/command";
+import { EnvUtils, type RunnerMethod } from "alepha/command";
 import { $logger } from "alepha/logger";
 import { FileSystemProvider, ShellProvider } from "alepha/system";
 import { PlatformCacheProvider } from "../providers/PlatformCacheProvider.ts";
@@ -31,7 +31,6 @@ export class VercelAdapter extends PlatformAdapter {
   protected readonly envUtils = $inject(EnvUtils);
   protected readonly api = $inject(VercelApi);
   protected readonly vercelCli = $inject(VercelCli);
-  protected readonly runner = $inject(Runner);
 
   /**
    * Vars that should not be pushed as env vars.
@@ -43,13 +42,11 @@ export class VercelAdapter extends PlatformAdapter {
     command: string,
     options: Parameters<ShellProvider["run"]>[1] = {},
   ) {
-    const capture = options.capture;
-    const output = await this.shell.run(command, {
-      ...options,
-      capture: capture ?? this.runner.useDynamicLogger,
-    });
+    const output = await this.shell.run(command, options);
 
-    if (capture && !this.runner.useDynamicLogger) {
+    // When the caller captured the output, echo it to the log so the user
+    // still sees it (uncaptured commands stream straight to the terminal).
+    if (options.capture) {
       this.log.info(output);
     }
 
@@ -64,7 +61,7 @@ export class VercelAdapter extends PlatformAdapter {
     await run({
       name: "authenticate",
       handler: async () => {
-        await this.vercelCli.ensureInstalled(ctx.root, run);
+        await this.vercelCli.ensureInstalled(ctx.root);
 
         let needsLogin = false;
 
@@ -76,9 +73,7 @@ export class VercelAdapter extends PlatformAdapter {
         }
 
         if (needsLogin) {
-          run.pause();
           await this.vercelCli.login();
-          run.resume();
         }
 
         if (await this.cache.isLoginFresh(ctx.root, "vercel")) {

package/src/cli/platform-lib/atoms/platformOptions.ts

@@ -1,4 +1,4 @@
-import { $atom, type Static, t } from "alepha";
+import { $atom, type Static, z } from "alepha";
 
 /**
  * Platform deployment configuration atom.
@@ -9,19 +9,19 @@ import { $atom, type Static, t } from "alepha";
 export const platformOptions = $atom({
   name: "alepha.cli.platform.options",
   description: "Platform deployment configuration",
-  schema: t.optional(
-    t.object({
+  schema: z
+    .object({
       /**
        * Project name override. Defaults to root package.json "name".
        */
-      name: t.optional(t.text()),
+      name: z.text().optional(),
 
       /**
        * Default environment when --env is omitted.
        *
        * @default "production"
        */
-      default: t.optional(t.text()),
+      default: z.text().optional(),
 
       /**
        * Multi-tenancy mode — controls whether `--tenant <slug>` is
@@ -36,14 +36,14 @@ export const platformOptions = $atom({
        *
        * @default "none"
        */
-      tenancy: t.optional(t.enum(["none", "optional", "required"])),
+      tenancy: z.enum(["none", "optional", "required"]).optional(),
 
       /**
        * Secret store configuration for syncing .env secrets
        * to external providers (e.g. GitHub Actions environments).
        */
-      secrets: t.optional(
-        t.object({
+      secrets: z
+        .object({
           /**
            * Explicit override of the worker secret-key allowlist.
            *
@@ -60,12 +60,12 @@ export const platformOptions = $atom({
            * neither this nor a manifest is present, the `.env.<env>` file is
            * itself the allowlist (legacy fallback).
            */
-          keys: t.optional(t.array(t.text())),
+          keys: z.array(z.text()).optional(),
 
           /**
            * Secret store backend.
            */
-          store: t.optional(t.enum(["github"])),
+          store: z.enum(["github"]).optional(),
 
           /**
            * Pattern for resolving environment names in the store.
@@ -73,20 +73,20 @@ export const platformOptions = $atom({
            *
            * @default "{project}-{env}"
            */
-          environmentPattern: t.optional(t.text()),
-        }),
-      ),
+          environmentPattern: z.text().optional(),
+        })
+        .optional(),
 
       /**
        * Named environments with their adapter and configuration.
        */
-      environments: t.record(
-        t.text({
+      environments: z.record(
+        z.text({
           description:
             "Environment name (e.g. 'production', 'staging', 'preview'). Used in resource naming and selected via --env.",
         }),
-        t.object({
-          adapter: t.enum(["cloudflare", "vercel"]),
+        z.object({
+          adapter: z.enum(["cloudflare", "vercel"]),
           /**
            * Custom domain for the deployed worker (e.g. "api.example.com").
            *
@@ -98,14 +98,34 @@ export const platformOptions = $atom({
            * Wildcard patterns require `zone` to be set, and the wildcard DNS
            * record must already exist (proxied) in the Cloudflare zone.
            */
-          domain: t.optional(t.text()),
+          domain: z.text().optional(),
           /**
            * Cloudflare zone name (e.g. "alepha.dev") that owns `domain`.
            *
-           * Required when `domain` contains a wildcard (`*`). Ignored for
-           * plain custom domains, which Cloudflare resolves automatically.
+           * Required when `domain` contains a wildcard (`*`). For a plain
+           * host, setting `zone` switches the binding from a Custom Domain to
+           * a zone *Route* (`domain/*`) — needed when another Worker holds a
+           * wildcard route covering the host (routes win by specificity,
+           * while a Custom Domain would lose to the wildcard route).
+           */
+          zone: z.text().optional(),
+          /**
+           * Worker-to-worker service bindings, e.g.
+           * `[{ binding: "CLUB", service: "club-staging" }]`.
+           *
+           * Exposed on the runtime `env` (Alepha store key `cloudflare.env`).
+           * Use a binding to fetch() a sibling Worker on the same zone —
+           * plain subrequests to a host served by a same-zone Worker route
+           * bypass the route and 522.
            */
-          zone: t.optional(t.text()),
+          services: z
+            .array(
+              z.object({
+                binding: z.text(),
+                service: z.text(),
+              }),
+            )
+            .optional(),
           /**
            * Cloudflare data jurisdiction for R2 buckets and D1 databases.
            * - "eu": data stays within the EU
@@ -113,7 +133,7 @@ export const platformOptions = $atom({
            *
            * Omit for the default (global) jurisdiction.
            */
-          jurisdiction: t.optional(t.enum(["eu", "fedramp"])),
+          jurisdiction: z.enum(["eu", "fedramp"]).optional(),
           /**
            * Cloudflare account ID to deploy into.
            *
@@ -121,11 +141,11 @@ export const platformOptions = $atom({
            * token's account when the token is scoped to exactly one.
            * Required when the token has access to multiple accounts.
            */
-          accountId: t.optional(t.text()),
+          accountId: z.text().optional(),
         }),
       ),
-    }),
-  ),
+    })
+    .optional(),
 });
 
 /**
@@ -143,4 +163,5 @@ export interface EnvironmentConfig {
   vars?: Record<string, string>;
   jurisdiction?: "eu" | "fedramp";
   accountId?: string;
+  services?: Array<{ binding: string; service: string }>;
 }