@vibe-forge/tsconfigs 0.7.1 → 0.8.0

package/dist/packages/hooks/src/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/hooks/src/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/hooks/src/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/hooks/src/context.d.ts

@@ -0,0 +1,14 @@
+import type { Logger } from '@vibe-forge/utils/create-logger';
+import type { HookPluginConfig } from '@vibe-forge/types';
+import type { HookInputs, HookOutputs } from './type';
+export type HookLogger = Logger;
+export interface HookContext {
+    logger: HookLogger;
+}
+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 type PluginConfig = (Partial<Plugin> | (() => Partial<Plugin>))[] | HookPluginConfig;

package/dist/packages/hooks/src/context.js

@@ -0,0 +1 @@
+export const definePlugin = (plugin) => plugin;

package/dist/packages/hooks/src/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/hooks/src/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/hooks/src/index.d.ts

@@ -0,0 +1,9 @@
+export * from './bridge';
+export * from './bridge-loader';
+export * from './call';
+export * from './context';
+export * from './entry';
+export * from './loader';
+export * from './native';
+export * from './runtime';
+export * from './type';

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

@@ -0,0 +1,9 @@
+export * from './bridge';
+export * from './bridge-loader';
+export * from './call';
+export * from './context';
+export * from './entry';
+export * from './loader';
+export * from './native';
+export * from './runtime';
+export * from './type';

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

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

package/dist/packages/hooks/src/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/hooks/src/native.d.ts

@@ -0,0 +1,44 @@
+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: {
+    assets?: {
+        hookPlugins?: unknown[];
+    };
+}) => boolean;
+export declare const resolveMockHome: (cwd: string, env: Record<string, string | null | undefined>) => 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: {
+    cwd: string;
+    env: Record<string, string | null | undefined>;
+}) => {
+    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;

package/dist/packages/hooks/src/native.js

@@ -0,0 +1,65 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import process from 'node:process';
+export const NATIVE_HOOK_BRIDGE_ADAPTER_ENV = '__VF_VIBE_FORGE_HOOK_BRIDGE_ADAPTER__';
+const isPlainObject = (value) => (value != null && typeof value === 'object' && !Array.isArray(value));
+export const hasManagedHookPlugins = (ctx) => (ctx.assets?.hookPlugins?.length ?? 0) > 0;
+export const resolveMockHome = (cwd, env) => {
+    const explicitHome = env.HOME?.trim() || process.env.HOME?.trim();
+    return explicitHome ? resolve(explicitHome) : resolve(cwd, '.ai', '.mock');
+};
+export const resolveManagedHookPackageDir = () => {
+    try {
+        const pkgJsonPath = require.resolve('@vibe-forge/hooks/package.json');
+        return dirname(pkgJsonPath);
+    }
+    catch (error) {
+        throw new Error('Failed to resolve @vibe-forge/hooks managed hook entry', { cause: error });
+    }
+};
+export const resolveManagedHookScriptPath = (fileName) => (resolve(resolveManagedHookPackageDir(), fileName));
+export const shellQuote = (value) => JSON.stringify(value);
+export const buildNodeScriptCommand = (params) => `${shellQuote(params.nodePath)} ${shellQuote(params.scriptPath)}`;
+export const prepareManagedHookRuntime = (ctx) => {
+    const mockHome = resolveMockHome(ctx.cwd, ctx.env);
+    const nodePath = process.execPath;
+    ctx.env.__VF_PROJECT_WORKSPACE_FOLDER__ = ctx.env.__VF_PROJECT_WORKSPACE_FOLDER__ ?? ctx.cwd;
+    ctx.env.__VF_PROJECT_NODE_PATH__ = nodePath;
+    return {
+        mockHome,
+        nodePath
+    };
+};
+export const readJsonFileOrDefault = async (filePath, fallback) => {
+    try {
+        return JSON.parse(await readFile(filePath, 'utf8'));
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            return fallback;
+        throw error;
+    }
+};
+export const writeJsonFile = async (filePath, value) => {
+    await mkdir(dirname(filePath), { recursive: true });
+    await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+};
+export const mergeManagedHookGroups = (params) => {
+    const parsed = isPlainObject(params.existing) ? params.existing : {};
+    const hooks = isPlainObject(parsed.hooks)
+        ? parsed.hooks
+        : {};
+    const nextHooks = { ...hooks };
+    for (const eventName of params.eventNames) {
+        const groups = Array.isArray(hooks[eventName])
+            ? hooks[eventName].filter(group => !params.isManagedGroup(group))
+            : [];
+        nextHooks[eventName] = params.enabled && (params.shouldManageEvent?.(eventName) ?? true)
+            ? [...groups, params.createGroup(eventName)]
+            : groups;
+    }
+    return {
+        ...parsed,
+        hooks: nextHooks
+    };
+};

package/dist/packages/hooks/src/runtime.d.ts

@@ -0,0 +1,27 @@
+import type { HookContext, Plugin } from './context';
+import type { HookInput, HookInputs, HookOutputCore, HookOutputs } from './type';
+export declare const callPluginHook: <K extends keyof HookInputs>(eventName: K, context: HookContext, input: HookInputs[K], plugins?: Partial<Plugin>[]) => Promise<HookOutputs[K]>;
+export declare const executeHookInput: (input: HookInput, env?: Record<string, string | null | undefined>) => Promise<HookOutputCore | (HookOutputCore & {
+    hookSpecificOutput?: {
+        hookEventName: "PreToolUse";
+        permissionDecision: "allow" | "deny" | "ask";
+        permissionDecisionReason: string;
+    };
+}) | (HookOutputCore & {
+    hookSpecificOutput?: {
+        hookEventName: "PostToolUse";
+        additionalContext: string;
+    };
+}) | (HookOutputCore & {
+    hookSpecificOutput?: {
+        hookEventName: "UserPromptSubmit";
+        additionalContext: string;
+    };
+}) | (HookOutputCore & {
+    hookSpecificOutput?: {
+        hookEventName: "SessionStart";
+        additionalContext: string;
+    };
+})>;
+export declare const readHookInput: () => Promise<HookInput>;
+export declare const runHookCli: () => Promise<void>;

package/dist/packages/hooks/src/runtime.js

@@ -0,0 +1,86 @@
+import { Buffer } from 'node:buffer';
+import process from 'node:process';
+import { buildConfigJsonVariables, loadConfig, resetConfigCache } from '@vibe-forge/config';
+import { createLogger } from '@vibe-forge/utils/create-logger';
+import { resolveServerLogLevel } from '@vibe-forge/utils/log-level';
+import { transformCamelKey } from '@vibe-forge/utils/string-transform';
+import { resolvePlugins } from './loader';
+export const callPluginHook = async (eventName, context, input, plugins = []) => {
+    const { logger } = context;
+    const filteredPlugins = plugins.filter((item) => !!item && !!item[eventName]);
+    let index = 0;
+    const next = async () => {
+        if (index >= filteredPlugins.length) {
+            return { continue: true };
+        }
+        const currentPlugin = filteredPlugins[index];
+        const name = currentPlugin.name ?? '<anonymous>';
+        const hook = currentPlugin[eventName];
+        index++;
+        const withNameLogger = {
+            ...logger,
+            info: logger.info.bind(logger, `[plugin.${name}]`),
+            warn: logger.warn.bind(logger, `[plugin.${name}]`),
+            debug: logger.debug.bind(logger, `[plugin.${name}]`),
+            error: logger.error.bind(logger, `[plugin.${name}]`)
+        };
+        try {
+            return await hook({
+                ...context,
+                logger: withNameLogger
+            }, input, next);
+        }
+        catch (error) {
+            if (error instanceof Error && !error.name.includes('[plugin.')) {
+                error.name = `${error.name}[plugin.${name}]`;
+            }
+            throw error;
+        }
+    };
+    return next();
+};
+export const executeHookInput = async (input, env = process.env) => {
+    const workspaceFolder = env.__VF_PROJECT_WORKSPACE_FOLDER__ ?? input.cwd ?? process.env.HOME ?? '/';
+    const ctxId = env.__VF_PROJECT_AI_CTX_ID__ ?? input.sessionId ?? 'default';
+    const logPrefix = env.__VF_PROJECT_AI_LOG_PREFIX__ ?? '';
+    const loggerBase = createLogger(workspaceFolder, ctxId, input.sessionId, logPrefix, resolveServerLogLevel(env));
+    const logger = {
+        ...loggerBase,
+        info: (...args) => loggerBase.info(`[${input.hookEventName}]`, ...args),
+        warn: (...args) => loggerBase.warn(`[${input.hookEventName}]`, ...args),
+        debug: (...args) => loggerBase.debug(`[${input.hookEventName}]`, ...args),
+        error: (...args) => loggerBase.error(`[${input.hookEventName}]`, ...args)
+    };
+    resetConfigCache(workspaceFolder);
+    const jsonVariables = buildConfigJsonVariables(workspaceFolder, env);
+    const [config, userConfig] = await loadConfig({
+        cwd: workspaceFolder,
+        jsonVariables
+    });
+    const plugins = [
+        ...await resolvePlugins(config?.plugins ?? [], config?.enabledPlugins ?? {}),
+        ...await resolvePlugins(userConfig?.plugins ?? [], userConfig?.enabledPlugins ?? {})
+    ];
+    return callPluginHook(input.hookEventName, { logger }, input, plugins);
+};
+export const readHookInput = async () => {
+    const stdoutBuffer = await new Promise((resolve) => {
+        const chunks = [];
+        process.stdin.on('data', chunk => chunks.push(chunk));
+        process.stdin.once('end', () => resolve(Buffer.concat(chunks)));
+    });
+    return transformCamelKey(JSON.parse(stdoutBuffer.toString() || '{}'));
+};
+export const runHookCli = async () => {
+    try {
+        const input = await readHookInput();
+        const result = await executeHookInput(input);
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+    }
+    catch (error) {
+        process.stdout.write(`${JSON.stringify({
+            continue: false,
+            stopReason: `run hook error: ${String(error)}`
+        })}\n`);
+    }
+};