@vibe-forge/tsconfigs 0.7.2 → 0.9.0

package/dist/packages/core/src/env.d.ts

@@ -0,0 +1,17 @@
+import type { LogLevel } from '@vibe-forge/utils/log-level';
+export type { LogLevel } from '@vibe-forge/utils/log-level';
+export { normalizeLogLevel, resolveServerLogLevel } from '@vibe-forge/utils/log-level';
+export interface ServerEnv {
+    __VF_PROJECT_AI_SERVER_HOST__: string;
+    __VF_PROJECT_AI_SERVER_PORT__: number;
+    __VF_PROJECT_AI_SERVER_WS_PATH__: string;
+    __VF_PROJECT_AI_SERVER_DATA_DIR__: string;
+    __VF_PROJECT_AI_SERVER_LOG_DIR__: string;
+    __VF_PROJECT_AI_SERVER_LOG_LEVEL__: LogLevel;
+    __VF_PROJECT_AI_SERVER_DEBUG__: boolean;
+    __VF_PROJECT_AI_SERVER_ALLOW_CORS__: boolean;
+    __VF_PROJECT_AI_CLIENT_MODE__?: 'dev' | 'static';
+    __VF_PROJECT_AI_CLIENT_BASE__?: string;
+    __VF_PROJECT_AI_CLIENT_DIST_PATH__?: string;
+}
+export declare function loadEnv(): ServerEnv;

package/dist/packages/core/src/env.js

@@ -0,0 +1,21 @@
+import { env as processEnv } from 'node:process';
+import { normalizeLogLevel } from '@vibe-forge/utils/log-level';
+export { normalizeLogLevel, resolveServerLogLevel } from '@vibe-forge/utils/log-level';
+export function loadEnv() {
+    const { __VF_PROJECT_AI_SERVER_HOST__ = 'localhost', __VF_PROJECT_AI_SERVER_PORT__ = '8787', __VF_PROJECT_AI_SERVER_WS_PATH__ = '/ws', __VF_PROJECT_AI_SERVER_DATA_DIR__ = '.data', __VF_PROJECT_AI_SERVER_LOG_DIR__ = '.logs', __VF_PROJECT_AI_SERVER_LOG_LEVEL__ = 'info', __VF_PROJECT_AI_SERVER_DEBUG__, __VF_PROJECT_AI_SERVER_ALLOW_CORS__, __VF_PROJECT_AI_CLIENT_MODE__ = 'static', __VF_PROJECT_AI_CLIENT_BASE__, __VF_PROJECT_AI_CLIENT_DIST_PATH__ } = processEnv || {};
+    return {
+        __VF_PROJECT_AI_SERVER_HOST__,
+        __VF_PROJECT_AI_SERVER_PORT__: Number(__VF_PROJECT_AI_SERVER_PORT__),
+        __VF_PROJECT_AI_SERVER_WS_PATH__,
+        __VF_PROJECT_AI_SERVER_DATA_DIR__,
+        __VF_PROJECT_AI_SERVER_LOG_DIR__,
+        __VF_PROJECT_AI_SERVER_LOG_LEVEL__: normalizeLogLevel(__VF_PROJECT_AI_SERVER_LOG_LEVEL__) ?? 'info',
+        __VF_PROJECT_AI_SERVER_DEBUG__: __VF_PROJECT_AI_SERVER_DEBUG__ === 'true',
+        __VF_PROJECT_AI_SERVER_ALLOW_CORS__: __VF_PROJECT_AI_SERVER_ALLOW_CORS__ != null
+            ? __VF_PROJECT_AI_SERVER_ALLOW_CORS__ === 'true'
+            : true,
+        __VF_PROJECT_AI_CLIENT_MODE__: __VF_PROJECT_AI_CLIENT_MODE__,
+        __VF_PROJECT_AI_CLIENT_BASE__,
+        __VF_PROJECT_AI_CLIENT_DIST_PATH__
+    };
+}

package/dist/packages/core/src/hooks/bridge-loader.d.ts

@@ -0,0 +1,14 @@
+export interface NativeHookBridgeModule {
+    isNativeHookEnv: () => boolean;
+    runHookBridge: () => Promise<void> | void;
+}
+export interface NativeHookBridgeLoaderDeps {
+    hasHookBridgeExport: (packageName: string) => boolean;
+    loadHookBridge: (packageName: string) => unknown;
+    readAdapterScopeEntries: (scopeDir: string) => string[];
+    resolveSearchPaths: () => string[];
+}
+export declare const readInstalledAdapterScopeEntries: (scopeDir: string) => string[];
+export declare const resolvePreferredNativeHookBridgePackage: (env?: NodeJS.ProcessEnv) => string | undefined;
+export declare const listInstalledAdapterPackages: (deps?: NativeHookBridgeLoaderDeps) => string[];
+export declare const resolveActiveNativeHookBridge: (deps?: NativeHookBridgeLoaderDeps, env?: NodeJS.ProcessEnv) => NativeHookBridgeModule | undefined;

package/dist/packages/core/src/hooks/bridge-loader.js

@@ -0,0 +1,97 @@
+import { existsSync, readdirSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import process from 'node:process';
+import { NATIVE_HOOK_BRIDGE_ADAPTER_ENV } from './native';
+const HOOK_BRIDGE_EXPORT_SUFFIX = '/hook-bridge';
+const ADAPTER_SCOPE = '@vibe-forge';
+const ADAPTER_PREFIX = 'adapter-';
+const createWorkspaceRequire = () => {
+    const workspaceFolder = process.env.__VF_PROJECT_WORKSPACE_FOLDER__ ?? process.cwd();
+    return createRequire(path.resolve(workspaceFolder, '__vf-hook-loader__.js'));
+};
+const resolveAdapterPackageName = (value) => {
+    const trimmed = value.trim();
+    if (trimmed.startsWith('@'))
+        return trimmed;
+    if (trimmed.startsWith(ADAPTER_PREFIX))
+        return `${ADAPTER_SCOPE}/${trimmed}`;
+    return `${ADAPTER_SCOPE}/${ADAPTER_PREFIX}${trimmed}`;
+};
+const isHookBridgeResolveMiss = (error) => {
+    const code = error?.code;
+    return code === 'MODULE_NOT_FOUND' || code === 'ERR_PACKAGE_PATH_NOT_EXPORTED';
+};
+const isNativeHookBridgeModule = (value) => {
+    if (value == null || typeof value !== 'object')
+        return false;
+    return (typeof value.isNativeHookEnv === 'function'
+        && typeof value.runHookBridge === 'function');
+};
+export const readInstalledAdapterScopeEntries = (scopeDir) => {
+    if (!existsSync(scopeDir))
+        return [];
+    return readdirSync(scopeDir, { withFileTypes: true })
+        .filter(entry => (entry.name.startsWith(ADAPTER_PREFIX)
+        && (entry.isDirectory() || entry.isSymbolicLink())))
+        .map(entry => entry.name);
+};
+export const resolvePreferredNativeHookBridgePackage = (env = process.env) => {
+    const value = env[NATIVE_HOOK_BRIDGE_ADAPTER_ENV]?.trim();
+    return value ? resolveAdapterPackageName(value) : undefined;
+};
+const defaultLoaderDeps = {
+    resolveSearchPaths: () => createWorkspaceRequire().resolve.paths(`${ADAPTER_SCOPE}/adapter-placeholder`) ?? [],
+    readAdapterScopeEntries: readInstalledAdapterScopeEntries,
+    hasHookBridgeExport: (packageName) => {
+        try {
+            createWorkspaceRequire().resolve(`${packageName}${HOOK_BRIDGE_EXPORT_SUFFIX}`);
+            return true;
+        }
+        catch (error) {
+            if (isHookBridgeResolveMiss(error))
+                return false;
+            throw error;
+        }
+    },
+    loadHookBridge: packageName => createWorkspaceRequire()(`${packageName}${HOOK_BRIDGE_EXPORT_SUFFIX}`)
+};
+const tryLoadNativeHookBridge = (packageName, deps) => {
+    try {
+        if (!deps.hasHookBridgeExport(packageName))
+            return undefined;
+        const bridgeModule = deps.loadHookBridge(packageName);
+        if (!isNativeHookBridgeModule(bridgeModule))
+            return undefined;
+        return bridgeModule.isNativeHookEnv() ? bridgeModule : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+export const listInstalledAdapterPackages = (deps = defaultLoaderDeps) => {
+    const packages = new Set();
+    for (const searchPath of deps.resolveSearchPaths()) {
+        const scopeDir = path.resolve(searchPath, ADAPTER_SCOPE);
+        for (const entry of deps.readAdapterScopeEntries(scopeDir)) {
+            packages.add(`${ADAPTER_SCOPE}/${entry}`);
+        }
+    }
+    return [...packages].sort();
+};
+export const resolveActiveNativeHookBridge = (deps = defaultLoaderDeps, env = process.env) => {
+    const preferredPackage = resolvePreferredNativeHookBridgePackage(env);
+    if (preferredPackage) {
+        const preferredBridge = tryLoadNativeHookBridge(preferredPackage, deps);
+        if (preferredBridge)
+            return preferredBridge;
+    }
+    for (const packageName of listInstalledAdapterPackages(deps)) {
+        if (packageName === preferredPackage)
+            continue;
+        const bridgeModule = tryLoadNativeHookBridge(packageName, deps);
+        if (bridgeModule)
+            return bridgeModule;
+    }
+    return undefined;
+};

package/dist/packages/core/src/hooks/bridge.d.ts

@@ -0,0 +1,17 @@
+import type { AdapterCtx, AdapterOutputEvent, AdapterQueryOptions, AdapterSession } from '#~/adapter/index.js';
+import type { HookInputs } from './type';
+export interface AdapterHookBridge {
+    start: () => Promise<void>;
+    prepareInitialPrompt: (prompt?: string) => Promise<string | undefined>;
+    wrapSession: (session: AdapterSession) => AdapterSession;
+    handleOutput: (event: AdapterOutputEvent) => void;
+}
+export declare const createAdapterHookBridge: (params: {
+    ctx: Pick<AdapterCtx, "cwd" | "env" | "logger">;
+    adapter: string;
+    runtime: AdapterQueryOptions["runtime"];
+    sessionId: string;
+    type: AdapterQueryOptions["type"];
+    model?: string;
+    disabledEvents?: Array<keyof HookInputs>;
+}) => AdapterHookBridge;

package/dist/packages/core/src/hooks/bridge.js

@@ -0,0 +1,250 @@
+import { callHook } from './call';
+const normalizeText = (value) => (typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined);
+const stringifyUnknown = (value) => {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+};
+const describeContentPart = (item) => {
+    switch (item.type) {
+        case 'text':
+            return normalizeText(item.text);
+        case 'image':
+            return normalizeText(item.name) != null ? `[Image: ${item.name}]` : '[Image attachment]';
+        case 'tool_use':
+            return `Tool request: ${item.name}`;
+        case 'tool_result':
+            return typeof item.content === 'string' ? normalizeText(item.content) : stringifyUnknown(item.content);
+        default:
+            return undefined;
+    }
+};
+const extractPromptText = (content) => {
+    const parts = content
+        .map(describeContentPart)
+        .filter((value) => value != null);
+    return parts.length > 0 ? parts.join('\n\n') : undefined;
+};
+const extractAssistantText = (message) => {
+    if (message == null)
+        return undefined;
+    if (typeof message.content === 'string')
+        return normalizeText(message.content);
+    const parts = message.content
+        .filter((item) => item.type === 'text')
+        .map(item => normalizeText(item.text))
+        .filter((value) => value != null);
+    return parts.length > 0 ? parts.join('') : undefined;
+};
+const isToolUse = (item) => item.type === 'tool_use';
+const isToolResult = (item) => item.type === 'tool_result';
+export const createAdapterHookBridge = (params) => {
+    const { ctx, adapter, runtime, sessionId, type, model, disabledEvents: rawDisabledEvents = [] } = params;
+    const disabledEvents = new Set(rawDisabledEvents);
+    const pendingToolCalls = new Map();
+    let emitQueue = Promise.resolve();
+    let killRequested = false;
+    let lastAssistantMessage;
+    let sessionEnded = false;
+    const callBridgeHook = async (eventName, input, options) => {
+        if (disabledEvents.has(eventName)) {
+            return undefined;
+        }
+        try {
+            const output = await callHook(eventName, {
+                cwd: ctx.cwd,
+                sessionId,
+                adapter,
+                runtime,
+                hookSource: 'bridge',
+                canBlock: options.canBlock,
+                ...input
+            }, ctx.env);
+            if (options.enforce && output?.continue === false) {
+                throw new Error(output.stopReason ?? options.blockedMessage);
+            }
+            if (!options.canBlock && output?.continue === false) {
+                ctx.logger.warn(`[HookBridge] Ignoring blocking output from observational ${String(eventName)} hook`, output.stopReason);
+            }
+            return output;
+        }
+        catch (error) {
+            ctx.logger.error(`[HookBridge] ${String(eventName)} failed`, error);
+            if (options.enforce)
+                throw error;
+            return undefined;
+        }
+    };
+    const observeMessage = (message) => {
+        const assistantText = extractAssistantText(message);
+        if (assistantText != null)
+            lastAssistantMessage = assistantText;
+        const preToolUseDisabled = disabledEvents.has('PreToolUse');
+        const postToolUseDisabled = disabledEvents.has('PostToolUse');
+        const needsPendingToolCalls = !postToolUseDisabled;
+        if (Array.isArray(message.content)) {
+            for (const item of message.content) {
+                if (isToolUse(item)) {
+                    if (needsPendingToolCalls) {
+                        pendingToolCalls.set(item.id, {
+                            toolName: item.name,
+                            toolInput: item.input
+                        });
+                    }
+                    if (!preToolUseDisabled) {
+                        void callBridgeHook('PreToolUse', {
+                            toolCallId: item.id,
+                            toolName: item.name,
+                            toolInput: item.input
+                        }, {
+                            canBlock: false,
+                            blockedMessage: 'PreToolUse hook attempted to block an observed tool call'
+                        });
+                    }
+                }
+                if (isToolResult(item)) {
+                    const pending = pendingToolCalls.get(item.tool_use_id);
+                    pendingToolCalls.delete(item.tool_use_id);
+                    if (!postToolUseDisabled) {
+                        void callBridgeHook('PostToolUse', {
+                            toolCallId: item.tool_use_id,
+                            toolName: pending?.toolName ?? 'unknown',
+                            toolInput: pending?.toolInput,
+                            toolResponse: item.content,
+                            isError: item.is_error ?? false
+                        }, {
+                            canBlock: false,
+                            blockedMessage: 'PostToolUse hook attempted to block an observed tool result'
+                        });
+                    }
+                }
+            }
+        }
+        if (message.toolCall?.name != null) {
+            const toolCallId = message.toolCall.id ?? message.id;
+            if (needsPendingToolCalls && !pendingToolCalls.has(toolCallId)) {
+                pendingToolCalls.set(toolCallId, {
+                    toolName: message.toolCall.name,
+                    toolInput: message.toolCall.args
+                });
+            }
+            if (!preToolUseDisabled) {
+                void callBridgeHook('PreToolUse', {
+                    toolCallId,
+                    toolName: message.toolCall.name,
+                    toolInput: message.toolCall.args
+                }, {
+                    canBlock: false,
+                    blockedMessage: 'PreToolUse hook attempted to block a legacy observed tool call'
+                });
+            }
+            if (!postToolUseDisabled && (message.toolCall.output != null || message.toolCall.status === 'error')) {
+                pendingToolCalls.delete(toolCallId);
+                void callBridgeHook('PostToolUse', {
+                    toolCallId,
+                    toolName: message.toolCall.name,
+                    toolInput: message.toolCall.args,
+                    toolResponse: message.toolCall.output,
+                    isError: message.toolCall.status === 'error'
+                }, {
+                    canBlock: false,
+                    blockedMessage: 'PostToolUse hook attempted to block a legacy observed tool result'
+                });
+            }
+        }
+    };
+    return {
+        start: async () => {
+            if (disabledEvents.has('SessionStart'))
+                return;
+            await callBridgeHook('SessionStart', {
+                source: type === 'resume' ? 'resume' : 'startup',
+                model
+            }, {
+                canBlock: true,
+                enforce: true,
+                blockedMessage: 'SessionStart hook blocked session startup'
+            });
+        },
+        prepareInitialPrompt: async (prompt) => {
+            const normalizedPrompt = normalizeText(prompt);
+            if (normalizedPrompt == null)
+                return normalizedPrompt;
+            if (disabledEvents.has('UserPromptSubmit'))
+                return normalizedPrompt;
+            await callBridgeHook('UserPromptSubmit', { prompt: normalizedPrompt }, {
+                canBlock: true,
+                enforce: true,
+                blockedMessage: 'UserPromptSubmit hook blocked the initial prompt'
+            });
+            return normalizedPrompt;
+        },
+        wrapSession: (session) => ({
+            kill: () => {
+                killRequested = true;
+                session.kill();
+            },
+            emit: (event) => {
+                emitQueue = emitQueue
+                    .catch((error) => {
+                    ctx.logger.error('[HookBridge] emit queue failed', error);
+                })
+                    .then(async () => {
+                    if (event.type === 'message') {
+                        const prompt = extractPromptText(event.content);
+                        if (prompt != null && !disabledEvents.has('UserPromptSubmit')) {
+                            const output = await callBridgeHook('UserPromptSubmit', { prompt }, {
+                                canBlock: true,
+                                blockedMessage: 'UserPromptSubmit hook blocked the outgoing prompt'
+                            });
+                            if (output?.continue === false) {
+                                ctx.logger.warn('[HookBridge] Dropping outgoing message blocked by UserPromptSubmit hook', output.stopReason);
+                                return;
+                            }
+                        }
+                    }
+                    session.emit(event);
+                });
+            },
+            get pid() {
+                return session.pid;
+            }
+        }),
+        handleOutput: (event) => {
+            if (event.type === 'message' && event.data.role === 'assistant') {
+                observeMessage(event.data);
+                return;
+            }
+            if (event.type === 'stop') {
+                if (disabledEvents.has('Stop'))
+                    return;
+                void callBridgeHook('Stop', {
+                    lastAssistantMessage: extractAssistantText(event.data) ?? lastAssistantMessage
+                }, {
+                    canBlock: false,
+                    blockedMessage: 'Stop hook attempted to control an observed stop event'
+                });
+                return;
+            }
+            if (event.type === 'exit' && !sessionEnded) {
+                sessionEnded = true;
+                void callBridgeHook('SessionEnd', {
+                    reason: killRequested
+                        ? 'terminated'
+                        : (event.data.exitCode ?? 0) === 0
+                            ? 'completed'
+                            : 'failed',
+                    exitCode: event.data.exitCode,
+                    stderr: event.data.stderr,
+                    lastAssistantMessage
+                }, {
+                    canBlock: false,
+                    blockedMessage: 'SessionEnd hook attempted to control an observed session end'
+                });
+            }
+        }
+    };
+};

package/dist/packages/core/src/hooks/call.d.ts

@@ -0,0 +1,5 @@
+import type { HookInputs, HookOutputs } from './type';
+export type HookEventName = keyof HookInputs;
+type HookInputPayload<K extends HookEventName> = Omit<HookInputs[K], 'hookEventName'>;
+export declare const callHook: <K extends HookEventName>(hookEventName: K, input: HookInputPayload<K>, env?: Record<string, unknown>) => Promise<HookOutputs[K]>;
+export {};

package/dist/packages/core/src/hooks/call.js

@@ -0,0 +1,47 @@
+import { Buffer } from 'node:buffer';
+import { spawn } from 'node:child_process';
+import process from 'node:process';
+import { resolveManagedHookScriptPath } from './native';
+const pickHookEnv = (env) => {
+    const result = {};
+    for (const [key, value] of Object.entries(env)) {
+        if (typeof value === 'string') {
+            result[key] = value;
+        }
+    }
+    return result;
+};
+export const callHook = async (hookEventName, input, env = process.env) => {
+    const childEnv = pickHookEnv(env);
+    const child = spawn(process.execPath, [resolveManagedHookScriptPath('call-hook.js')], {
+        cwd: typeof input.cwd === 'string' ? input.cwd : process.cwd(),
+        env: childEnv,
+        stdio: ['pipe', 'pipe', 'pipe']
+    });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    child.stdout.on('data', chunk => stdoutChunks.push(chunk));
+    child.stderr.on('data', chunk => stderrChunks.push(chunk));
+    const exitCode = await new Promise((resolve, reject) => {
+        child.once('error', reject);
+        child.once('close', code => resolve(code ?? 0));
+        child.stdin.end(JSON.stringify({
+            ...input,
+            hookEventName
+        }));
+    });
+    const stdout = Buffer.concat(stdoutChunks).toString('utf-8').trim();
+    const stderr = Buffer.concat(stderrChunks).toString('utf-8').trim();
+    if (exitCode !== 0) {
+        throw new Error(`Failed to call hook: process exited with code ${exitCode}${stderr ? ` - ${stderr}` : ''}`);
+    }
+    if (stdout === '') {
+        return { continue: true };
+    }
+    try {
+        return JSON.parse(stdout);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse hook output: ${stdout}${stderr ? `\nstderr: ${stderr}` : ''}`, { cause: error });
+    }
+};

package/dist/packages/core/src/hooks/entry.d.ts

@@ -0,0 +1,5 @@
+import type { NativeHookBridgeModule } from './bridge-loader';
+export declare const runManagedHookEntrypoint: (deps?: {
+    resolveActiveNativeHookBridge?: () => NativeHookBridgeModule | undefined;
+    runHookCli?: () => Promise<void>;
+}) => Promise<void>;

package/dist/packages/core/src/hooks/entry.js

@@ -0,0 +1,15 @@
+import { runHookCli } from './runtime';
+import { resolveActiveNativeHookBridge } from './bridge-loader';
+export const runManagedHookEntrypoint = async (deps = {}) => {
+    try {
+        const bridge = (deps.resolveActiveNativeHookBridge ?? resolveActiveNativeHookBridge)();
+        if (bridge) {
+            await bridge.runHookBridge();
+            return;
+        }
+    }
+    catch (error) {
+        console.error('[vibe-forge hooks] failed to load native hook bridge, falling back to default hook runtime', error);
+    }
+    await (deps.runHookCli ?? runHookCli)();
+};

package/dist/packages/core/src/hooks/index.d.ts

@@ -0,0 +1,28 @@
+import type { Writable } from 'node:stream';
+import type { HookInputs, HookOutputs } from './type';
+export interface HookContext {
+    logger: {
+        stream: Writable;
+        info: (...args: unknown[]) => void;
+        warn: (...args: unknown[]) => void;
+        debug: (...args: unknown[]) => void;
+        error: (...args: unknown[]) => void;
+    };
+}
+export type Plugin = {
+    name?: string;
+} & {
+    [P in keyof HookInputs]: (ctx: HookContext, input: HookInputs[P], next: () => Promise<HookOutputs[P]>) => Promise<HookOutputs[P]>;
+};
+export declare const definePlugin: (plugin: Partial<Plugin>) => Partial<Plugin>;
+export interface PluginMap {
+}
+export type PluginConfig = (Partial<Plugin> | (() => Partial<Plugin>))[] | Record<string, Record<string, unknown>> | Partial<PluginMap>;
+export * from './bridge';
+export * from './bridge-loader';
+export * from './call';
+export * from './entry';
+export * from './loader';
+export * from './native';
+export * from './runtime';
+export * from './type';

package/dist/packages/core/src/hooks/index.js

@@ -0,0 +1,9 @@
+export const definePlugin = (plugin) => plugin;
+export * from './bridge';
+export * from './bridge-loader';
+export * from './call';
+export * from './entry';
+export * from './loader';
+export * from './native';
+export * from './runtime';
+export * from './type';

package/dist/packages/core/src/hooks/loader.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin, PluginConfig } from './index';
+export declare const resolvePlugins: (config: PluginConfig, enabledPlugins?: Record<string, boolean>) => Promise<Partial<Plugin>[]>;

package/dist/packages/core/src/hooks/loader.js

@@ -0,0 +1,57 @@
+/**
+ * 解析单个插件配置
+ */
+const loadPlugin = async (name, config) => {
+    try {
+        // eslint-disable-next-line ts/no-require-imports
+        const module = require(`${name}/hooks`);
+        // 兼容 ESM default export 和 CJS module.exports
+        const factory = module.default ?? module;
+        if (typeof factory === 'function') {
+            // TODO: 这里可以注入更多上下文，如全局配置、版本信息等
+            return factory(config);
+        }
+        else if (typeof factory === 'object' && factory !== null) {
+            return factory;
+        }
+        console.warn(`Plugin ${name} does not export a valid plugin factory or object.`);
+        return null;
+    }
+    catch (e) {
+        console.error(`Failed to load plugin ${name}:`, e);
+        return null;
+    }
+};
+export const resolvePlugins = async (config, enabledPlugins = {}) => {
+    // 1. 处理数组形式配置 (直接实例化或函数调用)
+    if (Array.isArray(config)) {
+        return config.map((p) => (typeof p === 'function' ? p() : p));
+    }
+    // 2. 处理对象形式配置 (动态加载)
+    const entries = Object.entries(config)
+        .filter(([pkgName]) => enabledPlugins[pkgName] !== false);
+    if (entries.length === 0)
+        return [];
+    // 并行加载所有插件
+    const modules = await Promise.allSettled(entries.map(([pkgName, pkgConfig]) => {
+        // 如果不是以 @ 或 @vibe-forge/plugin- 开头，则默认加上 @vibe-forge/plugin- 前缀
+        const resolvedName = pkgName.startsWith('@') ? pkgName : `@vibe-forge/plugin-${pkgName}`;
+        // dprint-ignore
+        return (loadPlugin(resolvedName, pkgConfig) ??
+            loadPlugin(pkgName, pkgConfig));
+    }));
+    // 收集成功加载的插件
+    const plugins = [];
+    modules.forEach((result, index) => {
+        const pkgName = entries[index][0];
+        if (result.status === 'fulfilled') {
+            if (result.value) {
+                plugins.push(result.value);
+            }
+        }
+        else {
+            console.error(`Error loading plugin ${pkgName}:`, result.reason);
+        }
+    });
+    return plugins;
+};

package/dist/packages/core/src/hooks/native.d.ts

@@ -0,0 +1,38 @@
+import type { AdapterCtx } from '../adapter';
+export interface NativeHookHandlerConfig {
+    type: 'command';
+    command: string;
+    timeout?: number;
+    statusMessage?: string;
+}
+export interface NativeHookMatcherGroup {
+    matcher?: string;
+    hooks?: NativeHookHandlerConfig[];
+}
+export interface NativeHooksConfigFile {
+    hooks?: Partial<Record<string, NativeHookMatcherGroup[]>> & Record<string, unknown>;
+}
+export declare const NATIVE_HOOK_BRIDGE_ADAPTER_ENV = "__VF_VIBE_FORGE_HOOK_BRIDGE_ADAPTER__";
+export declare const hasManagedHookPlugins: (ctx: Pick<AdapterCtx, "assets">) => boolean;
+export declare const resolveMockHome: (cwd: string, env: Pick<AdapterCtx, "env">["env"]) => string;
+export declare const resolveManagedHookPackageDir: () => string;
+export declare const resolveManagedHookScriptPath: (fileName: string) => string;
+export declare const shellQuote: (value: string) => string;
+export declare const buildNodeScriptCommand: (params: {
+    nodePath: string;
+    scriptPath: string;
+}) => string;
+export declare const prepareManagedHookRuntime: (ctx: Pick<AdapterCtx, "cwd" | "env">) => {
+    mockHome: string;
+    nodePath: string;
+};
+export declare const readJsonFileOrDefault: <T>(filePath: string, fallback: T) => Promise<T>;
+export declare const writeJsonFile: (filePath: string, value: unknown) => Promise<void>;
+export declare const mergeManagedHookGroups: (params: {
+    existing: unknown;
+    eventNames: readonly string[];
+    enabled: boolean;
+    isManagedGroup: (group: NativeHookMatcherGroup) => boolean;
+    createGroup: (eventName: string) => NativeHookMatcherGroup;
+    shouldManageEvent?: (eventName: string) => boolean;
+}) => NativeHooksConfigFile;