@straiffi/archon 1.11.14 → 1.11.16

package/dist/server/lib/opencodeApprovalTransport.js

@@ -0,0 +1,713 @@
+import { PassThrough } from 'node:stream';
+import { StringDecoder } from 'node:string_decoder';
+// Runs in the execution guest, not the Archon host. Only JSON frames cross stdio;
+// the per-run Basic auth secret never appears in arguments, logs or relay frames.
+// Keep this self-contained: sandbox launchers do not mount Archon's server files.
+const GUEST_RELAY = String.raw `
+const { spawn } = await import('node:child_process');
+const { randomBytes } = await import('node:crypto');
+const { createInterface } = await import('node:readline');
+const { resolve, basename, extname } = await import('node:path');
+const { pathToFileURL } = await import('node:url');
+const { stat } = await import('node:fs/promises');
+const major = Number(process.argv[1]);
+const password = randomBytes(32).toString('hex');
+const headers = { authorization: 'Basic ' + Buffer.from('opencode:' + password).toString('base64'), 'content-type': 'application/json' };
+const send = value => process.stdout.write(JSON.stringify(value) + '\n');
+if (typeof fetch !== 'function') {
+  send({ kind: 'failure', error: 'OpenCode approval streaming requires guest Node.js 18 or newer with built-in fetch.' });
+  process.exit(1);
+}
+let runtimeConfig;
+try {
+  const config = JSON.parse(process.env.OPENCODE_CONFIG_CONTENT || '{}');
+  const rules = JSON.parse(process.argv[2]);
+  const permissionObject = value => typeof value === 'string' ? { '*': value } : { ...value };
+  if (major === 1) {
+    const permission = permissionObject(config.permission);
+    for (const rule of rules) {
+      if (rule.permission === 'question') {
+        permission.question = rule.action;
+        continue;
+      }
+      const patterns = permissionObject(permission[rule.permission]);
+      patterns[rule.pattern] = rule.action;
+      permission[rule.permission] = patterns;
+    }
+    const agents = { ...config.agent };
+    agents.plan = { ...agents.plan, permission: { ...permissionObject(agents.plan?.permission), edit: 'deny', question: 'deny' } };
+    runtimeConfig = { ...config, permission, agent: agents };
+  } else {
+    const agents = { ...config.agents };
+    agents.plan = { ...agents.plan, permissions: [...agents.plan?.permissions || [], { action: 'edit', resource: '*', effect: 'deny' }, { action: 'question', resource: '*', effect: 'deny' }] };
+    runtimeConfig = { ...config, permissions: [...config.permissions || [], ...rules], agents };
+  }
+} catch (error) {
+  send({ kind: 'failure', error: 'Cannot configure OpenCode runtime permissions: ' + error.message });
+  process.exit(1);
+}
+let endpoint;
+let closing = false;
+let eventAbort;
+let killTimer;
+const server = spawn('opencode', ['serve', '--hostname', '127.0.0.1', '--port', '0'], {
+  env: { ...process.env, OPENCODE_SERVER_USERNAME: 'opencode', OPENCODE_SERVER_PASSWORD: password, OPENCODE_CONFIG_CONTENT: JSON.stringify(runtimeConfig) },
+  stdio: ['ignore', 'pipe', 'pipe'],
+});
+const stop = code => {
+  if (closing) {
+    return;
+  }
+  closing = true;
+  process.exitCode = code;
+  eventAbort?.abort();
+  server.kill('SIGTERM');
+  killTimer = setTimeout(() => server.kill('SIGKILL'), 2000);
+};
+server.on('error', error => {
+  send({ kind: 'failure', error: error.message });
+  stop(1);
+});
+server.on('close', code => {
+  clearTimeout(killTimer);
+  if (!closing) {
+    send({ kind: 'failure', error: 'OpenCode server exited with code ' + code });
+  }
+  process.exit(closing ? process.exitCode || 0 : 1);
+});
+// Both releases print their listening URL. Only trust an explicit loopback URL.
+let startup = '';
+const observe = chunk => {
+  startup = (startup + chunk.toString()).slice(-65536);
+  const match = startup.match(/http:\/\/127\.0\.0\.1:(\d+)/);
+  if (!endpoint && match) {
+    endpoint = 'http://127.0.0.1:' + match[1];
+    void fetch(endpoint + (major === 2 ? '/api/info' : '/session'), {
+      signal: AbortSignal.timeout(5000), redirect: 'error',
+    }).then(response => {
+      if (response.status !== 401) {
+        throw new Error('OpenCode server does not enforce per-run HTTP authentication');
+      }
+      send({ kind: 'listening', major, directory: process.cwd() });
+    }).catch(error => {
+      send({ kind: 'failure', error: error.message });
+      stop(1);
+    });
+  }
+};
+server.stdout.on('data', observe);
+server.stderr.on('data', chunk => {
+  observe(chunk);
+  process.stderr.write(chunk);
+});
+const http = async (path, method, body, signal) => {
+  if (!endpoint) {
+    throw new Error('OpenCode server is not listening');
+  }
+  const response = await fetch(endpoint + path, {
+    method, headers, body: body === undefined ? undefined : JSON.stringify(body),
+    signal: signal || AbortSignal.timeout(30000), redirect: 'error',
+  });
+  if (!response.ok) {
+    throw new Error('OpenCode HTTP ' + response.status + ': ' + (await response.text()).slice(0, 4096));
+  }
+  return response;
+};
+const subscribe = async () => {
+  eventAbort = new AbortController();
+  const response = await http(major === 2 ? '/api/event' : '/event', 'GET', undefined, eventAbort.signal);
+  if (!response.body || !response.headers.get('content-type')?.includes('text/event-stream')) {
+    throw new Error('OpenCode server does not support the expected SSE API');
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let connected = false;
+  while (!closing) {
+    const { done, value } = await reader.read();
+    if (done) {
+      throw new Error('OpenCode event stream disconnected');
+    }
+    buffer += decoder.decode(value, { stream: true });
+    buffer = buffer.replace(/\r\n/g, '\n');
+    let end;
+    while ((end = buffer.indexOf('\n\n')) >= 0) {
+      const frame = buffer.slice(0, end);
+      buffer = buffer.slice(end + 2);
+      const data = frame.split('\n').filter(line => line.startsWith('data:')).map(line => line.slice(5).trimStart()).join('\n');
+      if (!data) {
+        continue;
+      }
+      let event = JSON.parse(data);
+      // Effect's v2 encoded event schema can be JSON nested inside an SSE JSON string.
+      if (typeof event === 'string') {
+        event = JSON.parse(event);
+      }
+      if (event.type === 'server.connected' && !connected) {
+        connected = true;
+        send({ kind: 'subscribed' });
+      } else {
+        send({ kind: 'event', event });
+      }
+    }
+    if (buffer.length > 16 * 1024 * 1024) {
+      throw new Error('OpenCode SSE frame exceeds transport limit');
+    }
+  }
+};
+const input = createInterface({ input: process.stdin });
+input.on('line', line => {
+  void (async () => {
+    const frame = JSON.parse(line);
+    if (frame.kind === 'stop') {
+      stop(frame.code || 0);
+      return;
+    }
+    if (frame.kind === 'subscribe') {
+      void subscribe().catch(error => {
+        if (!closing) {
+          send({ kind: 'failure', error: error.message });
+          stop(1);
+        }
+      });
+      return;
+    }
+    try {
+      let value;
+      if (frame.kind === 'files') {
+        value = await Promise.all(frame.files.map(async file => {
+          const path = resolve(file);
+          const info = await stat(path);
+          const mime = info.isDirectory() ? 'application/x-directory' : ({ '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.webp': 'image/webp', '.pdf': 'application/pdf' }[extname(path).toLowerCase()] || 'text/plain');
+          return { type: 'file', url: pathToFileURL(path).href, filename: basename(path), mime };
+        }));
+      } else {
+        const response = await http(frame.path, frame.method || 'GET', frame.body);
+        const text = await response.text();
+        value = text ? JSON.parse(text) : null;
+      }
+      send({ kind: 'response', id: frame.id, value });
+    } catch (error) {
+      send({ kind: 'response', id: frame.id, error: error.message });
+    }
+  })().catch(error => {
+    send({ kind: 'failure', error: error.message });
+    stop(1);
+  });
+});
+input.on('close', () => stop(0));
+process.on('SIGTERM', () => stop(0));
+process.on('SIGINT', () => stop(0));
+`;
+export const buildOpencodeSessionPermissionRules = (major, _mode) => {
+    const rules = [
+        { permission: 'read', pattern: '*.env', action: 'ask' },
+        { permission: 'read', pattern: '*.env.*', action: 'ask' },
+        { permission: 'external_directory', pattern: '*', action: 'ask' },
+        { permission: 'question', pattern: '*', action: 'deny' },
+    ];
+    return major === 1 ? rules : rules.map(rule => ({ action: rule.permission, resource: rule.pattern, effect: rule.action }));
+};
+export const buildOpencodeApprovalInvocation = (compatibility, mode) => ({
+    command: 'node',
+    args: ['--input-type=module', '-e', GUEST_RELAY, String(compatibility.runtimeIdentity.major), JSON.stringify([
+            ...buildOpencodeSessionPermissionRules(compatibility.runtimeIdentity.major, mode),
+            // Plan edits are invocation-scoped. Never leave this deny in durable session rules.
+            ...(mode === 'plan' ? [compatibility.runtimeIdentity.major === 1
+                    ? { permission: 'edit', pattern: '*', action: 'deny' }
+                    : { action: 'edit', resource: '*', effect: 'deny' }] : []),
+        ])],
+    stdio: ['pipe', 'pipe', 'pipe'],
+    stdin: null,
+    sessionId: null,
+});
+const object = (value) => (value !== null && typeof value === 'object' && !Array.isArray(value) ? value : {});
+const text = (value) => typeof value === 'string' ? value : '';
+const deferred = () => {
+    let resolve;
+    let reject;
+    const promise = new Promise((yes, no) => { resolve = yes; reject = no; });
+    // Callers currently observe sessionReady but not always ready.
+    void promise.catch(() => { });
+    return { promise, resolve, reject };
+};
+export const connectOpencodeStreamingInvocation = (child, request, _context) => {
+    if (!request.opencodeApprovalContext) {
+        return {
+            stdout: child.stdout,
+            // Let orchestration use its original placement-aware process interrupt.
+            interrupt: async () => { throw new Error('Use the CLI execution handle to interrupt this invocation.'); },
+            sessionReady: Promise.resolve(request.resumeSessionId ?? ''),
+            ready: Promise.resolve(request.resumeSessionId ?? ''),
+        };
+    }
+    if (!child.stdin || !child.stdout) {
+        child.kill('SIGTERM');
+        throw new Error('OpenCode approval transport requires guest Node.js with piped stdin/stdout.');
+    }
+    return connectOpencodeApprovalTransport(child, request);
+};
+const loadBroker = () => {
+    const modulePath = './opencodeToolApprovals.js';
+    return import(modulePath);
+};
+export const connectOpencodeApprovalTransport = (child, request, approvalBroker = loadBroker()) => {
+    const stdout = new PassThrough();
+    const session = deferred();
+    const ready = deferred();
+    const subscribed = deferred();
+    const pending = new Map();
+    const approvals = new Set();
+    const seenApprovals = new Set();
+    const nativelySettled = new Set();
+    const replying = new Set();
+    const reconciling = new Set();
+    const sessions = new Set();
+    const emitted = new Map();
+    const tools = new Map();
+    const roles = new Map();
+    const bufferedParts = new Map();
+    const decoder = new StringDecoder('utf8');
+    let sequence = 0;
+    let remainder = '';
+    let nativeSessionId = request.resumeSessionId ?? '';
+    let nativeDirectory = request.cwd;
+    let stopped = false;
+    let closing = false;
+    let promptStarted = false;
+    let active = false;
+    let admitted = false;
+    let idlePending = false;
+    let v2ReplyField = null;
+    let major = request.opencodeCompatibility?.runtimeIdentity.major ?? request.opencodeRuntimeIdentity?.major;
+    const context = request.opencodeApprovalContext;
+    const mode = request.mode ?? 'build';
+    const broker = approvalBroker;
+    void broker.catch(error => finish(error instanceof Error ? error : new Error(String(error))));
+    const write = (frame) => {
+        if (!stopped) {
+            child.stdin.write(`${JSON.stringify(frame)}\n`);
+        }
+    };
+    const rpc = (frame) => {
+        if (stopped || (closing && !/\/(abort|interrupt)$/.test(text(frame.path)))) {
+            return Promise.reject(new Error('OpenCode transport is closed.'));
+        }
+        const result = deferred();
+        const id = ++sequence;
+        pending.set(id, result);
+        write({ ...frame, id });
+        return result.promise;
+    };
+    const api = (path, body, method = body === undefined ? 'GET' : 'POST') => rpc({ path, body, method });
+    const emit = (type, part, error, sessionID = nativeSessionId) => {
+        stdout.write(`${JSON.stringify({ type, timestamp: Date.now(), sessionID, ...(part ? { part } : {}), ...(error ? { error } : {}) })}\n`);
+    };
+    const cancel = (reason) => {
+        void broker.then(module => module.cancelOpencodeToolApprovals(context, reason)).catch(() => { });
+    };
+    const finish = (error) => {
+        if (stopped) {
+            return;
+        }
+        closing = true;
+        cancel(error?.message ?? 'OpenCode invocation completed.');
+        if (error) {
+            emit('error', undefined, { name: 'TransportError', data: { message: error.message } });
+            session.reject(error);
+            ready.reject(error);
+        }
+        subscribed.reject(error ?? new Error('OpenCode invocation completed.'));
+        write({ kind: 'stop', code: error ? 1 : 0 });
+        stopped = true;
+        clearTimeout(startupTimeout);
+        for (const result of pending.values()) {
+            result.reject(error ?? new Error('OpenCode transport is closed.'));
+        }
+        pending.clear();
+        stdout.end();
+    };
+    const startupTimeout = setTimeout(() => finish(new Error('OpenCode approval server did not become ready within 30 seconds.')), 30_000);
+    const finishIfIdle = () => {
+        if (!closing && admitted && idlePending && approvals.size === 0 && replying.size === 0 && reconciling.size === 0) {
+            finish();
+        }
+    };
+    const emitPart = (part) => {
+        const type = text(part.type);
+        const key = `${text(part.sessionID)}:${text(part.id)}`;
+        const state = object(part.state);
+        if (type === 'text' || type === 'reasoning') {
+            // Match CLI output: one completed full-value part, not cumulative snapshots.
+            if (!object(part.time).end) {
+                return;
+            }
+        }
+        else if (type === 'tool' && state.status !== 'completed' && state.status !== 'error') {
+            return;
+        }
+        const normalized = { ...part, ...(type === 'tool' ? { title: state.title ?? part.title } : {}) };
+        const fingerprint = JSON.stringify(normalized);
+        if (emitted.get(key) === fingerprint) {
+            return;
+        }
+        const eventType = { 'step-start': 'step_start', 'step-finish': 'step_finish', tool: 'tool_use', text: 'text', reasoning: 'reasoning' }[type];
+        if (eventType) {
+            emitted.set(key, fingerprint);
+            emit(eventType, normalized, undefined, text(part.sessionID));
+        }
+    };
+    const consume = (input) => {
+        if (stopped || closing) {
+            return;
+        }
+        let event = object(input);
+        if (event.payload) {
+            event = object(event.payload);
+        }
+        // v2.0.7 uses session.*; older compatibility bridges used session.next.*.
+        const type = text(event.type).replace(/^session\.next\./, 'session.');
+        if (major !== 2 && /^session\.(?:next\.|text\.|reasoning\.|step\.|tool\.|execution\.)/.test(text(event.type))) {
+            return;
+        }
+        const data = object(event.properties ?? event.data);
+        const part = object(data.part);
+        const sid = text(data.sessionID ?? part.sessionID ?? object(data.info).sessionID);
+        if (type === 'session.created') {
+            const info = object(data.info ?? data);
+            if (sessions.has(text(info.parentID))) {
+                sessions.add(text(info.id ?? info.sessionID));
+            }
+        }
+        if (!sessions.has(sid)) {
+            return;
+        }
+        if (type === 'permission.replied' || type === 'permission.v2.replied') {
+            const id = text(data.requestID);
+            const reply = data.reply;
+            if (!id || nativelySettled.has(id) || !['once', 'always', 'reject'].includes(text(reply))) {
+                return;
+            }
+            nativelySettled.add(id);
+            seenApprovals.add(id);
+            reconciling.add(id);
+            void broker.then(module => module.settleOpencodeToolApproval(context, sid, id, reply)).then(() => {
+                reconciling.delete(id);
+                if (!replying.has(id)) {
+                    approvals.delete(id);
+                }
+                finishIfIdle();
+            }).catch(error => finish(error instanceof Error ? error : new Error(String(error))));
+            return;
+        }
+        if (type === 'permission.asked' || type === 'permission.v2.asked') {
+            const id = text(data.id);
+            if (!id || seenApprovals.has(id)) {
+                return;
+            }
+            const nativeV2 = major === 2 || type === 'permission.v2.asked';
+            const patterns = stringArray(data.patterns ?? data.resources);
+            const grantPatterns = stringArray(data.always);
+            const sessionScope = !nativeV2 && grantPatterns.length > 0 && samePatterns(patterns, grantPatterns);
+            seenApprovals.add(id);
+            approvals.add(id);
+            void broker.then(module => {
+                if (closing || stopped || nativelySettled.has(id)) {
+                    return undefined;
+                }
+                return module.requestOpencodeToolApproval(context, {
+                    nativeRequestId: id,
+                    nativeSessionId: sid,
+                    permission: text(data.permission ?? data.action),
+                    patterns,
+                    metadata: object(data.metadata),
+                    supportedScopes: sessionScope ? ['once', 'session'] : ['once'],
+                });
+            }).then(async (reply) => {
+                if (closing || stopped || nativelySettled.has(id) || !reply) {
+                    return;
+                }
+                if (!sessionScope && reply === 'always') {
+                    throw new Error('OpenCode native grant patterns do not support this session-scoped approval.');
+                }
+                if (nativeV2 && !v2ReplyField) {
+                    throw new Error('OpenCode server does not expose a supported v2 permission reply schema.');
+                }
+                replying.add(id);
+                try {
+                    await api(nativeV2
+                        ? `/api/session/${encodeURIComponent(sid)}/permission/${encodeURIComponent(id)}/reply`
+                        : `/permission/${encodeURIComponent(id)}/reply`, nativeV2 ? { [v2ReplyField]: reply } : { reply });
+                }
+                catch (error) {
+                    if (!nativelySettled.has(id)) {
+                        throw error;
+                    }
+                }
+                finally {
+                    replying.delete(id);
+                }
+                approvals.delete(id);
+                finishIfIdle();
+            }).catch(error => finish(error instanceof Error ? error : new Error(String(error))));
+            return;
+        }
+        if (type === 'session.execution.started') {
+            active = true;
+            idlePending = false;
+            return;
+        }
+        if (type === 'session.execution.succeeded' || type === 'session.execution.failed' || type === 'session.execution.interrupted') {
+            if (type !== 'session.execution.succeeded') {
+                emit('error', undefined, data.error ?? { message: 'OpenCode execution interrupted.' }, sid);
+            }
+            if (sid === nativeSessionId) {
+                idlePending = true;
+                finishIfIdle();
+            }
+            return;
+        }
+        if (type === 'session.error' || type === 'session.step.failed') {
+            active = true;
+            emit('error', undefined, data.error, sid);
+            return;
+        }
+        if (sid === nativeSessionId && promptStarted && (type === 'session.status' || type === 'session.idle')) {
+            const idle = type === 'session.idle' || object(data.status).type === 'idle';
+            if (!idle) {
+                active = true;
+                idlePending = false;
+            }
+            else if (active) {
+                idlePending = true;
+                finishIfIdle();
+            }
+            return;
+        }
+        if (type === 'message.updated') {
+            if (major === 2) {
+                return;
+            }
+            const info = object(data.info);
+            const id = text(info.id);
+            roles.set(id, text(info.role));
+            if (sid === nativeSessionId && info.role === 'assistant') {
+                active = true;
+            }
+            for (const buffered of bufferedParts.get(id) ?? []) {
+                if (info.role === 'assistant') {
+                    emitPart(buffered);
+                }
+            }
+            bufferedParts.delete(id);
+            return;
+        }
+        if (type === 'message.part.updated') {
+            if (major === 2) {
+                return;
+            }
+            const id = text(part.messageID);
+            if (!roles.has(id)) {
+                bufferedParts.set(id, [...bufferedParts.get(id) ?? [], part]);
+            }
+            else if (roles.get(id) === 'assistant') {
+                emitPart(part);
+            }
+            return;
+        }
+        // v2 emits native semantic events rather than legacy message parts.
+        const toolId = text(data.callID ?? data.id);
+        const base = { id: text(data.textID ?? data.reasoningID ?? data.callID ?? data.id) || `${text(data.assistantMessageID)}:${type.split('.')[1]}:${data.ordinal ?? ''}`, sessionID: sid, messageID: data.assistantMessageID };
+        if (type === 'session.text.ended' || type === 'session.reasoning.ended') {
+            const kind = type.includes('.reasoning.') ? 'reasoning' : 'text';
+            emit(kind, { ...base, type: kind, text: data.text }, undefined, sid);
+        }
+        else if (type === 'session.step.started') {
+            active = true;
+            emit('step_start', { ...base, type: 'step-start' }, undefined, sid);
+        }
+        else if (type === 'session.step.ended') {
+            emit('step_finish', { ...base, type: 'step-finish', reason: data.finish, tokens: data.tokens, cost: data.cost }, undefined, sid);
+        }
+        else if (type === 'session.tool.input.started') {
+            tools.set(toolId, { ...base, type: 'tool', callID: toolId, tool: data.name, state: { status: 'pending', input: {} } });
+        }
+        else if (type === 'session.tool.called') {
+            tools.set(toolId, { ...tools.get(toolId), ...base, type: 'tool', callID: toolId, tool: data.tool ?? tools.get(toolId)?.tool, state: { status: 'running', input: data.input } });
+        }
+        else if (type === 'session.tool.success' || type === 'session.tool.failed') {
+            const tool = tools.get(toolId);
+            if (tool) {
+                const content = Array.isArray(data.content) ? data.content : [];
+                emit('tool_use', { ...tool, state: { ...object(tool.state), status: data.error ? 'error' : 'completed', error: data.error,
+                        output: content.map(item => text(object(item).text)).filter(Boolean).join('\n'), metadata: data.metadata ?? data.structured } }, undefined, sid);
+                tools.delete(toolId);
+            }
+        }
+    };
+    const start = async () => {
+        // Derive the observed API generation in-guest when caller uses cached host compatibility.
+        if (!major) {
+            try {
+                const health = object(await api('/global/health'));
+                major = text(health.version).startsWith('1.') ? 1 : undefined;
+            }
+            catch {
+                major = 2;
+            }
+        }
+        if (major !== 1 && major !== 2) {
+            throw new Error('OpenCode server returned an unsupported API version.');
+        }
+        write({ kind: 'subscribe' });
+        await subscribed.promise;
+        const model = resolveModel(request, major);
+        const root = major === 2 ? '/api/session' : '/session';
+        const spec = object(await api('/doc'));
+        const createProperties = operationProperties(spec, root, 'post');
+        const patchProperties = operationProperties(spec, `${root}/{sessionID}`, 'patch');
+        const permissionField = major === 1 ? 'permission' : 'permissions';
+        if (!(permissionField in createProperties) || !(permissionField in patchProperties)) {
+            throw new Error('OpenCode server does not support required create/PATCH session permission rules.');
+        }
+        const replyProperties = operationProperties(spec, '/api/session/{sessionID}/permission/{requestID}/reply', 'post');
+        v2ReplyField = 'decision' in replyProperties ? 'decision' : 'reply' in replyProperties ? 'reply' : null;
+        const rules = buildOpencodeSessionPermissionRules(major, mode);
+        const result = object(await api(nativeSessionId ? `${root}/${encodeURIComponent(nativeSessionId)}` : root, nativeSessionId ? undefined : { [permissionField]: rules, ...(major === 2 ? { location: { directory: nativeDirectory }, agent: mode, model } : {}) }));
+        const info = major === 2 ? object(result.data) : result;
+        nativeSessionId = text(info.id);
+        if (!nativeSessionId) {
+            throw new Error('OpenCode server did not return a native session ID.');
+        }
+        sessions.add(nativeSessionId);
+        const path = `${root}/${encodeURIComponent(nativeSessionId)}`;
+        if (request.resumeSessionId) {
+            const existing = info[permissionField];
+            if (existing !== undefined && existing !== null && !Array.isArray(existing)) {
+                throw new Error('OpenCode session returned malformed permission rules.');
+            }
+            // v1 PATCH appends natively; v2 replaces the permissions field.
+            await api(path, { [permissionField]: major === 1 ? rules : [...Array.isArray(existing) ? existing : [], ...rules] }, 'PATCH');
+        }
+        session.resolve(nativeSessionId);
+        if (major === 2 && request.resumeSessionId) {
+            await api(`${path}/agent`, { agent: mode });
+            if (model) {
+                await api(`${path}/model`, { model });
+            }
+        }
+        const files = await rpc({ kind: 'files', files: request.files ?? [] });
+        promptStarted = true;
+        await api(`${path}/${major === 2 ? 'prompt' : 'prompt_async'}`, major === 2
+            ? { text: request.prompt, files: files.map(file => ({ uri: file.url, name: file.filename })) }
+            : { agent: mode, model, variant: request.variant?.trim() || undefined, parts: [...files, { type: 'text', text: request.prompt }] });
+        clearTimeout(startupTimeout);
+        admitted = true;
+        ready.resolve(nativeSessionId);
+        finishIfIdle();
+    };
+    const onData = (chunk) => {
+        remainder += typeof chunk === 'string' ? chunk : decoder.write(chunk);
+        const lines = remainder.split('\n');
+        remainder = lines.pop() ?? '';
+        try {
+            for (const line of lines) {
+                if (!line.trim()) {
+                    continue;
+                }
+                const frame = object(JSON.parse(line));
+                if (frame.kind === 'listening') {
+                    if (typeof frame.directory === 'string' && frame.directory) {
+                        nativeDirectory = frame.directory;
+                    }
+                    if (frame.major === 1 || frame.major === 2) {
+                        if (major && major !== frame.major) {
+                            throw new Error('OpenCode relay API generation does not match the selected runtime.');
+                        }
+                        major = frame.major;
+                    }
+                    void start().catch(error => finish(error instanceof Error ? error : new Error(String(error))));
+                }
+                else if (frame.kind === 'subscribed') {
+                    subscribed.resolve();
+                }
+                else if (frame.kind === 'event') {
+                    consume(frame.event);
+                }
+                else if (frame.kind === 'response') {
+                    const result = pending.get(Number(frame.id));
+                    pending.delete(Number(frame.id));
+                    if (frame.error) {
+                        result?.reject(new Error(text(frame.error)));
+                    }
+                    else {
+                        result?.resolve(frame.value);
+                    }
+                }
+                else if (frame.kind === 'failure') {
+                    finish(new Error(text(frame.error)));
+                }
+            }
+        }
+        catch (error) {
+            finish(error instanceof Error ? error : new Error(String(error)));
+        }
+    };
+    child.stdout.on('data', onData);
+    child.stdout.once('end', () => finish(new Error('OpenCode relay disconnected.')));
+    child.once('error', error => finish(error));
+    child.once('close', () => finish(new Error('OpenCode relay closed.')));
+    child.stdin.on('error', error => finish(error));
+    return {
+        stdout,
+        ready: ready.promise,
+        sessionReady: session.promise,
+        interrupt: async () => {
+            if (stopped || closing) {
+                return;
+            }
+            closing = true;
+            cancel('OpenCode invocation stopped.');
+            try {
+                if (nativeSessionId) {
+                    await api(major === 2 ? `/api/session/${encodeURIComponent(nativeSessionId)}/interrupt` : `/session/${encodeURIComponent(nativeSessionId)}/abort`, {});
+                }
+            }
+            finally {
+                finish(new Error('OpenCode invocation stopped.'));
+            }
+        },
+    };
+};
+const stringArray = (value) => Array.isArray(value) ? value.filter((item) => typeof item === 'string') : [];
+const samePatterns = (left, right) => {
+    const a = new Set(left);
+    const b = new Set(right);
+    return a.size === b.size && [...a].every(pattern => b.has(pattern));
+};
+const operationProperties = (spec, path, method) => {
+    const operation = object(object(object(spec.paths)[path])[method]);
+    let schema = object(object(object(object(operation.requestBody).content)['application/json']).schema);
+    if (typeof schema.$ref === 'string') {
+        schema = object(object(object(spec.components).schemas)[schema.$ref.split('/').at(-1)]);
+    }
+    return object(schema.properties);
+};
+const resolveModel = (request, major) => {
+    const value = request.model?.trim();
+    if (!value) {
+        if (request.variant?.trim() && major === 2) {
+            throw new Error('OpenCode v2 variant selection requires a model.');
+        }
+        return undefined;
+    }
+    const slash = value.indexOf('/');
+    if (slash <= 0 || slash === value.length - 1) {
+        throw new Error('OpenCode model selection requires provider/model.');
+    }
+    const [id, suffix] = value.slice(slash + 1).split('#');
+    return major === 2
+        ? { providerID: value.slice(0, slash), id, ...(request.variant?.trim() || suffix ? { variant: request.variant?.trim() || suffix } : {}) }
+        : { providerID: value.slice(0, slash), modelID: id };
+};
+//# sourceMappingURL=opencodeApprovalTransport.js.map