@appliance.sh/api-server 1.20.0 → 1.22.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@appliance.sh/api-server",
-  "version": "1.20.0",
+  "version": "1.22.0",
   "description": "",
   "author": "Eliot Lim",
   "repository": "https://github.com/appliance-sh/appliance.sh",
@@ -19,8 +19,8 @@
     "test:e2e": "vitest run --config vitest.e2e.config.ts"
   },
   "dependencies": {
-    "@appliance.sh/infra": "1.20.0",
-    "@appliance.sh/sdk": "1.20.0",
+    "@appliance.sh/infra": "1.22.0",
+    "@appliance.sh/sdk": "1.22.0",
     "@aws-sdk/client-ecr": "^3.1005.0",
     "@aws-sdk/client-s3": "^3.750.0",
     "express": "^5.2.1"

package/src/services/build.service.ts

@@ -1,7 +1,7 @@
 import { S3Client, GetObjectCommand } from '@aws-sdk/client-s3';
 import { ECRClient, GetAuthorizationTokenCommand } from '@aws-sdk/client-ecr';
 import { applianceBaseConfig, applianceInput } from '@appliance.sh/sdk';
-import type { ApplianceContainer } from '@appliance.sh/sdk';
+import type { ApplianceContainer, ApplianceFrameworkApp } from '@appliance.sh/sdk';
 import { execSync } from 'child_process';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
@@ -10,6 +10,11 @@ import * as os from 'node:os';
 export interface ResolvedBuild {
   imageUri?: string;
   codeS3Key?: string;
+  runtime?: string;
+  handler?: string;
+  layers?: string[];
+  architectures?: string[];
+  environment?: Record<string, string>;
 }
 
 function getBaseConfig() {
@@ -18,6 +23,23 @@ function getBaseConfig() {
   return applianceBaseConfig.parse(JSON.parse(raw));
 }
 
+const LAMBDA_ADAPTER_LAYER: Record<string, string> = {
+  'linux/amd64': 'arn:aws:lambda:${region}:753240598075:layer:LambdaAdapterLayerX86:26',
+  'linux/arm64': 'arn:aws:lambda:${region}:753240598075:layer:LambdaAdapterLayerArm64:26',
+};
+
+const FRAMEWORK_RUNTIMES: Record<string, string> = {
+  node: 'nodejs22.x',
+  python: 'python3.13',
+  auto: 'nodejs22.x',
+  other: 'nodejs22.x',
+};
+
+const FRAMEWORK_ARCHITECTURES: Record<string, string> = {
+  'linux/amd64': 'x86_64',
+  'linux/arm64': 'arm64',
+};
+
 export class BuildService {
   async resolve(buildId: string, tag: string): Promise<ResolvedBuild> {
     const config = getBaseConfig();
@@ -55,8 +77,9 @@ export class BuildService {
 
       if (manifest.type === 'container') {
         return this.resolveContainer(tmpDir, manifest, tag, config);
+      } else if (manifest.type === 'framework') {
+        return this.resolveFramework(manifest, s3Key, config);
       } else {
-        // For framework/other, the zip is already in S3 — just reference it
         return { codeS3Key: s3Key };
       }
     } finally {
@@ -64,6 +87,43 @@ export class BuildService {
     }
   }
 
+  /**
+   * Framework builds are fully pre-processed by the CLI (dependencies installed,
+   * run.sh generated). The server just resolves Lambda-specific params from the
+   * manifest metadata and points at the original uploaded zip.
+   */
+  private resolveFramework(
+    manifest: ApplianceFrameworkApp,
+    s3Key: string,
+    config: ReturnType<typeof getBaseConfig>
+  ): ResolvedBuild {
+    const port = manifest.port ?? 8080;
+    const framework = manifest.framework ?? 'auto';
+    const runtime = FRAMEWORK_RUNTIMES[framework] ?? FRAMEWORK_RUNTIMES['node'];
+
+    const platform = manifest.platform;
+    const layerArn = LAMBDA_ADAPTER_LAYER[platform]?.replace('${region}', config.aws.region);
+    if (!layerArn) throw new Error(`No Lambda Web Adapter layer for platform: ${platform}`);
+    const architecture = FRAMEWORK_ARCHITECTURES[platform];
+    if (!architecture) throw new Error(`No Lambda architecture for platform: ${platform}`);
+
+    return {
+      codeS3Key: s3Key,
+      runtime,
+      handler: 'run.sh',
+      layers: [layerArn],
+      architectures: [architecture],
+      environment: {
+        AWS_LAMBDA_EXEC_WRAPPER: '/opt/bootstrap',
+        AWS_LWA_PORT: String(port),
+      },
+    };
+  }
+
+  /**
+   * Container builds are fully pre-processed by the CLI (Lambda Web Adapter
+   * already injected). The server just loads the image and pushes it to ECR.
+   */
   private async resolveContainer(
     tmpDir: string,
     manifest: ApplianceContainer,
@@ -76,31 +136,12 @@ export class BuildService {
     const imageTarPath = path.join(tmpDir, 'image.tar');
     if (!fs.existsSync(imageTarPath)) throw new Error('Build missing image.tar');
 
-    // Load the user's original image into Docker and capture the loaded image reference
+    // Load the pre-built Lambda-ready image
     const loadOutput = execSync(`docker load -i "${imageTarPath}"`, { encoding: 'utf-8' });
-    // Output is like "Loaded image: name:tag" or "Loaded image ID: sha256:abc..."
     const loadedMatch = loadOutput.match(/Loaded image(?: ID)?:\s*(.+)/);
     if (!loadedMatch) throw new Error(`Failed to parse docker load output: ${loadOutput}`);
     const loadedImage = loadedMatch[1].trim();
 
-    // Wrap the image with the Lambda Web Adapter so the same plain HTTP
-    // container works on both Lambda and ECS/Fargate without any changes.
-    const lambdaImageName = `${manifest.name}-lambda`;
-    const wrapperDockerfile = path.join(tmpDir, 'Dockerfile.lambda');
-    fs.writeFileSync(
-      wrapperDockerfile,
-      [
-        `FROM --platform=${manifest.platform} public.ecr.aws/awsguru/aws-lambda-adapter:0.9.1 AS adapter`,
-        `FROM ${loadedImage}`,
-        `COPY --from=adapter /lambda-adapter /opt/extensions/lambda-adapter`,
-        `ENV AWS_LWA_PORT=${manifest.port}`,
-      ].join('\n')
-    );
-    execSync(
-      `docker build --platform ${manifest.platform} --provenance=false -f "${wrapperDockerfile}" -t "${lambdaImageName}" "${tmpDir}"`,
-      { stdio: 'pipe' }
-    );
-
     // Auth with ECR
     const ecr = new ECRClient({ region: config.aws.region });
     const authResult = await ecr.send(new GetAuthorizationTokenCommand({}));
@@ -116,15 +157,15 @@ export class BuildService {
       stdio: ['pipe', 'pipe', 'pipe'],
     });
 
-    // Tag and push the Lambda-wrapped image
+    // Tag and push
     const remoteTag = `${ecrRepositoryUrl}:${tag}`;
-    execSync(`docker tag ${lambdaImageName} ${remoteTag}`, { stdio: 'pipe' });
-    execSync(`docker push ${remoteTag}`, { stdio: 'pipe' });
+    execSync(`docker tag "${loadedImage}" "${remoteTag}"`, { stdio: 'pipe' });
+    execSync(`docker push "${remoteTag}"`, { stdio: 'pipe' });
 
     // Get digest
     let imageUri: string;
     try {
-      imageUri = execSync(`docker inspect --format='{{index .RepoDigests 0}}' ${remoteTag}`, {
+      imageUri = execSync(`docker inspect --format='{{index .RepoDigests 0}}' "${remoteTag}"`, {
         encoding: 'utf-8',
       }).trim();
     } catch {