alepha 0.19.1 → 0.19.3

package/src/cli/platform/index.ts

@@ -1,16 +1,18 @@
 import { $module } from "alepha";
 import { AlephaCli } from "alepha/cli";
+import { cliConfigPlugins } from "alepha/cli/config";
 import { CloudflareAdapter } from "./adapters/CloudflareAdapter.ts";
-import { DockerAdapter } from "./adapters/DockerAdapter.ts";
 import { VercelAdapter } from "./adapters/VercelAdapter.ts";
+import {
+  type PlatformOptions,
+  platformOptions,
+} from "./atoms/platformOptions.ts";
 import { PlatformCommand } from "./commands/platform.ts";
 import { SecretsCommand } from "./commands/SecretsCommand.ts";
 import { GitHubSecretStore } from "./providers/GitHubSecretStore.ts";
 import { MemorySecretStore } from "./providers/MemorySecretStore.ts";
 import { PlatformCacheProvider } from "./providers/PlatformCacheProvider.ts";
 import { CloudflareApi } from "./services/CloudflareApi.ts";
-import { DockerComposeGenerator } from "./services/DockerComposeGenerator.ts";
-import { DockerSshService } from "./services/DockerSshService.ts";
 import { NamingService } from "./services/NamingService.ts";
 import { PlatformInspector } from "./services/PlatformInspector.ts";
 import { PlatformOrchestrator } from "./services/PlatformOrchestrator.ts";
@@ -21,17 +23,54 @@ import { WranglerApi } from "./services/WranglerApi.ts";
 
 // ---------------------------------------------------------------------------
 
-export const AlephaCliPlatform = $module({
-  name: "alepha.cli.platform",
+declare module "alepha/cli/config" {
+  interface AlephaCliConfig {
+    platform?: PlatformOptions;
+  }
+}
+
+// ---------------------------------------------------------------------------
+
+/**
+ * CLI plugin for multi-cloud deployment orchestration.
+ *
+ * Manages the full lifecycle of deploying Alepha apps: provision resources,
+ * build, migrate databases, deploy, and sync secrets. Supports Cloudflare
+ * Workers and Vercel.
+ *
+ * Commands:
+ * - `alepha platform plan`    — show project topology and resource names
+ * - `alepha platform up`      — full deployment pipeline
+ * - `alepha platform down`    — teardown an environment
+ * - `alepha platform status`  — inspect deployed resources
+ * - `alepha platform build`   — build apps locally
+ * - `alepha platform deploy`  — deploy to cloud
+ * - `alepha platform migrate` — run database migrations
+ * - `alepha platform secrets` — manage external secret stores
+ *
+ * Configuration in `alepha.config.ts`:
+ *
+ * ```typescript
+ * import { AlephaCliPlatformPlugin } from "alepha/cli/platform";
+ *
+ * export default defineConfig({
+ *   services: [AlephaCliPlatformPlugin],
+ *   platform: {
+ *     environments: {
+ *       production: { adapter: "cloudflare", domain: "myapp.com" },
+ *     },
+ *   },
+ * });
+ * ```
+ */
+export const AlephaCliPlatformPlugin = $module({
+  name: "alepha.cli.plugins.platform",
   services: [
     AlephaCli,
     PlatformCommand,
     SecretsCommand,
     CloudflareAdapter,
     CloudflareApi,
-    DockerAdapter,
-    DockerComposeGenerator,
-    DockerSshService,
     VercelAdapter,
     VercelApi,
     VercelCli,
@@ -48,8 +87,15 @@ export const AlephaCliPlatform = $module({
 
 // ---------------------------------------------------------------------------
 
+cliConfigPlugins.push((config, alepha) => {
+  if (config.platform) {
+    alepha.set(platformOptions, config.platform);
+  }
+});
+
+// ---------------------------------------------------------------------------
+
 export * from "./adapters/CloudflareAdapter.ts";
-export * from "./adapters/DockerAdapter.ts";
 export * from "./adapters/PlatformAdapter.ts";
 export * from "./adapters/VercelAdapter.ts";
 export * from "./atoms/platformOptions.ts";
@@ -63,8 +109,6 @@ export * from "./schemas/cloudflare.ts";
 export * from "./schemas/platform.ts";
 export * from "./schemas/vercel.ts";
 export * from "./services/CloudflareApi.ts";
-export * from "./services/DockerComposeGenerator.ts";
-export * from "./services/DockerSshService.ts";
 export * from "./services/NamingService.ts";
 export * from "./services/PlatformInspector.ts";
 export * from "./services/PlatformOrchestrator.ts";

package/src/cli/platform/services/PlatformInspector.ts

@@ -1,4 +1,4 @@
-import { $inject, $use, Alepha, AlephaError } from "alepha";
+import { $inject, $state, Alepha, AlephaError } from "alepha";
 import { Asker } from "alepha/command";
 import { $logger } from "alepha/logger";
 import { FileSystemProvider } from "alepha/system";
@@ -29,7 +29,7 @@ export class PlatformInspector {
   protected readonly alepha = $inject(Alepha);
   protected readonly fs = $inject(FileSystemProvider);
   protected readonly asker = $inject(Asker);
-  protected readonly options = $use(platformOptions);
+  protected readonly options = $state(platformOptions);
   protected readonly naming = $inject(NamingService);
 
   /**

package/src/cli/platform/services/PlatformOrchestrator.ts

@@ -2,7 +2,6 @@ import { $inject, AlephaError } from "alepha";
 import type { RunnerMethod } from "alepha/command";
 import { $logger, ConsoleColorProvider } from "alepha/logger";
 import { CloudflareAdapter } from "../adapters/CloudflareAdapter.ts";
-import { DockerAdapter } from "../adapters/DockerAdapter.ts";
 import type {
   AppDefinition,
   PlatformAdapter,
@@ -28,7 +27,6 @@ export class PlatformOrchestrator {
   protected readonly inspector = $inject(PlatformInspector);
   protected readonly naming = $inject(NamingService);
   protected readonly cloudflareAdapter = $inject(CloudflareAdapter);
-  protected readonly dockerAdapter = $inject(DockerAdapter);
   protected readonly vercelAdapter = $inject(VercelAdapter);
 
   // -------------------------------------------------------------------------
@@ -39,15 +37,8 @@ export class PlatformOrchestrator {
     switch (adapterName) {
       case "cloudflare":
         return this.cloudflareAdapter;
-      case "docker":
-      case "docker-compose":
-        return this.dockerAdapter;
       case "vercel":
         return this.vercelAdapter;
-      case "aks":
-        throw new AlephaError(
-          `Adapter "${adapterName}" is not yet available. Currently supported: cloudflare, docker, vercel`,
-        );
       default:
         throw new AlephaError(`Unknown adapter: "${adapterName}"`);
     }

package/src/cli/vendor/__tests__/VendorService.spec.ts

@@ -0,0 +1,407 @@
+import { Alepha } from "alepha";
+import {
+  FileSystemProvider,
+  MemoryFileSystemProvider,
+  MemoryShellProvider,
+  ShellProvider,
+} from "alepha/system";
+import { describe, it } from "vitest";
+import { VendorService } from "../services/VendorService.ts";
+
+describe("VendorService", () => {
+  const createTestEnv = () => {
+    const alepha = Alepha.create()
+      .with({ provide: ShellProvider, use: MemoryShellProvider })
+      .with({ provide: FileSystemProvider, use: MemoryFileSystemProvider });
+
+    const service = alepha.inject(VendorService);
+    const shell = alepha.inject(MemoryShellProvider);
+    const fs = alepha.inject(MemoryFileSystemProvider);
+
+    return { service, shell, fs };
+  };
+
+  describe("sync", () => {
+    it("should clone the remote repository", async ({ expect }) => {
+      const { service, shell, fs } = createTestEnv();
+
+      await fs.mkdir("/tmp/.alepha-vendor-fake/packages/my-pkg", {
+        recursive: true,
+      });
+      await fs.writeFile(
+        "/tmp/.alepha-vendor-fake/packages/my-pkg/index.ts",
+        "export {}",
+      );
+
+      await service.sync({
+        root: "/project",
+        remote: "git@github.com:user/repo.git",
+        branch: "main",
+        packages: ["my-pkg"],
+      });
+
+      expect(
+        shell.wasCalledMatching(
+          /git clone --depth 1 --branch main --filter=blob:none git@github.com:user\/repo\.git/,
+        ),
+      ).toBe(true);
+    });
+
+    it("should remove local package dir before copying", async ({ expect }) => {
+      const { service, shell, fs } = createTestEnv();
+
+      /**
+       * Since MemoryShellProvider does not actually clone, we simulate
+       * by pre-populating the temp directory. We override cloneRemote
+       * to return a known path.
+       */
+      class TestVendorService extends VendorService {
+        protected override async cloneRemote(): Promise<string> {
+          await shell.run(
+            "git clone --depth 1 --branch main --filter=blob:none remote /tmp/test-clone",
+          );
+          return "/tmp/test-clone";
+        }
+      }
+
+      const alepha = Alepha.create()
+        .with({ provide: ShellProvider, use: MemoryShellProvider })
+        .with({ provide: FileSystemProvider, use: MemoryFileSystemProvider });
+
+      const testService = alepha.inject(TestVendorService);
+      const testFs = alepha.inject(MemoryFileSystemProvider);
+
+      await testFs.mkdir("/tmp/test-clone/packages/my-pkg", {
+        recursive: true,
+      });
+      await testFs.writeFile(
+        "/tmp/test-clone/packages/my-pkg/index.ts",
+        "export {}",
+      );
+      await testFs.mkdir("/project/packages/my-pkg", { recursive: true });
+      await testFs.writeFile("/project/packages/my-pkg/old-file.ts", "old");
+
+      const result = await testService.sync({
+        root: "/project",
+        remote: "remote",
+        branch: "main",
+        packages: ["my-pkg"],
+        force: true,
+      });
+
+      expect(result.synced).toEqual(["my-pkg"]);
+      expect(result.errors).toEqual([]);
+      expect(testFs.wasDeleted("/project/packages/my-pkg")).toBe(true);
+    });
+
+    it("should report errors for missing remote packages", async ({
+      expect,
+    }) => {
+      class TestVendorService extends VendorService {
+        protected override async cloneRemote(): Promise<string> {
+          return "/tmp/test-clone";
+        }
+      }
+
+      const alepha = Alepha.create()
+        .with({ provide: ShellProvider, use: MemoryShellProvider })
+        .with({ provide: FileSystemProvider, use: MemoryFileSystemProvider });
+
+      const testService = alepha.inject(TestVendorService);
+      const testFs = alepha.inject(MemoryFileSystemProvider);
+
+      await testFs.mkdir("/tmp/test-clone/packages", { recursive: true });
+
+      const result = await testService.sync({
+        root: "/project",
+        remote: "remote",
+        branch: "main",
+        packages: ["missing-pkg"],
+      });
+
+      expect(result.synced).toEqual([]);
+      expect(result.errors).toEqual([
+        'Package "missing-pkg" not found in remote',
+      ]);
+    });
+
+    it("should sync multiple packages", async ({ expect }) => {
+      class TestVendorService extends VendorService {
+        protected override async cloneRemote(): Promise<string> {
+          return "/tmp/test-clone";
+        }
+      }
+
+      const alepha = Alepha.create()
+        .with({ provide: ShellProvider, use: MemoryShellProvider })
+        .with({ provide: FileSystemProvider, use: MemoryFileSystemProvider });
+
+      const testService = alepha.inject(TestVendorService);
+      const testFs = alepha.inject(MemoryFileSystemProvider);
+
+      await testFs.mkdir("/tmp/test-clone/packages/pkg-a", { recursive: true });
+      await testFs.writeFile("/tmp/test-clone/packages/pkg-a/index.ts", "a");
+      await testFs.mkdir("/tmp/test-clone/packages/pkg-b", { recursive: true });
+      await testFs.writeFile("/tmp/test-clone/packages/pkg-b/index.ts", "b");
+
+      const result = await testService.sync({
+        root: "/project",
+        remote: "remote",
+        branch: "main",
+        packages: ["pkg-a", "pkg-b"],
+        force: true,
+      });
+
+      expect(result.synced).toEqual(["pkg-a", "pkg-b"]);
+      expect(result.errors).toEqual([]);
+    });
+
+    it("should clean up temp directory even on error", async ({ expect }) => {
+      class TestVendorService extends VendorService {
+        protected override async cloneRemote(): Promise<string> {
+          return "/tmp/test-clone";
+        }
+      }
+
+      const alepha = Alepha.create()
+        .with({ provide: ShellProvider, use: MemoryShellProvider })
+        .with({ provide: FileSystemProvider, use: MemoryFileSystemProvider });
+
+      const testService = alepha.inject(TestVendorService);
+      const testFs = alepha.inject(MemoryFileSystemProvider);
+
+      await testFs.mkdir("/tmp/test-clone/packages/pkg-a", { recursive: true });
+      await testFs.writeFile("/tmp/test-clone/packages/pkg-a/index.ts", "a");
+
+      /**
+       * Make cp throw to simulate a failure mid-sync.
+       */
+      const originalCp = testFs.cp.bind(testFs);
+      testFs.cp = async () => {
+        throw new Error("disk full");
+      };
+
+      await expect(
+        testService.sync({
+          root: "/project",
+          remote: "remote",
+          branch: "main",
+          packages: ["pkg-a"],
+          force: true,
+        }),
+      ).rejects.toThrow("disk full");
+
+      expect(testFs.wasDeleted("/tmp/test-clone")).toBe(true);
+
+      testFs.cp = originalCp;
+    });
+  });
+
+  describe("diff", () => {
+    it("should clone the remote repository for diff", async ({ expect }) => {
+      const { service, shell } = createTestEnv();
+
+      await service.diff({
+        root: "/project",
+        remote: "git@github.com:user/repo.git",
+        branch: "main",
+        packages: [],
+      });
+
+      expect(
+        shell.wasCalledMatching(
+          /git clone --depth 1 --branch main --filter=blob:none/,
+        ),
+      ).toBe(true);
+    });
+
+    it("should detect added files", async ({ expect }) => {
+      class TestVendorService extends VendorService {
+        protected override async cloneRemote(): Promise<string> {
+          return "/tmp/test-clone";
+        }
+      }
+
+      const alepha = Alepha.create()
+        .with({ provide: ShellProvider, use: MemoryShellProvider })
+        .with({ provide: FileSystemProvider, use: MemoryFileSystemProvider });
+
+      const testService = alepha.inject(TestVendorService);
+      const testFs = alepha.inject(MemoryFileSystemProvider);
+
+      await testFs.mkdir("/tmp/test-clone/packages/pkg", { recursive: true });
+      await testFs.writeFile("/tmp/test-clone/packages/pkg/new-file.ts", "new");
+      await testFs.writeFile("/tmp/test-clone/packages/pkg/shared.ts", "same");
+
+      await testFs.mkdir("/project/packages/pkg", { recursive: true });
+      await testFs.writeFile("/project/packages/pkg/shared.ts", "same");
+
+      const result = await testService.diff({
+        root: "/project",
+        remote: "remote",
+        branch: "main",
+        packages: ["pkg"],
+      });
+
+      expect(result.packages).toHaveLength(1);
+      expect(result.packages[0].added).toEqual(["new-file.ts"]);
+      expect(result.packages[0].modified).toEqual([]);
+      expect(result.packages[0].removed).toEqual([]);
+      expect(result.totalChanges).toBe(1);
+    });
+
+    it("should detect modified files", async ({ expect }) => {
+      class TestVendorService extends VendorService {
+        protected override async cloneRemote(): Promise<string> {
+          return "/tmp/test-clone";
+        }
+      }
+
+      const alepha = Alepha.create()
+        .with({ provide: ShellProvider, use: MemoryShellProvider })
+        .with({ provide: FileSystemProvider, use: MemoryFileSystemProvider });
+
+      const testService = alepha.inject(TestVendorService);
+      const testFs = alepha.inject(MemoryFileSystemProvider);
+
+      await testFs.mkdir("/tmp/test-clone/packages/pkg", { recursive: true });
+      await testFs.writeFile(
+        "/tmp/test-clone/packages/pkg/file.ts",
+        "updated content",
+      );
+
+      await testFs.mkdir("/project/packages/pkg", { recursive: true });
+      await testFs.writeFile(
+        "/project/packages/pkg/file.ts",
+        "original content",
+      );
+
+      const result = await testService.diff({
+        root: "/project",
+        remote: "remote",
+        branch: "main",
+        packages: ["pkg"],
+      });
+
+      expect(result.packages[0].modified).toEqual(["file.ts"]);
+      expect(result.totalChanges).toBe(1);
+    });
+
+    it("should detect removed files", async ({ expect }) => {
+      class TestVendorService extends VendorService {
+        protected override async cloneRemote(): Promise<string> {
+          return "/tmp/test-clone";
+        }
+      }
+
+      const alepha = Alepha.create()
+        .with({ provide: ShellProvider, use: MemoryShellProvider })
+        .with({ provide: FileSystemProvider, use: MemoryFileSystemProvider });
+
+      const testService = alepha.inject(TestVendorService);
+      const testFs = alepha.inject(MemoryFileSystemProvider);
+
+      await testFs.mkdir("/tmp/test-clone/packages/pkg", { recursive: true });
+      await testFs.writeFile("/tmp/test-clone/packages/pkg/shared.ts", "same");
+
+      await testFs.mkdir("/project/packages/pkg", { recursive: true });
+      await testFs.writeFile("/project/packages/pkg/shared.ts", "same");
+      await testFs.writeFile("/project/packages/pkg/local-only.ts", "local");
+
+      const result = await testService.diff({
+        root: "/project",
+        remote: "remote",
+        branch: "main",
+        packages: ["pkg"],
+      });
+
+      expect(result.packages[0].removed).toEqual(["local-only.ts"]);
+      expect(result.totalChanges).toBe(1);
+    });
+
+    it("should handle package only in local", async ({ expect }) => {
+      class TestVendorService extends VendorService {
+        protected override async cloneRemote(): Promise<string> {
+          return "/tmp/test-clone";
+        }
+      }
+
+      const alepha = Alepha.create()
+        .with({ provide: ShellProvider, use: MemoryShellProvider })
+        .with({ provide: FileSystemProvider, use: MemoryFileSystemProvider });
+
+      const testService = alepha.inject(TestVendorService);
+      const testFs = alepha.inject(MemoryFileSystemProvider);
+
+      await testFs.mkdir("/tmp/test-clone/packages", { recursive: true });
+      await testFs.mkdir("/project/packages/pkg", { recursive: true });
+      await testFs.writeFile("/project/packages/pkg/file.ts", "local");
+
+      const result = await testService.diff({
+        root: "/project",
+        remote: "remote",
+        branch: "main",
+        packages: ["pkg"],
+      });
+
+      expect(result.packages[0].removed).toEqual(["file.ts"]);
+      expect(result.packages[0].added).toEqual([]);
+      expect(result.totalChanges).toBe(1);
+    });
+
+    it("should handle package only in remote", async ({ expect }) => {
+      class TestVendorService extends VendorService {
+        protected override async cloneRemote(): Promise<string> {
+          return "/tmp/test-clone";
+        }
+      }
+
+      const alepha = Alepha.create()
+        .with({ provide: ShellProvider, use: MemoryShellProvider })
+        .with({ provide: FileSystemProvider, use: MemoryFileSystemProvider });
+
+      const testService = alepha.inject(TestVendorService);
+      const testFs = alepha.inject(MemoryFileSystemProvider);
+
+      await testFs.mkdir("/tmp/test-clone/packages/pkg", { recursive: true });
+      await testFs.writeFile("/tmp/test-clone/packages/pkg/file.ts", "remote");
+
+      const result = await testService.diff({
+        root: "/project",
+        remote: "remote",
+        branch: "main",
+        packages: ["pkg"],
+      });
+
+      expect(result.packages[0].added).toEqual(["file.ts"]);
+      expect(result.packages[0].removed).toEqual([]);
+      expect(result.totalChanges).toBe(1);
+    });
+
+    it("should clean up temp directory after diff", async ({ expect }) => {
+      class TestVendorService extends VendorService {
+        protected override async cloneRemote(): Promise<string> {
+          return "/tmp/test-clone";
+        }
+      }
+
+      const alepha = Alepha.create()
+        .with({ provide: ShellProvider, use: MemoryShellProvider })
+        .with({ provide: FileSystemProvider, use: MemoryFileSystemProvider });
+
+      const testService = alepha.inject(TestVendorService);
+      const testFs = alepha.inject(MemoryFileSystemProvider);
+
+      await testFs.mkdir("/tmp/test-clone/packages", { recursive: true });
+
+      await testService.diff({
+        root: "/project",
+        remote: "remote",
+        branch: "main",
+        packages: [],
+      });
+
+      expect(testFs.wasDeleted("/tmp/test-clone")).toBe(true);
+    });
+  });
+});

package/src/cli/vendor/atoms/vendorOptions.ts

@@ -0,0 +1,41 @@
+import { $atom, type Static, t } from "alepha";
+
+/**
+ * Vendor configuration atom.
+ *
+ * Filled from the `vendor` section of `alepha.config.ts`.
+ * Read by `VendorCommand` to resolve remote, branch, and packages.
+ */
+export const vendorOptions = $atom({
+  name: "alepha.cli.vendor.options",
+  description: "Vendor synchronization configuration",
+  schema: t.optional(
+    t.object({
+      /**
+       * Git remote URL.
+       *
+       * @default "git@github.com:feunard/alepha.git"
+       */
+      remote: t.optional(t.text()),
+
+      /**
+       * Branch to sync from.
+       *
+       * @default "main"
+       */
+      branch: t.optional(t.text()),
+
+      /**
+       * Package directory names under `packages/` to sync.
+       *
+       * @example ["alepha", "@alepha/bucket-s3"]
+       */
+      packages: t.array(t.text()),
+    }),
+  ),
+});
+
+/**
+ * Type for vendor options.
+ */
+export type VendorOptions = Static<typeof vendorOptions.schema>;