@atomservice/functions-cli 0.1.6 → 0.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomservice/functions-cli",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "函数服务命令行工具（atomfunctions）：项目脚手架、本地构建、部署、运维",
   "type": "module",
   "author": "openorson",
@@ -30,9 +30,11 @@
     "atomfn": "./bin/functions.ts"
   },
   "dependencies": {
-    "@atomservice/functions-sdk": "0.1.6",
+    "@atomservice/functions-sdk": "0.1.8",
     "@clack/prompts": "1.5.0",
+    "change-case": "5.4.4",
     "citty": "0.2.2",
+    "listr2": "10.2.1",
     "picocolors": "1.1.1",
     "typebox": "1.2.2"
   },

package/src/build.ts

@@ -1,10 +1,24 @@
-import { readdir, rm } from "node:fs/promises"
+import { chmod, 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 { BUNDLE_FILE, ENTRY_FILE, FUNCTION_CONFIG_FILE, FUNCTION_FILE, SDK_PACKAGE } from "./consts.ts"
 import type { BundleConfig, DeployManifest, FunctionFileConfig } from "./types.ts"
 import { readJson } from "./utils.ts"
 
+async function spawnQuiet(cmd: string[], timeoutMs: number): Promise<{ exitCode: number; stderr: string }> {
+  const proc = Bun.spawn(cmd, { stdout: "ignore", stderr: "pipe" })
+  const timer = setTimeout(() => proc.kill(), timeoutMs)
+  try {
+    const exitCode = await proc.exited
+    clearTimeout(timer)
+    const stderr = await new Response(proc.stderr).text()
+    return { exitCode, stderr }
+  } catch (err) {
+    clearTimeout(timer)
+    throw err
+  }
+}
+
 export interface BuildResult {
   manifest: DeployManifest
   artifactPath: string
@@ -81,11 +95,11 @@ export async function writeEntry(bundleDir: string, functions: ResolvedFunction[
   return entryPath
 }
 
-async function compileBinary(bundleDir: string, functions: ResolvedFunction[]): Promise<string> {
+async function compileBinary(bundleDir: string, functions: ResolvedFunction[], target: string): 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}`
+    const result = await $`bun build --compile --minify --target=${target} ${entryPath} --outfile ${outPath}`
       .cwd(bundleDir)
       .quiet()
       .nothrow()
@@ -98,7 +112,7 @@ async function compileBinary(bundleDir: string, functions: ResolvedFunction[]):
 
 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()
+  const build = await $`podman build --pull=missing -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")
@@ -112,9 +126,10 @@ async function buildImage(
   project: string,
   bundle: string,
   version: string,
+  arch: string,
   binaryPath: string,
 ): Promise<string> {
-  const image = `localhost/atomfn/${project}-${bundle}:${version}`
+  const image = `localhost/atomfn/${project}-${bundle}:${version}-${arch}`
   const stagedBinary = path.join(bundleDir, "bundle")
   await Bun.write(stagedBinary, Bun.file(binaryPath))
   try {
@@ -145,45 +160,192 @@ async function hashTree(dir: string): Promise<string> {
   return hasher.digest("hex").slice(0, 16)
 }
 
+async function parseRustFunctions(bundleDir: string): Promise<string[]> {
+  const mainPath = path.join(bundleDir, "src", "main.rs")
+  if (!(await Bun.file(mainPath).exists())) return []
+
+  const source = await Bun.file(mainPath).text()
+  const macroMatch = source.match(/serve!\s*\{([^}]*)\}/)
+  if (!macroMatch) return []
+
+  const body = macroMatch[1] ?? ""
+  const functions: string[] = []
+  const entryRegex = /(stream\s+)?([a-z][a-z0-9_]*)/g
+  for (let match = entryRegex.exec(body); match !== null; match = entryRegex.exec(body)) {
+    const name = match[2]
+    if (name) functions.push(name)
+  }
+  return functions.sort()
+}
+
+async function generateRustConfig(
+  bundleDir: string,
+  functions: string[],
+  defaults: FunctionFileConfig = {},
+): Promise<void> {
+  const config: Record<string, FunctionFileConfig> = {}
+  for (const fn of functions) {
+    const fnConfigPath = path.join(bundleDir, "src", "functions", fn, FUNCTION_CONFIG_FILE)
+    const fnConfig = await readJson<FunctionFileConfig>(fnConfigPath)
+    config[fn] = { ...defaults, ...(fnConfig ?? {}) }
+  }
+  const configPath = path.join(bundleDir, "functions.config.json")
+  await Bun.write(configPath, JSON.stringify({ functions: config }, null, 2))
+}
+
+async function podmanMachineArch(): Promise<string> {
+  try {
+    const proc = Bun.spawn(["podman", "info", "--format", "{{.Host.Arch}}"], { stdout: "pipe", stderr: "ignore" })
+    await proc.exited
+    const out = (await new Response(proc.stdout).text()).trim()
+    return out === "amd64" ? "x64" : out // normalize amd64→x64
+  } catch {
+    return "x64"
+  }
+}
+
+async function buildRustBinary(bundleDir: string, bundle: string, arch: string): Promise<string> {
+  const outPath = path.join(bundleDir, ".atomfn-bundle")
+  const machineArch = await podmanMachineArch()
+
+  let cmd: string[]
+  let binaryRelPath: string
+
+  if (machineArch === arch) {
+    // podman machine 与目标架构相同，原生编译
+    cmd = [
+      "podman",
+      "run",
+      "--rm",
+      "--pull=missing",
+      "-v",
+      `${bundleDir}:/build:Z`,
+      "-e",
+      "CARGO_TARGET_DIR=/build/target",
+      "-w",
+      "/build",
+      "rust:1-slim-bookworm",
+      "cargo",
+      "build",
+      "--release",
+    ]
+    binaryRelPath = path.join("target", "release", bundle)
+  } else {
+    // 跨架构编译，使用交叉编译工具链（避免 QEMU）
+    const rustTarget = arch === "arm64" ? "aarch64-unknown-linux-gnu" : "x86_64-unknown-linux-gnu"
+    const aptPackage = arch === "arm64" ? "gcc-aarch64-linux-gnu" : "gcc-x86-64-linux-gnu"
+    const linker = arch === "arm64" ? "aarch64-linux-gnu-gcc" : "x86_64-linux-gnu-gcc"
+    const linkerEnvKey =
+      arch === "arm64"
+        ? "CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER"
+        : "CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_LINKER"
+    cmd = [
+      "podman",
+      "run",
+      "--rm",
+      "--pull=missing",
+      "-v",
+      `${bundleDir}:/build:Z`,
+      "-e",
+      "CARGO_TARGET_DIR=/build/target",
+      "-e",
+      `${linkerEnvKey}=${linker}`,
+      "-w",
+      "/build",
+      "rust:1-slim-bookworm",
+      "sh",
+      "-c",
+      `apt-get update -qq && apt-get install -y -q ${aptPackage} && cargo build --target ${rustTarget} --release`,
+    ]
+    binaryRelPath = path.join("target", rustTarget, "release", bundle)
+  }
+
+  const result = await spawnQuiet(cmd, 600_000)
+
+  if (result.exitCode !== 0) {
+    throw new Error(`Rust 编译失败（${arch}）：${result.stderr.slice(-500)}`)
+  }
+
+  const binaryPath = path.join(bundleDir, binaryRelPath)
+  await Bun.write(outPath, Bun.file(binaryPath))
+  await chmod(outPath, 0o755)
+  return outPath
+}
+
 async function buildRustBundle(
   root: string,
   project: string,
   bundle: string,
   config: BundleConfig,
+  arch: string,
 ): Promise<BuildResult> {
-  const bundleDir = path.join(root, bundle)
-  const functions = config.functions ?? []
+  const bundleDir = path.join(root, "bundles", bundle)
+  const functions = await parseRustFunctions(bundleDir)
   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`)
+    throw new Error(`rust bundle ${bundle} 的 src/main.rs 中没有找到 serve! 宏声明`)
   }
+
+  await generateRustConfig(bundleDir, functions, config.defaults)
   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,
+
+  const hasContainerfile = await Bun.file(path.join(bundleDir, "Containerfile")).exists()
+
+  if (!hasContainerfile) {
+    const binaryPath = await buildRustBinary(bundleDir, bundle, arch)
+    return {
+      manifest: {
+        project,
+        bundle,
+        arch,
+        version,
+        artifact: "binary",
+        functions,
+        memory: config.memory,
+        cpus: config.cpus,
+        maxConcurrency: config.maxConcurrency,
+        env: config.env,
+      },
+      artifactPath: binaryPath,
+    }
+  }
+
+  // 有 Containerfile：与 bun 流程对齐——先交叉编译 binary，再用 Containerfile 打包运行时镜像
+  const binaryPath = await buildRustBinary(bundleDir, bundle, arch)
+  try {
+    const image = `localhost/atomfn/${project}-${bundle}:${version}-${arch}`
+    const tarPath = await buildImage(bundleDir, project, bundle, version, arch, binaryPath)
+    return {
+      manifest: {
+        project,
+        bundle,
+        arch,
+        version,
+        artifact: "image",
+        functions,
+        image,
+        memory: config.memory,
+        cpus: config.cpus,
+        maxConcurrency: config.maxConcurrency,
+        env: config.env,
+      },
+      artifactPath: tarPath,
+    }
+  } finally {
+    await rm(binaryPath, { force: true })
   }
 }
 
-export async function buildBundle(root: string, project: string, bundle: string): Promise<BuildResult> {
-  const bundleDir = path.join(root, bundle)
+export async function buildBundle(
+  root: string,
+  project: string,
+  bundle: string,
+  target: string,
+  arch: string,
+): Promise<BuildResult> {
+  const bundleDir = path.join(root, "bundles", 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 === "rust") return buildRustBundle(root, project, bundle, config, arch)
   if (config.language !== "bun") throw new Error(`暂不支持的语言：${config.language}`)
 
   const functions = await resolveFunctions(bundleDir, config.defaults)
@@ -195,18 +357,20 @@ export async function buildBundle(root: string, project: string, bundle: string)
   const hasContainerfile = await Bun.file(path.join(bundleDir, "Containerfile")).exists()
 
   if (hasContainerfile) {
-    const binaryPath = await compileBinary(bundleDir, functions)
+    const binaryPath = await compileBinary(bundleDir, functions, target)
     try {
-      const tarPath = await buildImage(bundleDir, project, bundle, version, binaryPath)
+      const image = `localhost/atomfn/${project}-${bundle}:${version}-${arch}`
+      const tarPath = await buildImage(bundleDir, project, bundle, version, arch, binaryPath)
       return {
         manifest: {
           project,
           bundle,
+          arch,
           version,
           artifact: "image",
           functions: names,
           asyncFunctions: asyncFunctions.length ? asyncFunctions : undefined,
-          image: `localhost/atomfn/${project}-${bundle}:${version}`,
+          image,
           memory: config.memory,
           cpus: config.cpus,
           maxConcurrency: config.maxConcurrency,
@@ -219,11 +383,12 @@ export async function buildBundle(root: string, project: string, bundle: string)
     }
   }
 
-  const binaryPath = await compileBinary(bundleDir, functions)
+  const binaryPath = await compileBinary(bundleDir, functions, target)
   return {
     manifest: {
       project,
       bundle,
+      arch,
       version,
       artifact: "binary",
       functions: names,

package/src/client.ts

@@ -55,10 +55,10 @@ export class AdminClient {
   }
 
   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 })
+    const data = await this.send<{ bundle: BundleRecord }>("POST", `/projects/${project}/bundles`, {
+      headers: { "x-atomfn-manifest": JSON.stringify(manifest), "content-type": "application/octet-stream" },
+      body: artifact,
+    })
     return data.bundle
   }
 

package/src/commands/bundle.ts

@@ -1,10 +1,11 @@
 import path from "node:path"
+import { $ } from "bun"
 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 { scaffoldBundle, scaffoldContainerfile } from "../scaffold.ts"
 import type { BundleConfig, Language } from "../types.ts"
 import { isValidSlug, readJson, unwrap } from "../utils.ts"
 
@@ -13,6 +14,7 @@ const createCommand = defineCommand({
   args: {
     slug: { type: "positional", required: false, description: "bundle 名" },
     lang: { type: "string", description: "语言：bun（默认）" },
+    "with-containerfile": { type: "boolean", description: "生成逃生舱 Containerfile 模板" },
   },
   async run({ args }) {
     intro(pc.cyan("创建函数包"))
@@ -66,6 +68,28 @@ const createCommand = defineCommand({
 
     await scaffoldBundle(bundleDir, { language })
     log.success(`已创建 bundle ${slug}`)
+
+    const withContainerfile =
+      args["with-containerfile"] === true ||
+      (await confirm({ message: "是否生成 Containerfile 模板？", initialValue: false }))
+    if (!isCancel(withContainerfile) && withContainerfile) {
+      await scaffoldContainerfile(bundleDir)
+      log.success("已生成 Containerfile")
+    }
+
+    if (language === "bun") {
+      const install = await confirm({ message: "是否安装依赖包？", initialValue: true })
+      if (!isCancel(install) && install) {
+        log.info("正在安装依赖...")
+        const result = await $`bun install`.cwd(bundleDir).quiet().nothrow()
+        if (result.exitCode === 0) {
+          log.success("依赖安装完成")
+        } else {
+          log.warn("依赖安装失败，请稍后手动执行 bun install")
+        }
+      }
+    }
+
     outro(pc.green(`完成，路径 ${path.relative(ctx.root, bundleDir)}`))
   },
 })