@ankhorage/infra 4.1.12 → 5.0.0

package/src/projectInfrastructure.test.ts

@@ -1,203 +1,148 @@
+import type { InfraGeneratedArtifact, InfraLedger } from '@ankhorage/contracts/infra';
 import { afterEach, describe, expect, test } from 'bun:test';
 import { promises as fs } from 'fs';
 import os from 'os';
 import path from 'path';
 
 import {
+  readStoredInfraStateAsync,
+  removeStoredInfraStateAsync,
   resolveProjectFile,
-  resolveProjectInfrastructureTarget,
-  syncProjectInfrastructure,
-} from './projectInfrastructure.js';
-import { createAppManifest } from './testSupport.js';
+  writeInfraGeneratedArtifactsAsync,
+  writeStoredInfraStateAsync,
+} from './project/index.js';
 
-const tempRoots = new Set<string>();
+const temporaryPaths = new Set<string>();
 
 afterEach(async () => {
   await Promise.all(
-    [...tempRoots].map((rootPath) => fs.rm(rootPath, { force: true, recursive: true })),
+    [...temporaryPaths].map((entry) => fs.rm(entry, { force: true, recursive: true })),
   );
-  tempRoots.clear();
+  temporaryPaths.clear();
 });
 
-describe('project infrastructure sync', () => {
-  test('writes generated files and the infra ledger', async () => {
-    const projectPath = await fs.mkdtemp(path.join(os.tmpdir(), 'infra-sync-'));
-    tempRoots.add(projectPath);
-
-    const result = await syncProjectInfrastructure({
-      projectId: 'shop',
-      projectPath,
-      manifest: createAppManifest('shop', {
-        deployment: { target: 'minikube', monitoring: false },
-        modules: [],
-      }),
-      generateInfrastructureImpl() {
-        return {
-          files: [
-            {
-              path: 'infra/minikube/scripts/status.sh',
-              content: '#!/usr/bin/env bash\n',
-              executable: true,
-            },
-            { path: 'infra/minikube/.env.example', content: 'APP_PORT=1\n' },
-          ],
-          warnings: ['generated warning'],
-          meta: {
-            target: 'minikube',
-            providers: [],
-          },
-          dependencies: [],
-        };
-      },
-    });
-
-    expect(result.generated).toBe(2);
-    expect(result.removed).toBe(0);
-    expect(result.warnings).toEqual(['generated warning']);
-    expect(await fs.readFile(path.join(projectPath, 'infra/minikube/.env.example'), 'utf8')).toBe(
-      'APP_PORT=1\n',
-    );
-
-    const ledger = JSON.parse(
-      await fs.readFile(path.join(projectPath, '.ankh/infra-ledger.json'), 'utf8'),
-    ) as {
-      readonly target: string;
-      readonly files: readonly string[];
-    };
-    expect(ledger.target).toBe('minikube');
-    expect(ledger.files).toEqual([
-      'infra/minikube/.env.example',
-      'infra/minikube/scripts/status.sh',
-    ]);
-  });
-
-  test('removes stale files when regeneration shrinks the output set', async () => {
-    const projectPath = await fs.mkdtemp(path.join(os.tmpdir(), 'infra-stale-'));
-    tempRoots.add(projectPath);
-
-    const manifest = createAppManifest('shop', {
-      deployment: { target: 'minikube', monitoring: false },
-      modules: [],
-    });
-
-    await syncProjectInfrastructure({
-      projectId: 'shop',
-      projectPath,
-      manifest,
-      generateInfrastructureImpl() {
-        return {
-          files: [
-            { path: 'infra/minikube/scripts/status.sh', content: 'first' },
-            { path: 'infra/minikube/scripts/up.sh', content: 'extra' },
-          ],
-          warnings: [],
-          meta: { target: 'minikube', providers: [] },
-          dependencies: [],
-        };
-      },
+describe('project Infra state and artifacts', () => {
+  test('persists environment-scoped desired state and a secret-safe ledger', async () => {
+    const projectPath = await temporaryProject();
+    await writeStoredInfraStateAsync(projectPath, {
+      schemaVersion: 1,
+      desired: desired,
+      ledger: ledger([]),
     });
-
-    const result = await syncProjectInfrastructure({
-      projectId: 'shop',
-      projectPath,
-      manifest,
-      generateInfrastructureImpl() {
-        return {
-          files: [{ path: 'infra/minikube/scripts/status.sh', content: 'second' }],
-          warnings: [],
-          meta: { target: 'minikube', providers: [] },
-          dependencies: [],
-        };
-      },
+    expect(await readStoredInfraStateAsync(projectPath, 'local')).toEqual({
+      schemaVersion: 1,
+      desired,
+      ledger: ledger([]),
     });
-
-    expect(result.removed).toBe(1);
-    expect(await pathExists(path.join(projectPath, 'infra/minikube/scripts/up.sh'))).toBe(false);
+    await removeStoredInfraStateAsync(projectPath, 'local');
+    expect(await readStoredInfraStateAsync(projectPath, 'local')).toBeNull();
   });
 
-  test('cleans generated files when deployment is removed', async () => {
-    const projectPath = await fs.mkdtemp(path.join(os.tmpdir(), 'infra-clean-'));
-    tempRoots.add(projectPath);
-
-    await fs.mkdir(path.join(projectPath, '.ankh'), { recursive: true });
-    await fs.mkdir(path.join(projectPath, 'infra/minikube/scripts'), { recursive: true });
-    await fs.writeFile(
-      path.join(projectPath, 'infra/minikube/scripts/status.sh'),
-      'status',
-      'utf8',
-    );
-    await fs.writeFile(
-      path.join(projectPath, '.ankh/infra-ledger.json'),
-      JSON.stringify({
-        schemaVersion: 1,
-        generatedAt: new Date().toISOString(),
-        target: 'minikube',
-        files: ['infra/minikube/scripts/status.sh'],
-        warnings: [],
-      }),
-      'utf8',
-    );
-
-    const result = await syncProjectInfrastructure({
-      projectId: 'shop',
+  test('writes deterministic artifacts and removes only previously tracked stale files', async () => {
+    const projectPath = await temporaryProject();
+    const unrelatedPath = path.join(projectPath, 'infra/unrelated.txt');
+    await fs.mkdir(path.dirname(unrelatedPath), { recursive: true });
+    await fs.writeFile(unrelatedPath, 'keep', 'utf8');
+    const first = artifact('infra/compose.yaml', 'first');
+    const stale = artifact('infra/stale.yaml', 'stale');
+    await writeInfraGeneratedArtifactsAsync(projectPath, [first, stale], undefined);
+    const result = await writeInfraGeneratedArtifactsAsync(
       projectPath,
-      manifest: createAppManifest('shop', { modules: [] }),
-    });
-
-    expect(result.generated).toBe(0);
-    expect(result.removed).toBe(1);
-    expect(await pathExists(path.join(projectPath, '.ankh/infra-ledger.json'))).toBe(false);
+      [artifact('infra/compose.yaml', 'second')],
+      ledger([first, stale]),
+    );
+    expect(result).toEqual({ written: 1, removed: 1 });
+    expect(await fs.readFile(path.join(projectPath, 'infra/compose.yaml'), 'utf8')).toBe('second');
+    expect(await fs.readFile(unrelatedPath, 'utf8')).toBe('keep');
+    expect(await fileExists(path.join(projectPath, 'infra/stale.yaml'))).toBe(false);
   });
 
-  test('preserves apps/studio skip behavior', async () => {
-    const projectPath = await fs.mkdtemp(path.join(os.tmpdir(), 'infra-studio-'));
-    tempRoots.add(projectPath);
-
-    const result = await syncProjectInfrastructure({
-      projectId: 'studio',
-      projectPath,
-      manifest: createAppManifest('studio', {
-        deployment: { target: 'minikube', monitoring: false },
-        modules: [],
-      }),
-    });
-
-    expect(result.skipped?.reason).toContain('apps/studio');
+  test('rejects traversal, state collisions and duplicate artifact paths before writing', async () => {
+    const projectPath = await temporaryProject();
+    expect(() => resolveProjectFile(projectPath, '../outside')).toThrow('outside project root');
+    expect(() => resolveProjectFile(projectPath, '.ankh/infra/local/state.json')).toThrow(
+      'Invalid generated Infra artifact path',
+    );
+    expect(
+      await captureError(
+        writeInfraGeneratedArtifactsAsync(
+          projectPath,
+          [artifact('infra/duplicate', 'a'), artifact('infra/duplicate', 'b')],
+          undefined,
+        ),
+      ),
+    ).toContain('Duplicate generated Infra artifact path');
+    expect(await fileExists(path.join(projectPath, 'infra/duplicate'))).toBe(false);
   });
 
-  test('resolves targets from the ledger when deployment metadata is absent', async () => {
-    const projectPath = await fs.mkdtemp(path.join(os.tmpdir(), 'infra-target-'));
-    tempRoots.add(projectPath);
-
-    await fs.mkdir(path.join(projectPath, '.ankh'), { recursive: true });
+  test('fails closed when stored secret outputs contain a resolved value', async () => {
+    const projectPath = await temporaryProject();
+    const statePath = path.join(projectPath, '.ankh/infra/local/state.json');
+    await fs.mkdir(path.dirname(statePath), { recursive: true });
     await fs.writeFile(
-      path.join(projectPath, '.ankh/infra-ledger.json'),
+      statePath,
       JSON.stringify({
         schemaVersion: 1,
-        generatedAt: new Date().toISOString(),
-        target: 'minikube',
-        files: [],
-        warnings: [],
+        desired,
+        ledger: {
+          ...ledger([]),
+          outputs: [
+            {
+              owner: artifact('infra/example', '').owner,
+              name: 'password',
+              visibility: 'secret',
+              value: 'must-not-be-accepted',
+            },
+          ],
+        },
       }),
       'utf8',
     );
-
-    const target = await resolveProjectInfrastructureTarget({
-      manifest: createAppManifest('shop', { modules: [] }),
-      projectPath,
-    });
-
-    expect(target).toBe('minikube');
-  });
-
-  test('rejects generated file paths outside the project root', () => {
-    expect(() => resolveProjectFile('/workspace/project', '../outside.txt')).toThrow(
-      'Invalid infra output path outside project root',
+    expect(await captureError(readStoredInfraStateAsync(projectPath, 'local'))).toContain(
+      'invalid shape',
     );
   });
 });
 
-async function pathExists(filePath: string): Promise<boolean> {
+const desired = {
+  deployment: {
+    compute: { provider: 'local' },
+    runtime: { provider: 'docker-compose' },
+  },
+} as const;
+
+function ledger(artifacts: readonly InfraGeneratedArtifact[]): InfraLedger {
+  return {
+    schemaVersion: 1,
+    projectId: 'sample',
+    environment: 'local',
+    targets: [],
+    resources: [],
+    outputs: [],
+    artifacts: artifacts.map(({ owner, path: artifactPath }) => ({ owner, path: artifactPath })),
+  };
+}
+
+function artifact(artifactPath: string, content: string): InfraGeneratedArtifact {
+  return {
+    owner: {
+      projectId: 'sample',
+      environment: 'local',
+      adapter: 'docker-compose',
+      resourceId: 'runtime',
+    },
+    path: artifactPath,
+    content,
+  };
+}
+
+async function temporaryProject(): Promise<string> {
+  const projectPath = await fs.mkdtemp(path.join(os.tmpdir(), 'infra-project-'));
+  temporaryPaths.add(projectPath);
+  return projectPath;
+}
+
+async function fileExists(filePath: string): Promise<boolean> {
   try {
     await fs.access(filePath);
     return true;
@@ -205,3 +150,12 @@ async function pathExists(filePath: string): Promise<boolean> {
     return false;
   }
 }
+
+async function captureError(operation: Promise<unknown>): Promise<string> {
+  try {
+    await operation;
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+  throw new Error('Expected operation to fail.');
+}

package/src/readme-usage.ts

@@ -1,39 +1,30 @@
-import { runCli } from './cli/bin.js';
+import { runInfraCliAsync } from './cli/runInfraCliAsync.js';
 
 /***
- * Provider, CLI, and project API surface
+ * Provider-neutral infrastructure lifecycle
  *
- * `@ankhorage/infra` owns infrastructure generation, project reconciliation,
- * and generated lifecycle execution.
+ * `@ankhorage/infra` resolves only the compute, runtime, and service adapter packages selected by
+ * an environment-aware Infra manifest. Its typed use cases own orchestration, dependency ordering,
+ * safe outputs, deterministic artifacts, and environment-scoped ownership state. Provider packages
+ * own all technology-specific implementation.
  *
- * The same owner implementation backs CLI consumers and the public
- * `@ankhorage/infra/project` application-service boundary. Trusted hosts such
- * as Studio should call that subpath instead of reproducing ledger, generated
- * file, lifecycle-script, or port-forward configuration semantics.
- *
- * CLI entrypoints:
- *
- * - `ankh infra ...`
- * - `bunx @ankhorage/infra ...`
- *
- * Current command surface:
+ * The standalone CLI and `ankh infra` expose the same lifecycle:
  *
  * - `validate`
+ * - `plan`
  * - `generate`
- * - `status`
  * - `up`
+ * - `status`
+ * - `outputs`
  * - `down`
+ * - `destroy`
  *
- * Project resolution for the CLI is workspace-aware: pass `[project]`, or
- * omit it when cwd is already inside `apps/<project>`. Programmatic project
- * operations accept an explicit project path and do not require Studio or a
- * particular workspace layout.
- *
- * Running applications can repair their provider-aware host endpoints through
- * `ensureProjectInfrastructureRuntime()` from `@ankhorage/infra/project`. This
- * operation only ensures the generated runtime port-forward group; it does not
- * deploy, bootstrap, or reconcile infrastructure.
+ * `local` is the only default environment. Destruction always requires an explicit environment and
+ * exact `<project>:<environment>` confirmation. Persistent resources remain retained unless each
+ * exact owned resource is separately authorized with `--delete-resource <adapter>:<resourceId>`.
+ * Environment-style outputs print only explicitly public values with an environment-variable name;
+ * secret outputs remain references.
  *
  * @usage
  */
-await runCli(['--help']);
+await runInfraCliAsync(['--help']);

package/src/testSupport.ts

@@ -3,7 +3,7 @@ import { promises as fs } from 'fs';
 import os from 'os';
 import path from 'path';
 
-import type { InfraCommandContext } from './commandContext.js';
+import type { InfraCommandContext } from './types/infraCli.js';
 
 export interface CapturedCommandContext {
   readonly context: InfraCommandContext;
@@ -79,7 +79,17 @@ export async function createWorkspaceFixture(
 
 export function createAppManifest(
   projectId: string,
-  infra: AppManifest['infra'] = { modules: [] },
+  infra: AppManifest['infra'] = {
+    environments: {
+      local: {
+        deployment: {
+          compute: { provider: 'local' },
+          runtime: { provider: 'docker-compose' },
+        },
+      },
+    },
+    modules: [],
+  },
 ): AppManifest {
   return {
     metadata: {

package/src/types/infraCli.ts

@@ -0,0 +1,115 @@
+import type { AnkhCapabilityId } from '@ankhorage/contracts/cli';
+import type { AppEnvironmentId } from '@ankhorage/contracts/environments';
+import type { InfraEnvironmentSpec } from '@ankhorage/contracts/infra';
+
+import type { readStoredInfraStateAsync } from '../features/environment-lifecycle/adapters/outbound/readStoredInfraStateAsync.js';
+import type { removeStoredInfraStateAsync } from '../features/environment-lifecycle/adapters/outbound/removeStoredInfraStateAsync.js';
+import type { writeInfraGeneratedArtifactsAsync } from '../features/environment-lifecycle/adapters/outbound/writeInfraGeneratedArtifactsAsync.js';
+import type { writeStoredInfraStateAsync } from '../features/environment-lifecycle/adapters/outbound/writeStoredInfraStateAsync.js';
+import type { destroyInfraEnvironmentAsync } from '../features/environment-lifecycle/application/use-cases/destroyInfraEnvironmentAsync.js';
+import type { downInfraEnvironmentAsync } from '../features/environment-lifecycle/application/use-cases/downInfraEnvironmentAsync.js';
+import type { generateInfraEnvironmentAsync } from '../features/environment-lifecycle/application/use-cases/generateInfraEnvironmentAsync.js';
+import type { getInfraEnvironmentOutputs } from '../features/environment-lifecycle/application/use-cases/getInfraEnvironmentOutputs.js';
+import type { planInfraEnvironmentAsync } from '../features/environment-lifecycle/application/use-cases/planInfraEnvironmentAsync.js';
+import type { statusInfraEnvironmentAsync } from '../features/environment-lifecycle/application/use-cases/statusInfraEnvironmentAsync.js';
+import type { upInfraEnvironmentAsync } from '../features/environment-lifecycle/application/use-cases/upInfraEnvironmentAsync.js';
+import type { validateInfraEnvironmentAsync } from '../features/environment-lifecycle/application/use-cases/validateInfraEnvironmentAsync.js';
+import type {
+  InfraOperationRequest,
+  InfraOrchestrationDependencies,
+  InfraStoredState,
+} from './infraOrchestration.js';
+import type { ResolvedInfraProject } from './infraProject.js';
+
+type InfraCommandName =
+  'validate' | 'plan' | 'generate' | 'up' | 'status' | 'outputs' | 'down' | 'destroy';
+
+export interface InfraCommandContext {
+  readonly cwd: string;
+  readonly env: Readonly<Record<string, string | undefined>>;
+  readonly version: string;
+  writeStdout(text: string): void;
+  writeStderr(text: string): void;
+}
+
+export interface InfraCommandRunResult {
+  readonly exitCode: number;
+}
+
+export interface ParsedInfraArguments {
+  readonly projectId?: string;
+  readonly environment?: AppEnvironmentId;
+  readonly format: 'human' | 'json' | 'env';
+  readonly confirmation?: string;
+  readonly deleteResources: readonly string[];
+}
+
+export interface InfraCommandRunRequest {
+  readonly context: InfraCommandContext;
+  readonly arguments: ParsedInfraArguments;
+}
+
+type InfraCommandImplementation = (
+  request: InfraCommandRunRequest,
+  services: InfraCommandServices,
+) => Promise<InfraCommandRunResult>;
+
+export interface InfraCommandDefinition {
+  readonly capability: AnkhCapabilityId;
+  readonly path: readonly [InfraCommandName];
+  readonly standaloneName: InfraCommandName;
+  readonly summary: string;
+  readonly run: InfraCommandImplementation;
+}
+
+export interface InfraCommandInvocation {
+  readonly argv: readonly string[];
+  readonly command: InfraCommandDefinition;
+  readonly context: InfraCommandContext;
+}
+
+export interface InfraLifecycleOperations {
+  readonly validate: typeof validateInfraEnvironmentAsync;
+  readonly plan: typeof planInfraEnvironmentAsync;
+  readonly generate: typeof generateInfraEnvironmentAsync;
+  readonly up: typeof upInfraEnvironmentAsync;
+  readonly status: typeof statusInfraEnvironmentAsync;
+  readonly outputs: typeof getInfraEnvironmentOutputs;
+  readonly down: typeof downInfraEnvironmentAsync;
+  readonly destroy: typeof destroyInfraEnvironmentAsync;
+}
+
+export interface InfraCommandServices {
+  readonly resolveProject: (options: {
+    readonly cwd: string;
+    readonly projectId?: string;
+  }) => Promise<ResolvedInfraProject>;
+  readonly readState: typeof readStoredInfraStateAsync;
+  readonly writeState: typeof writeStoredInfraStateAsync;
+  readonly removeState: typeof removeStoredInfraStateAsync;
+  readonly writeArtifacts: typeof writeInfraGeneratedArtifactsAsync;
+  readonly operations: InfraLifecycleOperations;
+  readonly createDependencies: (context: InfraCommandContext) => InfraOrchestrationDependencies;
+}
+
+export interface RunInfraCommandOptions {
+  readonly services?: Partial<InfraCommandServices>;
+}
+
+export interface CreateInfraRuntimeProviderOptions {
+  readonly runCommandImpl?: RunInfraCommandImpl;
+  readonly services?: Partial<InfraCommandServices>;
+}
+
+export type RunInfraCommandImpl = (
+  request: InfraCommandInvocation,
+  options?: RunInfraCommandOptions,
+) => Promise<InfraCommandRunResult>;
+
+export interface PreparedInfraCommandOperation {
+  readonly project: ResolvedInfraProject;
+  readonly state: InfraStoredState | null;
+  readonly desired: InfraEnvironmentSpec;
+  readonly operation: InfraOperationRequest;
+  readonly dependencies: InfraOrchestrationDependencies;
+}

package/src/types/infraOrchestration.ts

@@ -0,0 +1,126 @@
+import type { AppEnvironmentId } from '@ankhorage/contracts/environments';
+import type {
+  InfraComputeAdapter,
+  InfraComputeSnapshot,
+  InfraComputeTarget,
+  InfraDestroyRequest,
+  InfraEnvironmentSpec,
+  InfraExecutionContext,
+  InfraGeneratedArtifact,
+  InfraLedger,
+  InfraManifest,
+  InfraOutput,
+  InfraOwnedResource,
+  InfraPlan,
+  InfraResult,
+  InfraRuntimeAdapter,
+  InfraRuntimeDesiredState,
+  InfraServiceAdapter,
+  InfraStatus,
+} from '@ankhorage/contracts/infra';
+
+import type { InfraAdapterPackageResolver } from '../features/environment-lifecycle/application/ports/outbound/infraAdapterPackage.js';
+
+export interface ResolvedInfraEnvironment {
+  readonly id: AppEnvironmentId;
+  readonly desired: InfraEnvironmentSpec;
+  readonly manifest: InfraManifest;
+}
+
+export interface InfraEnvironmentResolutionRequest {
+  readonly environment?: string;
+  readonly manifest: InfraManifest;
+  readonly operation:
+    'validate' | 'plan' | 'generate' | 'up' | 'status' | 'outputs' | 'down' | 'destroy';
+}
+
+export interface ResolvedInfraAdapters {
+  readonly compute: InfraComputeAdapter;
+  readonly runtime: InfraRuntimeAdapter;
+  readonly services: readonly InfraServiceAdapter[];
+}
+
+export interface InfraStoredState {
+  readonly schemaVersion: 1;
+  readonly desired: InfraEnvironmentSpec;
+  readonly ledger: InfraLedger;
+}
+
+export interface PreparedInfraOperation {
+  readonly environment: ResolvedInfraEnvironment;
+  readonly context: InfraExecutionContext;
+  readonly adapters: ResolvedInfraAdapters;
+  readonly compute: InfraComputeSnapshot;
+  readonly runtimeDesired: InfraRuntimeDesiredState;
+}
+
+export interface InfraOrchestrationDependencies {
+  readonly adapterResolver: InfraAdapterPackageResolver;
+  readonly credentials: InfraExecutionContext['credentials'];
+  readonly secrets: InfraExecutionContext['secrets'];
+}
+
+export interface InfraOperationRequest {
+  readonly projectId: string;
+  readonly manifest: InfraManifest;
+  readonly environment?: string;
+  readonly previous?: InfraLedger;
+  readonly previousDesired?: InfraEnvironmentSpec;
+  readonly signal?: AbortSignal;
+}
+
+export interface InfraDestroyOperationRequest extends InfraOperationRequest {
+  readonly confirmation: InfraDestroyRequest['confirmation'];
+  readonly persistence: InfraDestroyRequest['persistence'];
+}
+
+export interface InfraValidateResult {
+  readonly environment: AppEnvironmentId;
+}
+
+export type InfraValidateOperationResult = InfraResult<InfraValidateResult>;
+
+export type InfraUpRequest = InfraOperationRequest;
+
+export interface InfraUpResult {
+  readonly environment: AppEnvironmentId;
+  readonly targets: readonly InfraComputeTarget[];
+  readonly resources: readonly InfraOwnedResource[];
+  readonly outputs: readonly InfraOutput[];
+  readonly ledger: InfraLedger;
+}
+
+export type InfraUpOperationResult = InfraResult<InfraUpResult>;
+
+export type InfraPlanOperationResult = InfraResult<InfraPlan>;
+
+export interface InfraGenerateResult {
+  readonly environment: AppEnvironmentId;
+  readonly artifacts: readonly InfraGeneratedArtifact[];
+  readonly ledger: InfraLedger;
+}
+
+export type InfraGenerateOperationResult = InfraResult<InfraGenerateResult>;
+
+export type InfraStatusOperationResult = InfraResult<InfraStatus>;
+
+export interface InfraOutputsResult {
+  readonly environment: AppEnvironmentId;
+  readonly outputs: readonly InfraOutput[];
+}
+
+export type InfraOutputsOperationResult = InfraResult<InfraOutputsResult>;
+
+export interface InfraDownResult {
+  readonly environment: AppEnvironmentId;
+  readonly ledger: InfraLedger;
+}
+
+export type InfraDownOperationResult = InfraResult<InfraDownResult>;
+
+export interface InfraDestroyResult {
+  readonly environment: AppEnvironmentId;
+  readonly ledger: InfraLedger | null;
+}
+
+export type InfraDestroyOperationResult = InfraResult<InfraDestroyResult>;

package/src/types/infraProject.ts

@@ -0,0 +1,15 @@
+import type { AppManifest } from '@ankhorage/contracts';
+
+export interface InfraArtifactWriteResult {
+  readonly written: number;
+  readonly removed: number;
+}
+
+export interface ResolvedInfraProject {
+  readonly appsRoot: string;
+  readonly manifest: AppManifest;
+  readonly manifestPath: string;
+  readonly projectId: string;
+  readonly projectPath: string;
+  readonly workspaceRoot: string;
+}