@gravito/launchpad 1.0.0-beta.1 → 1.0.0

package/dist/index.mjs

@@ -0,0 +1,785 @@
+// src/index.ts
+import { PlanetCore, ServiceProvider } from "@gravito/core";
+import { OrbitRipple } from "@gravito/ripple";
+import { OrbitCache } from "@gravito/stasis";
+
+// src/Application/MissionControl.ts
+var MissionControl = class {
+  constructor(poolManager, injector, docker, router) {
+    this.poolManager = poolManager;
+    this.injector = injector;
+    this.docker = docker;
+    this.router = router;
+  }
+  async launch(mission, onTelemetry) {
+    console.log(`[MissionControl] \u6E96\u5099\u767C\u5C04\u4EFB\u52D9: ${mission.id}`);
+    const rocket = await this.poolManager.assignMission(mission);
+    await this.injector.deploy(rocket);
+    const publicPort = await this.docker.getExposedPort(rocket.containerId, 3e3);
+    console.log(`[MissionControl] \u4EFB\u52D9 ${mission.id} \u6620\u5C04\u7AEF\u53E3: ${publicPort}`);
+    const domain = `${mission.id}.dev.local`.toLowerCase();
+    rocket.assignDomain(domain);
+    if (this.router) {
+      this.router.register(domain, `http://localhost:${publicPort}`);
+    }
+    this.docker.streamLogs(rocket.containerId, (log) => {
+      onTelemetry("log", { rocketId: rocket.id, text: log });
+    });
+    const statsTimer = setInterval(async () => {
+      if (rocket.status === "DECOMMISSIONED" || rocket.status === "IDLE") {
+        clearInterval(statsTimer);
+        return;
+      }
+      const stats = await this.docker.getStats(rocket.containerId);
+      onTelemetry("stats", { rocketId: rocket.id, ...stats });
+    }, 5e3);
+    const ttl = 10 * 60 * 1e3;
+    setTimeout(async () => {
+      console.log(`[MissionControl] \u4EFB\u52D9 ${mission.id} TTL \u5DF2\u5230\u671F\uFF0C\u57F7\u884C\u81EA\u52D5\u56DE\u6536...`);
+      clearInterval(statsTimer);
+      await this.poolManager.recycle(mission.id);
+      onTelemetry("log", { rocketId: rocket.id, text: "--- MISSION EXPIRED (TTL) ---" });
+    }, ttl);
+    return rocket.id;
+  }
+};
+
+// src/Application/PayloadInjector.ts
+var PayloadInjector = class {
+  constructor(docker, git) {
+    this.docker = docker;
+    this.git = git;
+  }
+  async deploy(rocket) {
+    if (!rocket.currentMission) {
+      throw new Error(`Rocket ${rocket.id} \u6C92\u6709\u6307\u6D3E\u4EFB\u52D9\uFF0C\u7121\u6CD5\u90E8\u7F72`);
+    }
+    const { repoUrl, branch } = rocket.currentMission;
+    const containerId = rocket.containerId;
+    console.log(`[PayloadInjector] \u6B63\u5728\u62C9\u53D6\u4EE3\u78BC: ${repoUrl} (${branch})`);
+    const codePath = await this.git.clone(repoUrl, branch);
+    console.log(`[PayloadInjector] \u6B63\u5728\u6CE8\u5165\u8F09\u8377\u81F3\u5BB9\u5668: ${containerId}`);
+    await this.docker.copyFiles(containerId, codePath, "/app");
+    console.log(`[PayloadInjector] \u6B63\u5728\u5B89\u88DD\u4F9D\u8CF4...`);
+    const registry = process.env.LAUNCHPAD_NPM_REGISTRY || process.env.NPM_CONFIG_REGISTRY || "";
+    const baseInstallConfig = ["[install]", "frozenLockfile = false"];
+    const bunfigContent = registry ? `${baseInstallConfig.join("\n")}
+registry = "${registry}"
+` : `${baseInstallConfig.join("\n")}
+`;
+    await this.docker.executeCommand(containerId, [
+      "sh",
+      "-c",
+      `echo "${bunfigContent}" > /app/bunfig.toml`
+    ]);
+    await this.docker.executeCommand(containerId, ["rm", "-f", "/app/bun.lockb"]);
+    let installRes = await this.docker.executeCommand(containerId, [
+      "bun",
+      "install",
+      "--cwd",
+      "/app",
+      "--no-save",
+      "--ignore-scripts"
+    ]);
+    if (installRes.exitCode !== 0 && !registry) {
+      const fallbackRegistry = "https://registry.npmmirror.com";
+      const fallbackBunfig = `${baseInstallConfig.join("\n")}
+registry = "${fallbackRegistry}"
+`;
+      await this.docker.executeCommand(containerId, [
+        "sh",
+        "-c",
+        `echo "${fallbackBunfig}" > /app/bunfig.toml`
+      ]);
+      installRes = await this.docker.executeCommand(containerId, [
+        "bun",
+        "install",
+        "--cwd",
+        "/app",
+        "--no-save",
+        "--ignore-scripts"
+      ]);
+    }
+    if (installRes.exitCode !== 0) {
+      throw new Error(`\u5B89\u88DD\u4F9D\u8CF4\u5931\u6557: ${installRes.stderr}`);
+    }
+    console.log(`[PayloadInjector] \u9EDE\u706B\uFF01`);
+    this.docker.executeCommand(containerId, ["bun", "run", "/app/examples/demo.ts"]).catch((e) => {
+      console.error(`[PayloadInjector] \u904B\u884C\u7570\u5E38:`, e);
+    });
+    rocket.ignite();
+  }
+};
+
+// src/Domain/Rocket.ts
+import { AggregateRoot } from "@gravito/enterprise";
+
+// src/Domain/Events.ts
+import { DomainEvent } from "@gravito/enterprise";
+var MissionAssigned = class extends DomainEvent {
+  constructor(rocketId, missionId) {
+    super();
+    this.rocketId = rocketId;
+    this.missionId = missionId;
+  }
+};
+var RocketIgnited = class extends DomainEvent {
+  constructor(rocketId) {
+    super();
+    this.rocketId = rocketId;
+  }
+};
+var RocketSplashedDown = class extends DomainEvent {
+  constructor(rocketId) {
+    super();
+    this.rocketId = rocketId;
+  }
+};
+var RefurbishmentCompleted = class extends DomainEvent {
+  constructor(rocketId) {
+    super();
+    this.rocketId = rocketId;
+  }
+};
+
+// src/Domain/RocketStatus.ts
+var RocketStatus = /* @__PURE__ */ ((RocketStatus2) => {
+  RocketStatus2["IDLE"] = "IDLE";
+  RocketStatus2["PREPARING"] = "PREPARING";
+  RocketStatus2["ORBITING"] = "ORBITING";
+  RocketStatus2["REFURBISHING"] = "REFURBISHING";
+  RocketStatus2["DECOMMISSIONED"] = "DECOMMISSIONED";
+  return RocketStatus2;
+})(RocketStatus || {});
+
+// src/Domain/Rocket.ts
+var Rocket = class _Rocket extends AggregateRoot {
+  _status = "IDLE" /* IDLE */;
+  _currentMission = null;
+  _containerId;
+  _assignedDomain = null;
+  constructor(id, containerId) {
+    super(id);
+    this._containerId = containerId;
+  }
+  get status() {
+    return this._status;
+  }
+  get currentMission() {
+    return this._currentMission;
+  }
+  get containerId() {
+    return this._containerId;
+  }
+  get assignedDomain() {
+    return this._assignedDomain;
+  }
+  /**
+   * 分配域名
+   */
+  assignDomain(domain) {
+    this._assignedDomain = domain;
+  }
+  /**
+   * 分配任務 (指派任務給 IDLE 的火箭)
+   */
+  assignMission(mission) {
+    if (this._status !== "IDLE" /* IDLE */) {
+      throw new Error(`\u7121\u6CD5\u6307\u6D3E\u4EFB\u52D9\uFF1A\u706B\u7BAD ${this.id} \u72C0\u614B\u70BA ${this._status}\uFF0C\u975E IDLE`);
+    }
+    this._status = "PREPARING" /* PREPARING */;
+    this._currentMission = mission;
+    this.addDomainEvent(new MissionAssigned(this.id, mission.id));
+  }
+  /**
+   * 點火啟動 (應用程式啟動成功)
+   */
+  ignite() {
+    if (this._status !== "PREPARING" /* PREPARING */) {
+      throw new Error(`\u7121\u6CD5\u9EDE\u706B\uFF1A\u706B\u7BAD ${this.id} \u5C1A\u672A\u9032\u5165 PREPARING \u72C0\u614B`);
+    }
+    this._status = "ORBITING" /* ORBITING */;
+    this.addDomainEvent(new RocketIgnited(this.id));
+  }
+  /**
+   * 任務降落 (PR 合併或關閉，暫停服務)
+   */
+  splashDown() {
+    if (this._status !== "ORBITING" /* ORBITING */) {
+      throw new Error(`\u7121\u6CD5\u964D\u843D\uFF1A\u706B\u7BAD ${this.id} \u4E0D\u5728\u904B\u884C\u8ECC\u9053\u4E0A`);
+    }
+    this._status = "REFURBISHING" /* REFURBISHING */;
+    this.addDomainEvent(new RocketSplashedDown(this.id));
+  }
+  /**
+   * 翻新完成 (清理完畢，回歸池中)
+   */
+  finishRefurbishment() {
+    if (this._status !== "REFURBISHING" /* REFURBISHING */) {
+      throw new Error(`\u7121\u6CD5\u5B8C\u6210\u7FFB\u65B0\uFF1A\u706B\u7BAD ${this.id} \u4E0D\u5728 REFURBISHING \u72C0\u614B`);
+    }
+    this._status = "IDLE" /* IDLE */;
+    this._currentMission = null;
+    this.addDomainEvent(new RefurbishmentCompleted(this.id));
+  }
+  /**
+   * 火箭除役 (移除容器)
+   */
+  decommission() {
+    this._status = "DECOMMISSIONED" /* DECOMMISSIONED */;
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      containerId: this.containerId,
+      status: this._status,
+      currentMission: this._currentMission,
+      assignedDomain: this._assignedDomain
+    };
+  }
+  static fromJSON(data) {
+    const rocket = new _Rocket(data.id, data.containerId);
+    rocket._status = data.status;
+    rocket._currentMission = data.currentMission;
+    rocket._assignedDomain = data.assignedDomain;
+    return rocket;
+  }
+};
+
+// src/Application/PoolManager.ts
+var PoolManager = class {
+  constructor(dockerAdapter, rocketRepository, refurbishUnit, router) {
+    this.dockerAdapter = dockerAdapter;
+    this.rocketRepository = rocketRepository;
+    this.refurbishUnit = refurbishUnit;
+    this.router = router;
+  }
+  /**
+   * 初始化發射場：預先準備指定數量的火箭
+   */
+  async warmup(count) {
+    const currentRockets = await this.rocketRepository.findAll();
+    const needed = count - currentRockets.length;
+    if (needed <= 0) {
+      return;
+    }
+    console.log(`[LaunchPad] \u6B63\u5728\u71B1\u6A5F\uFF0C\u6E96\u5099\u767C\u5C04 ${needed} \u67B6\u65B0\u706B\u7BAD...`);
+    for (let i = 0; i < needed; i++) {
+      const containerId = await this.dockerAdapter.createBaseContainer();
+      const rocketId = `rocket-${Math.random().toString(36).substring(2, 9)}`;
+      const rocket = new Rocket(rocketId, containerId);
+      await this.rocketRepository.save(rocket);
+    }
+  }
+  /**
+   * 獲取一架可用的火箭並分配任務
+   */
+  async assignMission(mission) {
+    let rocket = await this.rocketRepository.findIdle();
+    if (!rocket) {
+      console.log(`[LaunchPad] \u8CC7\u6E90\u5403\u7DCA\uFF0C\u6B63\u5728\u7DCA\u6025\u547C\u53EB\u5F8C\u63F4\u706B\u7BAD...`);
+      const containerId = await this.dockerAdapter.createBaseContainer();
+      rocket = new Rocket(`rocket-dynamic-${Date.now()}`, containerId);
+    }
+    rocket.assignMission(mission);
+    await this.rocketRepository.save(rocket);
+    return rocket;
+  }
+  /**
+   * 回收指定任務的火箭
+   */
+  async recycle(missionId) {
+    const allRockets = await this.rocketRepository.findAll();
+    const rocket = allRockets.find((r) => r.currentMission?.id === missionId);
+    if (!rocket) {
+      console.warn(`[LaunchPad] \u627E\u4E0D\u5230\u5C6C\u65BC\u4EFB\u52D9 ${missionId} \u7684\u706B\u7BAD`);
+      return;
+    }
+    if (this.router && rocket.assignedDomain) {
+      this.router.unregister(rocket.assignedDomain);
+    }
+    if (this.refurbishUnit) {
+      await this.refurbishUnit.refurbish(rocket);
+    } else {
+      rocket.splashDown();
+      rocket.finishRefurbishment();
+    }
+    await this.rocketRepository.save(rocket);
+  }
+};
+
+// src/Application/RefurbishUnit.ts
+var RefurbishUnit = class {
+  constructor(docker) {
+    this.docker = docker;
+  }
+  /**
+   * 執行火箭翻新邏輯
+   */
+  async refurbish(rocket) {
+    console.log(`[RefurbishUnit] \u6B63\u5728\u7FFB\u65B0\u706B\u7BAD: ${rocket.id} (\u5BB9\u5668: ${rocket.containerId})`);
+    rocket.splashDown();
+    try {
+      const cleanupCommands = ["sh", "-c", "rm -rf /app/* && pkill -f bun || true && rm -rf /tmp/*"];
+      const result = await this.docker.executeCommand(rocket.containerId, cleanupCommands);
+      if (result.exitCode !== 0) {
+        console.error(`[RefurbishUnit] \u6E05\u7406\u5931\u6557: ${result.stderr}`);
+        rocket.decommission();
+        return;
+      }
+      rocket.finishRefurbishment();
+      console.log(`[RefurbishUnit] \u706B\u7BAD ${rocket.id} \u7FFB\u65B0\u5B8C\u6210\uFF0C\u5DF2\u9032\u5165 IDLE \u72C0\u614B\u3002`);
+    } catch (error) {
+      console.error(`[RefurbishUnit] \u56DE\u6536\u904E\u7A0B\u767C\u751F\u7570\u5E38:`, error);
+      rocket.decommission();
+    }
+  }
+};
+
+// src/Domain/Mission.ts
+import { ValueObject } from "@gravito/enterprise";
+var Mission = class _Mission extends ValueObject {
+  get id() {
+    return this.props.id;
+  }
+  get repoUrl() {
+    return this.props.repoUrl;
+  }
+  get branch() {
+    return this.props.branch;
+  }
+  get commitSha() {
+    return this.props.commitSha;
+  }
+  static create(props) {
+    return new _Mission(props);
+  }
+};
+
+// src/Infrastructure/Docker/DockerAdapter.ts
+import { getRuntimeAdapter } from "@gravito/core";
+var DockerAdapter = class {
+  baseImage = "oven/bun:1.0-slim";
+  runtime = getRuntimeAdapter();
+  async createBaseContainer() {
+    const rocketId = `rocket-${Math.random().toString(36).substring(2, 9)}`;
+    const proc = this.runtime.spawn([
+      "docker",
+      "run",
+      "-d",
+      "--name",
+      rocketId,
+      "--label",
+      "gravito-origin=launchpad",
+      "-p",
+      "3000",
+      // 讓 Docker 分配隨機宿主機埠
+      "-v",
+      `${process.env.HOME}/.bun/install/cache:/root/.bun/install/cache`,
+      "-v",
+      `${process.env.HOME}/.bun/install/cache:/home/bun/.bun/install/cache`,
+      this.baseImage,
+      "tail",
+      "-f",
+      "/dev/null"
+    ]);
+    const stdout = await new Response(proc.stdout ?? null).text();
+    const containerId = stdout.trim();
+    const exitCode = await proc.exited;
+    if (containerId.length === 64 && /^[0-9a-f]+$/.test(containerId)) {
+      return containerId;
+    }
+    if (exitCode !== 0) {
+      const stderr = await new Response(proc.stderr ?? null).text();
+      throw new Error(`Docker \u5BB9\u5668\u5EFA\u7ACB\u5931\u6557: ${stderr || stdout}`);
+    }
+    return containerId;
+  }
+  async getExposedPort(containerId, containerPort = 3e3) {
+    const proc = this.runtime.spawn(["docker", "port", containerId, containerPort.toString()]);
+    const stdout = await new Response(proc.stdout ?? null).text();
+    const firstLine = stdout.split("\n")[0] ?? "";
+    if (!firstLine) {
+      throw new Error(`\u7121\u6CD5\u7372\u53D6\u5BB9\u5668\u6620\u5C04\u7AEF\u53E3: ${stdout}`);
+    }
+    const match = firstLine.match(/:(\d+)$/);
+    if (!match?.[1]) {
+      throw new Error(`\u7121\u6CD5\u7372\u53D6\u5BB9\u5668\u6620\u5C04\u7AEF\u53E3: ${stdout}`);
+    }
+    return Number.parseInt(match[1], 10);
+  }
+  async copyFiles(containerId, sourcePath, targetPath) {
+    const proc = this.runtime.spawn(["docker", "cp", sourcePath, `${containerId}:${targetPath}`]);
+    const exitCode = await proc.exited;
+    if (exitCode && exitCode !== 0) {
+      const stderr = await new Response(proc.stderr ?? null).text();
+      throw new Error(stderr || "Docker copy failed");
+    }
+  }
+  async executeCommand(containerId, command) {
+    const proc = this.runtime.spawn(["docker", "exec", "-u", "0", containerId, ...command]);
+    const stdout = await new Response(proc.stdout ?? null).text();
+    const stderr = await new Response(proc.stderr ?? null).text();
+    const exitCode = await proc.exited;
+    return { stdout, stderr, exitCode };
+  }
+  async removeContainer(containerId) {
+    await this.runtime.spawn(["docker", "rm", "-f", containerId]).exited;
+  }
+  async removeContainerByLabel(label) {
+    const listProc = this.runtime.spawn(["docker", "ps", "-aq", "--filter", `label=${label}`]);
+    const ids = await new Response(listProc.stdout ?? null).text();
+    if (ids.trim()) {
+      const idList = ids.trim().split("\n");
+      await this.runtime.spawn(["docker", "rm", "-f", ...idList]).exited;
+    }
+  }
+  streamLogs(containerId, onData) {
+    const proc = this.runtime.spawn(["docker", "logs", "-f", containerId], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const read = async (stream) => {
+      if (!stream) {
+        return;
+      }
+      const reader = stream.getReader();
+      const decoder = new TextDecoder();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        onData(decoder.decode(value));
+      }
+    };
+    read(proc.stdout);
+    read(proc.stderr);
+  }
+  async getStats(containerId) {
+    const proc = this.runtime.spawn([
+      "docker",
+      "stats",
+      containerId,
+      "--no-stream",
+      "--format",
+      "{{.CPUPerc}},{{.MemUsage}}"
+    ]);
+    const stdout = await new Response(proc.stdout ?? null).text();
+    const [cpu, memory] = stdout.trim().split(",");
+    return { cpu: cpu || "0%", memory: memory || "0B / 0B" };
+  }
+};
+
+// src/Infrastructure/Git/ShellGitAdapter.ts
+import { mkdir } from "fs/promises";
+import { getRuntimeAdapter as getRuntimeAdapter2 } from "@gravito/core";
+var ShellGitAdapter = class {
+  baseDir = "/tmp/gravito-launchpad-git";
+  async clone(repoUrl, branch) {
+    const dirName = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    const targetDir = `${this.baseDir}/${dirName}`;
+    await mkdir(this.baseDir, { recursive: true });
+    const runtime = getRuntimeAdapter2();
+    const proc = runtime.spawn([
+      "git",
+      "clone",
+      "--depth",
+      "1",
+      "--branch",
+      branch,
+      repoUrl,
+      targetDir
+    ]);
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      throw new Error("Git Clone Failed");
+    }
+    return targetDir;
+  }
+};
+
+// src/Infrastructure/GitHub/OctokitGitHubAdapter.ts
+import { createHmac, timingSafeEqual } from "crypto";
+import { Octokit } from "@octokit/rest";
+var OctokitGitHubAdapter = class {
+  octokit;
+  constructor(token) {
+    this.octokit = new Octokit({ auth: token });
+  }
+  verifySignature(payload, signature, secret) {
+    if (!signature) {
+      return false;
+    }
+    const hmac = createHmac("sha256", secret);
+    const digest = Buffer.from(`sha256=${hmac.update(payload).digest("hex")}`, "utf8");
+    const checksum = Buffer.from(signature, "utf8");
+    return digest.length === checksum.length && timingSafeEqual(digest, checksum);
+  }
+  async postComment(repoOwner, repoName, prNumber, comment) {
+    try {
+      await this.octokit.issues.createComment({
+        owner: repoOwner,
+        repo: repoName,
+        issue_number: prNumber,
+        body: comment
+      });
+      console.log(`[GitHub] \u5DF2\u5728 PR #${prNumber} \u7559\u4E0B\u90E8\u7F72\u8CC7\u8A0A`);
+    } catch (error) {
+      console.error(`[GitHub] \u7559\u8A00\u5931\u6557: ${error.message}`);
+    }
+  }
+};
+
+// src/Infrastructure/Persistence/CachedRocketRepository.ts
+var CachedRocketRepository = class {
+  constructor(cache) {
+    this.cache = cache;
+  }
+  CACHE_KEY = "launchpad:rockets";
+  async getMap() {
+    const data = await this.cache.get(this.CACHE_KEY);
+    return new Map(Object.entries(data || {}));
+  }
+  async save(rocket) {
+    const map = await this.getMap();
+    map.set(rocket.id, rocket.toJSON());
+    await this.cache.set(this.CACHE_KEY, Object.fromEntries(map));
+  }
+  async findById(id) {
+    const map = await this.getMap();
+    const data = map.get(id);
+    return data ? Rocket.fromJSON(data) : null;
+  }
+  async findIdle() {
+    const rockets = await this.findAll();
+    return rockets.find((r) => r.status === "IDLE") || null;
+  }
+  async findAll() {
+    const map = await this.getMap();
+    return Array.from(map.values()).map((data) => Rocket.fromJSON(data));
+  }
+  async delete(id) {
+    const map = await this.getMap();
+    map.delete(id);
+    await this.cache.set(this.CACHE_KEY, Object.fromEntries(map));
+  }
+};
+
+// src/Infrastructure/Router/BunProxyAdapter.ts
+import { getRuntimeAdapter as getRuntimeAdapter3 } from "@gravito/core";
+var BunProxyAdapter = class {
+  routes = /* @__PURE__ */ new Map();
+  // domain -> targetUrl
+  register(domain, targetUrl) {
+    console.log(`[Proxy] \u8A3B\u518A\u8DEF\u7531: ${domain} -> ${targetUrl}`);
+    this.routes.set(domain.toLowerCase(), targetUrl);
+  }
+  unregister(domain) {
+    console.log(`[Proxy] \u8A3B\u92B7\u8DEF\u7531: ${domain}`);
+    this.routes.delete(domain.toLowerCase());
+  }
+  start(port) {
+    const self = this;
+    const runtime = getRuntimeAdapter3();
+    runtime.serve({
+      port,
+      async fetch(request) {
+        const host = request.headers.get("host")?.split(":")[0]?.toLowerCase();
+        if (!host || !self.routes.has(host)) {
+          return new Response("Rocket Not Found or Mission Not Started", { status: 404 });
+        }
+        const targetBase = self.routes.get(host);
+        const url = new URL(request.url);
+        const targetUrl = `${targetBase}${url.pathname}${url.search}`;
+        console.log(`[Proxy] \u8F49\u767C: ${host}${url.pathname} -> ${targetUrl}`);
+        try {
+          const proxyReq = new Request(targetUrl, {
+            method: request.method,
+            headers: request.headers,
+            body: request.body,
+            // @ts-expect-error Bun specific
+            duplex: "half"
+          });
+          return await fetch(proxyReq);
+        } catch (error) {
+          console.error(`[Proxy] \u8F49\u767C\u5931\u6557: ${error.message}`);
+          return new Response("Proxy Error", { status: 502 });
+        }
+      }
+    });
+    console.log(`[Proxy] \u52D5\u614B\u8DEF\u7531\u4F3A\u670D\u5668\u5DF2\u555F\u52D5\u65BC Port: ${port}`);
+  }
+};
+
+// src/index.ts
+var LaunchpadServiceProvider = class extends ServiceProvider {
+  register(container) {
+    if (!container.has("cache")) {
+      const cacheFromServices = this.core?.services?.get("cache");
+      if (cacheFromServices) {
+        container.instance("cache", cacheFromServices);
+      }
+    }
+    container.singleton("launchpad.docker", () => new DockerAdapter());
+    container.singleton("launchpad.git", () => new ShellGitAdapter());
+    container.singleton("launchpad.router", () => new BunProxyAdapter());
+    container.singleton(
+      "launchpad.github",
+      () => new OctokitGitHubAdapter(process.env.GITHUB_TOKEN)
+    );
+    container.singleton("launchpad.repo", () => {
+      const cache = container.make("cache");
+      return new CachedRocketRepository(cache);
+    });
+    container.singleton("launchpad.refurbish", () => {
+      return new RefurbishUnit(container.make("launchpad.docker"));
+    });
+    container.singleton("launchpad.pool", () => {
+      return new PoolManager(
+        container.make("launchpad.docker"),
+        container.make("launchpad.repo"),
+        container.make("launchpad.refurbish"),
+        container.make("launchpad.router")
+      );
+    });
+    container.singleton("launchpad.injector", () => {
+      return new PayloadInjector(
+        container.make("launchpad.docker"),
+        container.make("launchpad.git")
+      );
+    });
+    container.singleton("launchpad.ctrl", () => {
+      return new MissionControl(
+        container.make("launchpad.pool"),
+        container.make("launchpad.injector"),
+        container.make("launchpad.docker"),
+        container.make("launchpad.router")
+      );
+    });
+  }
+  boot() {
+    const core = this.core;
+    if (!core) {
+      return;
+    }
+    const logger = core.logger;
+    const router = core.container.make("launchpad.router");
+    const docker = core.container.make("launchpad.docker");
+    router.start(8080);
+    logger.info("[Launchpad] \u6B63\u5728\u6383\u63CF\u4E26\u6E05\u7406\u6B98\u7559\u8CC7\u6E90...");
+    docker.removeContainerByLabel("gravito-origin=launchpad").then(() => {
+      logger.info("[Launchpad] \u8CC7\u6E90\u6E05\u7406\u5B8C\u7562\uFF0C\u7CFB\u7D71\u5C31\u7DD2\u3002");
+    }).catch((err) => {
+      logger.warn("[Launchpad] \u81EA\u52D5\u6E05\u7406\u5931\u6557 (\u53EF\u80FD\u662F\u74B0\u5883\u7121\u5BB9\u5668):", err.message);
+    });
+  }
+};
+var LaunchpadOrbit = class {
+  constructor(ripple) {
+    this.ripple = ripple;
+  }
+  async install(core) {
+    core.register(new LaunchpadServiceProvider());
+    core.router.post("/launch", async (c) => {
+      const rawBody = await c.req.text();
+      const signature = c.req.header("x-hub-signature-256") || "";
+      const secret = process.env.GITHUB_WEBHOOK_SECRET;
+      const github = core.container.make("launchpad.github");
+      if (secret && !github.verifySignature(rawBody, signature, secret)) {
+        core.logger.error("[GitHub] Webhook signature verification failed");
+        return c.json({ error: "Invalid signature" }, 401);
+      }
+      const body = JSON.parse(rawBody);
+      const event = c.req.header("x-github-event");
+      if (event === "pull_request") {
+        const action = body.action;
+        const pr = body.pull_request;
+        const missionId = `pr-${pr.number}`;
+        if (["opened", "synchronize", "reopened"].includes(action)) {
+          const mission = Mission.create({
+            id: missionId,
+            repoUrl: pr.base.repo.clone_url,
+            branch: pr.head.ref,
+            commitSha: pr.head.sha
+          });
+          const ctrl = core.container.make("launchpad.ctrl");
+          const rocketId = await ctrl.launch(mission, (type, data) => {
+            this.ripple.getServer().broadcast("telemetry", "telemetry.data", { type, data });
+          });
+          if (action === "opened" || action === "reopened") {
+            const previewUrl = `http://${missionId}.dev.local:8080`;
+            const dashboardUrl = `http://${c.req.header("host")?.split(":")[0]}:5173`;
+            const comment = `\u{1F680} **Gravito Launchpad: Deployment Ready!**
+
+- **Preview URL**: [${previewUrl}](${previewUrl})
+- **Mission Dashboard**: [${dashboardUrl}](${dashboardUrl})
+
+*Rocket ID: ${rocketId} | Commit: ${pr.head.sha.slice(0, 7)}*`;
+            await github.postComment(
+              pr.base.repo.owner.login,
+              pr.base.repo.name,
+              pr.number,
+              comment
+            );
+          }
+          return c.json({ success: true, missionId, rocketId });
+        }
+        if (action === "closed") {
+          const pool = core.container.make("launchpad.pool");
+          await pool.recycle(missionId);
+          return c.json({ success: true, action: "recycled" });
+        }
+      }
+      return c.json({ success: true, message: "Event ignored" });
+    });
+    core.router.post("/recycle", async (c) => {
+      const body = await c.req.json();
+      if (!body.missionId) {
+        return c.json({ error: "missionId required" }, 400);
+      }
+      const pool = core.container.make("launchpad.pool");
+      await pool.recycle(body.missionId);
+      return c.json({ success: true });
+    });
+  }
+};
+async function bootstrapLaunchpad() {
+  const ripple = new OrbitRipple({ path: "/ws" });
+  const core = await PlanetCore.boot({
+    config: {
+      APP_NAME: "Gravito Launchpad",
+      PORT: 4e3,
+      CACHE_DRIVER: "file"
+    },
+    orbits: [
+      new OrbitCache(),
+      ripple,
+      new LaunchpadOrbit(ripple)
+      // 傳入實例
+    ]
+  });
+  await core.bootstrap();
+  const liftoffConfig = core.liftoff();
+  return {
+    port: liftoffConfig.port,
+    websocket: ripple.getHandler(),
+    fetch: (req, server) => {
+      if (ripple.getServer().upgrade(req, server)) {
+        return;
+      }
+      return liftoffConfig.fetch(req, server);
+    }
+  };
+}
+export {
+  LaunchpadOrbit,
+  Mission,
+  MissionControl,
+  PayloadInjector,
+  PoolManager,
+  RefurbishUnit,
+  Rocket,
+  RocketStatus,
+  bootstrapLaunchpad
+};