@tduyng/pi-opencode-z 0.0.0-stage → 0.0.1

package/src/session.ts

@@ -0,0 +1,191 @@
+import { createHash, randomBytes } from 'node:crypto'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import type { Message, Tool } from '@earendil-works/pi-ai'
+
+import { api } from './client.js'
+import type { JsonObject, McpResult } from './mcp.js'
+
+export const MCP_SERVER_NAME = 'pi'
+export const TOOL_PREFIX = `${MCP_SERVER_NAME}_`
+export const BRIDGE_AGENT = 'pi'
+
+const MCP_EXECUTION_TIMEOUT_MS = 300_000
+
+export type ParkedCall = {
+    name: string
+    args: JsonObject
+    resolve(result: McpResult): void
+}
+
+export type TokenTotals = { input: number; output: number; cacheRead: number; cacheWrite: number }
+
+export type BridgeSession = {
+    token: string
+    dir?: string
+    opencodeSessionId?: string
+    retiredOpencodeIds: Set<string>
+    modelId?: string
+    variant?: string
+    systemPrompt?: string
+    toolsKey?: string
+    syncedCount: number
+    fingerprints: string[]
+    tools: Tool[]
+    parked: Map<string, ParkedCall>
+    answeredPermissions: Set<string>
+    refusedTools: string[]
+    lateUsage: TokenTotals
+    latestStep: TokenTotals
+}
+
+export type BridgeSessionStore = { sessions: Map<string, BridgeSession> }
+
+export function createSessionStore(): BridgeSessionStore {
+    return { sessions: new Map() }
+}
+
+export function bridgeSession(store: BridgeSessionStore, piSessionId: string): BridgeSession {
+    const existing = store.sessions.get(piSessionId)
+    if (existing) return existing
+
+    const created: BridgeSession = {
+        token: randomBytes(12).toString('hex'),
+        retiredOpencodeIds: new Set(),
+        syncedCount: 0,
+        fingerprints: [],
+        tools: [],
+        parked: new Map(),
+        answeredPermissions: new Set(),
+        refusedTools: [],
+        lateUsage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        latestStep: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 }
+    }
+    store.sessions.set(piSessionId, created)
+    return created
+}
+
+export function allSessions(store: BridgeSessionStore): BridgeSession[] {
+    return [...store.sessions.values()]
+}
+
+export function findByOpencodeId(store: BridgeSessionStore, opencodeSessionId: string): BridgeSession | undefined {
+    for (const session of store.sessions.values()) {
+        if (session.opencodeSessionId === opencodeSessionId) return session
+        if (session.retiredOpencodeIds.has(opencodeSessionId)) return session
+    }
+    return undefined
+}
+
+export function messageFingerprint(message: Message): string {
+    const value =
+        message.role === 'toolResult'
+            ? [message.role, message.toolCallId, message.toolName, message.isError, message.content]
+            : [message.role, message.content]
+    return createHash('sha256').update(JSON.stringify(value)).digest('base64url')
+}
+
+export function toolsKey(tools: Tool[] | undefined): string {
+    return JSON.stringify(
+        (tools ?? []).map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters
+        }))
+    )
+}
+
+const AGENT_SYSTEM = [
+    'You are the model behind the Pi coding agent.',
+    '',
+    'Pi tools are MCP tools named pi_*. Call the exact declared name, such as pi_read or pi_bash. A functions. namespace label does not rename a tool.',
+    'OpenCode built-ins such as read, edit, write, bash, glob and grep are disabled. Use their pi_ counterparts instead.',
+    'Your working directory is not the project. Put project paths in pi_ tool arguments.',
+    'Answer in plain prose when no tool is needed.'
+].join('\n')
+
+function bridgeConfig(mcpUrl: string): string {
+    return `${JSON.stringify(
+        {
+            mcp: {
+                timeout: { startup: 15_000, catalog: 15_000, execution: MCP_EXECUTION_TIMEOUT_MS },
+                servers: {
+                    [MCP_SERVER_NAME]: {
+                        type: 'remote',
+                        url: mcpUrl,
+                        codemode: false,
+                        timeout: { execution: MCP_EXECUTION_TIMEOUT_MS }
+                    }
+                }
+            },
+            agents: {
+                [BRIDGE_AGENT]: {
+                    description: 'Pi bridge',
+                    mode: 'primary',
+                    system: AGENT_SYSTEM,
+                    permissions: [
+                        { action: '*', resource: '*', effect: 'ask' },
+                        { action: `${TOOL_PREFIX}*`, resource: '*', effect: 'allow' }
+                    ]
+                }
+            }
+        },
+        null,
+        2
+    )}\n`
+}
+
+export async function ensureProjectDir(session: BridgeSession, mcpUrl: string): Promise<string> {
+    if (session.dir) return session.dir
+
+    const dir = await mkdtemp(join(tmpdir(), 'pi-opencode-z-'))
+    await writeFile(join(dir, 'opencode.jsonc'), bridgeConfig(mcpUrl), 'utf8')
+    session.dir = dir
+    return dir
+}
+
+export async function resetOpencodeSession(session: BridgeSession): Promise<void> {
+    const id = session.opencodeSessionId
+    session.opencodeSessionId = undefined
+    if (id) {
+        session.retiredOpencodeIds.add(id)
+        await api('DELETE', `/api/session/${id}`).catch(() => undefined)
+    }
+    session.modelId = undefined
+    session.variant = undefined
+    session.systemPrompt = undefined
+    session.toolsKey = undefined
+    session.syncedCount = 0
+    session.fingerprints = []
+    session.refusedTools = []
+    releaseParked(session, 'The bridge restarted this session; the call was dropped.')
+}
+
+export function releaseParked(session: BridgeSession, reason: string): void {
+    for (const call of session.parked.values()) {
+        call.resolve({ content: [{ type: 'text', text: reason }], isError: true })
+    }
+    session.parked.clear()
+}
+
+export async function disposeSession(
+    store: BridgeSessionStore,
+    piSessionId: string,
+    unregister: (token: string) => void
+): Promise<void> {
+    const session = store.sessions.get(piSessionId)
+    if (!session) return
+    store.sessions.delete(piSessionId)
+    unregister(session.token)
+    releaseParked(session, 'The Pi session ended.')
+    if (session.opencodeSessionId) {
+        await api('DELETE', `/api/session/${session.opencodeSessionId}`).catch(() => undefined)
+    }
+    if (session.dir) await rm(session.dir, { recursive: true, force: true }).catch(() => undefined)
+}
+
+export async function disposeAll(store: BridgeSessionStore, unregister: (token: string) => void): Promise<void> {
+    await Promise.all([...store.sessions.keys()].map((id) => disposeSession(store, id, unregister)))
+}