@namzu/sdk 14.0.7 → 15.0.0

package/src/plugin/__tests__/discovery-scopes.test.ts

@@ -1,133 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-
-import { PluginRuntimeConfigSchema } from '../../config/runtime.js'
-import {
-	PLUGIN_MANIFEST_FILENAME,
-	PROJECT_PLUGIN_DIR,
-	USER_PLUGIN_DIR,
-} from '../../constants/plugin/index.js'
-
-/**
- * `allowedScopes` read exactly like a trust boundary and enforced nothing.
- *
- * A plugin is arbitrary code with hooks into tool execution, and the two
- * scopes are not equally trusted: a project plugin is reviewable in the repo
- * the agent works on, a user plugin comes from a home directory the repo's
- * reviewers never see. `PluginRuntimeConfig` carried `enabled`,
- * `autoDiscovery` and `allowedScopes`; nothing anywhere consulted any of the
- * three, and discovery scanned both locations unconditionally.
- */
-
-let home: string
-let workdir: string
-
-vi.mock('node:os', async () => {
-	const actual = await vi.importActual<typeof import('node:os')>('node:os')
-	return { ...actual, homedir: () => home }
-})
-
-async function plantPlugin(dir: string, name: string): Promise<void> {
-	const pluginDir = join(dir, name)
-	await mkdir(pluginDir, { recursive: true })
-	await writeFile(
-		join(pluginDir, PLUGIN_MANIFEST_FILENAME),
-		JSON.stringify({ name, version: '1.0.0' }),
-		'utf-8',
-	)
-}
-
-beforeEach(async () => {
-	home = await mkdtemp(join(tmpdir(), 'namzu-home-'))
-	workdir = await mkdtemp(join(tmpdir(), 'namzu-work-'))
-	await plantPlugin(join(workdir, PROJECT_PLUGIN_DIR), 'project-plugin')
-	await plantPlugin(join(home, USER_PLUGIN_DIR), 'user-plugin')
-})
-
-afterEach(async () => {
-	await Promise.all([
-		rm(home, { recursive: true, force: true }),
-		rm(workdir, { recursive: true, force: true }),
-	])
-})
-
-async function discover(
-	options?: Parameters<typeof import('../loader.js').discoverAllPluginDirs>[1],
-) {
-	const { discoverAllPluginDirs } = await import('../loader.js')
-	return discoverAllPluginDirs(workdir, options)
-}
-
-describe('a scope the host did not allow is not scanned', () => {
-	it('finds both when nothing is said', async () => {
-		const found = await discover()
-
-		expect(found.project).toHaveLength(1)
-		expect(found.user).toHaveLength(1)
-	})
-
-	it('keeps user plugins out when only project is allowed', async () => {
-		const found = await discover({ allowedScopes: ['project'] })
-
-		expect(found.project).toHaveLength(1)
-		// The setting that reads like a boundary now is one.
-		expect(found.user).toEqual([])
-	})
-
-	it('keeps project plugins out when only user is allowed', async () => {
-		const found = await discover({ allowedScopes: ['user'] })
-
-		expect(found.project).toEqual([])
-		expect(found.user).toHaveLength(1)
-	})
-
-	it('finds nothing when neither scope is allowed', async () => {
-		const found = await discover({ allowedScopes: [] })
-
-		expect(found).toEqual({ project: [], user: [] })
-	})
-})
-
-describe('the runtime switches turn discovery off', () => {
-	it('discovers nothing when the plugin runtime is disabled', async () => {
-		const found = await discover({ enabled: false })
-
-		expect(found).toEqual({ project: [], user: [] })
-	})
-
-	it('discovers nothing when auto-discovery is off', async () => {
-		const found = await discover({ autoDiscovery: false })
-
-		expect(found).toEqual({ project: [], user: [] })
-	})
-
-	it('a default-parsed config discovers nothing, because the runtime ships off', async () => {
-		// `enabled` defaults to false in the schema. A host who parses the
-		// config and passes it gets the documented default rather than a
-		// silently-on plugin runtime.
-		const found = await discover(PluginRuntimeConfigSchema.parse({}))
-
-		expect(found).toEqual({ project: [], user: [] })
-	})
-
-	it('an enabled default-parsed config finds both scopes', async () => {
-		const found = await discover(PluginRuntimeConfigSchema.parse({ enabled: true }))
-
-		expect(found.project).toHaveLength(1)
-		expect(found.user).toHaveLength(1)
-	})
-
-	it('a parsed config carries its scope restriction through', async () => {
-		const config = PluginRuntimeConfigSchema.parse({
-			enabled: true,
-			allowedScopes: ['project'],
-		})
-
-		const found = await discover(config)
-
-		expect(found.project).toHaveLength(1)
-		expect(found.user).toEqual([])
-	})
-})

package/src/plugin/__tests__/enable-contributions.test.ts

@@ -1,299 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import type { PluginRegistry } from '../../registry/plugin/index.js'
-import type { PluginId } from '../../types/ids/index.js'
-import type { PluginDefinition } from '../../types/plugin/index.js'
-import type { ToolDefinition, ToolRegistryContract } from '../../types/tool/index.js'
-import type { Logger } from '../../utils/logger.js'
-import { PluginLifecycleManager } from '../lifecycle.js'
-
-const mockConnect = vi.fn(async (): Promise<unknown> => undefined)
-const mockDisconnect = vi.fn(async (): Promise<void> => undefined)
-const mockListTools = vi.fn(async (): Promise<unknown[]> => [])
-
-vi.mock('../../connector/mcp/client.js', () => ({
-	MCPClient: vi.fn().mockImplementation((config: { serverName: string }) => ({
-		id: 'mcp-client-mock',
-		connect: mockConnect,
-		disconnect: mockDisconnect,
-		listTools: mockListTools,
-		// The real client has always had this; the mock did not, which went
-		// unnoticed while nothing on this path asked the client which server
-		// it was talking to. Admission does — a policy is per server name.
-		getState: () => ({ serverName: config.serverName }),
-	})),
-}))
-
-vi.mock('../../connector/mcp/adapter.js', () => ({
-	mcpToolToToolDefinition: vi.fn((mcpTool: { name: string }) => ({
-		name: mcpTool.name,
-		description: `mcp tool ${mcpTool.name}`,
-		inputSchema: { parse: vi.fn() } as any,
-		async execute() {
-			return { success: true, output: 'ok' }
-		},
-	})),
-}))
-
-function makeLogger(): Logger {
-	const s = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() }
-	return { ...s, child: vi.fn(() => ({ ...s, child: vi.fn() })) } as unknown as Logger
-}
-
-function makePluginRegistry(base: Partial<PluginDefinition>): {
-	registry: PluginRegistry
-	state: { current: PluginDefinition }
-} {
-	const state = {
-		current: {
-			id: 'plugin_test' as PluginId,
-			manifest: base.manifest ?? {
-				name: 'test-plugin',
-				version: '0.0.1',
-				description: 'test',
-			},
-			scope: 'project',
-			status: 'installed',
-			rootDir: '/tmp/plugin',
-			installedAt: 0,
-			...base,
-		} as PluginDefinition,
-	}
-	const registry = {
-		register: vi.fn((def: PluginDefinition) => {
-			state.current = def
-		}),
-		unregister: vi.fn(),
-		getOrThrow: vi.fn(() => state.current),
-		findByName: vi.fn(),
-		getAll: vi.fn(() => [state.current]),
-	} as unknown as PluginRegistry
-	return { registry, state }
-}
-
-function makeToolRegistry(): ToolRegistryContract {
-	const names: string[] = []
-	return {
-		register: vi.fn((tool: ToolDefinition) => {
-			names.push(tool.name)
-		}),
-		unregister: vi.fn((name: string) => {
-			const i = names.indexOf(name)
-			if (i >= 0) names.splice(i, 1)
-		}),
-		listNames: vi.fn(() => [...names]),
-		has: vi.fn((name: string) => names.includes(name)),
-		get: vi.fn(),
-		execute: vi.fn(),
-		getAvailability: vi.fn(),
-	} as unknown as ToolRegistryContract
-}
-
-describe('PluginLifecycleManager enable() contribution types', () => {
-	const pluginId = 'plugin_test' as PluginId
-
-	beforeEach(() => {
-		mockConnect.mockReset()
-		mockDisconnect.mockReset()
-		mockListTools.mockReset()
-	})
-
-	describe('unsupported contribution types', () => {
-		it('throws when manifest declares skills', async () => {
-			const { registry } = makePluginRegistry({
-				manifest: {
-					name: 'p',
-					version: '0.0.1',
-					description: 't',
-					skills: ['./s'],
-				},
-			})
-			const mgr = new PluginLifecycleManager({
-				pluginRegistry: registry,
-				toolRegistry: makeToolRegistry(),
-				log: makeLogger(),
-			})
-			await expect(mgr.enable(pluginId)).rejects.toThrow(/\[skills\]/)
-		})
-
-		it('throws when manifest declares connectors', async () => {
-			const { registry } = makePluginRegistry({
-				manifest: {
-					name: 'p',
-					version: '0.0.1',
-					description: 't',
-					connectors: ['./c'],
-				},
-			})
-			const mgr = new PluginLifecycleManager({
-				pluginRegistry: registry,
-				toolRegistry: makeToolRegistry(),
-				log: makeLogger(),
-			})
-			await expect(mgr.enable(pluginId)).rejects.toThrow(/\[connectors\]/)
-		})
-
-		it('throws when manifest declares personas', async () => {
-			const { registry } = makePluginRegistry({
-				manifest: {
-					name: 'p',
-					version: '0.0.1',
-					description: 't',
-					personas: ['./pp'],
-				},
-			})
-			const mgr = new PluginLifecycleManager({
-				pluginRegistry: registry,
-				toolRegistry: makeToolRegistry(),
-				log: makeLogger(),
-			})
-			await expect(mgr.enable(pluginId)).rejects.toThrow(/\[personas\]/)
-		})
-
-		it('lists all unsupported types together when multiple declared', async () => {
-			const { registry } = makePluginRegistry({
-				manifest: {
-					name: 'p',
-					version: '0.0.1',
-					description: 't',
-					skills: ['./s'],
-					connectors: ['./c'],
-					personas: ['./pp'],
-				},
-			})
-			const mgr = new PluginLifecycleManager({
-				pluginRegistry: registry,
-				toolRegistry: makeToolRegistry(),
-				log: makeLogger(),
-			})
-			await expect(mgr.enable(pluginId)).rejects.toThrow(/skills, connectors, personas/)
-		})
-	})
-
-	describe('mcpServers wiring', () => {
-		it('registers namespaced tools for each MCP server tool', async () => {
-			mockConnect.mockResolvedValue(undefined)
-			mockListTools.mockResolvedValue([
-				{ name: 'read_file', inputSchema: { type: 'object' } },
-				{ name: 'write_file', inputSchema: { type: 'object' } },
-			])
-			const { registry } = makePluginRegistry({
-				manifest: {
-					name: 'fs-plugin',
-					version: '0.0.1',
-					description: 't',
-					mcpServers: [{ name: 'fs', command: '/bin/true' }],
-				},
-			})
-			const toolRegistry = makeToolRegistry()
-			const mgr = new PluginLifecycleManager({
-				pluginRegistry: registry,
-				toolRegistry,
-				log: makeLogger(),
-			})
-
-			await mgr.enable(pluginId)
-
-			expect(mockConnect).toHaveBeenCalledOnce()
-			expect(mockListTools).toHaveBeenCalledOnce()
-			expect(toolRegistry.listNames()).toEqual([
-				'fs-plugin__mcp__fs__read_file',
-				'fs-plugin__mcp__fs__write_file',
-			])
-		})
-
-		it('disconnects MCP clients and unregisters tools on disable', async () => {
-			mockConnect.mockResolvedValue(undefined)
-			mockDisconnect.mockResolvedValue(undefined)
-			mockListTools.mockResolvedValue([{ name: 'ping', inputSchema: { type: 'object' } }])
-			const { registry } = makePluginRegistry({
-				manifest: {
-					name: 'net',
-					version: '0.0.1',
-					description: 't',
-					mcpServers: [{ name: 'srv', command: '/bin/true' }],
-				},
-			})
-			const toolRegistry = makeToolRegistry()
-			const mgr = new PluginLifecycleManager({
-				pluginRegistry: registry,
-				toolRegistry,
-				log: makeLogger(),
-			})
-
-			await mgr.enable(pluginId)
-			expect(toolRegistry.listNames()).toContain('net__mcp__srv__ping')
-
-			await mgr.disable(pluginId)
-			expect(mockDisconnect).toHaveBeenCalledOnce()
-			expect(toolRegistry.listNames()).toEqual([])
-		})
-
-		it('disconnects MCP clients before unregistering tools on disable', async () => {
-			mockConnect.mockResolvedValue(undefined)
-			mockDisconnect.mockResolvedValue(undefined)
-			mockListTools.mockResolvedValue([{ name: 'ping', inputSchema: { type: 'object' } }])
-			const { registry } = makePluginRegistry({
-				manifest: {
-					name: 'net',
-					version: '0.0.1',
-					description: 't',
-					mcpServers: [{ name: 'srv', command: '/bin/true' }],
-				},
-			})
-			const events: string[] = []
-			const toolRegistry = {
-				register: vi.fn(),
-				unregister: vi.fn(() => events.push('unregister')),
-				listNames: vi.fn(() => []),
-				has: vi.fn(),
-				get: vi.fn(),
-				execute: vi.fn(),
-				getAvailability: vi.fn(),
-			} as unknown as ToolRegistryContract
-			mockDisconnect.mockImplementation(async () => {
-				events.push('disconnect')
-			})
-			const mgr = new PluginLifecycleManager({
-				pluginRegistry: registry,
-				toolRegistry,
-				log: makeLogger(),
-			})
-
-			await mgr.enable(pluginId)
-			await mgr.disable(pluginId)
-
-			expect(events).toEqual(['disconnect', 'unregister'])
-		})
-
-		it('rolls back tools and MCP clients when connect fails mid-enable', async () => {
-			mockConnect
-				.mockResolvedValueOnce(undefined) // first server connects
-				.mockRejectedValueOnce(new Error('connect refused')) // second fails
-			mockDisconnect.mockResolvedValue(undefined)
-			mockListTools.mockResolvedValue([{ name: 't', inputSchema: { type: 'object' } }])
-			const { registry } = makePluginRegistry({
-				manifest: {
-					name: 'multi',
-					version: '0.0.1',
-					description: 't',
-					mcpServers: [
-						{ name: 'a', command: '/bin/true' },
-						{ name: 'b', command: '/bin/false' },
-					],
-				},
-			})
-			const toolRegistry = makeToolRegistry()
-			const mgr = new PluginLifecycleManager({
-				pluginRegistry: registry,
-				toolRegistry,
-				log: makeLogger(),
-			})
-
-			await expect(mgr.enable(pluginId)).rejects.toThrow(/connect refused/)
-
-			// Rollback: first server's tools unregistered, first client disconnected.
-			expect(toolRegistry.listNames()).toEqual([])
-			expect(mockDisconnect).toHaveBeenCalledOnce()
-		})
-	})
-})

package/src/plugin/__tests__/hook-ordering.test.ts

@@ -1,252 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-
-import type { PluginId, RunId } from '../../types/ids/index.js'
-import type { PluginHookResult } from '../../types/plugin/index.js'
-import { PluginLifecycleManager } from '../lifecycle.js'
-
-/**
- * Hook order was install order — neither declared nor stable, since it
- * depends on when each plugin happened to be installed. That is fine for a
- * hook that only observes and wrong for one that decides: `executeHooks`
- * SHORT-CIRCUITS on `skip` and `error`, so a hook that denies a dangerous
- * command only gets to deny it if it runs before whatever else stops the
- * chain. A guard whose firing depends on installation history is not a
- * guard.
- */
-
-const RUN_ID = 'run_x' as RunId
-
-function makeLogger(): never {
-	const logger = {
-		info: vi.fn(),
-		warn: vi.fn(),
-		error: vi.fn(),
-		debug: vi.fn(),
-		child: () => logger,
-	}
-	return logger as never
-}
-
-function makeManager(hookTimeoutMs?: number) {
-	return new PluginLifecycleManager({
-		pluginRegistry: {} as never,
-		toolRegistry: {} as never,
-		log: makeLogger(),
-		...(hookTimeoutMs !== undefined ? { hookTimeoutMs } : {}),
-	})
-}
-
-const record = (order: string[], name: string, result?: PluginHookResult) => async () => {
-	order.push(name)
-	return result ?? ({ action: 'continue' } as PluginHookResult)
-}
-
-describe('priority', () => {
-	it('runs a lower priority first, whatever order it was registered in', async () => {
-		const order: string[] = []
-		const manager = makeManager()
-		manager.registerHook('p_late' as PluginId, {
-			event: 'pre_tool_use',
-			priority: 900,
-			handler: record(order, 'observer'),
-		})
-		manager.registerHook('p_guard' as PluginId, {
-			event: 'pre_tool_use',
-			priority: 10,
-			handler: record(order, 'guard'),
-		})
-
-		await manager.executeHooks('pre_tool_use', { runId: RUN_ID })
-		expect(order).toEqual(['guard', 'observer'])
-	})
-
-	it('lets a guard deny before anything downstream can stop the chain', async () => {
-		const order: string[] = []
-		const manager = makeManager()
-		// Registered first, so under install order it would have run first
-		// and short-circuited before the guard ever saw the call.
-		manager.registerHook('p_other' as PluginId, {
-			event: 'pre_tool_use',
-			handler: record(order, 'other', { action: 'skip', reason: 'unrelated' }),
-		})
-		manager.registerHook('p_guard' as PluginId, {
-			event: 'pre_tool_use',
-			priority: 1,
-			handler: record(order, 'guard', { action: 'error', message: 'denied' }),
-		})
-
-		const results = await manager.executeHooks('pre_tool_use', { runId: RUN_ID })
-		expect(order).toEqual(['guard'])
-		expect(results).toEqual([{ action: 'error', message: 'denied' }])
-	})
-
-	it('keeps registration order for equal priorities', async () => {
-		const order: string[] = []
-		const manager = makeManager()
-		for (const name of ['a', 'b', 'c']) {
-			manager.registerHook(`p_${name}` as PluginId, {
-				event: 'iteration_start',
-				handler: record(order, name),
-			})
-		}
-
-		// A plugin that never sets a priority behaves exactly as before.
-		await manager.executeHooks('iteration_start', { runId: RUN_ID })
-		expect(order).toEqual(['a', 'b', 'c'])
-	})
-
-	it('unwinds a post hook in the opposite order, so a guard closes last', async () => {
-		const order: string[] = []
-		const manager = makeManager()
-		// Registered observer-first on purpose: under plain registration
-		// order the reversal alone would already produce the expected
-		// result, and the assertion would hold with no sorting at all.
-		manager.registerHook('p_observer' as PluginId, {
-			event: 'post_tool_use',
-			priority: 900,
-			handler: record(order, 'observer'),
-		})
-		manager.registerHook('p_guard' as PluginId, {
-			event: 'post_tool_use',
-			priority: 1,
-			handler: record(order, 'guard'),
-		})
-
-		// Post hooks unwind, so whichever opened first closes last — the
-		// wrapping order a guard needs.
-		await manager.executeHooks('post_tool_use', { runId: RUN_ID })
-		expect(order).toEqual(['observer', 'guard'])
-	})
-
-	it('composes modify in priority order', async () => {
-		const seen: unknown[] = []
-		const manager = makeManager()
-		manager.registerHook('p_second' as PluginId, {
-			event: 'pre_tool_use',
-			priority: 200,
-			handler: async (ctx) => {
-				seen.push(ctx.toolInput)
-				return { action: 'modify', input: { ...(ctx.toolInput as object), second: true } }
-			},
-		})
-		manager.registerHook('p_first' as PluginId, {
-			event: 'pre_tool_use',
-			priority: 100,
-			handler: async (ctx) => {
-				seen.push(ctx.toolInput)
-				return { action: 'modify', input: { ...(ctx.toolInput as object), first: true } }
-			},
-		})
-
-		const results = await manager.executeHooks('pre_tool_use', {
-			runId: RUN_ID,
-			toolInput: { base: true },
-		})
-
-		// What each hook SAW, not just the merged result: the merged object
-		// is identical either way round, so asserting on it alone would hold
-		// with no ordering at all.
-		expect(seen).toEqual([{ base: true }, { base: true, first: true }])
-		expect(results.at(-1)).toEqual({
-			action: 'modify',
-			input: { base: true, first: true, second: true },
-		})
-	})
-})
-
-describe('the deadline timer', () => {
-	it('does not keep a timer armed after the hook resolves', async () => {
-		const manager = makeManager(60_000)
-		manager.registerHook('p' as PluginId, {
-			event: 'run_start',
-			handler: async () => ({ action: 'continue' }),
-		})
-
-		vi.useFakeTimers()
-		try {
-			await manager.executeHooks('run_start', { runId: RUN_ID })
-			// An armed timer keeps the Node event loop alive. Hooks fire on
-			// every tool call and every model call, so a leak here meant a
-			// short run could not exit until the last deadline expired.
-			expect(vi.getTimerCount()).toBe(0)
-		} finally {
-			vi.useRealTimers()
-		}
-	})
-
-	it('clears the timer even when the hook throws', async () => {
-		const manager = makeManager(60_000)
-		manager.registerHook('p' as PluginId, {
-			event: 'run_start',
-			handler: async () => {
-				throw new Error('boom')
-			},
-		})
-
-		vi.useFakeTimers()
-		try {
-			const results = await manager.executeHooks('run_start', { runId: RUN_ID })
-			expect(results[0]?.action).toBe('error')
-			expect(vi.getTimerCount()).toBe(0)
-		} finally {
-			vi.useRealTimers()
-		}
-	})
-
-	it('leaves nothing armed across a chain of hooks', async () => {
-		const manager = makeManager(60_000)
-		for (let i = 0; i < 5; i++) {
-			manager.registerHook(`p${i}` as PluginId, {
-				event: 'iteration_start',
-				handler: async () => ({ action: 'continue' }),
-			})
-		}
-
-		vi.useFakeTimers()
-		try {
-			await manager.executeHooks('iteration_start', { runId: RUN_ID })
-			expect(vi.getTimerCount()).toBe(0)
-		} finally {
-			vi.useRealTimers()
-		}
-	})
-
-	it('tells a slow hook it was abandoned instead of only walking away', async () => {
-		const manager = makeManager(5)
-		let aborted = false
-		manager.registerHook('p' as PluginId, {
-			event: 'run_start',
-			handler: async (ctx) => {
-				ctx.signal?.addEventListener('abort', () => {
-					aborted = true
-				})
-				await new Promise((resolve) => setTimeout(resolve, 100))
-				return { action: 'continue' }
-			},
-		})
-
-		const results = await manager.executeHooks('run_start', { runId: RUN_ID })
-		expect(results[0]).toEqual({ action: 'error', message: 'Hook timeout' })
-		// Without this the hook never learns it was dropped, and an HTTP
-		// request inside it keeps a socket open for a run that moved on.
-		expect(aborted).toBe(true)
-	})
-
-	it('does not abort a hook that finished in time', async () => {
-		const manager = makeManager(10_000)
-		let aborted = false
-		manager.registerHook('p' as PluginId, {
-			event: 'run_start',
-			handler: async (ctx) => {
-				ctx.signal?.addEventListener('abort', () => {
-					aborted = true
-				})
-				return { action: 'continue' }
-			},
-		})
-
-		await manager.executeHooks('run_start', { runId: RUN_ID })
-		await new Promise((resolve) => setTimeout(resolve, 20))
-		expect(aborted).toBe(false)
-	})
-})