@atomservice/functions-cli 0.1.6 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomservice/functions-cli",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "函数服务命令行工具（atomfunctions）：项目脚手架、本地构建、部署、运维",
   "type": "module",
   "author": "openorson",

package/src/commands/bundle.ts

@@ -1,10 +1,11 @@
 import path from "node:path"
+import { $ } from "bun"
 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 { scaffoldBundle } from "../scaffold.ts"
+import { scaffoldBundle, scaffoldContainerfile } from "../scaffold.ts"
 import type { BundleConfig, Language } from "../types.ts"
 import { isValidSlug, readJson, unwrap } from "../utils.ts"
 
@@ -13,6 +14,7 @@ const createCommand = defineCommand({
   args: {
     slug: { type: "positional", required: false, description: "bundle 名" },
     lang: { type: "string", description: "语言：bun（默认）" },
+    "with-containerfile": { type: "boolean", description: "生成逃生舱 Containerfile 模板" },
   },
   async run({ args }) {
     intro(pc.cyan("创建函数包"))
@@ -66,6 +68,28 @@ const createCommand = defineCommand({
 
     await scaffoldBundle(bundleDir, { language })
     log.success(`已创建 bundle ${slug}`)
+
+    const withContainerfile =
+      args["with-containerfile"] === true ||
+      (await confirm({ message: "是否生成 Containerfile 模板？", initialValue: false }))
+    if (!isCancel(withContainerfile) && withContainerfile) {
+      await scaffoldContainerfile(bundleDir)
+      log.success("已生成 Containerfile")
+    }
+
+    if (language === "bun") {
+      const install = await confirm({ message: "是否安装依赖包？", initialValue: true })
+      if (!isCancel(install) && install) {
+        log.info("正在安装依赖...")
+        const result = await $`bun install`.cwd(bundleDir).quiet().nothrow()
+        if (result.exitCode === 0) {
+          log.success("依赖安装完成")
+        } else {
+          log.warn("依赖安装失败，请稍后手动执行 bun install")
+        }
+      }
+    }
+
     outro(pc.green(`完成，路径 ${path.relative(ctx.root, bundleDir)}`))
   },
 })

package/src/commands/dev.ts

@@ -1,32 +1,80 @@
-import { rm } from "node:fs/promises"
+import { existsSync, readdirSync } from "node:fs"
+import type { Dirent } from "node:fs"
+import { rm, writeFile } from "node:fs/promises"
+import { connect } from "node:net"
 import path from "node:path"
-import { intro, log } from "@clack/prompts"
+import { intro, log, outro, select, text } from "@clack/prompts"
 import { defineCommand } from "citty"
 import pc from "picocolors"
 import { resolveFunctions, writeEntry } from "../build.ts"
-import { BUNDLE_FILE, DEFAULT_DEV_PORT } from "../consts.ts"
+import { BUNDLES_DIR, BUNDLE_FILE, DEFAULT_DEV_PORT, DEV_PID_FILE } from "../consts.ts"
 import { loadContext } from "../context.ts"
 import type { BundleConfig } from "../types.ts"
-import { readJson } from "../utils.ts"
+import { isValidSlug, readJson, unwrap, writeJson } from "../utils.ts"
 
-export const devCommand = defineCommand({
-  meta: { name: "dev", description: "本地热重载运行函数包" },
+function pidFile(bundleDir: string): string {
+  return path.join(bundleDir, DEV_PID_FILE)
+}
+
+function isPortInUse(port: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    const sock = connect({ port, host: "127.0.0.1" }, () => {
+      sock.destroy()
+      resolve(true)
+    })
+    sock.on("error", () => resolve(false))
+  })
+}
+
+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) => existsSync(path.join(dir, e.name, BUNDLE_FILE)))
+    .map((e) => e.name)
+    .sort()
+}
+
+const startCommand = defineCommand({
+  meta: { name: "start", description: "启动本地开发服务器" },
   args: {
-    bundle: { type: "positional", description: "bundle 名", required: true },
-    port: { type: "string", description: `本地端口（默认 ${DEFAULT_DEV_PORT}）` },
+    bundle: { type: "positional", required: false, description: "bundle 名" },
+    port: { type: "string", description: `本地端口（默认从 atombundle.json 读取，否则 ${DEFAULT_DEV_PORT}）` },
   },
   async run({ args }) {
-    intro(pc.cyan(`本地运行 ${args.bundle}`))
     const ctx = await loadContext()
     if (!ctx) {
       log.error("未找到 atomfunctions.json")
       process.exit(1)
     }
-    const bundleDir = path.join(ctx.root, args.bundle)
 
-    const config = await readJson<BundleConfig>(path.join(bundleDir, BUNDLE_FILE))
+    let bundle: string
+    if (typeof args.bundle === "string") {
+      if (!isValidSlug(args.bundle)) {
+        log.error("bundle 名需以小写字母开头，仅含小写字母、数字、连字符")
+        process.exit(1)
+      }
+      bundle = args.bundle
+    } 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 bundleDir = path.join(ctx.root, BUNDLES_DIR, bundle)
+    const configPath = path.join(bundleDir, BUNDLE_FILE)
+    const config = await readJson<BundleConfig>(configPath)
     if (!config) {
-      log.error(`未找到 ${args.bundle}/${BUNDLE_FILE}`)
+      log.error(`未找到 ${BUNDLES_DIR}/${bundle}/${BUNDLE_FILE}`)
       process.exit(1)
     }
     if (config.language !== "bun") {
@@ -34,16 +82,50 @@ export const devCommand = defineCommand({
       process.exit(1)
     }
 
+    const defaultPort = args.port ? Number(args.port) : (config.dev?.port ?? DEFAULT_DEV_PORT)
+    if (Number.isNaN(defaultPort) || defaultPort < 1 || defaultPort > 65535) {
+      log.error("端口号不合法，范围 1-65535")
+      process.exit(1)
+    }
+
+    const portStr = unwrap(
+      await text({
+        message: "监听端口",
+        initialValue: String(defaultPort),
+        validate: (v) => {
+          const n = Number(v)
+          if (Number.isNaN(n) || n < 1 || n > 65535) return "端口号不合法，范围 1-65535"
+        },
+      }),
+    ).trim()
+    const port = Number(portStr)
+
+    const pf = pidFile(bundleDir)
+    if (existsSync(pf)) {
+      const oldPid = Number(await Bun.file(pf).text().catch(() => ""))
+      if (oldPid && isProcessAlive(oldPid)) {
+        log.error(`bundle ${bundle} 已在运行中（pid ${oldPid}）`)
+        process.exit(1)
+      }
+      await rm(pf, { force: true })
+    }
+
+    if (await isPortInUse(port)) {
+      log.error(`端口 ${port} 已被占用，请更换`)
+      process.exit(1)
+    }
+
     const functions = await resolveFunctions(bundleDir, config.defaults)
     if (functions.length === 0) {
       log.error("该 bundle 内没有函数")
       process.exit(1)
     }
 
-    const port = Number(args.port ?? DEFAULT_DEV_PORT)
+    intro(pc.cyan(`本地开发 ${bundle}`))
+
     const entryPath = await writeEntry(bundleDir, functions)
     log.info(`函数：${functions.map((f) => f.name).join("、")}`)
-    log.info(pc.dim(`http://localhost:${port}/__invoke/<function>`))
+    log.info(pc.dim(`http://localhost:${port}/invoke/<function>`))
 
     const proc = Bun.spawn(["bun", "--watch", entryPath], {
       cwd: bundleDir,
@@ -52,20 +134,80 @@ export const devCommand = defineCommand({
         ...process.env,
         ...config.env,
         ATOMFN_PROJECT: ctx.project,
-        ATOMFN_BUNDLE: args.bundle,
+        ATOMFN_BUNDLE: bundle,
         ATOMFN_PORT: String(port),
       },
     })
 
-    const cleanup = async () => {
+    await writeFile(pf, String(proc.pid))
+
+    // write back port if changed
+    const prevPort = config.dev?.port
+    if (port !== prevPort) {
+      config.dev = { ...config.dev, port }
+      await writeJson(configPath, config)
+    }
+
+    const onExit = async () => {
       proc.kill()
       await rm(entryPath, { force: true })
+      await rm(pf, { force: true })
       process.exit(0)
     }
-    process.on("SIGINT", cleanup)
-    process.on("SIGTERM", cleanup)
+    process.on("SIGINT", onExit)
+    process.on("SIGTERM", onExit)
 
     await proc.exited
     await rm(entryPath, { force: true })
+    await rm(pf, { force: true })
+  },
+})
+
+const stopCommand = defineCommand({
+  meta: { name: "stop", description: "停止本地开发服务器" },
+  async run() {
+    const ctx = await loadContext()
+    if (!ctx) {
+      log.error("未找到 atomfunctions.json")
+      process.exit(1)
+    }
+
+    const bundles = await listBundles(ctx.root)
+    let stopped = 0
+    for (const b of bundles) {
+      const pf = pidFile(path.join(ctx.root, BUNDLES_DIR, b))
+      if (!existsSync(pf)) continue
+      const pid = Number(await Bun.file(pf).text().catch(() => ""))
+      if (!pid) continue
+      if (isProcessAlive(pid)) {
+        try {
+          process.kill(pid, "SIGTERM")
+          stopped++
+        } catch {
+          // already gone
+        }
+      }
+      await rm(pf, { force: true })
+    }
+
+    if (stopped === 0) {
+      outro("没有正在运行的 dev 服务")
+    } else {
+      outro(pc.green(`已停止 ${stopped} 个 dev 服务`))
+    }
   },
 })
+
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export const devCommand = defineCommand({
+  meta: { name: "dev", description: "本地开发服务器" },
+  subCommands: { start: startCommand, stop: stopCommand },
+})

package/src/consts.ts

@@ -5,6 +5,7 @@ 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 DEV_PID_FILE = ".atomfn-dev.pid"
 export const SCHEMAS_DIR = "schemas"
 export const FUNCTION_FILE = "function.ts"
 export const FUNCTION_CONFIG_FILE = "function.json"

package/src/index.ts

@@ -10,7 +10,6 @@ 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"
@@ -34,7 +33,6 @@ export const mainCommand = defineCommand({
     function: functionCommand,
     push: pushCommand,
     pull: pullCommand,
-    new: newCommand,
     dev: devCommand,
     deploy: deployCommand,
     list: listCommand,

package/src/types.ts

@@ -47,6 +47,7 @@ export interface BundleConfig {
   defaults?: FunctionFileConfig
   functions?: string[]
   env?: Record<string, string>
+  dev?: { port?: number }
 }
 
 export interface DeployManifest {

package/src/commands/new.ts

@@ -1,68 +0,0 @@
-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 进行部署"))
-  },
-})