@doubao-dev/plugin-cli 0.0.0-stage → 0.0.40-canary-dea0ddc73-20261026073950

package/dist/index.d.ts

@@ -0,0 +1,165 @@
+import type { Command } from 'commander';
+import { z } from 'zod';
+
+export declare type AddCommandHook = (ctx: {
+    program: Command;
+    hooks: PluginHooks;
+}) => Awaitable<void>;
+
+export declare type AfterUploadHook = (ctx: UploadContext, result: Readonly<UploadResult>) => Awaitable<void>;
+
+declare interface AppProject {
+    root: string;
+}
+
+export declare type Awaitable<T> = T | Promise<T>;
+
+export declare interface CLIOptions {
+    readonly plugins?: readonly CLIPlugin[];
+}
+
+export declare interface CLIPlugin {
+    readonly name: string;
+    readonly setup: (api: PluginAPI) => Awaitable<void>;
+}
+
+export declare function definePlugin(plugin: CLIPlugin): CLIPlugin;
+
+declare interface DevAction {
+    label: string;
+    run(): Awaitable<void>;
+}
+
+declare interface DevContext {
+    project: PluginProject;
+    options: Readonly<Record<string, unknown>>;
+    signal: AbortSignal;
+}
+
+export declare type DevHook = (ctx: DevContext) => Awaitable<readonly DevService[]>;
+
+declare interface DevService {
+    name: string;
+    title: string;
+    option?: string;
+    watch?: readonly string[];
+    appliesTo(ctx: DevContext): Awaitable<boolean>;
+    start(ctx: DevServiceContext): Promise<void>;
+    createUI?(ctx: DevContext, onExit: (interrupted: boolean) => void): Promise<DevUI>;
+}
+
+declare interface DevServiceContext extends DevContext {
+    interactive: boolean;
+    log: Logger;
+    report(state: Partial<Omit<DevServiceState, 'name' | 'title'>>): void;
+    onDispose(dispose: () => Awaitable<void>): void;
+    onFileChange(listener: () => Awaitable<void>): void;
+}
+
+declare interface DevServiceState {
+    name: string;
+    title: string;
+    status: DevStatus;
+    message: string;
+    details?: Readonly<Record<string, string>>;
+    links?: Readonly<Record<string, string>>;
+    actions?: Readonly<Record<string, DevAction>>;
+    progress?: number;
+    busy?: boolean;
+    panel?: {
+        title: string;
+        message: string;
+        status: DevStatus;
+        qr?: string;
+        select?: boolean;
+    };
+}
+
+declare type DevStatus = 'pending' | 'success' | 'error';
+
+declare interface DevUI {
+    log: Logger;
+    update(services: readonly DevServiceState[]): void;
+    close(): Promise<void>;
+}
+
+declare type Logger = Record<'info' | 'success' | 'warn' | 'error', (message: string) => void>;
+
+declare type McpServer = Record<string, unknown>;
+
+export declare type ModifyPackagePlanHook = (ctx: UploadContext, plan: Readonly<PackagePlan>) => Awaitable<PackagePlan>;
+
+declare interface PackagePlan {
+    version?: string;
+    exclude?: readonly string[];
+}
+
+export declare interface PluginAPI {
+    onAddCommand(callback: AddCommandHook): void;
+    onDev(callback: DevHook): void;
+    onModifyPackagePlan(callback: ModifyPackagePlanHook): void;
+    onAfterUpload(callback: AfterUploadHook): void;
+}
+
+export declare interface PluginHooks {
+    addCommand: RegisteredHook<AddCommandHook>[];
+    dev: RegisteredHook<DevHook>[];
+    modifyPackagePlan: RegisteredHook<ModifyPackagePlanHook>[];
+    afterUpload: RegisteredHook<AfterUploadHook>[];
+}
+
+declare type PluginManifest = z.infer<typeof pluginManifestSchema>;
+
+declare const pluginManifestSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    id: z.ZodOptional<z.ZodString>;
+    displayName: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$loose>;
+
+declare class PluginProject {
+    readonly root: string;
+    readonly plugin: PluginManifest;
+    readonly app?: AppProject;
+    private readonly pluginManifestPath;
+    constructor(cwd?: string);
+    updatePluginId(id: string): Promise<void>;
+    pack({ version, exclude }?: PackagePlan): Promise<Blob>;
+    readSkills(): Skill[];
+    get mcpServers(): McpServer[];
+}
+
+export declare interface RegisteredHook<T> {
+    pluginName: string;
+    callback: T;
+}
+
+export declare function runCLI(argv?: string[], options?: CLIOptions): Promise<void>;
+
+declare interface Skill {
+    root: string;
+    content: string;
+}
+
+declare interface UploadContext {
+    project: PluginProject;
+    options: Readonly<UploadOptions>;
+}
+
+declare interface UploadOptions {
+    version?: string;
+}
+
+declare interface UploadResult {
+    packageId: string;
+    draft: {
+        name?: string;
+        ability_id?: string;
+        version?: string;
+    };
+    version?: string;
+}
+
+export { }

package/dist/index.js

@@ -0,0 +1,5 @@
+function definePlugin(plugin) {
+    return plugin;
+}
+export { main as runCLI } from "./188.js";
+export { definePlugin };

package/dist/main.d.ts

@@ -0,0 +1,163 @@
+import type { Command } from 'commander';
+import { z } from 'zod';
+
+declare type AddCommandHook = (ctx: {
+    program: Command;
+    hooks: PluginHooks;
+}) => Awaitable<void>;
+
+declare type AfterUploadHook = (ctx: UploadContext, result: Readonly<UploadResult>) => Awaitable<void>;
+
+declare interface AppProject {
+    root: string;
+}
+
+declare type Awaitable<T> = T | Promise<T>;
+
+declare interface CLIOptions {
+    readonly plugins?: readonly CLIPlugin[];
+}
+
+declare interface CLIPlugin {
+    readonly name: string;
+    readonly setup: (api: PluginAPI) => Awaitable<void>;
+}
+
+declare interface DevAction {
+    label: string;
+    run(): Awaitable<void>;
+}
+
+declare interface DevContext {
+    project: PluginProject;
+    options: Readonly<Record<string, unknown>>;
+    signal: AbortSignal;
+}
+
+declare type DevHook = (ctx: DevContext) => Awaitable<readonly DevService[]>;
+
+declare interface DevService {
+    name: string;
+    title: string;
+    option?: string;
+    watch?: readonly string[];
+    appliesTo(ctx: DevContext): Awaitable<boolean>;
+    start(ctx: DevServiceContext): Promise<void>;
+    createUI?(ctx: DevContext, onExit: (interrupted: boolean) => void): Promise<DevUI>;
+}
+
+declare interface DevServiceContext extends DevContext {
+    interactive: boolean;
+    log: Logger;
+    report(state: Partial<Omit<DevServiceState, 'name' | 'title'>>): void;
+    onDispose(dispose: () => Awaitable<void>): void;
+    onFileChange(listener: () => Awaitable<void>): void;
+}
+
+declare interface DevServiceState {
+    name: string;
+    title: string;
+    status: DevStatus;
+    message: string;
+    details?: Readonly<Record<string, string>>;
+    links?: Readonly<Record<string, string>>;
+    actions?: Readonly<Record<string, DevAction>>;
+    progress?: number;
+    busy?: boolean;
+    panel?: {
+        title: string;
+        message: string;
+        status: DevStatus;
+        qr?: string;
+        select?: boolean;
+    };
+}
+
+declare type DevStatus = 'pending' | 'success' | 'error';
+
+declare interface DevUI {
+    log: Logger;
+    update(services: readonly DevServiceState[]): void;
+    close(): Promise<void>;
+}
+
+declare type Logger = Record<'info' | 'success' | 'warn' | 'error', (message: string) => void>;
+
+export declare function main(argv?: string[], options?: CLIOptions): Promise<void>;
+
+declare type McpServer = Record<string, unknown>;
+
+declare type ModifyPackagePlanHook = (ctx: UploadContext, plan: Readonly<PackagePlan>) => Awaitable<PackagePlan>;
+
+declare interface PackagePlan {
+    version?: string;
+    exclude?: readonly string[];
+}
+
+declare interface PluginAPI {
+    onAddCommand(callback: AddCommandHook): void;
+    onDev(callback: DevHook): void;
+    onModifyPackagePlan(callback: ModifyPackagePlanHook): void;
+    onAfterUpload(callback: AfterUploadHook): void;
+}
+
+declare interface PluginHooks {
+    addCommand: RegisteredHook<AddCommandHook>[];
+    dev: RegisteredHook<DevHook>[];
+    modifyPackagePlan: RegisteredHook<ModifyPackagePlanHook>[];
+    afterUpload: RegisteredHook<AfterUploadHook>[];
+}
+
+declare type PluginManifest = z.infer<typeof pluginManifestSchema>;
+
+declare const pluginManifestSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    id: z.ZodOptional<z.ZodString>;
+    displayName: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$loose>;
+
+declare class PluginProject {
+    readonly root: string;
+    readonly plugin: PluginManifest;
+    readonly app?: AppProject;
+    private readonly pluginManifestPath;
+    constructor(cwd?: string);
+    updatePluginId(id: string): Promise<void>;
+    pack({ version, exclude }?: PackagePlan): Promise<Blob>;
+    readSkills(): Skill[];
+    get mcpServers(): McpServer[];
+}
+
+declare interface RegisteredHook<T> {
+    pluginName: string;
+    callback: T;
+}
+
+declare interface Skill {
+    root: string;
+    content: string;
+}
+
+declare interface UploadContext {
+    project: PluginProject;
+    options: Readonly<UploadOptions>;
+}
+
+declare interface UploadOptions {
+    version?: string;
+}
+
+declare interface UploadResult {
+    packageId: string;
+    draft: {
+        name?: string;
+        ability_id?: string;
+        version?: string;
+    };
+    version?: string;
+}
+
+export { }

package/dist/main.js

@@ -0,0 +1 @@
+export { main } from "./188.js";

package/dist/plugin.js

@@ -0,0 +1,97 @@
+import { existsSync, lstatSync, readFileSync, readdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { arrayBuffer } from "node:stream/consumers";
+import archiver from "archiver";
+import { readJson, readJsonSync, writeJson } from "fs-extra/esm";
+import { APP_GENERATED_DIRECTORIES, pluginManifestSchema, DOUBAO_APP_DIRECTORY, SKILL_FILENAME, findApp, mcpConfigSchema, PROJECT_EXCLUDED_FILES, findProjectRoot, PLUGIN_MANIFEST_FILENAME, MCP_CONFIG_FILENAME, PROJECT_EXCLUDED_DIRECTORIES } from "./188.js";
+class PluginProject {
+    root;
+    plugin;
+    app;
+    pluginManifestPath;
+    constructor(cwd = process.cwd()){
+        this.root = findProjectRoot(cwd);
+        this.pluginManifestPath = join(this.root, PLUGIN_MANIFEST_FILENAME);
+        this.plugin = pluginManifestSchema.parse(readJsonSync(this.pluginManifestPath));
+        this.app = findApp(this.root);
+    }
+    async updatePluginId(id) {
+        const manifest = pluginManifestSchema.parse(await readJson(this.pluginManifestPath));
+        manifest.id = id;
+        await writeJson(this.pluginManifestPath, manifest, {
+            spaces: 2
+        });
+        this.plugin.id = id;
+    }
+    async pack({ version, exclude = [] } = {}) {
+        const archive = archiver('zip', {
+            zlib: {
+                level: 9
+            }
+        });
+        const excludedDirectories = [
+            ...exclude,
+            ...this.app ? APP_GENERATED_DIRECTORIES.map((directory)=>`${DOUBAO_APP_DIRECTORY}/${directory}`) : []
+        ];
+        archive.on('warning', (error)=>archive.destroy(error));
+        archive.directory(this.root, false, (entry)=>{
+            const parts = entry.name.split('/');
+            if (entry.stats?.isSymbolicLink() || '.agents' === parts[0] || 'AGENTS.md' === entry.name || version && entry.name === PLUGIN_MANIFEST_FILENAME || excludedDirectories.some((directory)=>entry.name === directory || entry.name.startsWith(`${directory}/`)) || parts.some((part)=>PROJECT_EXCLUDED_DIRECTORIES.includes(part) || PROJECT_EXCLUDED_FILES.includes(part) || ".env" === part || part.startsWith(".env."))) return false;
+            const directory = entry.stats?.isDirectory() ? entry.name : dirname(entry.name);
+            if (findProjectRoot(join(this.root, directory)) !== this.root) return false;
+            return entry;
+        });
+        if (version) archive.append(JSON.stringify({
+            ...this.plugin,
+            version
+        }, null, 2), {
+            name: PLUGIN_MANIFEST_FILENAME
+        });
+        try {
+            const [content] = await Promise.all([
+                arrayBuffer(archive),
+                archive.finalize()
+            ]);
+            return new Blob([
+                content
+            ], {
+                type: 'application/zip'
+            });
+        } catch (error) {
+            archive.abort();
+            throw error;
+        }
+    }
+    readSkills() {
+        const directory = join(this.root, "skills");
+        const directoryStat = lstatSync(directory, {
+            throwIfNoEntry: false
+        });
+        if (!directoryStat) return [];
+        if (!directoryStat.isDirectory()) throw new Error(`${directory} 必须是目录`);
+        return readdirSync(directory, {
+            withFileTypes: true
+        }).filter((entry)=>entry.isDirectory()).map((entry)=>entry.name).sort().flatMap((name)=>{
+            const skillRoot = join(directory, name);
+            const filePath = join(skillRoot, SKILL_FILENAME);
+            const fileStat = lstatSync(filePath, {
+                throwIfNoEntry: false
+            });
+            if (!fileStat) return [];
+            if (!fileStat.isFile()) throw new Error(`${filePath} 必须是普通文件`);
+            return [
+                {
+                    root: skillRoot,
+                    content: readFileSync(filePath, 'utf8')
+                }
+            ];
+        });
+    }
+    get mcpServers() {
+        const filePath = join(this.root, MCP_CONFIG_FILENAME);
+        if (!existsSync(filePath)) return [];
+        const { mcpServers } = mcpConfigSchema.parse(readJsonSync(filePath));
+        return Object.values(mcpServers);
+    }
+}
+export { PluginProject };

package/dist/session.js

@@ -0,0 +1,248 @@
+import { relative, resolve, sep } from "node:path";
+import { cancel, isCancel, select as prompts_select } from "@clack/prompts";
+import { watch } from "chokidar";
+import { terminal_log, callHook, isInteractive, errorMessage } from "./188.js";
+import { ensureLogin } from "./command~1.js";
+function createLogUI() {
+    const previous = new Map();
+    return {
+        log: terminal_log,
+        update: (services)=>{
+            for (const service of services){
+                const last = previous.get(service.name);
+                previous.set(service.name, service);
+                if (last?.message !== service.message && 'error' !== service.status && !(void 0 !== service.progress && 'pending' === service.status)) ('success' === service.status ? terminal_log.success : terminal_log.info)(`${service.title}：${service.message}`);
+                for (const [label, url] of Object.entries(service.links ?? {}))if (last?.links?.[label] !== url) terminal_log.info(`${label}：${url}`);
+            }
+        },
+        close: async ()=>{}
+    };
+}
+async function runSession(project, options, hooks) {
+    const controller = new AbortController();
+    const completion = Promise.withResolvers();
+    const stop = (interrupted = false)=>{
+        if (interrupted) process.exitCode = 130;
+        controller.abort();
+        completion.resolve();
+    };
+    const ctx = {
+        project,
+        options,
+        signal: controller.signal
+    };
+    const selected = await selectServices(ctx, hooks);
+    if (!selected) return;
+    await ensureLogin(false !== options.tui && isInteractive());
+    const services = selected.map((item)=>({
+            ...item,
+            state: {
+                name: item.service.name,
+                title: item.service.title,
+                status: 'pending',
+                message: '正在启动'
+            },
+            phase: 'starting',
+            paths: (item.service.watch ?? []).map((path)=>relative(project.root, resolve(project.root, path))),
+            dirty: false,
+            disposers: []
+        }));
+    const renderers = services.filter(({ service })=>service.createUI);
+    if (renderers.length > 1) throw new Error('一次只能选择一个交互调试目标');
+    let ui = createLogUI();
+    let rendering = Promise.resolve();
+    let interactive = false;
+    const write = (level, message)=>{
+        try {
+            ui.log[level](message);
+        } catch (error) {
+            completion.reject(error);
+        }
+    };
+    const log = {
+        info: (message)=>write('info', message),
+        success: (message)=>write('success', message),
+        warn: (message)=>write('warn', message),
+        error: (message)=>write('error', message)
+    };
+    const snapshot = ()=>services.map(({ state })=>state);
+    const onSigint = ()=>stop(true);
+    const onSigterm = ()=>{
+        process.exitCode = 143;
+        stop();
+    };
+    process.on('SIGINT', onSigint);
+    process.on('SIGTERM', onSigterm);
+    let timer;
+    const dispose = async (runtime)=>{
+        for (const callback of runtime.disposers.splice(0).reverse())try {
+            await callback();
+        } catch (error) {
+            log.warn(`[${runtime.pluginName}] 清理失败：${errorMessage(error)}`);
+        }
+    };
+    const report = (runtime, patch)=>{
+        runtime.state = {
+            ...runtime.state,
+            ...patch
+        };
+        try {
+            ui.update(snapshot());
+        } catch (error) {
+            completion.reject(error);
+        }
+    };
+    const fail = (runtime, error)=>{
+        if (controller.signal.aborted) return;
+        report(runtime, {
+            status: 'error',
+            message: '运行失败',
+            busy: false
+        });
+        log.error(`[${runtime.pluginName}/${runtime.service.name}] ${errorMessage(error)}`);
+    };
+    const update = (runtime)=>{
+        if (!runtime.dirty || 'ready' !== runtime.phase || runtime.running || controller.signal.aborted) return;
+        runtime.running = Promise.resolve().then(async ()=>{
+            try {
+                while(runtime.dirty && !controller.signal.aborted){
+                    runtime.dirty = false;
+                    try {
+                        await runtime.onChange?.();
+                    } catch (error) {
+                        fail(runtime, error);
+                    }
+                }
+            } finally{
+                runtime.running = void 0;
+            }
+        });
+    };
+    try {
+        const renderer = renderers[0];
+        rendering = (async ()=>{
+            if (false === options.tui || !isInteractive() || !renderer) return;
+            let created;
+            try {
+                created = await renderer.service.createUI(ctx, stop);
+            } catch (error) {
+                if (!controller.signal.aborted) log.warn(`调试界面加载失败，使用普通日志：${errorMessage(error)}`);
+                return;
+            }
+            if (controller.signal.aborted) return void await created.close();
+            ui = created;
+            interactive = true;
+            ui.update(snapshot());
+        })().catch(completion.reject);
+        const matches = (value, path)=>!path || value === path || value.startsWith(`${path}${sep}`);
+        const watcher = watch(project.root, {
+            ignoreInitial: true,
+            followSymlinks: false,
+            ignored: (path)=>{
+                const value = relative(project.root, path);
+                return Boolean(value) && !services.some((runtime)=>runtime.paths.some((path)=>matches(value, path) || matches(path, value)));
+            }
+        });
+        watcher.on('all', (_event, path)=>{
+            if (controller.signal.aborted) return;
+            const value = relative(project.root, path);
+            for (const runtime of services)if (runtime.paths.some((path)=>matches(value, path))) runtime.dirty = true;
+            clearTimeout(timer);
+            timer = setTimeout(()=>services.forEach(update), 400);
+        });
+        watcher.on('error', completion.reject);
+        const starting = Promise.all(services.map(async (runtime)=>{
+            try {
+                if (runtime === renderer) await rendering;
+                controller.signal.throwIfAborted();
+                await runtime.service.start({
+                    ...ctx,
+                    interactive,
+                    log,
+                    report: (patch)=>report(runtime, patch),
+                    onDispose: (callback)=>runtime.disposers.push(callback),
+                    onFileChange: (listener)=>{
+                        runtime.onChange = listener;
+                    }
+                });
+                runtime.phase = 'ready';
+                update(runtime);
+            } catch (error) {
+                runtime.phase = 'failed';
+                fail(runtime, error);
+                await dispose(runtime);
+            }
+        }));
+        try {
+            await completion.promise;
+        } finally{
+            controller.abort();
+            clearTimeout(timer);
+            try {
+                await watcher.close();
+            } finally{
+                await starting;
+                await Promise.all(services.map((runtime)=>runtime.running));
+            }
+        }
+    } catch (error) {
+        if (error !== controller.signal.reason && !(error instanceof Error && 'AbortError' === error.name)) throw error;
+    } finally{
+        controller.abort();
+        await rendering;
+        for (const runtime of services.toReversed())await dispose(runtime);
+        try {
+            await ui.close();
+        } finally{
+            process.off('SIGINT', onSigint);
+            process.off('SIGTERM', onSigterm);
+        }
+    }
+}
+async function selectServices(ctx, hooks) {
+    const { options } = ctx;
+    const available = [];
+    const names = new Set();
+    for (const hook of hooks){
+        const contributed = await callHook(hook, ctx);
+        const { pluginName } = hook;
+        for (const service of contributed){
+            if (!service.name || names.has(service.name)) throw new Error(`[${pluginName}] 开发服务名称为空或重复：${service.name}`);
+            names.add(service.name);
+            const applies = await callHook({
+                pluginName,
+                callback: service.appliesTo
+            }, ctx);
+            if (!applies && service.option && options[service.option]) throw new Error(`[${pluginName}] 当前项目不支持：${service.title}`);
+            if (applies) available.push({
+                pluginName,
+                service
+            });
+        }
+    }
+    const targets = available.filter(({ service })=>service.option);
+    let target = '';
+    if (targets.length && !options.plugin && !targets.some(({ service })=>options[service.option]) && false !== options.tui && isInteractive()) {
+        const choice = await prompts_select({
+            message: '请选择调试目标',
+            options: [
+                {
+                    value: '',
+                    label: '插件调试（Skill / MCP）'
+                },
+                ...targets.map(({ service })=>({
+                        value: service.name,
+                        label: service.title
+                    }))
+            ]
+        });
+        if (isCancel(choice)) {
+            cancel('已取消调试。');
+            process.exitCode = 130;
+            return;
+        }
+        target = choice;
+    }
+    return available.filter(({ service })=>!service.option || options[service.option] || service.name === target);
+}
+export { runSession };