@vibe-forge/tsconfigs 0.7.2 → 0.8.0

package/dist/packages/adapters/opencode/src/runtime/session/child-env.js

@@ -0,0 +1,121 @@
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import process from 'node:process';
+import { NATIVE_HOOK_BRIDGE_ADAPTER_ENV } from '@vibe-forge/hooks';
+import { buildInlineConfigContent, resolveOpenCodeModel } from '../common';
+import { asPlainRecord } from '../common/object-utils';
+import { toProcessEnv } from './shared';
+import { ensureOpenCodeConfigDir } from './skill-config';
+const resolveMergedModelServices = (ctx) => ({
+    ...(ctx.configs[0]?.modelServices ?? {}),
+    ...(ctx.configs[1]?.modelServices ?? {})
+});
+const resolveMergedMcpServers = (ctx) => ({
+    ...(ctx.configs[0]?.mcpServers ?? {}),
+    ...(ctx.configs[1]?.mcpServers ?? {})
+});
+const resolveMcpServerSelection = (ctx, selection) => {
+    const include = selection?.include ?? Array.from(new Set([
+        ...(ctx.configs[0]?.defaultIncludeMcpServers ?? []),
+        ...(ctx.configs[1]?.defaultIncludeMcpServers ?? [])
+    ]));
+    const exclude = selection?.exclude ?? Array.from(new Set([
+        ...(ctx.configs[0]?.defaultExcludeMcpServers ?? []),
+        ...(ctx.configs[1]?.defaultExcludeMcpServers ?? [])
+    ]));
+    return include.length > 0 || exclude.length > 0
+        ? {
+            include: include.length > 0 ? include : undefined,
+            exclude: exclude.length > 0 ? exclude : undefined
+        }
+        : undefined;
+};
+const parseEnvConfigContent = (env) => {
+    const raw = env.OPENCODE_CONFIG_CONTENT;
+    if (typeof raw !== 'string' || raw.trim() === '')
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        return asPlainRecord(parsed);
+    }
+    catch {
+        return undefined;
+    }
+};
+const readBaseConfigContent = async (configDir) => {
+    if (configDir == null)
+        return undefined;
+    try {
+        const parsed = JSON.parse(await readFile(resolve(configDir, 'opencode.json'), 'utf8'));
+        return asPlainRecord(parsed);
+    }
+    catch {
+        return undefined;
+    }
+};
+export const buildChildEnv = async (params) => {
+    const configDir = await ensureOpenCodeConfigDir({ ctx: params.ctx, options: params.options });
+    const nativeHooksAvailable = params.ctx.env.__VF_PROJECT_AI_OPENCODE_NATIVE_HOOKS_AVAILABLE__ === '1';
+    const baseConfigContent = await readBaseConfigContent(configDir);
+    const { cliModel, providerConfig } = resolveOpenCodeModel(params.options.model, resolveMergedModelServices(params.ctx));
+    const inlineConfigContent = buildInlineConfigContent({
+        baseConfigContent,
+        adapterConfigContent: params.adapterConfig.configContent,
+        envConfigContent: parseEnvConfigContent(params.ctx.env),
+        permissionMode: params.options.permissionMode,
+        tools: params.options.tools,
+        mcpServers: undefined,
+        availableMcpServers: params.options.assetPlan?.mcpServers ??
+            mapResolvedMcpServerSelection(params.ctx, params.options),
+        systemPromptFile: params.systemPromptFile,
+        providerConfig
+    });
+    if (configDir != null) {
+        const configPath = resolve(configDir, 'opencode.json');
+        await rm(configPath, { force: true });
+        await writeFile(configPath, `${JSON.stringify(inlineConfigContent, null, 2)}\n`, 'utf8');
+    }
+    return {
+        cliModel,
+        env: toProcessEnv({
+            ...process.env,
+            ...params.ctx.env,
+            OPENCODE_DISABLE_AUTOUPDATE: params.ctx.env.OPENCODE_DISABLE_AUTOUPDATE ?? 'true',
+            ...(nativeHooksAvailable
+                ? {
+                    __VF_VIBE_FORGE_OPENCODE_HOOKS_ACTIVE__: '1',
+                    [NATIVE_HOOK_BRIDGE_ADAPTER_ENV]: 'opencode',
+                    __VF_OPENCODE_HOOK_RUNTIME__: params.options.runtime,
+                    __VF_OPENCODE_TASK_SESSION_ID__: params.options.sessionId
+                }
+                : {}),
+            ...(configDir == null
+                ? { OPENCODE_CONFIG_CONTENT: JSON.stringify(inlineConfigContent) }
+                : {}),
+            ...(configDir != null ? { OPENCODE_CONFIG_DIR: configDir } : {})
+        })
+    };
+};
+const mapResolvedMcpServerSelection = (ctx, options) => (options.assetPlan?.mcpServers ?? mapSelectedMcpServersToConfig(resolveMergedMcpServers(ctx), resolveMcpServerSelection(ctx, options.mcpServers)));
+const mapSelectedMcpServersToConfig = (availableMcpServers, selection) => {
+    if (availableMcpServers == null)
+        return undefined;
+    const include = selection?.include != null ? new Set(selection.include) : undefined;
+    const exclude = new Set(selection?.exclude ?? []);
+    return Object.fromEntries(Object.entries(availableMcpServers).filter(([name]) => {
+        if (include != null && !include.has(name))
+            return false;
+        if (exclude.has(name))
+            return false;
+        return true;
+    }));
+};
+export const ensureSystemPromptFile = async (ctx, options) => {
+    if (options.systemPrompt == null || options.systemPrompt.trim() === '')
+        return undefined;
+    const promptDir = resolve(ctx.cwd, '.ai', '.mock', '.opencode-adapter', options.sessionId, 'instructions');
+    const promptPath = resolve(promptDir, 'system.md');
+    await mkdir(promptDir, { recursive: true });
+    await writeFile(promptPath, options.systemPrompt);
+    return promptPath;
+};

package/dist/packages/adapters/opencode/src/runtime/session/direct.d.ts

@@ -0,0 +1,2 @@
+import type { AdapterCtx, AdapterQueryOptions, AdapterSession } from '@vibe-forge/types';
+export declare const createDirectOpenCodeSession: (ctx: AdapterCtx, options: AdapterQueryOptions) => Promise<AdapterSession>;

package/dist/packages/adapters/opencode/src/runtime/session/direct.js

@@ -0,0 +1,97 @@
+import { spawn } from 'node:child_process';
+import { resolveOpenCodeBinaryPath } from '../../paths';
+import { buildOpenCodeRunArgs, buildOpenCodeSessionTitle, resolveOpenCodeAgent } from '../common';
+import { buildChildEnv, ensureSystemPromptFile } from './child-env';
+import { findOpenCodeSessionId } from './process';
+import { getErrorMessage, resolveAdapterConfig, toAdapterErrorData } from './shared';
+export const createDirectOpenCodeSession = async (ctx, options) => {
+    const adapterConfig = resolveAdapterConfig(ctx);
+    const agent = resolveOpenCodeAgent({
+        agent: adapterConfig.agent,
+        planAgent: adapterConfig.planAgent,
+        permissionMode: options.permissionMode
+    });
+    const binaryPath = resolveOpenCodeBinaryPath(ctx.env);
+    const title = buildOpenCodeSessionTitle(options.sessionId, adapterConfig.titlePrefix);
+    const cachedSession = options.type === 'resume' ? await ctx.cache.get('adapter.opencode.session') : undefined;
+    const systemPromptFile = await ensureSystemPromptFile(ctx, options);
+    const { cliModel, env } = await buildChildEnv({ ctx, options, adapterConfig, systemPromptFile });
+    const opencodeSessionId = options.type === 'resume'
+        ? await findOpenCodeSessionId({
+            binaryPath,
+            cwd: ctx.cwd,
+            env,
+            title,
+            maxCount: adapterConfig.sessionListMaxCount ?? 50,
+            logger: ctx.logger
+        }) ?? cachedSession?.opencodeSessionId
+        : undefined;
+    if (options.type === 'create')
+        await ctx.cache.set('adapter.opencode.session', { title });
+    const proc = spawn(binaryPath, buildOpenCodeRunArgs({
+        prompt: options.description?.trim() !== '' ? options.description?.trim() : undefined,
+        files: [],
+        model: cliModel,
+        agent,
+        share: adapterConfig.share,
+        title,
+        dir: ctx.cwd,
+        opencodeSessionId,
+        extraOptions: options.extraOptions
+    }), {
+        cwd: ctx.cwd,
+        env: env,
+        stdio: 'inherit'
+    });
+    let finished = false;
+    let didEmitFatalError = false;
+    const emitEvent = (event) => {
+        if (event.type === 'error' && event.data.fatal !== false) {
+            didEmitFatalError = true;
+        }
+        options.onEvent(event);
+    };
+    const emitExitOnce = (data) => {
+        if (finished)
+            return;
+        finished = true;
+        emitEvent({ type: 'exit', data });
+    };
+    proc.on('error', (error) => {
+        emitEvent({ type: 'error', data: toAdapterErrorData(error) });
+        emitExitOnce({ exitCode: 1, stderr: getErrorMessage(error) });
+    });
+    proc.on('exit', (code) => {
+        void (async () => {
+            if ((code ?? 0) === 0) {
+                const resolvedSessionId = await findOpenCodeSessionId({
+                    binaryPath,
+                    cwd: ctx.cwd,
+                    env,
+                    title,
+                    maxCount: adapterConfig.sessionListMaxCount ?? 50,
+                    logger: ctx.logger
+                });
+                if (resolvedSessionId) {
+                    await ctx.cache.set('adapter.opencode.session', { opencodeSessionId: resolvedSessionId, title });
+                }
+            }
+            else if (!didEmitFatalError) {
+                emitEvent({
+                    type: 'error',
+                    data: toAdapterErrorData(`Process exited with code ${code ?? 1}`, {
+                        details: { exitCode: code ?? 1 }
+                    })
+                });
+            }
+            emitExitOnce({ exitCode: code ?? 0 });
+        })();
+    });
+    return {
+        kill: () => proc.kill(),
+        emit: () => {
+            ctx.logger.warn('emit() is not supported in direct mode for opencode');
+        },
+        pid: proc.pid
+    };
+};

package/dist/packages/adapters/opencode/src/runtime/session/process.d.ts

@@ -0,0 +1,17 @@
+import type { AdapterCtx } from '@vibe-forge/types';
+import type { OpenCodeRunResult } from './shared';
+export declare const findOpenCodeSessionId: (params: {
+    binaryPath: string;
+    cwd: string;
+    env: Record<string, string | null | undefined>;
+    title: string;
+    maxCount: number;
+    logger: AdapterCtx["logger"];
+}) => Promise<string | undefined>;
+export declare const runOpenCodeCommand: (params: {
+    binaryPath: string;
+    args: string[];
+    cwd: string;
+    env: Record<string, string | null | undefined>;
+    onStart?: (pid?: number) => void;
+}) => Promise<OpenCodeRunResult>;

package/dist/packages/adapters/opencode/src/runtime/session/process.js

@@ -0,0 +1,33 @@
+import { spawn } from 'node:child_process';
+import { extractOpenCodeSessionRecords, selectOpenCodeSessionByTitle } from '../common';
+import { execFileAsync } from './shared';
+export const findOpenCodeSessionId = async (params) => {
+    try {
+        const { stdout } = await execFileAsync(params.binaryPath, ['session', 'list', '--format', 'json', '--max-count', String(params.maxCount)], { cwd: params.cwd, env: params.env, maxBuffer: 1024 * 1024 * 8 });
+        return selectOpenCodeSessionByTitle(extractOpenCodeSessionRecords(stdout), params.title)?.id;
+    }
+    catch (err) {
+        params.logger.debug('Failed to resolve OpenCode session id from session list', { err });
+        return undefined;
+    }
+};
+export const runOpenCodeCommand = (params) => new Promise((resolveResult, reject) => {
+    const proc = spawn(params.binaryPath, params.args, {
+        cwd: params.cwd,
+        env: params.env,
+        stdio: 'pipe'
+    });
+    params.onStart?.(proc.pid);
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    proc.stdout.on('data', chunk => stdoutChunks.push(String(chunk)));
+    proc.stderr.on('data', chunk => stderrChunks.push(String(chunk)));
+    proc.on('error', reject);
+    proc.on('exit', code => {
+        resolveResult({
+            exitCode: code ?? 0,
+            stdout: stdoutChunks.join(''),
+            stderr: stderrChunks.join('')
+        });
+    });
+});

package/dist/packages/adapters/opencode/src/runtime/session/shared.d.ts

@@ -0,0 +1,42 @@
+import type { ChatMessage } from '@vibe-forge/core';
+import type { AdapterCtx } from '@vibe-forge/types';
+export interface OpenCodeAdapterConfig {
+    agent?: string;
+    planAgent?: string | false;
+    titlePrefix?: string;
+    share?: boolean;
+    sessionListMaxCount?: number;
+    configContent?: Record<string, unknown>;
+}
+export interface OpenCodeRunResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export declare const execFileAsync: (file: string, args: string[], options: {
+    cwd: string;
+    env: Record<string, string>;
+    maxBuffer: number;
+}) => Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+export declare const stripAnsi: (value: string) => string;
+export declare const createAssistantMessage: (content: string, model?: string) => ChatMessage;
+export declare const extractTextFromOpenCodeJsonEvents: (stdout: string) => string;
+export declare const getErrorMessage: (error: unknown) => string;
+export declare const toAdapterErrorData: (error: unknown, overrides?: Partial<{
+    message: string;
+    code: string;
+    details: unknown;
+    fatal: boolean;
+}>) => {
+    fatal: boolean;
+    details?: {} | null | undefined;
+    code?: string | undefined;
+    message: string;
+};
+export declare const toProcessEnv: (env: Record<string, string | null | undefined>) => {
+    [k: string]: string;
+};
+export declare const resolveAdapterConfig: (ctx: AdapterCtx) => OpenCodeAdapterConfig;

package/dist/packages/adapters/opencode/src/runtime/session/shared.js

@@ -0,0 +1,73 @@
+import { execFile } from 'node:child_process';
+import { omitAdapterCommonConfig } from '@vibe-forge/utils';
+import { uuid } from '@vibe-forge/utils/uuid';
+const stripAnsiSequences = (value) => {
+    let output = '';
+    let index = 0;
+    while (index < value.length) {
+        if (value.charCodeAt(index) === 27 && value[index + 1] === '[') {
+            index += 2;
+            while (index < value.length) {
+                const code = value.charCodeAt(index);
+                if (code >= 64 && code <= 126) {
+                    index += 1;
+                    break;
+                }
+                index += 1;
+            }
+            continue;
+        }
+        output += value[index];
+        index += 1;
+    }
+    return output;
+};
+export const execFileAsync = (file, args, options) => new Promise((resolve, reject) => {
+    execFile(file, args, options, (error, stdout, stderr) => {
+        if (error) {
+            reject(error);
+            return;
+        }
+        resolve({ stdout: String(stdout), stderr: String(stderr) });
+    });
+});
+export const stripAnsi = (value) => stripAnsiSequences(value);
+export const createAssistantMessage = (content, model) => ({
+    id: uuid(),
+    role: 'assistant',
+    content,
+    createdAt: Date.now(),
+    ...(model != null ? { model } : {})
+});
+export const extractTextFromOpenCodeJsonEvents = (stdout) => {
+    const textParts = [];
+    for (const rawLine of stdout.split('\n')) {
+        const line = rawLine.trim();
+        if (!line.startsWith('{') || !line.endsWith('}'))
+            continue;
+        try {
+            const event = JSON.parse(line);
+            if (event.type === 'text' && typeof event.part?.text === 'string') {
+                textParts.push(event.part.text);
+            }
+        }
+        catch {
+        }
+    }
+    return textParts.join('');
+};
+export const getErrorMessage = (error) => (error instanceof Error ? error.message : String(error ?? 'OpenCode session failed unexpectedly'));
+export const toAdapterErrorData = (error, overrides = {}) => ({
+    message: overrides.message ?? getErrorMessage(error),
+    ...(overrides.code != null ? { code: overrides.code } : {}),
+    ...(overrides.details !== undefined ? { details: overrides.details } : {}),
+    fatal: overrides.fatal ?? true
+});
+export const toProcessEnv = (env) => (Object.fromEntries(Object.entries(env).filter((entry) => typeof entry[1] === 'string')));
+export const resolveAdapterConfig = (ctx) => {
+    const [config, userConfig] = ctx.configs;
+    return omitAdapterCommonConfig({
+        ...(config?.adapters?.opencode ?? {}),
+        ...(userConfig?.adapters?.opencode ?? {})
+    });
+};

package/dist/packages/adapters/opencode/src/runtime/session/skill-config.d.ts

@@ -0,0 +1,5 @@
+import type { AdapterCtx, AdapterQueryOptions } from '@vibe-forge/types';
+export declare const ensureOpenCodeConfigDir: (params: {
+    ctx: AdapterCtx;
+    options: AdapterQueryOptions;
+}) => Promise<string>;

package/dist/packages/adapters/opencode/src/runtime/session/skill-config.js

@@ -0,0 +1,71 @@
+import { lstat, mkdir, readdir, rm, symlink } from 'node:fs/promises';
+import { basename, dirname, resolve } from 'node:path';
+import process from 'node:process';
+import { DefinitionLoader } from '@vibe-forge/definition-loader';
+const filterResolvedSkills = async (cwd, selection) => {
+    const loader = new DefinitionLoader(cwd);
+    const allSkills = await loader.loadDefaultSkills();
+    const include = selection?.include != null && selection.include.length > 0
+        ? new Set(selection.include)
+        : undefined;
+    const exclude = new Set(selection?.exclude ?? []);
+    const result = new Map();
+    for (const skill of allSkills) {
+        const name = basename(dirname(skill.path));
+        if ((include != null && !include.has(name)) || exclude.has(name) || result.has(name))
+            continue;
+        result.set(name, dirname(skill.path));
+    }
+    return result;
+};
+const ensureSymlinkTarget = async (sourcePath, targetPath) => {
+    try {
+        const existing = await lstat(targetPath);
+        if (existing.isSymbolicLink() || existing.isDirectory() || existing.isFile()) {
+            await rm(targetPath, { recursive: true, force: true });
+        }
+    }
+    catch {
+    }
+    await mkdir(dirname(targetPath), { recursive: true });
+    await symlink(sourcePath, targetPath);
+};
+const mirrorDirectoryEntries = async (sourceDir, targetDir) => {
+    try {
+        const entries = await readdir(sourceDir, { withFileTypes: true });
+        await mkdir(targetDir, { recursive: true });
+        for (const entry of entries) {
+            await ensureSymlinkTarget(resolve(sourceDir, entry.name), resolve(targetDir, entry.name));
+        }
+    }
+    catch {
+    }
+};
+export const ensureOpenCodeConfigDir = async (params) => {
+    const baseConfigDir = params.ctx.env.OPENCODE_CONFIG_DIR ?? process.env.OPENCODE_CONFIG_DIR ?? undefined;
+    const planOverlays = params.options.assetPlan?.overlays ?? [];
+    const resolvedSkills = planOverlays.length > 0
+        ? new Map(planOverlays
+            .filter((entry) => entry.kind === 'skill')
+            .map((entry) => [basename(entry.targetPath), entry.sourcePath]))
+        : await filterResolvedSkills(params.ctx.cwd, params.options.skills);
+    const configDir = resolve(params.ctx.cwd, '.ai', '.mock', '.opencode-adapter', params.options.sessionId, 'config-dir');
+    await rm(configDir, { recursive: true, force: true });
+    await mkdir(configDir, { recursive: true });
+    if (baseConfigDir) {
+        for (const folderName of ['agents', 'commands', 'modes', 'plugins']) {
+            await ensureSymlinkTarget(resolve(baseConfigDir, folderName), resolve(configDir, folderName)).catch(() => undefined);
+        }
+        for (const fileName of ['opencode.json', 'package.json', 'bun.lock', 'bun.lockb']) {
+            await ensureSymlinkTarget(resolve(baseConfigDir, fileName), resolve(configDir, fileName)).catch(() => undefined);
+        }
+        await mirrorDirectoryEntries(resolve(baseConfigDir, 'skills'), resolve(configDir, 'skills'));
+    }
+    for (const [name, sourceDir] of resolvedSkills.entries()) {
+        await ensureSymlinkTarget(sourceDir, resolve(configDir, 'skills', name));
+    }
+    for (const overlay of planOverlays.filter((entry) => entry.kind !== 'skill')) {
+        await ensureSymlinkTarget(overlay.sourcePath, resolve(configDir, overlay.targetPath));
+    }
+    return configDir;
+};

package/dist/packages/adapters/opencode/src/runtime/session/stream.d.ts

@@ -0,0 +1,2 @@
+import type { AdapterCtx, AdapterQueryOptions, AdapterSession } from '@vibe-forge/types';
+export declare const createStreamOpenCodeSession: (ctx: AdapterCtx, options: AdapterQueryOptions) => Promise<AdapterSession>;

package/dist/packages/adapters/opencode/src/runtime/session/stream.js

@@ -0,0 +1,178 @@
+import process from 'node:process';
+import { resolveOpenCodeBinaryPath } from '../../paths';
+import { DEFAULT_OPENCODE_TOOLS, buildOpenCodeRunArgs, buildOpenCodeSessionTitle, normalizeOpenCodePrompt, resolveOpenCodeAgent } from '../common';
+import { buildChildEnv, ensureSystemPromptFile } from './child-env';
+import { findOpenCodeSessionId, runOpenCodeCommand } from './process';
+import { createAssistantMessage, extractTextFromOpenCodeJsonEvents, getErrorMessage, resolveAdapterConfig, stripAnsi, toAdapterErrorData } from './shared';
+export const createStreamOpenCodeSession = async (ctx, options) => {
+    const adapterConfig = resolveAdapterConfig(ctx);
+    const agent = resolveOpenCodeAgent({
+        agent: adapterConfig.agent,
+        planAgent: adapterConfig.planAgent,
+        permissionMode: options.permissionMode
+    });
+    const binaryPath = resolveOpenCodeBinaryPath(ctx.env);
+    const title = buildOpenCodeSessionTitle(options.sessionId, adapterConfig.titlePrefix);
+    const systemPromptFile = await ensureSystemPromptFile(ctx, options);
+    const cachedSession = options.type === 'resume' ? await ctx.cache.get('adapter.opencode.session') : undefined;
+    if (options.type === 'create')
+        await ctx.cache.set('adapter.opencode.session', { title });
+    options.onEvent({
+        type: 'init',
+        data: {
+            uuid: options.sessionId,
+            model: options.model ?? 'default',
+            version: 'unknown',
+            tools: DEFAULT_OPENCODE_TOOLS,
+            slashCommands: [],
+            cwd: ctx.cwd,
+            agents: agent ? [agent] : [],
+            title
+        }
+    });
+    let destroyed = false;
+    let currentPid;
+    let currentKill;
+    let opencodeSessionId = cachedSession?.opencodeSessionId;
+    let didEmitFatalError = false;
+    const emitEvent = (event) => {
+        if (event.type === 'error' && event.data.fatal !== false) {
+            didEmitFatalError = true;
+        }
+        options.onEvent(event);
+    };
+    const emitUnexpectedExit = (error) => {
+        if (destroyed)
+            return;
+        destroyed = true;
+        currentPid = undefined;
+        currentKill = undefined;
+        ctx.logger.error('OpenCode session turn failed unexpectedly', { err: error });
+        emitEvent({ type: 'error', data: toAdapterErrorData(error) });
+        emitEvent({ type: 'exit', data: { exitCode: 1, stderr: getErrorMessage(error) } });
+    };
+    const runTurn = async (content, allowRetry) => {
+        if (destroyed)
+            return;
+        const normalized = normalizeOpenCodePrompt(content.content);
+        const { cliModel, env } = await buildChildEnv({ ctx, options, adapterConfig, systemPromptFile });
+        if (opencodeSessionId == null && options.type === 'resume') {
+            opencodeSessionId = await findOpenCodeSessionId({
+                binaryPath,
+                cwd: ctx.cwd,
+                env,
+                title,
+                maxCount: adapterConfig.sessionListMaxCount ?? 50,
+                logger: ctx.logger
+            });
+        }
+        const result = await runOpenCodeCommand({
+            binaryPath,
+            args: buildOpenCodeRunArgs({
+                prompt: normalized.prompt,
+                files: normalized.files,
+                model: cliModel,
+                agent,
+                share: adapterConfig.share,
+                title,
+                dir: ctx.cwd,
+                opencodeSessionId,
+                extraOptions: options.extraOptions,
+                format: 'json'
+            }),
+            cwd: ctx.cwd,
+            env,
+            onStart: (pid) => {
+                currentPid = pid;
+                currentKill = () => {
+                    if (pid != null) {
+                        try {
+                            process.kill(pid, 'SIGINT');
+                        }
+                        catch {
+                        }
+                    }
+                };
+            }
+        });
+        currentPid = undefined;
+        currentKill = undefined;
+        if (destroyed)
+            return;
+        const output = extractTextFromOpenCodeJsonEvents(result.stdout).trim();
+        const error = stripAnsi(result.stderr).trim();
+        if (result.exitCode !== 0) {
+            const missingSession = /session.+not found|no session found/i.test(`${result.stdout}\n${error}`);
+            if (missingSession && opencodeSessionId != null && allowRetry) {
+                opencodeSessionId = undefined;
+                await ctx.cache.set('adapter.opencode.session', { title });
+                await runTurn(content, false);
+                return;
+            }
+            if (!didEmitFatalError) {
+                emitEvent({
+                    type: 'error',
+                    data: toAdapterErrorData(result.stderr || result.stdout || `Process exited with code ${result.exitCode}`, {
+                        details: {
+                            exitCode: result.exitCode,
+                            stdout: result.stdout,
+                            stderr: result.stderr
+                        }
+                    })
+                });
+            }
+            emitEvent({ type: 'exit', data: { exitCode: result.exitCode, stderr: result.stderr || result.stdout } });
+            return;
+        }
+        const resolvedSessionId = await findOpenCodeSessionId({
+            binaryPath,
+            cwd: ctx.cwd,
+            env,
+            title,
+            maxCount: adapterConfig.sessionListMaxCount ?? 50,
+            logger: ctx.logger
+        });
+        if (resolvedSessionId) {
+            opencodeSessionId = resolvedSessionId;
+            await ctx.cache.set('adapter.opencode.session', { opencodeSessionId, title });
+        }
+        const assistantMessage = createAssistantMessage(output === '' ? (stripAnsi(result.stdout).trim() || '[OpenCode completed without text output]') : output, cliModel);
+        emitEvent({ type: 'message', data: assistantMessage });
+        emitEvent({ type: 'stop', data: assistantMessage });
+    };
+    let queue = Promise.resolve();
+    const enqueueMessage = (event) => {
+        queue = queue.catch(() => undefined).then(async () => {
+            try {
+                await runTurn(event, true);
+            }
+            catch (error) {
+                emitUnexpectedExit(error);
+            }
+        });
+    };
+    if (options.description != null && options.description.trim() !== '') {
+        enqueueMessage({ type: 'message', content: [{ type: 'text', text: options.description }] });
+    }
+    return {
+        kill: () => {
+            destroyed = true;
+            currentKill?.();
+        },
+        emit: (event) => {
+            if (destroyed)
+                return;
+            if (event.type === 'message')
+                enqueueMessage(event);
+            if (event.type === 'interrupt')
+                currentKill?.();
+            if (event.type === 'stop') {
+                destroyed = true;
+                currentKill?.();
+            }
+        },
+        get pid() {
+            return currentPid;
+        }
+    };
+};

package/dist/packages/adapters/opencode/src/runtime/session.d.ts

@@ -0,0 +1,2 @@
+import type { AdapterCtx, AdapterQueryOptions, AdapterSession } from '@vibe-forge/types';
+export declare const createOpenCodeSession: (ctx: AdapterCtx, options: AdapterQueryOptions) => Promise<AdapterSession>;

package/dist/packages/adapters/opencode/src/runtime/session.js

@@ -0,0 +1,5 @@
+import { createDirectOpenCodeSession } from './session/direct';
+import { createStreamOpenCodeSession } from './session/stream';
+export const createOpenCodeSession = async (ctx, options) => (options.mode === 'direct'
+    ? createDirectOpenCodeSession(ctx, options)
+    : createStreamOpenCodeSession(ctx, options));

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

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

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

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

package/dist/packages/app-runtime/__tests__/index.spec.d.ts

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