@fzgame/cli 0.0.0-stage → 0.1.0

package/src/runner.ts

@@ -0,0 +1,304 @@
+import { spawn } from 'node:child_process'
+import { mkdtemp, readdir, readFile, rm } from 'node:fs/promises'
+import { hostname } from 'node:os'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { request, type RequestOptions } from './fetch'
+import { buildGame } from './pack'
+import {
+  buildCommand,
+  installCommand,
+  planPipeline,
+  testCommand,
+} from './runner-pipeline'
+import { VERSION } from './version'
+
+export type RunnerStartOptions = {
+  server: string
+  key: string
+  pass: string
+}
+
+type RunnerJob = {
+  deploymentId: string
+  owner: string
+  repo: string
+  commitSha: string
+  branch?: string | null
+  rootDirectory?: string
+  cloneToken: string
+}
+
+const EXAMPLE =
+  'fzgame runner start --server http://localhost:3020 --key <key> --pass <pass>'
+
+const CLAIM_TIMEOUT_MS = 30_000
+const IDLE_SLEEP_MS = 2000
+const MIN_BACKOFF_MS = 2000
+const MAX_BACKOFF_MS = 30_000
+const UPLOAD_TIMEOUT_MS = 120_000
+const LOG_FLUSH_MS = 250
+const LOG_MAX_CHARS = 8000
+
+export async function startRunner(opts: RunnerStartOptions) {
+  const server = (opts.server || '').replace(/\/$/, '')
+  const key = opts.key || ''
+  const pass = opts.pass || ''
+  if (!server || !key || !pass) {
+    throw new Error(`Pass --server, --key, and --pass. Example: ${EXAMPLE}`)
+  }
+
+  const headers = {
+    'x-runner-key': key,
+    'x-runner-pass': pass,
+  }
+
+  const connected = await api(server, '/internal/ci-runners/connect', {
+    method: 'POST',
+    headers: { ...headers, 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      key,
+      pass,
+      hostname: hostname(),
+      version: VERSION,
+    }),
+  })
+  console.log(`Runner ${connected.name || key} connected to ${server}`)
+  console.log('Waiting for queued git deploys (fetch → build → test → publish)')
+
+  let stopping = false
+  const beat = setInterval(() => {
+    api(server, '/internal/ci-runners/heartbeat', {
+      method: 'POST',
+      headers,
+    }).catch(() => undefined)
+  }, 15_000)
+
+  const stop = () => {
+    if (stopping) return
+    stopping = true
+    clearInterval(beat)
+    api(server, '/internal/ci-runners/disconnect', {
+      method: 'POST',
+      headers,
+    })
+      .catch(() => undefined)
+      .finally(() => process.exit(0))
+  }
+  process.on('SIGINT', stop)
+  process.on('SIGTERM', stop)
+
+  let backoff = MIN_BACKOFF_MS
+  const retry = async (message: string) => {
+    console.error(`${message}; retrying in ${Math.round(backoff / 1000)}s`)
+    await sleep(backoff)
+    backoff = Math.min(backoff * 2, MAX_BACKOFF_MS)
+  }
+
+  while (!stopping) {
+    let res: Response
+    try {
+      res = await request(`${server}/internal/ci-runners/jobs/next`, {
+        headers,
+        timeoutMs: CLAIM_TIMEOUT_MS,
+      })
+    } catch (error) {
+      await retry(`claim failed: ${(error as Error).message}`)
+      continue
+    }
+    backoff = MIN_BACKOFF_MS
+
+    if (res.status === 204) {
+      await sleep(IDLE_SLEEP_MS)
+      continue
+    }
+    const text = await res.text()
+    if (!res.ok) {
+      await retry(`claim failed (${res.status}): ${text.slice(0, 200)}`)
+      continue
+    }
+    if (!text) {
+      await sleep(IDLE_SLEEP_MS)
+      continue
+    }
+
+    let job: RunnerJob
+    try {
+      job = JSON.parse(text) as RunnerJob
+    } catch {
+      await retry(`claim returned invalid JSON: ${text.slice(0, 200)}`)
+      continue
+    }
+
+    console.log(`Job ${job.deploymentId} ${job.owner}/${job.repo}@${job.commitSha.slice(0, 7)}`)
+    try {
+      await runJob(server, headers, job)
+      console.log(`Job ${job.deploymentId} ready`)
+    } catch (err) {
+      const message = (err as Error).message
+      console.error(`Job ${job.deploymentId} failed: ${message}`)
+      await api(server, `/internal/ci-runners/jobs/${job.deploymentId}/fail`, {
+        method: 'POST',
+        headers: { ...headers, 'Content-Type': 'application/json' },
+        body: JSON.stringify({ message }),
+      }).catch(() => undefined)
+    }
+  }
+}
+
+async function runJob(
+  server: string,
+  headers: Record<string, string>,
+  job: RunnerJob,
+) {
+  const work = await mkdtemp(join(tmpdir(), 'fzgame-run-'))
+
+  // Build output arrives in many small chunks; coalesce them so a chatty build
+  // does not turn into one HTTP request per chunk.
+  let pending = ''
+  let flushTimer: NodeJS.Timeout | undefined
+  const flushLogs = async () => {
+    if (flushTimer) {
+      clearTimeout(flushTimer)
+      flushTimer = undefined
+    }
+    if (!pending) return
+    const chunk = pending
+    pending = ''
+    await api(server, `/internal/ci-runners/jobs/${job.deploymentId}/logs`, {
+      method: 'POST',
+      headers: { ...headers, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ chunk }),
+    }).catch(() => undefined)
+  }
+  const log = (chunk: string) => {
+    process.stdout.write(chunk)
+    pending += chunk
+    if (pending.length >= LOG_MAX_CHARS) {
+      void flushLogs()
+      return
+    }
+    if (!flushTimer) {
+      flushTimer = setTimeout(() => void flushLogs(), LOG_FLUSH_MS)
+      flushTimer.unref()
+    }
+  }
+  const stage = async (name: string, status: string, error?: string) => {
+    await flushLogs()
+    await api(server, `/internal/ci-runners/jobs/${job.deploymentId}/stage`, {
+      method: 'POST',
+      headers: { ...headers, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ name, status, error }),
+    })
+  }
+
+  try {
+    await stage('fetch', 'running')
+    log(`fetch ${job.owner}/${job.repo} ${job.commitSha}\n`)
+    await runCmd('git', ['init'], work, log)
+    const origin = `https://x-access-token:${job.cloneToken}@github.com/${job.owner}/${job.repo}.git`
+    await runCmd('git', ['remote', 'add', 'origin', origin], work, () => undefined)
+    await runCmd('git', ['fetch', '--depth', '1', 'origin', job.commitSha], work, log)
+    await runCmd('git', ['checkout', '--force', 'FETCH_HEAD'], work, log)
+    await stage('fetch', 'ok')
+
+    const packRoot = job.rootDirectory ? join(work, job.rootDirectory) : work
+    const files = await readdir(packRoot)
+    const scripts = await readScripts(packRoot)
+    const planned = planPipeline(scripts)
+
+    await stage('build', 'running')
+    const install = installCommand(files)
+    if (install) await runCmd(install[0], install[1], packRoot, log)
+    const build = buildCommand(files, scripts)
+    if (build) await runCmd(build[0], build[1], packRoot, log)
+    await stage('build', 'ok')
+
+    if (planned.includes('test')) {
+      await stage('test', 'running')
+      const test = testCommand(files, scripts)
+      if (test) await runCmd(test[0], test[1], packRoot, log)
+      await stage('test', 'ok')
+    } else {
+      await stage('test', 'skipped')
+    }
+
+    await stage('publish', 'running')
+    const packed = await buildGame(packRoot)
+    log(`packed ${packed.dest}\n`)
+    const zip = await readFile(packed.dest)
+    const form = new FormData()
+    form.append(
+      'file',
+      new Blob([new Uint8Array(zip)], { type: 'application/zip' }),
+      'game.zip',
+    )
+    const published = await request(
+      `${server}/internal/ci-runners/jobs/${job.deploymentId}/artifact`,
+      { method: 'POST', headers, body: form, timeoutMs: UPLOAD_TIMEOUT_MS },
+    )
+    if (!published.ok) {
+      throw new Error(`publish failed (${published.status}): ${await published.text()}`)
+    }
+    await stage('publish', 'ok')
+  } finally {
+    await flushLogs()
+    await rm(work, { recursive: true, force: true })
+  }
+}
+
+async function readScripts(root: string) {
+  try {
+    const raw = JSON.parse(await readFile(join(root, 'package.json'), 'utf8')) as {
+      scripts?: { build?: string; test?: string }
+    }
+    return raw.scripts ?? {}
+  } catch {
+    return null
+  }
+}
+
+function runCmd(
+  cmd: string,
+  args: string[],
+  cwd: string,
+  onLog: (chunk: string) => void,
+) {
+  return new Promise<void>((resolve, reject) => {
+    // pnpm/npm/yarn are .cmd shims on Windows and only resolve through cmd.exe.
+    const useShell = process.platform === 'win32'
+    const child = spawn(cmd, useShell ? args.map(quoteForShell) : args, {
+      cwd,
+      env: process.env,
+      shell: useShell,
+    })
+    child.stdout.on('data', (buf: Buffer) => onLog(buf.toString()))
+    child.stderr.on('data', (buf: Buffer) => onLog(buf.toString()))
+    child.on('error', reject)
+    child.on('close', (code, signal) => {
+      if (code === 0) resolve()
+      else if (signal) reject(new Error(`${cmd} ${args.join(' ')} killed by ${signal}`))
+      else reject(new Error(`${cmd} ${args.join(' ')} exited ${code}`))
+    })
+  })
+}
+
+function quoteForShell(arg: string) {
+  return /[\s"&|<>^()]/.test(arg) ? `"${arg.replace(/"/g, '""')}"` : arg
+}
+
+async function api(server: string, path: string, init: RequestOptions) {
+  const res = await request(`${server}${path}`, init)
+  const text = await res.text()
+  if (!res.ok) throw new Error(`${path} failed (${res.status}): ${text.slice(0, 500)}`)
+  if (!text) return {} as { name?: string }
+  try {
+    return JSON.parse(text) as { name?: string }
+  } catch {
+    throw new Error(`${path} returned invalid JSON: ${text.slice(0, 200)}`)
+  }
+}
+
+function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}

package/src/version.ts

@@ -0,0 +1,19 @@
+import { readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+// Resolves to the package root from both src/ (vitest) and dist/ (the CJS bundle).
+const here = dirname(fileURLToPath(import.meta.url))
+
+function readVersion(): string {
+  try {
+    const raw = JSON.parse(readFileSync(join(here, '..', 'package.json'), 'utf8')) as {
+      version?: string
+    }
+    return raw.version ?? '0.0.0'
+  } catch {
+    return '0.0.0'
+  }
+}
+
+export const VERSION = readVersion()

package/src/zip.ts

@@ -0,0 +1,80 @@
+import { deflateRawSync } from 'node:zlib'
+
+// Fixed 1980-01-01 00:00 DOS timestamp: byte-identical archives for identical
+// input, with month and day fields that real extractors accept.
+const DOS_TIME = 0
+const DOS_DATE = 0x0021
+
+const CRC_TABLE = new Uint32Array(256)
+for (let n = 0; n < 256; n++) {
+  let c = n
+  for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1
+  CRC_TABLE[n] = c
+}
+
+function crc32(buf: Buffer): number {
+  let c = 0xffffffff
+  for (let i = 0; i < buf.length; i++) {
+    c = CRC_TABLE[(c ^ buf[i]!) & 0xff]! ^ (c >>> 8)
+  }
+  return (c ^ 0xffffffff) >>> 0
+}
+
+export function buildZip(files: Record<string, Buffer | string>): Buffer {
+  const records: Array<{
+    name: Buffer
+    data: Buffer
+    compressed: Buffer
+    crc: number
+    offset: number
+  }> = []
+  const parts: Buffer[] = []
+  let offset = 0
+
+  for (const [name, content] of Object.entries(files)) {
+    const data = Buffer.isBuffer(content) ? content : Buffer.from(content)
+    const compressed = deflateRawSync(data)
+    const crc = crc32(data)
+    const nameBuf = Buffer.from(name.replace(/\\/g, '/'), 'utf8')
+    const local = Buffer.alloc(30)
+    local.writeUInt32LE(0x04034b50, 0)
+    local.writeUInt16LE(20, 4)
+    local.writeUInt16LE(8, 8)
+    local.writeUInt16LE(DOS_TIME, 10)
+    local.writeUInt16LE(DOS_DATE, 12)
+    local.writeUInt32LE(crc, 14)
+    local.writeUInt32LE(compressed.length, 18)
+    local.writeUInt32LE(data.length, 22)
+    local.writeUInt16LE(nameBuf.length, 26)
+    parts.push(local, nameBuf, compressed)
+    records.push({ name: nameBuf, data, compressed, crc, offset })
+    offset += local.length + nameBuf.length + compressed.length
+  }
+
+  const centralStart = offset
+  for (const record of records) {
+    const central = Buffer.alloc(46)
+    central.writeUInt32LE(0x02014b50, 0)
+    central.writeUInt16LE(20, 4)
+    central.writeUInt16LE(20, 6)
+    central.writeUInt16LE(8, 10)
+    central.writeUInt16LE(DOS_TIME, 12)
+    central.writeUInt16LE(DOS_DATE, 14)
+    central.writeUInt32LE(record.crc, 16)
+    central.writeUInt32LE(record.compressed.length, 20)
+    central.writeUInt32LE(record.data.length, 24)
+    central.writeUInt16LE(record.name.length, 28)
+    central.writeUInt32LE(record.offset, 42)
+    parts.push(central, record.name)
+    offset += central.length + record.name.length
+  }
+
+  const eocd = Buffer.alloc(22)
+  eocd.writeUInt32LE(0x06054b50, 0)
+  eocd.writeUInt16LE(records.length, 8)
+  eocd.writeUInt16LE(records.length, 10)
+  eocd.writeUInt32LE(offset - centralStart, 12)
+  eocd.writeUInt32LE(centralStart, 16)
+  parts.push(eocd)
+  return Buffer.concat(parts)
+}