@jsbot-tellus/core 2.9.0 → 2.10.0

package/src/core/plugin/params/types.ts

@@ -35,14 +35,26 @@ export interface ParamLength {
     max?: number | undefined
 }
 
+export interface ParamTypeCandidate {
+    kind: 'type'
+    type: CommandParamType
+    length?: ParamLength | undefined
+}
+
+export interface ParamLiteralCandidate {
+    kind: 'literal'
+    value: string
+}
+
+export type ParamCandidate = ParamTypeCandidate | ParamLiteralCandidate
+
 export interface ParamSpec {
     name: string
-    type: CommandParamType
+    candidates: ParamCandidate[]
     required: boolean
     rest: boolean
     hasDefault: boolean
     defaultValue?: unknown
-    length?: ParamLength | undefined
 }
 
 export interface InputToken {
@@ -53,3 +65,35 @@ export interface InputToken {
 export function declarationError(message: string): Error {
     return new Error(`参数声明错误：${message}`)
 }
+
+export function candidateLabel(candidate: ParamCandidate): string {
+    if (candidate.kind === 'literal') {
+        const escaped = candidate.value
+            .replace(/\\/g, '\\\\')
+            .replace(/'/g, "\\'")
+
+        return `'${escaped}'`
+    }
+
+    const length = candidate.length
+
+    if (length === undefined) {
+        return candidate.type
+    }
+
+    return `${candidate.type}(${length.min ?? ''}..${length.max ?? ''})`
+}
+
+export function joinCandidateLabels(
+    candidates: readonly ParamCandidate[]
+): string {
+    const labels = candidates.map(candidateLabel)
+
+    if (labels.length === 0) return ''
+
+    if (labels.length === 1) return labels[0] ?? ''
+
+    const last = labels[labels.length - 1] ?? ''
+
+    return `${labels.slice(0, -1).join('、')} 或 ${last}`
+}

package/src/core/web/config-store.ts

@@ -128,27 +128,28 @@ function validatePlugins(
         definitions.map((definition) => [definition.manifest.id, definition])
     )
 
-    for (const [id, envelope] of Object.entries(config.plugins)) {
-        const definition = byId.get(id)
-
-        if (!definition) {
+    for (const id of Object.keys(config.plugins)) {
+        if (!byId.has(id)) {
             issues.push({
                 path: `plugins.${id}`,
                 message: `unknown plugin id: ${id}`,
             })
-
-            continue
         }
+    }
 
+    // Validate every enabled plugin, not only the ones already present in the
+    // config file. A newly installed plugin has no envelope yet; validating it
+    // here surfaces missing required options before the runtime is restarted.
+    for (const definition of definitions) {
+        const id = definition.manifest.id
+        const envelope = config.plugins[id]
         const enabled =
-            (envelope as PluginEnvelope).enabled ??
-            definition.manifest.defaultEnabled ??
-            false
+            envelope?.enabled ?? definition.manifest.defaultEnabled ?? false
 
         if (!enabled) continue
 
         const result = definition.manifest.configSchema.safeParse(
-            stripPluginEnvelope(envelope as PluginEnvelope)
+            stripPluginEnvelope(envelope ?? ({} as PluginEnvelope))
         )
 
         if (!result.success) {
@@ -255,9 +256,14 @@ export class ConfigStore {
             }
         }
 
+        const pluginIssues = validatePlugins(
+            parsed.data,
+            this.options.getPlugins()
+        )
+
         return {
-            ok: true,
-            issues: validatePlugins(parsed.data, this.options.getPlugins()),
+            ok: pluginIssues.length === 0,
+            issues: pluginIssues,
             config: parsed.data,
         }
     }

package/src/core/web/routes/plugins.ts

@@ -41,14 +41,19 @@ function pluginJsonSchema(
 }
 
 export async function handlePluginsList(ctx: ApiContext): Promise<void> {
-    const runtime = requireRuntime(ctx.deps)
+    const runtime = ctx.deps.getRuntime()
+    // The kernel can fail to start (for example when a plugin has no config
+    // yet). Keep serving the last loaded definitions so the WebUI can still
+    // edit plugin configs and recover without touching the file by hand.
+    const definitions = runtime?.plugins ?? ctx.deps.getPlugins()
     const statuses = new Map(
-        runtime.kernel.listPlugins().map((entry) => [entry.id, entry])
+        (runtime?.kernel.listPlugins() ?? []).map((entry) => [entry.id, entry])
     )
-    const plugins = runtime.plugins.map((definition) => {
+    const document = await ctx.deps.readConfig()
+    const plugins = definitions.map((definition) => {
         const id = definition.manifest.id
         const status = statuses.get(id)
-        const envelope = asRecord(runtime.config.plugins[id]) as Record<
+        const envelope = asRecord(document.config.plugins[id]) as Record<
             string,
             unknown
         >
@@ -57,6 +62,11 @@ export async function handlePluginsList(ctx: ApiContext): Promise<void> {
         const options = structuredClone(
             stripPluginEnvelope(envelope as never)
         ) as Record<string, unknown>
+        const enabled =
+            status?.enabled ??
+            (typeof envelope['enabled'] === 'boolean'
+                ? envelope['enabled']
+                : (definition.manifest.defaultEnabled ?? false))
 
         return {
             id,
@@ -64,22 +74,24 @@ export async function handlePluginsList(ctx: ApiContext): Promise<void> {
             description: definition.manifest.description,
             dependencies: definition.manifest.dependencies ?? [],
             defaultEnabled: definition.manifest.defaultEnabled ?? false,
-            enabled: status?.enabled ?? false,
+            enabled,
             loaded: status?.loaded ?? false,
             config: envelope,
             options,
             configSchema: pluginJsonSchema(definition),
         }
     })
-    const installed = runtime.installer.enabled
-        ? await runtime.installer.list()
-        : []
+    const installer = runtime?.installer
+    const installed =
+        installer !== undefined && installer.enabled
+            ? await installer.list()
+            : []
 
     sendData(ctx.res, 200, {
         plugins,
         installed,
-        installerEnabled: runtime.installer.enabled,
-        configHash: (await ctx.deps.readConfig()).hash,
+        installerEnabled: installer?.enabled ?? false,
+        configHash: document.hash,
     })
 }
 
@@ -90,14 +102,17 @@ export async function handlePluginConfigPut(ctx: ApiContext): Promise<void> {
 
     if (id === undefined) throw new HttpError(404, 'unknown plugin')
 
-    if (!isRecord(document.config.plugins[id])) {
+    const runtime = ctx.deps.getRuntime()
+    const definition = (runtime?.plugins ?? ctx.deps.getPlugins()).find(
+        (plugin) => plugin.manifest.id === id
+    )
+    const entry = document.config.plugins[id]
+
+    if (definition === undefined && entry === undefined) {
         throw new HttpError(404, `unknown plugin: ${id}`)
     }
 
-    const existing = asRecord(document.config.plugins[id]) as unknown as Record<
-        string,
-        unknown
-    >
+    const existing = asRecord(entry) as unknown as Record<string, unknown>
     const next = { ...existing }
 
     if (typeof body['enabled'] === 'boolean') {
@@ -115,10 +130,6 @@ export async function handlePluginConfigPut(ctx: ApiContext): Promise<void> {
             throw new HttpError(400, 'options must be an object')
         }
 
-        const runtime = ctx.deps.getRuntime()
-        const definition = runtime?.plugins.find(
-            (plugin) => plugin.manifest.id === id
-        )
         const options: Record<string, unknown> = {}
 
         for (const [key, value] of Object.entries(body['options'])) {

package/src/core/web/types.ts

@@ -64,6 +64,13 @@ export interface WebUiDeps {
     /** Current webui settings; picked up after runtime restarts. */
     getWebUiConfig(): WebUiConfig
 
+    /**
+     * Plugin definitions from the last successfully loaded runtime spec.
+     * Unlike `getRuntime()`, this stays available when the kernel fails to
+     * start, so plugin configs can still be edited from the WebUI.
+     */
+    getPlugins(): AnyPluginDefinition[]
+
     readConfig(): Promise<ConfigDocument>
     validateConfig(value: unknown): Promise<ConfigValidationResult>
     applyConfig(