@ankhorage/infra 4.1.12 → 5.1.0

package/src/projectEnvironment.ts

@@ -1,51 +0,0 @@
-import { promises as fs } from 'fs';
-import path from 'path';
-
-export async function readProjectInfrastructureEnvironment(args: {
-  readonly keys: readonly string[];
-  readonly projectPath: string;
-  readonly target: string;
-}): Promise<Readonly<Record<string, string>>> {
-  const infraRoot = path.join(args.projectPath, 'infra', args.target);
-  const envPath = path.join(infraRoot, '.env');
-  const fallbackPath = path.join(infraRoot, '.env.example');
-  const sourcePath = (await pathExists(envPath)) ? envPath : fallbackPath;
-  const environment = await readEnvironmentFile(sourcePath);
-  const selected: Record<string, string> = {};
-
-  for (const key of new Set(args.keys)) {
-    const value = environment.get(key);
-    if (value !== undefined) selected[key] = value;
-  }
-
-  return selected;
-}
-
-async function readEnvironmentFile(filePath: string): Promise<Map<string, string>> {
-  const out = new Map<string, string>();
-  const content = await fs.readFile(filePath, 'utf8');
-
-  for (const line of content.split(/\r?\n/u)) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith('#')) continue;
-    const separator = trimmed.indexOf('=');
-    if (separator <= 0) continue;
-    const key = trimmed.slice(0, separator).trim();
-    const value = trimmed
-      .slice(separator + 1)
-      .trim()
-      .replace(/^['"]|['"]$/g, '');
-    out.set(key, value);
-  }
-
-  return out;
-}
-
-async function pathExists(filePath: string): Promise<boolean> {
-  try {
-    await fs.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}

package/src/projectInfrastructure.ts

@@ -1,221 +0,0 @@
-import type { AppManifest } from '@ankhorage/contracts';
-import { promises as fs } from 'fs';
-import path from 'path';
-
-import { generateInfrastructure } from './index.js';
-import { validateInfraSupport } from './infraValidation.js';
-
-const INFRA_LEDGER_RELATIVE_PATH = '.ankh/infra-ledger.json';
-const STUDIO_PROJECT_ID = 'studio';
-
-interface InfraLedger {
-  readonly schemaVersion: 1;
-  readonly generatedAt: string;
-  readonly target: string;
-  readonly files: readonly string[];
-  readonly warnings: readonly string[];
-}
-
-export interface InfraSyncResult {
-  readonly generated: number;
-  readonly removed: number;
-  readonly warnings: readonly string[];
-  readonly skipped?: {
-    readonly reason: string;
-  };
-}
-
-export interface InfraProjectInspection {
-  readonly generated: boolean;
-  readonly generatedAt: string | null;
-  readonly hasDeployment: boolean;
-  readonly target: string | null;
-  readonly trackedFiles: number;
-  readonly warnings: readonly string[];
-  readonly skipped?: {
-    readonly reason: string;
-  };
-}
-
-export async function syncProjectInfrastructure(args: {
-  readonly generateInfrastructureImpl?: typeof generateInfrastructure;
-  readonly manifest: AppManifest;
-  readonly projectId: string;
-  readonly projectPath: string;
-}): Promise<InfraSyncResult> {
-  const supportWarnings = validateInfraSupport(args.manifest.infra);
-
-  if (args.projectId === STUDIO_PROJECT_ID) {
-    return {
-      generated: 0,
-      removed: 0,
-      warnings: supportWarnings,
-      skipped: {
-        reason: 'apps/studio is the dashboard and is not a generated app target.',
-      },
-    };
-  }
-
-  const previousLedger = await readInfraLedger(args.projectPath);
-  const previousFiles = new Set(previousLedger?.files ?? []);
-
-  if (args.manifest.infra.deployment === undefined) {
-    const removed = await removeFiles(args.projectPath, previousFiles);
-    await removeInfraLedger(args.projectPath);
-    return {
-      generated: 0,
-      removed,
-      warnings: supportWarnings,
-    };
-  }
-
-  const generated = (args.generateInfrastructureImpl ?? generateInfrastructure)(
-    args.manifest.infra,
-    {
-      namespaceHint: args.projectId,
-      appManifest: args.manifest,
-    },
-  );
-  const combinedWarnings = uniqueStrings([...supportWarnings, ...generated.warnings]);
-  const nextFiles = new Set<string>();
-
-  for (const file of generated.files) {
-    const outputPath = resolveProjectFile(args.projectPath, file.path);
-    await fs.mkdir(path.dirname(outputPath), { recursive: true });
-    await fs.writeFile(outputPath, file.content, 'utf8');
-
-    if (file.executable === true) {
-      await fs.chmod(outputPath, 0o755);
-    }
-
-    nextFiles.add(file.path);
-  }
-
-  const staleFiles = new Set([...previousFiles].filter((filePath) => !nextFiles.has(filePath)));
-  const removed = await removeFiles(args.projectPath, staleFiles);
-
-  await writeInfraLedger(args.projectPath, {
-    schemaVersion: 1,
-    generatedAt: new Date().toISOString(),
-    target: generated.meta.target,
-    files: [...nextFiles].sort(),
-    warnings: combinedWarnings,
-  });
-
-  return {
-    generated: generated.files.length,
-    removed,
-    warnings: combinedWarnings,
-  };
-}
-
-export async function inspectProjectInfrastructure(args: {
-  readonly manifest: AppManifest;
-  readonly projectId: string;
-  readonly projectPath: string;
-}): Promise<InfraProjectInspection> {
-  const supportWarnings = validateInfraSupport(args.manifest.infra);
-
-  if (args.projectId === STUDIO_PROJECT_ID) {
-    return {
-      generated: false,
-      generatedAt: null,
-      hasDeployment: false,
-      target: null,
-      trackedFiles: 0,
-      warnings: supportWarnings,
-      skipped: {
-        reason: 'apps/studio is the dashboard and is not a generated app target.',
-      },
-    };
-  }
-
-  const ledger = await readInfraLedger(args.projectPath);
-  return {
-    generated: ledger !== null,
-    generatedAt: ledger?.generatedAt ?? null,
-    hasDeployment: args.manifest.infra.deployment !== undefined,
-    target: args.manifest.infra.deployment?.target ?? ledger?.target ?? null,
-    trackedFiles: ledger?.files.length ?? 0,
-    warnings: uniqueStrings([...supportWarnings, ...(ledger?.warnings ?? [])]),
-  };
-}
-
-export async function resolveProjectInfrastructureTarget(args: {
-  readonly manifest: AppManifest;
-  readonly projectPath: string;
-}): Promise<string | null> {
-  const manifestTarget = args.manifest.infra.deployment?.target;
-  if (manifestTarget !== undefined) {
-    return manifestTarget;
-  }
-
-  const ledger = await readInfraLedger(args.projectPath);
-  return ledger?.target ?? null;
-}
-
-export function resolveProjectFile(projectPath: string, filePath: string): string {
-  const rootPath = path.resolve(projectPath);
-  const resolvedPath = path.resolve(rootPath, filePath);
-  const relativePath = path.relative(rootPath, resolvedPath);
-
-  if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
-    throw new Error(`Invalid infra output path outside project root: ${filePath}`);
-  }
-
-  return resolvedPath;
-}
-
-async function readInfraLedger(projectPath: string): Promise<InfraLedger | null> {
-  const ledgerPath = path.join(projectPath, INFRA_LEDGER_RELATIVE_PATH);
-
-  try {
-    const rawLedger = await fs.readFile(ledgerPath, 'utf8');
-    const parsedLedger: unknown = JSON.parse(rawLedger);
-    return isInfraLedger(parsedLedger) ? parsedLedger : null;
-  } catch {
-    return null;
-  }
-}
-
-async function writeInfraLedger(projectPath: string, ledger: InfraLedger): Promise<void> {
-  const ledgerPath = path.join(projectPath, INFRA_LEDGER_RELATIVE_PATH);
-  await fs.mkdir(path.dirname(ledgerPath), { recursive: true });
-  await fs.writeFile(ledgerPath, `${JSON.stringify(ledger, null, 2)}\n`, 'utf8');
-}
-
-async function removeInfraLedger(projectPath: string): Promise<void> {
-  await fs.rm(path.join(projectPath, INFRA_LEDGER_RELATIVE_PATH), { force: true });
-}
-
-async function removeFiles(projectPath: string, files: ReadonlySet<string>): Promise<number> {
-  let removedFiles = 0;
-
-  for (const filePath of files) {
-    await fs.rm(resolveProjectFile(projectPath, filePath), { force: true });
-    removedFiles += 1;
-  }
-
-  return removedFiles;
-}
-
-function isInfraLedger(value: unknown): value is InfraLedger {
-  return (
-    isRecord(value) &&
-    value.schemaVersion === 1 &&
-    typeof value.generatedAt === 'string' &&
-    typeof value.target === 'string' &&
-    Array.isArray(value.files) &&
-    value.files.every((filePath) => typeof filePath === 'string') &&
-    Array.isArray(value.warnings) &&
-    value.warnings.every((warning) => typeof warning === 'string')
-  );
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null;
-}
-
-function uniqueStrings(values: readonly string[]): readonly string[] {
-  return [...new Set(values)];
-}

package/src/runtime.test.ts

@@ -1,124 +0,0 @@
-import { afterEach, describe, expect, test } from 'bun:test';
-import { promises as fs } from 'fs';
-import os from 'os';
-import path from 'path';
-
-import {
-  InfraScriptExecutionError,
-  resolveProjectInfraScriptPath,
-  runProjectInfraScript,
-} from './runtime.js';
-import { createCapturedCommandContext } from './testSupport.js';
-
-const tempRoots = new Set<string>();
-
-afterEach(async () => {
-  await Promise.all(
-    [...tempRoots].map((rootPath) => fs.rm(rootPath, { force: true, recursive: true })),
-  );
-  tempRoots.clear();
-});
-
-describe('runtime scripts', () => {
-  test('resolves minikube lifecycle scripts under the project infra directory', () => {
-    expect(
-      resolveProjectInfraScriptPath({
-        projectPath: '/workspace/apps/shop',
-        script: 'status',
-        target: 'minikube',
-      }),
-    ).toBe('/workspace/apps/shop/infra/minikube/scripts/status.sh');
-  });
-
-  test('streams script output to the command context', async () => {
-    const projectPath = await fs.mkdtemp(path.join(os.tmpdir(), 'infra-runtime-'));
-    tempRoots.add(projectPath);
-    const scriptDir = path.join(projectPath, 'infra/minikube/scripts');
-    await fs.mkdir(scriptDir, { recursive: true });
-    await fs.writeFile(
-      path.join(scriptDir, 'status.sh'),
-      '#!/usr/bin/env bash\necho status-ok\necho status-warn 1>&2\n',
-      'utf8',
-    );
-
-    const captured = createCapturedCommandContext(projectPath);
-
-    await runProjectInfraScript({
-      context: captured.context,
-      projectId: 'shop',
-      projectPath,
-      script: 'status',
-      target: 'minikube',
-    });
-
-    expect(captured.stdout.value).toContain('status-ok');
-    expect(captured.stderr.value).toContain('status-warn');
-  });
-
-  test('reports missing scripts clearly', async () => {
-    const projectPath = await fs.mkdtemp(path.join(os.tmpdir(), 'infra-missing-'));
-    tempRoots.add(projectPath);
-    const captured = createCapturedCommandContext(projectPath);
-
-    await expectRejectMessage(
-      runProjectInfraScript({
-        context: captured.context,
-        projectId: 'shop',
-        projectPath,
-        script: 'up',
-        target: 'minikube',
-      }),
-      'Run infra generate for project',
-    );
-  });
-
-  test('wraps non-zero script exits in InfraScriptExecutionError', async () => {
-    const projectPath = await fs.mkdtemp(path.join(os.tmpdir(), 'infra-error-'));
-    tempRoots.add(projectPath);
-    const scriptDir = path.join(projectPath, 'infra/minikube/scripts');
-    await fs.mkdir(scriptDir, { recursive: true });
-    await fs.writeFile(
-      path.join(scriptDir, 'down.sh'),
-      '#!/usr/bin/env bash\necho boom 1>&2\nexit 7\n',
-      'utf8',
-    );
-
-    const captured = createCapturedCommandContext(projectPath);
-
-    try {
-      await runProjectInfraScript({
-        context: captured.context,
-        projectId: 'shop',
-        projectPath,
-        script: 'down',
-        target: 'minikube',
-      });
-      throw new Error('Expected runtime script to fail.');
-    } catch (error) {
-      expect(error).toBeInstanceOf(InfraScriptExecutionError);
-    }
-  });
-
-  test('rejects unsupported deployment targets', () => {
-    expect(() =>
-      resolveProjectInfraScriptPath({
-        projectPath: '/workspace/apps/shop',
-        script: 'status',
-        target: 'aws',
-      }),
-    ).toThrow('Unsupported deployment target for infra scripts');
-  });
-});
-
-async function expectRejectMessage(promise: Promise<unknown>, text: string): Promise<void> {
-  let didReject = false;
-
-  try {
-    await promise;
-  } catch (error) {
-    didReject = true;
-    expect(error instanceof Error ? error.message : String(error)).toContain(text);
-  }
-
-  expect(didReject).toBe(true);
-}

package/src/runtime.ts

@@ -1,234 +0,0 @@
-import { spawn } from 'child_process';
-import { promises as fs } from 'fs';
-import path from 'path';
-
-import type { InfraCommandContext } from './commandContext.js';
-import { readProjectInfrastructureEnvironment } from './projectEnvironment.js';
-
-export type InfraLifecycleScript = 'destroy' | 'down' | 'port-forward' | 'reset' | 'status' | 'up';
-
-export interface InfraScriptOutput {
-  readonly stderr: string;
-  readonly stdout: string;
-}
-
-export interface InfraPortForwardInfo {
-  readonly localPort: number;
-  readonly url: string;
-}
-
-export class InfraScriptExecutionError extends Error {
-  readonly exitCode: number | null;
-  readonly stderr: string;
-  readonly stdout: string;
-
-  constructor(args: {
-    readonly exitCode: number | null;
-    readonly message: string;
-    readonly stderr: string;
-    readonly stdout: string;
-  }) {
-    super(args.message);
-    this.name = 'InfraScriptExecutionError';
-    this.exitCode = args.exitCode;
-    this.stderr = args.stderr;
-    this.stdout = args.stdout;
-  }
-}
-
-export async function runProjectInfrastructureLifecycle(args: {
-  readonly args?: readonly string[];
-  readonly env?: Readonly<Record<string, string | undefined>>;
-  readonly onStderr?: (chunk: string) => void;
-  readonly onStdout?: (chunk: string) => void;
-  readonly projectId: string;
-  readonly projectPath: string;
-  readonly script: InfraLifecycleScript;
-  readonly target: string;
-}): Promise<InfraScriptOutput> {
-  const scriptPath = resolveProjectInfraScriptPath(args);
-  if (!(await pathExists(scriptPath))) {
-    throw new Error(
-      `Infra script not found: ${scriptPath}. Run infra generate for project '${args.projectId}' first.`,
-    );
-  }
-
-  return runShellScript({
-    args: args.args ?? [],
-    env: args.env ?? process.env,
-    onStderr: args.onStderr,
-    onStdout: args.onStdout,
-    scriptPath,
-  });
-}
-
-export async function resolveProjectInfrastructurePortForward(args: {
-  readonly projectPath: string;
-  readonly target: string;
-}): Promise<InfraPortForwardInfo> {
-  const environment = await readProjectInfrastructureEnvironment({
-    keys: ['APP_PORT_FORWARD_LOCAL_PORT'],
-    projectPath: args.projectPath,
-    target: args.target,
-  });
-  const localPort = parsePositivePort(environment.APP_PORT_FORWARD_LOCAL_PORT);
-
-  if (localPort === null) {
-    throw new Error(
-      'Generated Infra did not provide a valid APP_PORT_FORWARD_LOCAL_PORT. Regenerate infrastructure first.',
-    );
-  }
-
-  return {
-    localPort,
-    url: `http://127.0.0.1:${localPort}`,
-  };
-}
-
-/** Ensures the generated host forwards required by a running application are active. */
-export async function ensureProjectInfrastructureRuntime(args: {
-  readonly projectId: string;
-  readonly projectPath: string;
-  readonly target: string;
-}): Promise<InfraScriptOutput> {
-  try {
-    return await runProjectInfrastructureLifecycle({
-      args: ['start', 'runtime'],
-      projectId: args.projectId,
-      projectPath: args.projectPath,
-      script: 'port-forward',
-      target: args.target,
-    });
-  } catch (error) {
-    if (!(error instanceof InfraScriptExecutionError)) {
-      throw error;
-    }
-
-    const detail = error.stderr.trim() || error.stdout.trim();
-    throw new InfraScriptExecutionError({
-      exitCode: error.exitCode,
-      message: `Failed to ensure infrastructure runtime for project '${args.projectId}'${
-        detail.length > 0 ? `: ${detail}` : '.'
-      }`,
-      stderr: error.stderr,
-      stdout: error.stdout,
-    });
-  }
-}
-
-export async function runProjectInfraScript(args: {
-  readonly context: InfraCommandContext;
-  readonly projectId: string;
-  readonly projectPath: string;
-  readonly script: InfraLifecycleScript;
-  readonly target: string;
-}): Promise<void> {
-  await runProjectInfrastructureLifecycle({
-    env: args.context.env,
-    onStderr: (chunk) => args.context.writeStderr(chunk),
-    onStdout: (chunk) => args.context.writeStdout(chunk),
-    projectId: args.projectId,
-    projectPath: args.projectPath,
-    script: args.script,
-    target: args.target,
-  });
-}
-
-export function resolveProjectInfraScriptPath(args: {
-  readonly projectPath: string;
-  readonly script: InfraLifecycleScript;
-  readonly target: string;
-}): string {
-  return path.join(args.projectPath, getInfraScriptsDirectory(args.target), `${args.script}.sh`);
-}
-
-function getInfraScriptsDirectory(target: string): string {
-  switch (target) {
-    case 'minikube':
-      return 'infra/minikube/scripts';
-    default:
-      throw new Error(`Unsupported deployment target for infra scripts: ${target}`);
-  }
-}
-
-async function runShellScript(args: {
-  readonly args: readonly string[];
-  readonly env: Readonly<Record<string, string | undefined>>;
-  readonly onStderr?: (chunk: string) => void;
-  readonly onStdout?: (chunk: string) => void;
-  readonly scriptPath: string;
-}): Promise<InfraScriptOutput> {
-  return new Promise<InfraScriptOutput>((resolve, reject) => {
-    const child = spawn('bash', [args.scriptPath, ...args.args], {
-      cwd: path.dirname(args.scriptPath),
-      env: { ...args.env },
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-
-    let stdout = '';
-    let stderr = '';
-    child.stdout.setEncoding('utf8');
-    child.stderr.setEncoding('utf8');
-    child.stdout.on('data', (chunk: string) => {
-      stdout += chunk;
-      args.onStdout?.(chunk);
-    });
-    child.stderr.on('data', (chunk: string) => {
-      stderr += chunk;
-      args.onStderr?.(chunk);
-    });
-    child.once('error', (error) =>
-      reject(createStartError(args.scriptPath, error, stdout, stderr)),
-    );
-    child.once('close', (exitCode) => {
-      if (exitCode === 0) {
-        resolve({ stderr, stdout });
-        return;
-      }
-      reject(createExitError(args.scriptPath, exitCode, stdout, stderr));
-    });
-  });
-}
-
-function createStartError(
-  scriptPath: string,
-  error: Error,
-  stdout: string,
-  stderr: string,
-): InfraScriptExecutionError {
-  return new InfraScriptExecutionError({
-    exitCode: null,
-    message: `Failed to start infra script '${scriptPath}': ${error.message}`,
-    stderr,
-    stdout,
-  });
-}
-
-function createExitError(
-  scriptPath: string,
-  exitCode: number | null,
-  stdout: string,
-  stderr: string,
-): InfraScriptExecutionError {
-  return new InfraScriptExecutionError({
-    exitCode,
-    message: `Infra script '${scriptPath}' exited with code ${exitCode ?? 'unknown'}.`,
-    stderr,
-    stdout,
-  });
-}
-
-function parsePositivePort(value: string | undefined): number | null {
-  if (value === undefined) return null;
-  const parsed = Number.parseInt(value.trim(), 10);
-  return Number.isInteger(parsed) && parsed >= 1 && parsed <= 65_535 ? parsed : null;
-}
-
-async function pathExists(filePath: string): Promise<boolean> {
-  try {
-    await fs.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}

package/src/secretStore.test.ts

@@ -1,76 +0,0 @@
-import type {
-  SupabaseVaultQueryResult,
-  SupabaseVaultSqlClient,
-  SupabaseVaultSqlExecutor,
-} from '@ankhorage/supabase-vault';
-import { describe, expect, test } from 'bun:test';
-
-import { createInfraSecretStoreAdapter } from './secretStore';
-
-class FakeSupabaseVaultClient implements SupabaseVaultSqlClient {
-  query<TRow extends Record<string, unknown>>(): Promise<SupabaseVaultQueryResult<TRow>> {
-    return Promise.resolve({ rows: [] });
-  }
-
-  transaction<TResult>(
-    operation: (executor: SupabaseVaultSqlExecutor) => Promise<TResult>,
-  ): Promise<TResult> {
-    return operation(this);
-  }
-}
-
-describe('createInfraSecretStoreAdapter', () => {
-  test('returns null when the manifest does not select a secret store', () => {
-    expect(
-      createInfraSecretStoreAdapter({
-        manifest: {},
-        providers: {},
-      }),
-    ).toBeNull();
-  });
-
-  test('creates the released Supabase Vault adapter from trusted options', () => {
-    const adapter = createInfraSecretStoreAdapter({
-      manifest: {
-        secretStore: {
-          provider: 'supabase-vault',
-        },
-      },
-      providers: {
-        supabaseVault: {
-          client: new FakeSupabaseVaultClient(),
-        },
-      },
-    });
-
-    expect(adapter).not.toBeNull();
-    expect(typeof adapter?.list).toBe('function');
-    expect(typeof adapter?.resolve).toBe('function');
-  });
-
-  test('requires trusted provider bootstrap options', () => {
-    expect(() =>
-      createInfraSecretStoreAdapter({
-        manifest: {
-          secretStore: {
-            provider: 'supabase-vault',
-          },
-        },
-        providers: {},
-      }),
-    ).toThrow('requires trusted Supabase Vault adapter options');
-  });
-
-  test('rejects unknown providers instead of silently falling back', () => {
-    expect(() =>
-      createInfraSecretStoreAdapter({
-        manifest: {
-          secretStore: {
-            provider: 'aws-secrets-manager',
-          },
-        },
-        providers: {},
-      }),
-    ).toThrow('Unsupported secret-store provider');
-  });
-});