@ankhorage/infra 4.1.10 → 5.0.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ankhorage/infra",
   "type": "module",
-  "version": "4.1.10",
+  "version": "5.0.0",
   "description": "Project-aware infrastructure generation library and executable Ankh provider for Ankhorage.",
   "homepage": "https://github.com/ankhorage/infra#readme",
   "bugs": {
@@ -35,8 +35,7 @@
     "openapi"
   ],
   "dependencies": {
-    "@ankhorage/contracts": "^11.0.0",
-    "@ankhorage/supabase-vault": "^0.2.9"
+    "@ankhorage/contracts": "^19.0.0"
   },
   "files": [
     "dist",
@@ -77,11 +76,13 @@
     "provider": "./dist/cli/index.js",
     "capabilities": [
       "infra.validate",
+      "infra.plan",
       "infra.generate",
-      "infra.status",
       "infra.up",
+      "infra.status",
+      "infra.outputs",
       "infra.down",
-      "infra.secret-store"
+      "infra.destroy"
     ]
   },
   "publishConfig": {
@@ -98,20 +99,29 @@
     "format:check": "ankhorage-prettier --check .",
     "prepack": "bun run build",
     "test": "bun test src",
-    "test:e2e": "bun run test:e2e:supabase",
-    "test:e2e:minikube": "ANKH_MINIKUBE_ISOLATION=1 bun test src/adapters/minikube/base/twoAppIsolation.integration.test.ts",
-    "test:e2e:supabase": "ANKH_MINIKUBE_SUPABASE_ISOLATION=1 bun test src/adapters/minikube/base/twoAppIsolation.integration.test.ts",
+    "test:e2e": "ANKH_INFRA_COMPOSITION_E2E=1 bun test src/infraComposition.integration.test.ts",
     "typecheck": "bun x tsc --noEmit -p tsconfig.json",
+    "check-types": "bun run typecheck",
     "version-packages": "ankhorage-changeset version",
-    "knip:check": "ankhorage-knip"
+    "knip:check": "ankhorage-knip",
+    "knip:test": "bun run knip:check"
   },
   "devDependencies": {
     "@ankhorage/ankh": "^0.8.11",
-    "@ankhorage/devtools": "^1.11.1",
+    "@ankhorage/cerbos": "^0.2.0",
+    "@ankhorage/devtools": "^1.14.0",
+    "@ankhorage/docker-compose": "^0.4.0",
+    "@ankhorage/hetzner": "^0.3.0",
+    "@ankhorage/k3s": "^0.3.0",
+    "@ankhorage/local": "^0.3.0",
+    "@ankhorage/minikube": "^0.3.0",
     "@ankhorage/paradox": "^0.1.24",
+    "@ankhorage/r2": "^0.2.0",
+    "@ankhorage/supabase": "^0.2.0",
+    "@ankhorage/supabase-vault": "^0.3.1",
     "@types/bun": "^1.4.1",
     "@types/node": "^25.6.0",
     "typescript": "^5.9.3"
   },
-  "packageManager": "bun@1.4.1"
+  "packageManager": "bun@1.4.2"
 }

package/src/adapterPackages.integration.test.ts

@@ -0,0 +1,79 @@
+import type { InfraEnvironmentSpec } from '@ankhorage/contracts/infra';
+import { expect, test } from 'bun:test';
+
+import { createNodeInfraAdapterPackageResolver } from './features/environment-lifecycle/adapters/outbound/createNodeInfraAdapterPackageResolver.js';
+import { resolveInfraAdaptersAsync } from './features/environment-lifecycle/application/use-cases/resolveInfraAdaptersAsync.js';
+
+test('loads every published package in the required provider composition matrix', async () => {
+  const environments = [
+    environment('local', 'minikube'),
+    environment('local', 'k3s'),
+    environment('local', 'docker-compose'),
+    production(false),
+    production(true),
+  ];
+  const resolved = await Promise.all(
+    environments.map((desired) =>
+      resolveInfraAdaptersAsync(desired, createNodeInfraAdapterPackageResolver()),
+    ),
+  );
+  expect(resolved.every(({ ok }) => ok)).toBe(true);
+  expect(
+    new Set(
+      resolved.flatMap((result) =>
+        result.ok
+          ? [
+              result.value.compute.descriptor.id,
+              result.value.runtime.descriptor.id,
+              ...result.value.services.map(({ descriptor }) => descriptor.id),
+            ]
+          : [],
+      ),
+    ),
+  ).toEqual(
+    new Set([
+      'local',
+      'hetzner',
+      'minikube',
+      'k3s',
+      'docker-compose',
+      'supabase',
+      'cerbos',
+      'r2',
+      'supabase-vault',
+    ]),
+  );
+});
+
+function environment(
+  compute: 'local',
+  runtime: 'minikube' | 'k3s' | 'docker-compose',
+): InfraEnvironmentSpec {
+  if (runtime === 'minikube') {
+    return {
+      deployment: { compute: { provider: compute }, runtime: { provider: runtime } },
+      database: { provider: 'supabase' },
+    };
+  }
+  return {
+    deployment: { compute: { provider: compute }, runtime: { provider: runtime } },
+    database: { provider: 'supabase' },
+  };
+}
+
+function production(withOptionalServices: boolean): InfraEnvironmentSpec {
+  return {
+    deployment: {
+      compute: { provider: 'hetzner', location: 'nbg1' },
+      runtime: { provider: 'k3s', topology: { servers: 1, agents: 0 } },
+    },
+    database: { provider: 'supabase' },
+    ...(withOptionalServices
+      ? {
+          objectStorage: { provider: 'r2' as const, buckets: ['media'] },
+          authz: { provider: 'cerbos' as const, kind: 'ABAC' as const },
+          secretStore: { provider: 'supabase-vault' as const },
+        }
+      : {}),
+  };
+}

package/src/cli/bin.ts

@@ -1,67 +1,8 @@
 #!/usr/bin/env bun
 
-import type { InfraCommandContext, InfraCommandRunResult } from '../commandContext.js';
-import { createDefaultCommandContext } from '../commandContext.js';
-import {
-  findInfraCommandByStandaloneName,
-  type InfraCommandServices,
-  renderRootHelp,
-  renderUnknownCommand,
-  runInfraCommand,
-  type RunInfraCommandImpl,
-} from '../commands.js';
-
-export interface InfraCliOptions {
-  readonly context?: InfraCommandContext;
-  readonly runCommandImpl?: RunInfraCommandImpl;
-  readonly services?: Partial<InfraCommandServices>;
-}
-
-export async function runCli(
-  argv: readonly string[],
-  options: InfraCliOptions = {},
-): Promise<InfraCommandRunResult> {
-  const context = options.context ?? createDefaultCommandContext();
-  const runCommand = options.runCommandImpl ?? runInfraCommand;
-  const [firstToken, ...restTokens] = argv;
-
-  if (firstToken === undefined || isHelpToken(firstToken)) {
-    context.writeStdout(renderRootHelp(context.version));
-    return { exitCode: 0 };
-  }
-
-  if (isVersionToken(firstToken)) {
-    context.writeStdout(`${context.version}\n`);
-    return { exitCode: 0 };
-  }
-
-  const command = findInfraCommandByStandaloneName(firstToken);
-  if (command === null) {
-    context.writeStderr(renderUnknownCommand(firstToken));
-    return { exitCode: 1 };
-  }
-
-  return runCommand(
-    {
-      argv: restTokens,
-      command,
-      context,
-    },
-    {
-      services: options.services,
-    },
-  );
-}
-
-function isHelpToken(value: string): boolean {
-  return value === '--help' || value === '-h' || value === 'help';
-}
-
-function isVersionToken(value: string): boolean {
-  return value === '--version' || value === '-v' || value === 'version';
-}
+import { runInfraCliAsync } from './runInfraCliAsync.js';
 
 if (import.meta.main) {
-  const result = await runCli(process.argv.slice(2));
+  const result = await runInfraCliAsync(process.argv.slice(2));
   process.exit(result.exitCode);
 }

package/src/cli/cli.test.ts

@@ -1,137 +1,46 @@
-import type { AnkhDiscoveredPackage, AnkhLoadedProvider } from '@ankhorage/ankh';
-import {
-  createPackageRegistry,
-  createProviderRegistry,
-  runCli as runAnkhCli,
-} from '@ankhorage/ankh';
 import { describe, expect, test } from 'bun:test';
 
 import { createCapturedCommandContext } from '../testSupport.js';
-import { runCli } from './bin.js';
-import { createInfraRuntimeProvider } from './index.js';
+import { runInfraCliAsync } from './runInfraCliAsync.js';
 
-describe('standalone cli and provider-backed dispatch', () => {
-  test('prints help and version for the standalone CLI', async () => {
+describe('standalone Infra CLI', () => {
+  test('prints help/version and dispatches all commands through the shared runner', async () => {
     const help = createCapturedCommandContext('/workspace', '9.9.9');
     const version = createCapturedCommandContext('/workspace', '9.9.9');
-
-    expect((await runCli([], { context: help.context })).exitCode).toBe(0);
-    expect(help.stdout.value).toContain('ankhorage-infra <command> [project]');
-    expect(help.stdout.value).not.toContain('port-forward');
-
-    expect((await runCli(['--version'], { context: version.context })).exitCode).toBe(0);
+    expect((await runInfraCliAsync([], { context: help.context })).exitCode).toBe(0);
+    expect(help.stdout.value).toContain('ankhorage-infra <command>');
+    expect(help.stdout.value).toContain('destroy');
+    expect((await runInfraCliAsync(['--version'], { context: version.context })).exitCode).toBe(0);
     expect(version.stdout.value).toBe('9.9.9\n');
-  });
 
-  test('uses the shared command runner for standalone CLI dispatch', async () => {
-    const captured = createCapturedCommandContext('/workspace');
     const calls: string[] = [];
-
-    const result = await runCli(['validate', 'shop'], {
-      context: captured.context,
-      runCommandImpl(request) {
-        calls.push(request.command.standaloneName);
-        request.context.writeStdout(
-          `ran:${request.command.standaloneName}:${request.argv.join(',')}\n`,
-        );
-        return Promise.resolve({ exitCode: 0 });
-      },
-    });
-
-    expect(result.exitCode).toBe(0);
-    expect(calls).toEqual(['validate']);
-    expect(captured.stdout.value).toContain('ran:validate:shop');
-  });
-
-  test('routes provider-backed dispatch through @ankhorage/ankh', async () => {
-    const captured = createCapturedCommandContext('/workspace');
-    const calls: string[] = [];
-    const provider = createInfraRuntimeProvider({
-      runCommandImpl(request) {
-        calls.push(request.command.standaloneName);
-        request.context.writeStdout(`provider:${request.command.standaloneName}\n`);
-        return Promise.resolve({ exitCode: 0 });
-      },
-    });
-
-    const packageRegistry = createPackageRegistry([createDiscoveredPackage()]);
-    const providerRegistry = createProviderRegistry([createLoadedProvider(provider)]);
-
-    const result = await runAnkhCli(['infra', 'status', 'shop'], {
-      context: captured.context,
-      registry: packageRegistry,
-      providerRegistry,
-    });
-
-    expect(result.exitCode).toBe(0);
-    expect(calls).toEqual(['status']);
-    expect(captured.stdout.value).toContain('provider:status');
-  });
-
-  test('uses the same injected shared runner from both surfaces', async () => {
-    const standalone = createCapturedCommandContext('/workspace');
-    const providerContext = createCapturedCommandContext('/workspace');
-    const calls: string[] = [];
-
-    const runCommandImpl = (request: {
-      readonly argv: readonly string[];
-      readonly command: { readonly standaloneName: string };
-      readonly context: { writeStdout(text: string): void };
-    }) => {
-      calls.push(request.command.standaloneName);
-      request.context.writeStdout(`shared:${request.command.standaloneName}\n`);
-      return Promise.resolve({ exitCode: 0 });
-    };
-
-    await runCli(['generate', 'shop'], {
-      context: standalone.context,
-      runCommandImpl,
-    });
-
-    const provider = createInfraRuntimeProvider({ runCommandImpl });
-    const packageRegistry = createPackageRegistry([createDiscoveredPackage()]);
-    const providerRegistry = createProviderRegistry([createLoadedProvider(provider)]);
-
-    await runAnkhCli(['infra', 'generate', 'shop'], {
-      context: providerContext.context,
-      registry: packageRegistry,
-      providerRegistry,
-    });
-
-    expect(calls).toEqual(['generate', 'generate']);
-    expect(standalone.stdout.value).toContain('shared:generate');
-    expect(providerContext.stdout.value).toContain('shared:generate');
+    for (const name of [
+      'validate',
+      'plan',
+      'generate',
+      'up',
+      'status',
+      'outputs',
+      'down',
+      'destroy',
+    ]) {
+      await runInfraCliAsync([name, 'shop'], {
+        context: createCapturedCommandContext('/workspace').context,
+        runCommandImpl(request) {
+          calls.push(request.command.standaloneName);
+          return Promise.resolve({ exitCode: 0 });
+        },
+      });
+    }
+    expect(calls).toEqual([
+      'validate',
+      'plan',
+      'generate',
+      'up',
+      'status',
+      'outputs',
+      'down',
+      'destroy',
+    ]);
   });
 });
-
-function createDiscoveredPackage(): AnkhDiscoveredPackage {
-  return {
-    metadata: {
-      category: 'infra',
-      provider: './dist/cli/index.js',
-      capabilities: ['infra.validate', 'infra.generate', 'infra.status', 'infra.up', 'infra.down'],
-    },
-    packageJsonPath: '/workspace/package.json',
-    packageName: '@ankhorage/infra',
-    packageRoot: '/workspace',
-    source: 'workspace',
-  };
-}
-
-function createLoadedProvider(
-  provider: ReturnType<typeof createInfraRuntimeProvider>,
-): AnkhLoadedProvider {
-  return {
-    discoveredPackage: createDiscoveredPackage(),
-    manifest: {
-      id: provider.id,
-      category: provider.category,
-      version: provider.version,
-      capabilities: provider.capabilities,
-      commands: provider.commands,
-    },
-    providerModuleDefaultExport: provider,
-    providerModulePath: '/workspace/dist/cli/index.js',
-    providerModuleUrl: 'file:///workspace/dist/cli/index.js',
-  };
-}

package/src/cli/commands/destroy.ts

@@ -0,0 +1,57 @@
+import type { AppEnvironmentId } from '@ankhorage/contracts/environments';
+
+import { INFRA_CAPABILITIES } from '../../constants.js';
+import type { InfraCommandDefinition } from '../../types/infraCli.js';
+import type { InfraDestroyOperationRequest } from '../../types/infraOrchestration.js';
+import { prepareInfraCommandOperationAsync } from '../utils/prepareInfraCommandOperationAsync.js';
+import { requireInfraSuccess } from '../utils/requireInfraSuccess.js';
+import { resolveInfraPersistence } from '../utils/resolveInfraPersistence.js';
+import { writeInfraStructured } from '../utils/writeInfraStructured.js';
+
+/*** Define exact-scope destruction behind environment and persistent-resource confirmation. */
+export const destroy = {
+  standaloneName: 'destroy',
+  path: ['destroy'],
+  capability: INFRA_CAPABILITIES[7],
+  summary: 'Destroy exact owned resources behind explicit confirmation.',
+  async run(request, services) {
+    const operation = await prepareInfraCommandOperationAsync(request, services, true);
+    const environment = requireEnvironment(request.arguments.environment);
+    const confirmation = `${operation.project.projectId}:${environment}`;
+    if (request.arguments.confirmation !== confirmation) {
+      throw new Error(`Infra destroy requires --confirm ${confirmation}.`);
+    }
+    const destroyRequest: InfraDestroyOperationRequest = {
+      ...operation.operation,
+      environment,
+      confirmation: { projectId: operation.project.projectId, environment },
+      persistence: resolveInfraPersistence(
+        operation.state?.ledger,
+        request.arguments.deleteResources,
+      ),
+    };
+    const result = await services.operations.destroy(destroyRequest, operation.dependencies);
+    requireInfraSuccess(result, request.context);
+    await services.writeArtifacts(operation.project.projectPath, [], operation.state?.ledger);
+    if (result.value.ledger === null) {
+      await services.removeState(operation.project.projectPath, environment);
+    } else {
+      await services.writeState(operation.project.projectPath, {
+        schemaVersion: 1,
+        desired: operation.desired,
+        ledger: result.value.ledger,
+      });
+    }
+    writeInfraStructured(request.context, request.arguments.format, {
+      environment: result.value.environment,
+      retainedResources: result.value.ledger?.resources.length ?? 0,
+    });
+    return { exitCode: 0 };
+  },
+} as const satisfies InfraCommandDefinition;
+
+/*** Require the explicit destroy environment after CLI parsing. */
+function requireEnvironment(value: AppEnvironmentId | undefined): AppEnvironmentId {
+  if (value === undefined) throw new Error('Infra destroy requires an explicit environment.');
+  return value;
+}

package/src/cli/commands/down.ts

@@ -0,0 +1,28 @@
+import { INFRA_CAPABILITIES } from '../../constants.js';
+import type { InfraCommandDefinition } from '../../types/infraCli.js';
+import { prepareInfraCommandOperationAsync } from '../utils/prepareInfraCommandOperationAsync.js';
+import { requireInfraSuccess } from '../utils/requireInfraSuccess.js';
+import { writeInfraStructured } from '../utils/writeInfraStructured.js';
+
+/*** Define reversible runtime suspension while retaining persistent resources. */
+export const down = {
+  standaloneName: 'down',
+  path: ['down'],
+  capability: INFRA_CAPABILITIES[6],
+  summary: 'Reversibly suspend runtime workloads while retaining persistent data.',
+  async run(request, services) {
+    const operation = await prepareInfraCommandOperationAsync(request, services);
+    const result = await services.operations.down(operation.operation, operation.dependencies);
+    requireInfraSuccess(result, request.context);
+    await services.writeState(operation.project.projectPath, {
+      schemaVersion: 1,
+      desired: operation.desired,
+      ledger: result.value.ledger,
+    });
+    writeInfraStructured(request.context, request.arguments.format, {
+      environment: result.value.environment,
+      state: 'stopped',
+    });
+    return { exitCode: 0 };
+  },
+} as const satisfies InfraCommandDefinition;

package/src/cli/commands/generate.ts

@@ -0,0 +1,34 @@
+import { INFRA_CAPABILITIES } from '../../constants.js';
+import type { InfraCommandDefinition } from '../../types/infraCli.js';
+import { prepareInfraCommandOperationAsync } from '../utils/prepareInfraCommandOperationAsync.js';
+import { requireInfraSuccess } from '../utils/requireInfraSuccess.js';
+import { writeInfraStructured } from '../utils/writeInfraStructured.js';
+
+/*** Define deterministic review-artifact generation without remote side effects. */
+export const generate = {
+  standaloneName: 'generate',
+  path: ['generate'],
+  capability: INFRA_CAPABILITIES[2],
+  summary: 'Generate deterministic review artifacts without remote side effects.',
+  async run(request, services) {
+    const operation = await prepareInfraCommandOperationAsync(request, services);
+    const result = await services.operations.generate(operation.operation, operation.dependencies);
+    requireInfraSuccess(result, request.context);
+    const written = await services.writeArtifacts(
+      operation.project.projectPath,
+      result.value.artifacts,
+      operation.state?.ledger,
+    );
+    await services.writeState(operation.project.projectPath, {
+      schemaVersion: 1,
+      desired: operation.desired,
+      ledger: result.value.ledger,
+    });
+    writeInfraStructured(request.context, request.arguments.format, {
+      environment: result.value.environment,
+      ...written,
+      artifacts: result.value.artifacts.map(({ path }) => path),
+    });
+    return { exitCode: 0 };
+  },
+} as const satisfies InfraCommandDefinition;

package/src/cli/commands/outputs.ts

@@ -0,0 +1,25 @@
+import { INFRA_CAPABILITIES } from '../../constants.js';
+import type { InfraCommandDefinition } from '../../types/infraCli.js';
+import { prepareInfraCommandOperationAsync } from '../utils/prepareInfraCommandOperationAsync.js';
+import { requireInfraSuccess } from '../utils/requireInfraSuccess.js';
+import { writeInfraEnvironmentOutputs } from '../utils/writeInfraEnvironmentOutputs.js';
+import { writeInfraStructured } from '../utils/writeInfraStructured.js';
+
+/*** Define safe public-output and secret-reference presentation. */
+export const outputs = {
+  standaloneName: 'outputs',
+  path: ['outputs'],
+  capability: INFRA_CAPABILITIES[5],
+  summary: 'Print safe public outputs and secret references.',
+  async run(request, services) {
+    const operation = await prepareInfraCommandOperationAsync(request, services);
+    const result = services.operations.outputs(operation.operation);
+    requireInfraSuccess(result, request.context);
+    if (request.arguments.format === 'env') {
+      writeInfraEnvironmentOutputs(request.context, result.value.outputs);
+    } else {
+      writeInfraStructured(request.context, request.arguments.format, result.value);
+    }
+    return { exitCode: 0 };
+  },
+} as const satisfies InfraCommandDefinition;

package/src/cli/commands/plan.ts

@@ -0,0 +1,20 @@
+import { INFRA_CAPABILITIES } from '../../constants.js';
+import type { InfraCommandDefinition } from '../../types/infraCli.js';
+import { prepareInfraCommandOperationAsync } from '../utils/prepareInfraCommandOperationAsync.js';
+import { requireInfraSuccess } from '../utils/requireInfraSuccess.js';
+import { writeInfraStructured } from '../utils/writeInfraStructured.js';
+
+/*** Define the ordered side-effect-free infrastructure planning command. */
+export const plan = {
+  standaloneName: 'plan',
+  path: ['plan'],
+  capability: INFRA_CAPABILITIES[1],
+  summary: 'Print an ordered side-effect-free infrastructure plan.',
+  async run(request, services) {
+    const operation = await prepareInfraCommandOperationAsync(request, services);
+    const result = await services.operations.plan(operation.operation, operation.dependencies);
+    requireInfraSuccess(result, request.context);
+    writeInfraStructured(request.context, request.arguments.format, result.value);
+    return { exitCode: 0 };
+  },
+} as const satisfies InfraCommandDefinition;

package/src/cli/commands/status.ts

@@ -0,0 +1,20 @@
+import { INFRA_CAPABILITIES } from '../../constants.js';
+import type { InfraCommandDefinition } from '../../types/infraCli.js';
+import { prepareInfraCommandOperationAsync } from '../utils/prepareInfraCommandOperationAsync.js';
+import { requireInfraSuccess } from '../utils/requireInfraSuccess.js';
+import { writeInfraStructured } from '../utils/writeInfraStructured.js';
+
+/*** Define provider-neutral environment status aggregation. */
+export const status = {
+  standaloneName: 'status',
+  path: ['status'],
+  capability: INFRA_CAPABILITIES[4],
+  summary: 'Aggregate provider-neutral environment status.',
+  async run(request, services) {
+    const operation = await prepareInfraCommandOperationAsync(request, services);
+    const result = await services.operations.status(operation.operation, operation.dependencies);
+    requireInfraSuccess(result, request.context);
+    writeInfraStructured(request.context, request.arguments.format, result.value);
+    return { exitCode: 0 };
+  },
+} as const satisfies InfraCommandDefinition;

package/src/cli/commands/up.ts

@@ -0,0 +1,29 @@
+import { INFRA_CAPABILITIES } from '../../constants.js';
+import type { InfraCommandDefinition } from '../../types/infraCli.js';
+import { prepareInfraCommandOperationAsync } from '../utils/prepareInfraCommandOperationAsync.js';
+import { requireInfraSuccess } from '../utils/requireInfraSuccess.js';
+import { writeInfraStructured } from '../utils/writeInfraStructured.js';
+
+/*** Define idempotent environment creation and reconciliation. */
+export const up = {
+  standaloneName: 'up',
+  path: ['up'],
+  capability: INFRA_CAPABILITIES[3],
+  summary: 'Idempotently ensure and reconcile the selected environment.',
+  async run(request, services) {
+    const operation = await prepareInfraCommandOperationAsync(request, services);
+    const result = await services.operations.up(operation.operation, operation.dependencies);
+    requireInfraSuccess(result, request.context);
+    await services.writeState(operation.project.projectPath, {
+      schemaVersion: 1,
+      desired: operation.desired,
+      ledger: result.value.ledger,
+    });
+    writeInfraStructured(request.context, request.arguments.format, {
+      environment: result.value.environment,
+      resources: result.value.resources.length,
+      outputs: result.value.outputs,
+    });
+    return { exitCode: 0 };
+  },
+} as const satisfies InfraCommandDefinition;

package/src/cli/commands/validate.ts

@@ -0,0 +1,20 @@
+import { INFRA_CAPABILITIES } from '../../constants.js';
+import type { InfraCommandDefinition } from '../../types/infraCli.js';
+import { prepareInfraCommandOperationAsync } from '../utils/prepareInfraCommandOperationAsync.js';
+import { requireInfraSuccess } from '../utils/requireInfraSuccess.js';
+import { writeInfraStructured } from '../utils/writeInfraStructured.js';
+
+/*** Define the manifest, compatibility, credential and selected-adapter validation command. */
+export const validate = {
+  standaloneName: 'validate',
+  path: ['validate'],
+  capability: INFRA_CAPABILITIES[0],
+  summary: 'Validate manifest, compatibility, credentials and selected adapters.',
+  async run(request, services) {
+    const operation = await prepareInfraCommandOperationAsync(request, services);
+    const result = await services.operations.validate(operation.operation, operation.dependencies);
+    requireInfraSuccess(result, request.context);
+    writeInfraStructured(request.context, request.arguments.format, result.value);
+    return { exitCode: 0 };
+  },
+} as const satisfies InfraCommandDefinition;

package/src/cli/constants.ts

@@ -0,0 +1,19 @@
+import { destroy } from './commands/destroy.js';
+import { down } from './commands/down.js';
+import { generate } from './commands/generate.js';
+import { outputs } from './commands/outputs.js';
+import { plan } from './commands/plan.js';
+import { status } from './commands/status.js';
+import { up } from './commands/up.js';
+import { validate } from './commands/validate.js';
+
+export const INFRA_COMMANDS = [
+  validate,
+  plan,
+  generate,
+  up,
+  status,
+  outputs,
+  down,
+  destroy,
+] as const;