alepha 0.19.0 → 0.19.2

package/src/bin/index.ts

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 import { Alepha, run } from "alepha";
 import { AlephaCli, version } from "alepha/cli";
-import { AlephaCliPlatform } from "alepha/cli/platform";
 
 const alepha = Alepha.create({
   env: {
@@ -14,6 +13,5 @@ const alepha = Alepha.create({
 });
 
 alepha.with(AlephaCli);
-alepha.with(AlephaCliPlatform);
 
 run(alepha);

package/src/bucket/providers/LocalFileStorageProvider.ts

@@ -8,7 +8,7 @@ import {
   $atom,
   $hook,
   $inject,
-  $use,
+  $state,
   Alepha,
   AlephaError,
   type FileLike,
@@ -55,7 +55,7 @@ export class LocalFileStorageProvider implements FileStorageProvider {
   protected readonly log = $logger();
   protected readonly fileDetector = $inject(FileDetector);
   protected readonly fileSystemProvider = $inject(FileSystemProvider);
-  protected readonly options = $use(localFileStorageOptions);
+  protected readonly options = $state(localFileStorageOptions);
 
   protected get storagePath(): string {
     return this.options.storagePath;

package/src/cache/core/{primitives → __tests__}/$cache.middleware.spec.ts

@@ -1,7 +1,7 @@
 import { $pipeline, Alepha } from "alepha";
 import { describe, test } from "vitest";
 import { AlephaCache } from "../index.ts";
-import { $cache } from "./$cache.ts";
+import { $cache } from "../primitives/$cache.ts";
 
 describe("$cache middleware", () => {
   test("caches handler result", async ({ expect }) => {

package/src/cache/core/{providers → __tests__}/MemoryCacheProvider.spec.ts

@@ -1,7 +1,7 @@
 import { Alepha } from "alepha";
 import { DateTimeProvider } from "alepha/datetime";
 import { beforeEach, describe, expect, it } from "vitest";
-import { MemoryCacheProvider } from "./MemoryCacheProvider.ts";
+import { MemoryCacheProvider } from "../providers/MemoryCacheProvider.ts";
 
 describe("MemoryCacheProvider", () => {
   let alepha: Alepha;

package/src/cache/core/primitives/$cache.ts

@@ -1,7 +1,7 @@
 import {
   $atom,
   $inject,
-  $use,
+  $state,
   AlephaError,
   createPrimitive,
   type InstantiableClass,
@@ -173,7 +173,7 @@ export class CachePrimitive<
   TReturn = any,
   TParameter extends any[] = any[],
 > extends Primitive<CachePrimitiveOptions<TReturn, TParameter>> {
-  protected readonly settings = $use(cacheOptions);
+  protected readonly settings = $state(cacheOptions);
   protected readonly dateTimeProvider = $inject(DateTimeProvider);
   public readonly provider = this.$provider();
 

package/src/cache/redis/providers/RedisCacheProvider.ts

@@ -1,4 +1,4 @@
-import { $atom, $inject, $use, Alepha, type Static, t } from "alepha";
+import { $atom, $inject, $state, Alepha, type Static, t } from "alepha";
 import { CacheProvider } from "alepha/cache";
 import { $logger } from "alepha/logger";
 import { RedisProvider } from "alepha/redis";
@@ -34,7 +34,7 @@ declare module "alepha" {
 export class RedisCacheProvider extends CacheProvider {
   protected readonly log = $logger();
   protected readonly redisProvider = $inject(RedisProvider);
-  protected readonly options = $use(redisCacheOptions);
+  protected readonly options = $state(redisCacheOptions);
   protected readonly alepha = $inject(Alepha);
 
   public async get(name: string, key: string): Promise<Uint8Array | undefined> {

package/src/cli/config/defineConfig.ts

@@ -7,7 +7,9 @@ import {
   type DevOptions,
   devOptions,
 } from "alepha/cli";
+import { type DevtoolsOptions, devtoolsOptions } from "alepha/cli/devtools";
 import { type PlatformOptions, platformOptions } from "alepha/cli/platform";
+import { type VendorOptions, vendorOptions } from "alepha/cli/vendor";
 import type { CommandPrimitive } from "alepha/command";
 
 export interface AlephaCliConfig {
@@ -35,6 +37,11 @@ export interface AlephaCliConfig {
    */
   dev?: DevOptions;
 
+  /**
+   * Configure devtools plugin.
+   */
+  devtools?: DevtoolsOptions;
+
   /**
    * Environment variables to set before running commands.
    *
@@ -46,6 +53,11 @@ export interface AlephaCliConfig {
    * Platform deployment configuration.
    */
   platform?: PlatformOptions;
+
+  /**
+   * Vendor synchronization configuration.
+   */
+  vendor?: VendorOptions;
 }
 
 export type AlephaCliConfigFn = (alepha: Alepha) => AlephaCliConfig;
@@ -87,6 +99,14 @@ export const defineConfig = (
       alepha.set(platformOptions, config.platform);
     }
 
+    if (config.devtools) {
+      alepha.set(devtoolsOptions, config.devtools);
+    }
+
+    if (config.vendor) {
+      alepha.set(vendorOptions, config.vendor);
+    }
+
     return {
       ...config.commands,
     };

package/src/cli/core/{services → __tests__}/ProjectScaffolder.spec.ts

@@ -6,7 +6,7 @@ import {
   ShellProvider,
 } from "alepha/system";
 import { describe, expect, it } from "vitest";
-import { ProjectScaffolder } from "./ProjectScaffolder.ts";
+import { ProjectScaffolder } from "../services/ProjectScaffolder.ts";
 
 describe("ProjectScaffolder", () => {
   const createTestEnv = () => {

package/src/cli/core/{commands/gen → __tests__}/changelog.spec.ts

@@ -10,7 +10,7 @@ import {
   changelogOptions,
   GitMessageParser,
   GitProvider,
-} from "./changelog.ts";
+} from "../commands/gen/changelog.ts";
 
 // =============================================================================
 // MOCK GIT PROVIDER

package/src/cli/core/{commands → __tests__}/init.spec.ts

@@ -7,7 +7,7 @@ import {
   ShellProvider,
 } from "alepha/system";
 import { describe, expect, it } from "vitest";
-import { InitCommand } from "./init.ts";
+import { InitCommand } from "../commands/init.ts";
 
 describe("alepha init", () => {
   const createTestEnv = () => {
@@ -542,13 +542,7 @@ describe("alepha init", () => {
     });
 
     it("should check each codegen flag independently", async () => {
-      for (const flag of [
-        "--react",
-        "--ui",
-        "--auth",
-        "--admin",
-        "--tailwind",
-      ]) {
+      for (const flag of ["--react", "--ui", "--saas", "--tailwind"]) {
         const { fs, cli, cmd, json } = createTestEnv();
         await setupProject(fs, json);
         await fs.writeFile("/project/src/existing.ts", "export {}");
@@ -630,15 +624,13 @@ describe("alepha init", () => {
       );
     };
 
-    it("should skip biome.json when workspace root has it", async () => {
+    it("should always create biome.json even when workspace root has it", async () => {
       const { fs, cli, cmd, json } = createTestEnv();
       await setupWorkspace(fs, json);
 
       await cli.run(cmd.init, { root: "/workspace/packages/my-pkg" });
 
-      expect(fs.wasWritten("/workspace/packages/my-pkg/biome.json")).toBe(
-        false,
-      );
+      expect(fs.wasWritten("/workspace/packages/my-pkg/biome.json")).toBe(true);
     });
 
     it("should skip .editorconfig when workspace root has it", async () => {

package/src/cli/core/assets.ts

@@ -4,6 +4,5 @@ import { fileURLToPath } from "node:url";
 const packageRoot = join(fileURLToPath(import.meta.url), "../../../..");
 
 export const cliAssets = {
-  devtools: join(packageRoot, "assets/devtools-ui"),
   logo: join(packageRoot, "assets/logo.svg"),
 };

package/src/cli/core/atoms/devOptions.ts

@@ -10,11 +10,6 @@ export const devOptions = $atom({
   name: "alepha.cli.dev.options",
   description: "Dev configuration options",
   schema: t.object({
-    /**
-     * Disable devtools.
-     */
-    noDevtools: t.optional(t.boolean({ default: false })),
-
     /**
      * Disable Vite React plugin.
      */

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

@@ -1,4 +1,4 @@
-import { $inject, $use, Alepha, AlephaError, t } from "alepha";
+import { $inject, $state, Alepha, AlephaError, t } from "alepha";
 import { $command } from "alepha/command";
 import { $logger } from "alepha/logger";
 import {
@@ -31,7 +31,7 @@ export class BuildCommand {
   protected readonly scaffolder = $inject(ProjectScaffolder);
   protected readonly boot = $inject(AppEntryProvider);
   protected readonly viteBuildProvider = $inject(ViteBuildProvider);
-  protected readonly options = $use(buildOptions);
+  protected readonly options = $state(buildOptions);
 
   /**
    * Build pipeline: tasks run sequentially in this order.

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

@@ -1,4 +1,7 @@
-import { $inject, $use, Alepha, t } from "alepha";
+import { spawn } from "node:child_process";
+import { readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { $inject, $state, Alepha, t } from "alepha";
 import { $command } from "alepha/command";
 import { $logger } from "alepha/logger";
 import { FileSystemProvider } from "alepha/system";
@@ -18,48 +21,180 @@ export class DevCommand {
   protected readonly alepha = $inject(Alepha);
   protected readonly viteDevServer = $inject(ViteDevServerProvider);
   protected readonly boot = $inject(AppEntryProvider);
-  protected readonly options = $use(devOptions);
+  protected readonly options = $state(devOptions);
 
   /**
    * Will run the project in watch mode.
+   *
+   * When run from a workspace root (with apps/ directory), spawns all apps in parallel.
+   * When run from an app directory, starts a single Vite dev server.
    */
   public readonly dev = $command({
     name: "dev",
     mode: true,
     description: "Run the project in development mode",
     flags: t.object({
-      "no-devtools": t.optional(
-        t.boolean({
-          description: "Disable devtools",
-        }),
-      ),
-      "no-vite-react-plugin": t.optional(
-        t.boolean({
-          description: "Disable Vite React plugin",
+      only: t.optional(
+        t.string({
+          description:
+            "Run only specific apps (comma-separated: --only api,companion)",
         }),
       ),
     }),
     handler: async ({ root, flags }) => {
-      await this.scaffolder.ensureConfig(root, {
-        tsconfigJson: true,
-      });
-
-      const entry = await this.boot.getAppEntry(root);
-      this.log.debug("Entry file found", { entry });
-
-      const options = this.options;
-
-      // -> here, we assume we use Vite as runner (api or fullstack)
-      // but it's planned to support Bun runner in the future as well
-      await this.viteDevServer.init({
-        root,
-        entry,
-        noDevtools: flags["no-devtools"] ?? options.noDevtools ?? false,
-        noViteReactPlugin:
-          flags["no-vite-react-plugin"] ?? options.noViteReactPlugin ?? false,
-      });
-
-      await this.viteDevServer.start();
+      const apps = await this.discoverApps(root);
+
+      if (apps.length > 0) {
+        await this.runMultiple(root, apps, flags);
+      } else {
+        await this.runSingle(root);
+      }
     },
   });
+
+  /**
+   * Discover apps in the workspace root.
+   *
+   * Looks for directories under apps/ that contain a package.json.
+   * Supports scoped directories (e.g., apps/@passeo/api).
+   * Returns empty array if not in a workspace root.
+   */
+  protected async discoverApps(
+    root: string,
+  ): Promise<Array<{ name: string; path: string }>> {
+    const appsDir = join(root, "apps");
+
+    if (!(await this.fs.exists(appsDir))) {
+      return [];
+    }
+
+    const entries = await readdir(appsDir);
+    const apps: Array<{ name: string; path: string }> = [];
+
+    for (const entry of entries) {
+      const appPath = join(appsDir, entry);
+      const pkgPath = join(appPath, "package.json");
+
+      if (await this.fs.exists(pkgPath)) {
+        apps.push({ name: entry, path: appPath });
+        continue;
+      }
+
+      // Check scoped directories (e.g., apps/@passeo/api)
+      const entryStat = await stat(appPath).catch(() => null);
+      if (entryStat?.isDirectory()) {
+        const scopedEntries = await readdir(appPath);
+        for (const scopedEntry of scopedEntries) {
+          const scopedPath = join(appPath, scopedEntry);
+          const scopedPkgPath = join(scopedPath, "package.json");
+
+          if (await this.fs.exists(scopedPkgPath)) {
+            apps.push({ name: scopedEntry, path: scopedPath });
+          }
+        }
+      }
+    }
+
+    return apps;
+  }
+
+  /**
+   * Run a single app (existing behavior).
+   */
+  protected async runSingle(root: string): Promise<void> {
+    await this.scaffolder.ensureConfig(root, {
+      tsconfigJson: true,
+    });
+
+    const entry = await this.boot.getAppEntry(root);
+    this.log.debug("Entry file found", { entry });
+
+    const options = this.options;
+
+    await this.viteDevServer.init({
+      root,
+      entry,
+      noViteReactPlugin: options.noViteReactPlugin ?? false,
+    });
+
+    await this.viteDevServer.start();
+  }
+
+  /**
+   * Run multiple apps in parallel with colored prefixed output.
+   */
+  protected async runMultiple(
+    _root: string,
+    apps: Array<{ name: string; path: string }>,
+    flags: Record<string, unknown>,
+  ): Promise<void> {
+    const only = flags.only as string | undefined;
+
+    if (only) {
+      const filter = only.split(",").map((s) => s.trim().toLowerCase());
+      apps = apps.filter((app) => filter.includes(app.name.toLowerCase()));
+    }
+
+    if (apps.length === 0) {
+      this.log.warn("No apps found to run");
+      return;
+    }
+
+    this.log.debug(
+      `Starting ${apps.length} apps: ${apps.map((a) => a.name).join(", ")}`,
+    );
+
+    const basePort = 5173;
+    const processes = apps.map((app, i) => this.spawnApp(app, basePort + i));
+
+    // Handle graceful shutdown
+    const cleanup = () => {
+      for (const proc of processes) {
+        proc.kill("SIGTERM");
+      }
+    };
+
+    process.once("SIGINT", cleanup);
+    process.once("SIGTERM", cleanup);
+
+    // Wait for all processes (they run until killed)
+    await Promise.allSettled(
+      processes.map(
+        (proc) =>
+          new Promise<void>((resolve) => {
+            proc.on("exit", () => resolve());
+          }),
+      ),
+    );
+  }
+
+  /**
+   * Spawn a single app process with inherited stdio.
+   *
+   * Each child process gets APP_NAME set, so the Alepha logger
+   * handles prefixing automatically.
+   */
+  protected spawnApp(
+    app: { name: string; path: string },
+    port: number,
+  ): ReturnType<typeof spawn> {
+    const proc = spawn("yarn", ["alepha", "dev"], {
+      cwd: app.path,
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        APP_NAME: app.name.toUpperCase(),
+        SERVER_PORT: String(port),
+        FORCE_COLOR: "1",
+      },
+    });
+
+    proc.on("exit", (code) => {
+      if (code !== 0 && code !== null) {
+        this.log.error(`${app.name} exited with code ${code}`);
+      }
+    });
+
+    return proc;
+  }
 }

package/src/cli/core/commands/gen/changelog.ts

@@ -1,6 +1,6 @@
 import { exec } from "node:child_process";
 import { promisify } from "node:util";
-import { $inject, $use, t } from "alepha";
+import { $inject, $state, t } from "alepha";
 import { $command } from "alepha/command";
 import { $logger } from "alepha/logger";
 import { changelogOptions } from "../../atoms/changelogOptions.ts";
@@ -64,7 +64,7 @@ export class ChangelogCommand {
   protected readonly log = $logger();
   protected readonly git = $inject(GitProvider);
   protected readonly parser = $inject(GitMessageParser);
-  protected readonly config = $use(changelogOptions);
+  protected readonly config = $state(changelogOptions);
 
   // ---------------------------------------------------------------------------
   // FORMATTING

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

@@ -43,15 +43,10 @@ export class InitCommand {
             "Include @alepha/ui (components, auth portal, admin portal)",
         }),
       ),
-      auth: t.optional(
+      saas: t.optional(
         t.boolean({
           description:
-            "Include authentication (AppSecurity, $uiAuth). Implies --api --ui --react",
-        }),
-      ),
-      admin: t.optional(
-        t.boolean({
-          description: "Include admin portal ($uiAdmin). Implies --auth",
+            "Include authentication, admin portal, API, UI, and React. Everything you need for a SaaS app.",
         }),
       ),
       tailwind: t.optional(

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

@@ -25,7 +25,6 @@ export class VerifyCommand {
     description: "Verify the Alepha project",
     handler: async ({ root, run }) => {
       await run("alepha clean");
-      await run("alepha format");
       await run("alepha lint");
 
       await run("alepha typecheck");

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

@@ -1,4 +1,4 @@
-import { $inject, $use, AlephaError } from "alepha";
+import { $inject, $state, AlephaError } from "alepha";
 import { FileSystemProvider } from "alepha/system";
 import { appEntryOptions } from "../atoms/appEntryOptions.ts";
 
@@ -9,7 +9,7 @@ import { appEntryOptions } from "../atoms/appEntryOptions.ts";
  */
 export class AppEntryProvider {
   protected readonly fs = $inject(FileSystemProvider);
-  protected readonly options = $use(appEntryOptions);
+  protected readonly options = $state(appEntryOptions);
 
   protected readonly serverEntries = [
     "main.server.ts",