alepha 0.21.2 → 0.23.0

package/src/cli/core/commands/build.ts

@@ -19,7 +19,6 @@ import { BuildDockerTask } from "../tasks/BuildDockerTask.ts";
 import { BuildPrerenderTask } from "../tasks/BuildPrerenderTask.ts";
 import { BuildPwaTask } from "../tasks/BuildPwaTask.ts";
 import { BuildServerTask } from "../tasks/BuildServerTask.ts";
-import { BuildSitemapTask } from "../tasks/BuildSitemapTask.ts";
 import { BuildStaticTask } from "../tasks/BuildStaticTask.ts";
 import type { BuildTaskContext } from "../tasks/BuildTask.ts";
 import { BuildVercelTask } from "../tasks/BuildVercelTask.ts";
@@ -43,7 +42,6 @@ export class BuildCommand {
     $inject(BuildClientTask),
     $inject(BuildServerTask),
     $inject(BuildAssetsTask),
-    $inject(BuildSitemapTask),
     $inject(BuildPwaTask),
     $inject(BuildPrerenderTask),
     $inject(BuildVercelTask),
@@ -53,6 +51,29 @@ export class BuildCommand {
     $inject(BuildCompressTask),
   ];
 
+  /**
+   * Value aliases accepted for `--target`.
+   *
+   * These let the CLI accept short forms (e.g. `--target cf`) that are
+   * canonicalized to a real {@link BuildTarget} before they flow into the
+   * pipeline. The enum in `flags.target` must also list the alias so it
+   * passes schema validation.
+   */
+  protected readonly targetAliases: Record<string, BuildTarget> = {
+    cf: "cloudflare",
+  };
+
+  /**
+   * Canonicalize a raw `--target` value, mapping any known alias
+   * (e.g. `cf` → `cloudflare`) to its real {@link BuildTarget}.
+   */
+  protected resolveTarget(target: string | undefined): BuildTarget | undefined {
+    if (!target) {
+      return undefined;
+    }
+    return this.targetAliases[target] ?? (target as BuildTarget);
+  }
+
   /**
    * Resolve the effective runtime based on target and explicit runtime flag.
    *
@@ -99,9 +120,9 @@ export class BuildCommand {
         }),
       ),
       target: t.optional(
-        t.enum(["bare", "docker", "vercel", "cloudflare", "static"], {
+        t.enum(["bare", "docker", "vercel", "cloudflare", "cf", "static"], {
           aliases: ["t"],
-          description: "Deployment target",
+          description: "Deployment target (cf = cloudflare)",
         }),
       ),
       runtime: t.optional(
@@ -130,11 +151,6 @@ export class BuildCommand {
             "Skip the bundle steps (Vite client/server + asset compression). Only regenerates target-specific deploy config (e.g. wrangler.jsonc). Use when `dist/` is already built and you just need the config refreshed.",
         }),
       ),
-      sitemap: t.optional(
-        t.text({
-          description: "Generate sitemap.xml with base URL",
-        }),
-      ),
     }),
     handler: async ({ flags, run, root }) => {
       process.env.NODE_ENV = "production";
@@ -152,24 +168,26 @@ export class BuildCommand {
       this.log.trace("Entry file found", { entry });
 
       // Resolve flags → mutate the atom (single source of truth)
-      this.alepha.store.mut(buildOptions, (current) => ({
-        ...current,
-        stats: flags.stats ?? current.stats ?? false,
-        target: flags.target ?? current.target,
-        runtime: this.resolveRuntime(
-          flags.target ?? current.target,
-          flags.runtime ?? current.runtime,
-        ),
-        ...(flags.compile !== undefined && {
-          docker: {
-            ...current.docker,
-            compile: flags.compile ? (current.docker?.compile ?? true) : false,
-          },
-        }),
-        ...(flags.sitemap && {
-          sitemap: { hostname: flags.sitemap },
-        }),
-      }));
+      this.alepha.store.mut(buildOptions, (current) => {
+        const target = this.resolveTarget(flags.target) ?? current.target;
+        return {
+          ...current,
+          stats: flags.stats ?? current.stats ?? false,
+          target,
+          runtime: this.resolveRuntime(
+            target,
+            flags.runtime ?? current.runtime,
+          ),
+          ...(flags.compile !== undefined && {
+            docker: {
+              ...current.docker,
+              compile: flags.compile
+                ? (current.docker?.compile ?? true)
+                : false,
+            },
+          }),
+        };
+      });
 
       const options = this.options;
 
@@ -211,28 +229,57 @@ export class BuildCommand {
         runtime: options.runtime,
       });
 
+      // Prebuilt + manifest fast-path: skip `analyze app` (which boots
+      // the workspace via Vite and requires its full node_modules tree).
+      // BuildCloudflareTask reads from `ctx.manifest` instead of from
+      // `ctx.alepha` in this mode. Falls back to the introspection path
+      // when no manifest is present (older artifacts).
+      let manifest: Awaited<ReturnType<typeof this.loadManifest>> = null;
+      if (flags.prebuilt) {
+        manifest = await this.loadManifest(root);
+      }
+
       let appAlepha: Alepha | undefined;
       let hasClient = false;
 
-      await run({
-        name: "analyze app",
-        handler: async () => {
-          appAlepha = await this.viteBuildProvider.init({ entry });
-          hasClient = this.viteBuildProvider.hasClient();
-        },
-      });
+      if (!manifest) {
+        await run({
+          name: "analyze app",
+          handler: async () => {
+            appAlepha = await this.viteBuildProvider.init({ entry });
+            hasClient = this.viteBuildProvider.hasClient();
+          },
+        });
 
-      if (!appAlepha) {
-        throw new AlephaError("Alepha instance not found");
+        if (!appAlepha) {
+          throw new AlephaError("Alepha instance not found");
+        }
       }
 
+      // Read platformOptions from the CLI's Alepha instance — this is
+      // where alepha.config.ts wrote them during the configure hook.
+      // The workspace's appAlepha (from Vite) is a separate instance
+      // and doesn't have these. Captured here so BuildCloudflareTask
+      // can serialize them into dist/manifest.json without needing to
+      // re-load alepha.config.ts at deploy time.
+      const platformOptions =
+        (this.alepha.store.get("alepha.cli.platform.options") as
+          | BuildTaskContext["platformOptions"]
+          | undefined) ?? null;
+
       const ctx: BuildTaskContext = {
-        alepha: appAlepha,
+        // Cast: when manifest mode is active, BuildCloudflareTask reads
+        // from ctx.manifest and never dereferences ctx.alepha. Bundle
+        // tasks (BuildClient/Server/etc.) self-guard on ctx.flags.prebuilt
+        // and return early, so they don't touch alepha either.
+        alepha: (appAlepha ?? null) as unknown as Alepha,
         options,
         root,
         run,
         entry,
         hasClient,
+        manifest,
+        platformOptions,
         flags: { image: flags.image, prebuilt: flags.prebuilt },
       };
 
@@ -241,4 +288,25 @@ export class BuildCommand {
       }
     },
   });
+
+  /**
+   * Read `dist/manifest.json` produced by a previous `alepha build`.
+   * Returns null when absent or unparseable — caller falls back to the
+   * Vite-introspection path.
+   */
+  protected async loadManifest(root: string) {
+    try {
+      const fs = await import("node:fs/promises");
+      const path = await import("node:path");
+      const raw = await fs.readFile(
+        path.join(root, "dist", "manifest.json"),
+        "utf-8",
+      );
+      return JSON.parse(
+        raw,
+      ) as import("../tasks/BuildCloudflareTask.ts").BuildManifest;
+    } catch {
+      return null;
+    }
+  }
 }

package/src/cli/core/commands/init.ts

@@ -42,18 +42,6 @@ export class InitCommand {
           description: "Include Tailwind CSS with Vite plugin. Implies --react",
         }),
       ),
-      shadcn: t.optional(
-        t.union([t.boolean(), t.text()], {
-          description:
-            "Set up shadcn/ui (components.json, cn helper, theme tokens, alepha registry). Pass an optional preset id (default: b0). Implies --react and --tailwind",
-        }),
-      ),
-      saas: t.optional(
-        t.union([t.boolean(), t.text()], {
-          description:
-            "Scaffold a SaaS starter: auth (login/register/reset/verify) + admin panel (/admin AppShell with users/sessions/api-keys/parameters/audits). Pass an optional preset id (default: b0). Implies --shadcn and --api",
-        }),
-      ),
       force: t.optional(
         t.boolean({
           aliases: ["f"],

package/src/cli/core/commands/pack.ts

@@ -0,0 +1,133 @@
+import { $inject, AlephaError, t } from "alepha";
+import { $command } from "alepha/command";
+import { $logger } from "alepha/logger";
+import { FileSystemProvider, ShellProvider } from "alepha/system";
+
+/**
+ * Pack the workspace into a deployable `tar.gz`.
+ *
+ * The tar contains everything a remote runner (Alepha Rocket, or any
+ * `alepha platform <op> --prebuilt` consumer) needs to deploy the app:
+ *
+ *   dist/                 pre-built output (incl. manifest.json)
+ *   migrations/           SQL files (if present)
+ *
+ * No source, no `alepha.config.ts`, no `package.json` — the deploy
+ * side reads everything from `dist/manifest.json` and never touches
+ * source. Excludes: `node_modules`, `.DS_Store`, macOS AppleDouble
+ * (`._*`), `.alepha` build cache, `e2e`, `playwright-report`,
+ * `coverage`.
+ *
+ * Output name: `<project-name>-<tag>.tar.gz` (default tag
+ * "latest"). Project name comes from `package.json.name`. Naming
+ * mirrors Docker tags — same artifact, different tag = different
+ * file.
+ */
+export class PackCommand {
+  protected readonly log = $logger();
+  protected readonly fs = $inject(FileSystemProvider);
+  protected readonly shell = $inject(ShellProvider);
+
+  public readonly pack = $command({
+    name: "pack",
+    description:
+      "Pack the workspace into a deployable tar.gz (for `alepha platform --prebuilt` consumers like Alepha Rocket).",
+    flags: t.object({
+      tag: t.optional(
+        t.text({
+          aliases: ["t"],
+          description:
+            "Tag suffix for the artifact name (Docker-style). Defaults to `latest` → `<project>-latest.tar.gz`. Pass a real version like `0.0.2` for a pinned artifact.",
+        }),
+      ),
+      output: t.optional(
+        t.text({
+          aliases: ["o"],
+          description:
+            "Output directory for the tar.gz (default: current dir).",
+        }),
+      ),
+    }),
+    handler: async ({ flags, root, run }) => {
+      const pkgPath = this.fs.join(root, "package.json");
+      let project: string;
+      try {
+        const pkg = await this.fs.readJsonFile<{ name?: string }>(pkgPath);
+        if (!pkg.name) {
+          throw new AlephaError(
+            'Missing "name" in package.json — `alepha pack` needs it for the artifact filename.',
+          );
+        }
+        project = pkg.name;
+      } catch (err) {
+        if (err instanceof AlephaError) throw err;
+        throw new AlephaError(
+          `Could not read package.json at ${pkgPath}. Run \`alepha pack\` from a workspace directory.`,
+        );
+      }
+
+      const tag = flags.tag ?? "latest";
+      const outputDir = flags.output ?? root;
+      const filename = `${project}-${tag}.tar.gz`;
+      const outputPath = this.fs.join(outputDir, filename);
+
+      // Include list: just `dist/` + `migrations/`. Everything else
+      // (src, alepha.config.ts, tsconfig.json, package.json) is
+      // dev-time scaffolding — the deploy side reads
+      // `dist/manifest.json` for project/env/resources and never
+      // touches source.
+      const candidates = ["dist", "migrations"];
+      const includes: string[] = [];
+      for (const candidate of candidates) {
+        if (await this.fs.exists(this.fs.join(root, candidate))) {
+          includes.push(candidate);
+        }
+      }
+
+      if (!includes.includes("dist")) {
+        throw new AlephaError(
+          "dist/ missing — run `alepha build --target=cloudflare` before `alepha pack`.",
+        );
+      }
+      const manifestPath = this.fs.join(root, "dist", "manifest.json");
+      if (!(await this.fs.exists(manifestPath))) {
+        throw new AlephaError(
+          `dist/manifest.json missing — required for prebuilt deploys. Rebuild with the current alepha version (\`alepha build --target=cloudflare\`).`,
+        );
+      }
+
+      // macOS sets COPYFILE_DISABLE=0 by default; tar will then include
+      // AppleDouble `._*` files. Force it off here so the tarball is
+      // portable. Also pass explicit excludes for `node_modules`,
+      // `.DS_Store`, etc. — they slip in via `dist/`.
+      const excludes = [
+        "node_modules",
+        ".DS_Store",
+        "._*",
+        ".alepha",
+        "e2e",
+        "playwright-report",
+        "test-results",
+        "coverage",
+      ]
+        .map((p) => `--exclude='${p}'`)
+        .join(" ");
+
+      const tarCmd = `tar -czf '${outputPath}' ${excludes} ${includes.map((p) => `'${p}'`).join(" ")}`;
+      // Wrap in `sh -c` so the env-var assignment is interpreted by the
+      // shell instead of being parsed as the binary name. COPYFILE_DISABLE
+      // suppresses macOS AppleDouble (`._*`) entries that tar otherwise
+      // emits when running on HFS+/APFS.
+      const cmd = `sh -c "COPYFILE_DISABLE=1 ${tarCmd}"`;
+
+      await run({
+        name: `pack → ${filename}`,
+        handler: async () => {
+          await this.shell.run(cmd, { root });
+        },
+      });
+
+      this.log.info(`Packed ${filename} → ${outputPath}`);
+    },
+  });
+}

package/src/cli/core/index.ts

@@ -14,6 +14,7 @@ import {
 import { GenCommand } from "./commands/gen.ts";
 import { InitCommand } from "./commands/init.ts";
 import { LintCommand } from "./commands/lint.ts";
+import { PackCommand } from "./commands/pack.ts";
 import { RootCommand } from "./commands/root.ts";
 import { TestCommand } from "./commands/test.ts";
 import { TypecheckCommand } from "./commands/typecheck.ts";
@@ -33,7 +34,6 @@ import { BuildCompressTask } from "./tasks/BuildCompressTask.ts";
 import { BuildDockerTask } from "./tasks/BuildDockerTask.ts";
 import { BuildPrerenderTask } from "./tasks/BuildPrerenderTask.ts";
 import { BuildServerTask } from "./tasks/BuildServerTask.ts";
-import { BuildSitemapTask } from "./tasks/BuildSitemapTask.ts";
 import { BuildStaticTask } from "./tasks/BuildStaticTask.ts";
 import { BuildVercelTask } from "./tasks/BuildVercelTask.ts";
 
@@ -52,6 +52,7 @@ export * from "./commands/gen/changelog.ts";
 export * from "./commands/gen/openapi.ts";
 export * from "./commands/init.ts";
 export * from "./commands/lint.ts";
+export * from "./commands/pack.ts";
 export * from "./commands/root.ts";
 export * from "./commands/test.ts";
 export * from "./commands/typecheck.ts";
@@ -72,7 +73,6 @@ export * from "./tasks/BuildCompressTask.ts";
 export * from "./tasks/BuildDockerTask.ts";
 export * from "./tasks/BuildPrerenderTask.ts";
 export * from "./tasks/BuildServerTask.ts";
-export * from "./tasks/BuildSitemapTask.ts";
 export * from "./tasks/BuildStaticTask.ts";
 export * from "./tasks/BuildTask.ts";
 export * from "./tasks/BuildVercelTask.ts";
@@ -116,6 +116,7 @@ export const AlephaCli = $module({
     DevCommand,
     InitCommand,
     LintCommand,
+    PackCommand,
     RootCommand,
     TestCommand,
     TypecheckCommand,
@@ -129,7 +130,6 @@ export const AlephaCli = $module({
     BuildDockerTask,
     BuildPrerenderTask,
     BuildServerTask,
-    BuildSitemapTask,
     BuildStaticTask,
     BuildVercelTask,
   ],

package/src/cli/core/providers/ViteDevServerProvider.ts

@@ -324,13 +324,22 @@ export class ViteDevServerProvider {
         // Skip when waiting for startup retry
         if (this.waitingForRetry) return [];
 
-        const firstModule = ctx.modules[0] as
-          | { _ssrModule?: unknown; _clientModule?: unknown }
-          | undefined;
-        const isBrowserOnly = firstModule && !firstModule._ssrModule;
-
-        // Browser-only: let Vite HMR handle it (React Fast Refresh)
-        if (isBrowserOnly) return;
+        // React component (.tsx/.jsx) edits always need the SSR module
+        // graph invalidated — the `_ssrModule` shortcut below misses files
+        // that are workspace-linked source-only (e.g. `@alepha/ui/...`).
+        // Those don't carry an `_ssrModule` ref on `ctx.modules[0]` on
+        // first edit and get classified as browser-only, leaving stale
+        // SSR HTML and triggering hydration mismatches on next request.
+        const isTsx = /\.(tsx|jsx)$/.test(ctx.file);
+        if (!isTsx) {
+          const firstModule = ctx.modules[0] as
+            | { _ssrModule?: unknown; _clientModule?: unknown }
+            | undefined;
+          const isBrowserOnly = firstModule && !firstModule._ssrModule;
+
+          // Browser-only: let Vite HMR handle it (React Fast Refresh)
+          if (isBrowserOnly) return;
+        }
 
         // Queue Alepha reload for server-side invalidation
         this.changedFiles.add(ctx.file);
@@ -626,7 +635,17 @@ if (import.meta.hot) {
   }
 
   /**
-   * Invalidate modules and all their importers.
+   * Invalidate modules and all their importers, across both client and
+   * SSR module graphs.
+   *
+   * Vite registers a file under multiple module ids (one per query
+   * variant — e.g. `?v=…`, `?import` and the bare path), and `getModuleById`
+   * only matches one. For workspace-linked source files (`@alepha/ui/...`)
+   * the SSR-graph entry is keyed by the absolute path while the client
+   * may use the package-qualified id. `getModulesByFile` returns every
+   * variant Vite knows about for a given absolute path — invalidating
+   * each catches both halves of the dual graph and prevents stale SSR
+   * compiled exports from surviving across edits.
    */
   protected invalidateModulesWithImporters(changedFiles: Set<string>): void {
     const graph = this.server.moduleGraph;
@@ -636,16 +655,21 @@ if (import.meta.hot) {
     while (queue.length > 0) {
       const file = queue.pop()!;
       if (invalidated.has(file)) continue;
-
-      const mod = this.server.moduleGraph.getModuleById(file);
-      if (!mod) continue;
-
-      graph.invalidateModule(mod);
       invalidated.add(file);
 
-      for (const importer of mod.importers) {
-        if (importer.id && !invalidated.has(importer.id)) {
-          queue.push(importer.id);
+      const mods = new Set([
+        ...(graph.getModulesByFile(file) ?? []),
+        ...(graph.getModuleById(file) ? [graph.getModuleById(file)!] : []),
+      ]);
+      if (mods.size === 0) continue;
+
+      for (const mod of mods) {
+        graph.invalidateModule(mod);
+        for (const importer of mod.importers) {
+          const key = importer.file ?? importer.id;
+          if (key && !invalidated.has(key)) {
+            queue.push(key);
+          }
         }
       }
     }

package/src/cli/core/services/PackageManagerUtils.ts

@@ -418,16 +418,6 @@ export class PackageManagerUtils {
       devDependencies["@tailwindcss/vite"] = alephaDeps["@tailwindcss/vite"];
     }
 
-    if (modes.shadcn) {
-      // Add `shadcn` CLI as a project devDep — `alepha init --shadcn` runs
-      // `yarn shadcn init` after install to scaffold components.json,
-      // theme tokens, cn() helper, and runtime deps (clsx, tailwind-merge,
-      // class-variance-authority, lucide-react, tw-animate-css). Keeping
-      // the CLI in the project lets users re-run `yarn shadcn add ...`
-      // without `npx`.
-      devDependencies.shadcn = alephaDeps.shadcn;
-    }
-
     if (modes.react) {
       dependencies.react = alephaDeps.react;
       dependencies["react-dom"] = alephaDeps["react-dom"];
@@ -459,12 +449,6 @@ export interface DependencyModes {
   react?: boolean;
   expo?: boolean;
   tailwind?: boolean;
-  shadcn?: boolean;
-  /**
-   * SaaS starter: implies `shadcn` + adds the alepha auth + admin registry
-   * components on top via `shadcn add @alepha/...`.
-   */
-  saas?: boolean;
   /**
    * Whether the project is a workspace package inside a monorepo.
    */