@vibe-forge/core 0.7.3 → 0.7.5

package/src/hooks/bridge.ts

@@ -0,0 +1,368 @@
+import type {
+  AdapterCtx,
+  AdapterEvent,
+  AdapterOutputEvent,
+  AdapterQueryOptions,
+  AdapterSession
+} from '#~/adapter/index.js'
+import type { ChatMessage, ChatMessageContent } from '#~/types.js'
+import type { HookInputs } from './type'
+
+import { callHook } from './call'
+
+const normalizeText = (value: unknown) => (
+  typeof value === 'string' && value.trim() !== '' ? value.trim() : undefined
+)
+
+const stringifyUnknown = (value: unknown) => {
+  try {
+    return JSON.stringify(value)
+  } catch {
+    return String(value)
+  }
+}
+
+const describeContentPart = (item: ChatMessageContent): string | undefined => {
+  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: AdapterEvent['content']) => {
+  const parts = content
+    .map(describeContentPart)
+    .filter((value): value is string => value != null)
+
+  return parts.length > 0 ? parts.join('\n\n') : undefined
+}
+
+const extractAssistantText = (message: ChatMessage | undefined) => {
+  if (message == null) return undefined
+  if (typeof message.content === 'string') return normalizeText(message.content)
+
+  const parts = message.content
+    .filter((item): item is Extract<ChatMessageContent, { type: 'text' }> => item.type === 'text')
+    .map(item => normalizeText(item.text))
+    .filter((value): value is string => value != null)
+
+  return parts.length > 0 ? parts.join('') : undefined
+}
+
+const isToolUse = (
+  item: ChatMessageContent
+): item is Extract<ChatMessageContent, { type: 'tool_use' }> => item.type === 'tool_use'
+
+const isToolResult = (
+  item: ChatMessageContent
+): item is Extract<ChatMessageContent, { type: 'tool_result' }> => item.type === 'tool_result'
+
+interface HookOutputLike {
+  continue?: boolean
+  stopReason?: string
+}
+
+export interface AdapterHookBridge {
+  start: () => Promise<void>
+  prepareInitialPrompt: (prompt?: string) => Promise<string | undefined>
+  wrapSession: (session: AdapterSession) => AdapterSession
+  handleOutput: (event: AdapterOutputEvent) => void
+}
+
+export 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 => {
+  const {
+    ctx,
+    adapter,
+    runtime,
+    sessionId,
+    type,
+    model,
+    disabledEvents: rawDisabledEvents = []
+  } = params
+  const disabledEvents = new Set(rawDisabledEvents)
+
+  const pendingToolCalls = new Map<string, { toolName: string; toolInput?: unknown }>()
+  let emitQueue = Promise.resolve()
+  let killRequested = false
+  let lastAssistantMessage: string | undefined
+  let sessionEnded = false
+
+  const callBridgeHook = async (
+    eventName: Parameters<typeof callHook>[0],
+    input: Record<string, unknown>,
+    options: {
+      canBlock: boolean
+      enforce?: boolean
+      blockedMessage: string
+    }
+  ): Promise<HookOutputLike | undefined> => {
+    if (disabledEvents.has(eventName as keyof HookInputs)) {
+      return undefined
+    }
+
+    try {
+      const output = await callHook(
+        eventName as never,
+        {
+          cwd: ctx.cwd,
+          sessionId,
+          adapter,
+          runtime,
+          hookSource: 'bridge',
+          canBlock: options.canBlock,
+          ...input
+        } as never,
+        ctx.env
+      ) as HookOutputLike
+
+      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: ChatMessage) => {
+    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/src/hooks/index.ts

@@ -34,6 +34,8 @@ export type PluginConfig =
   | Partial<PluginMap>
 
 export * from './call'
+export * from './bridge'
 export * from './loader'
+export * from './native'
 export * from './runtime'
 export * from './type'

package/src/hooks/loader.ts

@@ -34,7 +34,10 @@ const loadPlugin = async (
   }
 }
 
-export const resolvePlugins = async (config: PluginConfig): Promise<Partial<Plugin>[]> => {
+export const resolvePlugins = async (
+  config: PluginConfig,
+  enabledPlugins: Record<string, boolean> = {}
+): Promise<Partial<Plugin>[]> => {
   // 1. 处理数组形式配置 (直接实例化或函数调用)
   if (Array.isArray(config)) {
     return config.map((p) => (typeof p === 'function' ? p() : p))
@@ -42,6 +45,7 @@ export const resolvePlugins = async (config: PluginConfig): Promise<Partial<Plug
 
   // 2. 处理对象形式配置 (动态加载)
   const entries = Object.entries(config)
+    .filter(([pkgName]) => enabledPlugins[pkgName] !== false)
   if (entries.length === 0) return []
 
   // 并行加载所有插件

package/src/hooks/native.ts

@@ -0,0 +1,116 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { dirname, resolve } from 'node:path'
+import process from 'node:process'
+
+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>
+}
+
+const isPlainObject = (value: unknown): value is Record<string, unknown> => (
+  value != null && typeof value === 'object' && !Array.isArray(value)
+)
+
+export const hasManagedHookPlugins = (
+  ctx: Pick<AdapterCtx, 'assets'>
+) => (ctx.assets?.hookPlugins.length ?? 0) > 0
+
+export const resolveMockHome = (
+  cwd: string,
+  env: Pick<AdapterCtx, 'env'>['env']
+) => {
+  const explicitHome = env.HOME?.trim() || process.env.HOME?.trim()
+  return explicitHome ? resolve(explicitHome) : resolve(cwd, '.ai', '.mock')
+}
+
+export const resolveHookCliPackageDir = () => {
+  try {
+    const pkgJsonPath = require.resolve('@vibe-forge/cli/package.json')
+    return dirname(pkgJsonPath)
+  } catch (error) {
+    throw new Error('Failed to resolve @vibe-forge/cli for native hooks', { cause: error })
+  }
+}
+
+export const resolveHookCliScriptPath = (fileName: string) => (
+  resolve(resolveHookCliPackageDir(), fileName)
+)
+
+export const shellQuote = (value: string) => JSON.stringify(value)
+
+export const buildNodeScriptCommand = (params: {
+  nodePath: string
+  scriptPath: string
+}) => `${shellQuote(params.nodePath)} ${shellQuote(params.scriptPath)}`
+
+export const prepareManagedHookRuntime = (
+  ctx: Pick<AdapterCtx, 'cwd' | 'env'>
+) => {
+  const mockHome = resolveMockHome(ctx.cwd, ctx.env)
+  const cliPackageDir = resolveHookCliPackageDir()
+  const nodePath = process.execPath
+
+  ctx.env.__VF_PROJECT_CLI_PACKAGE_DIR__ = cliPackageDir
+  ctx.env.__VF_PROJECT_WORKSPACE_FOLDER__ = ctx.env.__VF_PROJECT_WORKSPACE_FOLDER__ ?? ctx.cwd
+  ctx.env.__VF_PROJECT_NODE_PATH__ = nodePath
+
+  return {
+    mockHome,
+    cliPackageDir,
+    nodePath
+  }
+}
+
+export const readJsonFileOrDefault = async <T>(filePath: string, fallback: T): Promise<T> => {
+  try {
+    return JSON.parse(await readFile(filePath, 'utf8')) as T
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException)?.code === 'ENOENT') return fallback
+    throw error
+  }
+}
+
+export const writeJsonFile = async (filePath: string, value: unknown) => {
+  await mkdir(dirname(filePath), { recursive: true })
+  await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8')
+}
+
+export const mergeManagedHookGroups = (params: {
+  existing: unknown
+  eventNames: readonly string[]
+  enabled: boolean
+  isManagedGroup: (group: NativeHookMatcherGroup) => boolean
+  createGroup: (eventName: string) => NativeHookMatcherGroup
+  shouldManageEvent?: (eventName: string) => boolean
+}): NativeHooksConfigFile => {
+  const parsed = isPlainObject(params.existing) ? params.existing as NativeHooksConfigFile : {}
+  const hooks = isPlainObject(parsed.hooks) ? parsed.hooks : {}
+  const nextHooks: Record<string, unknown> = { ...hooks }
+
+  for (const eventName of params.eventNames) {
+    const groups = Array.isArray(hooks[eventName])
+      ? (hooks[eventName] as NativeHookMatcherGroup[]).filter(group => !params.isManagedGroup(group))
+      : []
+    nextHooks[eventName] = params.enabled && (params.shouldManageEvent?.(eventName) ?? true)
+      ? [...groups, params.createGroup(eventName)]
+      : groups
+  }
+
+  return {
+    ...parsed,
+    hooks: nextHooks
+  }
+}

package/src/hooks/runtime.ts

@@ -99,8 +99,8 @@ export const executeHookInput = async (
   }
   const [config, userConfig] = await loadConfig({ jsonVariables })
   const plugins = [
-    ...await resolvePlugins(config?.plugins ?? []),
-    ...await resolvePlugins(userConfig?.plugins ?? [])
+    ...await resolvePlugins(config?.plugins ?? [], config?.enabledPlugins ?? {}),
+    ...await resolvePlugins(userConfig?.plugins ?? [], userConfig?.enabledPlugins ?? {})
   ]
 
   return callPluginHook(

package/src/hooks/type.ts

@@ -1,4 +1,17 @@
-import type { ToolInput, ToolOutput } from '../tools'
+import type { AdapterQueryOptions } from '../adapter'
+
+export type HookSource = 'native' | 'bridge'
+
+export interface HookToolCall {
+  toolCallId?: string
+  toolName: string
+  toolInput?: unknown
+}
+
+export interface HookToolResult extends HookToolCall {
+  toolResponse?: unknown
+  isError?: boolean
+}
 
 /**
  * https://docs.anthropic.com/en/docs/claude-code/hooks#hook-input
@@ -7,25 +20,37 @@ export interface HookInputCore {
   cwd: string
   sessionId: string
   hookEventName: keyof HookInputs
+  adapter?: string
+  runtime?: AdapterQueryOptions['runtime']
+  hookSource?: HookSource
+  canBlock?: boolean
 }
 
 export interface HookInputs {
   /**
    * https://docs.anthropic.com/en/docs/claude-code/hooks#pretooluse-input
    */
-  PreToolUse: HookInputCore & ToolInput
+  PreToolUse: HookInputCore & HookToolCall
   /**
    * https://docs.anthropic.com/en/docs/claude-code/hooks#posttooluse-input
    */
-  PostToolUse: HookInputCore & ToolOutput
+  PostToolUse: HookInputCore & HookToolResult
   Notification: HookInputCore
   UserPromptSubmit: HookInputCore & { prompt: string }
-  Stop: HookInputCore
+  Stop: HookInputCore & {
+    lastAssistantMessage?: string
+  }
   SubagentStop: HookInputCore
   PreCompact: HookInputCore
-  SessionStart: HookInputCore
+  SessionStart: HookInputCore & {
+    source?: 'startup' | 'resume'
+    model?: string
+  }
   SessionEnd: HookInputCore & {
     reason: string
+    exitCode?: number
+    stderr?: string
+    lastAssistantMessage?: string
   }
 
   StartTasks: HookInputCore & {