@korajs/cli 0.2.0 → 0.3.1

package/dist/{chunk-E4JG7THU.js → chunk-E7OCVRYL.js}

@@ -8,54 +8,16 @@ import {
 } from "./chunk-KTSRAPSE.js";
 
 // src/commands/deploy/adapters/adapter.ts
-var DEPLOY_PLATFORMS = ["fly", "railway", "render", "docker", "kora-cloud"];
+var DEPLOY_PLATFORMS = ["fly", "railway", "aws-ecs", "aws-lightsail", "render", "docker", "kora-cloud"];
 function isDeployPlatform(value) {
   return DEPLOY_PLATFORMS.includes(value);
 }
 
-// src/commands/deploy/artifacts/fly-toml-generator.ts
-import { mkdir, writeFile } from "fs/promises";
-import { join } from "path";
-var GENERATED_HEADER = "# Generated by kora deploy \u2014 do not edit manually";
-function generateFlyToml(options) {
-  const internalPort = options.internalPort ?? 3e3;
-  return [
-    GENERATED_HEADER,
-    "",
-    `app = "${options.appName}"`,
-    `primary_region = "${options.region}"`,
-    "",
-    "[build]",
-    `  dockerfile = "Dockerfile"`,
-    "",
-    "[http_service]",
-    `  internal_port = ${String(internalPort)}`,
-    "  force_https = true",
-    '  auto_stop_machines = "stop"',
-    "  auto_start_machines = true",
-    "  min_machines_running = 0",
-    "",
-    "  [[http_service.checks]]",
-    '    grace_period = "10s"',
-    '    interval = "30s"',
-    '    method = "GET"',
-    '    timeout = "5s"',
-    '    path = "/"',
-    ""
-  ].join("\n");
-}
-async function writeFlyTomlArtifact(deployDirectory, options) {
-  await mkdir(deployDirectory, { recursive: true });
-  const filePath = join(deployDirectory, "fly.toml");
-  await writeFile(filePath, generateFlyToml(options), "utf-8");
-  return filePath;
-}
-
 // src/commands/deploy/builder/client-builder.ts
 import { spawn } from "child_process";
 import { copyFile, readdir } from "fs/promises";
 import { existsSync } from "fs";
-import { join as join2, resolve } from "path";
+import { join, resolve } from "path";
 async function buildClient(options) {
   const viteEntryPoint = await resolveProjectBinaryEntryPoint(options.projectRoot, "vite", "vite");
   if (!viteEntryPoint) {
@@ -76,12 +38,12 @@ async function buildClient(options) {
   return { outDir: options.outDir };
 }
 async function patchSqliteWasmAssets(projectRoot, outDir) {
-  const assetsDir = join2(outDir, "assets");
+  const assetsDir = join(outDir, "assets");
   if (!existsSync(assetsDir)) return;
   const files = await readdir(assetsDir);
   const hashedWasm = files.find((f) => /^sqlite3-.+\.wasm$/.test(f));
   if (hashedWasm && !files.includes("sqlite3.wasm")) {
-    await copyFile(join2(assetsDir, hashedWasm), join2(assetsDir, "sqlite3.wasm"));
+    await copyFile(join(assetsDir, hashedWasm), join(assetsDir, "sqlite3.wasm"));
   }
   if (!files.includes("sqlite3-opfs-async-proxy.js")) {
     const proxyFile = resolve(
@@ -94,7 +56,7 @@ async function patchSqliteWasmAssets(projectRoot, outDir) {
       "sqlite3-opfs-async-proxy.js"
     );
     if (existsSync(proxyFile)) {
-      await copyFile(proxyFile, join2(assetsDir, "sqlite3-opfs-async-proxy.js"));
+      await copyFile(proxyFile, join(assetsDir, "sqlite3-opfs-async-proxy.js"));
     }
   }
 }
@@ -119,9 +81,9 @@ async function runProcess(command, args, cwd) {
 }
 
 // src/commands/deploy/builder/server-bundler.ts
-import { mkdir as mkdir2 } from "fs/promises";
+import { mkdir } from "fs/promises";
 import { access } from "fs/promises";
-import { join as join3 } from "path";
+import { join as join2 } from "path";
 import { build } from "esbuild";
 var DEFAULT_ENTRY_CANDIDATES = [
   "server.ts",
@@ -137,8 +99,8 @@ async function bundleServer(options) {
       `Could not find a server entry file in ${options.projectRoot}. Looked for: ${candidates.join(", ")}`
     );
   }
-  await mkdir2(options.deployDirectory, { recursive: true });
-  const outputFilePath = join3(options.deployDirectory, "server-bundled.js");
+  await mkdir(options.deployDirectory, { recursive: true });
+  const outputFilePath = join2(options.deployDirectory, "server-bundled.js");
   await build({
     entryPoints: [entryFilePath],
     outfile: outputFilePath,
@@ -160,7 +122,7 @@ async function bundleServer(options) {
 }
 async function resolveServerEntry(projectRoot, candidates) {
   for (const candidate of candidates) {
-    const fullPath = join3(projectRoot, candidate);
+    const fullPath = join2(projectRoot, candidate);
     try {
       await access(fullPath);
       return fullPath;
@@ -170,6 +132,44 @@ async function resolveServerEntry(projectRoot, candidates) {
   return null;
 }
 
+// src/commands/deploy/artifacts/fly-toml-generator.ts
+import { mkdir as mkdir2, writeFile } from "fs/promises";
+import { join as join3 } from "path";
+var GENERATED_HEADER = "# Generated by kora deploy \u2014 do not edit manually";
+function generateFlyToml(options) {
+  const internalPort = options.internalPort ?? 3e3;
+  return [
+    GENERATED_HEADER,
+    "",
+    `app = "${options.appName}"`,
+    `primary_region = "${options.region}"`,
+    "",
+    "[build]",
+    `  dockerfile = "Dockerfile"`,
+    "",
+    "[http_service]",
+    `  internal_port = ${String(internalPort)}`,
+    "  force_https = true",
+    '  auto_stop_machines = "stop"',
+    "  auto_start_machines = true",
+    "  min_machines_running = 0",
+    "",
+    "  [[http_service.checks]]",
+    '    grace_period = "10s"',
+    '    interval = "30s"',
+    '    method = "GET"',
+    '    timeout = "5s"',
+    '    path = "/"',
+    ""
+  ].join("\n");
+}
+async function writeFlyTomlArtifact(deployDirectory, options) {
+  await mkdir2(deployDirectory, { recursive: true });
+  const filePath = join3(deployDirectory, "fly.toml");
+  await writeFile(filePath, generateFlyToml(options), "utf-8");
+  return filePath;
+}
+
 // src/commands/deploy/adapters/fly-adapter.ts
 import { spawn as spawn2 } from "child_process";
 import { join as join4 } from "path";
@@ -896,6 +896,745 @@ var StubDeployAdapter = class {
   }
 };
 
+// src/commands/deploy/adapters/aws-ecs-adapter.ts
+import { spawn as spawn4 } from "child_process";
+import { join as join7 } from "path";
+var AwsEcsAdapter = class {
+  name = "aws-ecs";
+  logger = createLogger();
+  runner;
+  currentContext;
+  constructor(options = {}) {
+    this.runner = options.runner ?? new NodeAwsCommandRunner();
+    this.currentContext = options.context ?? null;
+  }
+  setContext(context) {
+    this.currentContext = context;
+  }
+  async detect() {
+    const result = await this.runner.run("aws", ["--version"], process.cwd());
+    return result.exitCode === 0;
+  }
+  async install() {
+    const available = await this.detect();
+    if (!available) {
+      throw new Error(
+        "AWS CLI is required but not installed. Install from https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html"
+      );
+    }
+  }
+  async authenticate() {
+    const cwd = this.currentContext?.projectRoot ?? process.cwd();
+    const result = await this.runner.run("aws", ["sts", "get-caller-identity"], cwd);
+    if (result.exitCode !== 0) {
+      throw new Error(
+        "AWS CLI is not authenticated. Run `aws configure` or set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables."
+      );
+    }
+  }
+  async provision(config) {
+    this.currentContext = {
+      projectRoot: config.projectRoot,
+      appName: config.appName,
+      region: config.region ?? "us-east-1"
+    };
+    const region = config.region ?? "us-east-1";
+    const repoName = `kora/${config.appName}`;
+    const createRepo = await this.runner.run("aws", [
+      "ecr",
+      "create-repository",
+      "--repository-name",
+      repoName,
+      "--region",
+      region,
+      "--image-scanning-configuration",
+      "scanOnPush=true"
+    ], config.projectRoot);
+    if (createRepo.exitCode !== 0 && !createRepo.stderr.includes("RepositoryAlreadyExistsException")) {
+      throw new Error(`Failed to create ECR repository: ${createRepo.stderr}`);
+    }
+    const identity = await this.runner.run("aws", ["sts", "get-caller-identity", "--query", "Account", "--output", "text"], config.projectRoot);
+    const accountId = identity.stdout.trim();
+    await this.runner.run("aws", [
+      "ecs",
+      "create-cluster",
+      "--cluster-name",
+      config.appName,
+      "--region",
+      region
+    ], config.projectRoot);
+    await this.runner.run("aws", [
+      "logs",
+      "create-log-group",
+      "--log-group-name",
+      `/ecs/${config.appName}`,
+      "--region",
+      region
+    ], config.projectRoot);
+    return {
+      applicationId: `${accountId}.dkr.ecr.${region}.amazonaws.com/${repoName}`,
+      databaseId: null,
+      secretsSet: ["PORT"]
+    };
+  }
+  async build(config) {
+    this.currentContext = {
+      projectRoot: config.projectRoot,
+      appName: config.appName,
+      region: config.region
+    };
+    const deployDirectory = join7(config.projectRoot, ".kora", "deploy");
+    await bundleServer({
+      projectRoot: config.projectRoot,
+      deployDirectory
+    });
+    const client = await buildClient({
+      projectRoot: config.projectRoot,
+      outDir: join7(deployDirectory, "dist"),
+      mode: "production"
+    });
+    return {
+      clientDirectory: client.outDir,
+      serverBundlePath: join7(deployDirectory, "server-bundled.js"),
+      deployDirectory
+    };
+  }
+  async deploy(artifacts) {
+    const context = this.requireContext();
+    const region = context.region ?? "us-east-1";
+    const repoName = `kora/${context.appName}`;
+    const loginPassword = await this.runner.run("aws", [
+      "ecr",
+      "get-login-password",
+      "--region",
+      region
+    ], context.projectRoot);
+    if (loginPassword.exitCode !== 0) {
+      throw new Error(`ECR login failed: ${loginPassword.stderr}`);
+    }
+    const identity = await this.runner.run("aws", [
+      "sts",
+      "get-caller-identity",
+      "--query",
+      "Account",
+      "--output",
+      "text"
+    ], context.projectRoot);
+    const accountId = identity.stdout.trim();
+    const ecrUri = `${accountId}.dkr.ecr.${region}.amazonaws.com`;
+    const imageUri = `${ecrUri}/${repoName}:latest`;
+    const dockerLogin = await this.runner.run("docker", [
+      "login",
+      "--username",
+      "AWS",
+      "--password-stdin",
+      ecrUri
+    ], artifacts.deployDirectory);
+    this.logger.step("Building Docker image...");
+    const dockerBuild = await this.runner.run("docker", [
+      "build",
+      "--platform",
+      "linux/amd64",
+      "-t",
+      imageUri,
+      "."
+    ], artifacts.deployDirectory);
+    if (dockerBuild.exitCode !== 0) {
+      throw new Error(`Docker build failed: ${dockerBuild.stderr}`);
+    }
+    this.logger.step("Pushing image to ECR...");
+    const dockerPush = await this.runner.run("docker", [
+      "push",
+      imageUri
+    ], artifacts.deployDirectory);
+    if (dockerPush.exitCode !== 0) {
+      throw new Error(`Docker push failed: ${dockerPush.stderr}`);
+    }
+    const taskDef = JSON.stringify({
+      family: context.appName,
+      networkMode: "awsvpc",
+      requiresCompatibilities: ["FARGATE"],
+      cpu: "256",
+      memory: "512",
+      executionRoleArn: `arn:aws:iam::${accountId}:role/ecsTaskExecutionRole`,
+      containerDefinitions: [{
+        name: context.appName,
+        image: imageUri,
+        essential: true,
+        portMappings: [{ containerPort: 3001, protocol: "tcp" }],
+        logConfiguration: {
+          logDriver: "awslogs",
+          options: {
+            "awslogs-group": `/ecs/${context.appName}`,
+            "awslogs-region": region,
+            "awslogs-stream-prefix": "ecs"
+          }
+        },
+        healthCheck: {
+          command: ["CMD-SHELL", "curl -f http://localhost:3001/health || exit 1"],
+          interval: 30,
+          timeout: 5,
+          retries: 3,
+          startPeriod: 60
+        }
+      }]
+    });
+    const registerTask = await this.runner.run("aws", [
+      "ecs",
+      "register-task-definition",
+      "--cli-input-json",
+      taskDef,
+      "--region",
+      region
+    ], context.projectRoot);
+    if (registerTask.exitCode !== 0) {
+      throw new Error(`Task definition registration failed: ${registerTask.stderr}`);
+    }
+    const updateService = await this.runner.run("aws", [
+      "ecs",
+      "update-service",
+      "--cluster",
+      context.appName,
+      "--service",
+      context.appName,
+      "--task-definition",
+      context.appName,
+      "--force-new-deployment",
+      "--region",
+      region
+    ], context.projectRoot);
+    const deploymentId = (/* @__PURE__ */ new Date()).toISOString();
+    if (updateService.exitCode !== 0) {
+      this.logger.step("Service not found, creating new service...");
+      this.logger.step(
+        `Task definition registered. Create the ECS service with:
+  aws ecs create-service \\
+    --cluster ${context.appName} \\
+    --service-name ${context.appName} \\
+    --task-definition ${context.appName} \\
+    --desired-count 1 \\
+    --launch-type FARGATE \\
+    --network-configuration "awsvpcConfiguration={subnets=[<subnet-id>],securityGroups=[<sg-id>],assignPublicIp=ENABLED}" \\
+    --region ${region}`
+      );
+    }
+    return {
+      deploymentId,
+      liveUrl: `https://${context.appName}.${region}.amazonaws.com`,
+      syncUrl: `wss://${context.appName}.${region}.amazonaws.com/kora-sync`
+    };
+  }
+  async rollback(deploymentId) {
+    const context = this.requireContext();
+    const region = context.region ?? "us-east-1";
+    const result = await this.runner.run("aws", [
+      "ecs",
+      "update-service",
+      "--cluster",
+      context.appName,
+      "--service",
+      context.appName,
+      "--task-definition",
+      `${context.appName}:${deploymentId}`,
+      "--force-new-deployment",
+      "--region",
+      region
+    ], context.projectRoot);
+    if (result.exitCode !== 0) {
+      throw new Error(`ECS rollback failed: ${result.stderr}`);
+    }
+  }
+  async *logs(options) {
+    const context = this.requireContext();
+    const region = context.region ?? "us-east-1";
+    const args = [
+      "logs",
+      "get-log-events",
+      "--log-group-name",
+      `/ecs/${context.appName}`,
+      "--log-stream-name",
+      "ecs/latest",
+      "--region",
+      region
+    ];
+    if (options.tail) {
+      args.push("--limit", String(options.tail));
+    }
+    const result = await this.runner.run("aws", args, context.projectRoot);
+    if (result.exitCode !== 0) {
+      return;
+    }
+    try {
+      const parsed = JSON.parse(result.stdout);
+      for (const event of parsed.events ?? []) {
+        yield {
+          timestamp: new Date(event.timestamp).toISOString(),
+          level: inferLogLevel3(event.message),
+          message: event.message
+        };
+      }
+    } catch {
+      for (const line of result.stdout.split("\n").filter(Boolean)) {
+        yield { timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "info", message: line };
+      }
+    }
+  }
+  async status() {
+    const context = this.requireContext();
+    const region = context.region ?? "us-east-1";
+    const result = await this.runner.run("aws", [
+      "ecs",
+      "describe-services",
+      "--cluster",
+      context.appName,
+      "--services",
+      context.appName,
+      "--region",
+      region
+    ], context.projectRoot);
+    if (result.exitCode !== 0) {
+      return { state: "failed", message: result.stderr };
+    }
+    try {
+      const parsed = JSON.parse(result.stdout);
+      const service = parsed.services?.[0];
+      if (!service) {
+        return { state: "unknown", message: "Service not found" };
+      }
+      if (service.status === "ACTIVE" && service.runningCount > 0) {
+        return {
+          state: "healthy",
+          message: `Running ${service.runningCount}/${service.desiredCount} tasks`
+        };
+      }
+      return {
+        state: service.runningCount === 0 ? "pending" : "healthy",
+        message: `Status: ${service.status}, running: ${service.runningCount}/${service.desiredCount}`
+      };
+    } catch {
+      return { state: "unknown", message: "Could not parse service status" };
+    }
+  }
+  requireContext() {
+    if (!this.currentContext) {
+      throw new Error("AWS ECS adapter context is not initialized. Run provision() first.");
+    }
+    return this.currentContext;
+  }
+};
+var NodeAwsCommandRunner = class {
+  async run(command, args, cwd) {
+    return new Promise((resolve2) => {
+      const child = spawn4(command, args, {
+        cwd,
+        env: process.env,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString("utf-8");
+      });
+      child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString("utf-8");
+      });
+      child.on("error", (error) => {
+        resolve2({ exitCode: 1, stdout, stderr: `${stderr}
+${error.message}` });
+      });
+      child.on("exit", (code) => {
+        resolve2({ exitCode: code ?? 1, stdout: stdout.trim(), stderr: stderr.trim() });
+      });
+    });
+  }
+};
+function inferLogLevel3(line) {
+  const normalized = line.toLowerCase();
+  if (normalized.includes("error")) return "error";
+  if (normalized.includes("warn")) return "warn";
+  if (normalized.includes("debug")) return "debug";
+  return "info";
+}
+
+// src/commands/deploy/adapters/aws-lightsail-adapter.ts
+import { spawn as spawn5 } from "child_process";
+import { join as join8 } from "path";
+var AwsLightsailAdapter = class {
+  name = "aws-lightsail";
+  logger = createLogger();
+  runner;
+  currentContext;
+  constructor(options = {}) {
+    this.runner = options.runner ?? new NodeAwsLightsailCommandRunner();
+    this.currentContext = options.context ?? null;
+  }
+  setContext(context) {
+    this.currentContext = context;
+  }
+  async detect() {
+    const result = await this.runner.run("aws", ["--version"], process.cwd());
+    return result.exitCode === 0;
+  }
+  async install() {
+    const available = await this.detect();
+    if (!available) {
+      throw new Error(
+        "AWS CLI is required but not installed. Install from https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html"
+      );
+    }
+  }
+  async authenticate() {
+    const cwd = this.currentContext?.projectRoot ?? process.cwd();
+    const result = await this.runner.run("aws", ["sts", "get-caller-identity"], cwd);
+    if (result.exitCode !== 0) {
+      throw new Error(
+        "AWS CLI is not authenticated. Run `aws configure` or set AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY environment variables."
+      );
+    }
+  }
+  async provision(config) {
+    this.currentContext = {
+      projectRoot: config.projectRoot,
+      appName: config.appName,
+      region: config.region ?? "us-east-1"
+    };
+    const region = config.region ?? "us-east-1";
+    const serviceName = sanitizeLightsailName(config.appName);
+    const createService = await this.runner.run("aws", [
+      "lightsail",
+      "create-container-service",
+      "--service-name",
+      serviceName,
+      "--power",
+      "nano",
+      "--scale",
+      "1",
+      "--region",
+      region
+    ], config.projectRoot);
+    if (createService.exitCode !== 0 && !createService.stderr.includes("already exists")) {
+      throw new Error(`Failed to create Lightsail container service: ${createService.stderr}`);
+    }
+    return {
+      applicationId: serviceName,
+      databaseId: null,
+      secretsSet: ["PORT"]
+    };
+  }
+  async build(config) {
+    this.currentContext = {
+      projectRoot: config.projectRoot,
+      appName: config.appName,
+      region: config.region
+    };
+    const deployDirectory = join8(config.projectRoot, ".kora", "deploy");
+    await bundleServer({
+      projectRoot: config.projectRoot,
+      deployDirectory
+    });
+    const client = await buildClient({
+      projectRoot: config.projectRoot,
+      outDir: join8(deployDirectory, "dist"),
+      mode: "production"
+    });
+    return {
+      clientDirectory: client.outDir,
+      serverBundlePath: join8(deployDirectory, "server-bundled.js"),
+      deployDirectory
+    };
+  }
+  async deploy(artifacts) {
+    const context = this.requireContext();
+    const region = context.region ?? "us-east-1";
+    const serviceName = sanitizeLightsailName(context.appName);
+    const imageTag = `${serviceName}:latest`;
+    this.logger.step("Building Docker image...");
+    const dockerBuild = await this.runner.run("docker", [
+      "build",
+      "--platform",
+      "linux/amd64",
+      "-t",
+      imageTag,
+      "."
+    ], artifacts.deployDirectory);
+    if (dockerBuild.exitCode !== 0) {
+      throw new Error(`Docker build failed: ${dockerBuild.stderr}`);
+    }
+    this.logger.step("Pushing image to Lightsail...");
+    const pushImage = await this.runner.run("aws", [
+      "lightsail",
+      "push-container-image",
+      "--service-name",
+      serviceName,
+      "--label",
+      "latest",
+      "--image",
+      imageTag,
+      "--region",
+      region
+    ], artifacts.deployDirectory);
+    if (pushImage.exitCode !== 0) {
+      throw new Error(`Lightsail image push failed: ${pushImage.stderr}`);
+    }
+    const lightsailImage = parseLightsailImageRef(pushImage.stdout) ?? `:${serviceName}.latest.1`;
+    this.logger.step("Creating Lightsail deployment...");
+    const environment = { PORT: "3001" };
+    for (const key of PASSTHROUGH_ENV_VARS) {
+      const value = process.env[key];
+      if (value) {
+        environment[key] = value;
+      }
+    }
+    const containers = JSON.stringify({
+      [serviceName]: {
+        image: lightsailImage,
+        ports: { "3001": "HTTP" },
+        environment
+      }
+    });
+    const publicEndpoint = JSON.stringify({
+      containerName: serviceName,
+      containerPort: 3001,
+      healthCheck: {
+        path: "/health",
+        intervalSeconds: 30,
+        timeoutSeconds: 5,
+        healthyThreshold: 2,
+        unhealthyThreshold: 3
+      }
+    });
+    const createDeploy = await this.runner.run("aws", [
+      "lightsail",
+      "create-container-service-deployment",
+      "--service-name",
+      serviceName,
+      "--containers",
+      containers,
+      "--public-endpoint",
+      publicEndpoint,
+      "--region",
+      region
+    ], context.projectRoot);
+    if (createDeploy.exitCode !== 0) {
+      throw new Error(`Lightsail deployment failed: ${createDeploy.stderr}`);
+    }
+    const serviceInfo = await this.runner.run("aws", [
+      "lightsail",
+      "get-container-services",
+      "--service-name",
+      serviceName,
+      "--region",
+      region
+    ], context.projectRoot);
+    const rawUrl = parseLightsailUrl(serviceInfo.stdout) ?? `https://${serviceName}.${region}.cs.amazonlightsail.com`;
+    const serviceUrl = rawUrl.replace(/\/+$/, "");
+    const deploymentId = (/* @__PURE__ */ new Date()).toISOString();
+    return {
+      deploymentId,
+      liveUrl: serviceUrl,
+      syncUrl: `${serviceUrl.replace("https://", "wss://")}/kora-sync`
+    };
+  }
+  async rollback(_deploymentId) {
+    const context = this.requireContext();
+    const region = context.region ?? "us-east-1";
+    const serviceName = sanitizeLightsailName(context.appName);
+    const deployments = await this.runner.run("aws", [
+      "lightsail",
+      "get-container-service-deployments",
+      "--service-name",
+      serviceName,
+      "--region",
+      region
+    ], context.projectRoot);
+    if (deployments.exitCode !== 0) {
+      throw new Error(`Lightsail rollback failed: ${deployments.stderr}`);
+    }
+    const previousDeployment = parsePreviousDeployment(deployments.stdout, serviceName);
+    if (!previousDeployment) {
+      throw new Error("No previous deployment found to rollback to.");
+    }
+    const redeploy = await this.runner.run("aws", [
+      "lightsail",
+      "create-container-service-deployment",
+      "--service-name",
+      serviceName,
+      "--containers",
+      JSON.stringify(previousDeployment.containers),
+      "--public-endpoint",
+      JSON.stringify(previousDeployment.publicEndpoint),
+      "--region",
+      region
+    ], context.projectRoot);
+    if (redeploy.exitCode !== 0) {
+      throw new Error(`Lightsail rollback deployment failed: ${redeploy.stderr}`);
+    }
+  }
+  async *logs(options) {
+    const context = this.requireContext();
+    const region = context.region ?? "us-east-1";
+    const serviceName = sanitizeLightsailName(context.appName);
+    const args = [
+      "lightsail",
+      "get-container-log",
+      "--service-name",
+      serviceName,
+      "--container-name",
+      serviceName,
+      "--region",
+      region
+    ];
+    if (options.since) {
+      args.push("--start-time", options.since);
+    }
+    const result = await this.runner.run("aws", args, context.projectRoot);
+    if (result.exitCode !== 0) {
+      return;
+    }
+    try {
+      const parsed = JSON.parse(result.stdout);
+      const events = parsed.logEvents ?? [];
+      const limited = options.tail ? events.slice(-options.tail) : events;
+      for (const event of limited) {
+        yield {
+          timestamp: event.createdAt,
+          level: inferLogLevel4(event.message),
+          message: event.message
+        };
+      }
+    } catch {
+      for (const line of result.stdout.split("\n").filter(Boolean)) {
+        yield { timestamp: (/* @__PURE__ */ new Date()).toISOString(), level: "info", message: line };
+      }
+    }
+  }
+  async status() {
+    const context = this.requireContext();
+    const region = context.region ?? "us-east-1";
+    const serviceName = sanitizeLightsailName(context.appName);
+    const result = await this.runner.run("aws", [
+      "lightsail",
+      "get-container-services",
+      "--service-name",
+      serviceName,
+      "--region",
+      region
+    ], context.projectRoot);
+    if (result.exitCode !== 0) {
+      return { state: "failed", message: result.stderr };
+    }
+    try {
+      const parsed = JSON.parse(result.stdout);
+      const service = parsed.containerServices?.[0];
+      if (!service) {
+        return { state: "unknown", message: "Container service not found" };
+      }
+      const deployState = service.currentDeployment?.state ?? "UNKNOWN";
+      if (service.state === "RUNNING" && deployState === "ACTIVE") {
+        return {
+          state: "healthy",
+          message: "Lightsail container service is running",
+          liveUrl: service.url
+        };
+      }
+      if (service.state === "DEPLOYING" || deployState === "ACTIVATING") {
+        return {
+          state: "pending",
+          message: `Service: ${service.state}, Deployment: ${deployState}`
+        };
+      }
+      return {
+        state: service.state === "DISABLED" ? "failed" : "unknown",
+        message: `Service: ${service.state}, Deployment: ${deployState}`
+      };
+    } catch {
+      return { state: "unknown", message: "Could not parse service status" };
+    }
+  }
+  requireContext() {
+    if (!this.currentContext) {
+      throw new Error("AWS Lightsail adapter context is not initialized. Run provision() first.");
+    }
+    return this.currentContext;
+  }
+};
+var NodeAwsLightsailCommandRunner = class {
+  async run(command, args, cwd) {
+    return new Promise((resolve2) => {
+      const child = spawn5(command, args, {
+        cwd,
+        env: process.env,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString("utf-8");
+      });
+      child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString("utf-8");
+      });
+      child.on("error", (error) => {
+        resolve2({ exitCode: 1, stdout, stderr: `${stderr}
+${error.message}` });
+      });
+      child.on("exit", (code) => {
+        resolve2({ exitCode: code ?? 1, stdout: stdout.trim(), stderr: stderr.trim() });
+      });
+    });
+  }
+};
+var PASSTHROUGH_ENV_VARS = [
+  "DATABASE_URL",
+  "AUTH_SECRET",
+  "PUBLIC_URL",
+  "NODE_ENV"
+];
+function sanitizeLightsailName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-{2,}/g, "-").replace(/^-|-$/g, "").slice(0, 255) || "kora-app";
+}
+function parseLightsailImageRef(output) {
+  const match = output.match(/Refer to this image as\s+"?(:[^"\s]+)"?/i);
+  if (match?.[1]) {
+    return match[1];
+  }
+  const refMatch = output.match(/(:\S+\.\S+\.\d+)/);
+  return refMatch?.[1] ?? null;
+}
+function parseLightsailUrl(rawJson) {
+  try {
+    const parsed = JSON.parse(rawJson);
+    const url = parsed.containerServices?.[0]?.url;
+    if (typeof url === "string" && url.length > 0) {
+      return url.startsWith("https://") ? url : `https://${url}`;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function parsePreviousDeployment(rawJson, serviceName) {
+  try {
+    const parsed = JSON.parse(rawJson);
+    const deployments = parsed.deployments ?? [];
+    const previous = deployments.length > 1 ? deployments[1] : null;
+    if (!previous) return null;
+    return {
+      containers: previous.containers,
+      publicEndpoint: previous.publicEndpoint
+    };
+  } catch {
+    return null;
+  }
+}
+function inferLogLevel4(line) {
+  const normalized = line.toLowerCase();
+  if (normalized.includes("error")) return "error";
+  if (normalized.includes("warn")) return "warn";
+  if (normalized.includes("debug")) return "debug";
+  return "info";
+}
+
 // src/commands/deploy/adapters/factory.ts
 function createDeployAdapter(platform) {
   switch (platform) {
@@ -903,6 +1642,10 @@ function createDeployAdapter(platform) {
       return new FlyAdapter();
     case "railway":
       return new RailwayAdapter();
+    case "aws-ecs":
+      return new AwsEcsAdapter();
+    case "aws-lightsail":
+      return new AwsLightsailAdapter();
     case "render":
     case "docker":
     case "kora-cloud":
@@ -916,7 +1659,7 @@ function createDeployAdapter(platform) {
 
 // src/commands/deploy/artifacts/dockerfile-generator.ts
 import { mkdir as mkdir4, writeFile as writeFile3 } from "fs/promises";
-import { join as join7 } from "path";
+import { join as join9 } from "path";
 var GENERATED_HEADER3 = "# Generated by kora deploy \u2014 do not edit manually";
 function generateDockerfile(options = {}) {
   const nodeVersion = options.nodeVersion ?? "20-alpine";
@@ -980,31 +1723,31 @@ function generateDockerIgnore() {
 }
 async function writeDockerfileArtifact(deployDirectory, options = {}) {
   await mkdir4(deployDirectory, { recursive: true });
-  const dockerfilePath = join7(deployDirectory, "Dockerfile");
+  const dockerfilePath = join9(deployDirectory, "Dockerfile");
   await writeFile3(dockerfilePath, generateDockerfile(options), "utf-8");
   if (options.nativeDependencies && Object.keys(options.nativeDependencies).length > 0) {
-    const pkgJsonPath = join7(deployDirectory, "package.json");
+    const pkgJsonPath = join9(deployDirectory, "package.json");
     await writeFile3(pkgJsonPath, generateDeployPackageJson(options.nativeDependencies), "utf-8");
   }
   return dockerfilePath;
 }
 async function writeDockerIgnoreArtifact(deployDirectory) {
   await mkdir4(deployDirectory, { recursive: true });
-  const dockerIgnorePath = join7(deployDirectory, ".dockerignore");
+  const dockerIgnorePath = join9(deployDirectory, ".dockerignore");
   await writeFile3(dockerIgnorePath, generateDockerIgnore(), "utf-8");
   return dockerIgnorePath;
 }
 
 // src/commands/deploy/state/deploy-state.ts
 import { mkdir as mkdir5, readFile, rm, writeFile as writeFile4 } from "fs/promises";
-import { join as join8 } from "path";
-var KORA_DEPLOY_DIRECTORY = join8(".kora", "deploy");
+import { join as join10 } from "path";
+var KORA_DEPLOY_DIRECTORY = join10(".kora", "deploy");
 var DEPLOY_STATE_FILENAME = "deploy.json";
 function resolveDeployDirectory(projectRoot) {
-  return join8(projectRoot, KORA_DEPLOY_DIRECTORY);
+  return join10(projectRoot, KORA_DEPLOY_DIRECTORY);
 }
 function resolveDeployStatePath(projectRoot) {
-  return join8(resolveDeployDirectory(projectRoot), DEPLOY_STATE_FILENAME);
+  return join10(resolveDeployDirectory(projectRoot), DEPLOY_STATE_FILENAME);
 }
 async function readDeployState(projectRoot) {
   const statePath = resolveDeployStatePath(projectRoot);
@@ -1290,7 +2033,8 @@ var deployCommand = defineCommand({
     await writeDockerfileArtifact(deployDirectory, {
       nativeDependencies: {
         "better-sqlite3": "^11.0.0",
-        "drizzle-orm": "^0.45.2"
+        "drizzle-orm": "^0.45.2",
+        "postgres": "^3.4.0"
       }
     });
     await writeDockerIgnoreArtifact(deployDirectory);
@@ -1357,6 +2101,14 @@ async function resolvePlatform(options) {
       label: "Railway",
       value: "railway"
     },
+    {
+      label: "AWS ECS Fargate (production multi-instance)",
+      value: "aws-ecs"
+    },
+    {
+      label: "AWS Lightsail Containers (simple, cost-effective)",
+      value: "aws-lightsail"
+    },
     {
       label: "Render",
       value: "render"
@@ -1521,10 +2273,10 @@ function toPascalCase(name) {
 export {
   DEPLOY_PLATFORMS,
   isDeployPlatform,
-  generateFlyToml,
-  writeFlyTomlArtifact,
   buildClient,
   bundleServer,
+  generateFlyToml,
+  writeFlyTomlArtifact,
   FlyAdapter,
   NodeFlyCommandRunner,
   generateRailwayJson,
@@ -1547,4 +2299,4 @@ export {
   deployCommand,
   generateTypes
 };
-//# sourceMappingURL=chunk-E4JG7THU.js.map
+//# sourceMappingURL=chunk-E7OCVRYL.js.map