@atomservice/functions-cli 0.1.6

package/src/commands/project.ts

@@ -0,0 +1,145 @@
+import path from "node:path"
+import { intro, log, outro, select, text } from "@clack/prompts"
+import { defineCommand } from "citty"
+import pc from "picocolors"
+import { ClientError } from "../client.ts"
+import { LOCAL_DIR, MANIFEST_FILE } from "../consts.ts"
+import { authedClient, requireServerContext } from "../context.ts"
+import { openInEditor } from "../editor.ts"
+import type { Manifest } from "../types.ts"
+import { isValidSlug, readJson, unwrap, writeJson } from "../utils.ts"
+import { writeView } from "../views.ts"
+
+function intentFile(ctx: { root: string }, slug: string, action: string): string {
+  return path.join(ctx.root, LOCAL_DIR, "project", `${slug}.${action}.json`)
+}
+
+async function askSlug(provided: string | undefined): Promise<string> {
+  if (provided) {
+    if (!isValidSlug(provided)) throw new Error("项目标识需以小写字母开头，仅含小写字母、数字、连字符")
+    return provided
+  }
+  return unwrap(
+    await text({
+      message: "项目标识",
+      validate: (v) =>
+        v?.trim() && isValidSlug(v.trim()) ? undefined : "需以小写字母开头，仅含小写字母、数字、连字符",
+    }),
+  ).trim()
+}
+
+const listCommand = defineCommand({
+  meta: { name: "list", description: "查看所有项目" },
+  async run() {
+    intro(pc.cyan("项目列表"))
+    const ctx = await requireServerContext()
+    const client = await authedClient(ctx)
+    try {
+      const data = await client.get<{ projects: unknown[] }>("/projects")
+      const file = await writeView(ctx, "projects.list.json", data)
+      outro(pc.green(`已生成 ${file}`))
+    } catch (err) {
+      if (err instanceof ClientError) {
+        outro(pc.red(err.message))
+        process.exit(1)
+      }
+      throw err
+    }
+  },
+})
+
+const createCommand = defineCommand({
+  meta: { name: "create", description: "新建项目意图（仅超管，push 生效）" },
+  args: {
+    slug: { type: "positional", required: false, description: "项目标识" },
+    name: { type: "string", description: "项目名称" },
+    description: { type: "string", description: "项目描述" },
+  },
+  async run({ args }) {
+    intro(pc.cyan("新建项目"))
+    const ctx = await requireServerContext()
+    const slug = await askSlug(args.slug)
+    const name =
+      args.name ??
+      unwrap(
+        await text({
+          message: "项目名称",
+          initialValue: slug,
+          validate: (v) => (v?.trim() ? undefined : "请输入名称"),
+        }),
+      ).trim()
+    const payload: Record<string, unknown> = { slug, name }
+    if (args.description) payload.description = args.description
+
+    const file = intentFile(ctx, slug, "create")
+    await writeJson(file, payload)
+    openInEditor(file)
+    outro(pc.green(`已生成意图 ${path.relative(ctx.root, file)}，编辑后执行 atomfunctions push`))
+  },
+})
+
+const linkCommand = defineCommand({
+  meta: { name: "link", description: "绑定当前目录到指定项目" },
+  args: { slug: { type: "positional", required: false, description: "项目标识" } },
+  async run({ args }) {
+    intro(pc.cyan("绑定项目"))
+    const ctx = await requireServerContext()
+    const client = await authedClient(ctx)
+
+    let slug: string
+    if (args.slug) {
+      if (!isValidSlug(args.slug)) {
+        log.error("项目标识需以小写字母开头，仅含小写字母、数字、连字符")
+        process.exit(1)
+      }
+      slug = args.slug
+    } else {
+      let projects: { slug: string; name: string }[] = []
+      try {
+        const data = await client.get<{ projects: { slug: string; name: string }[] }>("/projects")
+        projects = data.projects
+      } catch {}
+      if (projects.length > 0) {
+        slug = unwrap(
+          await select({
+            message: "选择项目",
+            options: projects.map((p) => ({ value: p.slug, label: p.slug, hint: p.name })),
+          }),
+        ) as string
+      } else {
+        slug = unwrap(
+          await text({
+            message: "项目标识",
+            validate: (v) =>
+              v?.trim() && isValidSlug(v.trim()) ? undefined : "需以小写字母开头，仅含小写字母、数字、连字符",
+          }),
+        ).trim()
+      }
+    }
+
+    try {
+      await client.get(`/projects/${slug}`)
+    } catch (err) {
+      if (err instanceof ClientError && err.status === 404) {
+        log.error(`项目 "${slug}" 在服务器上不存在`)
+        process.exit(1)
+      }
+      throw err
+    }
+
+    const manifestPath = path.join(ctx.root, MANIFEST_FILE)
+    const manifest = await readJson<Manifest>(manifestPath)
+    if (!manifest) {
+      log.error("读取 atomfunctions.json 失败")
+      process.exit(1)
+    }
+    manifest.project = { slug }
+    await writeJson(manifestPath, manifest)
+    outro(pc.green(`已绑定项目 ${slug}`))
+  },
+})
+
+export const projectCommand = defineCommand({
+  meta: { name: "project", description: "管理项目" },
+  subCommands: { list: listCommand, create: createCommand, link: linkCommand },
+})

package/src/commands/pull.ts

@@ -0,0 +1,73 @@
+import { rmSync } from "node:fs"
+import path from "node:path"
+import { intro, outro, spinner } from "@clack/prompts"
+import { defineCommand } from "citty"
+import pc from "picocolors"
+import type { AdminClient } from "../client.ts"
+import { ClientError } from "../client.ts"
+import { REMOTE_DIR } from "../consts.ts"
+import { authedClient, requireProjectContext } from "../context.ts"
+import type { CliContext } from "../types.ts"
+import { ensureDir, writeJson } from "../utils.ts"
+
+interface ProjectDto {
+  id: string
+  slug: string
+  name: string
+  description: string | null
+  createdAt: number
+  updatedAt: number
+}
+
+interface BundleRecord {
+  project: string
+  bundle: string
+  version: string
+  functions: string[]
+  updatedAt: string
+}
+
+export async function runPull(
+  ctx: CliContext & { manifest: { project: { slug: string } } },
+  client: AdminClient,
+): Promise<{ bundles: number }> {
+  const project = ctx.manifest.project.slug
+  const remoteDir = path.join(ctx.root, REMOTE_DIR)
+
+  rmSync(path.join(remoteDir, "bundles"), { recursive: true, force: true })
+  ensureDir(path.join(remoteDir, "bundles"))
+
+  const { project: projectDto } = await client.get<{ project: ProjectDto }>(`/projects/${project}`)
+  await writeJson(path.join(remoteDir, "project.json"), projectDto)
+
+  const { bundles } = await client.get<{ bundles: BundleRecord[] }>(`/projects/${project}/bundles`)
+  for (const bundle of bundles) {
+    await writeJson(path.join(remoteDir, "bundles", `${bundle.bundle}.json`), bundle)
+  }
+
+  return { bundles: bundles.length }
+}
+
+export const pullCommand = defineCommand({
+  meta: { name: "pull", description: "拉取服务器最新状态到 remote/" },
+  async run() {
+    intro(pc.cyan("拉取最新状态"))
+    const ctx = await requireProjectContext()
+    const client = await authedClient(ctx)
+    const spin = spinner()
+    spin.start("同步中")
+    try {
+      const stats = await runPull(ctx as Parameters<typeof runPull>[0], client)
+      spin.stop(pc.green(`已同步：${stats.bundles} 函数包`))
+      outro("remote/ 已刷新")
+    } catch (err) {
+      spin.stop(pc.red("拉取失败"))
+      if (err instanceof ClientError) {
+        outro(pc.red(err.message))
+      } else {
+        outro(pc.red(String(err)))
+      }
+      process.exit(1)
+    }
+  },
+})

package/src/commands/push.ts

@@ -0,0 +1,136 @@
+import { readdirSync } from "node:fs"
+import { rm } from "node:fs/promises"
+import path from "node:path"
+import { confirm, intro, isCancel, log, outro, spinner } from "@clack/prompts"
+import { defineCommand } from "citty"
+import pc from "picocolors"
+import { ClientError } from "../client.ts"
+import { LOCAL_DIR } from "../consts.ts"
+import { authedClient, requireServerContext } from "../context.ts"
+import { readJson } from "../utils.ts"
+
+type IntentAction = "create" | "update" | "delete"
+type IntentKind = "project"
+
+interface Intent {
+  kind: IntentKind
+  action: IntentAction
+  slug: string
+  file: string
+  payload: Record<string, unknown>
+}
+
+function parseName(file: string): { action: IntentAction } | null {
+  const match = file.match(/^.+\.(create|update|delete)\.json$/)
+  if (!match?.[1]) return null
+  return { action: match[1] as IntentAction }
+}
+
+async function scanIntents(root: string): Promise<Intent[]> {
+  const intents: Intent[] = []
+  const dir = path.join(root, LOCAL_DIR, "project")
+  let entries: string[]
+  try {
+    entries = readdirSync(dir)
+  } catch {
+    return []
+  }
+  for (const file of entries) {
+    const parsed = parseName(file)
+    if (!parsed) continue
+    const filePath = path.join(dir, file)
+    const payload = (await readJson<Record<string, unknown>>(filePath)) ?? {}
+    const slug = typeof payload.slug === "string" ? payload.slug : null
+    if (!slug) throw new Error(`意图文件 ${file} 缺少 slug 字段`)
+    intents.push({ kind: "project", action: parsed.action, slug, file: filePath, payload })
+  }
+  // create → update → delete
+  const rank = (i: Intent) => ["create", "update", "delete"].indexOf(i.action)
+  return intents.sort((a, b) => rank(a) - rank(b))
+}
+
+function cleanPayload(payload: Record<string, unknown>): Record<string, unknown> {
+  const out: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(payload)) {
+    if (key === "$schema" || key === "slug") continue
+    out[key] = value
+  }
+  return out
+}
+
+const actionLabel: Record<IntentAction, string> = {
+  create: pc.green("新增"),
+  update: pc.blue("更新"),
+  delete: pc.red("删除"),
+}
+
+const kindLabel: Record<IntentKind, string> = { project: "项目" }
+
+export const pushCommand = defineCommand({
+  meta: { name: "push", description: "将本地意图应用到服务器" },
+  async run() {
+    intro(pc.cyan("推送变更"))
+    const ctx = await requireServerContext()
+
+    let intents: Intent[]
+    try {
+      intents = await scanIntents(ctx.root)
+    } catch (err) {
+      outro(pc.red(String(err)))
+      process.exit(1)
+    }
+
+    if (intents.length === 0) {
+      outro("没有待推送的意图")
+      return
+    }
+
+    console.log("")
+    console.log(pc.bold("待推送变更："))
+    for (const intent of intents) {
+      console.log(`  ${actionLabel[intent.action]} ${kindLabel[intent.kind]}  ${pc.bold(intent.slug)}`)
+    }
+    console.log("")
+
+    const confirmed = await confirm({ message: `确认推送以上 ${intents.length} 项变更？` })
+    if (isCancel(confirmed) || !confirmed) {
+      outro(pc.yellow("已取消"))
+      return
+    }
+
+    const client = await authedClient(ctx)
+    let applied = 0
+    let failed = 0
+
+    for (const intent of intents) {
+      const spin = spinner()
+      spin.start(`${intent.action} ${intent.kind} ${intent.slug}`)
+      try {
+        const body = cleanPayload(intent.payload)
+        if (intent.kind === "project") {
+          if (intent.action === "create") {
+            await client.post("/projects", { slug: intent.slug, ...body })
+          } else if (intent.action === "update") {
+            await client.post(`/projects/${intent.slug}`, body)
+          } else if (intent.action === "delete") {
+            await client.del(`/projects/${intent.slug}`)
+          }
+        }
+        await rm(intent.file, { force: true })
+        spin.stop(pc.green(`✓ ${actionLabel[intent.action]} ${kindLabel[intent.kind]} ${intent.slug}`))
+        applied += 1
+      } catch (err) {
+        failed += 1
+        if (err instanceof ClientError) {
+          spin.stop(pc.red(`✗ ${intent.kind} ${intent.slug}：${err.message}`))
+        } else {
+          spin.stop(pc.red(`✗ ${intent.kind} ${intent.slug}`))
+          log.error(String(err))
+        }
+      }
+    }
+
+    outro(failed === 0 ? pc.green(`完成：应用 ${applied} 项`) : pc.yellow(`应用 ${applied} 项，失败 ${failed} 项`))
+    if (failed > 0) process.exit(1)
+  },
+})

package/src/commands/rollback.ts

@@ -0,0 +1,56 @@
+import { intro, log, outro, select } from "@clack/prompts"
+import { defineCommand } from "citty"
+import pc from "picocolors"
+import { AdminClient } from "../client.ts"
+import { pickTarget, requireProjectContext } from "../context.ts"
+import { unwrap } from "../utils.ts"
+
+export const rollbackCommand = defineCommand({
+  meta: { name: "rollback", description: "回滚函数包到历史版本（扇出到所有机器）" },
+  args: {
+    bundle: { type: "positional", description: "bundle 名", required: true },
+    version: { type: "string", description: "目标版本（不填则从历史中选择）" },
+  },
+  async run({ args }) {
+    intro(pc.cyan(`回滚 ${args.bundle}`))
+    const ctx = await requireProjectContext()
+
+    const primary = pickTarget(ctx)
+    const history = await new AdminClient(primary.server, primary.token).versions(ctx.project, args.bundle)
+
+    let version = args.version
+    if (!version) {
+      version = unwrap(
+        await select({
+          message: "选择回滚到的版本",
+          options: history.map((record, index) => ({
+            value: record.version,
+            label: `${record.version}${index === 0 ? pc.dim(" (当前)") : ""}`,
+            hint: record.updatedAt,
+          })),
+        }),
+      ) as string
+    }
+
+    const results = await Promise.all(
+      ctx.targets.map(async (t) => {
+        try {
+          await new AdminClient(t.server, t.token).rollback(ctx.project, args.bundle, version as string)
+          return { host: t.host, ok: true }
+        } catch (error) {
+          return { host: t.host, ok: false, message: error instanceof Error ? error.message : String(error) }
+        }
+      }),
+    )
+
+    const failed = results.filter((r) => !r.ok)
+    if (failed.length === 0) {
+      log.success(`已在 ${ctx.targets.length} 台机器回滚到 ${version}`)
+      outro(pc.green("完成"))
+    } else {
+      for (const f of failed) log.error(`  ${f.host}: ${f.message}`)
+      outro(pc.red("部分机器回滚失败"))
+      process.exitCode = 1
+    }
+  },
+})

package/src/commands/token.ts

@@ -0,0 +1,130 @@
+import { intro, log, outro, select, text } from "@clack/prompts"
+import { defineCommand } from "citty"
+import pc from "picocolors"
+import { ClientError } from "../client.ts"
+import { authedClient, requireProjectContext } from "../context.ts"
+import { unwrap } from "../utils.ts"
+import { writeView } from "../views.ts"
+
+interface TokenInfo {
+  id: string
+  name: string
+  project: string
+  tokenPrefix: string
+  revoked: boolean
+  createdAt: number
+}
+
+function fmtDate(ts: number): string {
+  const d = new Date(ts * 1000)
+  return `${d.getFullYear()}/${String(d.getMonth() + 1).padStart(2, "0")}/${String(d.getDate()).padStart(2, "0")}`
+}
+
+const listCommand = defineCommand({
+  meta: { name: "list", description: "查看当前项目的访问 token" },
+  async run() {
+    intro(pc.cyan("token 列表"))
+    const ctx = await requireProjectContext()
+    const client = await authedClient(ctx)
+    try {
+      const data = await client.get<{ tokens: unknown[] }>(`/projects/${ctx.project}/tokens`)
+      const file = await writeView(ctx, "tokens.list.json", data)
+      outro(pc.green(`已生成 ${file}`))
+    } catch (err) {
+      if (err instanceof ClientError) {
+        outro(pc.red(err.message))
+        process.exit(1)
+      }
+      throw err
+    }
+  },
+})
+
+const createCommand = defineCommand({
+  meta: { name: "create", description: "创建当前项目的访问 token（派发给客户端调用函数）" },
+  args: {
+    name: { type: "string", description: "令牌备注" },
+  },
+  async run({ args }) {
+    intro(pc.cyan("创建访问 token"))
+    const ctx = await requireProjectContext()
+    const client = await authedClient(ctx)
+    const name = args.name ?? unwrap(await text({ message: "令牌备注（可选）", placeholder: "ci" })).trim()
+    try {
+      const res = await client.post<{ token: string }>(`/projects/${ctx.project}/tokens`, { name: name || undefined })
+      log.warn("以下令牌仅显示一次，请妥善保存：")
+      log.message(pc.bold(res.token))
+      outro(pc.green("已创建访问 token"))
+    } catch (err) {
+      if (err instanceof ClientError) {
+        outro(pc.red(err.message))
+        process.exit(1)
+      }
+      throw err
+    }
+  },
+})
+
+const revokeCommand = defineCommand({
+  meta: { name: "revoke", description: "吊销当前项目的访问 token" },
+  args: {
+    id: { type: "positional", required: false, description: "token id" },
+  },
+  async run({ args }) {
+    intro(pc.cyan("吊销 token"))
+    const ctx = await requireProjectContext()
+    const client = await authedClient(ctx)
+
+    let id: string
+    if (args.id) {
+      id = args.id
+    } else {
+      let tokens: TokenInfo[] = []
+      try {
+        const data = await client.get<{ tokens: TokenInfo[] }>(`/projects/${ctx.project}/tokens`)
+        tokens = data.tokens
+      } catch (err) {
+        if (err instanceof ClientError) {
+          outro(pc.red(err.message))
+          process.exit(1)
+        }
+        throw err
+      }
+      if (tokens.length === 0) {
+        outro("当前项目暂无 token")
+        return
+      }
+      const active = tokens.filter((t) => !t.revoked)
+      if (active.length === 0) {
+        outro("当前项目没有有效的 token")
+        return
+      }
+      id = unwrap(
+        await select({
+          message: "选择要吊销的 token",
+          options: active.map((t) => ({
+            value: t.id,
+            label: `${t.name || "—"} · ${t.tokenPrefix}`,
+            hint: fmtDate(t.createdAt),
+          })),
+        }),
+      ) as string
+    }
+
+    try {
+      await client.del(`/projects/${ctx.project}/tokens/${id}`)
+      outro(pc.green("已吊销"))
+    } catch (err) {
+      if (err instanceof ClientError) {
+        outro(pc.red(err.message))
+        process.exit(1)
+      }
+      throw err
+    }
+  },
+})
+
+export const tokenCommand = defineCommand({
+  meta: { name: "token", description: "管理客户端访问 token" },
+  subCommands: { list: listCommand, create: createCommand, revoke: revokeCommand },
+})

package/src/commands/user.ts

@@ -0,0 +1,77 @@
+import { intro, outro, password as passwordPrompt, text } from "@clack/prompts"
+import { defineCommand } from "citty"
+import pc from "picocolors"
+import { ClientError } from "../client.ts"
+import { authedClient, requireServerContext } from "../context.ts"
+import { unwrap } from "../utils.ts"
+import { writeView } from "../views.ts"
+
+const listCommand = defineCommand({
+  meta: { name: "list", description: "查看所有用户" },
+  async run() {
+    intro(pc.cyan("用户列表"))
+    const ctx = await requireServerContext()
+    const client = await authedClient(ctx)
+    try {
+      const data = await client.get<{ users: unknown[] }>("/users")
+      const file = await writeView(ctx, "users.list.json", data)
+      outro(pc.green(`已生成 ${file}`))
+    } catch (err) {
+      if (err instanceof ClientError) {
+        outro(pc.red(err.message))
+        process.exit(1)
+      }
+      throw err
+    }
+  },
+})
+
+const createCommand = defineCommand({
+  meta: { name: "create", description: "创建用户（仅超管）" },
+  args: {
+    email: { type: "string" },
+    name: { type: "string" },
+    password: { type: "string" },
+    super: { type: "boolean", description: "授予超级管理员", default: false },
+  },
+  async run({ args }) {
+    intro(pc.cyan("创建用户"))
+    const ctx = await requireServerContext()
+    const client = await authedClient(ctx)
+    const email =
+      args.email ??
+      unwrap(await text({ message: "邮箱", validate: (v) => (v?.trim() ? undefined : "请输入邮箱") })).trim()
+    const name =
+      args.name ??
+      unwrap(await text({ message: "用户名", validate: (v) => (v?.trim() ? undefined : "请输入用户名") })).trim()
+    const secret =
+      args.password ??
+      unwrap(
+        await passwordPrompt({
+          message: "初始密码（至少 8 位）",
+          validate: (v) => (v && v.length >= 8 ? undefined : "至少 8 位"),
+        }),
+      )
+    const isSuperAdmin = args.super
+    try {
+      const res = await client.post<{ user: { name: string } }>("/users", {
+        email,
+        name,
+        password: secret,
+        isSuperAdmin,
+      })
+      outro(pc.green(`已创建用户 ${res.user.name}`))
+    } catch (err) {
+      if (err instanceof ClientError) {
+        outro(pc.red(err.message))
+        process.exit(1)
+      }
+      throw err
+    }
+  },
+})
+
+export const userCommand = defineCommand({
+  meta: { name: "user", description: "管理用户" },
+  subCommands: { list: listCommand, create: createCommand },
+})

package/src/commands/whoami.ts

@@ -0,0 +1,51 @@
+import { intro, log, outro } from "@clack/prompts"
+import { defineCommand } from "citty"
+import pc from "picocolors"
+import { AdminClient } from "../client.ts"
+import { loadContext } from "../context.ts"
+import { getCredential } from "../creds.ts"
+import { hostOf } from "../utils.ts"
+
+interface WhoamiUser {
+  id: string
+  email: string
+  name: string
+  isSuperAdmin: boolean
+  createdAt: string
+}
+
+export const whoamiCommand = defineCommand({
+  meta: { name: "whoami", description: "查看当前登录账号信息" },
+  args: {
+    server: { type: "string", description: "服务器地址（默认读取 atomfunctions.json）" },
+  },
+  async run({ args }) {
+    intro(pc.cyan("atomfunctions whoami"))
+    const ctx = await loadContext()
+    if (!ctx) process.exit(1)
+    const server = args.server ?? ctx.manifest.server
+    if (!server) {
+      log.error("无法确定服务器地址")
+      process.exit(1)
+    }
+
+    const host = hostOf(server)
+    const cred = await getCredential(host)
+    if (!cred) {
+      log.error(`尚未登录 ${host}`)
+      process.exit(1)
+    }
+
+    const client = new AdminClient(server, cred.token)
+    const res = await client.get<{ user: WhoamiUser }>("/auth/whoami")
+    const user = res.user
+
+    log.info(`服务器：${pc.cyan(host)}`)
+    log.info(`账号：  ${pc.bold(user.name)} (${user.email})`)
+    if (user.isSuperAdmin) {
+      log.info(`角色：  ${pc.yellow("超级管理员")}`)
+    }
+
+    outro(pc.green("已登录"))
+  },
+})