@ankhorage/infra 2.0.1 → 3.1.1

package/src/runtime.ts

@@ -4,7 +4,17 @@ import path from 'path';
 
 import type { InfraCommandContext } from './commandContext.js';
 
-export type InfraLifecycleScript = 'down' | 'status' | 'up';
+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;
@@ -25,13 +35,16 @@ export class InfraScriptExecutionError extends Error {
   }
 }
 
-export async function runProjectInfraScript(args: {
-  readonly context: InfraCommandContext;
+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<void> {
+}): Promise<InfraScriptOutput> {
   const scriptPath = resolveProjectInfraScriptPath(args);
   if (!(await pathExists(scriptPath))) {
     throw new Error(
@@ -39,12 +52,56 @@ export async function runProjectInfraScript(args: {
     );
   }
 
-  await runShellScript({
-    context: args.context,
+  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 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'));
+
+  if (localPort === null) {
+    throw new Error(
+      `Generated Infra did not provide a valid APP_PORT_FORWARD_LOCAL_PORT in ${sourcePath}. Regenerate infrastructure first.`,
+    );
+  }
+
+  return {
+    localPort,
+    url: `http://127.0.0.1:${localPort}`,
+  };
+}
+
+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;
@@ -63,60 +120,96 @@ function getInfraScriptsDirectory(target: string): string {
 }
 
 async function runShellScript(args: {
-  readonly context: InfraCommandContext;
+  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<void> {
-  await new Promise<void>((resolve, reject) => {
-    const child = spawn('bash', [args.scriptPath], {
+}): Promise<InfraScriptOutput> {
+  return new Promise<InfraScriptOutput>((resolve, reject) => {
+    const child = spawn('bash', [args.scriptPath, ...args.args], {
       cwd: path.dirname(args.scriptPath),
-      env: { ...args.context.env },
+      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.context.writeStdout(chunk);
+      args.onStdout?.(chunk);
     });
-
-    child.stderr.setEncoding('utf8');
     child.stderr.on('data', (chunk: string) => {
       stderr += chunk;
-      args.context.writeStderr(chunk);
-    });
-
-    child.once('error', (error) => {
-      reject(
-        new InfraScriptExecutionError({
-          exitCode: null,
-          message: `Failed to start infra script '${args.scriptPath}': ${error.message}`,
-          stderr,
-          stdout,
-        }),
-      );
+      args.onStderr?.(chunk);
     });
-
+    child.once('error', (error) =>
+      reject(createStartError(args.scriptPath, error, stdout, stderr)),
+    );
     child.once('close', (exitCode) => {
       if (exitCode === 0) {
-        resolve();
+        resolve({ stderr, stdout });
         return;
       }
-
-      reject(
-        new InfraScriptExecutionError({
-          exitCode,
-          message: `Infra script '${args.scriptPath}' exited with code ${exitCode ?? 'unknown'}.`,
-          stderr,
-          stdout,
-        }),
-      );
+      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,
+  });
+}
+
+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);
+  return Number.isInteger(parsed) && parsed >= 1 && parsed <= 65_535 ? parsed : null;
+}
+
 async function pathExists(filePath: string): Promise<boolean> {
   try {
     await fs.access(filePath);

package/src/testSupport.ts

@@ -79,7 +79,7 @@ export async function createWorkspaceFixture(
 
 export function createAppManifest(
   projectId: string,
-  infra: AppManifest['infra'] = { plugins: [] },
+  infra: AppManifest['infra'] = { modules: [] },
 ): AppManifest {
   return {
     metadata: {