@jsbot-tellus/core 2.1.0 → 2.2.0

package/src/core/plugin/loader.ts

@@ -4,9 +4,103 @@ import { pathToFileURL } from 'node:url'
 import fg from 'fast-glob'
 import type { Logger } from '../logging/logger.js'
 import { collectPluginExports } from './exports.js'
+import { readInstallState, readJsonFile } from './install-dir.js'
+import { NpmCliRunner, type NpmRunner } from './npm-runner.js'
 import type { AnyPluginDefinition } from './types.js'
 
-type LoaderLogger = Pick<Logger, 'warn' | 'error'>
+type LoaderLogger = Pick<Logger, 'warn' | 'error'> & {
+    info?: Logger['info'] | undefined
+}
+
+export interface LocalPluginLoaderOptions {
+    /** Build local plugins that have a build script but no dist. Defaults to true. */
+    autoBuild?: boolean | undefined
+    /** Timeout for a single local plugin build. Defaults to 120 seconds. */
+    buildTimeoutMs?: number | undefined
+    /** npm runner override, mainly for tests. */
+    runner?: NpmRunner | undefined
+}
+
+const DEFAULT_BUILD_TIMEOUT_MS = 120_000
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+async function directoryExists(path: string): Promise<boolean> {
+    const info = await stat(path).catch(() => null)
+
+    return info?.isDirectory() ?? false
+}
+
+async function readBuildScript(directory: string): Promise<string | undefined> {
+    const manifest = await readJsonFile(join(directory, 'package.json')).catch(
+        () => undefined
+    )
+
+    if (!isRecord(manifest) || !isRecord(manifest['scripts'])) {
+        return undefined
+    }
+
+    const build = manifest['scripts']['build']
+
+    return typeof build === 'string' && build.trim().length > 0
+        ? build
+        : undefined
+}
+
+async function readManagedDirectories(
+    root: string
+): Promise<Set<string> | null> {
+    try {
+        const state = await readInstallState(root)
+
+        return new Set(
+            Object.values(state.packages).map((record) => record.dir)
+        )
+    } catch {
+        return null
+    }
+}
+
+async function buildLocalPlugin(
+    directory: string,
+    name: string,
+    logger: LoaderLogger | undefined,
+    runner: NpmRunner,
+    timeoutMs: number
+): Promise<boolean> {
+    if ((await readBuildScript(directory)) === undefined) {
+        logger?.warn(
+            `skipping local plugin ${name}: dist directory not found and package.json has no build script`
+        )
+        return false
+    }
+
+    if (!(await directoryExists(join(directory, 'node_modules')))) {
+        logger?.warn(
+            `skipping local plugin ${name}: dist directory not found and node_modules is missing; run npm install --prefix ${directory}`
+        )
+        return false
+    }
+
+    logger?.info?.(`building local plugin ${name}: dist directory not found`)
+
+    try {
+        await runner.run(['run', 'build'], {
+            cwd: directory,
+            timeoutMs,
+        })
+    } catch (error) {
+        logger?.error(`failed to build local plugin ${name}`, error)
+        logger?.warn(`skipping local plugin ${name}: build failed`)
+        return false
+    }
+
+    logger?.info?.(`built local plugin ${name}`)
+
+    return true
+}
 
 export async function loadPluginsFromDirectory(
     directory: string,
@@ -63,7 +157,8 @@ export async function loadPluginsFromDirectory(
 
 export async function loadLocalPlugins(
     root: string,
-    logger?: LoaderLogger | undefined
+    logger?: LoaderLogger | undefined,
+    options: LocalPluginLoaderOptions = {}
 ): Promise<AnyPluginDefinition[]> {
     const absolute = resolve(root)
     const info = await stat(absolute).catch(() => null)
@@ -75,18 +170,66 @@ export async function loadLocalPlugins(
     )
     const plugins: AnyPluginDefinition[] = []
 
+    let autoBuild = options.autoBuild !== false
+    let managed = new Set<string>()
+
+    if (autoBuild) {
+        const directories = await readManagedDirectories(absolute)
+
+        if (directories === null) {
+            logger?.warn(
+                'cannot read plugin install state; automatic local plugin build is disabled'
+            )
+            autoBuild = false
+        } else {
+            managed = directories
+        }
+    }
+
+    const runner = options.runner ?? new NpmCliRunner()
+    const timeoutMs = options.buildTimeoutMs ?? DEFAULT_BUILD_TIMEOUT_MS
+
     for (const entry of entries) {
         if (!entry.isDirectory() || entry.name.startsWith('.')) continue
         if (entry.name === 'node_modules') continue
 
-        const dist = join(absolute, entry.name, 'dist')
-        const distInfo = await stat(dist).catch(() => null)
+        const directory = join(absolute, entry.name)
+        const dist = join(directory, 'dist')
+        let distInfo = await stat(dist).catch(() => null)
 
         if (!distInfo?.isDirectory()) {
-            logger?.warn(
-                `skipping local plugin ${entry.name}: dist directory not found`
+            if (!autoBuild) {
+                logger?.warn(
+                    `skipping local plugin ${entry.name}: dist directory not found`
+                )
+                continue
+            }
+
+            if (managed.has(entry.name)) {
+                logger?.warn(
+                    `skipping local plugin ${entry.name}: dist directory not found (installed package is expected to include dist)`
+                )
+                continue
+            }
+
+            const built = await buildLocalPlugin(
+                directory,
+                entry.name,
+                logger,
+                runner,
+                timeoutMs
             )
-            continue
+
+            if (!built) continue
+
+            distInfo = await stat(dist).catch(() => null)
+
+            if (!distInfo?.isDirectory()) {
+                logger?.warn(
+                    `skipping local plugin ${entry.name}: build finished but dist directory not found`
+                )
+                continue
+            }
         }
 
         plugins.push(...(await loadPluginsFromDirectory(dist, logger)))

package/src/core/plugin/types.ts

@@ -13,6 +13,7 @@ import type { SendOptions } from '../messaging/sender.js'
 import type { PluginKV } from '../plugin/kv.js'
 import type { Permission } from '../security/permission.js'
 import type { SessionStore } from '../storage/session.js'
+import type { CommandParamArgs } from './command-params.js'
 
 export type EventType = 'message' | 'notice' | 'request' | 'meta'
 
@@ -74,28 +75,33 @@ export type PluginMiddleware = (
     next: () => Promise<void>
 ) => void | Promise<void>
 
-export interface CommandOptions {
+export interface CommandOptions<Declaration extends string = string> {
     name: string
     aliases?: string[] | undefined
     prefixes?: string[] | undefined
     permission?: Permission | undefined
     description?: string | undefined
-    params?: string | undefined
+    params?: Declaration | undefined
 }
 
 export interface CommandGroupOptions<
-    TArgs extends unknown[] = [],
-> extends CommandOptions {
-    handler?: CommandHandler<OneBotMessageEvent, TArgs> | undefined
+    Declaration extends string = string,
+> extends CommandOptions<Declaration> {
+    handler?:
+        | CommandHandler<OneBotMessageEvent, CommandParamArgs<Declaration>>
+        | undefined
 }
 
 export interface CommandGroupRegistrar {
-    register<TArgs extends unknown[] = []>(
-        options: CommandOptions,
-        handler: CommandHandler<OneBotMessageEvent, TArgs>
+    register<Declaration extends string = string>(
+        options: CommandOptions<Declaration>,
+        handler: CommandHandler<
+            OneBotMessageEvent,
+            CommandParamArgs<Declaration>
+        >
     ): () => void
-    group<TArgs extends unknown[] = []>(
-        options: CommandGroupOptions<TArgs>,
+    group<Declaration extends string = string>(
+        options: CommandGroupOptions<Declaration>,
         setup: (group: CommandGroupRegistrar) => void
     ): () => void
 }
@@ -184,7 +190,7 @@ export interface CoreServices {
         can(actual: Permission, required: Permission): boolean
     }
     commands: {
-        list(): ReadonlyArray<CommandInfo>
+        list(event?: SnowLumaEvent): ReadonlyArray<CommandInfo>
     }
     plugins: PluginStatus
     installer: PluginInstaller

package/src/plugins/core/index.ts

@@ -38,7 +38,7 @@ export const corePlugin = definePlugin({
             async (event, context) => {
                 const role = ctx.core.roles.roleOf(event.user_id)
                 const commands = ctx.core.commands
-                    .list()
+                    .list(event)
                     .filter((command) =>
                         ctx.core.roles.can(role, command.permission)
                     )