@jsbot-tellus/core 2.4.0 → 2.5.1

package/src/core/plugin/install/paths.ts

@@ -0,0 +1,72 @@
+import { readFileSync } from 'node:fs'
+import { mkdir, realpath, rm, stat, symlink, writeFile } from 'node:fs/promises'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { VALIDATE_SCRIPT, VALIDATE_SCRIPT_FILE } from './validate-script.js'
+
+export const CORE_PACKAGE_NAME = '@jsbot-tellus/core'
+
+export function packageDirectoryName(name: string): string {
+    return name.startsWith('@') ? name.replace('/', '__') : name
+}
+
+export function corePackageRoot(): string {
+    let current = dirname(fileURLToPath(import.meta.url))
+
+    for (;;) {
+        try {
+            const manifest = JSON.parse(
+                readFileSync(join(current, 'package.json'), 'utf8')
+            ) as Record<string, unknown>
+
+            if (manifest['name'] === CORE_PACKAGE_NAME) return current
+        } catch {
+            // keep walking up
+        }
+
+        const parent = dirname(current)
+
+        if (parent === current) {
+            throw new Error(`cannot locate ${CORE_PACKAGE_NAME} package root`)
+        }
+
+        current = parent
+    }
+}
+
+export async function ensureCoreLink(dir: string): Promise<void> {
+    const target = corePackageRoot()
+    const link = join(dir, 'node_modules', '@jsbot-tellus', 'core')
+
+    await mkdir(dirname(link), { recursive: true })
+
+    const existing = await realpath(link).catch(() => null)
+
+    if (existing !== null) {
+        const resolvedTarget = await realpath(target).catch(() => target)
+
+        if (existing === resolvedTarget) return
+
+        await rm(link, { recursive: true, force: true })
+    }
+
+    await symlink(
+        target,
+        link,
+        process.platform === 'win32' ? 'junction' : 'dir'
+    )
+}
+
+export async function pathExists(path: string): Promise<boolean> {
+    return (await stat(path).catch(() => null)) !== null
+}
+
+export async function ensureInstallRoot(root: string): Promise<void> {
+    await mkdir(root, { recursive: true })
+    await mkdir(join(root, '.jsbot'), { recursive: true })
+    await writeFile(
+        join(root, '.jsbot', VALIDATE_SCRIPT_FILE),
+        VALIDATE_SCRIPT,
+        'utf8'
+    )
+}

package/src/core/plugin/install/state.ts

@@ -0,0 +1,196 @@
+import { randomUUID } from 'node:crypto'
+import { readFile, rename, rm, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+export const INSTALL_STATE_FILE = '.jsbot-installed.json'
+
+export interface InstalledPackageRecord {
+    spec: string
+    version: string
+    pluginIds: string[]
+    dependencies: Record<string, string[]>
+    installedAt: string
+    /** Directory name under the plugins root. */
+    dir: string
+}
+
+export interface InstallState {
+    version: 2
+    packages: Record<string, InstalledPackageRecord>
+}
+
+export class InstallStateError extends Error {
+    constructor(message: string, options?: ErrorOptions) {
+        super(message, options)
+        this.name = 'InstallStateError'
+    }
+}
+
+export async function readJsonFile(path: string): Promise<unknown> {
+    try {
+        return JSON.parse(await readFile(path, 'utf8'))
+    } catch (error) {
+        if ((error as NodeJS.ErrnoException).code === 'ENOENT') return undefined
+
+        throw error
+    }
+}
+
+export async function readPackageVersion(
+    directory: string
+): Promise<string | undefined> {
+    const manifest = await readJsonFile(join(directory, 'package.json')).catch(
+        () => undefined
+    )
+
+    if (typeof manifest !== 'object' || manifest === null) return undefined
+
+    const version = (manifest as Record<string, unknown>)['version']
+
+    return typeof version === 'string' ? version : undefined
+}
+
+export function isSafeDirectoryName(value: string): boolean {
+    return (
+        value.length > 0 &&
+        value !== '.' &&
+        value !== '..' &&
+        !value.includes('/') &&
+        !value.includes('\\')
+    )
+}
+
+export async function readInstallState(dir: string): Promise<InstallState> {
+    const path = join(dir, INSTALL_STATE_FILE)
+    let value: unknown
+
+    try {
+        value = await readJsonFile(path)
+    } catch (error) {
+        throw new InstallStateError(`安装状态文件无法解析: ${path}`, {
+            cause: error,
+        })
+    }
+
+    if (value === undefined) {
+        return { version: 2, packages: {} }
+    }
+
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new InstallStateError(`安装状态文件格式无效: ${path}`)
+    }
+
+    if ((value as Record<string, unknown>)['version'] !== 2) {
+        throw new InstallStateError(`不支持的安装状态版本，请检查 ${path}`)
+    }
+
+    const packages = (value as Record<string, unknown>)['packages']
+
+    if (
+        typeof packages !== 'object' ||
+        packages === null ||
+        Array.isArray(packages)
+    ) {
+        throw new InstallStateError(`安装状态 packages 字段无效: ${path}`)
+    }
+
+    const result: Record<string, InstalledPackageRecord> = {}
+    const directories = new Set<string>()
+
+    for (const [name, rawRecord] of Object.entries(packages)) {
+        if (
+            typeof rawRecord !== 'object' ||
+            rawRecord === null ||
+            Array.isArray(rawRecord)
+        ) {
+            throw new InstallStateError(`安装状态记录无效: ${name}`)
+        }
+
+        const record = rawRecord as Record<string, unknown>
+        const pluginIds = record['pluginIds']
+        const dependencies = record['dependencies']
+        const directory = record['dir']
+
+        if (
+            typeof record['spec'] !== 'string' ||
+            typeof record['version'] !== 'string' ||
+            typeof record['installedAt'] !== 'string' ||
+            typeof directory !== 'string' ||
+            !isSafeDirectoryName(directory) ||
+            !Array.isArray(pluginIds) ||
+            pluginIds.some((item) => typeof item !== 'string')
+        ) {
+            throw new InstallStateError(`安装状态记录不完整: ${name}`)
+        }
+
+        if (directories.has(directory)) {
+            throw new InstallStateError(
+                `安装状态存在重复的插件目录: ${directory}`
+            )
+        }
+
+        directories.add(directory)
+
+        if (
+            typeof dependencies !== 'object' ||
+            dependencies === null ||
+            Array.isArray(dependencies)
+        ) {
+            throw new InstallStateError(`安装状态依赖字段无效: ${name}`)
+        }
+
+        const parsedDependencies: Record<string, string[]> = {}
+
+        for (const [id, list] of Object.entries(dependencies)) {
+            if (
+                !Array.isArray(list) ||
+                list.some((item) => typeof item !== 'string')
+            ) {
+                throw new InstallStateError(
+                    `安装状态依赖记录无效: ${name}.${id}`
+                )
+            }
+
+            parsedDependencies[id] = [...list]
+        }
+
+        result[name] = {
+            spec: record['spec'],
+            version: record['version'],
+            pluginIds: [...pluginIds],
+            dependencies: parsedDependencies,
+            installedAt: record['installedAt'],
+            dir: directory,
+        }
+    }
+
+    return { version: 2, packages: result }
+}
+
+export async function writeInstallState(
+    dir: string,
+    state: InstallState
+): Promise<void> {
+    const sorted: InstallState = { version: 2, packages: {} }
+
+    for (const name of Object.keys(state.packages).sort()) {
+        const record = state.packages[name]
+        if (!record) continue
+        sorted.packages[name] = record
+    }
+
+    const path = join(dir, INSTALL_STATE_FILE)
+    const temporary = `${path}.${randomUUID()}.tmp`
+
+    try {
+        await writeFile(
+            temporary,
+            `${JSON.stringify(sorted, null, 4)}\n`,
+            'utf8'
+        )
+        await rename(temporary, path)
+    } catch (error) {
+        await rm(temporary, { force: true }).catch(() => undefined)
+        throw error
+    }
+}

package/src/core/plugin/install/validate-script.ts

@@ -0,0 +1,154 @@
+export const VALIDATE_SCRIPT_FILE = 'validate.mjs'
+
+export const VALIDATE_SCRIPT = `import { readdir } from 'node:fs/promises'
+import { extname, join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+const directory = process.argv[2]
+
+if (!directory) {
+    console.error('missing plugin directory')
+    process.exit(2)
+}
+
+const extensions = new Set(['.js', '.mjs', '.cjs'])
+
+async function filesIn(directory) {
+    const entries = await readdir(directory, { withFileTypes: true })
+    entries.sort((a, b) => a.name.localeCompare(b.name))
+
+    const files = []
+
+    for (const entry of entries) {
+        if (entry.name.startsWith('.')) continue
+
+        const path = join(directory, entry.name)
+
+        if (entry.isDirectory()) {
+            if (entry.name === 'node_modules') continue
+            files.push(...(await filesIn(path)))
+            continue
+        }
+
+        if (
+            entry.isFile() &&
+            extensions.has(extname(entry.name)) &&
+            !/\\.d\\.(ts|mts|cts)$/.test(entry.name)
+        ) {
+            files.push(path)
+        }
+    }
+
+    return files
+}
+
+function isPlugin(value) {
+    if (typeof value !== 'object' || value === null) return false
+    if (!('manifest' in value) || !('setup' in value)) return false
+
+    const manifest = value.manifest
+
+    if (
+        typeof manifest !== 'object' ||
+        manifest === null ||
+        typeof manifest.id !== 'string' ||
+        typeof manifest.configSchema !== 'object' ||
+        manifest.configSchema === null ||
+        typeof manifest.configSchema.safeParse !== 'function' ||
+        typeof value.setup !== 'function'
+    ) {
+        return false
+    }
+
+    if (
+        manifest.dependencies !== undefined &&
+        (!Array.isArray(manifest.dependencies) ||
+            manifest.dependencies.some((item) => typeof item !== 'string'))
+    ) {
+        return false
+    }
+
+    return true
+}
+
+function collect(value, result) {
+    if (Array.isArray(value)) {
+        for (const item of value) collect(item, result)
+        return
+    }
+
+    if (isPlugin(value)) {
+        result.push(value)
+        return
+    }
+
+    if (
+        typeof value === 'object' &&
+        value !== null &&
+        'plugins' in value &&
+        Array.isArray(value.plugins)
+    ) {
+        for (const item of value.plugins) collect(item, result)
+    }
+}
+
+const files = await filesIn(directory).catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error))
+    process.exit(3)
+})
+
+if (files.length === 0) {
+    console.error('插件 dist 目录中没有可加载的文件')
+    process.exit(4)
+}
+
+const found = []
+const invalid = []
+
+for (const file of files) {
+    let imported
+
+    try {
+        imported = await import(pathToFileURL(file).href)
+    } catch (error) {
+        invalid.push(
+            \`failed to import \${file}: \${error instanceof Error ? error.message : String(error)}\`
+        )
+        continue
+    }
+
+    if (typeof imported !== 'object' || imported === null) continue
+
+    for (const candidate of [imported.default, imported.plugin, imported.plugins]) {
+        collect(candidate, found)
+    }
+}
+
+const unique = found.filter((plugin, index) => found.indexOf(plugin) === index)
+
+if (unique.length === 0) {
+    console.error(
+        invalid[0] ??
+            'package does not export a JsBot plugin (default / plugin / plugins)'
+    )
+    process.exit(5)
+}
+
+console.log(
+    '__JSBOT_PLUGIN__' +
+        JSON.stringify(
+            unique.map((plugin) => ({
+                id: plugin.manifest.id,
+                version:
+                    typeof plugin.manifest.version === 'string'
+                        ? plugin.manifest.version
+                        : '0.0.0',
+                dependencies: Array.isArray(plugin.manifest.dependencies)
+                    ? plugin.manifest.dependencies.filter(
+                          (item) => typeof item === 'string'
+                      )
+                    : [],
+            }))
+        )
+)
+`