@atomservice/functions-cli 0.1.6

package/src/commands/function.ts

@@ -0,0 +1,126 @@
+import type { Dirent } from "node:fs"
+import { readdirSync } from "node:fs"
+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 { scaffoldFunction } from "../scaffold.ts"
+import type { BundleConfig, FunctionKind } from "../types.ts"
+import { isValidSlug, readJson, unwrap } from "../utils.ts"
+
+async function listBundles(root: string): Promise<string[]> {
+  const dir = path.join(root, BUNDLES_DIR)
+  let entries: Dirent[]
+  try {
+    entries = readdirSync(dir, { withFileTypes: true }) as unknown as Dirent[]
+  } catch {
+    return []
+  }
+  return entries
+    .filter((e) => e.isDirectory() && !e.name.startsWith("."))
+    .filter((e) => {
+      try {
+        return Bun.file(path.join(dir, e.name, BUNDLE_FILE)).size > 0
+      } catch {
+        return false
+      }
+    })
+    .map((e) => e.name)
+    .sort()
+}
+
+const KIND_OPTIONS: { value: FunctionKind; label: string; hint: string }[] = [
+  { value: "function", label: "function", hint: "同步请求-响应" },
+  { value: "streamFunction", label: "streamFunction", hint: "同步流式" },
+  { value: "asyncFunction", label: "asyncFunction", hint: "异步入队，请求-响应" },
+  { value: "asyncStreamFunction", label: "asyncStreamFunction", hint: "异步入队，流式" },
+]
+
+const createCommand = defineCommand({
+  meta: { name: "create", description: "在函数包下创建函数" },
+  args: {
+    slug: { type: "positional", required: false, description: "函数名" },
+    bundle: { type: "string", description: "指定 bundle 名（跳过交互选择）" },
+    kind: { type: "string", description: "函数类型：function / streamFunction / asyncFunction / asyncStreamFunction" },
+  },
+  async run({ args }) {
+    intro(pc.cyan("创建函数"))
+    const ctx = await loadContext()
+    if (!ctx) {
+      log.error("未找到 atomfunctions.json")
+      process.exit(1)
+    }
+
+    let bundle: string
+    if (typeof args.bundle === "string") {
+      bundle = args.bundle
+      const bundleDir = path.join(ctx.root, BUNDLES_DIR, bundle)
+      const cfg = await readJson<BundleConfig>(path.join(bundleDir, BUNDLE_FILE))
+      if (!cfg) {
+        log.error(`bundle ${bundle} 不存在或不是有效的函数包`)
+        process.exit(1)
+      }
+    } else {
+      const bundles = await listBundles(ctx.root)
+      if (bundles.length === 0) {
+        log.error("尚未创建任何 bundle，请先运行 atomfn bundle create")
+        process.exit(1)
+      }
+      bundle = unwrap(
+        await select({
+          message: "选择函数包",
+          options: bundles.map((b) => ({ value: b, label: b })),
+        }),
+      ) as string
+    }
+
+    const slug =
+      args.slug ??
+      unwrap(
+        await text({
+          message: "函数名",
+          validate: (v) => {
+            const s = v?.trim()
+            if (!s) return "请输入函数名"
+            return isValidSlug(s) ? undefined : "需以小写字母开头，仅含小写字母、数字、连字符"
+          },
+        }),
+      ).trim()
+
+    if (!isValidSlug(slug)) {
+      log.error("函数名需以小写字母开头，仅含小写字母、数字、连字符")
+      process.exit(1)
+    }
+
+    const kind: FunctionKind =
+      typeof args.kind === "string"
+        ? (args.kind as FunctionKind)
+        : (unwrap(
+            await select({
+              message: "选择函数类型",
+              options: KIND_OPTIONS,
+              initialValue: "function",
+            }),
+          ) 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()) {
+      const ok = await confirm({ message: `函数 ${bundle}/${slug} 已存在，是否覆盖？`, initialValue: false })
+      if (isCancel(ok) || !ok) {
+        outro(pc.yellow("已取消"))
+        return
+      }
+    }
+    await scaffoldFunction(bundleDir, slug, "bun", kind)
+    log.success(`已创建${KIND_OPTIONS.find((k) => k.value === kind)?.label}函数 ${bundle}/${slug}`)
+    outro(pc.green("完成，运行 atomfunctions deploy 进行部署"))
+  },
+})
+
+export const functionCommand = defineCommand({
+  meta: { name: "function", description: "管理函数" },
+  subCommands: { create: createCommand },
+})

package/src/commands/init.ts

@@ -0,0 +1,122 @@
+import path from "node:path"
+import { intro, log, outro, select, text } from "@clack/prompts"
+import { defineCommand } from "citty"
+import pc from "picocolors"
+import { AdminClient } from "../client.ts"
+import {
+  GITIGNORE_BODY,
+  LOCAL_DIR,
+  MANIFEST_FILE,
+  MANIFEST_SCHEMA,
+  MANIFEST_SCHEMA_FILE,
+  REMOTE_DIR,
+  SCHEMAS_DIR,
+  VIEWS_DIR,
+} from "../consts.ts"
+import { getCredential } from "../creds.ts"
+import type { Manifest } from "../types.ts"
+import { ensureDir, hostOf, isValidSlug, readJson, unwrap, writeJson } from "../utils.ts"
+
+export const initCommand = defineCommand({
+  meta: { name: "init", description: "在当前目录初始化函数项目" },
+  args: {
+    server: { type: "string", description: "控制面服务器地址" },
+    project: { type: "string", description: "项目标识 slug（可选）" },
+  },
+  async run({ args }) {
+    intro(pc.cyan("初始化函数项目"))
+    const root = process.cwd()
+    const existing = await readJson<Manifest>(path.join(root, MANIFEST_FILE))
+
+    const server = (
+      args.server ??
+      unwrap(
+        await text({
+          message: "控制面服务器地址",
+          initialValue: existing?.server ?? "",
+          placeholder: "https://fn.example.com",
+          validate: (v) => {
+            const s = v?.trim()
+            if (!s) return "请输入服务器地址"
+            try {
+              new URL(s)
+            } catch {
+              return "请输入合法的 URL"
+            }
+          },
+        }),
+      )
+    ).trim()
+
+    if (args.server) {
+      try {
+        new URL(server)
+      } catch {
+        log.error("--server 不是合法的 URL")
+        process.exit(1)
+      }
+    }
+
+    let slug: string | undefined
+
+    if (args.project) {
+      if (!isValidSlug(args.project)) {
+        log.error("项目标识需以小写字母开头，仅含小写字母、数字、连字符")
+        process.exit(1)
+      }
+      slug = args.project
+    } else {
+      const host = hostOf(server)
+      const cred = await getCredential(host)
+      if (cred) {
+        const client = new AdminClient(server, cred.token)
+        try {
+          const { projects } = await client.get<{ projects: { slug: string; name: string }[] }>("/projects")
+          if (projects.length > 0) {
+            const options = [
+              ...projects.map((p) => ({ value: p.slug, label: p.slug, hint: p.name })),
+              { value: "__skip__", label: "暂不绑定项目" },
+            ]
+            const chosen = unwrap(await select({ message: "绑定项目", options })) as string
+            if (chosen !== "__skip__") slug = chosen
+          } else {
+            log.info("服务器上暂无项目可供绑定")
+          }
+        } catch {
+          log.warn("无法获取项目列表，跳过项目绑定")
+        }
+      } else {
+        const input = unwrap(
+          await text({
+            message: "项目标识（尚未创建项目可留空）",
+            initialValue: existing?.project?.slug ?? "",
+            placeholder: "留空",
+            validate: (v) => {
+              const s = v?.trim()
+              if (!s) return undefined
+              return isValidSlug(s) ? undefined : "需以小写字母开头，仅含小写字母、数字、连字符"
+            },
+          }),
+        ).trim()
+        if (input) slug = input
+      }
+    }
+
+    const manifest: Manifest = {
+      $schema: `./${SCHEMAS_DIR}/${MANIFEST_SCHEMA_FILE}`,
+      server,
+      ...(slug ? { project: { slug } } : {}),
+    }
+    await writeJson(path.join(root, MANIFEST_FILE), manifest)
+    ensureDir(path.join(root, SCHEMAS_DIR))
+    await Bun.write(path.join(root, SCHEMAS_DIR, MANIFEST_SCHEMA_FILE), MANIFEST_SCHEMA)
+    await Bun.write(path.join(root, ".gitignore"), GITIGNORE_BODY)
+    for (const sub of [`${LOCAL_DIR}/project`, REMOTE_DIR, VIEWS_DIR]) {
+      ensureDir(path.join(root, sub))
+    }
+
+    outro(
+      slug ? pc.green(`完成，已绑定项目 ${slug}`) : pc.green("完成，可通过 atomfunctions project link <slug> 绑定项目"),
+    )
+  },
+})

package/src/commands/invoke.ts

@@ -0,0 +1,40 @@
+import { intro, log, outro } from "@clack/prompts"
+import { defineCommand } from "citty"
+import pc from "picocolors"
+import { pickTarget, requireProjectContext } from "../context.ts"
+import { parseRef } from "../utils.ts"
+
+export const invokeCommand = defineCommand({
+  meta: { name: "invoke", description: "调用函数（调试用）" },
+  args: {
+    ref: { type: "positional", description: "<bundle>/<function>", required: true },
+    server: { type: "string", description: "指定机器（默认首台）" },
+    data: { type: "string", description: "JSON 请求体（不填则从 stdin 读取）" },
+  },
+  async run({ args }) {
+    const { bundle, fn } = parseRef(args.ref)
+    if (!fn) {
+      log.error("请使用 <bundle>/<function> 格式")
+      process.exit(1)
+    }
+
+    intro(pc.cyan(`调用 ${bundle}/${fn}`))
+    const ctx = await requireProjectContext()
+    const target = pickTarget(ctx, args.server)
+
+    const body = args.data ?? ((await Bun.stdin.text()) || "{}")
+    const url = `${target.server.replace(/\/+$/, "")}/${ctx.project}/${bundle}/${fn}`
+
+    let res: Response
+    try {
+      res = await fetch(url, { method: "POST", headers: { "content-type": "application/json" }, body })
+    } catch {
+      log.error(`无法连接到 ${url}`)
+      process.exit(1)
+    }
+
+    const text = await res.text()
+    process.stdout.write(`${text}\n`)
+    outro(res.ok ? pc.green(`HTTP ${res.status}`) : pc.red(`HTTP ${res.status}`))
+  },
+})

package/src/commands/list.ts

@@ -0,0 +1,32 @@
+import { intro, log, outro } from "@clack/prompts"
+import { defineCommand } from "citty"
+import pc from "picocolors"
+import { AdminClient } from "../client.ts"
+import { pickTarget, requireProjectContext } from "../context.ts"
+
+export const listCommand = defineCommand({
+  meta: { name: "list", description: "列出已部署的函数包" },
+  args: {
+    server: { type: "string", description: "指定查询的机器（默认首台）" },
+  },
+  async run({ args }) {
+    intro(pc.cyan("已部署函数包"))
+    const ctx = await requireProjectContext()
+    const target = pickTarget(ctx, args.server)
+    const client = new AdminClient(target.server, target.token)
+    const bundles = await client.list(ctx.project)
+
+    if (bundles.length === 0) {
+      log.warn("当前项目暂无已部署的函数包")
+      outro(pc.yellow("已结束"))
+      return
+    }
+
+    for (const b of bundles) {
+      log.info(
+        `${pc.bold(`${b.project}/${b.bundle}`)} ${pc.dim(`${b.artifact}:${b.version}`)}\n  函数：${b.functions.join("、")}`,
+      )
+    }
+    outro(pc.green(`共 ${bundles.length} 个函数包`))
+  },
+})

package/src/commands/login.ts

@@ -0,0 +1,105 @@
+import path from "node:path"
+import { intro, log, outro, password as passwordPrompt, spinner, text } from "@clack/prompts"
+import { defineCommand } from "citty"
+import pc from "picocolors"
+import { MANIFEST_FILE } from "../consts.ts"
+import { getSavedPassword, savePassword, setCredential } from "../creds.ts"
+import type { Manifest } from "../types.ts"
+import { hostOf, readJson, unwrap } from "../utils.ts"
+
+export const loginCommand = defineCommand({
+  meta: { name: "login", description: "登录控制面" },
+  args: {
+    server: { type: "string", description: "服务器地址（默认读取 atomfunctions.json）" },
+    account: { type: "string", description: "邮箱或用户名" },
+    password: { type: "string", description: "密码" },
+  },
+  async run({ args }) {
+    intro(pc.cyan("atomfunctions 登录"))
+    const root = process.cwd()
+    const manifest = await readJson<Manifest>(path.join(root, MANIFEST_FILE))
+    let server = args.server ?? manifest?.server
+    if (!server) {
+      server = unwrap(
+        await text({
+          message: "控制面服务器地址",
+          placeholder: "http://localhost:4922",
+          validate: (v) => (v?.trim() ? undefined : "请输入服务器地址"),
+        }),
+      ).trim()
+    } else {
+      server = server.trim()
+    }
+
+    try {
+      new URL(server)
+    } catch {
+      log.error("请输入合法的 URL")
+      process.exit(1)
+    }
+
+    const host = hostOf(server)
+    const baseUrl = server.replace(/\/+$/, "")
+    const savedPassword = await getSavedPassword(host)
+
+    const account = args.account
+      ? args.account
+      : unwrap(
+          await text({
+            message: "账号（用户名或邮箱）",
+            validate: (v) => (v?.trim() ? undefined : "请输入账号"),
+          }),
+        ).trim()
+
+    async function attemptLogin(pw: string) {
+      const res = await fetch(`${baseUrl}/v1/auth/login`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ account, password: pw }),
+      })
+      if (!res.ok) {
+        const body = (await res.json().catch(() => ({}))) as { error?: { message?: string } }
+        throw new Error(body.error?.message ?? `登录失败（${res.status}）`)
+      }
+      return (await res.json()) as { token: string; user: { email: string; name: string } }
+    }
+
+    const spin = spinner()
+
+    if (!args.password && savedPassword) {
+      spin.start("使用已保存的密码登录")
+      try {
+        const res = await attemptLogin(savedPassword)
+        await setCredential(host, { token: res.token, account: res.user.email })
+        spin.stop(pc.green(`已登录为 ${res.user.name}`))
+        outro(`凭证已保存（${host}）`)
+        return
+      } catch {
+        spin.stop(pc.yellow("已保存的密码已失效，请重新输入"))
+      }
+    }
+
+    const secret = args.password
+      ? args.password
+      : unwrap(
+          await passwordPrompt({
+            message: "密码",
+            validate: (v) => (v && v.length > 0 ? undefined : "请输入密码"),
+          }),
+        )
+
+    spin.start("正在登录")
+    try {
+      const res = await attemptLogin(secret)
+      await setCredential(host, { token: res.token, account: res.user.email })
+      await savePassword(host, secret)
+      spin.stop(pc.green(`已登录为 ${res.user.name}`))
+    } catch (err) {
+      spin.stop(pc.red("登录失败"))
+      log.error(err instanceof Error ? err.message : "未知错误")
+      process.exit(1)
+    }
+
+    outro(`凭证已保存（${host}）`)
+  },
+})

package/src/commands/logout.ts

@@ -0,0 +1,26 @@
+import { intro, outro } from "@clack/prompts"
+import { defineCommand } from "citty"
+import pc from "picocolors"
+import { loadContext } from "../context.ts"
+import { clearCredential } from "../creds.ts"
+import { hostOf } from "../utils.ts"
+
+export const logoutCommand = defineCommand({
+  meta: { name: "logout", description: "退出登录，移除本地凭证" },
+  args: {
+    server: { type: "string", description: "服务器地址（默认读取 atomfunctions.json）" },
+  },
+  async run({ args }) {
+    intro(pc.cyan("atomfunctions 退出登录"))
+    const ctx = await loadContext()
+    if (!ctx) process.exit(1)
+    const server = args.server ?? ctx.manifest.server
+    if (!server) {
+      outro(pc.red("无法确定服务器地址，请用 --server 指定"))
+      process.exit(1)
+    }
+    const host = hostOf(server)
+    const removed = await clearCredential(host)
+    outro(removed ? pc.green(`已退出 ${host}`) : `未找到 ${host} 的登录凭证`)
+  },
+})

package/src/commands/logs.ts

@@ -0,0 +1,29 @@
+import { intro, log, outro } from "@clack/prompts"
+import { defineCommand } from "citty"
+import pc from "picocolors"
+import { AdminClient } from "../client.ts"
+import { pickTarget, requireProjectContext } from "../context.ts"
+
+export const logsCommand = defineCommand({
+  meta: { name: "logs", description: "查看函数包日志（指定机器）" },
+  args: {
+    bundle: { type: "positional", description: "bundle 名", required: true },
+    server: { type: "string", description: "指定机器（默认首台，日志按机器区分）" },
+    tail: { type: "string", description: "末尾行数（默认 200）" },
+  },
+  async run({ args }) {
+    intro(pc.cyan(`日志 ${args.bundle}`))
+    const ctx = await requireProjectContext()
+    const target = pickTarget(ctx, args.server)
+    const client = new AdminClient(target.server, target.token)
+    const tail = Number(args.tail ?? "200")
+    const text = await client.logs(ctx.project, args.bundle, Number.isFinite(tail) ? tail : 200)
+
+    if (!text.trim()) {
+      log.warn("暂无日志")
+    } else {
+      process.stdout.write(`${text}\n`)
+    }
+    outro(pc.green("已结束"))
+  },
+})

package/src/commands/member.ts

@@ -0,0 +1,140 @@
+import { intro, multiselect, outro } from "@clack/prompts"
+import { defineCommand } from "citty"
+import pc from "picocolors"
+import { ClientError } from "../client.ts"
+import { authedClient, requireProjectContext, requireServerContext } from "../context.ts"
+import { unwrap } from "../utils.ts"
+import { writeView } from "../views.ts"
+
+async function fail(err: unknown): Promise<never> {
+  const msg = err instanceof Error ? err.message : String(err)
+  outro(pc.red(msg))
+  process.exit(1)
+}
+
+const listCommand = defineCommand({
+  meta: { name: "list", description: "查看项目成员" },
+  args: {
+    project: { type: "string", description: "项目标识（默认读取 atomfunctions.json）" },
+  },
+  async run({ args }) {
+    intro(pc.cyan("项目成员"))
+    const ctx = await requireProjectContext()
+    const client = await authedClient(ctx)
+    const slug = args.project ?? ctx.project
+    try {
+      const data = await client.get<{ members: unknown[] }>(`/projects/${slug}/members`)
+      const file = await writeView(ctx, "members.list.json", data)
+      outro(pc.green(`已生成 ${file}`))
+    } catch (err) {
+      await fail(err)
+    }
+  },
+})
+
+const addCommand = defineCommand({
+  meta: { name: "add", description: "拉用户进项目（角色设为 admin）" },
+  args: {
+    project: { type: "string", description: "项目标识（默认读取 atomfunctions.json）" },
+  },
+  async run({ args }) {
+    intro(pc.cyan("添加成员"))
+    const ctx = await requireProjectContext()
+    const client = await authedClient(ctx)
+    const slug = args.project ?? ctx.project
+
+    let selectedAccounts: string[] = []
+    try {
+      const [usersData, membersData] = await Promise.all([
+        client.get<{ users: { name: string; email: string; isSuperAdmin: boolean }[] }>("/users"),
+        client.get<{ members: { name: string }[] }>(`/projects/${slug}/members`),
+      ])
+      const existing = new Set(membersData.members.map((m) => m.name))
+      const candidates = usersData.users.filter((u) => !u.isSuperAdmin && !existing.has(u.name))
+      if (candidates.length === 0) {
+        outro("所有用户已在项目中")
+        return
+      }
+      selectedAccounts = unwrap(
+        await multiselect({
+          message: "选择要添加的用户",
+          options: candidates.map((u) => ({ value: u.name, label: u.name, hint: u.email })),
+          required: true,
+        }),
+      ) as string[]
+    } catch (err) {
+      await fail(err)
+    }
+
+    let done = 0
+    let failed = 0
+    for (const account of selectedAccounts) {
+      try {
+        await client.post(`/projects/${slug}/members`, { account })
+        done++
+      } catch {
+        failed++
+      }
+    }
+    outro(pc.green(`已添加 ${done} 人${failed > 0 ? `，${failed} 人失败` : ""}`))
+  },
+})
+
+const removeCommand = defineCommand({
+  meta: { name: "remove", description: "移除项目成员" },
+  args: {
+    project: { type: "string", description: "项目标识（默认读取 atomfunctions.json）" },
+    account: { type: "positional", required: false, description: "用户邮箱或用户名" },
+  },
+  async run({ args }) {
+    intro(pc.cyan("移除成员"))
+    const ctx = await requireProjectContext()
+    const client = await authedClient(ctx)
+    const slug = args.project ?? ctx.project
+
+    let selectedAccounts: string[]
+    if (args.account) {
+      selectedAccounts = [args.account]
+    } else {
+      let members: { name: string; role: string; email: string }[] = []
+      try {
+        const data = await client.get<{ members: { name: string; role: string; email: string }[] }>(
+          `/projects/${slug}/members`,
+        )
+        members = data.members
+      } catch (err) {
+        await fail(err)
+      }
+      if (members.length === 0) {
+        outro("该项目暂无成员")
+        return
+      }
+      selectedAccounts = unwrap(
+        await multiselect({
+          message: "选择要移除的成员",
+          options: members.map((m) => ({ value: m.name, label: m.name, hint: `${m.email}  ${m.role}` })),
+          required: true,
+        }),
+      ) as string[]
+    }
+
+    let done = 0
+    let failed = 0
+    for (const account of selectedAccounts) {
+      try {
+        await client.del(`/projects/${slug}/members/${encodeURIComponent(account)}`)
+        done += 1
+      } catch (err) {
+        failed += 1
+        if (err instanceof ClientError) outro(pc.red(`✗ ${account}：${err.message}`))
+      }
+    }
+    outro(failed === 0 ? pc.green(`已移除 ${done} 人`) : pc.yellow(`移除 ${done} 人，失败 ${failed} 人`))
+    if (failed > 0) process.exit(1)
+  },
+})
+
+export const memberCommand = defineCommand({
+  meta: { name: "member", description: "管理项目成员" },
+  subCommands: { list: listCommand, add: addCommand, remove: removeCommand },
+})

package/src/commands/new.ts

@@ -0,0 +1,68 @@
+import path from "node:path"
+import { intro, log, outro, select } from "@clack/prompts"
+import { defineCommand } from "citty"
+import pc from "picocolors"
+import { BUNDLE_FILE } from "../consts.ts"
+import { loadContext } from "../context.ts"
+import { scaffoldBundle, scaffoldContainerfile, scaffoldFunction } from "../scaffold.ts"
+import type { BundleConfig, Language } from "../types.ts"
+import { isValidSlug, parseRef, readJson, unwrap } from "../utils.ts"
+
+export const newCommand = defineCommand({
+  meta: { name: "new", description: "创建函数包（bundle）或函数（function）" },
+  args: {
+    ref: { type: "positional", description: "<bundle> 或 <bundle>/<function>", required: true },
+    lang: { type: "string", description: "语言：bun（默认）" },
+    "with-containerfile": { type: "boolean", description: "生成逃生舱 Containerfile 模板" },
+  },
+  async run({ args }) {
+    intro(pc.cyan("创建脚手架"))
+    const ctx = await loadContext()
+    if (!ctx) {
+      log.error("未找到 atomfunctions.json")
+      process.exit(1)
+    }
+    const { bundle, fn } = parseRef(args.ref)
+
+    if (!isValidSlug(bundle)) {
+      log.error("bundle 名需以小写字母开头，仅含小写字母、数字、连字符")
+      process.exit(1)
+    }
+
+    const bundleDir = path.join(ctx.root, bundle)
+    const existingConfig = await readJson<BundleConfig>(path.join(bundleDir, BUNDLE_FILE))
+
+    let language: Language = existingConfig?.language ?? "bun"
+    if (!existingConfig) {
+      language = (args.lang ??
+        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 ${bundle}`)
+    }
+
+    if (args["with-containerfile"]) {
+      await scaffoldContainerfile(bundleDir)
+      log.success("已生成逃生舱 Containerfile")
+    }
+
+    if (fn) {
+      if (!isValidSlug(fn)) {
+        log.error("function 名需以小写字母开头，仅含小写字母、数字、连字符")
+        process.exit(1)
+      }
+      await scaffoldFunction(bundleDir, fn, language)
+      log.success(`已创建函数 ${bundle}/${fn}`)
+    }
+
+    outro(pc.green("完成，运行 atomfunctions deploy 进行部署"))
+  },
+})