@vibe-forge/tsconfigs 0.7.1 → 0.8.0

package/dist/packages/adapters/opencode/__tests__/session-runtime-stream.spec.js

@@ -0,0 +1,151 @@
+import { execFile, spawn } from 'node:child_process';
+import { describe, expect, it, vi } from 'vitest';
+import { createOpenCodeSession } from '#~/runtime/session.js';
+import { flushAsyncWork, makeCtx, makeErrorProc, makeProc, mockExecFileJsonResponses, registerRuntimeTestHooks } from './runtime-test-helpers';
+vi.mock('node:child_process', () => ({
+    spawn: vi.fn(),
+    execFile: vi.fn()
+}));
+const spawnMock = vi.mocked(spawn);
+const execFileMock = vi.mocked(execFile);
+describe('createOpenCodeSession stream runtime', () => {
+    registerRuntimeTestHooks();
+    it('emits init, message, and stop for a successful stream turn', async () => {
+        mockExecFileJsonResponses(execFileMock, [
+            { id: 'sess_1', title: 'Vibe Forge:session-1', updatedAt: '2026-03-26T00:00:00.000Z' }
+        ]);
+        spawnMock.mockImplementation(() => makeProc({ stdout: 'pong\n' }));
+        const events = [];
+        const { ctx, cacheStore } = makeCtx();
+        await createOpenCodeSession(ctx, {
+            type: 'create',
+            runtime: 'server',
+            sessionId: 'session-1',
+            description: 'Reply with exactly pong.',
+            onEvent: (event) => events.push(event)
+        });
+        await flushAsyncWork();
+        expect(spawnMock.mock.calls[0]?.[1]).toEqual([
+            'run',
+            '--format',
+            'json',
+            '--title',
+            'Vibe Forge:session-1',
+            '--dir',
+            '/tmp',
+            'Reply with exactly pong.'
+        ]);
+        expect(events.map(event => event.type)).toEqual(['init', 'message', 'stop']);
+        expect(events[1]).toMatchObject({ type: 'message', data: { role: 'assistant', content: 'pong' } });
+        expect(cacheStore.get('adapter.opencode.session')).toMatchObject({
+            opencodeSessionId: 'sess_1',
+            title: 'Vibe Forge:session-1'
+        });
+    });
+    it('reuses the cached OpenCode session id for later turns', async () => {
+        mockExecFileJsonResponses(execFileMock, [{
+                id: 'sess_1',
+                title: 'Vibe Forge:session-stream',
+                updatedAt: '2026-03-26T00:00:00.000Z'
+            }], [{ id: 'sess_1', title: 'Vibe Forge:session-stream', updatedAt: '2026-03-26T00:01:00.000Z' }]);
+        spawnMock
+            .mockImplementationOnce(() => makeProc({ stdout: 'first\n' }))
+            .mockImplementationOnce(() => makeProc({ stdout: 'second\n' }));
+        const events = [];
+        const { ctx } = makeCtx();
+        const session = await createOpenCodeSession(ctx, {
+            type: 'create',
+            runtime: 'server',
+            sessionId: 'session-stream',
+            description: 'first',
+            onEvent: (event) => events.push(event)
+        });
+        await flushAsyncWork();
+        session.emit({ type: 'message', content: [{ type: 'text', text: 'second' }] });
+        await flushAsyncWork();
+        expect(spawnMock.mock.calls[0]?.[1]).toContain('--title');
+        expect(spawnMock.mock.calls[1]?.[1]).toContain('--session');
+        expect(spawnMock.mock.calls[1]?.[1]).toContain('sess_1');
+        expect(events.filter(event => event.type === 'message')).toHaveLength(2);
+    });
+    it('does not start a turn until a message arrives when create has no description', async () => {
+        spawnMock.mockImplementation(() => makeProc({ stdout: 'later\n' }));
+        const events = [];
+        const { ctx } = makeCtx();
+        const session = await createOpenCodeSession(ctx, {
+            type: 'create',
+            runtime: 'server',
+            sessionId: 'session-empty-create',
+            onEvent: (event) => events.push(event)
+        });
+        await flushAsyncWork();
+        expect(spawnMock).not.toHaveBeenCalled();
+        expect(events).toEqual([expect.objectContaining({ type: 'init' })]);
+        mockExecFileJsonResponses(execFileMock, [
+            { id: 'sess_later', title: 'Vibe Forge:session-empty-create', updatedAt: '2026-03-26T00:00:00.000Z' }
+        ]);
+        session.emit({ type: 'message', content: [{ type: 'text', text: 'later' }] });
+        await flushAsyncWork();
+        expect(spawnMock).toHaveBeenCalledTimes(1);
+        expect(spawnMock.mock.calls[0]?.[1]).toContain('later');
+    });
+    it('retries without the cached session id when resume hits a missing session', async () => {
+        mockExecFileJsonResponses(execFileMock, [{
+                id: 'sess_new',
+                title: 'Vibe Forge:session-resume',
+                updatedAt: '2026-03-26T00:00:00.000Z'
+            }], [{ id: 'sess_new', title: 'Vibe Forge:session-resume', updatedAt: '2026-03-26T00:00:01.000Z' }]);
+        spawnMock
+            .mockImplementationOnce(() => makeProc({ stderr: 'Error: session not found\n', exitCode: 1 }))
+            .mockImplementationOnce(() => makeProc({ stdout: 'recovered\n' }));
+        const events = [];
+        const { ctx, cacheStore } = makeCtx({
+            cacheSeed: {
+                'adapter.opencode.session': {
+                    opencodeSessionId: 'sess_missing',
+                    title: 'Vibe Forge:session-resume'
+                }
+            }
+        });
+        await createOpenCodeSession(ctx, {
+            type: 'resume',
+            runtime: 'server',
+            sessionId: 'session-resume',
+            description: 'continue',
+            onEvent: (event) => events.push(event)
+        });
+        await flushAsyncWork();
+        expect(spawnMock.mock.calls[0]?.[1]).toContain('sess_missing');
+        expect(spawnMock.mock.calls[1]?.[1]).toContain('sess_new');
+        expect(events.some(event => event.type === 'exit')).toBe(false);
+        expect(events.some(event => event.type === 'stop')).toBe(true);
+        expect(cacheStore.get('adapter.opencode.session')).toMatchObject({
+            opencodeSessionId: 'sess_new',
+            title: 'Vibe Forge:session-resume'
+        });
+    });
+    it('emits exit when a stream turn fails before the child process starts cleanly', async () => {
+        spawnMock.mockImplementation(() => makeErrorProc(new Error('spawn failed')));
+        const events = [];
+        const { ctx } = makeCtx();
+        await createOpenCodeSession(ctx, {
+            type: 'create',
+            runtime: 'server',
+            sessionId: 'session-stream-error',
+            description: 'hello',
+            onEvent: (event) => events.push(event)
+        });
+        await flushAsyncWork();
+        expect(events).toEqual([
+            expect.objectContaining({ type: 'init' }),
+            expect.objectContaining({
+                type: 'error',
+                data: expect.objectContaining({
+                    message: 'spawn failed',
+                    fatal: true
+                })
+            }),
+            { type: 'exit', data: { exitCode: 1, stderr: 'spawn failed' } }
+        ]);
+    });
+});

package/dist/packages/adapters/opencode/src/adapter-config.d.ts

@@ -0,0 +1,19 @@
+export {};
+declare module '@vibe-forge/types' {
+    interface Cache {
+        'adapter.opencode.session': {
+            opencodeSessionId?: string;
+            title?: string;
+        };
+    }
+    interface AdapterMap {
+        opencode: {
+            agent?: string;
+            planAgent?: string | false;
+            titlePrefix?: string;
+            share?: boolean;
+            sessionListMaxCount?: number;
+            configContent?: Record<string, unknown>;
+        };
+    }
+}

package/dist/packages/adapters/opencode/src/adapter-config.js

@@ -0,0 +1 @@
+export {};

package/dist/packages/adapters/opencode/src/icon.d.ts

@@ -0,0 +1,2 @@
+export declare const adapterIcon: string;
+export declare const adapterDisplayName = "OpenCode";

package/dist/packages/adapters/opencode/src/icon.js

@@ -0,0 +1,16 @@
+const OPENCODE_ICON_SVG = `
+<svg height="1em" style="flex:none;line-height:1" viewBox="0 0 24 24" width="1em" xmlns="http://www.w3.org/2000/svg">
+  <rect width="24" height="24" rx="6" fill="#0F172A"></rect>
+  <path d="M12 3.25 4.75 7.5v9L12 20.75l7.25-4.25v-9L12 3.25Zm0 2.06 5.5 3.22-5.5 3.22-5.5-3.22L12 5.31Zm-6 4.97 5 2.93v5.46l-5-2.93v-5.4Zm7 8.39v-5.46l5-2.93v5.4l-5 2.99Z" fill="url(#opencode-fill)"></path>
+  <defs>
+    <linearGradient id="opencode-fill" x1="4.75" x2="19.25" y1="3.25" y2="20.75" gradientUnits="userSpaceOnUse">
+      <stop stop-color="#34D399"></stop>
+      <stop offset=".55" stop-color="#22C55E"></stop>
+      <stop offset="1" stop-color="#14B8A6"></stop>
+    </linearGradient>
+  </defs>
+</svg>
+`
+    .trim();
+export const adapterIcon = `data:image/svg+xml;utf8,${encodeURIComponent(OPENCODE_ICON_SVG)}`;
+export const adapterDisplayName = 'OpenCode';

package/dist/packages/adapters/opencode/src/index.d.ts

@@ -0,0 +1,3 @@
+import './adapter-config';
+declare const _default: import("@vibe-forge/types").Adapter;
+export default _default;

package/dist/packages/adapters/opencode/src/index.js

@@ -0,0 +1,8 @@
+import './adapter-config';
+import { defineAdapter } from '@vibe-forge/types';
+import { initOpenCodeAdapter } from './runtime/init';
+import { createOpenCodeSession } from './runtime/session';
+export default defineAdapter({
+    init: initOpenCodeAdapter,
+    query: createOpenCodeSession
+});

package/dist/packages/adapters/opencode/src/models.d.ts

@@ -0,0 +1,2 @@
+import type { AdapterBuiltinModel } from '@vibe-forge/types';
+export declare const builtinModels: AdapterBuiltinModel[];

package/dist/packages/adapters/opencode/src/models.js

@@ -0,0 +1,22 @@
+export const builtinModels = [
+    {
+        value: 'default',
+        title: 'default',
+        description: "Use OpenCode's configured default model"
+    },
+    {
+        value: 'openai/gpt-5',
+        title: 'openai/gpt-5',
+        description: 'OpenAI GPT-5 via the OpenAI provider'
+    },
+    {
+        value: 'anthropic/claude-sonnet-4-5',
+        title: 'anthropic/claude-sonnet-4-5',
+        description: 'Anthropic Claude Sonnet 4.5 via the Anthropic provider'
+    },
+    {
+        value: 'anthropic/claude-haiku-4-5',
+        title: 'anthropic/claude-haiku-4-5',
+        description: 'Anthropic Claude Haiku 4.5 via the Anthropic provider'
+    }
+];

package/dist/packages/adapters/opencode/src/paths.d.ts

@@ -0,0 +1,3 @@
+import type { AdapterCtx } from '@vibe-forge/types';
+export declare const toRealPath: (targetPath: string) => string;
+export declare const resolveOpenCodeBinaryPath: (env: AdapterCtx["env"]) => string;

package/dist/packages/adapters/opencode/src/paths.js

@@ -0,0 +1,24 @@
+import { existsSync, realpathSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, resolve } from 'node:path';
+const require = createRequire(import.meta.url ?? __filename);
+const adapterPackageDir = dirname(require.resolve('@vibe-forge/adapter-opencode/package.json'));
+export const toRealPath = (targetPath) => {
+    try {
+        return realpathSync(targetPath);
+    }
+    catch {
+        return targetPath;
+    }
+};
+export const resolveOpenCodeBinaryPath = (env) => {
+    const envPath = env.__VF_PROJECT_AI_ADAPTER_OPENCODE_CLI_PATH__;
+    if (typeof envPath === 'string' && envPath.trim() !== '') {
+        return envPath;
+    }
+    const bundledPath = resolve(adapterPackageDir, 'node_modules/.bin/opencode');
+    if (existsSync(bundledPath)) {
+        return toRealPath(bundledPath);
+    }
+    return 'opencode';
+};

package/dist/packages/adapters/opencode/src/runtime/common/agent.d.ts

@@ -0,0 +1,6 @@
+import type { AdapterQueryOptions } from '@vibe-forge/types';
+export declare const resolveOpenCodeAgent: (params: {
+    agent?: string;
+    planAgent?: string | false;
+    permissionMode?: AdapterQueryOptions["permissionMode"];
+}) => string | undefined;

package/dist/packages/adapters/opencode/src/runtime/common/agent.js

@@ -0,0 +1,7 @@
+export const resolveOpenCodeAgent = (params) => {
+    if (params.permissionMode !== 'plan')
+        return params.agent;
+    if (params.planAgent === false)
+        return params.agent;
+    return params.planAgent ?? params.agent ?? 'plan';
+};

package/dist/packages/adapters/opencode/src/runtime/common/inline-config.d.ts

@@ -0,0 +1,12 @@
+import type { AdapterQueryOptions, Config } from '@vibe-forge/types';
+export declare const buildInlineConfigContent: (params: {
+    baseConfigContent?: Record<string, unknown>;
+    adapterConfigContent?: Record<string, unknown>;
+    envConfigContent?: Record<string, unknown>;
+    permissionMode?: AdapterQueryOptions["permissionMode"];
+    tools?: AdapterQueryOptions["tools"];
+    mcpServers?: AdapterQueryOptions["mcpServers"];
+    availableMcpServers?: Config["mcpServers"];
+    systemPromptFile?: string;
+    providerConfig?: Record<string, unknown>;
+}) => Record<string, unknown>;

package/dist/packages/adapters/opencode/src/runtime/common/inline-config.js

@@ -0,0 +1,31 @@
+import { mapMcpServersToOpenCode } from './mcp';
+import { deepMerge } from './object-utils';
+import { mergePermissionNodes, normalizePermissionNode, rewritePermissionMode } from './permission-node';
+import { buildToolPermissionConfig, mapPermissionModeToOpenCode } from './permissions';
+import { buildToolConfig } from './tools';
+export const buildInlineConfigContent = (params) => {
+    const mergedBaseConfig = deepMerge(deepMerge(params.baseConfigContent ?? {}, params.envConfigContent ?? {}), params.adapterConfigContent ?? {});
+    const inheritedPermission = normalizePermissionNode(mergedBaseConfig.permission);
+    const hasToolFilter = (params.tools?.include?.length ?? 0) > 0 || (params.tools?.exclude?.length ?? 0) > 0;
+    const basePermission = params.permissionMode === 'dontAsk' || params.permissionMode === 'bypassPermissions'
+        ? rewritePermissionMode(inheritedPermission, params.permissionMode)
+        : mergePermissionNodes(inheritedPermission, mapPermissionModeToOpenCode(params.permissionMode));
+    const permission = params.permissionMode == null && !hasToolFilter
+        ? undefined
+        : mergePermissionNodes(basePermission, buildToolPermissionConfig(params.tools, basePermission));
+    const tools = buildToolConfig(params.tools);
+    const mcp = mapMcpServersToOpenCode(params.availableMcpServers, params.mcpServers);
+    const inheritedInstructions = Array.isArray(mergedBaseConfig.instructions)
+        ? mergedBaseConfig.instructions.filter((value) => typeof value === 'string' && value.trim() !== '')
+        : [];
+    const instructions = params.systemPromptFile == null
+        ? inheritedInstructions
+        : [...inheritedInstructions, params.systemPromptFile];
+    return deepMerge(mergedBaseConfig, {
+        ...(instructions.length > 0 ? { instructions } : {}),
+        ...(permission != null ? { permission } : {}),
+        ...(tools ? { tools } : {}),
+        ...(mcp ? { mcp } : {}),
+        ...(params.providerConfig ? { provider: params.providerConfig } : {})
+    });
+};

package/dist/packages/adapters/opencode/src/runtime/common/mcp.d.ts

@@ -0,0 +1,2 @@
+import type { AdapterQueryOptions, Config } from '@vibe-forge/types';
+export declare const mapMcpServersToOpenCode: (mcpServers: Config["mcpServers"] | undefined, selection: AdapterQueryOptions["mcpServers"]) => Record<string, Record<string, unknown>> | undefined;

package/dist/packages/adapters/opencode/src/runtime/common/mcp.js

@@ -0,0 +1,31 @@
+const filterMcpServers = (mcpServers, selection) => {
+    if (mcpServers == null)
+        return {};
+    const include = selection?.include != null && selection.include.length > 0
+        ? new Set(selection.include)
+        : undefined;
+    const exclude = new Set(selection?.exclude ?? []);
+    return Object.fromEntries(Object.entries(mcpServers).filter(([name]) => (include == null || include.has(name)) && !exclude.has(name)));
+};
+export const mapMcpServersToOpenCode = (mcpServers, selection) => {
+    const filtered = filterMcpServers(mcpServers, selection);
+    const result = {};
+    for (const [name, server] of Object.entries(filtered)) {
+        if ('url' in server) {
+            result[name] = {
+                type: 'remote',
+                url: server.url,
+                enabled: server.enabled ?? true,
+                ...(server.headers != null ? { headers: server.headers } : {})
+            };
+            continue;
+        }
+        result[name] = {
+            type: 'local',
+            command: [server.command, ...server.args],
+            enabled: server.enabled ?? true,
+            ...(server.env != null ? { environment: server.env } : {})
+        };
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+};

package/dist/packages/adapters/opencode/src/runtime/common/model.d.ts

@@ -0,0 +1,40 @@
+import type { ModelServiceConfig } from '@vibe-forge/types';
+export declare const resolveOpenCodeModel: (rawModel: string | undefined, modelServices: Record<string, ModelServiceConfig>) => {
+    cliModel: undefined;
+    providerConfig: undefined;
+} | {
+    cliModel: string;
+    providerConfig: undefined;
+} | {
+    cliModel: string;
+    providerConfig: {
+        [x: string]: {
+            npm: string;
+            name: string | undefined;
+            options: {
+                headers: Record<string, string>;
+                timeout?: number | undefined;
+                chunkTimeout?: number | undefined;
+                apiKey: string;
+                baseURL: string;
+            } | {
+                headers?: undefined;
+                timeout?: number | undefined;
+                chunkTimeout?: number | undefined;
+                apiKey: string;
+                baseURL: string;
+            };
+            models: {
+                [x: string]: {
+                    limit?: {
+                        output: number;
+                    } | undefined;
+                    options?: {
+                        maxOutputTokens: number;
+                    } | undefined;
+                    name: string;
+                };
+            };
+        };
+    };
+};

package/dist/packages/adapters/opencode/src/runtime/common/model.js

@@ -0,0 +1,97 @@
+import { asPlainRecord, normalizeStringRecord } from './object-utils';
+const normalizePositiveInteger = (value) => (typeof value === 'number' && Number.isFinite(value) && value > 0
+    ? Math.floor(value)
+    : undefined);
+const appendQueryParams = (baseURL, queryParams) => {
+    if (Object.keys(queryParams).length === 0)
+        return baseURL;
+    const url = new URL(baseURL);
+    for (const [key, value] of Object.entries(queryParams)) {
+        url.searchParams.set(key, value);
+    }
+    return url.toString();
+};
+const normalizeProviderBaseURL = (baseURL, npmPackage) => {
+    if (npmPackage === '@ai-sdk/openai-compatible')
+        return baseURL.replace(/\/chat\/completions\/?$/u, '');
+    if (npmPackage === '@ai-sdk/openai')
+        return baseURL.replace(/\/responses\/?$/u, '');
+    return baseURL;
+};
+const getProviderExtra = (service) => ({
+    ...asPlainRecord(asPlainRecord(service.extra)?.codex),
+    ...asPlainRecord(asPlainRecord(service.extra)?.opencode)
+});
+const inferProviderPackage = (service, providerExtra) => {
+    if (typeof providerExtra.npm === 'string' && providerExtra.npm.trim() !== '')
+        return providerExtra.npm;
+    const wireApi = typeof providerExtra.wireApi === 'string' ? providerExtra.wireApi : undefined;
+    return wireApi === 'responses' || service.apiBaseUrl.includes('/responses')
+        ? '@ai-sdk/openai'
+        : '@ai-sdk/openai-compatible';
+};
+export const resolveOpenCodeModel = (rawModel, modelServices) => {
+    const normalized = rawModel?.trim();
+    if (normalized == null || normalized === '' || normalized.toLowerCase() === 'default') {
+        return { cliModel: undefined, providerConfig: undefined };
+    }
+    if (!normalized.includes(',')) {
+        return { cliModel: normalized, providerConfig: undefined };
+    }
+    const commaIndex = normalized.indexOf(',');
+    const serviceKey = normalized.slice(0, commaIndex).trim();
+    const modelId = normalized.slice(commaIndex + 1).trim();
+    const service = modelServices[serviceKey];
+    if (!service || modelId === '') {
+        return {
+            cliModel: serviceKey !== '' && modelId !== '' ? `${serviceKey}/${modelId}` : (modelId || normalized),
+            providerConfig: undefined
+        };
+    }
+    const providerExtra = getProviderExtra(service);
+    const providerId = typeof providerExtra.providerId === 'string' && providerExtra.providerId.trim() !== ''
+        ? providerExtra.providerId
+        : serviceKey;
+    const npm = inferProviderPackage(service, providerExtra);
+    const baseURL = appendQueryParams(normalizeProviderBaseURL(service.apiBaseUrl, npm), normalizeStringRecord(providerExtra.queryParams));
+    const normalizedTimeoutMs = normalizePositiveInteger(service.timeoutMs);
+    const normalizedMaxOutputTokens = normalizePositiveInteger(service.maxOutputTokens);
+    return {
+        cliModel: `${providerId}/${modelId}`,
+        providerConfig: {
+            [providerId]: {
+                npm,
+                name: service.title?.trim() !== '' ? service.title : serviceKey,
+                options: {
+                    apiKey: service.apiKey,
+                    baseURL,
+                    ...(normalizedTimeoutMs != null
+                        ? {
+                            timeout: normalizedTimeoutMs,
+                            chunkTimeout: normalizedTimeoutMs
+                        }
+                        : {}),
+                    ...(() => {
+                        const headers = normalizeStringRecord(providerExtra.headers);
+                        return Object.keys(headers).length > 0 ? { headers } : {};
+                    })()
+                },
+                models: {
+                    [modelId]: {
+                        name: modelId,
+                        ...(normalizedMaxOutputTokens != null
+                            ? {
+                                limit: {
+                                    output: normalizedMaxOutputTokens
+                                },
+                                options: {
+                                    maxOutputTokens: normalizedMaxOutputTokens
+                                }
+                            }
+                            : {})
+                    }
+                }
+            }
+        }
+    };
+};

package/dist/packages/adapters/opencode/src/runtime/common/object-utils.d.ts

@@ -0,0 +1,3 @@
+export declare const asPlainRecord: (value: unknown) => Record<string, unknown> | undefined;
+export declare const normalizeStringRecord: (value: unknown) => Record<string, string>;
+export declare const deepMerge: (base: Record<string, unknown>, override: Record<string, unknown>) => Record<string, unknown>;

package/dist/packages/adapters/opencode/src/runtime/common/object-utils.js

@@ -0,0 +1,28 @@
+export const asPlainRecord = (value) => (value != null && typeof value === 'object' && !Array.isArray(value)
+    ? value
+    : undefined);
+export const normalizeStringRecord = (value) => {
+    const result = {};
+    const record = asPlainRecord(value);
+    if (!record)
+        return result;
+    for (const [key, entry] of Object.entries(record)) {
+        if (typeof entry === 'string' && entry !== '') {
+            result[key] = entry;
+        }
+    }
+    return result;
+};
+export const deepMerge = (base, override) => {
+    const result = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+        const baseRecord = asPlainRecord(result[key]);
+        const valueRecord = asPlainRecord(value);
+        if (baseRecord && valueRecord) {
+            result[key] = deepMerge(baseRecord, valueRecord);
+            continue;
+        }
+        result[key] = value;
+    }
+    return result;
+};

package/dist/packages/adapters/opencode/src/runtime/common/permission-node.d.ts

@@ -0,0 +1,10 @@
+export type PermissionValue = 'allow' | 'ask' | 'deny';
+export type PermissionNode = PermissionValue | PermissionRecord;
+export interface PermissionRecord {
+    [key: string]: PermissionNode;
+}
+export declare const isPermissionValue: (value: unknown) => value is PermissionValue;
+export declare const normalizePermissionNode: (value: unknown) => PermissionNode | undefined;
+export declare const mergePermissionNodes: (base: PermissionNode | undefined, override: PermissionNode | undefined) => PermissionNode | undefined;
+export declare const rewritePermissionMode: (value: PermissionNode | undefined, mode: "dontAsk" | "bypassPermissions") => PermissionNode;
+export declare const findPermissionEntry: (permission: PermissionNode | undefined, key: string) => PermissionNode | undefined;

package/dist/packages/adapters/opencode/src/runtime/common/permission-node.js

@@ -0,0 +1,98 @@
+import { asPlainRecord } from './object-utils';
+import { LEGACY_TOOL_PERMISSION_ALIASES } from './tools';
+export const isPermissionValue = (value) => (value === 'allow' || value === 'ask' || value === 'deny');
+export const normalizePermissionNode = (value) => {
+    if (isPermissionValue(value))
+        return value;
+    const record = asPlainRecord(value);
+    if (!record)
+        return undefined;
+    const result = {};
+    for (const [key, entry] of Object.entries(record)) {
+        const normalized = normalizePermissionNode(entry);
+        if (normalized != null)
+            result[key] = normalized;
+    }
+    return Object.keys(result).length > 0 ? result : {};
+};
+const clonePermissionNode = (value) => {
+    if (value == null || isPermissionValue(value))
+        return value;
+    const result = {};
+    for (const [key, entry] of Object.entries(value)) {
+        const cloned = clonePermissionNode(entry);
+        if (cloned != null)
+            result[key] = cloned;
+    }
+    return result;
+};
+const asPermissionRecord = (value) => (value != null && !isPermissionValue(value) ? value : undefined);
+const transformPermissionNode = (value, transform) => {
+    if (value == null || isPermissionValue(value))
+        return value == null ? undefined : transform(value);
+    const result = {};
+    for (const [key, entry] of Object.entries(value)) {
+        const transformed = transformPermissionNode(entry, transform);
+        if (transformed != null)
+            result[key] = transformed;
+    }
+    return result;
+};
+const applyPermissionLevel = (base, level) => {
+    if (base == null)
+        return level;
+    if (isPermissionValue(base)) {
+        if (level === 'deny')
+            return 'deny';
+        if (level === 'allow')
+            return base === 'ask' ? 'allow' : base;
+        return base === 'allow' ? 'ask' : base;
+    }
+    if (level === 'deny')
+        return 'deny';
+    const record = asPermissionRecord(transformPermissionNode(base, (entry) => (level === 'allow'
+        ? (entry === 'ask' ? 'allow' : entry)
+        : (entry === 'allow' ? 'ask' : entry)))) ?? {};
+    if (!('*' in record))
+        record['*'] = level;
+    return record;
+};
+export const mergePermissionNodes = (base, override) => {
+    if (override == null)
+        return clonePermissionNode(base);
+    if (base == null)
+        return clonePermissionNode(override);
+    if (isPermissionValue(base)) {
+        return isPermissionValue(override)
+            ? override
+            : mergePermissionNodes({ '*': base }, override);
+    }
+    if (isPermissionValue(override))
+        return applyPermissionLevel(base, override);
+    const result = { ...clonePermissionNode(base) };
+    for (const [key, value] of Object.entries(override)) {
+        result[key] = mergePermissionNodes(result[key], value);
+    }
+    return result;
+};
+export const rewritePermissionMode = (value, mode) => {
+    const transformed = transformPermissionNode(value, (entry) => (mode === 'bypassPermissions' || entry === 'ask' ? 'allow' : entry));
+    if (transformed == null || isPermissionValue(transformed))
+        return transformed ?? { '*': 'allow' };
+    if (!('*' in transformed))
+        transformed['*'] = 'allow';
+    return transformed;
+};
+export const findPermissionEntry = (permission, key) => {
+    const record = asPermissionRecord(permission);
+    if (!record)
+        return undefined;
+    if (key in record)
+        return clonePermissionNode(record[key]);
+    for (const [alias, normalized] of Object.entries(LEGACY_TOOL_PERMISSION_ALIASES)) {
+        if (normalized === key && alias in record) {
+            return clonePermissionNode(record[alias]);
+        }
+    }
+    return undefined;
+};

package/dist/packages/adapters/opencode/src/runtime/common/permissions.d.ts

@@ -0,0 +1,4 @@
+import type { AdapterQueryOptions } from '@vibe-forge/types';
+import type { PermissionNode, PermissionRecord } from './permission-node';
+export declare const mapPermissionModeToOpenCode: (permissionMode: AdapterQueryOptions["permissionMode"]) => PermissionRecord | undefined;
+export declare const buildToolPermissionConfig: (tools: AdapterQueryOptions["tools"], basePermission?: PermissionNode | undefined) => PermissionRecord | undefined;