| |
| import fs from "node:fs/promises"; |
| import path from "node:path"; |
| import { afterEach, beforeEach, describe, expect, it } from "vitest"; |
| import { installPluginWithHookFallback } from "../cli/plugins-install-hook-fallback.js"; |
| import { readConfigFileSnapshot } from "../config/config.js"; |
| import { loadConfigForInstall } from "../plugins/install-config.js"; |
| import { |
| createOpenClawTestState, |
| type OpenClawTestState, |
| } from "../test-utils/openclaw-test-state.js"; |
| import { pinConfigDir } from "../utils.js"; |
| import { readHookInstalls } from "./installs.js"; |
| import { |
| clearInternalHooks, |
| createInternalHookEvent, |
| setInternalHooksEnabled, |
| triggerInternalHook, |
| } from "./internal-hooks.js"; |
| import { prepareInternalHooks } from "./loader.js"; |
| import { loadWorkspaceHookEntries } from "./workspace.js"; |
|
|
| async function writeHook(hookDir: string, name: string): Promise<void> { |
| await fs.mkdir(hookDir, { recursive: true }); |
| await fs.writeFile( |
| path.join(hookDir, "HOOK.md"), |
| [ |
| "---", |
| `name: ${name}`, |
| 'description: "Test hook"', |
| 'metadata: {"openclaw":{"events":["command:new"]}}', |
| "---", |
| "", |
| ].join("\n"), |
| "utf-8", |
| ); |
| await fs.writeFile( |
| path.join(hookDir, "handler.js"), |
| `export default async function(event) { event.messages.push(${JSON.stringify(name)}); }\n`, |
| "utf-8", |
| ); |
| } |
|
|
| describe.each([ |
| { mode: "copied", link: false }, |
| { mode: "linked", link: true }, |
| ])("hooks install ($mode)", ({ link }) => { |
| let state: OpenClawTestState; |
|
|
| beforeEach(async () => { |
| state = await createOpenClawTestState({ label: "hooks-install", layout: "split" }); |
| pinConfigDir(); |
| clearInternalHooks(); |
| await state.writeConfig({ |
| agents: { defaults: { workspace: state.workspaceDir } }, |
| plugins: { enabled: false }, |
| }); |
| }); |
|
|
| afterEach(async () => { |
| try { |
| const disabled = await prepareInternalHooks( |
| { hooks: { internal: { enabled: false } } }, |
| state.workspaceDir, |
| ); |
| disabled.commit(); |
| clearInternalHooks(); |
| setInternalHooksEnabled(true); |
| } finally { |
| await state.cleanup(); |
| pinConfigDir(); |
| } |
| }); |
|
|
| it.each([ |
| { layout: "single hook", hookPath: ".", hookPackId: "hello-hook" }, |
| { layout: "conventional pack", hookPath: "./hooks/hello-hook", hookPackId: "hello-hooks" }, |
| { layout: "direct-child pack", hookPath: "./hello-hook", hookPackId: "hello-hooks" }, |
| ])( |
| "discovers and triggers only installed hooks from a $layout", |
| async ({ hookPath, hookPackId }) => { |
| const sourceDir = state.path("sources", "hook-pack"); |
| await writeHook(path.resolve(sourceDir, hookPath), "hello-hook"); |
| await writeHook(state.path("sources", "adjacent-hook"), "adjacent-hook"); |
| if (hookPath !== ".") { |
| await fs.writeFile( |
| path.join(sourceDir, "package.json"), |
| JSON.stringify({ |
| name: "@acme/hello-hooks", |
| version: "0.0.0", |
| openclaw: { hooks: [hookPath] }, |
| }), |
| "utf-8", |
| ); |
| |
| await writeHook(path.join(sourceDir, "unlisted-root"), "unlisted-root"); |
| await writeHook(path.join(sourceDir, "hooks", "unlisted-nested"), "unlisted-nested"); |
| } |
|
|
| const snapshot = await loadConfigForInstall({ |
| rawSpec: sourceDir, |
| }); |
| const installResult = await installPluginWithHookFallback({ |
| request: { source: "local", path: sourceDir, mode: "install", link }, |
| snapshot, |
| safetyOverrides: { config: snapshot.config }, |
| }); |
| expect(installResult).toEqual({ ok: true }); |
|
|
| const installed = await readConfigFileSnapshot(); |
| expect(installed.valid).toBe(true); |
| expect(installed.config.hooks?.internal).toMatchObject({ |
| enabled: true, |
| entries: { "hello-hook": { enabled: true } }, |
| }); |
| expect(installed.config.hooks?.internal?.load?.extraDirs ?? []).toEqual( |
| link ? [sourceDir] : [], |
| ); |
| const installPath = link ? sourceDir : state.statePath("hooks", hookPackId); |
| expect(readHookInstalls()).toEqual({ |
| [hookPackId]: expect.objectContaining({ |
| source: "path", |
| sourcePath: sourceDir, |
| installPath, |
| hooks: ["hello-hook"], |
| }), |
| }); |
| await expect( |
| fs.readFile(path.resolve(installPath, hookPath, "handler.js"), "utf-8"), |
| ).resolves.toContain("hello-hook"); |
|
|
| const options = { bundledHooksDir: state.path("bundled-none") }; |
| const discovered = loadWorkspaceHookEntries(state.workspaceDir, { |
| ...options, |
| config: installed.config, |
| }); |
| const prepared = await prepareInternalHooks(installed.config, state.workspaceDir, options); |
| prepared.commit(); |
| const event = createInternalHookEvent("command", "new", "test-session"); |
| await triggerInternalHook(event); |
| expect({ |
| discovered: discovered.map((entry) => entry.hook.name).toSorted(), |
| loaded: prepared.loadedCount, |
| messages: event.messages.toSorted(), |
| }).toEqual({ |
| discovered: ["hello-hook"], |
| loaded: 1, |
| messages: ["hello-hook"], |
| }); |
| }, |
| ); |
| }); |
|
|
