@opencode-compat/facade-plugin 0.1.0

package/README.md

@@ -0,0 +1,7 @@
+# @opencode-compat/facade-plugin
+
+Install-override stand-in for @opencode-ai/plugin (classic + v2/promise)
+
+**License:** MPL-2.0
+
+See the monorepo [README](../../README.md) and [OCP 0.1](../../docs/ocp/0.1.md).

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @opencode-compat/facade-plugin — install-override stand-in for `@opencode-ai/plugin`.
+ *
+ * Classic surface: Hooks types + `tool` re-export.
+ * Subpaths: `./tool`, `./tui`, `./v2/promise`, `./v2/effect`.
+ */
+export declare const PKG: "@opencode-compat/facade-plugin";
+export declare const VERSION: "0.1.0";
+export * from "./tool";
+export type { AuthHook, AuthOAuthResult, AuthOuathResult, AuthPrompt, BunShell, Config, Event, HostClient, Hooks, Message, Model, ModelV2, Part, Permission, Plugin, PluginInput, PluginModule, PluginOptions, Project, Provider, ProviderContext, ProviderHook, ProviderHookContext, ProviderV2, UserMessage, WorkspaceAdapter, WorkspaceInfo, WorkspaceTarget, } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,10 @@
+/**
+ * @opencode-compat/facade-plugin — install-override stand-in for `@opencode-ai/plugin`.
+ *
+ * Classic surface: Hooks types + `tool` re-export.
+ * Subpaths: `./tool`, `./tui`, `./v2/promise`, `./v2/effect`.
+ */
+export const PKG = "@opencode-compat/facade-plugin";
+export const VERSION = "0.1.0";
+export * from "./tool";
+//# sourceMappingURL=index.js.map

package/dist/tool.d.ts

@@ -0,0 +1,66 @@
+import { z } from "zod";
+export type ToolContext = {
+    sessionID: string;
+    messageID: string;
+    agent: string;
+    /**
+     * Current project directory for this session.
+     * Prefer this over process.cwd() when resolving relative paths.
+     */
+    directory: string;
+    /**
+     * Project worktree root for this session.
+     * Useful for generating stable relative paths (e.g. path.relative(worktree, absPath)).
+     */
+    worktree: string;
+    abort: AbortSignal;
+    metadata(input: {
+        title?: string;
+        metadata?: {
+            [key: string]: unknown;
+        };
+    }): void;
+    ask(input: AskInput): Promise<void>;
+};
+type AskInput = {
+    permission: string;
+    patterns: string[];
+    always: string[];
+    metadata: {
+        [key: string]: unknown;
+    };
+};
+export type ToolAttachment = {
+    type: "file";
+    mime: string;
+    url: string;
+    filename?: string;
+};
+export type ToolResult = string | {
+    title?: string;
+    output: string;
+    metadata?: {
+        [key: string]: unknown;
+    };
+    attachments?: ToolAttachment[];
+};
+type ToolFn = {
+    <Args extends z.ZodRawShape>(input: {
+        description: string;
+        args: Args;
+        execute(args: z.infer<z.ZodObject<Args>>, context: ToolContext): Promise<ToolResult>;
+    }): {
+        description: string;
+        args: Args;
+        execute(args: z.infer<z.ZodObject<Args>>, context: ToolContext): Promise<ToolResult>;
+    };
+    schema: typeof z;
+};
+/**
+ * Classic `tool()` helper — identity wrapper matching `@opencode-ai/plugin/tool`.
+ * Implemented in the facade so forks without remapping still get a working helper.
+ */
+export declare const tool: ToolFn;
+export type ToolDefinition = ReturnType<typeof tool>;
+export {};
+//# sourceMappingURL=tool.d.ts.map

package/dist/tool.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+/**
+ * Classic `tool()` helper — identity wrapper matching `@opencode-ai/plugin/tool`.
+ * Implemented in the facade so forks without remapping still get a working helper.
+ */
+export const tool = Object.assign(function tool(input) {
+    return input;
+}, { schema: z });
+//# sourceMappingURL=tool.js.map

package/dist/tui.d.ts

@@ -0,0 +1,44 @@
+export declare const PKG_TUI: "@opencode-compat/facade-plugin/tui";
+/** Loose portable stubs — full fidelity comes from native host tui. */
+export type TuiPlugin = (api: TuiPluginApi, options: Record<string, unknown> | undefined, meta: TuiPluginMeta) => Promise<void>;
+export type TuiPluginModule = {
+    id?: string;
+    tui: TuiPlugin;
+    server?: never;
+};
+export type TuiPluginState = "first" | "updated" | "same";
+export type TuiPluginEntry = {
+    id: string;
+    source: "file" | "npm" | "internal";
+    spec: string;
+    target: string;
+    requested?: string;
+    version?: string;
+    modified?: number;
+    first_time: number;
+    last_time: number;
+    time_changed: number;
+    load_count: number;
+    fingerprint: string;
+};
+export type TuiPluginMeta = TuiPluginEntry & {
+    state: TuiPluginState;
+};
+export type TuiPluginApi = {
+    [key: string]: unknown;
+};
+type NativeTui = Record<string, unknown>;
+export declare function getNativeTui(): Promise<NativeTui>;
+/**
+ * Async helpers that load native then invoke.
+ * Prefer these over the sync binds when the host plugin may not be preloaded.
+ */
+export declare function createBindingLookup(...args: unknown[]): Promise<unknown>;
+export declare function stringifyKeySequence(...args: unknown[]): Promise<unknown>;
+export declare function stringifyKeyStroke(...args: unknown[]): Promise<unknown>;
+export declare function formatCommandBindings(...args: unknown[]): Promise<unknown>;
+export declare function formatKeySequence(...args: unknown[]): Promise<unknown>;
+/** @deprecated Sync bind requires prior getNativeTui(); prefer async helpers. */
+export declare const createBindingLookupSync: (...args: unknown[]) => unknown;
+export {};
+//# sourceMappingURL=tui.d.ts.map

package/dist/tui.js

@@ -0,0 +1,83 @@
+/**
+ * Facade path for `@opencode-ai/plugin/tui`.
+ *
+ * Runtime values are loaded lazily from the host’s native plugin `./tui`.
+ * Portable type stubs cover the common TuiPlugin* surface for type-only imports.
+ */
+import { importNativePlugin } from "@opencode-compat/adapter";
+export const PKG_TUI = "@opencode-compat/facade-plugin/tui";
+let nativePromise;
+let nativeCache;
+export function getNativeTui() {
+    nativePromise ??= importNativePlugin("tui")
+        .then((mod) => {
+        nativeCache = mod;
+        return mod;
+    })
+        .catch((err) => {
+        nativePromise = undefined;
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`${PKG_TUI}: failed to load host native ./tui — ${message}. ` +
+            "Ensure a cooperating host (opencode/mimo/kilo) is detected and its plugin package is installed.");
+    });
+    return nativePromise;
+}
+function bind(name) {
+    return (...args) => {
+        if (!nativeCache) {
+            throw new Error(`${PKG_TUI}: native tui not loaded yet — call await getNativeTui() first, or use getNativeTui() for full exports. Missing eager bind: ${name}`);
+        }
+        const value = nativeCache[name];
+        if (typeof value !== "function") {
+            throw new Error(`${PKG_TUI}: native export missing: ${name}`);
+        }
+        return value(...args);
+    };
+}
+/**
+ * Async helpers that load native then invoke.
+ * Prefer these over the sync binds when the host plugin may not be preloaded.
+ */
+export async function createBindingLookup(...args) {
+    const native = await getNativeTui();
+    const fn = native.createBindingLookup;
+    if (typeof fn !== "function") {
+        throw new Error(`${PKG_TUI}: native export missing: createBindingLookup`);
+    }
+    return fn(...args);
+}
+export async function stringifyKeySequence(...args) {
+    const native = await getNativeTui();
+    const fn = native.stringifyKeySequence;
+    if (typeof fn !== "function") {
+        throw new Error(`${PKG_TUI}: native export missing: stringifyKeySequence`);
+    }
+    return fn(...args);
+}
+export async function stringifyKeyStroke(...args) {
+    const native = await getNativeTui();
+    const fn = native.stringifyKeyStroke;
+    if (typeof fn !== "function") {
+        throw new Error(`${PKG_TUI}: native export missing: stringifyKeyStroke`);
+    }
+    return fn(...args);
+}
+export async function formatCommandBindings(...args) {
+    const native = await getNativeTui();
+    const fn = native.formatCommandBindings;
+    if (typeof fn !== "function") {
+        throw new Error(`${PKG_TUI}: native export missing: formatCommandBindings`);
+    }
+    return fn(...args);
+}
+export async function formatKeySequence(...args) {
+    const native = await getNativeTui();
+    const fn = native.formatKeySequence;
+    if (typeof fn !== "function") {
+        throw new Error(`${PKG_TUI}: native export missing: formatKeySequence`);
+    }
+    return fn(...args);
+}
+/** @deprecated Sync bind requires prior getNativeTui(); prefer async helpers. */
+export const createBindingLookupSync = bind("createBindingLookup");
+//# sourceMappingURL=tui.js.map

package/dist/types.d.ts

@@ -0,0 +1,371 @@
+/**
+ * Portable classic plugin types for OCP facades.
+ * Structurally aligned with @opencode-ai/plugin@1.18.3 Hooks keys;
+ * SDK entity shapes are intentionally loose so facades do not hard-depend
+ * on a single fork’s generated client types.
+ */
+import type { Auth } from "@opencode-compat/facade-sdk";
+import type { ToolDefinition } from "./tool";
+/** Opaque host client — OpenCode `createOpencodeClient` / MiMo residual / Kilo `createKiloClient`. */
+export type HostClient = {
+    readonly [key: string]: unknown;
+};
+export type Project = {
+    id: string;
+    worktree: string;
+    vcsDir?: string;
+    vcs?: "git";
+    time: {
+        created: number;
+        initialized?: number;
+    };
+};
+export type Model = {
+    id: string;
+    providerID: string;
+    name: string;
+    [key: string]: unknown;
+};
+export type Provider = {
+    id: string;
+    name: string;
+    source: "env" | "config" | "custom" | "api";
+    env: string[];
+    key?: string;
+    options: Record<string, unknown>;
+    models: Record<string, Model>;
+    [key: string]: unknown;
+};
+export type ProviderV2 = {
+    id: string;
+    name?: string;
+    [key: string]: unknown;
+};
+export type ModelV2 = {
+    id: string;
+    providerID?: string;
+    [key: string]: unknown;
+};
+export type Permission = {
+    id: string;
+    type: string;
+    pattern?: string | string[];
+    sessionID: string;
+    messageID: string;
+    callID?: string;
+    title: string;
+    metadata: Record<string, unknown>;
+    time: {
+        created: number;
+    };
+};
+export type UserMessage = {
+    id: string;
+    sessionID: string;
+    role: "user";
+    time: {
+        created: number;
+    };
+    agent: string;
+    model: {
+        providerID: string;
+        modelID: string;
+    };
+    [key: string]: unknown;
+};
+export type Message = UserMessage | {
+    role: string;
+    id: string;
+    [key: string]: unknown;
+};
+export type Part = {
+    id?: string;
+    type?: string;
+    [key: string]: unknown;
+};
+export type Event = {
+    type: string;
+    properties?: unknown;
+};
+export type BunShell = {
+    (strings: TemplateStringsArray, ...values: unknown[]): unknown;
+    [key: string]: unknown;
+};
+export type ProviderContext = {
+    source: "env" | "config" | "custom" | "api";
+    info: Provider;
+    options: Record<string, unknown>;
+};
+export type WorkspaceInfo = {
+    id: string;
+    type: string;
+    name: string;
+    branch: string | null;
+    directory: string | null;
+    extra: unknown | null;
+    projectID: string;
+};
+export type WorkspaceTarget = {
+    type: "local";
+    directory: string;
+} | {
+    type: "remote";
+    url: string | URL;
+    headers?: Record<string, string>;
+};
+export type WorkspaceAdapter = {
+    name: string;
+    description: string;
+    configure(config: WorkspaceInfo): WorkspaceInfo | Promise<WorkspaceInfo>;
+    create(config: WorkspaceInfo, env: Record<string, string | undefined>, from?: WorkspaceInfo): Promise<void>;
+    remove(config: WorkspaceInfo): Promise<void>;
+    target(config: WorkspaceInfo): WorkspaceTarget | Promise<WorkspaceTarget>;
+};
+export type PluginInput = {
+    client: HostClient;
+    project: Project;
+    directory: string;
+    worktree: string;
+    experimental_workspace: {
+        register(type: string, adapter: WorkspaceAdapter): void;
+    };
+    serverUrl: URL;
+    $: BunShell;
+};
+export type PluginOptions = Record<string, unknown>;
+export type Config = {
+    plugin?: Array<string | [string, PluginOptions]>;
+    [key: string]: unknown;
+};
+export type Plugin = (input: PluginInput, options?: PluginOptions) => Promise<Hooks>;
+export type PluginModule = {
+    id?: string;
+    server: Plugin;
+    tui?: never;
+};
+type Rule = {
+    key: string;
+    op: "eq" | "neq";
+    value: string;
+};
+export type AuthHook = {
+    provider: string;
+    loader?: (auth: () => Promise<Auth>, provider: Provider) => Promise<Record<string, unknown>>;
+    methods: Array<{
+        type: "oauth";
+        label: string;
+        prompts?: AuthPrompt[];
+        authorize(inputs?: Record<string, string>): Promise<AuthOAuthResult>;
+    } | {
+        type: "api";
+        label: string;
+        prompts?: AuthPrompt[];
+        authorize?(inputs?: Record<string, string>): Promise<{
+            type: "success";
+            key: string;
+            provider?: string;
+            metadata?: Record<string, string>;
+        } | {
+            type: "failed";
+        }>;
+    }>;
+};
+export type AuthPrompt = {
+    type: "text";
+    key: string;
+    message: string;
+    placeholder?: string;
+    validate?: (value: string) => string | undefined;
+    /** @deprecated Use `when` instead */
+    condition?: (inputs: Record<string, string>) => boolean;
+    when?: Rule;
+} | {
+    type: "select";
+    key: string;
+    message: string;
+    options: Array<{
+        label: string;
+        value: string;
+        hint?: string;
+    }>;
+    /** @deprecated Use `when` instead */
+    condition?: (inputs: Record<string, string>) => boolean;
+    when?: Rule;
+};
+export type AuthOAuthResult = {
+    url: string;
+    instructions: string;
+} & ({
+    method: "auto";
+    callback(): Promise<({
+        type: "success";
+        provider?: string;
+    } & ({
+        refresh: string;
+        access: string;
+        expires: number;
+        accountId?: string;
+        enterpriseUrl?: string;
+    } | {
+        key: string;
+        metadata?: Record<string, string>;
+    })) | {
+        type: "failed";
+    }>;
+} | {
+    method: "code";
+    callback(code: string): Promise<({
+        type: "success";
+        provider?: string;
+    } & ({
+        refresh: string;
+        access: string;
+        expires: number;
+        accountId?: string;
+        enterpriseUrl?: string;
+    } | {
+        key: string;
+        metadata?: Record<string, string>;
+    })) | {
+        type: "failed";
+    }>;
+});
+/** @deprecated Use AuthOAuthResult instead. */
+export type AuthOuathResult = AuthOAuthResult;
+export type ProviderHookContext = {
+    auth?: Auth;
+};
+export type ProviderHook = {
+    id: string;
+    models?: (provider: ProviderV2, ctx: ProviderHookContext) => Promise<Record<string, ModelV2>>;
+};
+/** OCP 0.1 portable classic Hooks (OpenCode ∩ Kilo core; MiMo gaps accepted). */
+export interface Hooks {
+    dispose?: () => Promise<void>;
+    event?: (input: {
+        event: Event;
+    }) => Promise<void>;
+    config?: (input: Config) => Promise<void>;
+    tool?: {
+        [key: string]: ToolDefinition;
+    };
+    auth?: AuthHook;
+    provider?: ProviderHook;
+    "chat.message"?: (input: {
+        sessionID: string;
+        agent?: string;
+        model?: {
+            providerID: string;
+            modelID: string;
+        };
+        messageID?: string;
+        variant?: string;
+    }, output: {
+        message: UserMessage;
+        parts: Part[];
+    }) => Promise<void>;
+    "chat.params"?: (input: {
+        sessionID: string;
+        agent: string;
+        model: Model;
+        provider: ProviderContext;
+        message: UserMessage;
+    }, output: {
+        temperature: number;
+        topP: number;
+        topK: number;
+        maxOutputTokens: number | undefined;
+        options: Record<string, unknown>;
+    }) => Promise<void>;
+    "chat.headers"?: (input: {
+        sessionID: string;
+        agent: string;
+        model: Model;
+        provider: ProviderContext;
+        message: UserMessage;
+    }, output: {
+        headers: Record<string, string>;
+    }) => Promise<void>;
+    "permission.ask"?: (input: Permission, output: {
+        status: "ask" | "deny" | "allow";
+    }) => Promise<void>;
+    "command.execute.before"?: (input: {
+        command: string;
+        sessionID: string;
+        arguments: string;
+    }, output: {
+        parts: Part[];
+    }) => Promise<void>;
+    "tool.execute.before"?: (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        args: unknown;
+    }) => Promise<void>;
+    "shell.env"?: (input: {
+        cwd: string;
+        sessionID?: string;
+        callID?: string;
+    }, output: {
+        env: Record<string, string>;
+    }) => Promise<void>;
+    "tool.execute.after"?: (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+        args: unknown;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+    "experimental.chat.messages.transform"?: (input: Record<string, never>, output: {
+        messages: {
+            info: Message;
+            parts: Part[];
+        }[];
+    }) => Promise<void>;
+    "experimental.chat.system.transform"?: (input: {
+        sessionID?: string;
+        model: Model;
+    }, output: {
+        system: string[];
+    }) => Promise<void>;
+    "experimental.provider.small_model"?: (input: {
+        provider: ProviderV2;
+    }, output: {
+        model?: ModelV2;
+    }) => Promise<void>;
+    "experimental.session.compacting"?: (input: {
+        sessionID: string;
+    }, output: {
+        context: string[];
+        prompt?: string;
+    }) => Promise<void>;
+    "experimental.compaction.autocontinue"?: (input: {
+        sessionID: string;
+        agent: string;
+        model: Model;
+        provider: ProviderContext;
+        message: UserMessage;
+        overflow: boolean;
+    }, output: {
+        enabled: boolean;
+    }) => Promise<void>;
+    "experimental.text.complete"?: (input: {
+        sessionID: string;
+        messageID: string;
+        partID: string;
+    }, output: {
+        text: string;
+    }) => Promise<void>;
+    "tool.definition"?: (input: {
+        toolID: string;
+    }, output: {
+        description: string;
+        parameters: unknown;
+    }) => Promise<void>;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/v2/effect.d.ts

@@ -0,0 +1,3 @@
+export declare const PKG_V2_EFFECT: "@opencode-compat/facade-plugin/v2/effect";
+export declare function define(_plugin: unknown): never;
+//# sourceMappingURL=effect.d.ts.map

package/dist/v2/effect.js

@@ -0,0 +1,14 @@
+/**
+ * Facade path for `@opencode-ai/plugin/v2/effect` — loud fail unless host capable.
+ */
+import { detect } from "@opencode-compat/profile";
+export const PKG_V2_EFFECT = "@opencode-compat/facade-plugin/v2/effect";
+export function define(_plugin) {
+    const result = detect();
+    if (result.supported && result.profile.capabilities.effectV2) {
+        throw new Error(`${PKG_V2_EFFECT}: host declares effectV2 but Effect host bridge is not implemented in this facade build`);
+    }
+    throw new Error(`${PKG_V2_EFFECT}: Effect v2 not supported by this host/facade build` +
+        (result.supported ? ` (host=${result.profile.id})` : ""));
+}
+//# sourceMappingURL=effect.js.map

package/dist/v2/promise.d.ts

@@ -0,0 +1,7 @@
+import { createPluginContext, createPromiseV2Host, injectLanguageModel, injectSdk, resolveProvider, runPromisePlugin, type LanguageModelInput, type LanguageModelV3Like, type Plugin, type PluginContext, type PromisePlugin, type PromiseV2Host } from "@opencode-compat/host-promise-v2";
+export declare const PKG_V2_PROMISE: "@opencode-compat/facade-plugin/v2/promise";
+export type { LanguageModelInput, LanguageModelV3Like, Plugin, PluginContext, PromisePlugin, PromiseV2Host, };
+/** Re-exports for hosts / tests that import through the facade path. */
+export { createPluginContext, createPromiseV2Host, injectLanguageModel, injectSdk, resolveProvider, runPromisePlugin, };
+export declare function define(plugin: Plugin): Plugin;
+//# sourceMappingURL=promise.d.ts.map

package/dist/v2/promise.js

@@ -0,0 +1,22 @@
+/**
+ * Facade path for `@opencode-ai/plugin/v2/promise`.
+ * T3 surface — requires host kit (`@opencode-compat/host-promise-v2`) + capable host.
+ */
+import { detect } from "@opencode-compat/profile";
+import { createPluginContext, createPromiseV2Host, define as hostDefine, injectLanguageModel, injectSdk, resolveProvider, runPromisePlugin, } from "@opencode-compat/host-promise-v2";
+export const PKG_V2_PROMISE = "@opencode-compat/facade-plugin/v2/promise";
+/** Re-exports for hosts / tests that import through the facade path. */
+export { createPluginContext, createPromiseV2Host, injectLanguageModel, injectSdk, resolveProvider, runPromisePlugin, };
+export function define(plugin) {
+    const result = detect();
+    if (!result.supported) {
+        throw new Error(`${PKG_V2_PROMISE}: host ${result.id} cannot load OCP plugins. ${result.message ?? ""}`.trim());
+    }
+    if (!result.profile.capabilities.promiseV2) {
+        throw new Error(`${PKG_V2_PROMISE}: Promise v2 not available on host "${result.profile.id}". ` +
+            "Wire @opencode-compat/host-promise-v2 from the OCP layer (or run on OpenCode). " +
+            "See docs/ocp/0.1.md §7.");
+    }
+    return hostDefine(plugin);
+}
+//# sourceMappingURL=promise.js.map

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@opencode-compat/facade-plugin",
+  "version": "0.1.0",
+  "description": "Install-override stand-in for @opencode-ai/plugin (classic + v2/promise)",
+  "type": "module",
+  "license": "MPL-2.0",
+  "author": "oakimov",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/oakimov/opencode-plugin-compat.git",
+    "directory": "packages/facade-plugin"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./tool": {
+      "types": "./dist/tool.d.ts",
+      "import": "./dist/tool.js"
+    },
+    "./tui": {
+      "types": "./dist/tui.d.ts",
+      "import": "./dist/tui.js"
+    },
+    "./v2/promise": {
+      "types": "./dist/v2/promise.d.ts",
+      "import": "./dist/v2/promise.js"
+    },
+    "./v2/effect": {
+      "types": "./dist/v2/effect.d.ts",
+      "import": "./dist/v2/effect.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md",
+    "!dist/**/*.map"
+  ],
+  "scripts": {
+    "build": "bunx tsc -p tsconfig.json",
+    "typecheck": "bunx tsc -p tsconfig.json --noEmit",
+    "prepack": "bunx tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "@opencode-compat/adapter": "0.1.0",
+    "@opencode-compat/facade-sdk": "0.1.0",
+    "@opencode-compat/host-promise-v2": "0.1.0",
+    "@opencode-compat/profile": "0.1.0",
+    "zod": "^4.1.8"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.3"
+  },
+  "bugs": {
+    "url": "https://github.com/oakimov/opencode-plugin-compat/issues"
+  },
+  "homepage": "https://github.com/oakimov/opencode-plugin-compat/tree/main/packages/facade-plugin#readme",
+  "keywords": [
+    "opencode",
+    "ocp",
+    "facade",
+    "plugin"
+  ],
+  "engines": {
+    "bun": ">=1.2.0"
+  }
+}