@vibe-forge/tsconfigs 0.7.2 → 0.9.0

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

@@ -0,0 +1,67 @@
+import { findPermissionEntry, isPermissionValue } from './permission-node';
+import { LEGACY_TOOL_PERMISSION_ALIASES } from './tools';
+const OPENCODE_PERMISSION_KEYS = [
+    'bash',
+    'edit',
+    'glob',
+    'grep',
+    'question',
+    'read',
+    'list',
+    'lsp',
+    'skill',
+    'task',
+    'todoread',
+    'todowrite',
+    'webfetch',
+    'websearch',
+    'codesearch'
+];
+export const mapPermissionModeToOpenCode = (permissionMode) => {
+    if (permissionMode == null)
+        return undefined;
+    if (permissionMode === 'dontAsk' || permissionMode === 'bypassPermissions')
+        return { '*': 'allow' };
+    if (permissionMode === 'acceptEdits')
+        return { '*': 'allow', bash: 'ask', edit: 'allow', task: 'ask' };
+    if (permissionMode === 'plan')
+        return { '*': 'allow', bash: 'ask', edit: 'deny', task: 'deny' };
+    return { '*': 'allow', bash: 'ask', edit: 'ask', task: 'ask' };
+};
+const normalizePermissionToolKey = (value) => {
+    const key = value.trim();
+    if (key === '')
+        return undefined;
+    return LEGACY_TOOL_PERMISSION_ALIASES[key] ?? key;
+};
+const resolvePermissionValue = (key, basePermission) => {
+    const explicit = findPermissionEntry(basePermission, key);
+    if (isPermissionValue(explicit))
+        return explicit;
+    const wildcard = findPermissionEntry(basePermission, '*');
+    if (isPermissionValue(wildcard))
+        return wildcard;
+    return isPermissionValue(basePermission) ? basePermission : 'allow';
+};
+export const buildToolPermissionConfig = (tools, basePermission = undefined) => {
+    const includes = new Set((tools?.include ?? []).map(normalizePermissionToolKey).filter(Boolean));
+    const excludes = new Set((tools?.exclude ?? []).map(normalizePermissionToolKey).filter(Boolean));
+    const allowAllTools = includes.delete('*');
+    if (includes.size === 0 && excludes.size === 0)
+        return undefined;
+    const result = {};
+    const explicitKeys = Object.keys(isPermissionValue(basePermission) || basePermission == null ? {} : basePermission).map(normalizePermissionToolKey).filter((value) => value != null && value !== '*');
+    if (includes.size > 0 && !allowAllTools) {
+        result['*'] = 'deny';
+        for (const key of new Set([...OPENCODE_PERMISSION_KEYS, ...explicitKeys])) {
+            if (!includes.has(key))
+                result[key] = 'deny';
+        }
+        for (const key of includes) {
+            result[key] = findPermissionEntry(basePermission, key) ?? resolvePermissionValue(key, basePermission);
+        }
+    }
+    for (const key of excludes)
+        result[key] = 'deny';
+    return result;
+};

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

@@ -0,0 +1,7 @@
+import type { AdapterMessageContent } from '@vibe-forge/types';
+export declare const resolveLocalAttachmentPath: (value: string) => string | undefined;
+export declare const normalizeOpenCodePrompt: (content: AdapterMessageContent[]) => {
+    prompt: string;
+    files: string[];
+};
+export declare const buildOpenCodeSessionTitle: (sessionId: string, titlePrefix?: string) => string;

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

@@ -0,0 +1,43 @@
+import { isAbsolute } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const resolveLocalAttachmentPath = (value) => {
+    if (value.startsWith('file://')) {
+        try {
+            return fileURLToPath(value);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return isAbsolute(value) ? value : undefined;
+};
+export const normalizeOpenCodePrompt = (content) => {
+    const promptParts = [];
+    const files = new Set();
+    for (const item of content) {
+        if (item.type === 'text') {
+            const text = item.text.trim();
+            if (text !== '')
+                promptParts.push(text);
+            continue;
+        }
+        if (item.type === 'image') {
+            const filePath = resolveLocalAttachmentPath(item.url);
+            if (filePath)
+                files.add(filePath);
+            continue;
+        }
+        if (item.type === 'tool_result') {
+            promptParts.push(String(item.content));
+            continue;
+        }
+        if (item.type === 'tool_use') {
+            promptParts.push(`Tool request: ${item.name}`);
+        }
+    }
+    return {
+        prompt: promptParts.join('\n\n').trim() || (files.size > 0 ? 'Please inspect the attached file(s).' : 'Continue.'),
+        files: Array.from(files)
+    };
+};
+export const buildOpenCodeSessionTitle = (sessionId, titlePrefix = 'Vibe Forge') => `${titlePrefix}:${sessionId}`;

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

@@ -0,0 +1,7 @@
+export interface OpenCodeSessionRecord {
+    id: string;
+    title?: string;
+    updatedAt?: number;
+}
+export declare const extractOpenCodeSessionRecords: (input: unknown) => OpenCodeSessionRecord[];
+export declare const selectOpenCodeSessionByTitle: (sessions: OpenCodeSessionRecord[], title: string) => OpenCodeSessionRecord;

package/dist/packages/adapters/opencode/src/runtime/common/session-records.js

@@ -0,0 +1,43 @@
+import { asPlainRecord } from './object-utils';
+const parseTimestamp = (value) => {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value === 'string' && value.trim() !== '') {
+        const parsed = Date.parse(value);
+        return Number.isNaN(parsed) ? undefined : parsed;
+    }
+    return undefined;
+};
+export const extractOpenCodeSessionRecords = (input) => {
+    const parsed = typeof input === 'string' ? JSON.parse(input) : input;
+    const record = asPlainRecord(parsed);
+    const payload = Array.isArray(parsed)
+        ? parsed
+        : Array.isArray(record?.sessions)
+            ? record.sessions
+            : Array.isArray(record?.items)
+                ? record.items
+                : [];
+    return payload.flatMap((entry) => {
+        const current = asPlainRecord(entry);
+        if (!current)
+            return [];
+        const id = [current.id, current.sessionId, current.sessionID]
+            .find((value) => typeof value === 'string' && value.trim() !== '');
+        if (id == null)
+            return [];
+        return [{
+                id,
+                title: typeof current.title === 'string' && current.title.trim() !== '' ? current.title : undefined,
+                updatedAt: parseTimestamp(current.updatedAt ??
+                    current.updated_at ??
+                    current.modifiedAt ??
+                    current.modified_at ??
+                    current.createdAt ??
+                    current.created_at)
+            }];
+    });
+};
+export const selectOpenCodeSessionByTitle = (sessions, title) => (sessions
+    .filter(session => session.title === title)
+    .sort((left, right) => (right.updatedAt ?? 0) - (left.updatedAt ?? 0))[0]);

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

@@ -0,0 +1,17 @@
+import type { AdapterQueryOptions } from '@vibe-forge/types';
+export declare const DEFAULT_OPENCODE_TOOLS: string[];
+export declare const LEGACY_TOOL_PERMISSION_ALIASES: Record<string, string>;
+export declare const buildToolConfig: (tools: AdapterQueryOptions["tools"]) => Record<string, boolean> | undefined;
+export declare const sanitizeOpenCodeExtraOptions: (extraOptions?: string[]) => string[];
+export declare const buildOpenCodeRunArgs: (params: {
+    prompt?: string;
+    files: string[];
+    model?: string;
+    agent?: string;
+    share?: boolean;
+    title?: string;
+    dir?: string;
+    opencodeSessionId?: string;
+    extraOptions?: string[];
+    format?: "default" | "json";
+}) => string[];

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

@@ -0,0 +1,124 @@
+export const DEFAULT_OPENCODE_TOOLS = [
+    'bash',
+    'edit',
+    'glob',
+    'grep',
+    'patch',
+    'write',
+    'read',
+    'list',
+    'lsp',
+    'skill',
+    'todoread',
+    'todowrite',
+    'webfetch',
+    'websearch',
+    'question'
+];
+export const LEGACY_TOOL_PERMISSION_ALIASES = {
+    agent: 'task',
+    bash: 'bash',
+    edit: 'edit',
+    fetch: 'webfetch',
+    glob: 'glob',
+    grep: 'grep',
+    list: 'list',
+    ls: 'list',
+    lsp: 'lsp',
+    patch: 'edit',
+    read: 'read',
+    skill: 'skill',
+    task: 'task',
+    todoread: 'todoread',
+    todowrite: 'todowrite',
+    view: 'read',
+    webfetch: 'webfetch',
+    websearch: 'websearch',
+    write: 'edit'
+};
+const OPEN_CODE_TOOL_ALIASES = {
+    bash: 'bash',
+    edit: 'edit',
+    fetch: 'webfetch',
+    glob: 'glob',
+    grep: 'grep',
+    list: 'list',
+    ls: 'list',
+    lsp: 'lsp',
+    patch: 'patch',
+    question: 'question',
+    read: 'read',
+    skill: 'skill',
+    todoread: 'todoread',
+    todowrite: 'todowrite',
+    view: 'read',
+    webfetch: 'webfetch',
+    websearch: 'websearch',
+    write: 'write'
+};
+const PERMISSION_ONLY_TOOL_KEYS = new Set(['agent', 'task']);
+const MANAGED_FLAGS_WITH_VALUE = new Set([
+    '--agent',
+    '--attach',
+    '--file',
+    '--format',
+    '--model',
+    '--port',
+    '--session',
+    '--title',
+    '-f',
+    '-m',
+    '-s'
+]);
+const MANAGED_FLAGS = new Set(['--continue', '--fork', '--share', '-c']);
+export const buildToolConfig = (tools) => {
+    const result = {};
+    for (const [list, enabled] of [[tools?.exclude ?? [], false], [tools?.include ?? [], true]]) {
+        for (const name of list) {
+            const key = name.trim();
+            if (key === '' || key === '*' || PERMISSION_ONLY_TOOL_KEYS.has(key))
+                continue;
+            result[OPEN_CODE_TOOL_ALIASES[key] ?? key] = enabled;
+        }
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+};
+export const sanitizeOpenCodeExtraOptions = (extraOptions) => {
+    const sanitized = [];
+    for (let index = 0; index < (extraOptions ?? []).length; index += 1) {
+        const current = extraOptions?.[index];
+        if (current == null)
+            continue;
+        if (MANAGED_FLAGS_WITH_VALUE.has(current)) {
+            index += 1;
+            continue;
+        }
+        if (!MANAGED_FLAGS.has(current)) {
+            sanitized.push(current);
+        }
+    }
+    return sanitized;
+};
+export const buildOpenCodeRunArgs = (params) => {
+    const args = ['run', '--format', params.format ?? 'default'];
+    if (params.opencodeSessionId) {
+        args.push('--session', params.opencodeSessionId);
+    }
+    else if (params.title) {
+        args.push('--title', params.title);
+    }
+    if (params.model)
+        args.push('--model', params.model);
+    if (params.agent)
+        args.push('--agent', params.agent);
+    if (params.share)
+        args.push('--share');
+    if (params.dir)
+        args.push('--dir', params.dir);
+    for (const file of params.files)
+        args.push('--file', file);
+    args.push(...sanitizeOpenCodeExtraOptions(params.extraOptions));
+    if (params.prompt != null && params.prompt !== '')
+        args.push(params.prompt);
+    return args;
+};

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

@@ -0,0 +1,8 @@
+export { resolveOpenCodeAgent } from './common/agent';
+export { buildInlineConfigContent } from './common/inline-config';
+export { mapMcpServersToOpenCode } from './common/mcp';
+export { resolveOpenCodeModel } from './common/model';
+export { buildToolPermissionConfig, mapPermissionModeToOpenCode } from './common/permissions';
+export { buildOpenCodeSessionTitle, normalizeOpenCodePrompt, resolveLocalAttachmentPath } from './common/prompt';
+export { extractOpenCodeSessionRecords, type OpenCodeSessionRecord, selectOpenCodeSessionByTitle } from './common/session-records';
+export { buildOpenCodeRunArgs, buildToolConfig, DEFAULT_OPENCODE_TOOLS, sanitizeOpenCodeExtraOptions } from './common/tools';

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

@@ -0,0 +1,8 @@
+export { resolveOpenCodeAgent } from './common/agent';
+export { buildInlineConfigContent } from './common/inline-config';
+export { mapMcpServersToOpenCode } from './common/mcp';
+export { resolveOpenCodeModel } from './common/model';
+export { buildToolPermissionConfig, mapPermissionModeToOpenCode } from './common/permissions';
+export { buildOpenCodeSessionTitle, normalizeOpenCodePrompt, resolveLocalAttachmentPath } from './common/prompt';
+export { extractOpenCodeSessionRecords, selectOpenCodeSessionByTitle } from './common/session-records';
+export { buildOpenCodeRunArgs, buildToolConfig, DEFAULT_OPENCODE_TOOLS, sanitizeOpenCodeExtraOptions } from './common/tools';

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

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

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

@@ -0,0 +1,39 @@
+import { execFile } from 'node:child_process';
+import { access, lstat, mkdir, symlink } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import process from 'node:process';
+import { promisify } from 'node:util';
+import { resolveOpenCodeBinaryPath } from '#~/paths.js';
+import { ensureOpenCodeNativeHooksInstalled } from './native-hooks';
+const execFileAsync = promisify(execFile);
+const ensureSymlink = async (sourcePath, targetPath) => {
+    try {
+        await access(sourcePath);
+    }
+    catch {
+        return;
+    }
+    try {
+        await lstat(targetPath);
+        return;
+    }
+    catch {
+    }
+    await mkdir(dirname(targetPath), { recursive: true });
+    await symlink(sourcePath, targetPath);
+};
+export const initOpenCodeAdapter = async (ctx) => {
+    const binaryPath = resolveOpenCodeBinaryPath(ctx.env);
+    try {
+        await execFileAsync(binaryPath, ['--version']);
+    }
+    catch {
+    }
+    const realHome = process.env.__VF_PROJECT_REAL_HOME__;
+    const aiHome = process.env.HOME;
+    if (realHome && aiHome) {
+        await ensureSymlink(join(realHome, '.local', 'share', 'opencode', 'auth.json'), join(aiHome, '.local', 'share', 'opencode', 'auth.json'));
+        await ensureSymlink(join(realHome, '.local', 'share', 'opencode', 'mcp-auth.json'), join(aiHome, '.local', 'share', 'opencode', 'mcp-auth.json'));
+    }
+    await ensureOpenCodeNativeHooksInstalled(ctx);
+};

package/dist/packages/adapters/opencode/src/runtime/native-hooks.d.ts

@@ -0,0 +1,2 @@
+import type { AdapterCtx } from '@vibe-forge/types';
+export declare const ensureOpenCodeNativeHooksInstalled: (ctx: Pick<AdapterCtx, "cwd" | "env" | "logger" | "assets">) => Promise<boolean>;

package/dist/packages/adapters/opencode/src/runtime/native-hooks.js

@@ -0,0 +1,222 @@
+import { access, mkdir, readdir, rm, symlink, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import process from 'node:process';
+import { hasManagedHookPlugins, prepareManagedHookRuntime, resolveManagedHookScriptPath, writeJsonFile } from '@vibe-forge/hooks';
+const MANAGED_PLUGIN_FILE_NAME = 'vibe-forge-hooks.js';
+const DEFAULT_OPENCODE_CONFIG = {
+    $schema: 'https://opencode.ai/config.json'
+};
+const pathExists = async (targetPath) => {
+    try {
+        await access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const ensureSymlinkTarget = async (sourcePath, targetPath) => {
+    await rm(targetPath, { recursive: true, force: true });
+    await mkdir(dirname(targetPath), { recursive: true });
+    await symlink(sourcePath, targetPath);
+};
+const mirrorDirectory = async (sourceDir, targetDir) => {
+    if (!await pathExists(sourceDir))
+        return;
+    await rm(targetDir, { recursive: true, force: true });
+    await mkdir(dirname(targetDir), { recursive: true });
+    await symlink(sourceDir, targetDir);
+};
+const mirrorFile = async (sourcePath, targetPath) => {
+    if (!await pathExists(sourcePath))
+        return false;
+    await ensureSymlinkTarget(sourcePath, targetPath);
+    return true;
+};
+const syncPluginDirectory = async (sourceDir, targetDir) => {
+    await mkdir(targetDir, { recursive: true });
+    const existingEntries = await readdir(targetDir).catch(() => []);
+    await Promise.all(existingEntries
+        .filter(entry => entry !== MANAGED_PLUGIN_FILE_NAME)
+        .map(entry => rm(resolve(targetDir, entry), { recursive: true, force: true })));
+    if (sourceDir == null || !await pathExists(sourceDir))
+        return;
+    const sourceEntries = await readdir(sourceDir);
+    for (const entry of sourceEntries) {
+        if (entry === MANAGED_PLUGIN_FILE_NAME)
+            continue;
+        await ensureSymlinkTarget(resolve(sourceDir, entry), resolve(targetDir, entry));
+    }
+};
+const buildManagedPluginSource = () => {
+    const callHookPath = resolveManagedHookScriptPath('call-hook.js');
+    return `import { spawnSync } from "node:child_process"
+import process from "node:process"
+
+const ACTIVE_MARKER = "__VF_VIBE_FORGE_OPENCODE_HOOKS_ACTIVE__"
+const NODE_PATH = process.env.__VF_PROJECT_NODE_PATH__ ?? ${JSON.stringify(process.execPath)}
+const CALL_HOOK_PATH = ${JSON.stringify(callHookPath)}
+const SESSION_ID = process.env.__VF_OPENCODE_TASK_SESSION_ID__ ?? "opencode-session"
+const RUNTIME = process.env.__VF_OPENCODE_HOOK_RUNTIME__
+
+const parseJson = (value, fallback) => {
+  try {
+    return JSON.parse(value)
+  } catch {
+    return fallback
+  }
+}
+
+const createBaseInput = (hookEventName, cwd, canBlock) => ({
+  hookEventName,
+  cwd,
+  sessionId: SESSION_ID,
+  adapter: "opencode",
+  runtime: RUNTIME,
+  hookSource: "native",
+  canBlock,
+})
+
+const callVibeForgeHook = (payload) => {
+  if (process.env[ACTIVE_MARKER] !== "1") return { continue: true }
+
+  try {
+    const result = spawnSync(NODE_PATH, [CALL_HOOK_PATH], {
+      input: JSON.stringify(payload),
+      encoding: "utf8",
+      env: {
+        ...process.env,
+        __VF_PROJECT_WORKSPACE_FOLDER__: payload.cwd ?? process.env.__VF_PROJECT_WORKSPACE_FOLDER__ ?? process.cwd(),
+      },
+    })
+
+    if ((result.status ?? 0) !== 0) {
+      console.error("[vibe-forge opencode hook] process exited with", result.status, result.stderr)
+      return { continue: true }
+    }
+
+    const stdout = result.stdout?.trim()
+    return stdout ? parseJson(stdout, { continue: true }) : { continue: true }
+  } catch (error) {
+    console.error("[vibe-forge opencode hook] failed", error)
+    return { continue: true }
+  }
+}
+
+const stopReason = (result, fallback) => (
+  typeof result?.stopReason === "string" && result.stopReason.trim() !== ""
+    ? result.stopReason.trim()
+    : fallback
+)
+
+const normalizeToolName = (input) => {
+  if (typeof input?.tool === "string" && input.tool.trim() !== "") return input.tool
+  if (typeof input?.name === "string" && input.name.trim() !== "") return input.name
+  return "unknown"
+}
+
+const normalizeToolInput = (input, output) => (
+  output?.args ?? input?.args ?? input?.input ?? input
+)
+
+const normalizeToolResponse = (input, output) => (
+  output?.result ?? output?.response ?? output?.data ?? input?.result ?? output
+)
+
+export const VibeForgeHooks = async ({ directory }) => ({
+  event: async ({ event }) => {
+    if (event?.type === "session.created") {
+      callVibeForgeHook({
+        ...createBaseInput("SessionStart", directory, true),
+        source: "startup",
+      })
+      return
+    }
+
+    if (event?.type === "session.idle") {
+      callVibeForgeHook(createBaseInput("Stop", directory, false))
+    }
+  },
+  "tool.execute.before": async (input, output) => {
+    const result = callVibeForgeHook({
+      ...createBaseInput("PreToolUse", directory, true),
+      toolName: normalizeToolName(input),
+      toolInput: normalizeToolInput(input, output),
+    })
+
+    if (result?.continue === false) {
+      throw new Error(stopReason(result, "blocked by Vibe Forge PreToolUse hook"))
+    }
+  },
+  "tool.execute.after": async (input, output) => {
+    const result = callVibeForgeHook({
+      ...createBaseInput("PostToolUse", directory, true),
+      toolName: normalizeToolName(input),
+      toolInput: normalizeToolInput(input, output),
+      toolResponse: normalizeToolResponse(input, output),
+      isError: Boolean(output?.error ?? output?.isError ?? input?.error),
+    })
+
+    if (result?.continue === false) {
+      throw new Error(stopReason(result, "blocked by Vibe Forge PostToolUse hook"))
+    }
+  },
+})
+`;
+};
+const resolveSourceConfigDir = (ctx) => {
+    const explicit = ctx.env.OPENCODE_CONFIG_DIR?.trim() || process.env.OPENCODE_CONFIG_DIR?.trim();
+    if (explicit)
+        return resolve(explicit);
+    const realHome = process.env.__VF_PROJECT_REAL_HOME__?.trim();
+    return realHome ? resolve(realHome, '.config', 'opencode') : undefined;
+};
+export const ensureOpenCodeNativeHooksInstalled = async (ctx) => {
+    const { env, logger, assets } = ctx;
+    env.__VF_PROJECT_AI_OPENCODE_NATIVE_HOOKS_AVAILABLE__ = '0';
+    const enabled = hasManagedHookPlugins({ assets });
+    try {
+        const { mockHome } = prepareManagedHookRuntime(ctx);
+        const sourceConfigDir = resolveSourceConfigDir(ctx);
+        const managedConfigDir = resolve(mockHome, '.config', 'opencode');
+        const pluginDir = resolve(managedConfigDir, 'plugins');
+        const managedPluginPath = resolve(pluginDir, MANAGED_PLUGIN_FILE_NAME);
+        await mkdir(managedConfigDir, { recursive: true });
+        if (sourceConfigDir != null && resolve(sourceConfigDir) !== managedConfigDir) {
+            await Promise.all([
+                mirrorDirectory(resolve(sourceConfigDir, 'agents'), resolve(managedConfigDir, 'agents')),
+                mirrorDirectory(resolve(sourceConfigDir, 'commands'), resolve(managedConfigDir, 'commands')),
+                mirrorDirectory(resolve(sourceConfigDir, 'modes'), resolve(managedConfigDir, 'modes')),
+                mirrorDirectory(resolve(sourceConfigDir, 'skills'), resolve(managedConfigDir, 'skills')),
+                mirrorFile(resolve(sourceConfigDir, 'package.json'), resolve(managedConfigDir, 'package.json')),
+                mirrorFile(resolve(sourceConfigDir, 'bun.lock'), resolve(managedConfigDir, 'bun.lock')),
+                mirrorFile(resolve(sourceConfigDir, 'bun.lockb'), resolve(managedConfigDir, 'bun.lockb'))
+            ]);
+            await syncPluginDirectory(resolve(sourceConfigDir, 'plugins'), pluginDir);
+            if (!await mirrorFile(resolve(sourceConfigDir, 'opencode.json'), resolve(managedConfigDir, 'opencode.json'))) {
+                await writeJsonFile(resolve(managedConfigDir, 'opencode.json'), DEFAULT_OPENCODE_CONFIG);
+            }
+        }
+        else {
+            await syncPluginDirectory(undefined, pluginDir);
+            if (!await pathExists(resolve(managedConfigDir, 'opencode.json'))) {
+                await writeJsonFile(resolve(managedConfigDir, 'opencode.json'), DEFAULT_OPENCODE_CONFIG);
+            }
+        }
+        if (enabled) {
+            await mkdir(pluginDir, { recursive: true });
+            await writeFile(managedPluginPath, buildManagedPluginSource(), 'utf8');
+        }
+        else {
+            await rm(managedPluginPath, { force: true });
+        }
+        env.OPENCODE_CONFIG_DIR = managedConfigDir;
+        env.__VF_PROJECT_AI_OPENCODE_NATIVE_HOOKS_AVAILABLE__ = enabled ? '1' : '0';
+        return enabled;
+    }
+    catch (error) {
+        logger.warn('[opencode hooks] failed to install native hook bridge', error);
+        env.__VF_PROJECT_AI_OPENCODE_NATIVE_HOOKS_AVAILABLE__ = '0';
+        return false;
+    }
+};

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

@@ -0,0 +1,14 @@
+import type { AdapterCtx, AdapterQueryOptions } from '@vibe-forge/types';
+import type { OpenCodeAdapterConfig } from './shared';
+export declare const buildChildEnv: (params: {
+    ctx: AdapterCtx;
+    options: AdapterQueryOptions;
+    adapterConfig: OpenCodeAdapterConfig;
+    systemPromptFile?: string;
+}) => Promise<{
+    cliModel: string | undefined;
+    env: {
+        [k: string]: string;
+    };
+}>;
+export declare const ensureSystemPromptFile: (ctx: AdapterCtx, options: AdapterQueryOptions) => Promise<string | undefined>;