339 lines
9.4 KiB
TypeScript
339 lines
9.4 KiB
TypeScript
import { spawn, ChildProcess } from 'child_process'
|
|
import { join, dirname } from 'path'
|
|
import { fileURLToPath } from 'url'
|
|
import { writeFileSync, mkdirSync, readFileSync } from 'fs'
|
|
import { createServer, Server } from 'http'
|
|
import { parse } from 'url'
|
|
import { extname } from 'path'
|
|
|
|
const __dirname = dirname(fileURLToPath(import.meta.url))
|
|
const rootDir = join(__dirname, '../..')
|
|
const testDir = join(__dirname, '..')
|
|
const cacheDir = join(testDir, 'node_modules/.cache/use-mcp-tests')
|
|
const testStateFile = join(cacheDir, 'test-state.json')
|
|
|
|
interface GlobalState {
|
|
honoServer?: ChildProcess
|
|
staticServer?: Server
|
|
staticPort?: number
|
|
honoPort?: number
|
|
processGroupId?: number
|
|
allChildProcesses?: Set<number>
|
|
}
|
|
|
|
declare global {
|
|
var __INTEGRATION_TEST_STATE__: GlobalState
|
|
}
|
|
|
|
function waitForOutput(process: ChildProcess, targetOutput: string, timeout = 30000): Promise<void> {
|
|
return new Promise((resolve, reject) => {
|
|
const timer = setTimeout(() => {
|
|
reject(new Error(`Timeout waiting for: ${targetOutput}`))
|
|
}, timeout)
|
|
|
|
const onData = (data: Buffer) => {
|
|
const output = data.toString()
|
|
console.log(`[server output] ${output}`)
|
|
if (output.includes(targetOutput)) {
|
|
clearTimeout(timer)
|
|
process.stdout?.off('data', onData)
|
|
process.stderr?.off('data', onData)
|
|
resolve()
|
|
}
|
|
}
|
|
|
|
process.stdout?.on('data', onData)
|
|
process.stderr?.on('data', onData)
|
|
})
|
|
}
|
|
|
|
async function checkPortAvailable(port: number): Promise<boolean> {
|
|
return new Promise((resolve) => {
|
|
const server = require('net').createServer()
|
|
|
|
server.listen(port, () => {
|
|
server.close(() => {
|
|
// Wait a bit for the port to fully close
|
|
setTimeout(() => resolve(true), 100)
|
|
})
|
|
})
|
|
|
|
server.on('error', (err: any) => {
|
|
console.log(`Port ${port} check failed: ${err.message}`)
|
|
resolve(false)
|
|
})
|
|
})
|
|
}
|
|
|
|
async function checkPortNotUsedByWrangler(port: number): Promise<boolean> {
|
|
// First check if port is available at network level
|
|
const networkAvailable = await checkPortAvailable(port)
|
|
if (!networkAvailable) {
|
|
return false
|
|
}
|
|
|
|
// Then check if there are wrangler processes using this port
|
|
return new Promise((resolve) => {
|
|
const { spawn } = require('child_process')
|
|
const lsof = spawn('lsof', ['-ti', `:${port}`])
|
|
|
|
let output = ''
|
|
lsof.stdout?.on('data', (data: Buffer) => {
|
|
output += data.toString()
|
|
})
|
|
|
|
lsof.on('close', () => {
|
|
if (output.trim()) {
|
|
// Port is in use
|
|
resolve(false)
|
|
} else {
|
|
// Port is free
|
|
resolve(true)
|
|
}
|
|
})
|
|
|
|
lsof.on('error', () => {
|
|
// lsof failed, assume port is available
|
|
resolve(true)
|
|
})
|
|
})
|
|
}
|
|
|
|
function findAvailablePortFromBase(basePort: number): Promise<number> {
|
|
return new Promise(async (resolve, reject) => {
|
|
for (let port = basePort; port < basePort + 20; port++) {
|
|
if (await checkPortNotUsedByWrangler(port)) {
|
|
resolve(port)
|
|
return
|
|
}
|
|
}
|
|
reject(new Error(`No available ports found starting from ${basePort}. Please stop any existing wrangler/workerd processes.`))
|
|
})
|
|
}
|
|
|
|
function runCommand(command: string, args: string[], cwd: string): Promise<void> {
|
|
return new Promise((resolve, reject) => {
|
|
const child = spawn(command, args, {
|
|
cwd,
|
|
stdio: 'inherit',
|
|
shell: true,
|
|
})
|
|
|
|
child.on('close', (code) => {
|
|
if (code === 0) {
|
|
resolve()
|
|
} else {
|
|
reject(new Error(`Command failed with code ${code}: ${command} ${args.join(' ')}`))
|
|
}
|
|
})
|
|
|
|
child.on('error', reject)
|
|
})
|
|
}
|
|
|
|
function findAvailablePort(startPort = 8000): Promise<number> {
|
|
return new Promise((resolve) => {
|
|
const server = createServer()
|
|
server
|
|
.listen(startPort, () => {
|
|
const port = (server.address() as any)?.port
|
|
server.close(() => resolve(port))
|
|
})
|
|
.on('error', () => {
|
|
resolve(findAvailablePort(startPort + 1))
|
|
})
|
|
})
|
|
}
|
|
|
|
export default async function globalSetup() {
|
|
console.log('🔧 Setting up integration test environment...')
|
|
|
|
const state: GlobalState = {
|
|
allChildProcesses: new Set<number>(),
|
|
}
|
|
globalThis.__INTEGRATION_TEST_STATE__ = state
|
|
|
|
// Set up signal handlers for cleanup
|
|
const cleanup = () => {
|
|
// Kill all tracked child processes
|
|
if (state.allChildProcesses) {
|
|
for (const pid of state.allChildProcesses) {
|
|
try {
|
|
process.kill(pid, 'SIGTERM')
|
|
setTimeout(() => {
|
|
try {
|
|
process.kill(pid, 'SIGKILL')
|
|
} catch (e) {
|
|
// Process already dead, ignore
|
|
}
|
|
}, 1000)
|
|
} catch (e) {
|
|
// Process already dead, ignore
|
|
}
|
|
}
|
|
}
|
|
|
|
// Also try process group cleanup as backup
|
|
if (state.processGroupId) {
|
|
try {
|
|
process.kill(-state.processGroupId, 'SIGTERM')
|
|
setTimeout(() => {
|
|
try {
|
|
process.kill(-state.processGroupId!, 'SIGKILL')
|
|
} catch (e) {
|
|
// Ignore errors
|
|
}
|
|
}, 1000)
|
|
} catch (e) {
|
|
// Ignore errors - process group may not exist
|
|
}
|
|
}
|
|
|
|
if (state.staticServer) {
|
|
state.staticServer.close()
|
|
state.staticServer.closeAllConnections?.()
|
|
}
|
|
}
|
|
|
|
process.on('SIGINT', cleanup)
|
|
process.on('SIGTERM', cleanup)
|
|
process.on('exit', cleanup)
|
|
|
|
try {
|
|
// Step 1: Build use-mcp library
|
|
console.log('📦 Building use-mcp library...')
|
|
await runCommand('pnpm', ['build'], rootDir)
|
|
|
|
// Step 2: Build inspector example
|
|
console.log('📦 Building inspector example...')
|
|
const inspectorDir = join(rootDir, 'examples/inspector')
|
|
await runCommand('pnpm', ['build'], inspectorDir)
|
|
|
|
// Step 3: Find available port and start hono-mcp server
|
|
console.log('🔍 Finding available port starting from 9901...')
|
|
const honoPort = await findAvailablePortFromBase(9901)
|
|
console.log(`📍 Using port ${honoPort} for hono-mcp server`)
|
|
|
|
console.log('🚀 Starting hono-mcp server...')
|
|
const honoDir = join(rootDir, 'examples/servers/hono-mcp')
|
|
const honoServer = spawn('pnpm', ['dev', `--port=${honoPort}`], {
|
|
cwd: honoDir,
|
|
stdio: ['ignore', 'pipe', 'pipe'],
|
|
shell: true,
|
|
detached: false, // Keep in same process group initially
|
|
})
|
|
|
|
// Track all child processes
|
|
if (honoServer.pid) {
|
|
state.allChildProcesses!.add(honoServer.pid)
|
|
}
|
|
|
|
// Store the process group ID and port
|
|
state.processGroupId = honoServer.pid
|
|
state.honoPort = honoPort
|
|
state.honoServer = honoServer
|
|
|
|
honoServer.stdout?.on('data', (data) => {
|
|
console.log(`[hono-mcp] ${data.toString()}`)
|
|
})
|
|
|
|
honoServer.stderr?.on('data', (data) => {
|
|
console.log(`[hono-mcp] ${data.toString()}`)
|
|
})
|
|
|
|
// Track when the process exits to remove it from our tracking
|
|
honoServer.on('exit', () => {
|
|
if (honoServer.pid) {
|
|
state.allChildProcesses!.delete(honoServer.pid)
|
|
}
|
|
})
|
|
|
|
// Wait for hono server to be ready
|
|
await waitForOutput(honoServer, 'Ready on')
|
|
state.honoServer = honoServer
|
|
|
|
// Step 4: Start simple static file server for inspector
|
|
console.log('🌐 Starting static file server for inspector...')
|
|
const inspectorDistDir = join(inspectorDir, 'dist')
|
|
const staticPort = await findAvailablePort(8000)
|
|
|
|
const staticServer = createServer((req, res) => {
|
|
const pathname = parse(req.url || '').pathname || '/'
|
|
let filePath = join(inspectorDistDir, pathname === '/' ? 'index.html' : pathname)
|
|
|
|
// Always disable keep-alive
|
|
res.setHeader('Connection', 'close')
|
|
|
|
try {
|
|
const data = readFileSync(filePath)
|
|
const ext = extname(filePath)
|
|
const contentType =
|
|
{
|
|
'.html': 'text/html',
|
|
'.js': 'application/javascript',
|
|
'.css': 'text/css',
|
|
'.json': 'application/json',
|
|
'.png': 'image/png',
|
|
'.jpg': 'image/jpeg',
|
|
'.gif': 'image/gif',
|
|
'.svg': 'image/svg+xml',
|
|
}[ext] || 'text/plain'
|
|
|
|
res.writeHead(200, { 'Content-Type': contentType })
|
|
res.end(data)
|
|
} catch (e) {
|
|
// Fallback to index.html for SPA routing
|
|
try {
|
|
const indexData = readFileSync(join(inspectorDistDir, 'index.html'))
|
|
res.writeHead(200, { 'Content-Type': 'text/html' })
|
|
res.end(indexData)
|
|
} catch (e2) {
|
|
res.writeHead(404, { 'Content-Type': 'text/plain' })
|
|
res.end('Not Found')
|
|
}
|
|
}
|
|
})
|
|
|
|
// Configure for immediate shutdown
|
|
staticServer.keepAliveTimeout = 0
|
|
staticServer.headersTimeout = 1
|
|
|
|
await new Promise<void>((resolve) => {
|
|
staticServer.listen(staticPort, () => {
|
|
console.log(`📁 Static server running on http://localhost:${staticPort}`)
|
|
resolve()
|
|
})
|
|
})
|
|
|
|
state.staticServer = staticServer
|
|
state.staticPort = staticPort
|
|
|
|
// Write state to file for tests to read
|
|
mkdirSync(cacheDir, { recursive: true })
|
|
writeFileSync(
|
|
testStateFile,
|
|
JSON.stringify(
|
|
{
|
|
honoPort: state.honoPort,
|
|
staticPort: state.staticPort,
|
|
},
|
|
null,
|
|
2,
|
|
),
|
|
)
|
|
|
|
console.log('✅ Integration test environment ready!')
|
|
} catch (error) {
|
|
console.error('❌ Failed to set up integration test environment:', error)
|
|
|
|
// Cleanup on failure
|
|
if (state.honoServer) {
|
|
state.honoServer.kill()
|
|
}
|
|
if (state.staticServer) {
|
|
state.staticServer.close()
|
|
}
|
|
|
|
throw error
|
|
}
|
|
}
|