@atomservice/functions-cli 0.1.7 → 0.1.8

package/src/commands/deploy.ts

@@ -1,20 +1,78 @@
 import { readdir, rm } from "node:fs/promises"
 import path from "node:path"
-import { intro, log, outro, spinner } from "@clack/prompts"
+import { confirm, intro, isCancel, log, multiselect, outro } from "@clack/prompts"
 import { defineCommand } from "citty"
+import { Listr } from "listr2"
 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"
+import { BUNDLE_FILE, BUNDLES_DIR } from "../consts.ts"
+import { requireProjectContext } from "../context.ts"
+import type { BundleConfig, DeployManifest, Manifest, ServerTarget } from "../types.ts"
+import { bunTarget, readJson } from "../utils.ts"
+
+class Semaphore {
+  private permits: number
+  private queue: Array<() => void> = []
+  constructor(permits: number) {
+    this.permits = permits
+  }
+  async acquire(): Promise<void> {
+    if (this.permits > 0) {
+      this.permits--
+      return
+    }
+    await new Promise<void>((resolve) => this.queue.push(resolve))
+  }
+  release(): void {
+    const next = this.queue.shift()
+    if (next) {
+      next()
+    } else {
+      this.permits++
+    }
+  }
+}
+
+async function resolveDeployTargets(
+  manifest: Manifest,
+  allTargets: ServerTarget[],
+  arg: string | true | undefined,
+): Promise<ServerTarget[]> {
+  if (arg === undefined || arg === true) return allTargets
+  if (arg === "all") return allTargets
+
+  const urls = [manifest.server, ...(manifest.servers ?? [])].filter(Boolean) as string[]
+
+  if (/^\d+$/.test(arg)) {
+    const idx = Number(arg)
+    const url = idx === 0 ? manifest.server : manifest.servers?.[idx - 1]
+    if (!url) throw new Error(`索引 ${arg} 超出范围，可用 0-${manifest.servers?.length ?? 0}`)
+    const match = allTargets.find((t) => t.server === url)
+    if (!match) throw new Error(`服务器 ${url} 未登录，请先执行 atomfunctions login`)
+    return [match]
+  }
+
+  if (arg.includes("://") || arg.includes("localhost")) {
+    const parts = arg.split(",").map((s) => s.trim())
+    const result: ServerTarget[] = []
+    for (const part of parts) {
+      const match = allTargets.find((t) => t.server === part || t.host === part)
+      if (!match) throw new Error(`服务器 ${part} 不在配置中，可用：${urls.join("、")}`)
+      result.push(match)
+    }
+    return result
+  }
+
+  throw new Error(`无法解析 --server 值：${arg}。支持：all、0/1/2（索引）、URL（逗号分隔）`)
+}
 
 async function listLocalBundles(root: string): Promise<string[]> {
-  const entries = await readdir(root, { withFileTypes: true })
+  const entries = await readdir(path.join(root, BUNDLES_DIR), { 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)
+    if (await Bun.file(path.join(root, BUNDLES_DIR, entry.name, BUNDLE_FILE)).exists()) bundles.push(entry.name)
   }
   return bundles.sort()
 }
@@ -30,7 +88,8 @@ async function deployToTarget(
     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 }
+      if (current?.version === manifest.version && current?.arch === manifest.arch)
+        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 }
@@ -45,15 +104,89 @@ async function deployToTarget(
 }
 
 export const deployCommand = defineCommand({
-  meta: { name: "deploy", description: "本地构建并部署函数包（扇出到所有机器）" },
+  meta: { name: "deploy", description: "本地构建并部署函数包" },
   args: {
     bundle: { type: "positional", description: "bundle 名（不填则部署全部变更）", required: false },
     force: { type: "boolean", description: "忽略版本一致检查，强制部署" },
+    target: { type: "string", description: "编译目标架构：x64 | arm64（默认根据服务器自动选择）" },
+    server: { type: "string", description: "部署目标：all（全部）、0/1/2（索引）、URL（逗号分隔）" },
   },
   async run({ args }) {
     intro(pc.cyan("部署函数包"))
     const ctx = await requireProjectContext()
 
+    let deployTargets: ServerTarget[]
+    if (typeof args.server === "string") {
+      deployTargets = await resolveDeployTargets(ctx.manifest, ctx.targets, args.server)
+    } else {
+      const options = ctx.targets.map((t, i) => ({ value: String(i), label: t.host, hint: t.server }))
+      const selected = await multiselect({
+        message: "选择部署目标",
+        options,
+        required: true,
+        initialValues: ctx.targets.map((_, i) => String(i)),
+      })
+      if (isCancel(selected)) {
+        outro(pc.yellow("已取消"))
+        return
+      }
+      deployTargets = (selected as string[]).map((i) => ctx.targets[Number(i)]).filter(Boolean) as ServerTarget[]
+    }
+
+    const force =
+      args.force === true ? true : await confirm({ message: "是否忽略版本一致检查，强制部署？", initialValue: false })
+    if (isCancel(force)) {
+      outro(pc.yellow("已取消"))
+      return
+    }
+
+    const targetArches = new Map<string, string | Error>()
+    await Promise.all(
+      deployTargets.map(async (t) => {
+        try {
+          const client = new AdminClient(t.server, t.token)
+          const health = await client.get<{ arch?: string }>("/health")
+          targetArches.set(t.server, health.arch ?? "x64")
+        } catch (err) {
+          targetArches.set(t.server, err instanceof Error ? err : new Error(String(err)))
+        }
+      }),
+    )
+    const bunSemaphore = new Semaphore(10)
+    const rustSemaphore = new Semaphore(1)
+    const serverSemaphores = new Map<string, Semaphore>()
+
+    const archErrors = deployTargets.filter((t) => targetArches.get(t.server) instanceof Error)
+    if (archErrors.length > 0) {
+      for (const t of archErrors) {
+        log.error(`${t.host}：无法获取服务器架构 — ${(targetArches.get(t.server) as Error).message}`)
+      }
+      outro(pc.red("部署中止"))
+      process.exitCode = 1
+      return
+    }
+
+    if (typeof args.target === "string") {
+      for (const key of targetArches.keys()) targetArches.set(key, args.target)
+    }
+
+    const archGroups = new Map<string, ServerTarget[]>()
+    for (const t of deployTargets) {
+      const arch = targetArches.get(t.server) as string
+      if (!archGroups.has(arch)) archGroups.set(arch, [])
+      const group = archGroups.get(arch) ?? []
+      group.push(t)
+      archGroups.set(arch, group)
+    }
+
+    const uniqueArches = [...archGroups.keys()]
+    if (uniqueArches.length === 1) {
+      log.info(pc.dim(`编译目标：${uniqueArches[0]}${!args.target ? "（服务器自动检测）" : ""}`))
+    } else {
+      log.info(pc.dim(`多架构部署：${uniqueArches.join("、")}`))
+    }
+    log.info(pc.dim(`目标机器：${deployTargets.map((t) => t.host).join("、")}`))
+
     const targets = args.bundle ? [args.bundle] : await listLocalBundles(ctx.root)
     if (targets.length === 0) {
       log.warn("没有可部署的 bundle")
@@ -61,43 +194,145 @@ export const deployCommand = defineCommand({
       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 })
+    type DeployTask = { bundle: string; target: ServerTarget; arch: string }
+
+    const deployTasks: DeployTask[] = targets.flatMap((bundle) =>
+      [...archGroups].flatMap(([arch, archTargets]) => archTargets.map((t) => ({ bundle, target: t, arch }))),
+    )
+
+    type DeployLine = {
+      bundle: string
+      host: string
+      ok: boolean
+      skipped: boolean
+      message?: string
+    }
+    const deployLines: DeployLine[] = []
+    let hasError = false
+
+    const buildCache = new Map<string, Promise<{ manifest: DeployManifest; artifactPath: string }>>()
+    const buildRefs = new Map<string, number>()
+    const configCache = new Map<string, BundleConfig>()
+
+    console.log("")
+
+    const listr = new Listr(
+      deployTasks.map(({ bundle, target, arch }) => ({
+        title: bundle,
+        task: async (_ctx, task) => {
+          const config =
+            configCache.get(bundle) ??
+            (await readJson<BundleConfig>(path.join(ctx.root, BUNDLES_DIR, bundle, BUNDLE_FILE)))
+          if (!config) throw new Error(`${bundle} 缺少 ${BUNDLE_FILE}`)
+          configCache.set(bundle, config)
+          const isRust = config?.language === "rust"
+          const isBun = config?.language === "bun"
+          const buildKey = `${bundle}-${arch}`
+          let semReleased = false
+
+          try {
+            if (isRust) {
+              task.title = `  ${bundle}  ${target.host} (${arch})  等待构建...`
+              await rustSemaphore.acquire()
+            } else if (isBun) {
+              await bunSemaphore.acquire()
+            }
+
+            task.title = `  ${bundle}  ${target.host} (${arch})  构建中...`
+
+            if (!buildCache.has(buildKey)) {
+              buildCache.set(buildKey, buildBundle(ctx.root, ctx.project, bundle, bunTarget(arch), arch))
+            }
+            buildRefs.set(buildKey, (buildRefs.get(buildKey) ?? 0) + 1)
+            const cached = buildCache.get(buildKey)
+            if (!cached) throw new Error("构建缓存异常")
+            const { manifest, artifactPath } = await cached
+            const versionLabel = pc.dim(`${manifest.artifact}:${manifest.version}`)
+
+            if (isRust) rustSemaphore.release()
+            else if (isBun) bunSemaphore.release()
+            semReleased = true
+
+            try {
+              const sem = serverSemaphores.get(target.server) ?? new Semaphore(1)
+              serverSemaphores.set(target.server, sem)
+              task.title = `  ${bundle}  ${target.host} (${arch})  部署中...  ${versionLabel}`
+              await sem.acquire()
+              try {
+                const r = await deployToTarget(target, manifest, artifactPath, force)
+                if (r.skipped) {
+                  task.title = `  ${bundle}  ${target.host} (${arch})  ${pc.dim("无变更")}  ${versionLabel}`
+                } else if (r.ok) {
+                  task.title = `  ${bundle}  ${target.host} (${arch})  ${pc.green("已部署")}  ${versionLabel}`
+                } else {
+                  task.title = `  ${bundle}  ${target.host} (${arch})  ${pc.red(r.message ?? "失败")}  ${versionLabel}`
+                  hasError = true
+                }
+                deployLines.push({ bundle, host: target.host, ok: r.ok, skipped: r.skipped, message: r.message })
+                if (!r.ok && !r.skipped) hasError = true
+              } finally {
+                sem.release()
+              }
+            } finally {
+              const refs = (buildRefs.get(buildKey) ?? 1) - 1
+              if (refs <= 0) {
+                buildRefs.delete(buildKey)
+                await rm(artifactPath, { force: true })
+              } else {
+                buildRefs.set(buildKey, refs)
+              }
+            }
+          } catch (error) {
+            if (!semReleased) {
+              if (isRust) rustSemaphore.release()
+              else if (isBun) bunSemaphore.release()
+            }
+            task.title = `  ${bundle}  ${target.host} (${arch})  ${pc.red((error as Error).message.slice(0, 100))}`
+            hasError = true
+            throw error
+          }
+        },
+      })),
+      {
+        concurrent: true,
+        exitOnError: false,
+        rendererOptions: { collapseErrors: false },
+      },
+    )
+
+    await listr.run().catch(() => {})
+
+    let totalOk = 0
+    let totalFail = 0
+    let totalSkip = 0
+    const serverSet = new Set<string>()
+
+    for (const line of deployLines) {
+      serverSet.add(line.host)
+      if (line.skipped) {
+        totalSkip++
+      } else if (line.ok) {
+        totalOk++
+      } else {
+        totalFail++
       }
     }
 
+    const total = totalOk + totalFail + totalSkip
+    if (total > 0) {
+      const parts: string[] = []
+      if (totalOk > 0) parts.push(pc.green(`${totalOk} 成功`))
+      if (totalFail > 0) parts.push(pc.red(`${totalFail} 失败`))
+      if (totalSkip > 0) parts.push(pc.dim(`${totalSkip} 跳过`))
+      const bundleCount = new Set(deployLines.map((l) => l.bundle)).size
+      const msg = `${pc.bold("部署结果")}  ${bundleCount} 个 bundle → ${serverSet.size} 台服务器，${parts.join("，")}，共 ${total} 次部署`
+      if (totalFail === total) log.error(msg)
+      else if (totalFail > 0) log.warn(msg)
+      else log.success(msg)
+    }
+
+    if (hasError) process.exitCode = 1
+
     outro(pc.green("部署流程结束"))
   },
 })

package/src/commands/dev.ts

@@ -64,7 +64,7 @@ const startCommand = defineCommand({
     } else {
       const bundles = await listBundles(ctx.root)
       if (bundles.length === 0) {
-        log.error("尚未创建任何 bundle，请先运行 atomfn bundle create")
+        log.error("尚未创建任何 bundle，请先运行 atomfunctions bundle create")
         process.exit(1)
       }
       bundle = unwrap(await select({ message: "选择函数包", options: bundles.map((b) => ({ value: b, label: b })) })) as string

package/src/commands/function.ts

@@ -8,7 +8,7 @@ import { BUNDLE_FILE, BUNDLES_DIR } from "../consts.ts"
 import { loadContext } from "../context.ts"
 import { scaffoldFunction } from "../scaffold.ts"
 import type { BundleConfig, FunctionKind } from "../types.ts"
-import { isValidSlug, readJson, unwrap } from "../utils.ts"
+import { readJson, unwrap } from "../utils.ts"
 
 async function listBundles(root: string): Promise<string[]> {
   const dir = path.join(root, BUNDLES_DIR)
@@ -65,7 +65,7 @@ const createCommand = defineCommand({
     } else {
       const bundles = await listBundles(ctx.root)
       if (bundles.length === 0) {
-        log.error("尚未创建任何 bundle，请先运行 atomfn bundle create")
+        log.error("尚未创建任何 bundle，请先运行 atomfunctions bundle create")
         process.exit(1)
       }
       bundle = unwrap(
@@ -76,6 +76,17 @@ const createCommand = defineCommand({
       ) as string
     }
 
+    const bundleDir = path.join(ctx.root, BUNDLES_DIR, bundle)
+    const bundleCfg = await readJson<BundleConfig>(path.join(bundleDir, BUNDLE_FILE))
+    if (!bundleCfg) {
+      log.error(`bundle ${bundle} 不存在或不是有效的函数包`)
+      process.exit(1)
+    }
+    const language = bundleCfg.language
+    const isRust = language === "rust"
+    const slugRe = /^[a-z][a-z0-9-]*$/
+    const slugHint = "需以小写字母开头，仅含小写字母、数字、连字符"
+
     const slug =
       args.slug ??
       unwrap(
@@ -84,13 +95,13 @@ const createCommand = defineCommand({
           validate: (v) => {
             const s = v?.trim()
             if (!s) return "请输入函数名"
-            return isValidSlug(s) ? undefined : "需以小写字母开头，仅含小写字母、数字、连字符"
+            return slugRe.test(s) ? undefined : slugHint
           },
         }),
       ).trim()
 
-    if (!isValidSlug(slug)) {
-      log.error("函数名需以小写字母开头，仅含小写字母、数字、连字符")
+    if (!slugRe.test(slug)) {
+      log.error(slugHint)
       process.exit(1)
     }
 
@@ -105,16 +116,20 @@ const createCommand = defineCommand({
             }),
           ) as FunctionKind)
 
-    const bundleDir = path.join(ctx.root, BUNDLES_DIR, bundle)
-    const fnDir = path.join(bundleDir, slug)
-    if (await Bun.file(path.join(fnDir, "function.ts")).exists()) {
+    let exists = false
+    if (isRust) {
+      exists = await Bun.file(path.join(bundleDir, "src", "functions", slug, "function.rs")).exists()
+    } else {
+      exists = await Bun.file(path.join(bundleDir, slug, "function.ts")).exists()
+    }
+    if (exists) {
       const ok = await confirm({ message: `函数 ${bundle}/${slug} 已存在，是否覆盖？`, initialValue: false })
       if (isCancel(ok) || !ok) {
         outro(pc.yellow("已取消"))
         return
       }
     }
-    await scaffoldFunction(bundleDir, slug, "bun", kind)
+    await scaffoldFunction(bundleDir, slug, language, kind)
     log.success(`已创建${KIND_OPTIONS.find((k) => k.value === kind)?.label}函数 ${bundle}/${slug}`)
     outro(pc.green("完成，运行 atomfunctions deploy 进行部署"))
   },

package/src/commands/init.ts

@@ -103,6 +103,7 @@ export const initCommand = defineCommand({
     }
 
     const manifest: Manifest = {
+      ...existing,
       $schema: `./${SCHEMAS_DIR}/${MANIFEST_SCHEMA_FILE}`,
       server,
       ...(slug ? { project: { slug } } : {}),