@ankhorage/infra 4.1.12 → 5.0.0

package/src/features/environment-lifecycle/adapters/outbound/createEnvironmentInfraCredentialPort.ts

@@ -0,0 +1,52 @@
+import type { InfraExecutionContext, InfraResult } from '@ankhorage/contracts/infra';
+
+import { createInfraFailure } from '../../utils/createInfraFailure.js';
+import { normalizeInfraEnvironmentKey } from '../../utils/normalizeInfraEnvironmentKey.js';
+
+/*** Resolve execution-only control-plane credentials from exact-name or prefixed environment data. */
+export function createEnvironmentInfraCredentialPort(
+  environment: Readonly<Record<string, string | undefined>>,
+): InfraExecutionContext['credentials'] {
+  return {
+    resolveAsync(reference) {
+      const prefixedName = `ANKH_INFRA_CREDENTIAL_${normalizeInfraEnvironmentKey(reference.name)}`;
+      const rawValue =
+        Reflect.get(environment, reference.name) ?? Reflect.get(environment, prefixedName);
+      if (rawValue === undefined || rawValue.length === 0) {
+        return Promise.resolve(
+          createInfraFailure(
+            'infra-control-plane-credential-missing',
+            `Control-plane credential ${reference.name} is unavailable. Set ${reference.name} or ${prefixedName}.`,
+          ),
+        );
+      }
+      return Promise.resolve(parseCredentialBundle(reference.name, rawValue));
+    },
+  };
+}
+
+/*** Parse JSON credential bundles; token variables also support their conventional scalar form. */
+function parseCredentialBundle(
+  name: string,
+  rawValue: string,
+): InfraResult<Readonly<Record<string, string>>> {
+  try {
+    const parsed: unknown = JSON.parse(rawValue);
+    if (isRecord(parsed) && Object.values(parsed).every((value) => typeof value === 'string')) {
+      return { ok: true, value: parsed as Readonly<Record<string, string>>, diagnostics: [] };
+    }
+  } catch {
+    if (name.endsWith('_TOKEN')) {
+      return { ok: true, value: { token: rawValue, apiToken: rawValue }, diagnostics: [] };
+    }
+  }
+  return createInfraFailure(
+    'infra-control-plane-credential-invalid',
+    `Control-plane credential ${name} must be a JSON object containing string fields.`,
+  );
+}
+
+/*** Narrow JSON credential bundles. */
+function isRecord(value: unknown): value is Readonly<Record<string, unknown>> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/src/features/environment-lifecycle/adapters/outbound/createEnvironmentInfraSecretPort.ts

@@ -0,0 +1,32 @@
+import type { InfraExecutionContext } from '@ankhorage/contracts/infra';
+
+import { createInfraFailure } from '../../utils/createInfraFailure.js';
+import { normalizeInfraEnvironmentKey } from '../../utils/normalizeInfraEnvironmentKey.js';
+
+/*** Resolve explicitly addressed secret values from environment data without serializing them. */
+export function createEnvironmentInfraSecretPort(
+  environment: Readonly<Record<string, string | undefined>>,
+): InfraExecutionContext['secrets'] {
+  return {
+    resolveAsync(reference) {
+      const variable = [
+        'ANKH_INFRA_SECRET',
+        reference.projectId,
+        reference.environment,
+        reference.ref,
+        reference.key,
+      ]
+        .map(normalizeInfraEnvironmentKey)
+        .join('_');
+      const value: unknown = Reflect.get(environment, variable);
+      return Promise.resolve(
+        typeof value !== 'string' || value.length === 0
+          ? createInfraFailure(
+              'infra-secret-unavailable',
+              `Secret reference ${reference.ref}/${reference.key} is unavailable. Set ${variable}.`,
+            )
+          : { ok: true, value, diagnostics: [] },
+      );
+    },
+  };
+}

package/src/features/environment-lifecycle/adapters/outbound/createNodeInfraAdapterPackageResolver.ts

@@ -0,0 +1,10 @@
+import type { InfraAdapterPackageResolver } from '../../application/ports/outbound/infraAdapterPackage.js';
+
+/*** Load only a catalog-selected package through the host module resolver. */
+export function createNodeInfraAdapterPackageResolver(): InfraAdapterPackageResolver {
+  return {
+    loadAsync(packageName) {
+      return import(packageName);
+    },
+  };
+}

package/src/features/environment-lifecycle/adapters/outbound/readStoredInfraStateAsync.ts

@@ -0,0 +1,34 @@
+import type { AppEnvironmentId } from '@ankhorage/contracts/environments';
+import { promises as fs } from 'fs';
+
+import type { InfraStoredState } from '../../../../types/infraOrchestration.js';
+import { isInfraStoredState } from '../../utils/isInfraStoredState.js';
+import { resolveInfraStatePath } from '../../utils/resolveInfraStatePath.js';
+
+/*** Read exact environment state; malformed ownership state fails closed rather than disappearing. */
+export async function readStoredInfraStateAsync(
+  projectPath: string,
+  environment: AppEnvironmentId,
+): Promise<InfraStoredState | null> {
+  const statePath = resolveInfraStatePath(projectPath, environment);
+  try {
+    const parsed: unknown = JSON.parse(await fs.readFile(statePath, 'utf8'));
+    if (!isInfraStoredState(parsed)) {
+      throw new Error(`Stored Infra state has an invalid shape: ${statePath}`);
+    }
+    return parsed;
+  } catch (error) {
+    if (isMissingFile(error)) return null;
+    throw error;
+  }
+}
+
+/*** Recognize only the filesystem's absent-file failure. */
+function isMissingFile(error: unknown): boolean {
+  return isRecord(error) && error.code === 'ENOENT';
+}
+
+/*** Narrow filesystem error values. */
+function isRecord(value: unknown): value is Readonly<Record<string, unknown>> {
+  return typeof value === 'object' && value !== null;
+}

package/src/features/environment-lifecycle/adapters/outbound/removeStoredInfraStateAsync.ts

@@ -0,0 +1,12 @@
+import type { AppEnvironmentId } from '@ankhorage/contracts/environments';
+import { promises as fs } from 'fs';
+
+import { resolveInfraStatePath } from '../../utils/resolveInfraStatePath.js';
+
+/*** Remove only the exact selected environment state after a complete destroy. */
+export async function removeStoredInfraStateAsync(
+  projectPath: string,
+  environment: AppEnvironmentId,
+): Promise<void> {
+  await fs.rm(resolveInfraStatePath(projectPath, environment), { force: true });
+}

package/src/{project.ts → features/environment-lifecycle/adapters/outbound/resolveInfraProjectAsync.ts}

@@ -2,16 +2,10 @@ import { type AppManifest, isAppManifest } from '@ankhorage/contracts';
 import { promises as fs } from 'fs';
 import path from 'path';
 
-export interface ResolvedInfraProject {
-  readonly appsRoot: string;
-  readonly manifest: AppManifest;
-  readonly manifestPath: string;
-  readonly projectId: string;
-  readonly projectPath: string;
-  readonly workspaceRoot: string;
-}
+import type { ResolvedInfraProject } from '../../../../types/infraProject.js';
 
-export async function resolveInfraProject(options: {
+/*** Resolve one manifest-backed Infra project from the workspace and optional project selector. */
+export async function resolveInfraProjectAsync(options: {
   readonly cwd: string;
   readonly projectId?: string;
 }): Promise<ResolvedInfraProject> {
@@ -37,7 +31,7 @@ export async function resolveInfraProject(options: {
   }
 
   const manifestPath = path.join(projectPath, 'ankh.config.json');
-  const manifest = await readProjectManifest({ manifestPath, projectId });
+  const manifest = await readProjectManifest(manifestPath);
 
   return {
     appsRoot,
@@ -60,54 +54,25 @@ function resolveProjectPath(appsRoot: string, projectId: string): string {
   return projectPath;
 }
 
-function createFallbackManifest(projectId: string): AppManifest {
-  return {
-    metadata: {
-      name: projectId,
-      slug: projectId,
-      version: '0.0.0',
-      category: 'developer_tools',
-      themeId: 'default',
-    },
-    themes: [],
-    activeThemeId: 'default',
-    infra: { modules: [] },
-    navigator: {
-      type: 'stack',
-      routes: [{ name: 'index', screenId: 'index' }],
-    },
-    screens: {},
-    settings: {
-      localization: {
-        defaultLocale: 'en',
-        locales: ['en'],
-      },
-    },
-  };
-}
-
-async function readProjectManifest(args: {
-  readonly manifestPath: string;
-  readonly projectId: string;
-}): Promise<AppManifest> {
-  if (!(await pathExists(args.manifestPath))) {
-    return createFallbackManifest(args.projectId);
+async function readProjectManifest(manifestPath: string): Promise<AppManifest> {
+  if (!(await pathExists(manifestPath))) {
+    throw new Error(`Project manifest not found: ${manifestPath}`);
   }
 
-  const rawManifest = await fs.readFile(args.manifestPath, 'utf8');
+  const rawManifest = await fs.readFile(manifestPath, 'utf8');
   let parsed: unknown;
 
   try {
     parsed = JSON.parse(rawManifest);
   } catch (error) {
     throw new Error(
-      `Project manifest is not valid JSON: ${args.manifestPath}: ${getErrorMessage(error)}`,
+      `Project manifest is not valid JSON: ${manifestPath}: ${getErrorMessage(error)}`,
       { cause: error },
     );
   }
 
   if (!isAppManifest(parsed)) {
-    throw new Error(`Project manifest has an invalid shape: ${args.manifestPath}`);
+    throw new Error(`Project manifest has an invalid shape: ${manifestPath}`);
   }
 
   return parsed;

package/src/features/environment-lifecycle/adapters/outbound/writeInfraGeneratedArtifactsAsync.ts

@@ -0,0 +1,34 @@
+import type { InfraGeneratedArtifact, InfraLedger } from '@ankhorage/contracts/infra';
+import { promises as fs } from 'fs';
+import path from 'path';
+
+import type { InfraArtifactWriteResult } from '../../../../types/infraProject.js';
+import { resolveProjectFile } from '../../utils/resolveProjectFile.js';
+
+/*** Write validated generated artifacts and remove only stale paths from the prior ledger. */
+export async function writeInfraGeneratedArtifactsAsync(
+  projectPath: string,
+  artifacts: readonly InfraGeneratedArtifact[],
+  previous: InfraLedger | undefined,
+): Promise<InfraArtifactWriteResult> {
+  const nextPaths = new Set<string>();
+  const validated = artifacts.map((artifact) => {
+    if (nextPaths.has(artifact.path)) {
+      throw new Error(`Duplicate generated Infra artifact path: ${artifact.path}`);
+    }
+    nextPaths.add(artifact.path);
+    return { artifact, outputPath: resolveProjectFile(projectPath, artifact.path) };
+  });
+  for (const { artifact, outputPath } of validated) {
+    await fs.mkdir(path.dirname(outputPath), { recursive: true });
+    await fs.writeFile(outputPath, artifact.content, 'utf8');
+    if (artifact.executable === true) await fs.chmod(outputPath, 0o755);
+  }
+  const stalePaths = (previous?.artifacts ?? [])
+    .map(({ path: artifactPath }) => artifactPath)
+    .filter((artifactPath) => !nextPaths.has(artifactPath));
+  for (const stalePath of stalePaths) {
+    await fs.rm(resolveProjectFile(projectPath, stalePath), { force: true });
+  }
+  return { written: validated.length, removed: stalePaths.length };
+}

package/src/features/environment-lifecycle/adapters/outbound/writeStoredInfraStateAsync.ts

@@ -0,0 +1,21 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+
+import type { InfraStoredState } from '../../../../types/infraOrchestration.js';
+import { isInfraStoredState } from '../../utils/isInfraStoredState.js';
+import { resolveInfraStatePath } from '../../utils/resolveInfraStatePath.js';
+
+/*** Persist serializable desired identity plus a secret-safe canonical ledger atomically. */
+export async function writeStoredInfraStateAsync(
+  projectPath: string,
+  state: InfraStoredState,
+): Promise<void> {
+  if (!isInfraStoredState(state)) {
+    throw new Error('Refusing to persist invalid or cross-scoped Infra ownership state.');
+  }
+  const statePath = resolveInfraStatePath(projectPath, state.ledger.environment);
+  const temporaryPath = `${statePath}.tmp`;
+  await fs.mkdir(path.dirname(statePath), { recursive: true });
+  await fs.writeFile(temporaryPath, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+  await fs.rename(temporaryPath, statePath);
+}

package/src/features/environment-lifecycle/application/ports/outbound/infraAdapterPackage.ts

@@ -0,0 +1,10 @@
+import type { InfraAdapterDescriptor } from '@ankhorage/contracts/infra';
+
+export interface InfraAdapterPackageResolver {
+  loadAsync(packageName: string): Promise<unknown>;
+}
+
+export interface InfraAdapterPackageModule {
+  readonly infraAdapterDescriptor: InfraAdapterDescriptor;
+  readonly createInfraAdapter: () => unknown;
+}

package/src/features/environment-lifecycle/application/use-cases/collectInfraWorkloadsAsync.ts

@@ -0,0 +1,25 @@
+import type {
+  InfraDiagnostic,
+  InfraExecutionContext,
+  InfraResult,
+  InfraServiceAdapter,
+  InfraWorkloadSpec,
+} from '@ankhorage/contracts/infra';
+
+import { appendInfraFailure } from '../../utils/appendInfraFailure.js';
+
+/*** Collect each service workload graph once in deterministic adapter order. */
+export async function collectInfraWorkloadsAsync(
+  context: InfraExecutionContext,
+  services: readonly InfraServiceAdapter[],
+): Promise<InfraResult<readonly InfraWorkloadSpec[]>> {
+  const workloads: InfraWorkloadSpec[] = [];
+  const diagnostics: InfraDiagnostic[] = [];
+  for (const service of services) {
+    const desired = await service.desiredWorkloadsAsync(context);
+    if (!desired.ok) return appendInfraFailure(diagnostics, desired);
+    workloads.push(...desired.value);
+    diagnostics.push(...desired.diagnostics);
+  }
+  return { ok: true, value: workloads, diagnostics };
+}

package/src/features/environment-lifecycle/application/use-cases/destroyInfraEnvironmentAsync.ts

@@ -0,0 +1,119 @@
+import type {
+  InfraDestroyRequest,
+  InfraDiagnostic,
+  InfraOutput,
+  InfraOwnedResource,
+  InfraResult,
+} from '@ankhorage/contracts/infra';
+
+import type {
+  InfraDestroyOperationRequest,
+  InfraDestroyOperationResult,
+  InfraOrchestrationDependencies,
+} from '../../../../types/infraOrchestration.js';
+import { appendInfraFailure } from '../../utils/appendInfraFailure.js';
+import { createInfraLedger } from '../../utils/createInfraLedger.js';
+import { infraIdentityKey } from '../../utils/infraIdentityKey.js';
+import { mergeInfraOutputs } from '../../utils/mergeInfraOutputs.js';
+import { mergeInfraResources } from '../../utils/mergeInfraResources.js';
+import { prepareInfraOperationAsync } from './prepareInfraOperationAsync.js';
+
+/*** Destroy exact owned resources in reverse dependency order behind explicit scope confirmation. */
+export async function destroyInfraEnvironmentAsync(
+  request: InfraDestroyOperationRequest,
+  dependencies: InfraOrchestrationDependencies,
+): Promise<InfraDestroyOperationResult> {
+  const prepared = await prepareInfraOperationAsync(request, 'destroy', dependencies);
+  if (!prepared.ok) return prepared;
+  const destroyRequest: InfraDestroyRequest = {
+    projectId: request.projectId,
+    environment: prepared.value.environment.id,
+    confirmation: request.confirmation,
+    persistence: request.persistence,
+  };
+  const safety = validateDestroyRequest(destroyRequest, request.previous?.resources ?? []);
+  if (!safety.ok) return safety;
+  const diagnostics: InfraDiagnostic[] = [...prepared.diagnostics];
+  const resources: InfraOwnedResource[] = [];
+  const outputs: InfraOutput[] = [];
+  for (const service of [...prepared.value.adapters.services].reverse()) {
+    const result = await service.destroyAsync(prepared.value.context, destroyRequest);
+    if (!result.ok) return appendInfraFailure(diagnostics, result);
+    resources.push(...result.value.resources);
+    outputs.push(...result.value.outputs);
+    diagnostics.push(...result.diagnostics);
+  }
+  if (prepared.value.runtimeDesired.targets.length > 0) {
+    const runtime = await prepared.value.adapters.runtime.destroyAsync(
+      prepared.value.context,
+      prepared.value.runtimeDesired,
+      destroyRequest,
+    );
+    if (!runtime.ok) return appendInfraFailure(diagnostics, runtime);
+    resources.push(...runtime.value.resources);
+    outputs.push(...runtime.value.outputs);
+    diagnostics.push(...runtime.diagnostics);
+  }
+  const compute = await prepared.value.adapters.compute.destroyAsync(
+    prepared.value.context,
+    destroyRequest,
+  );
+  if (!compute.ok) return appendInfraFailure(diagnostics, compute);
+  resources.push(...compute.value.resources);
+  outputs.push(...compute.value.outputs);
+  diagnostics.push(...compute.diagnostics);
+  const remainingResources = mergeInfraResources(resources);
+  const remainingOutputs = mergeInfraOutputs(outputs);
+  const ledger =
+    remainingResources.length === 0 && remainingOutputs.length === 0
+      ? null
+      : createInfraLedger({
+          projectId: request.projectId,
+          environment: prepared.value.environment.id,
+          targets: [],
+          resources: remainingResources,
+          outputs: remainingOutputs,
+        });
+  return {
+    ok: true,
+    value: { environment: prepared.value.environment.id, ledger },
+    diagnostics,
+  };
+}
+
+/*** Refuse cross-project confirmation and unowned persistent deletion before any mutation. */
+function validateDestroyRequest(
+  request: InfraDestroyRequest,
+  previous: readonly InfraOwnedResource[],
+): InfraResult<null> {
+  if (
+    request.confirmation.projectId !== request.projectId ||
+    request.confirmation.environment !== request.environment
+  ) {
+    return destroyFailure(
+      'infra-destroy-confirmation-mismatch',
+      'Infra destroy confirmation must exactly match the selected project and environment.',
+    );
+  }
+  if (request.persistence.policy === 'retain') {
+    return { ok: true, value: null, diagnostics: [] };
+  }
+  const owned = new Set(previous.map(({ identity }) => infraIdentityKey(identity)));
+  const invalid = request.persistence.confirmedResources.some(
+    (identity) =>
+      identity.projectId !== request.projectId ||
+      identity.environment !== request.environment ||
+      !owned.has(infraIdentityKey(identity)),
+  );
+  return invalid
+    ? destroyFailure(
+        'infra-destroy-resource-unowned',
+        'Persistent deletion confirmation contains a resource outside the stored Infra scope.',
+      )
+    : { ok: true, value: null, diagnostics: [] };
+}
+
+/*** Create one stable non-provider-specific destroy safety failure. */
+function destroyFailure(code: string, message: string): InfraResult<never> {
+  return { ok: false, diagnostics: [{ severity: 'error', code, message }] };
+}

package/src/features/environment-lifecycle/application/use-cases/downInfraEnvironmentAsync.ts

@@ -0,0 +1,65 @@
+import type { InfraDiagnostic, InfraOutput, InfraOwnedResource } from '@ankhorage/contracts/infra';
+
+import type {
+  InfraDownOperationResult,
+  InfraOperationRequest,
+  InfraOrchestrationDependencies,
+} from '../../../../types/infraOrchestration.js';
+import { appendInfraFailure } from '../../utils/appendInfraFailure.js';
+import { createInfraLedger } from '../../utils/createInfraLedger.js';
+import { retainUnchangedAdapterOutputs } from '../../utils/retainUnchangedAdapterOutputs.js';
+import { retainUnchangedAdapterResources } from '../../utils/retainUnchangedAdapterResources.js';
+import { prepareInfraOperationAsync } from './prepareInfraOperationAsync.js';
+
+/*** Reversibly suspend services and runtime while retaining compute and persistent data. */
+export async function downInfraEnvironmentAsync(
+  request: InfraOperationRequest,
+  dependencies: InfraOrchestrationDependencies,
+): Promise<InfraDownOperationResult> {
+  const prepared = await prepareInfraOperationAsync(request, 'down', dependencies);
+  if (!prepared.ok) return prepared;
+  const diagnostics: InfraDiagnostic[] = [...prepared.diagnostics];
+  const resources: InfraOwnedResource[] = [];
+  const outputs: InfraOutput[] = [];
+  const replacedAdapters = new Set<string>();
+  for (const service of [...prepared.value.adapters.services].reverse()) {
+    if (service.suspendAsync === undefined) continue;
+    const result = await service.suspendAsync(prepared.value.context);
+    if (!result.ok) return appendInfraFailure(diagnostics, result);
+    replacedAdapters.add(service.descriptor.id);
+    resources.push(...result.value.resources);
+    outputs.push(...result.value.outputs);
+    diagnostics.push(...result.diagnostics);
+  }
+  if (prepared.value.runtimeDesired.targets.length > 0) {
+    const runtime = await prepared.value.adapters.runtime.suspendAsync(
+      prepared.value.context,
+      prepared.value.runtimeDesired,
+    );
+    if (!runtime.ok) return appendInfraFailure(diagnostics, runtime);
+    replacedAdapters.add(prepared.value.adapters.runtime.descriptor.id);
+    resources.push(...runtime.value.resources);
+    outputs.push(...runtime.value.outputs);
+    diagnostics.push(...runtime.diagnostics);
+  }
+  const previousResources = request.previous?.resources ?? [];
+  const previousOutputs = request.previous?.outputs ?? [];
+  return {
+    ok: true,
+    value: {
+      environment: prepared.value.environment.id,
+      ledger: createInfraLedger({
+        projectId: request.projectId,
+        environment: prepared.value.environment.id,
+        targets:
+          prepared.value.compute.targets.length > 0
+            ? prepared.value.compute.targets
+            : (request.previous?.targets ?? []),
+        resources: retainUnchangedAdapterResources(previousResources, resources, replacedAdapters),
+        outputs: retainUnchangedAdapterOutputs(previousOutputs, outputs, replacedAdapters),
+        previous: request.previous,
+      }),
+    },
+    diagnostics,
+  };
+}

package/src/features/environment-lifecycle/application/use-cases/generateInfraEnvironmentAsync.ts

@@ -0,0 +1,51 @@
+import type { InfraDiagnostic } from '@ankhorage/contracts/infra';
+
+import type {
+  InfraGenerateOperationResult,
+  InfraOperationRequest,
+  InfraOrchestrationDependencies,
+} from '../../../../types/infraOrchestration.js';
+import { appendInfraFailure } from '../../utils/appendInfraFailure.js';
+import { createInfraLedger } from '../../utils/createInfraLedger.js';
+import { mergeInfraOutputs } from '../../utils/mergeInfraOutputs.js';
+import { mergeInfraResources } from '../../utils/mergeInfraResources.js';
+import { prepareInfraOperationAsync } from './prepareInfraOperationAsync.js';
+
+/*** Generate deterministic review artifacts without mutating local or remote infrastructure. */
+export async function generateInfraEnvironmentAsync(
+  request: InfraOperationRequest,
+  dependencies: InfraOrchestrationDependencies,
+): Promise<InfraGenerateOperationResult> {
+  const prepared = await prepareInfraOperationAsync(request, 'generate', dependencies);
+  if (!prepared.ok) return prepared;
+  const diagnostics: InfraDiagnostic[] = [...prepared.diagnostics];
+  const { runtime } = prepared.value.adapters;
+  const artifacts =
+    runtime.generateAsync === undefined || prepared.value.runtimeDesired.targets.length === 0
+      ? { ok: true as const, value: [], diagnostics: [] }
+      : await runtime.generateAsync(prepared.value.context, prepared.value.runtimeDesired);
+  if (!artifacts.ok) return appendInfraFailure(diagnostics, artifacts);
+  diagnostics.push(...artifacts.diagnostics);
+  return {
+    ok: true,
+    value: {
+      environment: prepared.value.environment.id,
+      artifacts: artifacts.value,
+      ledger: createInfraLedger({
+        projectId: request.projectId,
+        environment: prepared.value.environment.id,
+        targets:
+          prepared.value.compute.targets.length > 0
+            ? prepared.value.compute.targets
+            : (request.previous?.targets ?? []),
+        resources: mergeInfraResources(
+          request.previous?.resources ?? [],
+          prepared.value.compute.resources,
+        ),
+        outputs: mergeInfraOutputs(request.previous?.outputs ?? [], prepared.value.compute.outputs),
+        artifacts: artifacts.value,
+      }),
+    },
+    diagnostics,
+  };
+}

package/src/features/environment-lifecycle/application/use-cases/getInfraEnvironmentOutputs.ts

@@ -0,0 +1,41 @@
+import type {
+  InfraOperationRequest,
+  InfraOutputsOperationResult,
+} from '../../../../types/infraOrchestration.js';
+import { resolveInfraEnvironment } from '../../domain/resolveInfraEnvironment.js';
+
+/*** Return only safe serialized public outputs and secret references from the canonical ledger. */
+export function getInfraEnvironmentOutputs(
+  request: InfraOperationRequest,
+): InfraOutputsOperationResult {
+  const environment = resolveInfraEnvironment({
+    manifest: request.manifest,
+    environment: request.environment,
+    operation: 'outputs',
+  });
+  if (!environment.ok) return environment;
+  if (
+    request.previous !== undefined &&
+    (request.previous.projectId !== request.projectId ||
+      request.previous.environment !== environment.value.id)
+  ) {
+    return {
+      ok: false,
+      diagnostics: [
+        {
+          severity: 'error',
+          code: 'infra-ledger-scope-mismatch',
+          message: 'Stored Infra state does not belong to the selected project and environment.',
+        },
+      ],
+    };
+  }
+  return {
+    ok: true,
+    value: {
+      environment: environment.value.id,
+      outputs: request.previous?.outputs ?? [],
+    },
+    diagnostics: environment.diagnostics,
+  };
+}