@tduyng/pi-claude 0.0.0-stage → 0.0.2

package/src/mcp.ts

@@ -0,0 +1,288 @@
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from 'node:http'
+
+import { Validator } from 'ata-validator'
+import { t } from 'ata-validator/t'
+
+
+import type { JsonObject, JsonValue } from './json.js'
+const isStringOrNumber = new Validator(t.union([t.string(), t.number()])).isValidObject
+const isString = new Validator(t.string()).isValidObject
+
+export type McpToolDef = {
+    name: string
+    description: string
+    inputSchema: JsonObject
+}
+
+export type McpContent = { type: 'text'; text: string } | { type: 'image'; data: string; mimeType: string }
+
+export type McpResult = {
+    content: McpContent[]
+    isError?: boolean
+}
+
+export type McpHandlers = {
+    listTools(): McpToolDef[]
+    callTool(name: string, args: JsonObject, meta: JsonObject): Promise<McpResult>
+}
+
+export type McpServerHandle = {
+    port: number
+    urlFor(token: string): string
+    register(token: string, handlers: McpHandlers): void
+    unregister(token: string): void
+    close(): Promise<void>
+}
+
+const SERVER_INFO = { name: 'pi', version: '1.0.0' }
+const DEFAULT_PROTOCOL = '2025-11-25'
+const MAX_BODY_BYTES = 32 * 1024 * 1024
+
+type RpcId = string | number
+
+type McpRequest =
+    | { kind: 'malformed' }
+    | { kind: 'notification' }
+    | { kind: 'initialize'; id: RpcId; protocolVersion: string }
+    | { kind: 'ping'; id: RpcId }
+    | { kind: 'listTools'; id: RpcId }
+    | { kind: 'callTool'; id: RpcId; name: string; args: JsonObject; meta: JsonObject }
+    | { kind: 'unsupported'; id: RpcId; method: string }
+
+const ObjectSchema = t.object({}, { additionalProperties: true })
+const isObjectSchema = new Validator(ObjectSchema).isValidObject
+
+function isJsonObject<V>(value: V): value is V & JsonObject {
+    return isObjectSchema(value) && !Array.isArray(value)
+}
+
+function asObject(value: JsonValue | undefined): JsonObject {
+    return isJsonObject(value) ? value : {}
+}
+
+function parseRequest(body: string): McpRequest {
+    let frame: JsonObject
+    try {
+        const parsed: JsonValue = JSON.parse(body)
+        frame = asObject(parsed)
+    } catch {
+        return { kind: 'malformed' }
+    }
+    const id = frame['id']
+    if (!isStringOrNumber(id)) return { kind: 'notification' }
+
+    const method = frame['method']
+    if (!isString(method)) return { kind: 'malformed' }
+    const params = asObject(frame['params'])
+
+    switch (method) {
+        case 'initialize': {
+            const requested = params['protocolVersion']
+            return {
+                kind: 'initialize',
+                id,
+                protocolVersion: isString(requested) ? requested : DEFAULT_PROTOCOL
+            }
+        }
+        case 'ping':
+            return { kind: 'ping', id }
+        case 'tools/list':
+            return { kind: 'listTools', id }
+        case 'tools/call': {
+            const name = params['name']
+            if (!isString(name)) return { kind: 'malformed' }
+            return { kind: 'callTool', id, name, args: asObject(params['arguments']), meta: asObject(params['_meta']) }
+        }
+        default:
+            return { kind: 'unsupported', id, method }
+    }
+}
+
+class RequestBodyError extends Error {
+    readonly status = 413
+
+    constructor() {
+        super(`MCP request body exceeds ${MAX_BODY_BYTES} bytes`)
+        this.name = 'RequestBodyError'
+    }
+}
+
+function readBody(req: IncomingMessage): Promise<string> {
+    return new Promise((resolve, reject) => {
+        let body = ''
+        let bytes = 0
+        let rejected = false
+        req.setEncoding('utf8')
+        req.on('data', (chunk: string) => {
+            if (rejected) return
+            bytes += Buffer.byteLength(chunk, 'utf8')
+            if (bytes > MAX_BODY_BYTES) {
+                rejected = true
+                reject(new RequestBodyError())
+                return
+            }
+            body += chunk
+        })
+        req.on('end', () => {
+            if (!rejected) resolve(body)
+        })
+        req.on('error', reject)
+    })
+}
+
+type RpcResult =
+    | {
+          protocolVersion: string
+          capabilities: { tools: { listChanged?: boolean } }
+          serverInfo: { name: string; version: string }
+      }
+    | { alive?: true }
+    | { tools: McpToolDef[] }
+    | McpResult
+
+type RpcPayload =
+    | { jsonrpc: '2.0'; id: RpcId; result: RpcResult }
+    | { jsonrpc: '2.0'; id: RpcId; error: { code: number; message: string } }
+
+type RpcReply = { status: number; body?: RpcPayload }
+
+function ok(id: RpcId, result: RpcResult): RpcPayload {
+    return { jsonrpc: '2.0', id, result }
+}
+
+function send(res: ServerResponse, status: number, payload: RpcPayload | undefined, sessionId: string): void {
+    if (payload === undefined) {
+        res.writeHead(status, { 'mcp-session-id': sessionId }).end()
+        return
+    }
+    const body = JSON.stringify(payload)
+    res.writeHead(status, {
+        'content-type': 'application/json',
+        'content-length': Buffer.byteLength(body),
+        'mcp-session-id': sessionId
+    }).end(body)
+}
+
+async function respond(request: McpRequest, handlers: McpHandlers): Promise<RpcReply> {
+    switch (request.kind) {
+        case 'malformed':
+            return { status: 400 }
+        case 'notification':
+            return { status: 202 }
+        case 'initialize':
+            return {
+                status: 200,
+                body: ok(request.id, {
+                    protocolVersion: request.protocolVersion,
+                    capabilities: { tools: { listChanged: false } },
+                    serverInfo: SERVER_INFO
+                })
+            }
+        case 'ping':
+            return { status: 200, body: ok(request.id, {}) }
+        case 'listTools':
+            return { status: 200, body: ok(request.id, { tools: handlers.listTools() }) }
+        case 'callTool': {
+            let result: McpResult
+            try {
+                result = await handlers.callTool(request.name, request.args, request.meta)
+            } catch (error) {
+                result = {
+                    content: [{ type: 'text', text: error instanceof Error ? error.message : String(error) }],
+                    isError: true
+                }
+            }
+            return { status: 200, body: ok(request.id, result) }
+        }
+        case 'unsupported':
+            return {
+                status: 200,
+                body: {
+                    jsonrpc: '2.0',
+                    id: request.id,
+                    error: { code: -32601, message: `unsupported method: ${request.method}` }
+                }
+            }
+    }
+}
+
+export function mcpInputSchema(parameters: JsonObject | undefined): JsonObject {
+    if (!parameters) return { type: 'object', additionalProperties: false }
+    const schema = { ...parameters }
+    const required = schema['required']
+    if (required !== undefined && !Array.isArray(required) && isObjectSchema(required)) {
+        schema['required'] = Object.keys(required)
+    }
+    if (schema['required'] === undefined) schema['required'] = []
+    return schema
+}
+
+export function startMcpServer(): Promise<McpServerHandle> {
+    const registry = new Map<string, McpHandlers>()
+
+    const server: Server = createServer((req, res) => {
+        void (async () => {
+            const token = /^\/mcp\/([A-Za-z0-9_-]+)\/?$/.exec(req.url ?? '')?.[1]
+            const handlers = token ? registry.get(token) : undefined
+            if (!token || !handlers) {
+                send(res, 404, undefined, 'missing')
+                return
+            }
+            if (req.method === 'GET') {
+                res.writeHead(200, {
+                    'content-type': 'text/event-stream',
+                    'cache-control': 'no-cache',
+                    'mcp-session-id': token
+                })
+                res.write(': connected\n\n')
+                res.on('close', () => undefined)
+                return
+            }
+            if (req.method === 'DELETE') {
+                res.writeHead(200, { 'mcp-session-id': token }).end()
+                return
+            }
+            if (req.method !== 'POST') {
+                send(res, 405, undefined, token)
+                return
+            }
+
+            const request = parseRequest(await readBody(req))
+            const reply = await respond(request, handlers)
+            send(res, reply.status, reply.body, token)
+        })().catch((error) => {
+            if (!res.headersSent) send(res, error instanceof RequestBodyError ? error.status : 500, undefined, 'error')
+        })
+    })
+
+    server.requestTimeout = 0
+    server.headersTimeout = 60_000
+
+    return new Promise((resolve, reject) => {
+        server.on('error', reject)
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address()
+            if (address === null || isString(address)) {
+                reject(new Error('MCP server did not bind to a TCP port'))
+                return
+            }
+            server.unref()
+            resolve({
+                port: address.port,
+                urlFor: (token) => `http://127.0.0.1:${address.port}/mcp/${token}`,
+                register: (token, handlers) => {
+                    registry.set(token, handlers)
+                },
+                unregister: (token) => {
+                    registry.delete(token)
+                },
+                close: () =>
+                    new Promise((done) => {
+                        registry.clear()
+                        server.closeAllConnections()
+                        server.close(() => done())
+                    })
+            })
+        })
+    })
+}

package/src/protocol.ts

@@ -0,0 +1,335 @@
+import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { createInterface } from 'node:readline'
+
+import { Validator } from 'ata-validator'
+import { t } from 'ata-validator/t'
+
+
+import { jsonArray, jsonObject, jsonText, type JsonObject, type JsonValue } from './json.js'
+import type { CliBlock } from './transcript.js'
+
+export type ClaudeSpec = {
+    bin: string
+    model: string
+    systemPrompt: string
+    effort?: string
+    cwd: string
+    mcpUrl: string
+    contextWindow: number
+    maxTokens: number
+}
+
+const INIT_TIMEOUT_MS = 45_000
+const INIT_SCHEMA = t.object({
+    type: t.literal('system'),
+    subtype: t.literal('init'),
+    mcp_servers: t.optional(t.array(t.object({}, { additionalProperties: true })))
+})
+const isInitSchema = new Validator(INIT_SCHEMA).isValidObject
+
+class EventQueue {
+    private readonly items: JsonObject[] = []
+    private readonly waiters: ((event: JsonObject | undefined) => void)[] = []
+    private closed = false
+
+    push(event: JsonObject): void {
+        const waiter = this.waiters.shift()
+        if (waiter) waiter(event)
+        else this.items.push(event)
+    }
+
+    close(): void {
+        if (this.closed) return
+        this.closed = true
+        for (const waiter of this.waiters.splice(0)) waiter(undefined)
+    }
+
+    next(signal?: AbortSignal): Promise<JsonObject | undefined> {
+        const queued = this.items.shift()
+        if (queued) return Promise.resolve(queued)
+        if (this.closed) return Promise.resolve(undefined)
+
+        return new Promise((resolve, reject) => {
+            let settled = false
+            const waiter = (event: JsonObject | undefined) => {
+                if (settled) return
+                settled = true
+                signal?.removeEventListener('abort', onAbort)
+                resolve(event)
+            }
+            const onAbort = () => {
+                if (settled) return
+                settled = true
+                this.waiters.splice(this.waiters.indexOf(waiter), 1)
+                reject(new Error('aborted'))
+            }
+            this.waiters.push(waiter)
+            if (signal?.aborted) {
+                onAbort()
+                return
+            }
+            signal?.addEventListener('abort', onAbort, { once: true })
+        })
+    }
+}
+
+function childEnv(spec: ClaudeSpec): NodeJS.ProcessEnv {
+    const env: NodeJS.ProcessEnv = { ...process.env }
+    for (const key of [
+        'ANTHROPIC_API_KEY',
+        'ANTHROPIC_AUTH_TOKEN',
+        'ANTHROPIC_BASE_URL',
+        'ANTHROPIC_MODEL',
+        'ANTHROPIC_SMALL_FAST_MODEL',
+        'CLAUDE_CODE_USE_BEDROCK',
+        'CLAUDE_CODE_USE_VERTEX',
+        'CLAUDE_CODE_USE_FOUNDRY',
+        'CLAUDE_CODE_OAUTH_TOKEN',
+        'CLAUDECODE',
+        'CLAUDE_CODE_ENTRYPOINT'
+    ]) {
+        delete env[key]
+    }
+    Object.assign(env, {
+        CLAUDE_CODE_DISABLE_CLAUDE_MDS: '1',
+        CLAUDE_CODE_DISABLE_AUTO_MEMORY: '1',
+        CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: '1',
+        CLAUDE_CODE_DISABLE_BUNDLED_SKILLS: '1',
+        CLAUDE_CODE_DISABLE_POLICY_SKILLS: '1',
+        CLAUDE_CODE_DISABLE_CLAUDE_API_SKILL: '1',
+        CLAUDE_CODE_DISABLE_BACKGROUND_TASKS: '1',
+        CLAUDE_CODE_DISABLE_AGENT_VIEW: '1',
+        CLAUDE_CODE_DISABLE_CRON: '1',
+        CLAUDE_CODE_DISABLE_ARTIFACT: '1',
+        CLAUDE_CODE_DISABLE_ADVISOR_TOOL: '1',
+        CLAUDE_CODE_DISABLE_FAST_MODE: '1',
+        CLAUDE_CODE_DISABLE_ATTACHMENTS: '1',
+        CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING: '1',
+        CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS: '1',
+        DISABLE_AUTO_COMPACT: '1',
+        DISABLE_COMPACT: '1',
+        DISABLE_TELEMETRY: '1',
+        DISABLE_ERROR_REPORTING: '1',
+        DISABLE_AUTOUPDATER: '1',
+        MCP_TIMEOUT: '30000',
+        MCP_TOOL_TIMEOUT: '86400000',
+        CLAUDE_CODE_MCP_AUTO_BACKGROUND_MS: '0',
+        CLAUDE_CODE_MCP_TOOL_IDLE_TIMEOUT: '0',
+        MAX_MCP_OUTPUT_TOKENS: '200000',
+        CLAUDE_CODE_MAX_MCP_DESCRIPTION_LENGTH: '20000',
+        CLAUDE_CODE_MAX_CONTEXT_TOKENS: String(spec.contextWindow),
+        CLAUDE_CODE_MAX_OUTPUT_TOKENS: String(spec.maxTokens)
+    })
+    return env
+}
+
+function spawnArgs(spec: ClaudeSpec, promptPath: string, mcpPath: string): string[] {
+    const args = [
+        '-p',
+        '--input-format',
+        'stream-json',
+        '--output-format',
+        'stream-json',
+        '--verbose',
+        '--include-partial-messages',
+        '--model',
+        spec.model,
+        '--system-prompt-file',
+        promptPath,
+        '--tools',
+        '',
+        '--setting-sources',
+        '',
+        '--strict-mcp-config',
+        '--mcp-config',
+        mcpPath,
+        '--permission-mode',
+        'bypassPermissions',
+        '--allow-dangerously-skip-permissions',
+        '--no-session-persistence',
+        '--disable-slash-commands'
+    ]
+    if (spec.effort) args.push('--effort', spec.effort)
+    return args
+}
+
+function mcpConfig(url: string): string {
+    return `${JSON.stringify({
+        mcpServers: {
+            pi: { type: 'http', url, timeout: 86_400_000 }
+        }
+    })}\n`
+}
+
+export class ClaudeProcess {
+    readonly spec: ClaudeSpec
+    private readonly queue = new EventQueue()
+    private child?: ChildProcessWithoutNullStreams
+    private dir?: string
+    private stderrText = ''
+    private exited?: Promise<void>
+    private dead = false
+    private requests = 0
+
+    constructor(spec: ClaudeSpec) {
+        this.spec = spec
+    }
+
+    async start(first: CliBlock[]): Promise<void> {
+        try {
+            const dir = await mkdtemp(join(tmpdir(), 'pi-claude-'))
+            this.dir = dir
+            const promptPath = join(dir, 'system-prompt.txt')
+            const mcpPath = join(dir, 'mcp.json')
+            await writeFile(promptPath, this.spec.systemPrompt, 'utf8')
+            await writeFile(mcpPath, mcpConfig(this.spec.mcpUrl), 'utf8')
+
+            const child = spawn(this.spec.bin, spawnArgs(this.spec, promptPath, mcpPath), {
+                cwd: this.spec.cwd,
+                env: childEnv(this.spec),
+                stdio: ['pipe', 'pipe', 'pipe']
+            })
+            this.child = child
+            this.exited = new Promise((resolve) => {
+                child.once('exit', () => resolve())
+                child.once('error', () => resolve())
+            })
+            child.once('error', (error) => {
+                this.dead = true
+                this.stderrText = `${this.stderrText}\n${error.message}`.trim()
+                this.queue.close()
+            })
+            child.once('exit', () => {
+                this.dead = true
+                this.queue.close()
+            })
+            child.stdin.on('error', () => {
+                this.dead = true
+                this.queue.close()
+            })
+            child.stderr.setEncoding('utf8')
+            child.stderr.on('data', (chunk: string) => {
+                this.stderrText = (this.stderrText + chunk).slice(-8000)
+            })
+            const lines = createInterface({ input: child.stdout })
+            lines.on('line', (line: string) => {
+                if (!line.startsWith('{')) return
+                try {
+                    const event = jsonObject(JSON.parse(line))
+                    if (event) this.queue.push(event)
+                } catch {
+                    // A malformed line is not part of the stream contract; the next one may be.
+                }
+            })
+            this.sendUser(first)
+            await this.waitForInit()
+        } catch (error) {
+            await this.close()
+            throw error
+        }
+    }
+
+    private async waitForInit(): Promise<void> {
+        const deadline = Date.now() + INIT_TIMEOUT_MS
+        for (;;) {
+            const remaining = deadline - Date.now()
+            if (remaining <= 0)
+                throw new Error(`Claude Code did not start within ${INIT_TIMEOUT_MS}ms${this.stderrSuffix()}`)
+            let event: JsonObject | undefined
+            try {
+                event = await this.queue.next(AbortSignal.timeout(remaining))
+            } catch {
+                throw new Error(`Claude Code did not start within ${INIT_TIMEOUT_MS}ms${this.stderrSuffix()}`)
+            }
+            if (!event) throw new Error(`Claude Code exited during startup${this.stderrSuffix()}`)
+            if (!isInitSchema(event)) continue
+            const init = event
+            const servers = init.mcp_servers
+            if (!servers) return
+            let connected = false
+            for (const server of servers) {
+                const object = jsonObject(server)
+                if (!object || jsonText(object, 'name') !== 'pi') continue
+                connected = true
+                const status = jsonText(object, 'status')
+                if (status && /failed|error|disconnect/i.test(status)) {
+                    throw new Error(`Claude Code could not connect the Pi MCP server: ${status}${this.stderrSuffix()}`)
+                }
+            }
+            if (!connected) throw new Error(`Claude Code did not connect the Pi MCP server${this.stderrSuffix()}`)
+            return
+        }
+    }
+
+    sendUser(content: CliBlock[]): void {
+        if (!this.child || this.dead) throw new Error(`Claude Code is not running${this.stderrSuffix()}`)
+        const message = { type: 'user', message: { role: 'user', content }, parent_tool_use_id: null }
+        this.child.stdin.write(`${JSON.stringify(message)}\n`)
+    }
+
+    next(signal?: AbortSignal): Promise<JsonObject | undefined> {
+        return this.queue.next(signal)
+    }
+
+    isDead(): boolean {
+        return this.dead
+    }
+
+    stderrTail(): string {
+        return this.stderrText.trim()
+    }
+
+    private stderrSuffix(): string {
+        const tail = this.stderrTail()
+        return tail ? `\n${tail}` : ''
+    }
+
+    interrupt(): void {
+        if (!this.child || this.dead) return
+        this.requests += 1
+        const message = {
+            type: 'control_request',
+            request_id: `pi-${this.requests}`,
+            request: { subtype: 'interrupt' }
+        }
+        this.child.stdin.write(`${JSON.stringify(message)}\n`)
+    }
+
+    async close(): Promise<void> {
+        const child = this.child
+        this.child = undefined
+        this.dead = true
+        this.queue.close()
+        if (child) {
+            if (!child.stdin.destroyed) child.stdin.end()
+            child.kill('SIGINT')
+            await Promise.race([this.exited, new Promise((resolve) => setTimeout(resolve, 2000))])
+            if (child.exitCode === null && child.signalCode === null) child.kill('SIGKILL')
+        }
+        if (this.dir) {
+            const dir = this.dir
+            this.dir = undefined
+            await rm(dir, { recursive: true, force: true }).catch(() => undefined)
+        }
+    }
+}
+
+export function jsonEventType(event: JsonObject): string | undefined {
+    return jsonText(event, 'type')
+}
+
+export function jsonEventSubtype(event: JsonObject): string | undefined {
+    return jsonText(event, 'subtype')
+}
+
+export function jsonEventArray(event: JsonObject, key: string): JsonValue[] | undefined {
+    return jsonArray(event[key])
+}
+
+export function claudeBin(): string {
+    const value = process.env['PI_CLAUDE_BIN']
+    return value && value.length > 0 ? value : 'claude'
+}