@atomservice/functions-cli 0.1.6 → 0.1.8

package/src/commands/invoke.ts

@@ -1,40 +1,211 @@
-import { intro, log, outro } from "@clack/prompts"
+import { intro, isCancel, log, outro, select, spinner, text } from "@clack/prompts"
+import { JSON5 } from "bun"
 import { defineCommand } from "citty"
 import pc from "picocolors"
+import { AdminClient } from "../client.ts"
 import { pickTarget, requireProjectContext } from "../context.ts"
+import type { ServerTarget } from "../types.ts"
 import { parseRef } from "../utils.ts"
 
+function normalizeBody(raw: string): string {
+  const trimmed = raw.trim()
+  if (!trimmed) return ""
+  return JSON.stringify(JSON5.parse(trimmed))
+}
+
 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 读取）" },
+    server: { type: "string", description: "指定机器（不填则交互式选择）" },
+    ref: { type: "positional", description: "<bundle>/<function>（不填则交互式选择）", required: false },
+    data: { type: "string", description: "JSON 请求体，支持 @file.json（不填则交互式输入）" },
   },
   async run({ args }) {
-    const { bundle, fn } = parseRef(args.ref)
-    if (!fn) {
-      log.error("请使用 <bundle>/<function> 格式")
-      process.exit(1)
+    let refBundle: string | undefined
+    let refFn: string | undefined
+    if (args.ref) {
+      try {
+        const parsed = parseRef(args.ref)
+        refBundle = parsed.bundle
+        refFn = parsed.fn
+      } catch (err) {
+        log.error(err instanceof Error ? err.message : "引用格式错误")
+        process.exit(1)
+      }
     }
 
-    intro(pc.cyan(`调用 ${bundle}/${fn}`))
+    intro(pc.cyan("调用函数"))
     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 target: ServerTarget
+    if (typeof args.server === "string") {
+      target = pickTarget(ctx, args.server)
+    } else if (ctx.targets.length === 1 && ctx.targets[0]) {
+      target = ctx.targets[0]
+    } else {
+      const options = ctx.targets.map((t, i) => ({ value: String(i), label: t.host, hint: t.server }))
+      const selected = await select({
+        message: "选择目标机器",
+        options,
+        initialValue: "0",
+      })
+      if (isCancel(selected)) {
+        outro(pc.yellow("已取消"))
+        return
+      }
+      const idx = Number(selected)
+      const t = ctx.targets[idx]
+      if (!t) {
+        log.error("无效的目标机器")
+        process.exit(1)
+      }
+      target = t
+    }
+
+    const client = new AdminClient(target.server, target.token)
+
+    const s = spinner()
+    s.start("获取函数包列表")
+    let serverBundles: Awaited<ReturnType<typeof client.list>>
+    try {
+      serverBundles = await client.list(ctx.project)
+    } catch (err) {
+      s.stop(pc.red("获取失败"))
+      log.error(err instanceof Error ? err.message : "获取函数包列表失败")
+      process.exit(1)
+    }
+
+    let bundle: string
+    let bundleRecord: (typeof serverBundles)[number] | undefined
+    if (refBundle) {
+      bundle = refBundle
+      bundleRecord = serverBundles.find((b) => b.bundle === bundle)
+    } else {
+      s.stop(pc.dim(target.host))
+      if (serverBundles.length === 0) {
+        log.warn("该机器上没有已部署的函数包")
+        return
+      }
+      const selected = await select({
+        message: "选择 bundle",
+        options: serverBundles.map((b) => ({ value: b.bundle, label: b.bundle, hint: `${b.artifact}:${b.version}` })),
+      })
+      if (isCancel(selected)) {
+        outro(pc.yellow("已取消"))
+        return
+      }
+      bundle = selected as string
+      bundleRecord = serverBundles.find((b) => b.bundle === bundle)
+      s.start()
+    }
+
+    if (!bundleRecord || bundleRecord.functions.length === 0) {
+      s.stop(pc.red("无函数"))
+      log.error(`bundle ${bundle} 没有已部署的函数`)
+      process.exit(1)
+    }
+    const fnList = bundleRecord.functions
+    s.stop(pc.dim(`${bundle}  ${target.host}`))
 
+    let fn: string
+    if (refFn) {
+      if (!fnList.includes(refFn)) {
+        log.error(`函数 ${refFn} 不在 ${bundle} 中，可用：${fnList.join("、")}`)
+        process.exit(1)
+      }
+      fn = refFn
+    } else {
+      const selected = await select({
+        message: "选择函数",
+        options: fnList.map((f) => ({ value: f, label: f })),
+      })
+      if (isCancel(selected)) {
+        outro(pc.yellow("已取消"))
+        return
+      }
+      fn = selected as string
+    }
+
+    let body: string
+    if (args.data !== undefined) {
+      if (args.data.startsWith("@")) {
+        const filePath = args.data.slice(1)
+        try {
+          body = normalizeBody(await Bun.file(filePath).text())
+        } catch {
+          log.error(`无法读取文件：${filePath}`)
+          process.exit(1)
+        }
+      } else {
+        body = normalizeBody(args.data)
+      }
+    } else {
+      const input = await text({
+        message: "请求体（JSON/JSON5）",
+        placeholder: "留空表示无请求体",
+        validate: (v) => {
+          if (!v || v.trim() === "") return undefined
+          try {
+            JSON5.parse(v.trim())
+            return undefined
+          } catch {
+            return "JSON/JSON5 格式错误"
+          }
+        },
+      })
+      if (isCancel(input)) {
+        outro(pc.yellow("已取消"))
+        return
+      }
+      body = normalizeBody(input as string)
+    }
+
+    const url = `${target.server.replace(/\/+$/, "")}/${ctx.project}/${bundle}/${fn}`
+    const s2 = spinner()
+    s2.start(`调用 ${bundle}/${fn}`)
     let res: Response
     try {
-      res = await fetch(url, { method: "POST", headers: { "content-type": "application/json" }, body })
+      const headers: Record<string, string> = {
+        authorization: `Bearer ${target.token}`,
+      }
+      if (body) headers["content-type"] = "application/json"
+      res = await fetch(url, { method: "POST", headers, body: body || undefined })
     } catch {
+      s2.stop(pc.red("调用失败"))
       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}`))
+    const resText = await res.text()
+    s2.stop(pc.dim(`${bundle}/${fn}  ${target.host}`))
+
+    const statusColor = res.ok ? pc.green : pc.red
+    log.info(statusColor(`${res.status} ${res.statusText}`))
+
+    let parsed: unknown
+    try {
+      parsed = resText ? JSON.parse(resText) : undefined
+    } catch {
+      parsed = undefined
+    }
+
+    if (!res.ok) {
+      const errObj =
+        parsed && typeof parsed === "object" && "error" in parsed
+          ? (parsed as { error?: { code?: string; message?: string } }).error
+          : undefined
+      if (errObj?.message) {
+        log.error(`${errObj.message}${errObj.code ? pc.dim(`（${errObj.code}）`) : ""}`)
+      } else if (resText.trim()) {
+        log.error(resText.trim())
+      } else {
+        log.error(`请求失败（${res.status}），服务端未返回错误信息`)
+      }
+      process.exitCode = 1
+      return
+    }
+
+    const output = parsed !== undefined ? JSON.stringify(parsed, null, 2) : resText
+    if (output) process.stdout.write(`\n${output}\n`)
   },
 })

package/src/commands/list.ts

@@ -1,20 +1,50 @@
-import { intro, log, outro } from "@clack/prompts"
+import { intro, isCancel, log, outro, select, spinner } from "@clack/prompts"
 import { defineCommand } from "citty"
 import pc from "picocolors"
 import { AdminClient } from "../client.ts"
 import { pickTarget, requireProjectContext } from "../context.ts"
+import type { ServerTarget } from "../types.ts"
 
 export const listCommand = defineCommand({
   meta: { name: "list", description: "列出已部署的函数包" },
   args: {
-    server: { type: "string", description: "指定查询的机器（默认首台）" },
+    server: { type: "string", description: "指定机器（不填则交互式选择）" },
   },
   async run({ args }) {
     intro(pc.cyan("已部署函数包"))
     const ctx = await requireProjectContext()
-    const target = pickTarget(ctx, args.server)
+
+    let target: ServerTarget
+    if (typeof args.server === "string") {
+      target = pickTarget(ctx, args.server)
+    } else if (ctx.targets.length === 1) {
+      target = ctx.targets[0]!
+    } else {
+      const options = ctx.targets.map((t, i) => ({ value: String(i), label: t.host, hint: t.server }))
+      const selected = await select({
+        message: "选择目标机器",
+        options,
+        initialValue: "0",
+      })
+      if (isCancel(selected)) {
+        outro(pc.yellow("已取消"))
+        return
+      }
+      target = ctx.targets[Number(selected)]!
+    }
+
     const client = new AdminClient(target.server, target.token)
-    const bundles = await client.list(ctx.project)
+    const s = spinner()
+    s.start("获取函数包列表")
+    let bundles: Awaited<ReturnType<typeof client.list>>
+    try {
+      bundles = await client.list(ctx.project)
+    } catch (err) {
+      s.stop(pc.red("获取失败"))
+      log.error(err instanceof Error ? err.message : "获取函数包列表失败")
+      process.exit(1)
+    }
+    s.stop(pc.dim(target.host))
 
     if (bundles.length === 0) {
       log.warn("当前项目暂无已部署的函数包")
@@ -24,7 +54,7 @@ export const listCommand = defineCommand({
 
     for (const b of bundles) {
       log.info(
-        `${pc.bold(`${b.project}/${b.bundle}`)} ${pc.dim(`${b.artifact}:${b.version}`)}\n  函数：${b.functions.join("、")}`,
+        `${pc.bold(b.bundle)}  ${pc.dim(`${b.artifact}:${b.version}`)}\n  函数：${b.functions.join(", ")}`,
       )
     }
     outro(pc.green(`共 ${bundles.length} 个函数包`))

package/src/commands/logs.ts

@@ -1,29 +1,105 @@
-import { intro, log, outro } from "@clack/prompts"
+import { intro, isCancel, log, outro, select, spinner, text } from "@clack/prompts"
 import { defineCommand } from "citty"
 import pc from "picocolors"
 import { AdminClient } from "../client.ts"
 import { pickTarget, requireProjectContext } from "../context.ts"
+import type { ServerTarget } from "../types.ts"
 
 export const logsCommand = defineCommand({
-  meta: { name: "logs", description: "查看函数包日志（指定机器）" },
+  meta: { name: "logs", description: "查看函数包日志" },
   args: {
-    bundle: { type: "positional", description: "bundle 名", required: true },
-    server: { type: "string", description: "指定机器（默认首台，日志按机器区分）" },
+    server: { type: "string", description: "指定机器（不填则交互式选择）" },
+    bundle: { type: "positional", description: "bundle 名（不填则交互式选择）", required: false },
     tail: { type: "string", description: "末尾行数（默认 200）" },
   },
   async run({ args }) {
-    intro(pc.cyan(`日志 ${args.bundle}`))
+    intro(pc.cyan("查看日志"))
     const ctx = await requireProjectContext()
-    const target = pickTarget(ctx, args.server)
+
+    let target: ServerTarget
+    if (typeof args.server === "string") {
+      target = pickTarget(ctx, args.server)
+    } else if (ctx.targets.length === 1) {
+      target = ctx.targets[0]!
+    } else {
+      const options = ctx.targets.map((t, i) => ({ value: String(i), label: t.host, hint: t.server }))
+      const selected = await select({
+        message: "选择目标机器",
+        options,
+        initialValue: "0",
+      })
+      if (isCancel(selected)) {
+        outro(pc.yellow("已取消"))
+        return
+      }
+      target = ctx.targets[Number(selected)]!
+    }
+
     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("暂无日志")
+    let bundle: string
+    if (args.bundle) {
+      bundle = args.bundle
     } else {
-      process.stdout.write(`${text}\n`)
+      const s = spinner()
+      s.start("获取函数包列表")
+      let serverBundles: Awaited<ReturnType<typeof client.list>>
+      try {
+        serverBundles = await client.list(ctx.project)
+      } catch (err) {
+        s.stop(pc.red("获取失败"))
+        log.error(err instanceof Error ? err.message : "获取函数包列表失败")
+        process.exit(1)
+      }
+      s.stop(pc.dim(target.host))
+
+      if (serverBundles.length === 0) {
+        log.warn("该机器上没有已部署的函数包")
+        return
+      }
+      const selected = await select({
+        message: "选择 bundle",
+        options: serverBundles.map((b) => ({ value: b.bundle, label: b.bundle, hint: `${b.artifact}:${b.version}` })),
+      })
+      if (isCancel(selected)) {
+        outro(pc.yellow("已取消"))
+        return
+      }
+      bundle = selected as string
+    }
+
+    let tail: number
+    if (args.tail !== undefined) {
+      tail = Number(args.tail)
+      if (!Number.isFinite(tail) || tail <= 0) tail = 200
+    } else {
+      const input = await text({
+        message: "查看末尾行数",
+        initialValue: "200",
+        validate: (v) => (v && /^\d+$/.test(v) && Number(v) > 0 ? undefined : "请输入正整数"),
+      })
+      if (isCancel(input)) {
+        outro(pc.yellow("已取消"))
+        return
+      }
+      tail = Number(input)
+    }
+
+    const s = spinner()
+    s.start(`获取 ${bundle} 日志`)
+    try {
+      const logText = await client.logs(ctx.project, bundle, tail)
+      s.stop(pc.dim(`${bundle}  ${target.host}`))
+      if (!logText.trim()) {
+        log.warn("暂无日志")
+      } else {
+        process.stdout.write(`${logText}\n`)
+      }
+    } catch (err) {
+      s.stop(pc.red("获取失败"))
+      log.error(err instanceof Error ? err.message : "获取日志失败")
+      process.exit(1)
     }
-    outro(pc.green("已结束"))
   },
 })
+

package/src/commands/rollback.ts

@@ -1,56 +1,182 @@
-import { intro, log, outro, select } from "@clack/prompts"
+import { intro, isCancel, log, multiselect, outro, select, spinner } 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"
+import type { BundleRecord, ServerTarget } from "../types.ts"
+
+type BundlesOnHost = { host: string; server: string; token: string; bundles: BundleRecord[] }
+type VersionsOnHost = { host: string; server: string; token: string; versions: BundleRecord[] }
+
+function commonOf<T>(results: T[], pick: (r: T) => string[]): string[] {
+  const sets = results.map((r) => new Set(pick(r)))
+  const all = [...new Set(results.flatMap((r) => pick(r)))]
+  return all.filter((name) => sets.every((s) => s.has(name)))
+}
+
+function missingWarnings<T>(results: T[], pick: (r: T) => string[], common: string[], label: string): void {
+  const all = [...new Set(results.flatMap((r) => pick(r)))]
+  for (const name of all) {
+    if (common.includes(name)) continue
+    const missingOn = results.filter((r) => !pick(r).includes(name)).map((r) => (r as BundlesOnHost).host)
+    log.warn(`${name} 未在 ${missingOn.join("、")} ${label}`)
+  }
+}
+
+function formatTime(iso: string): string {
+  return new Date(iso).toLocaleString("zh-CN", { hour12: false })
+}
 
 export const rollbackCommand = defineCommand({
-  meta: { name: "rollback", description: "回滚函数包到历史版本（扇出到所有机器）" },
+  meta: { name: "rollback", description: "回滚函数包到历史版本" },
   args: {
-    bundle: { type: "positional", description: "bundle 名", required: true },
+    bundle: { type: "positional", description: "bundle 名（不填则交互式选择）", required: false },
+    server: { type: "string", description: "指定机器（不填则交互式选择）" },
     version: { type: "string", description: "目标版本（不填则从历史中选择）" },
   },
   async run({ args }) {
-    intro(pc.cyan(`回滚 ${args.bundle}`))
+    intro(pc.cyan("回滚函数包"))
     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,
-          })),
+    let targets: ServerTarget[]
+    if (typeof args.server === "string") {
+      targets = [pickTarget(ctx, args.server)]
+    } else if (ctx.targets.length === 1) {
+      targets = [ctx.targets[0]!]
+    } else {
+      const options = ctx.targets.map((t, i) => ({ value: String(i), label: t.host, hint: t.server }))
+      const selected = await multiselect({
+        message: "选择目标机器",
+        options,
+        required: true,
+        initialValues: ctx.targets.map((_, i) => String(i)),
+      })
+      if (isCancel(selected)) {
+        outro(pc.yellow("已取消"))
+        return
+      }
+      targets = (selected as string[]).map((i) => ctx.targets[Number(i)]!)
+    }
+
+    const bundlesResults: BundlesOnHost[] = []
+    for (const t of targets) {
+      try {
+        const c = new AdminClient(t.server, t.token)
+        bundlesResults.push({ host: t.host, server: t.server, token: t.token, bundles: await c.list(ctx.project) })
+      } catch (err) {
+        log.error(`${t.host}: ${err instanceof Error ? err.message : "获取函数包列表失败"}`)
+        process.exit(1)
+      }
+    }
+
+    const commonBundles = commonOf(bundlesResults, (r) => r.bundles.map((b) => b.bundle))
+    missingWarnings(bundlesResults, (r) => r.bundles.map((b) => b.bundle), commonBundles, "上部署")
+
+    if (commonBundles.length === 0) {
+      log.error("选中机器上没有共同部署的函数包")
+      process.exitCode = 1
+      return
+    }
+
+    let bundle: string
+    if (args.bundle) {
+      if (!commonBundles.includes(args.bundle)) {
+        const missingOn = bundlesResults.filter((r) => !r.bundles.some((b) => b.bundle === args.bundle)).map((r) => r.host)
+        log.error(`bundle ${args.bundle} 未在 ${missingOn.join("、")} 上部署`)
+        process.exit(1)
+      }
+      bundle = args.bundle
+    } else {
+      const firstBundles = bundlesResults[0]!.bundles
+      const selected = await select({
+        message: "选择 bundle",
+        options: commonBundles.map((name) => {
+          const record = firstBundles.find((b) => b.bundle === name)
+          return { value: name, label: name, hint: record ? `${record.artifact}:${record.version}` : undefined }
         }),
-      ) as string
+      })
+      if (isCancel(selected)) {
+        outro(pc.yellow("已取消"))
+        return
+      }
+      bundle = selected as string
     }
 
+    const versionResults: VersionsOnHost[] = []
+    for (const t of targets) {
+      try {
+        const c = new AdminClient(t.server, t.token)
+        versionResults.push({ host: t.host, server: t.server, token: t.token, versions: await c.versions(ctx.project, bundle) })
+      } catch (err) {
+        log.error(`${t.host}: ${err instanceof Error ? err.message : "获取版本历史失败"}`)
+        process.exit(1)
+      }
+    }
+
+    const commonVersions = commonOf(versionResults, (r) => r.versions.map((v) => v.version))
+    missingWarnings(versionResults, (r) => r.versions.map((v) => v.version), commonVersions, "上不存在该版本")
+
+    if (commonVersions.length === 0) {
+      log.error(`选中机器上没有 ${bundle} 的共同版本`)
+      process.exitCode = 1
+      return
+    }
+
+    let version: string
+    if (args.version) {
+      if (!commonVersions.includes(args.version)) {
+        const missingOn = versionResults.filter((r) => !r.versions.some((v) => v.version === args.version)).map((r) => r.host)
+        log.error(`版本 ${args.version} 未在 ${missingOn.join("、")} 上存在`)
+        process.exit(1)
+      }
+      version = args.version
+    } else {
+      const firstVersions = versionResults[0]!.versions
+      const options = commonVersions.map((ver) => {
+        const record = firstVersions.find((v) => v.version === ver)
+        const isLatest = versionResults.every((r) => r.versions[0]?.version === ver)
+        return {
+          value: ver,
+          label: `${ver}${isLatest ? pc.dim(" (当前)") : ""}`,
+          hint: record ? formatTime(record.updatedAt) : undefined,
+        }
+      })
+      const selected = await select({
+        message: "选择回滚到的版本",
+        options,
+      })
+      if (isCancel(selected)) {
+        outro(pc.yellow("已取消"))
+        return
+      }
+      version = selected as string
+    }
+
+    if (targets.length > 1) log.info(pc.dim(`目标机器：${targets.map((t) => t.host).join("、")}`))
+
+    const s = spinner()
+    s.start(`回滚 ${bundle}`)
     const results = await Promise.all(
-      ctx.targets.map(async (t) => {
+      targets.map(async (t) => {
         try {
-          await new AdminClient(t.server, t.token).rollback(ctx.project, args.bundle, version as string)
+          await new AdminClient(t.server, t.token).rollback(ctx.project, bundle, version)
           return { host: t.host, ok: true }
         } catch (error) {
           return { host: t.host, ok: false, message: error instanceof Error ? error.message : String(error) }
         }
       }),
     )
+    s.stop(pc.dim(`${bundle}  ${targets.map((t) => t.host).join("、")}`))
 
-    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
+    let hasError = false
+    for (const r of results) {
+      if (r.ok) {
+        log.success(`${r.host}  已回滚`)
+      } else {
+        log.error(`${r.host}  ${r.message ?? "回滚失败"}`)
+        hasError = true
+      }
     }
+    if (hasError) process.exitCode = 1
   },
 })

package/src/commands/whoami.ts

@@ -37,13 +37,17 @@ export const whoamiCommand = defineCommand({
     }
 
     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("超级管理员")}`)
+    try {
+      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("超级管理员")}`)
+      }
+    } catch (err) {
+      outro(pc.red(err instanceof Error ? err.message : "获取用户信息失败"))
+      process.exit(1)
     }
 
     outro(pc.green("已登录"))

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"
@@ -17,6 +18,7 @@ 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 RUST_SLUG_RE = /^[a-z][a-z0-9_]*$/
 export const VIEWS_DIR = "views"
 export const LOCAL_DIR = "local"
 export const REMOTE_DIR = "remote"
@@ -24,6 +26,7 @@ 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 RUST_SDK_VERSION = "0.1.4"
 export const LINUX_TARGET = "bun-linux-x64"
 export const DEFAULT_DEV_PORT = 8080