@opencode-ai/plugin 0.0.0-dev-19025 → 0.0.0-dev-202609031800

package/dist/effect/integration.d.ts

@@ -1,80 +0,0 @@
-import type { ConnectionInfo } from "@opencode-ai/client";
-import type { IntegrationApi } from "@opencode-ai/client/effect/api";
-import { Credential } from "@opencode-ai/schema/credential";
-import { Form } from "@opencode-ai/schema/form";
-import type { Effect, Scope } from "effect";
-import type { Transform } from "./registration.js";
-type IntegrationRef = {
-    id: string;
-    name: string;
-};
-export interface IntegrationOAuthMethod {
-    readonly id: string;
-    readonly type: "oauth";
-    readonly label: string;
-    readonly form?: Form.Fields;
-}
-export interface IntegrationCommandMethod {
-    readonly id: string;
-    readonly type: "command";
-    readonly label: string;
-    readonly command: ReadonlyArray<string>;
-}
-export interface IntegrationKeyMethod {
-    readonly type: "key";
-    readonly label?: string;
-    readonly form?: Form.Fields;
-}
-export interface IntegrationEnvMethod {
-    readonly type: "env";
-    readonly names: ReadonlyArray<string>;
-}
-export type IntegrationMethod = IntegrationOAuthMethod | IntegrationCommandMethod | IntegrationKeyMethod | IntegrationEnvMethod;
-export type IntegrationOAuthAuthorization = {
-    readonly url: string;
-    readonly instructions: string;
-    readonly expiresAt?: number;
-} & ({
-    readonly mode: "auto";
-    readonly callback: Effect.Effect<Credential.OAuth, unknown>;
-} | {
-    readonly mode: "code";
-    readonly callback: (code: string) => Effect.Effect<Credential.OAuth, unknown>;
-});
-export type IntegrationOAuthMethodRegistration = {
-    readonly integrationID: string;
-    readonly method: IntegrationOAuthMethod;
-    readonly authorize: (answer: Form.Answer) => Effect.Effect<IntegrationOAuthAuthorization, unknown, Scope.Scope>;
-    readonly refresh?: (credential: Credential.OAuth) => Effect.Effect<Credential.OAuth, unknown>;
-    readonly label?: (credential: Credential.OAuth) => string | undefined;
-};
-export type IntegrationMethodRegistration = IntegrationOAuthMethodRegistration | {
-    readonly integrationID: string;
-    readonly method: IntegrationCommandMethod;
-} | {
-    readonly integrationID: string;
-    readonly method: IntegrationKeyMethod;
-} | {
-    readonly integrationID: string;
-    readonly method: IntegrationEnvMethod;
-};
-export interface IntegrationEditor {
-    list(): readonly IntegrationRef[];
-    get(id: string): IntegrationRef | undefined;
-    update(id: string, update: (integration: IntegrationRef) => void): void;
-    remove(id: string): void;
-    readonly method: {
-        list(integrationID: string): readonly IntegrationMethod[];
-        update(input: IntegrationMethodRegistration): void;
-        remove(integrationID: string, method: IntegrationMethod): void;
-    };
-}
-export interface IntegrationDomain extends Omit<IntegrationApi<unknown>, "wellknown"> {
-    readonly transform: Transform<IntegrationEditor>;
-    readonly reload: () => Effect.Effect<void>;
-    readonly connection: {
-        readonly active: (integrationID: string) => Effect.Effect<ConnectionInfo | undefined>;
-        readonly resolve: (connection: ConnectionInfo) => Effect.Effect<Credential.Value | undefined, unknown>;
-    };
-}
-export {};

package/dist/effect/integration.js

@@ -1,2 +0,0 @@
-import { Credential } from "@opencode-ai/schema/credential";
-import { Form } from "@opencode-ai/schema/form";

package/dist/effect/mcp.d.ts

@@ -1,15 +0,0 @@
-import type { McpApi } from "@opencode-ai/client/effect/api";
-import type { Mcp } from "@opencode-ai/schema/mcp";
-import type { Effect, Types } from "effect";
-import type { Transform } from "./registration.js";
-export interface MCPEditor {
-    list(): readonly [string, Types.DeepMutable<Mcp.ServerConfig>][];
-    get(name: string): Types.DeepMutable<Mcp.ServerConfig> | undefined;
-    set(name: string, config: Mcp.ServerConfig): void;
-    update(name: string, update: (config: Types.DeepMutable<Mcp.ServerConfig>) => void): void;
-    remove(name: string): void;
-}
-export interface MCPDomain extends Pick<McpApi<unknown>, "list"> {
-    readonly transform: Transform<MCPEditor>;
-    readonly reload: () => Effect.Effect<void>;
-}

package/dist/effect/permission.d.ts

@@ -1,21 +0,0 @@
-import type { PermissionApi } from "@opencode-ai/client/effect/api";
-import type { Agent } from "@opencode-ai/schema/agent";
-import type { Permission } from "@opencode-ai/schema/permission";
-import type { Session } from "@opencode-ai/schema/session";
-import type { Hooks } from "./registration.js";
-export interface PermissionEvaluation {
-    readonly sessionID: Session.ID;
-    readonly agent?: Agent.ID;
-    readonly action: string;
-    readonly resources: ReadonlyArray<string>;
-    readonly metadata?: Record<string, unknown>;
-    readonly source?: Permission.Source;
-    effect: Permission.Effect;
-    message?: string;
-}
-export interface PermissionHooks {
-    readonly evaluate: PermissionEvaluation;
-}
-export type PermissionDomain = Pick<PermissionApi<unknown>, "list" | "get" | "reply"> & {
-    readonly hook: Hooks<PermissionHooks>;
-};

package/dist/effect/plugin.d.ts

@@ -1,54 +0,0 @@
-import type { ExperimentalApi, GenerateApi, PluginApi } from "@opencode-ai/client/effect/api";
-import type { Location } from "@opencode-ai/schema/location";
-import type { Effect, Scope } from "effect";
-import type { PluginOptions } from "../options.js";
-import type { App } from "../app.js";
-import type { AgentDomain } from "./agent.js";
-import type { AISDKDomain } from "./aisdk.js";
-import type { CatalogDomain } from "./catalog.js";
-import type { CommandDomain } from "./command.js";
-import type { EventDomain } from "./event.js";
-import type { IntegrationDomain } from "./integration.js";
-import type { MCPDomain } from "./mcp.js";
-import type { PermissionDomain } from "./permission.js";
-import type { ReferenceDomain } from "./reference.js";
-import type { RpcDomain } from "./rpc.js";
-import type { SessionDomain } from "./session.js";
-import type { ShellDomain } from "./shell.js";
-import type { SkillDomain } from "./skill.js";
-import type { StorageDomain } from "./storage.js";
-import type { ToolDomain } from "./tool.js";
-import type { VcsDomain } from "./vcs.js";
-import type { WebSearchDomain } from "./websearch.js";
-export interface Context {
-    readonly app: App;
-    readonly location: Location.Info;
-    readonly options: PluginOptions;
-    readonly agent: AgentDomain;
-    readonly aisdk: AISDKDomain;
-    readonly catalog: CatalogDomain;
-    readonly command: CommandDomain;
-    readonly event: EventDomain;
-    readonly experimental: {
-        readonly terminal: Pick<ExperimentalApi<unknown>["persistentPty"], "read">;
-    };
-    readonly integration: IntegrationDomain;
-    readonly mcp: MCPDomain;
-    readonly generate: GenerateApi<unknown>;
-    readonly permission: PermissionDomain;
-    readonly plugin: Pick<PluginApi<unknown>, "list">;
-    readonly reference: ReferenceDomain;
-    readonly rpc: RpcDomain;
-    readonly session: SessionDomain;
-    readonly shell: ShellDomain;
-    readonly skill: SkillDomain;
-    readonly storage: StorageDomain;
-    readonly tool: ToolDomain;
-    readonly vcs: VcsDomain;
-    readonly websearch: WebSearchDomain;
-}
-export interface Plugin<R = Scope.Scope> {
-    readonly id: string;
-    readonly effect: (context: Context) => Effect.Effect<void, never, R>;
-}
-export declare function define<R = Scope.Scope>(plugin: Plugin<R>): Plugin<R>;

package/dist/effect/reference.d.ts

@@ -1,14 +0,0 @@
-import type { ReferenceGitSource, ReferenceLocalSource } from "@opencode-ai/client";
-import type { ReferenceApi } from "@opencode-ai/client/effect/api";
-import type { Effect } from "effect";
-import type { Transform } from "./registration.js";
-export interface ReferenceEditor {
-    add(name: string, source: ReferenceLocalSource | ReferenceGitSource): void;
-    remove(name: string): void;
-    list(): readonly (readonly [string, ReferenceLocalSource | ReferenceGitSource])[];
-    get(name: string): ReferenceLocalSource | ReferenceGitSource | undefined;
-}
-export interface ReferenceDomain extends ReferenceApi<unknown> {
-    readonly transform: Transform<ReferenceEditor>;
-    readonly reload: () => Effect.Effect<void>;
-}

package/dist/effect/registration.d.ts

@@ -1,13 +0,0 @@
-import type { Effect, Scope } from "effect";
-export interface Registration {
-    readonly dispose: Effect.Effect<void>;
-}
-export interface ModelHookOptions {
-    /** Limits the hook to one provider. Unscoped hooks apply to every provider. */
-    readonly providerID?: string;
-}
-export type Hooks<Spec, Failures extends Record<keyof Spec, unknown> = Record<keyof Spec, never>> = <Name extends keyof Spec>(name: Name, callback: (input: Spec[Name]) => Effect.Effect<void, Failures[Name]>) => Effect.Effect<Registration, never, Scope.Scope>;
-export type ModelHooks<Spec, Failures extends Record<keyof Spec, unknown> = Record<keyof Spec, never>> = <Name extends keyof Spec>(name: Name, callback: (input: Spec[Name]) => Effect.Effect<void, Failures[Name]>, options?: Spec[Name] extends {
-    readonly model: unknown;
-} ? ModelHookOptions : never) => Effect.Effect<Registration, never, Scope.Scope>;
-export type Transform<Input> = (callback: (input: Input) => void) => Effect.Effect<Registration, never, Scope.Scope>;

package/dist/effect/rpc.d.ts

@@ -1,19 +0,0 @@
-import type { RpcApi } from "@opencode-ai/client/effect/api";
-export type { RpcClient } from "@opencode-ai/client/effect/api";
-import type { Rpc } from "@opencode-ai/schema/rpc";
-import type { Effect, Scope } from "effect";
-import type { Registration } from "./registration.js";
-export interface RpcCallContext<M extends Rpc.Method> {
-    readonly error: Rpc.ErrorFactory<M>;
-}
-export type RpcHandlers<D extends Rpc.Definition> = {
-    readonly [Name in keyof D["methods"]]: (input: Rpc.Output<D["methods"][Name]["input"]>, context: RpcCallContext<D["methods"][Name]>) => Effect.Effect<Rpc.HandlerOutput<D["methods"][Name]["output"]>, Rpc.HandlerError<D["methods"][Name]>>;
-};
-export interface RpcRegistration<D extends Rpc.Definition> extends Registration {
-    readonly events: {
-        readonly emit: (...args: Rpc.EventInput<D>) => Effect.Effect<void, unknown>;
-    };
-}
-export interface RpcDomain extends RpcApi<Rpc.SystemError, never, unknown> {
-    readonly register: <const D extends Rpc.Definition>(definition: D, handlers: RpcHandlers<NoInfer<D>>) => Effect.Effect<RpcRegistration<D>, unknown, Scope.Scope>;
-}

package/dist/effect/session.d.ts

@@ -1,77 +0,0 @@
-import type { SessionApi } from "@opencode-ai/client/effect/api";
-import type { GenerationOptionsFields, Message, SystemPart } from "@opencode-ai/ai";
-import type { Agent } from "@opencode-ai/schema/agent";
-import type { Model } from "@opencode-ai/schema/model";
-import type { PromptInput } from "@opencode-ai/schema/prompt-input";
-import type { Session } from "@opencode-ai/schema/session";
-import type { SessionInbox } from "@opencode-ai/schema/session-inbox";
-import type { SessionError } from "@opencode-ai/schema/session-error";
-import type { SessionMessage } from "@opencode-ai/schema/session-message";
-import type { JsonSchema, Types } from "effect";
-import type { ModelHooks } from "./registration.js";
-export interface SessionPrompt {
-    readonly sessionID: Session.ID;
-    readonly messageID: SessionMessage.ID;
-    prompt: Types.DeepMutable<PromptInput.Prompt>;
-    metadata?: Record<string, unknown>;
-    delivery: SessionInbox.Delivery;
-}
-export interface SessionContext {
-    readonly sessionID: Session.ID;
-    readonly agent: Agent.ID;
-    readonly model: Model.Ref;
-    system: Array<SystemPart>;
-    messages: Array<Message>;
-    tools: Record<string, {
-        description: string;
-        input: JsonSchema.JsonSchema;
-    }>;
-    /** Request overrides; unset fields retain route and model defaults. */
-    generation: Types.DeepMutable<GenerationOptionsFields>;
-    providerOptions: Record<string, unknown>;
-}
-export interface SessionModelRequest {
-    readonly sessionID: Session.ID;
-    readonly agent: Agent.ID;
-    readonly model: Model.Ref;
-    baseURL?: string;
-    headers: Record<string, string>;
-}
-export interface SessionHttpRequest {
-    readonly sessionID: Session.ID;
-    readonly agent: Agent.ID;
-    readonly model: Model.Ref;
-    request: Request;
-}
-export interface SessionHttpResponse {
-    readonly sessionID: Session.ID;
-    readonly agent: Agent.ID;
-    readonly model: Model.Ref;
-    readonly request: Request;
-    response: Response;
-}
-export type SessionRetryDecision = {
-    retry: false;
-} | {
-    retry: true;
-    delay: number;
-};
-export interface SessionRetry {
-    readonly sessionID: Session.ID;
-    readonly agent: Agent.ID;
-    readonly model: Model.Ref;
-    readonly error: SessionError.Error;
-    readonly attempt: number;
-    decision: SessionRetryDecision;
-}
-export interface SessionHooks {
-    readonly prompt: SessionPrompt;
-    readonly context: SessionContext;
-    readonly "model.request": SessionModelRequest;
-    readonly "http.request": SessionHttpRequest;
-    readonly "http.response": SessionHttpResponse;
-    readonly retry: SessionRetry;
-}
-export type SessionDomain = Pick<SessionApi<unknown>, "create" | "get" | "switchAgent" | "switchModel" | "prompt" | "generate" | "command" | "synthetic" | "interrupt" | "rename" | "move" | "wait" | "context"> & {
-    readonly hook: ModelHooks<SessionHooks>;
-};

package/dist/effect/shell.d.ts

@@ -1,14 +0,0 @@
-import type { Hooks } from "./registration.js";
-export interface ShellCreateBefore {
-    command: string;
-    cwd: string;
-    timeout: number;
-    shell: string;
-    env: Record<string, string | undefined>;
-}
-export interface ShellHooks {
-    readonly "create.before": ShellCreateBefore;
-}
-export interface ShellDomain {
-    readonly hook: Hooks<ShellHooks>;
-}

package/dist/effect/skill.d.ts

@@ -1,15 +0,0 @@
-import type { SkillApi } from "@opencode-ai/client/effect/api";
-import { Skill } from "@opencode-ai/schema/skill";
-import type { Effect, Types } from "effect";
-import type { Transform } from "./registration.js";
-export interface SkillEditor {
-    list(): readonly Types.DeepMutable<Skill.Info>[];
-    get(id: string): Types.DeepMutable<Skill.Info> | undefined;
-    add(skill: Skill.Info): void;
-    update(id: string, update: (skill: Types.DeepMutable<Skill.Info>) => void): void;
-    remove(id: string): void;
-}
-export interface SkillDomain extends SkillApi<unknown> {
-    readonly transform: Transform<SkillEditor>;
-    readonly reload: () => Effect.Effect<void>;
-}

package/dist/effect/skill.js

@@ -1 +0,0 @@
-import { Skill } from "@opencode-ai/schema/skill";

package/dist/effect/storage.d.ts

@@ -1,8 +0,0 @@
-import type { Effect, Schema } from "effect";
-import type { StorageScanOptions, StorageScanResult } from "../storage.js";
-export interface StorageDomain {
-    readonly get: (key: string) => Effect.Effect<Schema.Json | undefined>;
-    readonly set: (key: string, value: Schema.Json) => Effect.Effect<void>;
-    readonly remove: (key: string) => Effect.Effect<void>;
-    readonly scan: (options: StorageScanOptions) => Effect.Effect<StorageScanResult>;
-}

package/dist/effect/tool.d.ts

@@ -1,52 +0,0 @@
-import { Tool } from "@opencode-ai/schema/tool";
-import type { Agent } from "@opencode-ai/schema/agent";
-import type { Session } from "@opencode-ai/schema/session";
-import type { SessionMessage } from "@opencode-ai/schema/session-message";
-import type { Effect, Types } from "effect";
-import type { Hooks, Transform } from "./registration.js";
-export interface ToolEditor {
-    list(): readonly (Tool.Info & {
-        readonly id: string;
-    })[];
-    get(id: string): (Tool.Info & {
-        readonly id: string;
-    }) | undefined;
-    namespace(namespace: Tool.Namespace): void;
-    add<Input extends Tool.ValueSchema<any>, Output extends Tool.ValueSchema<any> | undefined>(tool: Tool.Info<Input, Output>): void;
-    /** Updates an existing tool; missing IDs are ignored. */
-    update(id: string, update: (tool: Types.Mutable<Tool.Info>) => void): void;
-    remove(id: string): void;
-}
-export interface ToolHooks {
-    readonly "execute.before": {
-        tool: string;
-        readonly sessionID: Session.ID;
-        readonly agent: Agent.ID;
-        readonly messageID: SessionMessage.ID;
-        readonly id: Tool.CallID;
-        input: unknown;
-    };
-    readonly "execute.after": {
-        readonly tool: string;
-        readonly sessionID: Session.ID;
-        readonly agent: Agent.ID;
-        readonly messageID: SessionMessage.ID;
-        readonly id: Tool.CallID;
-        readonly input: unknown;
-    } & ({
-        readonly status: "completed";
-        result: Tool.Result;
-    } | {
-        readonly status: "error";
-        error: Tool.Error;
-    });
-}
-export interface ToolFailures extends Record<keyof ToolHooks, unknown> {
-    readonly "execute.before": Tool.Error;
-    readonly "execute.after": never;
-}
-export interface ToolDomain {
-    readonly transform: Transform<ToolEditor>;
-    readonly reload: () => Effect.Effect<void>;
-    readonly hook: Hooks<ToolHooks, ToolFailures>;
-}

package/dist/effect/tool.js

@@ -1 +0,0 @@
-import { Tool } from "@opencode-ai/schema/tool";

package/dist/effect/vcs.d.ts

@@ -1,41 +0,0 @@
-import type { VcsApi } from "@opencode-ai/client/effect/api";
-import type { FileDiff } from "@opencode-ai/schema/file-diff";
-import type { Vcs } from "@opencode-ai/schema/vcs";
-import type { Effect } from "effect";
-import type { Transform } from "./registration.js";
-export interface VcsScope {
-    readonly directory: string;
-    readonly worktree: string;
-    readonly canonical: string;
-    readonly store?: string;
-}
-export interface VcsBranchesInput extends VcsScope {
-    readonly search?: string;
-    readonly limit?: number;
-}
-export interface VcsDiffInput extends VcsScope {
-    readonly mode: Vcs.Mode;
-    readonly base?: string;
-    readonly context: number;
-    readonly maxOutputBytes: number;
-}
-export interface VcsDefinition {
-    readonly id: string;
-    readonly name: string;
-    readonly info: (input: VcsScope) => Effect.Effect<Vcs.Info, unknown>;
-    readonly base?: (input: VcsScope) => Effect.Effect<Vcs.Base | null, unknown>;
-    readonly branches: (input: VcsBranchesInput) => Effect.Effect<Vcs.BranchList, unknown>;
-    readonly status: (input: VcsScope) => Effect.Effect<readonly Vcs.FileStatus[], unknown>;
-    readonly diff: (input: VcsDiffInput) => Effect.Effect<readonly FileDiff.Info[], unknown>;
-}
-export interface VcsDomain extends VcsApi<unknown> {
-    readonly transform: Transform<VcsEditor>;
-    readonly reload: () => Effect.Effect<void>;
-}
-export interface VcsEditor {
-    add(definition: VcsDefinition): void;
-    readonly default: {
-        get(): string | undefined;
-        set(selection: string): void;
-    };
-}

package/dist/effect/websearch.d.ts

@@ -1,20 +0,0 @@
-import type { WebSearch } from "@opencode-ai/schema/websearch";
-import type { WebSearchApi } from "@opencode-ai/client/effect/api";
-import type { Effect } from "effect";
-import type { Transform } from "./registration.js";
-export interface WebSearchDefinition {
-    readonly id: string;
-    readonly name: string;
-    readonly execute: (input: WebSearch.ProviderInput) => Effect.Effect<readonly WebSearch.Result[], unknown>;
-}
-export interface WebSearchDomain extends WebSearchApi<unknown> {
-    readonly transform: Transform<WebSearchEditor>;
-    readonly reload: () => Effect.Effect<void>;
-}
-export interface WebSearchEditor {
-    add(definition: WebSearchDefinition): void;
-    readonly default: {
-        get(): string | false | undefined;
-        set(selection: string | false): void;
-    };
-}

package/dist/host.d.ts

@@ -1,12 +0,0 @@
-export * as Host from "./host.js";
-export interface Target {
-    readonly directory: string;
-    readonly name?: string;
-}
-export interface Entrypoints {
-    readonly server?: string;
-    readonly tui?: string;
-    readonly rpc?: string;
-}
-export declare function resolve(target: Target): Entrypoints;
-export declare function load(entrypoint: string): Promise<unknown>;

package/dist/host.js

@@ -1,33 +0,0 @@
-export * as Host from "./host.js";
-import path from "node:path";
-import { importModule, resolveModule } from "@opencode-ai/util/runtime-import";
-export function resolve(target) {
-    const entry = (subpaths) => {
-        for (const subpath of subpaths) {
-            const specifier = target.name
-                ? [target.name, subpath].filter(Boolean).join("/")
-                : path.resolve(target.directory, subpath || "index");
-            try {
-                return resolveModule(specifier, target.directory);
-            }
-            catch (error) {
-                if (!(error instanceof Error) ||
-                    !("code" in error) ||
-                    ![
-                        "ENOENT",
-                        "ENOTDIR",
-                        "MODULE_NOT_FOUND",
-                        "ERR_MODULE_NOT_FOUND",
-                        "ERR_PACKAGE_PATH_NOT_EXPORTED",
-                        "ERR_UNSUPPORTED_DIR_IMPORT",
-                    ].includes(String(error.code)))
-                    throw error;
-            }
-        }
-        return undefined;
-    };
-    return { server: entry(["server", ""]), tui: entry(["tui"]), rpc: entry(["rpc"]) };
-}
-export function load(entrypoint) {
-    return importModule(entrypoint);
-}

package/dist/promise/adapter.d.ts

@@ -1,12 +0,0 @@
-import type { Scope } from "effect";
-import type { Plugin } from "./plugin.js";
-/**
- * Adapts a Promise plugin into an Effect plugin so the existing Effect-only
- * Core plugin runtime can run it unchanged.
- *
- * Hook registrations created during the async `setup` attach to the plugin's
- * scope, so unloading the plugin disposes them. The captured fiber context
- * preserves boot-time batching, so Promise-plugin transforms still coalesce
- * into one reload per domain.
- */
-export declare function fromPromise(plugin: Plugin): import("../effect/plugin.js").Plugin<Scope.Scope>;