@ankhorage/infra 3.1.1 → 3.3.0

package/src/project/index.test.ts

@@ -3,7 +3,11 @@ import { promises as fs } from 'fs';
 import os from 'os';
 import path from 'path';
 
+import { createAppManifest } from '../testSupport.js';
 import {
+  inspectProjectInfrastructure,
+  readProjectInfrastructureEnvironment,
+  resolveProjectInfrastructureDatabaseUrl,
   resolveProjectInfrastructurePortForward,
   runProjectInfrastructureLifecycle,
 } from './index.js';
@@ -29,7 +33,13 @@ async function createProjectFixture(): Promise<string> {
   );
   await fs.writeFile(
     path.join(infraRoot, '.env.example'),
-    'APP_PORT_FORWARD_LOCAL_PORT=48123\n',
+    [
+      'APP_PORT_FORWARD_LOCAL_PORT=48123',
+      'SITE_URL=http://example.local',
+      'DATABASE_URL=postgres://example',
+      'PRIVATE_VALUE=not-selected',
+      '',
+    ].join('\n'),
     'utf8',
   );
   return projectPath;
@@ -67,4 +77,73 @@ describe('@ankhorage/infra/project', () => {
       url: 'http://127.0.0.1:48123',
     });
   });
+
+  test('reads only requested runtime environment values from the generated fallback', async () => {
+    const projectPath = await createProjectFixture();
+    const result = await readProjectInfrastructureEnvironment({
+      keys: ['SITE_URL', 'MISSING_VALUE'],
+      projectPath,
+      target: 'minikube',
+    });
+
+    expect(result).toEqual({ SITE_URL: 'http://example.local' });
+  });
+
+  test('prefers generated runtime environment and resolves the trusted database URL', async () => {
+    const projectPath = await createProjectFixture();
+    const envPath = path.join(projectPath, 'infra', 'minikube', '.env');
+    await fs.writeFile(
+      envPath,
+      'SITE_URL=http://runtime.local\nDATABASE_URL=postgres://runtime\n',
+      'utf8',
+    );
+
+    const environment = await readProjectInfrastructureEnvironment({
+      keys: ['SITE_URL'],
+      projectPath,
+      target: 'minikube',
+    });
+    const databaseUrl = await resolveProjectInfrastructureDatabaseUrl({
+      projectPath,
+      target: 'minikube',
+    });
+
+    expect(environment).toEqual({ SITE_URL: 'http://runtime.local' });
+    expect(databaseUrl).toBe('postgres://runtime');
+  });
+
+  test('inspects deployment and generated state through the owner ledger', async () => {
+    const projectPath = await createProjectFixture();
+    await fs.mkdir(path.join(projectPath, '.ankh'), { recursive: true });
+    await fs.writeFile(
+      path.join(projectPath, '.ankh', 'infra-ledger.json'),
+      JSON.stringify({
+        schemaVersion: 1,
+        generatedAt: '2026-08-12T04:00:00.000Z',
+        target: 'minikube',
+        files: ['infra/minikube/.env.example', 'infra/minikube/scripts/status.sh'],
+        warnings: ['generated warning'],
+      }),
+      'utf8',
+    );
+    const manifest = createAppManifest('example', {
+      deployment: { monitoring: false, target: 'minikube' },
+      modules: [],
+    });
+
+    const result = await inspectProjectInfrastructure({
+      manifest,
+      projectId: 'example',
+      projectPath,
+    });
+
+    expect(result).toEqual({
+      generated: true,
+      generatedAt: '2026-08-12T04:00:00.000Z',
+      hasDeployment: true,
+      target: 'minikube',
+      trackedFiles: 2,
+      warnings: ['generated warning'],
+    });
+  });
 });

package/src/project/index.ts

@@ -2,8 +2,12 @@ export {
   type ResolvedInfraProject,
   resolveInfraProject as resolveInfraWorkspaceProject,
 } from '../project.js';
+export { resolveProjectInfrastructureDatabaseUrl } from '../projectDatabase.js';
+export { readProjectInfrastructureEnvironment } from '../projectEnvironment.js';
 export {
+  type InfraProjectInspection,
   type InfraSyncResult,
+  inspectProjectInfrastructure,
   resolveProjectInfrastructureTarget,
   syncProjectInfrastructure,
 } from '../projectInfrastructure.js';

package/src/projectDatabase.ts

@@ -0,0 +1,27 @@
+import { readProjectInfrastructureEnvironment } from './projectEnvironment.js';
+
+const DATABASE_URL_KEYS = [
+  'ANKH_SECRET_STORE_DATABASE_URL',
+  'SUPABASE_DB_URL',
+  'POSTGRES_URL',
+  'DB_URL',
+  'DATABASE_URL',
+] as const;
+
+export async function resolveProjectInfrastructureDatabaseUrl(args: {
+  readonly projectPath: string;
+  readonly target: string;
+}): Promise<string | null> {
+  const environment = await readProjectInfrastructureEnvironment({
+    keys: DATABASE_URL_KEYS,
+    projectPath: args.projectPath,
+    target: args.target,
+  });
+
+  for (const key of DATABASE_URL_KEYS) {
+    const value = environment[key]?.trim();
+    if (value) return value;
+  }
+
+  return null;
+}

package/src/projectEnvironment.ts

@@ -0,0 +1,51 @@
+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

@@ -25,6 +25,18 @@ export interface InfraSyncResult {
   };
 }
 
+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;
@@ -97,6 +109,38 @@ export async function syncProjectInfrastructure(args: {
   };
 }
 
+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;

package/src/runtime.ts

@@ -3,6 +3,7 @@ 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';
 
@@ -65,16 +66,16 @@ export async function resolveProjectInfrastructurePortForward(args: {
   readonly projectPath: string;
   readonly target: string;
 }): Promise<InfraPortForwardInfo> {
-  const infraRoot = path.join(args.projectPath, 'infra', args.target);
-  const envPath = path.join(infraRoot, '.env');
-  const fallbackEnvPath = path.join(infraRoot, '.env.example');
-  const sourcePath = (await pathExists(envPath)) ? envPath : fallbackEnvPath;
-  const env = await readSimpleEnvMap(sourcePath);
-  const localPort = parsePositivePort(env.get('APP_PORT_FORWARD_LOCAL_PORT'));
+  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 in ${sourcePath}. Regenerate infrastructure first.`,
+      'Generated Infra did not provide a valid APP_PORT_FORWARD_LOCAL_PORT. Regenerate infrastructure first.',
     );
   }
 
@@ -186,24 +187,6 @@ function createExitError(
   });
 }
 
-async function readSimpleEnvMap(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;
-}
-
 function parsePositivePort(value: string | undefined): number | null {
   if (value === undefined) return null;
   const parsed = Number.parseInt(value.trim(), 10);

package/src/types.ts

@@ -37,7 +37,7 @@ export interface InfrastructureGenerationOptions {
    */
   readonly appManifest?: Pick<
     AppManifest,
-    'generatedApis' | 'infra' | 'metadata' | 'navigator' | 'screens' | 'settings'
+    'deploy' | 'generatedApis' | 'infra' | 'metadata' | 'navigator' | 'screens' | 'settings'
   >;
 }