@gravito/launchpad 0.1.0

package/src/Domain/Rocket.ts

@@ -0,0 +1,116 @@
+import { AggregateRoot } from '@gravito/enterprise'
+import {
+  MissionAssigned,
+  RefurbishmentCompleted,
+  RocketIgnited,
+  RocketSplashedDown,
+} from './Events'
+import type { Mission } from './Mission'
+import { RocketStatus } from './RocketStatus'
+
+export class Rocket extends AggregateRoot<string> {
+  private _status: RocketStatus = RocketStatus.IDLE
+  private _currentMission: Mission | null = null
+  private _containerId: string
+  private _assignedDomain: string | null = null
+
+  constructor(id: string, containerId: string) {
+    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
+  }
+
+  /**
+   * 分配域名
+   */
+  public assignDomain(domain: string): void {
+    this._assignedDomain = domain
+  }
+
+  /**
+   * 分配任務 (指派任務給 IDLE 的火箭)
+   */
+  public assignMission(mission: Mission): void {
+    if (this._status !== RocketStatus.IDLE) {
+      throw new Error(`無法指派任務：火箭 ${this.id} 狀態為 ${this._status}，非 IDLE`)
+    }
+
+    this._status = RocketStatus.PREPARING
+    this._currentMission = mission
+    this.addDomainEvent(new MissionAssigned(this.id, mission.id))
+  }
+
+  /**
+   * 點火啟動 (應用程式啟動成功)
+   */
+  public ignite(): void {
+    if (this._status !== RocketStatus.PREPARING) {
+      throw new Error(`無法點火：火箭 ${this.id} 尚未進入 PREPARING 狀態`)
+    }
+
+    this._status = RocketStatus.ORBITING
+    this.addDomainEvent(new RocketIgnited(this.id))
+  }
+
+  /**
+   * 任務降落 (PR 合併或關閉，暫停服務)
+   */
+  public splashDown(): void {
+    if (this._status !== RocketStatus.ORBITING) {
+      throw new Error(`無法降落：火箭 ${this.id} 不在運行軌道上`)
+    }
+
+    this._status = RocketStatus.REFURBISHING
+    this.addDomainEvent(new RocketSplashedDown(this.id))
+  }
+
+  /**
+   * 翻新完成 (清理完畢，回歸池中)
+   */
+  public finishRefurbishment(): void {
+    if (this._status !== RocketStatus.REFURBISHING) {
+      throw new Error(`無法完成翻新：火箭 ${this.id} 不在 REFURBISHING 狀態`)
+    }
+
+    this._status = RocketStatus.IDLE
+    this._currentMission = null
+    this.addDomainEvent(new RefurbishmentCompleted(this.id))
+  }
+
+  /**
+   * 火箭除役 (移除容器)
+   */
+  public decommission(): void {
+    this._status = RocketStatus.DECOMMISSIONED
+  }
+
+  public toJSON() {
+    return {
+      id: this.id,
+      containerId: this.containerId,
+      status: this._status,
+      currentMission: this._currentMission,
+      assignedDomain: this._assignedDomain,
+    }
+  }
+
+  public static fromJSON(data: any): Rocket {
+    const rocket = new Rocket(data.id, data.containerId)
+    rocket._status = data.status
+    rocket._currentMission = data.currentMission
+    rocket._assignedDomain = data.assignedDomain
+    return rocket
+  }
+}

package/src/Domain/RocketStatus.ts

@@ -0,0 +1,10 @@
+/**
+ * 火箭生命週期狀態
+ */
+export enum RocketStatus {
+  IDLE = 'IDLE', // 待命：容器運行中，無任務
+  PREPARING = 'PREPARING', // 裝填：正在注入代碼 (Locked)
+  ORBITING = 'ORBITING', // 運行：應用服務中
+  REFURBISHING = 'REFURBISHING', // 翻新：正在清理環境
+  DECOMMISSIONED = 'DECOMMISSIONED', // 除役：容器已移除
+}

package/src/Infrastructure/Docker/DockerAdapter.ts

@@ -0,0 +1,127 @@
+import type { IDockerAdapter } from '../../Domain/Interfaces'
+
+export class DockerAdapter implements IDockerAdapter {
+  private baseImage = 'oven/bun:1.0-slim'
+
+  async createBaseContainer(): Promise<string> {
+    const rocketId = `rocket-${Math.random().toString(36).substring(2, 9)}`
+
+    const proc = Bun.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).text()
+    const containerId = stdout.trim()
+
+    if (containerId.length === 64 && /^[0-9a-f]+$/.test(containerId)) {
+      return containerId
+    }
+
+    if (proc.exitCode !== 0) {
+      const stderr = await new Response(proc.stderr).text()
+      throw new Error(`Docker 容器建立失敗: ${stderr || stdout}`)
+    }
+
+    return containerId
+  }
+
+  async getExposedPort(containerId: string, containerPort = 3000): Promise<number> {
+    const proc = Bun.spawn(['docker', 'port', containerId, containerPort.toString()])
+    const stdout = await new Response(proc.stdout).text()
+    // 輸出格式可能包含多行，如 0.0.0.0:32768 和 [::]:32768
+    // 我們取第一行並提取端口
+    const firstLine = stdout.split('\n')[0] ?? ''
+    if (!firstLine) {
+      throw new Error(`無法獲取容器映射端口: ${stdout}`)
+    }
+    const match = firstLine.match(/:(\d+)$/)
+    if (!match?.[1]) {
+      throw new Error(`無法獲取容器映射端口: ${stdout}`)
+    }
+    return Number.parseInt(match[1], 10)
+  }
+
+  async copyFiles(containerId: string, sourcePath: string, targetPath: string): Promise<void> {
+    const proc = Bun.spawn(['docker', 'cp', sourcePath, `${containerId}:${targetPath}`])
+    await proc.exited
+    if (proc.exitCode && proc.exitCode !== 0) {
+      const stderr = await new Response(proc.stderr).text()
+      throw new Error(stderr || 'Docker copy failed')
+    }
+  }
+
+  async executeCommand(
+    containerId: string,
+    command: string[]
+  ): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+    const proc = Bun.spawn(['docker', 'exec', '-u', '0', containerId, ...command])
+    const stdout = await new Response(proc.stdout).text()
+    const stderr = await new Response(proc.stderr).text()
+    await proc.exited
+    return { stdout, stderr, exitCode: proc.exitCode ?? -1 }
+  }
+
+  async removeContainer(containerId: string): Promise<void> {
+    await Bun.spawn(['docker', 'rm', '-f', containerId]).exited
+  }
+
+  async removeContainerByLabel(label: string): Promise<void> {
+    const listProc = Bun.spawn(['docker', 'ps', '-aq', '--filter', `label=${label}`])
+    const ids = await new Response(listProc.stdout).text()
+
+    if (ids.trim()) {
+      const idList = ids.trim().split('\n')
+      await Bun.spawn(['docker', 'rm', '-f', ...idList]).exited
+    }
+  }
+
+  streamLogs(containerId: string, onData: (data: string) => void): void {
+    const proc = Bun.spawn(['docker', 'logs', '-f', containerId], {
+      stdout: 'pipe',
+      stderr: 'pipe',
+    })
+    const read = async (stream: ReadableStream) => {
+      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: string): Promise<{ cpu: string; memory: string }> {
+    const proc = Bun.spawn([
+      'docker',
+      'stats',
+      containerId,
+      '--no-stream',
+      '--format',
+      '{{.CPUPerc}},{{.MemUsage}}',
+    ])
+    const stdout = await new Response(proc.stdout).text()
+    const [cpu, memory] = stdout.trim().split(',')
+    return { cpu: cpu || '0%', memory: memory || '0B / 0B' }
+  }
+}

package/src/Infrastructure/Git/ShellGitAdapter.ts

@@ -0,0 +1,22 @@
+import { mkdir } from 'node:fs/promises'
+import type { IGitAdapter } from '../../Domain/Interfaces'
+
+export class ShellGitAdapter implements IGitAdapter {
+  private baseDir = '/tmp/gravito-launchpad-git'
+
+  async clone(repoUrl: string, branch: string): Promise<string> {
+    const dirName = `${Date.now()}-${Math.random().toString(36).slice(2)}`
+    const targetDir = `${this.baseDir}/${dirName}`
+
+    await mkdir(this.baseDir, { recursive: true })
+
+    const proc = Bun.spawn(['git', 'clone', '--depth', '1', '--branch', branch, repoUrl, targetDir])
+
+    await proc.exited
+    if (proc.exitCode !== 0) {
+      throw new Error('Git Clone Failed')
+    }
+
+    return targetDir
+  }
+}

package/src/Infrastructure/GitHub/OctokitGitHubAdapter.ts

@@ -0,0 +1,42 @@
+import { createHmac, timingSafeEqual } from 'node:crypto'
+import { Octokit } from '@octokit/rest'
+import type { IGitHubAdapter } from '../../Domain/Interfaces'
+
+export class OctokitGitHubAdapter implements IGitHubAdapter {
+  private octokit: Octokit
+
+  constructor(token?: string) {
+    this.octokit = new Octokit({ auth: token })
+  }
+
+  verifySignature(payload: string, signature: string, secret: string): boolean {
+    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: string,
+    repoName: string,
+    prNumber: number,
+    comment: string
+  ): Promise<void> {
+    try {
+      await this.octokit.issues.createComment({
+        owner: repoOwner,
+        repo: repoName,
+        issue_number: prNumber,
+        body: comment,
+      })
+      console.log(`[GitHub] 已在 PR #${prNumber} 留下部署資訊`)
+    } catch (error: any) {
+      console.error(`[GitHub] 留言失敗: ${error.message}`)
+    }
+  }
+}

package/src/Infrastructure/Persistence/CachedRocketRepository.ts

@@ -0,0 +1,42 @@
+import type { CacheService } from 'gravito-core'
+import type { IRocketRepository } from '../../Domain/Interfaces'
+import { Rocket } from '../../Domain/Rocket'
+
+export class CachedRocketRepository implements IRocketRepository {
+  private CACHE_KEY = 'launchpad:rockets'
+
+  constructor(private cache: CacheService) {}
+
+  private async getMap(): Promise<Map<string, any>> {
+    const data = await this.cache.get<Record<string, any>>(this.CACHE_KEY)
+    return new Map(Object.entries(data || {}))
+  }
+
+  async save(rocket: Rocket): Promise<void> {
+    const map = await this.getMap()
+    map.set(rocket.id, rocket.toJSON())
+    await this.cache.set(this.CACHE_KEY, Object.fromEntries(map))
+  }
+
+  async findById(id: string): Promise<Rocket | null> {
+    const map = await this.getMap()
+    const data = map.get(id)
+    return data ? Rocket.fromJSON(data) : null
+  }
+
+  async findIdle(): Promise<Rocket | null> {
+    const rockets = await this.findAll()
+    return rockets.find((r) => r.status === 'IDLE') || null
+  }
+
+  async findAll(): Promise<Rocket[]> {
+    const map = await this.getMap()
+    return Array.from(map.values()).map((data) => Rocket.fromJSON(data))
+  }
+
+  async delete(id: string): Promise<void> {
+    const map = await this.getMap()
+    map.delete(id)
+    await this.cache.set(this.CACHE_KEY, Object.fromEntries(map))
+  }
+}

package/src/Infrastructure/Persistence/InMemoryRocketRepository.ts

@@ -0,0 +1,32 @@
+import type { IRocketRepository } from '../../Domain/Interfaces'
+import type { Rocket } from '../../Domain/Rocket'
+import { RocketStatus } from '../../Domain/RocketStatus'
+
+export class InMemoryRocketRepository implements IRocketRepository {
+  private rockets = new Map<string, Rocket>()
+
+  async save(rocket: Rocket): Promise<void> {
+    this.rockets.set(rocket.id, rocket)
+  }
+
+  async findById(id: string): Promise<Rocket | null> {
+    return this.rockets.get(id) || null
+  }
+
+  async findIdle(): Promise<Rocket | null> {
+    for (const rocket of this.rockets.values()) {
+      if (rocket.status === RocketStatus.IDLE) {
+        return rocket
+      }
+    }
+    return null
+  }
+
+  async findAll(): Promise<Rocket[]> {
+    return Array.from(this.rockets.values())
+  }
+
+  async delete(id: string): Promise<void> {
+    this.rockets.delete(id)
+  }
+}

package/src/Infrastructure/Router/BunProxyAdapter.ts

@@ -0,0 +1,54 @@
+import type { IRouterAdapter } from '../../Domain/Interfaces'
+
+export class BunProxyAdapter implements IRouterAdapter {
+  private routes = new Map<string, string>() // domain -> targetUrl
+
+  register(domain: string, targetUrl: string): void {
+    console.log(`[Proxy] 註冊路由: ${domain} -> ${targetUrl}`)
+    this.routes.set(domain.toLowerCase(), targetUrl)
+  }
+
+  unregister(domain: string): void {
+    console.log(`[Proxy] 註銷路由: ${domain}`)
+    this.routes.delete(domain.toLowerCase())
+  }
+
+  start(port: number): void {
+    const self = this
+
+    Bun.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] 轉發: ${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: any) {
+          console.error(`[Proxy] 轉發失敗: ${error.message}`)
+          return new Response('Proxy Error', { status: 502 })
+        }
+      },
+    })
+
+    console.log(`[Proxy] 動態路由伺服器已啟動於 Port: ${port}`)
+  }
+}

package/src/index.ts

@@ -0,0 +1,223 @@
+import { OrbitRipple } from '@gravito/ripple'
+import { OrbitCache } from '@gravito/stasis'
+import { type Container, type GravitoOrbit, PlanetCore, ServiceProvider } from 'gravito-core'
+import { MissionControl } from './Application/MissionControl'
+import { PayloadInjector } from './Application/PayloadInjector'
+import { PoolManager } from './Application/PoolManager'
+import { RefurbishUnit } from './Application/RefurbishUnit'
+import { Mission } from './Domain/Mission'
+import { DockerAdapter } from './Infrastructure/Docker/DockerAdapter'
+import { ShellGitAdapter } from './Infrastructure/Git/ShellGitAdapter'
+import { OctokitGitHubAdapter } from './Infrastructure/GitHub/OctokitGitHubAdapter'
+import { CachedRocketRepository } from './Infrastructure/Persistence/CachedRocketRepository'
+import { BunProxyAdapter } from './Infrastructure/Router/BunProxyAdapter'
+
+export * from './Application/MissionControl'
+export * from './Application/PayloadInjector'
+export * from './Application/PoolManager'
+export * from './Application/RefurbishUnit'
+export * from './Domain/Mission'
+export * from './Domain/Rocket'
+export * from './Domain/RocketStatus'
+
+/**
+ * Launchpad 內部的 Service Provider
+ */
+class LaunchpadServiceProvider extends ServiceProvider {
+  register(container: Container): void {
+    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<any>('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')
+      )
+    })
+  }
+
+  override boot(): void {
+    const core = this.core
+    if (!core) {
+      return
+    }
+    const logger = core.logger
+    const router = core.container.make<BunProxyAdapter>('launchpad.router')
+    const docker = core.container.make<DockerAdapter>('launchpad.docker')
+
+    // 啟動路由代理
+    router.start(8080)
+
+    // [New] 啟動時自動清理殘留容器，維持系統純淨
+    logger.info('[Launchpad] 正在掃描並清理殘留資源...')
+    docker
+      .removeContainerByLabel('gravito-origin=launchpad')
+      .then(() => {
+        logger.info('[Launchpad] 資源清理完畢，系統就緒。')
+      })
+      .catch((err) => {
+        logger.warn('[Launchpad] 自動清理失敗 (可能是環境無容器):', err.message)
+      })
+  }
+}
+
+/**
+ * Gravito Launchpad Orbit
+ */
+export class LaunchpadOrbit implements GravitoOrbit {
+  constructor(private ripple: OrbitRipple) {}
+
+  async install(core: PlanetCore): Promise<void> {
+    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<OctokitGitHubAdapter>('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<MissionControl>('launchpad.ctrl')
+          const rocketId = await ctrl.launch(mission, (type, data) => {
+            // 修正：使用正確的 broadcast 方法
+            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 =
+              `🚀 **Gravito Launchpad: Deployment Ready!**\n\n` +
+              `- **Preview URL**: [${previewUrl}](${previewUrl})\n` +
+              `- **Mission Dashboard**: [${dashboardUrl}](${dashboardUrl})\n\n` +
+              `*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<PoolManager>('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()) as any
+      if (!body.missionId) {
+        return c.json({ error: 'missionId required' }, 400)
+      }
+
+      const pool = core.container.make<PoolManager>('launchpad.pool')
+      await pool.recycle(body.missionId)
+      return c.json({ success: true })
+    })
+  }
+}
+
+/**
+ * 一鍵啟動 Launchpad 應用程式
+ */
+export async function bootstrapLaunchpad() {
+  const ripple = new OrbitRipple({ path: '/ws' })
+
+  const core = await PlanetCore.boot({
+    config: {
+      APP_NAME: 'Gravito Launchpad',
+      PORT: 4000,
+      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: Request, server: any) => {
+      if (ripple.getServer().upgrade(req, server)) {
+        return
+      }
+      return liftoffConfig.fetch(req, server)
+    },
+  }
+}