@atomservice/cli 0.1.0

package/bin/atom.ts

@@ -0,0 +1,58 @@
+#!/usr/bin/env bun
+import { UserError } from "@atomservice/core"
+import { type ArgsDef, type CommandDef, defineCommand, renderUsage, runCommand, runMain } from "citty"
+import pc from "picocolors"
+import { addCmd } from "../src/add/add.cmd.ts"
+import { initCmd } from "../src/init/init.cmd.ts"
+import { runCmd } from "../src/run/index.ts"
+import { buildServiceSubCommands } from "../src/service/index.ts"
+
+async function showUsage<T extends ArgsDef>(cmd: CommandDef<T>, parent?: CommandDef<T>) {
+  const raw = await renderUsage(cmd, parent)
+  const zh = raw
+    .replace(/USAGE/g, "用法")
+    .replace(/COMMANDS/g, "命令")
+    .replace(/ARGUMENTS/g, "参数")
+    .replace(/OPTIONS/g, "选项")
+    .replace(/Use .+ for more information about a command\./g, "运行 atom <命令> --help 查看命令详情。")
+  console.log(`${zh}\n`)
+}
+
+const main = defineCommand({
+  meta: { name: "atom", version: "0.0.1", description: "原子化自托管服务编排工具" },
+  subCommands: async () => ({
+    init: initCmd,
+    add: addCmd,
+    run: runCmd,
+    ...(await buildServiceSubCommands()),
+  }),
+  run: async () => {
+    const subcmd = process.argv.slice(2).find((a) => !a.startsWith("-"))
+    if (!subcmd) await showUsage(main)
+  },
+})
+
+const argv = process.argv.slice(2)
+const wantsHelpOrVersion =
+  argv.includes("--help") || argv.includes("-h") || (argv.length === 1 && argv[0] === "--version")
+
+if (wantsHelpOrVersion) {
+  // help / version 由 citty 自带逻辑处理
+  await runMain(main, { showUsage })
+} else {
+  try {
+    await runCommand(main, { rawArgs: argv })
+  } catch (err) {
+    if (err instanceof UserError) {
+      console.error(`\n${pc.red("✗")} ${err.message}`)
+      if (err.hint) console.error(pc.dim(`  ${err.hint}`))
+    } else {
+      console.error(`\n${pc.red("✗")} ${err instanceof Error ? err.message : String(err)}`)
+      console.error(pc.dim("  如果这看起来是个 bug，可加 --verbose 查看详细堆栈"))
+      if (process.env.ATOMSERVICE_VERBOSE && err instanceof Error && err.stack) {
+        console.error(pc.dim(err.stack))
+      }
+    }
+    process.exit(1)
+  }
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@atomservice/cli",
+  "version": "0.1.0",
+  "description": "atomservice 命令行工具（atom）：init / run / add / service",
+  "type": "module",
+  "author": "openorson",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/openorson/atomservice.git",
+    "directory": "packages/cli"
+  },
+  "bugs": "https://github.com/openorson/atomservice/issues",
+  "homepage": "https://github.com/openorson/atomservice/tree/main/packages/cli#readme",
+  "keywords": [
+    "atomservice",
+    "cli",
+    "self-hosted",
+    "podman",
+    "bun"
+  ],
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "files": [
+    "src",
+    "bin"
+  ],
+  "bin": {
+    "atom": "./bin/atom.ts"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.4.0",
+    "@atomservice/core": "workspace:*",
+    "citty": "^0.2.2",
+    "cli-table3": "^0.6.5",
+    "log-update": "^8.0.0",
+    "ora": "^9.4.0",
+    "picocolors": "^1.1.1"
+  }
+}

package/src/add/add.cmd.ts

@@ -0,0 +1,67 @@
+import fs from "node:fs"
+import path from "node:path"
+import { ATOMSERVICE_DIR } from "@atomservice/core"
+import { cancel, confirm, isCancel, multiselect, spinner } from "@clack/prompts"
+import { defineCommand } from "citty"
+import pc from "picocolors"
+import { OFFICIAL_SERVICES } from "../cli.consts.ts"
+import { ensureLocalLink } from "../cli.link.ts"
+
+async function installService(name: string) {
+  const pkgName = `@atomservice/${name}`
+  const symlinkPath = path.join(ATOMSERVICE_DIR, "node_modules", "@atomservice", name)
+
+  const existing = fs.lstatSync(symlinkPath, { throwIfNoEntry: false })
+  if (existing) {
+    try {
+      const resolved = fs.realpathSync(symlinkPath)
+      if (fs.existsSync(path.join(resolved, "package.json"))) return
+    } catch {
+      fs.rmSync(symlinkPath, { force: true, recursive: true })
+    }
+  }
+
+  const s = spinner()
+  s.start(`安装 ${pkgName}…`)
+
+  const installed = await Bun.$`bun add --cwd ${ATOMSERVICE_DIR} ${pkgName}`.quiet().nothrow()
+  if (installed.exitCode === 0) {
+    s.stop(pc.green(`${pkgName} 已安装`))
+    return
+  }
+
+  const linked = ensureLocalLink(name)
+  s.stop(linked ? pc.green(`${pkgName} 已就绪（开发模式）`) : pc.red(`${pkgName} 安装失败`))
+}
+
+export const addCmd = defineCommand({
+  meta: { name: "add", description: "安装原子服务" },
+  run: async () => {
+    const selected = await multiselect({
+      message: "选择要安装的原子服务（空格选择，回车确认）",
+      options: OFFICIAL_SERVICES,
+      required: true,
+    })
+
+    if (isCancel(selected)) {
+      cancel("已取消")
+      return
+    }
+
+    const ok = await confirm({ message: `安装 ${(selected as string[]).length} 个原子服务？` })
+
+    if (isCancel(ok) || !ok) {
+      cancel("已取消")
+      return
+    }
+
+    for (const name of selected as string[]) {
+      await installService(name)
+    }
+
+    console.log("")
+    console.log(
+      `${pc.green("✔")} 完成，在 ${pc.bold("~/.atomservice/atom.config.ts")} 中引入原子服务后运行 ${pc.cyan("atom run up")}`,
+    )
+  },
+})

package/src/cli.consts.ts

@@ -0,0 +1,14 @@
+import path from "node:path"
+import { ATOMSERVICE_DIR } from "@atomservice/core"
+
+export const CONFIG_PATH = path.join(ATOMSERVICE_DIR, "atom.config.ts")
+
+export const OFFICIAL_SERVICES: Array<{ value: string; label: string; hint: string }> = [
+  { value: "service-redis", label: "service-redis", hint: "Redis 缓存" },
+  { value: "service-postgres", label: "service-postgres", hint: "PostgreSQL 数据库" },
+  { value: "service-gateway", label: "service-gateway", hint: "反向代理 + HTTPS" },
+  { value: "service-gitea", label: "service-gitea", hint: "Gitea Git 服务" },
+  { value: "service-config", label: "service-config", hint: "通用配置中心" },
+  { value: "service-app", label: "service-app", hint: "容器化后端应用部署" },
+  { value: "service-site", label: "service-site", hint: "静态网站部署" },
+]

package/src/cli.link.ts

@@ -0,0 +1,41 @@
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
+
+function findMonorepoRoot(): string | null {
+  const scriptDir = import.meta.dirname
+  const candidates = [
+    path.resolve(scriptDir, "../../.."),
+    path.resolve(scriptDir, "../../../.."),
+    path.resolve(scriptDir, "../../../../.."),
+  ]
+  for (const candidate of candidates) {
+    if (fs.existsSync(path.join(candidate, "packages", "core", "package.json"))) {
+      return candidate
+    }
+  }
+  return null
+}
+
+export function ensureLocalLink(packageName: string): boolean {
+  const monorepoRoot = findMonorepoRoot()
+  if (!monorepoRoot) return false
+
+  const sourceDir = path.join(monorepoRoot, "packages", packageName)
+  if (!fs.existsSync(path.join(sourceDir, "package.json"))) return false
+
+  const atomserviceDir = path.join(os.homedir(), ".atomservice")
+  const targetDir = path.join(atomserviceDir, "node_modules", "@atomservice")
+  const symlinkPath = path.join(targetDir, packageName)
+
+  const existing = fs.lstatSync(symlinkPath, { throwIfNoEntry: false })
+  if (existing?.isSymbolicLink() || existing?.isDirectory()) {
+    const resolved = fs.realpathSync(symlinkPath)
+    if (resolved === sourceDir) return true
+    fs.rmSync(symlinkPath, { force: true, recursive: true })
+  }
+
+  fs.mkdirSync(targetDir, { recursive: true })
+  fs.symlinkSync(sourceDir, symlinkPath, "dir")
+  return true
+}

package/src/init/init.cmd.ts

@@ -0,0 +1,72 @@
+import fs from "node:fs"
+import path from "node:path"
+import { ATOMSERVICE_DIR } from "@atomservice/core"
+import { spinner } from "@clack/prompts"
+import { defineCommand } from "citty"
+import pc from "picocolors"
+import { CONFIG_PATH } from "../cli.consts.ts"
+import { ensureLocalLink } from "../cli.link.ts"
+
+async function ensureDir() {
+  fs.mkdirSync(ATOMSERVICE_DIR, { recursive: true })
+
+  const pkgPath = path.join(ATOMSERVICE_DIR, "package.json")
+  if (!fs.existsSync(pkgPath)) {
+    await Bun.write(
+      pkgPath,
+      `${JSON.stringify({ name: "atomservice-config", private: true, type: "module" }, null, 2)}\n`,
+    )
+  }
+}
+
+async function ensureCore() {
+  const symlinkPath = path.join(ATOMSERVICE_DIR, "node_modules", "@atomservice", "core")
+
+  const existing = fs.lstatSync(symlinkPath, { throwIfNoEntry: false })
+  if (existing) {
+    try {
+      const resolved = fs.realpathSync(symlinkPath)
+      if (fs.existsSync(path.join(resolved, "package.json"))) return
+    } catch {
+      fs.rmSync(symlinkPath, { force: true, recursive: true })
+    }
+  }
+
+  const s = spinner()
+  s.start("安装 @atomservice/core…")
+
+  const installed = await Bun.$`bun add --cwd ${ATOMSERVICE_DIR} @atomservice/core`.quiet().nothrow()
+  if (installed.exitCode === 0) {
+    s.stop(pc.green("@atomservice/core 已安装"))
+    return
+  }
+
+  const linked = ensureLocalLink("core")
+  s.stop(linked ? pc.green("@atomservice/core 已就绪（开发模式）") : pc.red("@atomservice/core 安装失败"))
+}
+
+export const initCmd = defineCommand({
+  meta: { name: "init", description: `初始化 atomservice 项目（${ATOMSERVICE_DIR}）` },
+  run: async () => {
+    await ensureDir()
+    await ensureCore()
+
+    if (fs.existsSync(CONFIG_PATH)) {
+      console.log(pc.dim("已就绪，无需重复初始化"))
+      console.log(pc.dim(`配置文件：${CONFIG_PATH}`))
+      return
+    }
+
+    const content = `import { defineConfig } from "@atomservice/core"
+
+export default defineConfig({
+  root: "${ATOMSERVICE_DIR}",
+  services: [],
+})
+`
+
+    await Bun.write(CONFIG_PATH, content)
+    console.log(`${pc.green("✔")} 已初始化 ${pc.bold(ATOMSERVICE_DIR)}`)
+    console.log(pc.dim("  编辑 atom.config.ts 添加原子服务后运行 atom run up"))
+  },
+})

package/src/run/index.ts

@@ -0,0 +1,13 @@
+import { defineCommand } from "citty"
+import { downCmd } from "./run.down.ts"
+import { statusCmd } from "./run.status.ts"
+import { upCmd } from "./run.up.ts"
+
+export const runCmd = defineCommand({
+  meta: { name: "run", description: "管理原子服务生命周期" },
+  subCommands: {
+    up: upCmd,
+    down: downCmd,
+    status: statusCmd,
+  },
+})

package/src/run/run.down.ts

@@ -0,0 +1,36 @@
+import { initForCli, loadConfig, selectServices } from "@atomservice/core"
+import { defineCommand } from "citty"
+import pc from "picocolors"
+import { runAtom } from "./run.utils.ts"
+
+export const downCmd = defineCommand({
+  meta: { name: "down", description: "反序停止原子服务" },
+  args: {
+    services: {
+      type: "positional",
+      required: false,
+      description: "要停止的服务名（可多个），不填则停止全部",
+    },
+    only: { type: "boolean", description: "仅停止指定服务，不自动停止其下游", default: false },
+    verbose: { type: "boolean", alias: "v", description: "显示详细命令输出", default: false },
+  },
+  run: async ({ args }) => {
+    if (args.verbose) process.env.ATOMSERVICE_VERBOSE = "1"
+    const config = await loadConfig()
+    let services = await initForCli(config)
+
+    if (services.length === 0) {
+      console.log(pc.dim("没有配置原子服务，请编辑 ~/.atomservice/atom.config.ts"))
+      return
+    }
+
+    const names = (args._ ?? []).filter((a): a is string => typeof a === "string" && a.length > 0)
+    if (names.length > 0) {
+      services = selectServices(services, names, { direction: "dependents", only: args.only })
+    }
+
+    for (const { serviceId, state, logger } of [...services].reverse()) {
+      await runAtom(serviceId, state, logger, (s) => s.downHandlers)
+    }
+  },
+})

package/src/run/run.status.ts

@@ -0,0 +1,70 @@
+import type { HealthStatus } from "@atomservice/core"
+import { initForCli, loadConfig } from "@atomservice/core"
+import { defineCommand } from "citty"
+import Table from "cli-table3"
+import logUpdate from "log-update"
+import pc from "picocolors"
+
+function renderTable(results: Map<string, HealthStatus>): string {
+  const table = new Table({
+    head: [pc.bold("原子服务"), pc.bold("状态"), pc.bold("信息")],
+  })
+  for (const [id, health] of results) {
+    const icon =
+      health.status === "healthy"
+        ? pc.green("✓ healthy")
+        : health.status === "unhealthy"
+          ? pc.red("✗ unhealthy")
+          : pc.yellow("? unknown")
+    table.push([id, icon, health.message ?? ""])
+  }
+  return table.toString()
+}
+
+export const statusCmd = defineCommand({
+  meta: { name: "status", description: "查看所有原子服务健康状态" },
+  args: {
+    watch: {
+      type: "boolean",
+      description: "持续监控，每 5 秒刷新",
+      default: false,
+      alias: "w",
+    },
+    verbose: { type: "boolean", alias: "v", description: "显示详细命令输出", default: false },
+  },
+  run: async ({ args }) => {
+    if (args.verbose) process.env.ATOMSERVICE_VERBOSE = "1"
+    const config = await loadConfig()
+    const services = await initForCli(config)
+
+    if (services.length === 0) {
+      console.log(pc.dim("没有配置原子服务，请编辑 ~/.atomservice/atom.config.ts"))
+      return
+    }
+
+    const refresh = async (): Promise<string> => {
+      const results = new Map<string, HealthStatus>()
+      await Promise.all(
+        services.map(async ({ serviceId, state }) => {
+          const status = state.healthHandler ? await state.healthHandler() : ({ status: "unknown" } as const)
+          results.set(serviceId, status)
+        }),
+      )
+      return renderTable(results)
+    }
+
+    if (args.watch) {
+      logUpdate(await refresh())
+      const interval = setInterval(async () => {
+        logUpdate(await refresh())
+      }, 5000)
+      process.on("SIGINT", () => {
+        clearInterval(interval)
+        logUpdate.done()
+        process.exit(0)
+      })
+    } else {
+      console.log(await refresh())
+    }
+  },
+})

package/src/run/run.up.ts

@@ -0,0 +1,38 @@
+import { initForCli, loadConfig, selectServices } from "@atomservice/core"
+import { defineCommand } from "citty"
+import pc from "picocolors"
+import { runAtom } from "./run.utils.ts"
+
+export const upCmd = defineCommand({
+  meta: { name: "up", description: "按依赖顺序启动原子服务" },
+  args: {
+    services: {
+      type: "positional",
+      required: false,
+      description: "要启动的服务名（可多个），不填则启动全部",
+    },
+    only: { type: "boolean", description: "仅启动指定服务，不自动启动其依赖", default: false },
+    verbose: { type: "boolean", alias: "v", description: "显示详细命令输出", default: false },
+  },
+  run: async ({ args }) => {
+    if (args.verbose) process.env.ATOMSERVICE_VERBOSE = "1"
+    const config = await loadConfig()
+    let services = await initForCli(config)
+
+    if (services.length === 0) {
+      console.log(pc.dim("没有配置原子服务，请编辑 ~/.atomservice/atom.config.ts"))
+      return
+    }
+
+    const names = (args._ ?? []).filter((a): a is string => typeof a === "string" && a.length > 0)
+    if (names.length > 0) {
+      services = selectServices(services, names, { direction: "deps", only: args.only })
+    }
+
+    await Bun.$`podman network create atomservice`.quiet().nothrow()
+
+    for (const { serviceId, state, logger } of services) {
+      await runAtom(serviceId, state, logger, (s) => s.upHandlers)
+    }
+  },
+})

package/src/run/run.utils.ts

@@ -0,0 +1,76 @@
+import type { Logger, ServiceLifecycle } from "@atomservice/core"
+import { UserError } from "@atomservice/core"
+import { spinner } from "@clack/prompts"
+import pc from "picocolors"
+
+export function elapsed(ms: number): string {
+  return `${(ms / 1000).toFixed(1)}s`
+}
+
+export async function runAtom(
+  serviceId: string,
+  state: ServiceLifecycle,
+  logger: Logger,
+  handlers: (lifecycle: ServiceLifecycle) => (() => Bun.MaybePromise<void>)[],
+): Promise<void> {
+  const verbose = !!process.env.ATOMSERVICE_VERBOSE
+  const t0 = Date.now()
+  let finalMsg = serviceId
+
+  if (verbose) {
+    const RESET = "\x1b[0m"
+    const BOLD = "\x1b[1m"
+    const cyan = (s: string) => (Bun.color("#22d3ee", "ansi") ?? "") + s + RESET
+    const green = (s: string) => (Bun.color("#4ade80", "ansi") ?? "") + s + RESET
+    const blue = (s: string) => (Bun.color("#7dd3fc", "ansi") ?? "") + s + RESET
+    const yellow = (s: string) => (Bun.color("#fbbf24", "ansi") ?? "") + s + RESET
+    const red = (s: string) => (Bun.color("#f87171", "ansi") ?? "") + s + RESET
+    const bar = (s: string) => (Bun.color("#52525b", "ansi") ?? "") + s + RESET
+    console.log(`${cyan("◇")}  ${BOLD}${serviceId}${RESET}`)
+    logger.info = (msg) => {
+      console.log(`${bar("│")}  ${blue("›")} ${msg}`)
+    }
+    logger.success = (msg) => {
+      finalMsg = msg
+    }
+    logger.warn = (msg) => {
+      console.log(`${bar("│")}  ${yellow("⚠")} ${msg}`)
+    }
+    logger.error = (msg) => {
+      console.log(`${bar("│")}  ${red("✗")} ${msg}`)
+      finalMsg = msg
+    }
+    try {
+      for (const fn of handlers(state)) await fn()
+      console.log(`${green("└")}  ${green(finalMsg)}  ${bar(elapsed(Date.now() - t0))}`)
+      console.log()
+    } catch (err) {
+      console.log(`${red("└")}  ${red(serviceId)}  ${bar(elapsed(Date.now() - t0))}`)
+      console.error(red(`   ${err instanceof Error ? err.message : String(err)}`))
+      if (err instanceof UserError && err.hint) console.error(bar(`   ${err.hint}`))
+      process.exit(1)
+    }
+  } else {
+    const s = spinner()
+    s.start(serviceId)
+    logger.info = (msg) => s.message(msg)
+    logger.success = (msg) => {
+      finalMsg = msg
+      s.message(msg)
+    }
+    logger.warn = (msg) => s.message(pc.yellow(msg))
+    logger.error = (msg) => {
+      finalMsg = msg
+      s.message(pc.red(msg))
+    }
+    try {
+      for (const fn of handlers(state)) await fn()
+      s.stop(`${pc.green(finalMsg)}  ${pc.dim(elapsed(Date.now() - t0))}`)
+    } catch (err) {
+      s.stop(`${pc.red(serviceId)}  ${pc.dim(elapsed(Date.now() - t0))}`)
+      console.error(pc.red(`  ${err instanceof Error ? err.message : String(err)}`))
+      if (err instanceof UserError && err.hint) console.error(pc.dim(`  ${err.hint}`))
+      process.exit(1)
+    }
+  }
+}

package/src/service/index.ts

@@ -0,0 +1 @@
+export { buildServiceSubCommands } from "./service.cmds.ts"

package/src/service/service.cmds.ts

@@ -0,0 +1,34 @@
+import { initForCli, loadConfig } from "@atomservice/core"
+import { defineCommand } from "citty"
+
+export async function buildServiceSubCommands(): Promise<Record<string, ReturnType<typeof defineCommand>>> {
+  let config: Awaited<ReturnType<typeof loadConfig>>
+  try {
+    config = await loadConfig()
+  } catch {
+    return {}
+  }
+  const services = await initForCli(config)
+  const subCommands: Record<string, ReturnType<typeof defineCommand>> = {}
+
+  for (const { serviceId, state } of services) {
+    if (!state.commands.length) continue
+
+    const cmds: Record<string, ReturnType<typeof defineCommand>> = {}
+    for (const cmd of state.commands) {
+      cmds[cmd.name] = defineCommand({
+        meta: { name: cmd.name, description: cmd.description },
+        run: async ({ args }) => {
+          await cmd.handler(args as Record<string, string>)
+        },
+      })
+    }
+
+    subCommands[serviceId] = defineCommand({
+      meta: { name: serviceId, description: `${serviceId} 原子服务命令` },
+      subCommands: cmds,
+    })
+  }
+
+  return subCommands
+}