@atomservice/functions-cli 0.1.6

package/src/consts.ts

@@ -0,0 +1,36 @@
+import os from "node:os"
+import path from "node:path"
+
+export const MANIFEST_FILE = "atomfunctions.json"
+export const MANIFEST_SCHEMA_FILE = "atomfunctions.schema.json"
+export const BUNDLE_FILE = "atombundle.json"
+export const BUNDLES_DIR = "bundles"
+export const SCHEMAS_DIR = "schemas"
+export const FUNCTION_FILE = "function.ts"
+export const FUNCTION_CONFIG_FILE = "function.json"
+export const ENTRY_FILE = ".atomfn-entry.ts"
+
+export const CREDS_DIR = path.join(os.homedir(), ".atomfunctions")
+export const CREDS_FILE = path.join(CREDS_DIR, "credentials.json")
+export const KEYCHAIN_SERVICE = "com.atomservice.functions"
+export const KEYCHAIN_SERVICE_PASSWORD = "com.atomservice.functions.password"
+
+export const ADMIN_PREFIX = "/v1"
+export const SLUG_RE = /^[a-z][a-z0-9-]*$/
+export const VIEWS_DIR = "views"
+export const LOCAL_DIR = "local"
+export const REMOTE_DIR = "remote"
+
+export const GITIGNORE_BODY = `${LOCAL_DIR}/\n${REMOTE_DIR}/\n${VIEWS_DIR}/\n`
+
+export const SDK_PACKAGE = "@atomservice/functions-sdk"
+export const LINUX_TARGET = "bun-linux-x64"
+export const DEFAULT_DEV_PORT = 8080
+
+import { ManifestSchema } from "./types.ts"
+
+export const MANIFEST_SCHEMA = JSON.stringify(
+  { $schema: "http://json-schema.org/draft-07/schema", ...ManifestSchema },
+  null,
+  2,
+)

package/src/context.ts

@@ -0,0 +1,90 @@
+import path from "node:path"
+import { log } from "@clack/prompts"
+import { AdminClient } from "./client.ts"
+import { MANIFEST_FILE, VIEWS_DIR } from "./consts.ts"
+import { getCredential } from "./creds.ts"
+import type { CliContext, Manifest, ServerTarget } from "./types.ts"
+import { hostOf, readJson } from "./utils.ts"
+
+async function findRoot(start: string): Promise<string | null> {
+  let dir = start
+  while (true) {
+    if (await Bun.file(path.join(dir, MANIFEST_FILE)).exists()) return dir
+    const parent = path.dirname(dir)
+    if (parent === dir) return null
+    dir = parent
+  }
+}
+
+export function resolveServers(manifest: Manifest): string[] {
+  const list = [...(manifest.servers ?? []), ...(manifest.server ? [manifest.server] : [])]
+  return [...new Set(list)]
+}
+
+export function pickTarget(ctx: CliContext, server?: string): ServerTarget {
+  if (!server) return ctx.targets[0] as ServerTarget
+  const match = ctx.targets.find((t) => t.host === server || t.server === server)
+  if (!match) {
+    log.error(`未找到机器 ${server}，已登录：${ctx.targets.map((t) => t.host).join("、")}`)
+    process.exit(1)
+  }
+  return match
+}
+
+export async function loadContext(): Promise<CliContext | null> {
+  const root = await findRoot(process.cwd())
+  if (!root) return null
+  const manifest = await readJson<Manifest>(path.join(root, MANIFEST_FILE))
+  if (!manifest) return null
+  return {
+    root,
+    manifest,
+    project: manifest.project?.slug ?? "",
+    viewsDir: path.join(root, VIEWS_DIR),
+    targets: [],
+  }
+}
+
+export async function requireServerContext(): Promise<CliContext> {
+  const ctx = await loadContext()
+  if (!ctx) {
+    log.error(`未找到 ${MANIFEST_FILE}，请先运行 atomfunctions init`)
+    process.exit(1)
+  }
+  if (!ctx.manifest.server) {
+    log.error(`${MANIFEST_FILE} 缺少 server 字段`)
+    process.exit(1)
+  }
+
+  const servers = resolveServers(ctx.manifest)
+  const targets: ServerTarget[] = []
+  for (const server of servers) {
+    const host = hostOf(server)
+    const cred = await getCredential(host)
+    if (cred) targets.push({ server, host, token: cred.token })
+  }
+
+  return { ...ctx, targets }
+}
+
+export async function requireProjectContext(): Promise<CliContext> {
+  const ctx = await requireServerContext()
+  if (!ctx.manifest.project?.slug) {
+    log.error(`${MANIFEST_FILE} 中尚未设置项目，请运行 atomfunctions project link <slug>`)
+    process.exit(1)
+  }
+  if (ctx.targets.length === 0) {
+    log.error("未找到可用的控制面服务器登录凭证，请先运行 atomfunctions login")
+    process.exit(1)
+  }
+  return ctx
+}
+
+export async function authedClient(ctx: CliContext): Promise<AdminClient> {
+  const target = ctx.targets[0]
+  if (!target) {
+    log.error("未找到可用的控制面服务器")
+    process.exit(1)
+  }
+  return new AdminClient(target.server, target.token)
+}

package/src/creds.ts

@@ -0,0 +1,71 @@
+import { chmodSync } from "node:fs"
+import { CREDS_DIR, CREDS_FILE, KEYCHAIN_SERVICE, KEYCHAIN_SERVICE_PASSWORD } from "./consts.ts"
+import type { CredentialEntry } from "./types.ts"
+import { ensureDir, readJson, writeJson } from "./utils.ts"
+
+type CredentialStore = Record<string, CredentialEntry>
+
+function useKeychain(): boolean {
+  return process.platform === "darwin"
+}
+
+async function keychainGet(host: string): Promise<CredentialEntry | null> {
+  const raw = await Bun.secrets.get({ service: KEYCHAIN_SERVICE, name: host })
+  if (!raw) return null
+  try {
+    return JSON.parse(raw) as CredentialEntry
+  } catch {
+    return null
+  }
+}
+
+async function keychainSet(host: string, entry: CredentialEntry): Promise<void> {
+  await Bun.secrets.set({ service: KEYCHAIN_SERVICE, name: host, value: JSON.stringify(entry) })
+}
+
+async function keychainClear(host: string): Promise<boolean> {
+  return Bun.secrets.delete({ service: KEYCHAIN_SERVICE, name: host })
+}
+
+export async function getSavedPassword(host: string): Promise<string | null> {
+  if (!useKeychain()) return null
+  return Bun.secrets.get({ service: KEYCHAIN_SERVICE_PASSWORD, name: host })
+}
+
+export async function savePassword(host: string, password: string): Promise<void> {
+  if (!useKeychain()) return
+  await Bun.secrets.set({ service: KEYCHAIN_SERVICE_PASSWORD, name: host, value: password })
+}
+
+async function load(): Promise<CredentialStore> {
+  return (await readJson<CredentialStore>(CREDS_FILE)) ?? {}
+}
+
+async function persist(store: CredentialStore): Promise<void> {
+  ensureDir(CREDS_DIR)
+  chmodSync(CREDS_DIR, 0o700)
+  await writeJson(CREDS_FILE, store)
+  chmodSync(CREDS_FILE, 0o600)
+}
+
+export async function getCredential(host: string): Promise<CredentialEntry | null> {
+  if (useKeychain()) return keychainGet(host)
+  const store = await load()
+  return store[host] ?? null
+}
+
+export async function setCredential(host: string, entry: CredentialEntry): Promise<void> {
+  if (useKeychain()) return keychainSet(host, entry)
+  const store = await load()
+  store[host] = entry
+  await persist(store)
+}
+
+export async function clearCredential(host: string): Promise<boolean> {
+  if (useKeychain()) return keychainClear(host)
+  const store = await load()
+  if (!store[host]) return false
+  delete store[host]
+  await persist(store)
+  return true
+}

package/src/editor.ts

@@ -0,0 +1,16 @@
+export function openInEditor(file: string): void {
+  if (process.platform !== "darwin") return
+  if (process.env.ATOMFN_NO_EDITOR === "1") return
+  const code = Bun.which("code")
+  if (!code) return
+  try {
+    Bun.spawnSync([code, file])
+  } catch {}
+}
+
+export function openBrowser(file: string): void {
+  const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open"
+  try {
+    Bun.spawnSync([cmd, file])
+  } catch {}
+}

package/src/index.ts

@@ -0,0 +1,45 @@
+import { defineCommand } from "citty"
+import { bundleCommand } from "./commands/bundle.ts"
+import { deployCommand } from "./commands/deploy.ts"
+import { devCommand } from "./commands/dev.ts"
+import { functionCommand } from "./commands/function.ts"
+import { initCommand } from "./commands/init.ts"
+import { invokeCommand } from "./commands/invoke.ts"
+import { listCommand } from "./commands/list.ts"
+import { loginCommand } from "./commands/login.ts"
+import { logoutCommand } from "./commands/logout.ts"
+import { logsCommand } from "./commands/logs.ts"
+import { memberCommand } from "./commands/member.ts"
+import { newCommand } from "./commands/new.ts"
+import { projectCommand } from "./commands/project.ts"
+import { pullCommand } from "./commands/pull.ts"
+import { pushCommand } from "./commands/push.ts"
+import { rollbackCommand } from "./commands/rollback.ts"
+import { tokenCommand } from "./commands/token.ts"
+import { userCommand } from "./commands/user.ts"
+import { whoamiCommand } from "./commands/whoami.ts"
+
+export const mainCommand = defineCommand({
+  meta: { name: "atomfunctions", description: "原子函数服务 CLI" },
+  subCommands: {
+    init: initCommand,
+    login: loginCommand,
+    logout: logoutCommand,
+    whoami: whoamiCommand,
+    user: userCommand,
+    project: projectCommand,
+    member: memberCommand,
+    token: tokenCommand,
+    bundle: bundleCommand,
+    function: functionCommand,
+    push: pushCommand,
+    pull: pullCommand,
+    new: newCommand,
+    dev: devCommand,
+    deploy: deployCommand,
+    list: listCommand,
+    logs: logsCommand,
+    invoke: invokeCommand,
+    rollback: rollbackCommand,
+  },
+})

package/src/scaffold.ts

@@ -0,0 +1,212 @@
+import path from "node:path"
+import { BUNDLE_FILE, FUNCTION_CONFIG_FILE, FUNCTION_FILE, SDK_PACKAGE } from "./consts.ts"
+import type { BundleConfig, FunctionKind, Language } from "./types.ts"
+import { ensureDir, writeJson } from "./utils.ts"
+
+function packageJson(bundle: string): string {
+  return `${JSON.stringify(
+    {
+      name: bundle,
+      private: true,
+      type: "module",
+      dependencies: { [SDK_PACKAGE]: "latest", typebox: "latest" },
+      devDependencies: { "@types/bun": "latest", typescript: "latest" },
+    },
+    null,
+    2,
+  )}\n`
+}
+
+function tsconfigJson(): string {
+  return `${JSON.stringify(
+    {
+      compilerOptions: {
+        lib: ["ESNext"],
+        target: "ESNext",
+        module: "Preserve",
+        moduleResolution: "bundler",
+        allowImportingTsExtensions: true,
+        verbatimModuleSyntax: true,
+        noEmit: true,
+        strict: true,
+        skipLibCheck: true,
+        types: ["bun"],
+      },
+    },
+    null,
+    2,
+  )}\n`
+}
+
+function functionSource(kind: FunctionKind): string {
+  const defName = {
+    function: "defineFunction",
+    streamFunction: "defineStreamFunction",
+    asyncFunction: "defineAsyncFunction",
+    asyncStreamFunction: "defineAsyncStreamFunction",
+  }[kind]
+  const isStream = kind === "streamFunction" || kind === "asyncStreamFunction"
+  const handlerBody = isStream
+    ? `  async *handler (event, ctx) {
+    ctx.log.info("greeting", { name: event.name })
+    yield { greeting: \`hello\` }
+    yield { greeting: \`, \${event.name}\` }
+  },`
+    : `  async handler (event, ctx) {
+    ctx.log.info("greeting", { name: event.name })
+    return { greeting: \`hello, \${event.name}\` }
+  },`
+  return `import { ${defName} } from "${SDK_PACKAGE}"
+import { Type } from "typebox"
+
+export default ${defName}({
+  input: Type.Object({ name: Type.String() }),
+  output: Type.Object({ greeting: Type.String() }),
+  errors: {},
+${handlerBody}
+})
+`
+}
+
+export async function scaffoldBundle(bundleDir: string, config: BundleConfig): Promise<void> {
+  ensureDir(bundleDir)
+  if (config.language === "rust") {
+    await scaffoldRustBundle(bundleDir, config)
+    return
+  }
+  await writeJson(path.join(bundleDir, BUNDLE_FILE), config)
+  await Bun.write(path.join(bundleDir, "package.json"), packageJson(path.basename(bundleDir)))
+  await Bun.write(path.join(bundleDir, "tsconfig.json"), tsconfigJson())
+  await Bun.write(path.join(bundleDir, ".gitignore"), "node_modules/\n.atomfn-*\nbundle\n")
+}
+
+export async function scaffoldFunction(
+  bundleDir: string,
+  fn: string,
+  language: Language = "bun",
+  kind: FunctionKind = "function",
+): Promise<void> {
+  if (language === "rust") {
+    const fnPath = path.join(bundleDir, "src", "functions", `${fn}.rs`)
+    ensureDir(path.dirname(fnPath))
+    await Bun.write(fnPath, rustFunctionSource(fn))
+    return
+  }
+  const fnDir = path.join(bundleDir, fn)
+  ensureDir(fnDir)
+  await Bun.write(path.join(fnDir, FUNCTION_FILE), functionSource(kind))
+  await writeJson(path.join(fnDir, FUNCTION_CONFIG_FILE), {})
+}
+
+function rustCargoToml(bundle: string): string {
+  return `[package]
+name = ${JSON.stringify(bundle)}
+version = "0.1.0"
+edition = "2021"
+
+[[bin]]
+name = ${JSON.stringify(bundle)}
+path = "src/main.rs"
+
+[dependencies]
+atomfunctions = "0.0.1"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+`
+}
+
+function rustMainSource(): string {
+  return `use atomfunctions::{serve, Ctx, FunctionError, Registry};
+use serde::{Deserialize, Serialize};
+
+#[derive(Deserialize)]
+struct GreetInput {
+    name: String,
+}
+
+#[derive(Serialize)]
+struct GreetOutput {
+    greeting: String,
+}
+
+fn greet(input: GreetInput, ctx: &Ctx) -> Result<GreetOutput, FunctionError> {
+    ctx.info("greeting");
+    Ok(GreetOutput { greeting: format!("hello, {}", input.name) })
+}
+
+fn main() {
+    let mut registry = Registry::new();
+    registry.function("greet", greet);
+    serve(registry);
+}
+`
+}
+
+function rustFunctionSource(fn: string): string {
+  return `// 函数 ${fn}：在 src/main.rs 中用 registry.function("${fn}", ${fn}) 注册，
+// 并在 ${BUNDLE_FILE} 的 functions 数组中加入 "${fn}"。
+use atomfunctions::{Ctx, FunctionError};
+use serde::{Deserialize, Serialize};
+
+#[derive(Deserialize)]
+pub struct Input {
+    pub name: String,
+}
+
+#[derive(Serialize)]
+pub struct Output {
+    pub greeting: String,
+}
+
+pub fn ${fn}(input: Input, _ctx: &Ctx) -> Result<Output, FunctionError> {
+    Ok(Output { greeting: format!("hello, {}", input.name) })
+}
+`
+}
+
+function rustContainerfile(bundle: string): string {
+  return `FROM rust:1-slim AS builder
+WORKDIR /build
+COPY . .
+RUN cargo build --release
+
+FROM debian:bookworm-slim
+RUN apt-get update \\
+    && apt-get install -y --no-install-recommends ca-certificates \\
+    && rm -rf /var/lib/apt/lists/*
+COPY --from=builder /build/target/release/${bundle} /app/bundle
+ENTRYPOINT ["/app/bundle"]
+`
+}
+
+async function scaffoldRustBundle(bundleDir: string, config: BundleConfig): Promise<void> {
+  const bundle = path.basename(bundleDir)
+  await writeJson(path.join(bundleDir, BUNDLE_FILE), { ...config, functions: config.functions ?? ["greet"] })
+  await Bun.write(path.join(bundleDir, "Cargo.toml"), rustCargoToml(bundle))
+  await Bun.write(path.join(bundleDir, "Containerfile"), rustContainerfile(bundle))
+  await Bun.write(path.join(bundleDir, "src", "main.rs"), rustMainSource())
+  await Bun.write(path.join(bundleDir, ".gitignore"), "target/\n.atomfn-*\n")
+}
+
+function containerfileSource(): string {
+  return `# 逃生舱：声明系统依赖（如 ffmpeg、libreoffice）后由平台本地构建整镜像。
+# 约定：平台会把编译好的二进制放在构建上下文的 ./bundle，需 COPY 到 /app/bundle 并作为 ENTRYPOINT。
+FROM debian:bookworm-slim
+
+RUN apt-get update \\
+    && apt-get install -y --no-install-recommends ca-certificates \\
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+COPY bundle /app/bundle
+RUN chmod +x /app/bundle
+
+ENTRYPOINT ["/app/bundle"]
+`
+}
+
+export async function scaffoldContainerfile(bundleDir: string): Promise<void> {
+  const target = path.join(bundleDir, "Containerfile")
+  if (await Bun.file(target).exists()) return
+  await Bun.write(target, containerfileSource())
+}

package/src/types.ts

@@ -0,0 +1,87 @@
+import { type Static, Type } from "typebox"
+
+export type Language = "bun" | "rust"
+
+export type FunctionKind = "function" | "streamFunction" | "asyncFunction" | "asyncStreamFunction"
+
+export type ExecutionMode = "inline" | "pooled" | "isolated"
+
+export interface FunctionFileConfig {
+  execution?: ExecutionMode
+  timeout?: number
+}
+
+export const ManifestSchema = Type.Object(
+  {
+    $schema: Type.Optional(Type.String({ description: "JSON Schema 引用，由工具自动生成，勿手动修改" })),
+    server: Type.Optional(Type.String({ description: "控制面服务器地址，如 http://localhost:4922" })),
+    servers: Type.Optional(Type.Array(Type.String(), { description: "已登录的全部控制面机器地址，deploy 时扇出" })),
+    project: Type.Optional(
+      Type.Object(
+        { slug: Type.String({ pattern: "^[a-z][a-z0-9-]*$", description: "项目标识" }) },
+        { additionalProperties: false, description: "项目信息（可选，后续可通过 project link 绑定）" },
+      ),
+    ),
+  },
+  { additionalProperties: false },
+)
+
+export type Manifest = Static<typeof ManifestSchema>
+
+export interface CredentialEntry {
+  token: string
+  account: string
+}
+
+export interface ServerTarget {
+  server: string
+  host: string
+  token: string
+}
+
+export interface BundleConfig {
+  language: Language
+  memory?: string
+  cpus?: number
+  maxConcurrency?: number
+  defaults?: FunctionFileConfig
+  functions?: string[]
+  env?: Record<string, string>
+}
+
+export interface DeployManifest {
+  project: string
+  bundle: string
+  version: string
+  artifact: "binary" | "image"
+  functions: string[]
+  asyncFunctions?: string[]
+  image?: string
+  memory?: string
+  cpus?: number
+  maxConcurrency?: number
+  env?: Record<string, string>
+}
+
+export interface BundleRecord {
+  project: string
+  bundle: string
+  containerName: string
+  host: string
+  port: number
+  functions: string[]
+  version: string
+  artifact: "binary" | "image"
+  image: string
+  memory?: string
+  maxConcurrency?: number
+  updatedAt: string
+}
+
+export interface CliContext {
+  root: string
+  manifest: Manifest
+  project: string
+  viewsDir: string
+  targets: ServerTarget[]
+}

package/src/utils.ts

@@ -0,0 +1,42 @@
+import { mkdirSync } from "node:fs"
+import path from "node:path"
+import { cancel, isCancel } from "@clack/prompts"
+import { SLUG_RE } from "./consts.ts"
+
+export function ensureDir(dir: string): void {
+  mkdirSync(dir, { recursive: true })
+}
+
+export async function readJson<T>(file: string): Promise<T | null> {
+  const handle = Bun.file(file)
+  if (!(await handle.exists())) return null
+  return (await handle.json()) as T
+}
+
+export async function writeJson(file: string, data: unknown): Promise<void> {
+  ensureDir(path.dirname(file))
+  await Bun.write(file, `${JSON.stringify(data, null, 2)}\n`)
+}
+
+export function hostOf(server: string): string {
+  return new URL(server).host
+}
+
+export function isValidSlug(slug: string): boolean {
+  return SLUG_RE.test(slug)
+}
+
+export function unwrap<T>(value: T | symbol): T {
+  if (isCancel(value)) {
+    cancel("已取消")
+    process.exit(0)
+  }
+  return value as T
+}
+
+export function parseRef(ref: string): { bundle: string; fn?: string } {
+  const parts = ref.split("/").filter(Boolean)
+  if (parts.length === 1) return { bundle: parts[0] as string }
+  if (parts.length === 2) return { bundle: parts[0] as string, fn: parts[1] as string }
+  throw new Error("引用格式应为 <bundle> 或 <bundle>/<function>")
+}

package/src/views.ts

@@ -0,0 +1,31 @@
+import path from "node:path"
+import { openInEditor } from "./editor.ts"
+import type { CliContext } from "./types.ts"
+import { writeJson } from "./utils.ts"
+
+const TIME_FIELDS = new Set(["createdAt", "updatedAt", "joinedAt", "lastUsedAt", "expiresAt"])
+
+function formatTimestamps(val: unknown): unknown {
+  if (Array.isArray(val)) return val.map(formatTimestamps)
+  if (val !== null && typeof val === "object") {
+    const out: Record<string, unknown> = {}
+    for (const [k, v] of Object.entries(val as Record<string, unknown>)) {
+      if (TIME_FIELDS.has(k) && typeof v === "number") {
+        out[k] = new Date(v * 1000).toLocaleString("zh-CN", { hour12: false })
+      } else if (TIME_FIELDS.has(k) && typeof v === "string") {
+        out[k] = v
+      } else {
+        out[k] = formatTimestamps(v)
+      }
+    }
+    return out
+  }
+  return val
+}
+
+export async function writeView(ctx: CliContext, relPath: string, data: unknown): Promise<string> {
+  const file = path.join(ctx.viewsDir, relPath)
+  await writeJson(file, formatTimestamps(data))
+  openInEditor(file)
+  return file
+}