@atomservice/functions-cli 0.1.6

package/bin/functions.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env bun
+import { log } from "@clack/prompts"
+import { runMain } from "citty"
+import { mainCommand } from "../src/index.ts"
+
+runMain(mainCommand).catch((err) => {
+  log.error(err instanceof Error ? err.message : String(err))
+  process.exit(1)
+})

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@atomservice/functions-cli",
+  "version": "0.1.6",
+  "description": "函数服务命令行工具（atomfunctions）：项目脚手架、本地构建、部署、运维",
+  "type": "module",
+  "author": "openorson",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/openorson/atomservice.git",
+    "directory": "services/functions/cli"
+  },
+  "bugs": "https://github.com/openorson/atomservice/issues",
+  "homepage": "https://github.com/openorson/atomservice/tree/main/services/functions/cli#readme",
+  "keywords": [
+    "atomservice",
+    "functions",
+    "faas",
+    "cli",
+    "bun"
+  ],
+  "engines": {
+    "bun": ">=1.3.14"
+  },
+  "files": [
+    "src",
+    "bin"
+  ],
+  "bin": {
+    "atomfunctions": "./bin/functions.ts",
+    "atomfn": "./bin/functions.ts"
+  },
+  "dependencies": {
+    "@atomservice/functions-sdk": "0.1.6",
+    "@clack/prompts": "1.5.0",
+    "citty": "0.2.2",
+    "picocolors": "1.1.1",
+    "typebox": "1.2.2"
+  },
+  "devDependencies": {
+    "typescript": "^6"
+  }
+}

package/src/build.ts

@@ -0,0 +1,252 @@
+import { readdir, rm } from "node:fs/promises"
+import path from "node:path"
+import { $ } from "bun"
+import { BUNDLE_FILE, ENTRY_FILE, FUNCTION_CONFIG_FILE, FUNCTION_FILE, LINUX_TARGET, SDK_PACKAGE } from "./consts.ts"
+import type { BundleConfig, DeployManifest, FunctionFileConfig } from "./types.ts"
+import { readJson } from "./utils.ts"
+
+export interface BuildResult {
+  manifest: DeployManifest
+  artifactPath: string
+}
+
+export interface ResolvedFunction {
+  name: string
+  config: FunctionFileConfig
+}
+
+export async function discoverFunctions(bundleDir: string): Promise<string[]> {
+  const entries = await readdir(bundleDir, { withFileTypes: true })
+  const names: string[] = []
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) continue
+    if (await Bun.file(path.join(bundleDir, entry.name, FUNCTION_FILE)).exists()) names.push(entry.name)
+  }
+  return names.sort()
+}
+
+export async function resolveFunctions(
+  bundleDir: string,
+  defaults: FunctionFileConfig = {},
+): Promise<ResolvedFunction[]> {
+  const names = await discoverFunctions(bundleDir)
+  const resolved: ResolvedFunction[] = []
+  for (const name of names) {
+    const fileConfig = await readJson<FunctionFileConfig>(path.join(bundleDir, name, FUNCTION_CONFIG_FILE))
+    resolved.push({ name, config: { ...defaults, ...(fileConfig ?? {}) } })
+  }
+  return resolved
+}
+
+async function hashSources(bundleDir: string, functions: string[]): Promise<string> {
+  const hasher = new Bun.CryptoHasher("sha256")
+  const files = [
+    path.join(bundleDir, BUNDLE_FILE),
+    path.join(bundleDir, "package.json"),
+    path.join(bundleDir, "bun.lock"),
+    path.join(bundleDir, "Containerfile"),
+    ...functions.flatMap((fn) => [
+      path.join(bundleDir, fn, FUNCTION_FILE),
+      path.join(bundleDir, fn, FUNCTION_CONFIG_FILE),
+    ]),
+  ]
+  for (const file of files) {
+    const handle = Bun.file(file)
+    if (await handle.exists()) {
+      hasher.update(file)
+      hasher.update(await handle.arrayBuffer())
+    }
+  }
+  return hasher.digest("hex").slice(0, 16)
+}
+
+function entrySource(functions: ResolvedFunction[]): string {
+  const imports = functions.map((f, i) => `import fn${i} from ${JSON.stringify(`./${f.name}/${FUNCTION_FILE}`)}`)
+  const entries = functions.map((f, i) => {
+    const override = JSON.stringify(f.config)
+    return `  ${JSON.stringify(f.name)}: { ...fn${i}, config: { ...fn${i}.config, ...${override} } },`
+  })
+  return `import { serve } from ${JSON.stringify(SDK_PACKAGE)}
+${imports.join("\n")}
+
+serve({
+${entries.join("\n")}
+})
+`
+}
+
+export async function writeEntry(bundleDir: string, functions: ResolvedFunction[]): Promise<string> {
+  const entryPath = path.join(bundleDir, ENTRY_FILE)
+  await Bun.write(entryPath, entrySource(functions))
+  return entryPath
+}
+
+async function compileBinary(bundleDir: string, functions: ResolvedFunction[]): Promise<string> {
+  const entryPath = await writeEntry(bundleDir, functions)
+  const outPath = path.join(bundleDir, ".atomfn-bundle")
+  try {
+    const result = await $`bun build --compile --minify --target=${LINUX_TARGET} ${entryPath} --outfile ${outPath}`
+      .cwd(bundleDir)
+      .quiet()
+      .nothrow()
+    if (result.exitCode !== 0) throw new Error(`编译失败：${result.stderr.toString().slice(-500)}`)
+  } finally {
+    await rm(entryPath, { force: true })
+  }
+  return outPath
+}
+
+async function podmanBuildAndSave(bundleDir: string, image: string): Promise<string> {
+  const containerfile = path.join(bundleDir, "Containerfile")
+  const build = await $`podman build -t ${image} -f ${containerfile} ${bundleDir}`.quiet().nothrow()
+  if (build.exitCode !== 0) throw new Error(`镜像构建失败：${build.stderr.toString().slice(-500)}`)
+
+  const tarPath = path.join(bundleDir, ".atomfn-image.tar")
+  const save = await $`podman save -o ${tarPath} ${image}`.quiet().nothrow()
+  if (save.exitCode !== 0) throw new Error(`镜像导出失败：${save.stderr.toString().slice(-500)}`)
+  return tarPath
+}
+
+async function buildImage(
+  bundleDir: string,
+  project: string,
+  bundle: string,
+  version: string,
+  binaryPath: string,
+): Promise<string> {
+  const image = `localhost/atomfn/${project}-${bundle}:${version}`
+  const stagedBinary = path.join(bundleDir, "bundle")
+  await Bun.write(stagedBinary, Bun.file(binaryPath))
+  try {
+    return await podmanBuildAndSave(bundleDir, image)
+  } finally {
+    await rm(stagedBinary, { force: true })
+  }
+}
+
+const HASH_SKIP = new Set(["target", "node_modules", ".git"])
+
+async function hashTree(dir: string): Promise<string> {
+  const hasher = new Bun.CryptoHasher("sha256")
+  const walk = async (current: string): Promise<void> => {
+    const entries = (await readdir(current, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))
+    for (const entry of entries) {
+      if (HASH_SKIP.has(entry.name) || entry.name.startsWith(".atomfn")) continue
+      const full = path.join(current, entry.name)
+      if (entry.isDirectory()) {
+        await walk(full)
+      } else {
+        hasher.update(full)
+        hasher.update(await Bun.file(full).arrayBuffer())
+      }
+    }
+  }
+  await walk(dir)
+  return hasher.digest("hex").slice(0, 16)
+}
+
+async function buildRustBundle(
+  root: string,
+  project: string,
+  bundle: string,
+  config: BundleConfig,
+): Promise<BuildResult> {
+  const bundleDir = path.join(root, bundle)
+  const functions = config.functions ?? []
+  if (functions.length === 0) {
+    throw new Error(`rust bundle ${bundle} 需在 ${BUNDLE_FILE} 的 functions 中声明函数名`)
+  }
+  if (!(await Bun.file(path.join(bundleDir, "Containerfile")).exists())) {
+    throw new Error(`rust bundle ${bundle} 缺少 Containerfile`)
+  }
+  const version = await hashTree(bundleDir)
+  const image = `localhost/atomfn/${project}-${bundle}:${version}`
+  const tarPath = await podmanBuildAndSave(bundleDir, image)
+  return {
+    manifest: {
+      project,
+      bundle,
+      version,
+      artifact: "image",
+      functions: [...functions].sort(),
+      image,
+      memory: config.memory,
+      cpus: config.cpus,
+      maxConcurrency: config.maxConcurrency,
+      env: config.env,
+    },
+    artifactPath: tarPath,
+  }
+}
+
+export async function buildBundle(root: string, project: string, bundle: string): Promise<BuildResult> {
+  const bundleDir = path.join(root, bundle)
+  const config = await readJson<BundleConfig>(path.join(bundleDir, BUNDLE_FILE))
+  if (!config) throw new Error(`未找到 ${bundle}/${BUNDLE_FILE}`)
+  if (config.language === "rust") return buildRustBundle(root, project, bundle, config)
+  if (config.language !== "bun") throw new Error(`暂不支持的语言：${config.language}`)
+
+  const functions = await resolveFunctions(bundleDir, config.defaults)
+  if (functions.length === 0) throw new Error(`bundle ${bundle} 内没有函数`)
+
+  const names = functions.map((f) => f.name)
+  const asyncFunctions = await detectAsyncFunctions(bundleDir, names)
+  const version = await hashSources(bundleDir, names)
+  const hasContainerfile = await Bun.file(path.join(bundleDir, "Containerfile")).exists()
+
+  if (hasContainerfile) {
+    const binaryPath = await compileBinary(bundleDir, functions)
+    try {
+      const tarPath = await buildImage(bundleDir, project, bundle, version, binaryPath)
+      return {
+        manifest: {
+          project,
+          bundle,
+          version,
+          artifact: "image",
+          functions: names,
+          asyncFunctions: asyncFunctions.length ? asyncFunctions : undefined,
+          image: `localhost/atomfn/${project}-${bundle}:${version}`,
+          memory: config.memory,
+          cpus: config.cpus,
+          maxConcurrency: config.maxConcurrency,
+          env: config.env,
+        },
+        artifactPath: tarPath,
+      }
+    } finally {
+      await rm(binaryPath, { force: true })
+    }
+  }
+
+  const binaryPath = await compileBinary(bundleDir, functions)
+  return {
+    manifest: {
+      project,
+      bundle,
+      version,
+      artifact: "binary",
+      functions: names,
+      asyncFunctions: asyncFunctions.length ? asyncFunctions : undefined,
+      memory: config.memory,
+      cpus: config.cpus,
+      maxConcurrency: config.maxConcurrency,
+      env: config.env,
+    },
+    artifactPath: binaryPath,
+  }
+}
+
+async function detectAsyncFunctions(bundleDir: string, names: string[]): Promise<string[]> {
+  const result: string[] = []
+  for (const name of names) {
+    try {
+      const module = await import(path.join(bundleDir, name, FUNCTION_FILE))
+      const kind = (module.default as { kind?: string } | undefined)?.kind
+      if (kind === "asyncFunction" || kind === "asyncStreamFunction") result.push(name)
+    } catch {
+      // 忽略无法导入的函数（缺依赖等），按同步处理
+    }
+  }
+  return result
+}

package/src/client.ts

@@ -0,0 +1,109 @@
+import { ADMIN_PREFIX } from "./consts.ts"
+import type { BundleRecord, DeployManifest } from "./types.ts"
+
+export class ClientError extends Error {
+  status: number
+  code: string
+
+  constructor(status: number, code: string, message: string) {
+    super(message)
+    this.status = status
+    this.code = code
+  }
+}
+
+interface ErrorBody {
+  error?: { code: string; message: string }
+}
+
+export class AdminClient {
+  private base: string
+  private token: string
+
+  constructor(server: string, token: string) {
+    this.base = `${server.replace(/\/+$/, "")}${ADMIN_PREFIX}`
+    this.token = token
+  }
+
+  private async parse<T>(res: Response): Promise<T> {
+    const text = await res.text()
+    let body: ErrorBody & T
+    try {
+      body = text ? (JSON.parse(text) as ErrorBody & T) : ({} as ErrorBody & T)
+    } catch {
+      throw new ClientError(res.status, "invalid_response", `服务端返回非 JSON：${text.slice(0, 200)}`)
+    }
+    if (!res.ok) {
+      const err = body.error
+      throw new ClientError(res.status, err?.code ?? "error", err?.message ?? `请求失败（${res.status}）`)
+    }
+    return body as T
+  }
+
+  private async send<T>(method: string, path: string, init?: RequestInit): Promise<T> {
+    let res: Response
+    try {
+      res = await fetch(`${this.base}${path}`, {
+        method,
+        headers: { authorization: `Bearer ${this.token}`, ...(init?.headers ?? {}) },
+        body: init?.body,
+      })
+    } catch {
+      throw new ClientError(0, "network", `无法连接到 ${this.base}，请检查地址与网络`)
+    }
+    return this.parse<T>(res)
+  }
+
+  async deploy(project: string, manifest: DeployManifest, artifact: Blob): Promise<BundleRecord> {
+    const form = new FormData()
+    form.set("manifest", JSON.stringify(manifest))
+    form.set("artifact", artifact, `${manifest.bundle}-${manifest.version}`)
+    const data = await this.send<{ bundle: BundleRecord }>("POST", `/projects/${project}/bundles`, { body: form })
+    return data.bundle
+  }
+
+  async list(project: string): Promise<BundleRecord[]> {
+    const data = await this.send<{ bundles: BundleRecord[] }>("GET", `/projects/${project}/bundles`)
+    return data.bundles
+  }
+
+  async remove(project: string, bundle: string): Promise<BundleRecord> {
+    const data = await this.send<{ bundle: BundleRecord }>("DELETE", `/projects/${project}/bundles/${bundle}`)
+    return data.bundle
+  }
+
+  async logs(project: string, bundle: string, tail: number): Promise<string> {
+    const data = await this.send<{ logs: string }>("GET", `/projects/${project}/bundles/${bundle}/logs?tail=${tail}`)
+    return data.logs
+  }
+
+  async versions(project: string, bundle: string): Promise<BundleRecord[]> {
+    const data = await this.send<{ versions: BundleRecord[] }>("GET", `/projects/${project}/bundles/${bundle}/versions`)
+    return data.versions
+  }
+
+  async rollback(project: string, bundle: string, version: string): Promise<BundleRecord> {
+    const data = await this.send<{ bundle: BundleRecord }>(
+      "POST",
+      `/projects/${project}/bundles/${bundle}/rollback?version=${version}`,
+    )
+    return data.bundle
+  }
+
+  async get<T>(p: string): Promise<T> {
+    return this.send<T>("GET", p)
+  }
+
+  async post<T>(p: string, body?: unknown): Promise<T> {
+    const init: RequestInit = {}
+    if (body !== undefined) {
+      init.body = JSON.stringify(body)
+      init.headers = { "content-type": "application/json" }
+    }
+    return this.send<T>("POST", p, init)
+  }
+
+  async del(p: string): Promise<void> {
+    await this.send<unknown>("DELETE", p)
+  }
+}

package/src/commands/bundle.ts

@@ -0,0 +1,76 @@
+import path from "node:path"
+import { confirm, intro, isCancel, log, outro, select, text } from "@clack/prompts"
+import { defineCommand } from "citty"
+import pc from "picocolors"
+import { BUNDLE_FILE, BUNDLES_DIR } from "../consts.ts"
+import { loadContext } from "../context.ts"
+import { scaffoldBundle } from "../scaffold.ts"
+import type { BundleConfig, Language } from "../types.ts"
+import { isValidSlug, readJson, unwrap } from "../utils.ts"
+
+const createCommand = defineCommand({
+  meta: { name: "create", description: "创建函数包（bundle）" },
+  args: {
+    slug: { type: "positional", required: false, description: "bundle 名" },
+    lang: { type: "string", description: "语言：bun（默认）" },
+  },
+  async run({ args }) {
+    intro(pc.cyan("创建函数包"))
+    const ctx = await loadContext()
+    if (!ctx) {
+      log.error("未找到 atomfunctions.json")
+      process.exit(1)
+    }
+
+    const slug =
+      args.slug ??
+      unwrap(
+        await text({
+          message: "bundle 名",
+          validate: (v) => {
+            const s = v?.trim()
+            if (!s) return "请输入 bundle 名"
+            return isValidSlug(s) ? undefined : "需以小写字母开头，仅含小写字母、数字、连字符"
+          },
+        }),
+      ).trim()
+
+    if (!isValidSlug(slug)) {
+      log.error("bundle 名需以小写字母开头，仅含小写字母、数字、连字符")
+      process.exit(1)
+    }
+
+    const bundleDir = path.join(ctx.root, BUNDLES_DIR, slug)
+    const existing = await readJson<BundleConfig>(path.join(bundleDir, BUNDLE_FILE))
+    if (existing) {
+      const ok = await confirm({ message: `bundle ${slug} 已存在，是否覆盖？`, initialValue: false })
+      if (isCancel(ok) || !ok) {
+        outro(pc.yellow("已取消"))
+        return
+      }
+    }
+
+    const language: Language =
+      typeof args.lang === "string"
+        ? (args.lang as Language)
+        : (unwrap(
+            await select({
+              message: "选择语言",
+              options: [
+                { value: "bun", label: "Bun (TypeScript)" },
+                { value: "rust", label: "Rust" },
+              ],
+              initialValue: "bun",
+            }),
+          ) as Language)
+
+    await scaffoldBundle(bundleDir, { language })
+    log.success(`已创建 bundle ${slug}`)
+    outro(pc.green(`完成，路径 ${path.relative(ctx.root, bundleDir)}`))
+  },
+})
+
+export const bundleCommand = defineCommand({
+  meta: { name: "bundle", description: "管理函数包" },
+  subCommands: { create: createCommand },
+})

package/src/commands/deploy.ts

@@ -0,0 +1,103 @@
+import { readdir, rm } from "node:fs/promises"
+import path from "node:path"
+import { intro, log, outro, spinner } from "@clack/prompts"
+import { defineCommand } from "citty"
+import pc from "picocolors"
+import { buildBundle } from "../build.ts"
+import { AdminClient } from "../client.ts"
+import { BUNDLE_FILE } from "../consts.ts"
+import { loadContext, pickTarget, requireProjectContext } from "../context.ts"
+import type { DeployManifest, ServerTarget } from "../types.ts"
+
+async function listLocalBundles(root: string): Promise<string[]> {
+  const entries = await readdir(root, { withFileTypes: true })
+  const bundles: string[] = []
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name.startsWith(".")) continue
+    if (await Bun.file(path.join(root, entry.name, BUNDLE_FILE)).exists()) bundles.push(entry.name)
+  }
+  return bundles.sort()
+}
+
+async function deployToTarget(
+  target: ServerTarget,
+  manifest: DeployManifest,
+  artifactPath: string,
+  force: boolean,
+): Promise<{ host: string; ok: boolean; skipped: boolean; message?: string }> {
+  const client = new AdminClient(target.server, target.token)
+  try {
+    if (!force) {
+      const remote = await client.list(manifest.project)
+      const current = remote.find((r) => r.project === manifest.project && r.bundle === manifest.bundle)
+      if (current?.version === manifest.version) return { host: target.host, ok: true, skipped: true }
+    }
+    await client.deploy(manifest.project, manifest, Bun.file(artifactPath))
+    return { host: target.host, ok: true, skipped: false }
+  } catch (error) {
+    return {
+      host: target.host,
+      ok: false,
+      skipped: false,
+      message: error instanceof Error ? error.message : String(error),
+    }
+  }
+}
+
+export const deployCommand = defineCommand({
+  meta: { name: "deploy", description: "本地构建并部署函数包（扇出到所有机器）" },
+  args: {
+    bundle: { type: "positional", description: "bundle 名（不填则部署全部变更）", required: false },
+    force: { type: "boolean", description: "忽略版本一致检查，强制部署" },
+  },
+  async run({ args }) {
+    intro(pc.cyan("部署函数包"))
+    const ctx = await requireProjectContext()
+
+    const targets = args.bundle ? [args.bundle] : await listLocalBundles(ctx.root)
+    if (targets.length === 0) {
+      log.warn("没有可部署的 bundle")
+      outro(pc.yellow("已结束"))
+      return
+    }
+
+    if (ctx.targets.length > 1) log.info(pc.dim(`目标机器：${ctx.targets.map((t) => t.host).join("、")}`))
+
+    for (const bundle of targets) {
+      const s = spinner()
+      s.start(`构建 ${bundle}`)
+      let artifactPath: string | undefined
+      try {
+        const { manifest, artifactPath: built } = await buildBundle(ctx.root, ctx.project, bundle)
+        artifactPath = built
+
+        s.message(`部署 ${bundle} 到 ${ctx.targets.length} 台机器`)
+        const results = await Promise.all(
+          ctx.targets.map((t) => deployToTarget(t, manifest, built, Boolean(args.force))),
+        )
+
+        const failed = results.filter((r) => !r.ok)
+        const deployed = results.filter((r) => r.ok && !r.skipped).length
+        const skipped = results.filter((r) => r.skipped).length
+
+        if (failed.length === 0) {
+          const detail =
+            skipped > 0 ? `${deployed} 部署 / ${skipped} 无变更` : `${manifest.artifact}:${manifest.version}`
+          s.stop(`${bundle} 完成 ${pc.dim(`(${detail})`)}`)
+        } else {
+          s.stop(pc.red(`${bundle} 部分失败`))
+          for (const f of failed) log.error(`  ${f.host}: ${f.message}`)
+          process.exitCode = 1
+        }
+      } catch (error) {
+        s.stop(pc.red(`${bundle} 构建失败`))
+        log.error(error instanceof Error ? error.message : String(error))
+        process.exitCode = 1
+      } finally {
+        if (artifactPath) await rm(artifactPath, { force: true })
+      }
+    }
+
+    outro(pc.green("部署流程结束"))
+  },
+})

package/src/commands/dev.ts

@@ -0,0 +1,71 @@
+import { rm } from "node:fs/promises"
+import path from "node:path"
+import { intro, log } from "@clack/prompts"
+import { defineCommand } from "citty"
+import pc from "picocolors"
+import { resolveFunctions, writeEntry } from "../build.ts"
+import { BUNDLE_FILE, DEFAULT_DEV_PORT } from "../consts.ts"
+import { loadContext } from "../context.ts"
+import type { BundleConfig } from "../types.ts"
+import { readJson } from "../utils.ts"
+
+export const devCommand = defineCommand({
+  meta: { name: "dev", description: "本地热重载运行函数包" },
+  args: {
+    bundle: { type: "positional", description: "bundle 名", required: true },
+    port: { type: "string", description: `本地端口（默认 ${DEFAULT_DEV_PORT}）` },
+  },
+  async run({ args }) {
+    intro(pc.cyan(`本地运行 ${args.bundle}`))
+    const ctx = await loadContext()
+    if (!ctx) {
+      log.error("未找到 atomfunctions.json")
+      process.exit(1)
+    }
+    const bundleDir = path.join(ctx.root, args.bundle)
+
+    const config = await readJson<BundleConfig>(path.join(bundleDir, BUNDLE_FILE))
+    if (!config) {
+      log.error(`未找到 ${args.bundle}/${BUNDLE_FILE}`)
+      process.exit(1)
+    }
+    if (config.language !== "bun") {
+      log.error(`dev 暂只支持 bun，当前为 ${config.language}`)
+      process.exit(1)
+    }
+
+    const functions = await resolveFunctions(bundleDir, config.defaults)
+    if (functions.length === 0) {
+      log.error("该 bundle 内没有函数")
+      process.exit(1)
+    }
+
+    const port = Number(args.port ?? DEFAULT_DEV_PORT)
+    const entryPath = await writeEntry(bundleDir, functions)
+    log.info(`函数：${functions.map((f) => f.name).join("、")}`)
+    log.info(pc.dim(`http://localhost:${port}/__invoke/<function>`))
+
+    const proc = Bun.spawn(["bun", "--watch", entryPath], {
+      cwd: bundleDir,
+      stdio: ["inherit", "inherit", "inherit"],
+      env: {
+        ...process.env,
+        ...config.env,
+        ATOMFN_PROJECT: ctx.project,
+        ATOMFN_BUNDLE: args.bundle,
+        ATOMFN_PORT: String(port),
+      },
+    })
+
+    const cleanup = async () => {
+      proc.kill()
+      await rm(entryPath, { force: true })
+      process.exit(0)
+    }
+    process.on("SIGINT", cleanup)
+    process.on("SIGTERM", cleanup)
+
+    await proc.exited
+    await rm(entryPath, { force: true })
+  },
+})