@namzu/sdk 14.0.6 → 15.0.0

package/src/connector/mcp/streamable-http.test.ts

@@ -1,169 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest'
-
-import type { MCPJsonRpcMessage } from '../../types/connector/index.js'
-import { MCPClient } from './client.js'
-
-afterEach(() => {
-	vi.unstubAllGlobals()
-})
-
-describe('Streamable HTTP MCP transport', () => {
-	it('connects through MCPClient, preserves session headers, and parses SSE responses', async () => {
-		const fetchMock = vi.fn<typeof fetch>()
-		fetchMock
-			.mockResolvedValueOnce(
-				jsonResponse(
-					{
-						jsonrpc: '2.0',
-						id: 1,
-						result: {
-							protocolVersion: '2024-11-05',
-							capabilities: { tools: { listChanged: true } },
-							serverInfo: { name: 'github' },
-						},
-					},
-					{ 'mcp-session-id': 'sid_123' },
-				),
-			)
-			.mockResolvedValueOnce(new Response('', { status: 202 }))
-			.mockResolvedValueOnce(
-				sseResponse([
-					{ jsonrpc: '2.0', method: 'notifications/progress', params: { pct: 50 } },
-					{
-						jsonrpc: '2.0',
-						id: 2,
-						result: {
-							tools: [
-								{
-									name: 'search_repositories',
-									description: 'Search repositories',
-									inputSchema: { type: 'object' },
-								},
-							],
-						},
-					},
-				]),
-			)
-		vi.stubGlobal('fetch', fetchMock)
-
-		const client = new MCPClient({
-			serverName: 'github',
-			transport: {
-				type: 'streamable_http',
-				url: 'https://mcp.example.test/mcp',
-				headers: { Authorization: 'Bearer token' },
-			},
-		})
-		const notifications: string[] = []
-		client.onNotification((method) => notifications.push(method))
-
-		await client.connect()
-		const tools = await client.listTools()
-
-		expect(tools.map((tool) => tool.name)).toEqual(['search_repositories'])
-		expect(notifications).toEqual(['notifications/progress'])
-		expect(fetchMock).toHaveBeenCalledTimes(3)
-
-		const initialize = requestAt(fetchMock, 0)
-		expect(initialize.input).toBe('https://mcp.example.test/mcp')
-		expect(initialize.body.method).toBe('initialize')
-		expect(initialize.headers.Authorization).toBe('Bearer token')
-		expect(initialize.headers.Accept).toBe('application/json, text/event-stream')
-
-		const initialized = requestAt(fetchMock, 1)
-		expect(initialized.body.method).toBe('notifications/initialized')
-		expect(initialized.headers['Mcp-Session-Id']).toBe('sid_123')
-
-		const listTools = requestAt(fetchMock, 2)
-		expect(listTools.body.method).toBe('tools/list')
-		expect(listTools.headers['Mcp-Session-Id']).toBe('sid_123')
-	})
-
-	it('supports the streamable-http alias without non-standard hint headers', async () => {
-		const fetchMock = vi.fn<typeof fetch>()
-		fetchMock
-			.mockResolvedValueOnce(
-				jsonResponse(
-					{
-						jsonrpc: '2.0',
-						id: 1,
-						result: {
-							protocolVersion: '2024-11-05',
-							capabilities: { tools: {} },
-							serverInfo: { name: 'linear' },
-						},
-					},
-					{ 'Mcp-Session-Id': 'sid_alias' },
-				),
-			)
-			.mockResolvedValueOnce(new Response(null, { status: 204 }))
-			.mockResolvedValueOnce(
-				jsonResponse({
-					jsonrpc: '2.0',
-					id: 2,
-					result: { content: [{ type: 'text', text: 'ok' }] },
-				}),
-			)
-		vi.stubGlobal('fetch', fetchMock)
-
-		const client = new MCPClient({
-			serverName: 'linear',
-			transport: {
-				type: 'streamable-http',
-				url: 'https://mcp.example.test/linear',
-			},
-		})
-
-		await client.connect()
-		const result = await client.callTool('create_issue', { title: 'Bug' })
-
-		expect(result.content).toEqual([{ type: 'text', text: 'ok' }])
-		const callTool = requestAt(fetchMock, 2)
-		expect(callTool.body.method).toBe('tools/call')
-		expect(callTool.headers).toEqual({
-			'Content-Type': 'application/json',
-			Accept: 'application/json, text/event-stream',
-			'Mcp-Session-Id': 'sid_alias',
-		})
-	})
-})
-
-function jsonResponse(body: MCPJsonRpcMessage, headers?: Record<string, string>): Response {
-	return new Response(JSON.stringify(body), {
-		status: 200,
-		headers: {
-			'content-type': 'application/json',
-			...headers,
-		},
-	})
-}
-
-function sseResponse(messages: MCPJsonRpcMessage[]): Response {
-	return new Response(messages.map((message) => `data: ${JSON.stringify(message)}\n\n`).join(''), {
-		status: 200,
-		headers: {
-			'content-type': 'text/event-stream',
-		},
-	})
-}
-
-function requestAt(
-	fetchMock: ReturnType<typeof vi.fn<typeof fetch>>,
-	index: number,
-): {
-	input: Parameters<typeof fetch>[0]
-	headers: Record<string, string>
-	body: MCPJsonRpcMessage
-} {
-	const call = fetchMock.mock.calls[index]
-	if (!call) {
-		throw new Error(`No fetch call at index ${index}`)
-	}
-	const [input, init] = call
-	if (!init) {
-		throw new Error(`Fetch call at index ${index} had no init`)
-	}
-	const headers = init.headers as Record<string, string>
-	const body = JSON.parse(String(init.body)) as MCPJsonRpcMessage
-	return { input, headers, body }
-}

package/src/constants/tools/__tests__/dangerous-patterns.test.ts

@@ -1,62 +0,0 @@
-import { describe, expect, it } from 'vitest'
-
-import { DANGEROUS_PATTERNS } from '../index.js'
-
-/**
- * `DANGEROUS_PATTERNS` is what `deny_dangerous_patterns` consults, and
- * `namzu run`'s own docstring promises that in a non-interactive run "the
- * safety gate still hard-denies catastrophic commands".
- *
- * The fork-bomb entry could not deny one. It was written `/:(){ :\|:& };:/`,
- * and in a regular expression `()` is an empty capture group rather than two
- * literal parentheses — so the pattern described `:{ :|:& };:`, a string that
- * is not valid shell and that nobody types. The list looked complete in review
- * and had a hole in it that only running the regex reveals.
- *
- * No test named a fork bomb before this one, which is how it survived.
- */
-
-function denies(command: string): boolean {
-	return DANGEROUS_PATTERNS.some((p) => p.test(command))
-}
-
-describe('the dangerous-command list denies fork bombs', () => {
-	// Spelling varies with whitespace and with the function's name; the bomb
-	// does not care, so neither may the pattern.
-	it.each([
-		':(){ :|:& };:',
-		':(){:|:&};:',
-		':() { :|:& }; :',
-		':(){ : | : & }; :',
-		'bomb(){ bomb|bomb& }; bomb',
-		'f(){ f|f& };f',
-	])('denies %j', (command) => {
-		expect(denies(command)).toBe(true)
-	})
-})
-
-describe('it does not deny ordinary shell', () => {
-	// A function containing a pipe and a background job is not a fork bomb.
-	// The signature is SELF-reference — the same name on both sides — and a
-	// pattern that fired on the general shape would make the gate useless by
-	// crying wolf.
-	it.each([
-		'build(){ make | tee log & }',
-		'watch(){ tail -f log | grep ERROR & }; watch',
-		'f(){ g|h& };f',
-		'run(){ a|b& }; run',
-		'git log | head -20',
-		'npm test',
-	])('allows %j', (command) => {
-		expect(denies(command)).toBe(false)
-	})
-})
-
-describe('the rest of the list still fires', () => {
-	it.each(['rm -rf /', 'mkfs.ext4 /dev/sda', 'dd if=/dev/zero of=/dev/sda', 'sudo rm x'])(
-		'denies %j',
-		(command) => {
-			expect(denies(command)).toBe(true)
-		},
-	)
-})

package/src/contracts/__tests__/an-id-the-sdk-mints-passes-its-own-schema.test.ts

@@ -1,84 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, describe, expect, it } from 'vitest'
-
-import {
-	DefaultFilesystemMigrator,
-	NOOP_FILESYSTEM_MIGRATION_SINK,
-} from '../../session/migration/filesystem.js'
-import { generateProjectId } from '../../utils/id.js'
-import { ProjectIdSchema } from '../schemas.js'
-
-/**
- * `ProjectIdSchema` was `/^prj_[a-z0-9]+$/` while the v0.2.0 filesystem
- * migration minted `prj_legacy_<suffix>`. So the SDK's own public validator
- * rejected ids the SDK itself had written to disk: a host that validated an
- * inbound project id — the reason the schema is exported at all — refused
- * every project it had migrated, with "Invalid project ID format" and no hint
- * that the id came from the SDK.
- *
- * Both minters are driven here rather than restated. A test that spells out
- * `prj_legacy_abc` as a literal would still pass if the migration changed its
- * shape tomorrow; running the migration means the two cannot drift apart
- * without this failing.
- */
-
-const dirs: string[] = []
-afterEach(async () => {
-	await Promise.all(dirs.map((d) => rm(d, { recursive: true, force: true })))
-	dirs.length = 0
-})
-
-describe('every project id the SDK mints passes the schema the SDK exports', () => {
-	it('accepts what the id generator produces', () => {
-		// 200 draws, because the generator is random over [0-9a-z] and one
-		// sample proves nothing about the alphabet it can reach.
-		for (let i = 0; i < 200; i++) {
-			const id = generateProjectId()
-			const parsed = ProjectIdSchema.safeParse(id)
-			expect({ id, ok: parsed.success }).toEqual({ id, ok: true })
-		}
-	})
-
-	it('accepts what the filesystem migration produces', async () => {
-		const root = await mkdtemp(join(tmpdir(), 'namzu-idschema-'))
-		dirs.push(root)
-		const runDir = join(root, 'threads', 'thd_a1b2c3d4e5f6', 'runs', 'run_seed')
-		await mkdir(runDir, { recursive: true })
-		await writeFile(join(runDir, 'run.json'), JSON.stringify({ id: 'run_seed' }), 'utf-8')
-
-		const result = await new DefaultFilesystemMigrator(NOOP_FILESYSTEM_MIGRATION_SINK).migrate(root)
-
-		expect(result.kind).toBe('migrated')
-		expect(result.migratedThreads).toHaveLength(1)
-		for (const { newProjectId } of result.migratedThreads) {
-			const parsed = ProjectIdSchema.safeParse(newProjectId)
-			expect({ newProjectId, ok: parsed.success }).toEqual({ newProjectId, ok: true })
-		}
-	})
-
-	it('still refuses what no minter produces, because the id is also a directory name', () => {
-		// Widening to accept the legacy form must not widen to accept a path.
-		// Everything here would be joined onto the store root if it got through.
-		const refused = [
-			'prj_../../etc',
-			'prj_..',
-			'prj_a/b',
-			'prj_a\\b',
-			'prj_',
-			'prj_legacy_',
-			'prj_ABC',
-			'prj_a-b',
-			'prj_a b',
-			'proj_abc',
-			'thd_abc',
-			'',
-		]
-
-		for (const candidate of refused) {
-			const parsed = ProjectIdSchema.safeParse(candidate)
-			expect({ candidate, ok: parsed.success }).toEqual({ candidate, ok: false })
-		}
-	})
-})

package/src/directory/__tests__/derive.test.ts

@@ -1,135 +0,0 @@
-import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { describe, expect, it } from 'vitest'
-
-import { deriveRunOptions } from '../derive.js'
-import { loadDirectory } from '../load.js'
-
-const provider = { id: 'mock', name: 'Mock' } as never
-
-function project(files: Record<string, string>): string {
-	const root = mkdtempSync(join(tmpdir(), 'namzu-derive-'))
-	for (const [relative, body] of Object.entries(files)) {
-		const full = join(root, relative)
-		mkdirSync(join(full, '..'), { recursive: true })
-		writeFileSync(full, body)
-	}
-	return root
-}
-
-const TOOL = (name: string) => `
-export default {
-  name: ${JSON.stringify(name)},
-  description: 'a tool',
-  inputSchema: { parse: (v) => v, safeParse: (v) => ({ success: true, data: v }) },
-  execute: async () => ({ success: true, output: 'ok' }),
-}
-`
-
-describe('turning a manifest into run options', () => {
-	it('carries instructions, config and tools across', async () => {
-		const root = project({
-			'instructions.md': 'You are terse.',
-			'agent.js': 'export default { model: "m", maxIterations: 3 }',
-			'tools/a.js': TOOL('a'),
-		})
-		const { manifest } = await loadDirectory(root)
-
-		const options = deriveRunOptions(manifest, { provider, prompt: 'hi' })
-
-		expect(options.model).toBe('m')
-		expect(options.instructions).toBe('You are terse.')
-		expect(options.maxIterations).toBe(3)
-		expect(options.tools?.has('a')).toBe(true)
-	})
-
-	it('points the working directory at the project, not the host', async () => {
-		// Left unset this defaults to the host's cwd, which aims the file
-		// tools' containment at the host's own source tree.
-		const root = project({
-			'instructions.md': 'hi',
-			'agent.js': 'export default { model: "m" }',
-		})
-		const { manifest } = await loadDirectory(root)
-
-		expect(deriveRunOptions(manifest, { provider, prompt: 'hi' }).workingDirectory).toBe(
-			manifest.root,
-		)
-	})
-
-	it('lets an explicit model win over agent.ts', async () => {
-		const root = project({
-			'instructions.md': 'hi',
-			'agent.js': 'export default { model: "from-file" }',
-		})
-		const { manifest } = await loadDirectory(root)
-
-		expect(deriveRunOptions(manifest, { provider, prompt: 'hi', model: 'explicit' }).model).toBe(
-			'explicit',
-		)
-	})
-
-	it('refuses when nothing names a model', async () => {
-		const root = project({ 'instructions.md': 'hi' })
-		const { manifest } = await loadDirectory(root)
-
-		expect(() => deriveRunOptions(manifest, { provider, prompt: 'hi' })).toThrow(/No model/)
-	})
-
-	it('forwards a name only when agent.ts declared one', async () => {
-		// A name guessed from a directory basename becomes the agent id in
-		// traces, where two sibling projects both called `agent` merge into one
-		// attribution bucket.
-		const declared = project({
-			'instructions.md': 'hi',
-			'agent.js': 'export default { model: "m", name: "researcher" }',
-		})
-		const guessed = project({
-			'instructions.md': 'hi',
-			'agent.js': 'export default { model: "m" }',
-		})
-
-		const withName = deriveRunOptions((await loadDirectory(declared)).manifest, {
-			provider,
-			prompt: 'x',
-		})
-		const without = deriveRunOptions((await loadDirectory(guessed)).manifest, {
-			provider,
-			prompt: 'x',
-		})
-
-		expect(withName.name).toBe('researcher')
-		expect(without.name).toBeUndefined()
-	})
-
-	it('refuses a manifest whose modules were never loaded', async () => {
-		// `manifest.tools` is empty for a reason that has nothing to do with
-		// the project. Running it would produce an agent with no capabilities
-		// and no indication why.
-		const root = project({
-			'instructions.md': 'hi',
-			'agent.js': 'export default { model: "m" }',
-			'tools/a.js': TOOL('a'),
-		})
-		const { manifest } = await loadDirectory(root, { modules: 'skip' })
-
-		expect(() => deriveRunOptions(manifest, { provider, prompt: 'hi' })).toThrow(/modules: "skip"/)
-	})
-
-	it('lets overrides win over everything', async () => {
-		const root = project({
-			'instructions.md': 'hi',
-			'agent.js': 'export default { model: "m", maxIterations: 3 }',
-		})
-		const { manifest } = await loadDirectory(root)
-
-		const options = deriveRunOptions(manifest, {
-			provider,
-			prompt: 'hi',
-			overrides: { maxIterations: 99 },
-		})
-
-		expect(options.maxIterations).toBe(99)
-	})
-})

package/src/directory/__tests__/load-diagnostics.test.ts

@@ -1,126 +0,0 @@
-import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { describe, expect, it } from 'vitest'
-
-import { loadDirectory } from '../load.js'
-
-/**
- * Three refusals this loader claimed to make and did not.
- *
- * Each is the same shape: a check that existed, read the wrong thing, and
- * therefore reported the wrong answer while looking correct in review. A
- * loader whose entire job is to say what is wrong with a directory has to be
- * held to the diagnostics it actually emits, not the ones its code appears to
- * emit.
- */
-
-function project(files: Record<string, string>): string {
-	const root = mkdtempSync(join(tmpdir(), 'namzu-diag-'))
-	for (const [relative, body] of Object.entries(files)) {
-		const full = join(root, relative)
-		mkdirSync(join(full, '..'), { recursive: true })
-		writeFileSync(full, body)
-	}
-	return root
-}
-
-describe('a tool that would crash later is refused now', () => {
-	it('rejects a default export with no inputSchema', async () => {
-		// `name` and `execute` alone used to pass. The object then registered
-		// clean and died in `toLLMTools()` on `inputSchema._def` — a TypeError
-		// naming neither this file nor this loader.
-		const root = project({
-			'tools/broken.js': `
-export default {
-  name: 'broken',
-  description: 'no schema',
-  execute: async () => ({ success: true }),
-}
-`,
-		})
-
-		const { manifest, diagnostics, ok } = await loadDirectory(root)
-
-		expect(ok).toBe(false)
-		expect(diagnostics.map((d) => d.code)).toContain('not_a_tool')
-		expect(manifest.tools).toHaveLength(0)
-	})
-
-	it('still accepts a hand-written tool that satisfies the published type', async () => {
-		// The required set and no more: demanding `defineTool`'s extras would
-		// make this loader refuse an object the SDK's own type accepts.
-		const root = project({
-			'tools/fine.js': `
-export default {
-  name: 'fine',
-  description: 'a tool',
-  inputSchema: { parse: (v) => v },
-  execute: async () => ({ success: true }),
-}
-`,
-		})
-
-		const { manifest, ok } = await loadDirectory(root)
-
-		expect(ok).toBe(true)
-		expect(manifest.tools).toHaveLength(1)
-	})
-})
-
-describe('an import failure explains itself', () => {
-	it('gives the extension hint for a module it cannot resolve', async () => {
-		// The hint is chosen from Node's error CODE. It used to be matched
-		// against the message, which never contains the code, so every hint in
-		// the function was unreachable and every author got the bare error.
-		const root = project({
-			'tools/importer.js': `
-import './nowhere-at-all.js'
-export default { name: 'x', description: 'x', inputSchema: {}, execute: async () => ({}) }
-`,
-		})
-
-		const { diagnostics } = await loadDirectory(root)
-
-		const failed = diagnostics.find((d) => d.code === 'module_load_failed')
-		expect(failed).toBeDefined()
-		expect(failed?.cause).toContain('real extension')
-	})
-})
-
-describe('agent.ts metadata is checked, not assumed', () => {
-	it('refuses metadata values that are not strings', async () => {
-		// Typed `Record<string, string>` and admitted on `typeof === 'object'`,
-		// so the values were never looked at and the type was a promise this
-		// loader did not keep.
-		const root = project({
-			'agent.js': 'export default { model: "m", metadata: { count: 1 } }',
-		})
-
-		const { diagnostics, ok } = await loadDirectory(root)
-
-		expect(ok).toBe(false)
-		expect(diagnostics.some((d) => d.code === 'invalid_config')).toBe(true)
-	})
-
-	it('refuses an array, which typeof calls an object', async () => {
-		const root = project({
-			'agent.js': 'export default { model: "m", metadata: ["a", "b"] }',
-		})
-
-		const { ok } = await loadDirectory(root)
-
-		expect(ok).toBe(false)
-	})
-
-	it('accepts a metadata object of strings', async () => {
-		const root = project({
-			'agent.js': 'export default { model: "m", metadata: { team: "core" } }',
-		})
-
-		const { manifest, ok } = await loadDirectory(root)
-
-		expect(ok).toBe(true)
-		expect(manifest.config.metadata).toEqual({ team: 'core' })
-	})
-})