@xyit/wellspring 0.0.0-stage → 1.1.0

package/src/commands/plugin.ts

@@ -0,0 +1,222 @@
+/*
+ * plugin 命令：list / install / link / remove。
+ */
+
+import { readFile, readdir } from "node:fs/promises"
+import { basename, join } from "node:path"
+
+import { Result } from "../api/result/result.ts"
+import { USAGE_CODES } from "../input/codes.ts"
+import { booleanValue, parseCommandArgs } from "../input/parse-options.ts"
+import type { ResolvedPaths } from "../platform/path.ts"
+import { statIfExists } from "../platform/file.ts"
+import { installPlugin } from "../plugin/install.ts"
+import { linkPlugin, removePlugin } from "../plugin/loader.ts"
+import { PLUGIN_NAME, pluginsRoot } from "../plugin/paths.ts"
+import { scaffoldPlugin } from "../plugin/scaffold.ts"
+import { readPluginState, setPluginEnabled } from "../plugin/state.ts"
+import { failure, success, type CommandContext, type CommandOutcome } from "./shared.ts"
+
+interface ScannedPlugin {
+    readonly dirName: string
+    readonly name: string
+    readonly version: string
+    readonly enabled: boolean
+    readonly deps: readonly string[]
+}
+
+/** 只扫插件目录的文件，不启动插件进程（plugin list / enable / disable 用） */
+async function scanPluginDirs(paths: ResolvedPaths): Promise<ScannedPlugin[]> {
+    const root = pluginsRoot(paths)
+    const disabled = await readPluginState(paths)
+    let names: string[]
+    try {
+        names = (await readdir(root)).sort()
+    } catch {
+        return []
+    }
+    const plugins: ScannedPlugin[] = []
+    for (const dirName of names) {
+        if (!PLUGIN_NAME.test(dirName) || dirName.startsWith(".")) continue
+        const dir = join(root, dirName)
+        const info = await statIfExists(dir)
+        if (info === null || !info.isDirectory()) continue
+        let name = dirName
+        let version = "0.0.0"
+        try {
+            const pkg = JSON.parse(await readFile(join(dir, "package.json"), "utf8")) as {
+                name?: unknown
+                version?: unknown
+            }
+            if (typeof pkg.name === "string" && pkg.name !== "") name = pkg.name
+            if (typeof pkg.version === "string" && pkg.version !== "") version = pkg.version
+        } catch {
+            /* 没有 package.json 时用目录名 */
+        }
+        let deps: string[] = []
+        try {
+            const source = await readFile(join(dir, "index.ts"), "utf8")
+            const match = /deps\s*:\s*\[([^\]]*)\]/.exec(source)
+            if (match !== null) {
+                deps = [...(match[1] ?? "").matchAll(/["']([^"']+)["']/g)].map(
+                    (item) => item[1] ?? "",
+                )
+            }
+        } catch {
+            /* 读不到入口时按没有依赖处理 */
+        }
+        plugins.push({
+            dirName,
+            name,
+            version,
+            enabled: !disabled.has(dirName),
+            deps: deps.filter((dep) => dep !== ""),
+        })
+    }
+    return plugins
+}
+
+/** 依赖目标插件的其它插件目录名 */
+function dependentsOf(
+    plugins: readonly ScannedPlugin[],
+    dirName: string,
+    pluginName: string,
+): string[] {
+    return plugins
+        .filter(
+            (plugin) =>
+                plugin.dirName !== dirName &&
+                (plugin.deps.includes(dirName) || plugin.deps.includes(pluginName)),
+        )
+        .map((plugin) => plugin.dirName)
+}
+
+export async function runPluginCommand(
+    ctx: CommandContext,
+    argv: readonly string[],
+): Promise<CommandOutcome> {
+    const [subcommand, ...rest] = argv
+    const parsed = parseCommandArgs(rest, {
+        force: { type: "boolean" },
+        ignore: { type: "boolean" },
+        dir: { type: "string" },
+    })
+    if (!parsed.isSuccess()) {
+        return { result: Result.error<unknown>(parsed.getCode() ?? USAGE_CODES.invalidValue) }
+    }
+    const line = parsed.getData()
+    if (line === null) {
+        return failure(USAGE_CODES.invalidValue)
+    }
+    const force = booleanValue(line.values, "force")
+    const ignore = booleanValue(line.values, "ignore")
+
+    try {
+        switch (subcommand) {
+            case "list": {
+                const plugins = await scanPluginDirs(ctx.paths)
+                for (const plugin of plugins) {
+                    const deps = plugin.deps.length === 0 ? "-" : plugin.deps.join(",")
+                    const status = plugin.enabled ? "enabled" : "disabled"
+                    ctx.elog.print(
+                        `${plugin.dirName}  ${plugin.name}@${plugin.version}  ${status}  deps=${deps}`,
+                    )
+                }
+                return success(plugins)
+            }
+            case "new": {
+                const name = line.positionals[0]
+                if (name === undefined) {
+                    return failure(`${USAGE_CODES.missingValue}:name`)
+                }
+                const created = await scaffoldPlugin({
+                    name,
+                    parentDir:
+                        typeof line.values["dir"] === "string" ? line.values["dir"] : undefined,
+                    force,
+                })
+                ctx.elog.info(`已创建插件 ${name}：${created.dir}`)
+                ctx.elog.print("下一步：")
+                ctx.elog.print(`  wellspring plugin link ${created.dir}`)
+                ctx.elog.print(`  wellspring plugin list`)
+                ctx.elog.print(`  wellspring ${created.commandName}`)
+                ctx.elog.print("类型检查：先把 Wellspring 链接进插件（见插件 README）")
+                return success(created)
+            }
+            case "enable":
+            case "disable": {
+                const name = line.positionals[0]
+                if (name === undefined) {
+                    return failure(`${USAGE_CODES.missingValue}:name`)
+                }
+                if (!PLUGIN_NAME.test(name)) {
+                    return failure(`${USAGE_CODES.invalidValue}:name`)
+                }
+                const plugins = await scanPluginDirs(ctx.paths)
+                const match =
+                    plugins.find((plugin) => plugin.dirName === name) ??
+                    plugins.find((plugin) => plugin.name === name)
+                const dirName = match === undefined ? name : match.dirName
+                const dir = join(pluginsRoot(ctx.paths), dirName)
+                if ((await statIfExists(dir)) === null) {
+                    return failure(`plugin.not-found:${name}`)
+                }
+                const enabled = subcommand === "enable"
+                await setPluginEnabled(dirName, enabled, ctx.paths)
+                ctx.elog.info(`${enabled ? "已启用" : "已禁用"}插件 ${dirName}（下次运行生效）`)
+                return success({ id: dirName, enabled })
+            }
+            case "install": {
+                const source = line.positionals[0]
+                if (source === undefined) {
+                    return failure(`${USAGE_CODES.missingValue}:path`)
+                }
+                const installed = await installPlugin(source, ctx.paths, { force })
+                ctx.elog.info(
+                    installed.dependenciesInstalled
+                        ? `已安装插件 ${installed.id}，已用 ${installed.packageManager ?? "包管理器"} 安装依赖`
+                        : `已安装插件 ${installed.id}`,
+                )
+                return success(installed)
+            }
+            case "link": {
+                const source = line.positionals[0]
+                if (source === undefined) {
+                    return failure(`${USAGE_CODES.missingValue}:path`)
+                }
+                const name = await linkPlugin(source, ctx.paths)
+                ctx.elog.info(`已链接插件 ${name}`)
+                return success({ id: name })
+            }
+            case "remove": {
+                const name = line.positionals[0]
+                if (name === undefined) {
+                    return failure(`${USAGE_CODES.missingValue}:name`)
+                }
+                const plugins = await scanPluginDirs(ctx.paths)
+                const target =
+                    plugins.find((plugin) => plugin.dirName === name) ??
+                    plugins.find((plugin) => plugin.name === name)
+                const dirName = target === undefined ? name : target.dirName
+                const dependents = dependentsOf(plugins, dirName, target?.name ?? dirName)
+                if (dependents.length > 0 && !ignore) {
+                    ctx.elog.error(
+                        `插件 ${dirName} 被这些插件依赖：${dependents.join(", ")}；` +
+                            "确认要强制卸载请加 --ignore",
+                    )
+                    return failure(`plugin.has-dependents:${dependents.join(",")}`)
+                }
+                await removePlugin(dirName, ctx.paths)
+                ctx.elog.info(
+                    `已删除插件 ${dirName}${ignore && dependents.length > 0 ? "（忽略依赖）" : ""}`,
+                )
+                return success({ id: dirName })
+            }
+            default:
+                return failure(`${USAGE_CODES.unknownSubcommand}:plugin ${subcommand ?? ""}`)
+        }
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error)
+        return failure(`plugin.install-failed:${message}`)
+    }
+}

package/src/commands/session.ts

@@ -0,0 +1,179 @@
+/*
+ * session 命令：list / show / delete。
+ */
+
+import { Result } from "../api/result/result.ts"
+import { USAGE_CODES } from "../input/codes.ts"
+import { booleanValue, parseCommandArgs, stringValue } from "../input/parse-options.ts"
+import { contentText } from "../session/replay.ts"
+import { SessionStore, type SessionData } from "../session/store.ts"
+import type { SessionEvent } from "../session/types.ts"
+import { failure, success, type CommandContext, type CommandOutcome } from "./shared.ts"
+
+function truncate(text: string, full: boolean): string {
+    if (full || text.length <= 200) {
+        return text
+    }
+    return `${text.slice(0, 200)}…`
+}
+
+function eventText(event: SessionEvent): string {
+    const message = event.data["message"]
+    if (typeof message !== "object" || message === null) {
+        return ""
+    }
+    const content = (message as { content?: unknown }).content
+    if (!Array.isArray(content)) {
+        return ""
+    }
+    return contentText(content as never)
+}
+
+function printSession(session: SessionData, full: boolean, ctx: CommandContext): void {
+    ctx.elog.print(`${session.meta.id}  ${session.meta.cwd}`)
+    for (const turn of session.turns) {
+        const mode = turn.mode ?? "chat"
+        ctx.elog.print(`#${turn.turn} [${mode}]`)
+        for (const event of turn.events) {
+            if (event.type === "user/message") {
+                ctx.elog.print(`  > ${truncate(eventText(event), full)}`)
+            } else if (event.type === "assistant/message") {
+                ctx.elog.print(`  ${truncate(eventText(event), full)}`)
+            } else if (event.type === "tool/call") {
+                const name = event.data["name"]
+                ctx.elog.print(`  [tool] ${String(name ?? "")}`)
+            } else if (event.type === "turn/end") {
+                const reason = event.data["reason"]
+                const kind =
+                    typeof reason === "object" && reason !== null
+                        ? ((reason as { kind?: unknown }).kind ?? "")
+                        : ""
+                ctx.elog.print(`  -- ${String(kind)}`)
+            }
+        }
+    }
+}
+
+async function handleList(ctx: CommandContext, args: readonly string[]): Promise<CommandOutcome> {
+    const parsed = parseCommandArgs(args, {
+        all: { type: "boolean" },
+        limit: { type: "string" },
+    })
+    if (!parsed.isSuccess()) {
+        return { result: Result.error<unknown>(parsed.getCode() ?? USAGE_CODES.invalidValue) }
+    }
+    const line = parsed.getData()
+    if (line === null) {
+        return failure(USAGE_CODES.invalidValue)
+    }
+    const rawLimit = stringValue(line.values, "limit")
+    let limit = 20
+    if (rawLimit !== undefined) {
+        const value = Number(rawLimit)
+        if (!Number.isInteger(value) || value <= 0) {
+            return failure(`${USAGE_CODES.invalidValue}:--limit`)
+        }
+        limit = value
+    }
+
+    const list = await new SessionStore().list({
+        cwd: process.cwd(),
+        all: booleanValue(line.values, "all"),
+        limit,
+    })
+    for (const item of list) {
+        ctx.elog.print(`${item.id}${item.last ? " *" : ""}  turns=${item.turns}  ${item.cwd}`)
+    }
+    return success(list.map((item) => ({ ...item, dir: undefined })))
+}
+
+async function handleShow(ctx: CommandContext, args: readonly string[]): Promise<CommandOutcome> {
+    const parsed = parseCommandArgs(args, {
+        full: { type: "boolean" },
+    })
+    if (!parsed.isSuccess()) {
+        return { result: Result.error<unknown>(parsed.getCode() ?? USAGE_CODES.invalidValue) }
+    }
+    const line = parsed.getData()
+    const id = line?.positionals[0]
+    if (id === undefined) {
+        return failure(`${USAGE_CODES.missingValue}:session-id`)
+    }
+    const session = await new SessionStore().open(id, process.cwd())
+    printSession(session, line !== null && booleanValue(line.values, "full"), ctx)
+    return success({ meta: session.meta, turns: session.turns })
+}
+
+async function handleDelete(ctx: CommandContext, args: readonly string[]): Promise<CommandOutcome> {
+    const parsed = parseCommandArgs(args, {
+        all: { type: "boolean" },
+        yes: { type: "boolean" },
+    })
+    if (!parsed.isSuccess()) {
+        return { result: Result.error<unknown>(parsed.getCode() ?? USAGE_CODES.invalidValue) }
+    }
+    const line = parsed.getData()
+    if (line === null) {
+        return failure(USAGE_CODES.invalidValue)
+    }
+    const all = booleanValue(line.values, "all")
+    const yes = booleanValue(line.values, "yes")
+    const store = new SessionStore()
+
+    if (all) {
+        if (!yes) {
+            return failure(USAGE_CODES.missingConfirmation)
+        }
+        const removed = await store.removeAll(process.cwd())
+        ctx.elog.info(`已删除 ${removed} 个会话`)
+        return success({ removed })
+    }
+
+    if (line.positionals.length === 0) {
+        return failure(`${USAGE_CODES.missingValue}:session-id`)
+    }
+    for (const id of line.positionals) {
+        await store.remove(id)
+        ctx.elog.info(`已删除 ${id}`)
+    }
+    return success({ removed: line.positionals })
+}
+
+export async function runSessionCommand(
+    ctx: CommandContext,
+    argv: readonly string[],
+): Promise<CommandOutcome> {
+    const [subcommand, ...rest] = argv
+    try {
+        switch (subcommand) {
+            case "list":
+                return await handleList(ctx, rest)
+            case "show":
+                return await handleShow(ctx, rest)
+            case "delete":
+                return await handleDelete(ctx, rest)
+            default:
+                return failure(`${USAGE_CODES.unknownSubcommand}:session ${subcommand ?? ""}`)
+        }
+    } catch (error) {
+        return failure(sessionErrorCode(error))
+    }
+}
+
+function sessionErrorCode(error: unknown): string {
+    if (error instanceof Error) {
+        if (error.name === "SessionNotFoundError") {
+            return "session.not-found"
+        }
+        if (error.name === "SessionAmbiguousError") {
+            return "session.ambiguous-id"
+        }
+        if (error.name === "SessionLockedError") {
+            return "session.locked"
+        }
+        if (error.message.includes("会话 id 不合法")) {
+            return USAGE_CODES.invalidSessionId
+        }
+    }
+    return "session.corrupted"
+}

package/src/commands/shared.ts

@@ -0,0 +1,103 @@
+/*
+ * 命令层公共类型与错误文案。
+ */
+
+import type { Logger } from "pino"
+
+import { Result } from "../api/result/result.ts"
+import type { AppSetting } from "../config/types.ts"
+import { isUsageCode } from "../input/codes.ts"
+import type { GlobalOptions } from "../input/types.ts"
+import type { Elog } from "../logger/elog4js.ts"
+import type { OpenAIClient } from "../network/openai.ts"
+import type { ResolvedPaths } from "../platform/path.ts"
+import type { LoadedPlugin } from "../plugin/loader.ts"
+import type { AgentToolRegistry } from "../plugin/agent-tools.ts"
+import type { PluginRegistry } from "../plugin/registry.ts"
+
+export interface CommandContext {
+    readonly global: GlobalOptions
+    readonly settings: AppSetting
+    readonly settingsFile: string
+    readonly configCode: string | null
+    readonly paths: ResolvedPaths
+    readonly logger: Logger
+    readonly elog: Elog
+    readonly registry: PluginRegistry
+    readonly agentTools: AgentToolRegistry
+    readonly openai: OpenAIClient | null
+    /** 当前生效的供应商 id 与模型（已按 models.* 解析）；测试上下文可省略 */
+    readonly activeProvider?: string
+    readonly activeModel?: string
+    readonly activeReasoning?: string
+    loadPlugins(): Promise<readonly LoadedPlugin[]>
+}
+
+export interface CommandOutcome {
+    readonly result: Result<unknown>
+}
+
+export function success(data?: unknown): CommandOutcome {
+    return { result: Result.successWithData<unknown>(data ?? null) }
+}
+
+export function failure(code: string): CommandOutcome {
+    return { result: Result.error<unknown>(code) }
+}
+
+const MESSAGES: Readonly<Record<string, string>> = {
+    "usage.unknown-command": "未知命令",
+    "usage.unknown-option": "未知参数",
+    "usage.unknown-subcommand": "未知子命令",
+    "usage.missing-value": "缺少参数值",
+    "usage.invalid-value": "参数值非法",
+    "usage.missing-context": "缺少对话内容",
+    "usage.invalid-session-id": "会话 id 不合法",
+    "usage.unknown-config-key": "配置项不存在",
+    "usage.conflicting-options": "参数互相冲突",
+    "usage.missing-confirmation": "缺少 --yes 确认",
+    "config.read-failed": "配置文件读取失败",
+    "config.parse-failed": "配置文件解析失败",
+    "config.invalid": "配置项非法",
+    "config.version-unsupported": "配置版本不受支持",
+    "config.write-failed": "配置文件写入失败",
+    "config.invalid-api-key": "API Key 格式不合法",
+    "config.credentials-write-failed": "凭据文件写入失败",
+    "openai.missing-api-key": "缺少 API Key（wellspring key set 或环境变量 OPENAI_API_KEY）",
+    "openai.empty-output": "模型返回空内容",
+    "openai.timeout": "模型请求超时",
+    "openai.connection-failed": "无法连接模型服务",
+    "openai.unauthorized": "模型服务鉴权失败",
+    "openai.forbidden": "模型服务拒绝访问",
+    "openai.rate-limited": "模型服务限流",
+    "openai.bad-request": "模型请求参数非法",
+    "openai.server-error": "模型服务内部错误",
+    "openai.request-failed": "模型请求失败",
+    "session.not-found": "会话不存在",
+    "session.parse-failed": "会话事件解析失败",
+    "session.corrupted": "会话段损坏",
+    "session.ambiguous-id": "会话 id 在多处重复",
+    "session.locked": "会话正在被其他进程写入",
+    "plugin.command-failed": "插件命令执行失败",
+    "plugin.load-failed": "插件加载失败",
+    "plugin.install-failed": "插件安装失败",
+    "plugin.has-dependents": "插件被其它插件依赖，使用 --ignore 强制卸载",
+    "plugin.not-found": "插件不存在",
+    "service.already-running": "服务已在运行",
+    "service.not-running": "没有正在运行的服务",
+    "service.stop-timeout": "等待服务退出超时",
+    "service.stop-failed": "停止服务失败",
+    "service.record-failed": "服务状态记录失败",
+    "runtime.unknown-status": "未知运行状态",
+}
+
+/** 错误码 → 人类可读文案，字段级细节保留在冒号后 */
+export function errorMessage(code: string): string {
+    const [base, detail] = code.split(":", 2)
+    const message = MESSAGES[base ?? ""] ?? base ?? code
+    return detail === undefined || detail === "" ? message : `${message}：${detail}`
+}
+
+export function exitCodeFor(code: string | null): number {
+    return isUsageCode(code) ? 2 : 1
+}

package/src/commands/start.ts

@@ -0,0 +1,88 @@
+/*
+ * start：以服务进程启动。
+ * 加载插件后触发 onInit，保持进程存活；只有 Ctrl+C / SIGTERM 或插件调用 shutdown() 才退出。
+ */
+
+import { emitInitHooks, emitShutdownHooks, setShutdownHandler } from "../api/host/hooks.ts"
+import { setHostStatus } from "../api/host/host.ts"
+import {
+    ServiceAlreadyRunningError,
+    assertServiceStartable,
+    clearServiceRecord,
+    writeServiceRecord,
+} from "../service/control.ts"
+import { failure, success, type CommandContext, type CommandOutcome } from "./shared.ts"
+
+export async function runStartCommand(ctx: CommandContext): Promise<CommandOutcome> {
+    await ctx.loadPlugins()
+
+    try {
+        await assertServiceStartable(ctx.paths)
+    } catch (error) {
+        if (error instanceof ServiceAlreadyRunningError) {
+            return failure(`service.already-running:${error.pid}`)
+        }
+        const message = error instanceof Error ? error.message : String(error)
+        return failure(`service.record-failed:${message}`)
+    }
+
+    await writeServiceRecord(
+        { pid: process.pid, startedAt: new Date().toISOString(), cwd: process.cwd() },
+        ctx.paths,
+    )
+
+    const state: { resolve: (() => void) | null } = { resolve: null }
+    const shutdownPromise = new Promise<void>((resolve) => {
+        state.resolve = resolve
+    })
+    const requestShutdown = (): void => {
+        state.resolve?.()
+    }
+
+    setShutdownHandler(requestShutdown)
+    let signals = 0
+    const onSignal = (): void => {
+        signals += 1
+        // 第二次 Ctrl+C 直接退出：某个插件的 onShutdown 卡住时仍然能停下来
+        if (signals > 1) {
+            ctx.elog.notice("强制退出")
+            process.exit(130)
+        }
+        requestShutdown()
+    }
+    process.on("SIGINT", onSignal)
+    process.on("SIGTERM", onSignal)
+
+    // 没有常驻 handle 时 Node 会直接退出，这里显式保持事件循环
+    const keepAlive = setInterval(() => undefined, 60_000)
+
+    ctx.logger.info({ pid: process.pid }, "service started")
+    ctx.elog.info("Wellspring 服务已启动，Ctrl+C 退出")
+
+    try {
+        await emitInitHooks()
+        await shutdownPromise
+        setHostStatus("stopping")
+        ctx.elog.notice("正在关闭…")
+        // 兜底：插件 onShutdown 若卡住（例如有长连接没断开），超时后强制退出
+        const forceExit = setTimeout(() => {
+            ctx.elog.notice("关闭超时，强制退出")
+            process.exit(130)
+        }, 10_000)
+        forceExit.unref()
+        try {
+            await emitShutdownHooks()
+        } finally {
+            clearTimeout(forceExit)
+        }
+        ctx.logger.info("service stopped")
+        ctx.elog.info("Wellspring 服务已关闭")
+        return success({ pid: process.pid })
+    } finally {
+        clearInterval(keepAlive)
+        process.off("SIGINT", onSignal)
+        process.off("SIGTERM", onSignal)
+        setShutdownHandler(null)
+        await clearServiceRecord(process.pid, ctx.paths)
+    }
+}

package/src/commands/stop.ts

@@ -0,0 +1,24 @@
+/*
+ * stop：停止正在运行的 wellspring start 服务。
+ * 读取 <dataDir>/service.json，发送 SIGTERM，等待进程退出。
+ */
+
+import { ServiceNotRunningError, ServiceStopTimeoutError, stopService } from "../service/control.ts"
+import { failure, success, type CommandContext, type CommandOutcome } from "./shared.ts"
+
+export async function runStopCommand(ctx: CommandContext): Promise<CommandOutcome> {
+    try {
+        const pid = await stopService(ctx.paths)
+        ctx.elog.info(`已停止 Wellspring 服务（pid ${pid}）`)
+        return success({ pid })
+    } catch (error) {
+        if (error instanceof ServiceNotRunningError) {
+            return failure("service.not-running")
+        }
+        if (error instanceof ServiceStopTimeoutError) {
+            return failure(`service.stop-timeout:${error.pid}`)
+        }
+        const message = error instanceof Error ? error.message : String(error)
+        return failure(`service.stop-failed:${message}`)
+    }
+}

package/src/commands/version.ts

@@ -0,0 +1,40 @@
+/*
+ * version：读取 package.json 的版本号并输出运行环境。
+ */
+
+import { join } from "node:path"
+
+import { readTextIfExists } from "../platform/file.ts"
+import { platform } from "../platform/os.ts"
+import { success, type CommandContext, type CommandOutcome } from "./shared.ts"
+
+interface PackageJson {
+    readonly name?: string
+    readonly version?: string
+}
+
+async function readPackage(): Promise<PackageJson> {
+    const file = join(import.meta.dirname, "../../package.json")
+    const text = await readTextIfExists(file)
+    if (text === null) {
+        return {}
+    }
+    try {
+        return JSON.parse(text) as PackageJson
+    } catch {
+        return {}
+    }
+}
+
+export async function runVersionCommand(ctx: CommandContext): Promise<CommandOutcome> {
+    const pkg = await readPackage()
+    const data = {
+        name: pkg.name ?? "wellspring",
+        version: pkg.version ?? "0.0.0",
+        node: process.versions.node,
+        platform,
+    }
+    ctx.elog.print(`${data.name} ${data.version}`)
+    ctx.elog.print(`node ${data.node}  ${data.platform}`)
+    return success(data)
+}

package/src/config/codes.ts

@@ -0,0 +1,17 @@
+/** 配置错误码。字段级错误格式为 `${invalid}:<path>`，path 为英文点分路径 */
+export const CONFIG_CODES = {
+    readFailed: "config.read-failed",
+    parseFailed: "config.parse-failed",
+    invalid: "config.invalid",
+    versionUnsupported: "config.version-unsupported",
+    writeFailed: "config.write-failed",
+    invalidApiKey: "config.invalid-api-key",
+    credentialsWriteFailed: "config.credentials-write-failed",
+} as const
+
+export type ConfigCode = (typeof CONFIG_CODES)[keyof typeof CONFIG_CODES]
+
+/** 字段级错误码，例如 config.invalid:logger.level */
+export function invalidCode(path: string): string {
+    return `${CONFIG_CODES.invalid}:${path}`
+}