@opencode/plugin 0.0.0-reserved → 2.0.1

package/dist/tui/context.d.ts

@@ -0,0 +1,458 @@
+import type { AgentInfo, CommandInfo, FormCancelInput, FormInfo, FormReplyInput, IntegrationInfo, LocationRef, McpResource, McpServer, ModelInfo, OpenCodeClient, OpenCodeEvent, PermissionSavedInfo, PermissionRequest, Project, ProviderInfo, ReferenceInfo, SessionInfo, SessionMessageInfo, SessionInboxInfo, ShellInfo, SkillInfo, VcsInfo } from "@opencode/client";
+import type { ResolvedTheme } from "@opencode/theme/tui";
+import type { CliRenderer, KeyEvent, MarkdownCodeBlockRenderer, Renderable } from "@opentui/core";
+import type { JSX } from "@opentui/solid";
+import type { Store } from "solid-js/store";
+export interface Storage {
+    /**
+     * Durable JSON state: persisted to disk, survives hot reloads and TUI
+     * restarts, and stays live-synced across running TUI instances.
+     */
+    store<Value extends object>(key: string, options: {
+        readonly initial: Value;
+    }): readonly [Store<Value>, (mutation: (draft: Value) => void) => Promise<void>];
+    /**
+     * Ephemeral in-memory state: survives plugin hot reloads (old and new
+     * generations share the same live store) and is gone when the TUI exits.
+     * Updates are synchronous and values need not be JSON-serializable.
+     */
+    memory<Value extends object>(key: string, options: {
+        readonly initial: Value;
+    }): readonly [Store<Value>, (mutation: (draft: Value) => void) => void];
+}
+interface LocationCollection<Value> {
+    list(location?: LocationRef): Value[] | undefined;
+    sync(location?: LocationRef): Promise<void>;
+    invalidate(location?: LocationRef): void;
+}
+type OpenCodeEventMap = {
+    [Type in OpenCodeEvent["type"]]: Extract<OpenCodeEvent, {
+        type: Type;
+    }>;
+};
+export interface Data {
+    readonly on: <Type extends OpenCodeEvent["type"]>(type: Type, handler: (event: OpenCodeEventMap[Type]) => void) => () => void;
+    readonly listen: (handler: (event: {
+        details: OpenCodeEvent;
+    }) => void) => () => void;
+    readonly session: {
+        list(): SessionInfo[];
+        get(sessionID: string): SessionInfo | undefined;
+        root(sessionID: string): string;
+        family(sessionID: string): string[];
+        cost(sessionID: string): number;
+        status(sessionID: string): "idle" | "running";
+        readonly pending: {
+            list(sessionID: string): SessionInboxInfo[];
+            sync(sessionID: string): Promise<void>;
+            invalidate(sessionID: string): void;
+        };
+        sync(sessionID: string): Promise<void>;
+        invalidate(sessionID: string): void;
+        readonly message: {
+            list(sessionID: string): SessionMessageInfo[];
+            get(sessionID: string, messageID: string): SessionMessageInfo | undefined;
+            sync(sessionID: string): Promise<void>;
+            invalidate(sessionID: string): void;
+        };
+        readonly permission: {
+            list(sessionID: string): PermissionRequest[] | undefined;
+            sync(sessionID: string): Promise<void>;
+            invalidate(sessionID: string): void;
+        };
+        readonly form: {
+            list(sessionID: string, location?: LocationRef): Array<FormInfo & {
+                readonly location?: LocationRef;
+            }> | undefined;
+            sync(sessionID: string, location?: LocationRef): Promise<void>;
+            invalidate(sessionID: string, location?: LocationRef): void;
+            reply(input: FormReplyInput, location?: LocationRef): Promise<void>;
+            cancel(input: FormCancelInput, location?: LocationRef): Promise<void>;
+        };
+    };
+    readonly project: {
+        list(): Project[];
+        get(projectID: string): Project | undefined;
+        sync(): Promise<void>;
+        invalidate(): void;
+        readonly permission: {
+            list(projectID: string): PermissionSavedInfo[] | undefined;
+            sync(projectID: string): Promise<void>;
+            invalidate(projectID: string): void;
+        };
+    };
+    readonly shell: {
+        list(location?: LocationRef): ShellInfo[];
+        get(id: string): ShellInfo | undefined;
+        sync(location?: LocationRef): Promise<void>;
+        invalidate(location?: LocationRef): void;
+    };
+    readonly location: {
+        default(): LocationRef;
+        sync(location?: LocationRef): Promise<void>;
+        invalidate(location?: LocationRef): void;
+        readonly vcs: {
+            info(location?: LocationRef): VcsInfo | undefined;
+            sync(location?: LocationRef): Promise<void>;
+            invalidate(location?: LocationRef): void;
+        };
+        readonly agent: LocationCollection<AgentInfo>;
+        readonly command: LocationCollection<CommandInfo>;
+        readonly integration: LocationCollection<IntegrationInfo>;
+        readonly mcp: {
+            readonly server: LocationCollection<McpServer>;
+            readonly resource: LocationCollection<McpResource>;
+        };
+        readonly model: LocationCollection<ModelInfo>;
+        readonly provider: LocationCollection<ProviderInfo>;
+        readonly reference: LocationCollection<ReferenceInfo>;
+        readonly skill: LocationCollection<SkillInfo>;
+    };
+}
+export type Route = {
+    readonly type: "home";
+} | {
+    readonly type: "session";
+    readonly sessionID: string;
+} | {
+    readonly type: "plugin";
+    readonly id: string;
+    readonly name: string;
+    readonly data?: Record<string, any>;
+};
+export type Destination = Route | Omit<Extract<Route, {
+    readonly type: "plugin";
+}>, "id">;
+export interface Page {
+    readonly name: string;
+    readonly render: (input: {
+        readonly data?: Record<string, any>;
+    }) => JSX.Element;
+}
+type PromptFooterInput = {
+    readonly sessionID?: string;
+    readonly mode: "normal" | "shell";
+    readonly showDetails: boolean;
+};
+export type PanelPresentation = "panel" | "fullscreen";
+/** Client-local state of the selected session panel. The host owns its layout and input scope. */
+export interface PanelInput {
+    /** Selected content name, set by ui.panel.open. Contributions decide whether to render it. */
+    readonly name: string;
+    readonly sessionID: string;
+    readonly width: number;
+    readonly presentation: PanelPresentation;
+    readonly focused: boolean;
+    readonly focus: () => void;
+    readonly close: () => void;
+    readonly toggleFullscreen: () => void;
+}
+/**
+ * The host UI's slot tree. Every path is one slot: a named boundary a plugin
+ * may render around, inside, or take over. Paths are absolute and
+ * dot-separated, and a path contains every path it prefixes — replacing
+ * `prompt.footer` owns everything under `prompt.footer.*`.
+ *
+ * Each slot publishes an input: reactive props passed to every claim render
+ * targeting it. Inputs carry only what the SDK cannot answer — instance
+ * identity and client-local state. Paths and their inputs are documented
+ * API: coarse, few, and kept stable across host refactors.
+ */
+export interface SlotMap {
+    readonly app: Readonly<Record<string, never>>;
+    readonly "home.footer": Readonly<Record<string, never>>;
+    readonly "prompt.footer": PromptFooterInput;
+    readonly "prompt.footer.status": PromptFooterInput;
+    readonly "prompt.footer.file": PromptFooterInput;
+    readonly "session.composer.top": {
+        readonly sessionID: string;
+    };
+    readonly "session.panel": PanelInput;
+    readonly "sidebar.content": {
+        readonly sessionID: string;
+    };
+    readonly "sidebar.footer": {
+        readonly sessionID: string;
+    };
+}
+export type SlotPath = keyof SlotMap;
+/**
+ * One contribution to the slot tree. Exactly one placement key names an
+ * absolute target path:
+ * - `prepend` / `append`: first/last inside the target's boundary
+ * - `before` / `after`: siblings adjacent to the target, outside its boundary
+ * - `replace`: take over the target. The boundary itself survives — siblings
+ *   anchored `before`/`after` it still compose — but the original content and
+ *   every claim inside the boundary are suppressed and recorded, never
+ *   silently dropped. At the same target the last-enabled claim wins; an
+ *   ancestor replacement beats a descendant one regardless of enable order.
+ *
+ * A claim aimed at a path the host no longer publishes degrades: additive
+ * claims append to the nearest surviving ancestor, replacements are
+ * suppressed. Several claims at one anchor coexist in plugin enable order.
+ *
+ * `render` receives the target slot's input, reactively. The `?: never`
+ * fields make the variants mutually exclusive: a claim with two placement
+ * keys is a type error, not a silent priority pick.
+ */
+export type SlotClaim<Path extends SlotPath = SlotPath> = Path extends SlotPath ? {
+    readonly render: (input: SlotMap[Path]) => JSX.Element;
+} & ({
+    readonly prepend: Path;
+    readonly append?: never;
+    readonly before?: never;
+    readonly after?: never;
+    readonly replace?: never;
+} | {
+    readonly append: Path;
+    readonly prepend?: never;
+    readonly before?: never;
+    readonly after?: never;
+    readonly replace?: never;
+} | {
+    readonly before: Path;
+    readonly prepend?: never;
+    readonly append?: never;
+    readonly after?: never;
+    readonly replace?: never;
+} | {
+    readonly after: Path;
+    readonly prepend?: never;
+    readonly append?: never;
+    readonly before?: never;
+    readonly replace?: never;
+} | {
+    readonly replace: Path;
+    readonly prepend?: never;
+    readonly append?: never;
+    readonly before?: never;
+    readonly after?: never;
+}) : never;
+export interface App {
+    readonly version: string;
+    readonly channel: string;
+}
+export type ToastVariant = "info" | "success" | "warning" | "error";
+export interface ToastOptions {
+    readonly title?: string;
+    readonly message: string;
+    readonly variant?: ToastVariant;
+    readonly duration?: number;
+}
+export interface Toast {
+    show(options: ToastOptions): void;
+}
+export type AttentionWhen = "always" | "focused" | "blurred";
+export type AttentionSoundName = "default" | "question" | "permission" | "error" | "done" | "subagent_done";
+export type AttentionNotification = boolean | {
+    readonly when?: AttentionWhen;
+};
+export type AttentionSound = boolean | {
+    readonly name?: AttentionSoundName;
+    readonly volume?: number;
+    readonly when?: AttentionWhen;
+};
+export interface AttentionNotifyOptions {
+    readonly title?: string;
+    readonly message: string;
+    readonly notification?: AttentionNotification;
+    readonly sound?: AttentionSound;
+}
+export type AttentionNotifySkipReason = "attention_disabled" | "empty_message" | "blurred" | "focused" | "focus_unknown" | "renderer_destroyed";
+export interface AttentionNotifyResult {
+    readonly ok: boolean;
+    readonly notification: boolean;
+    readonly sound: boolean;
+    readonly skipped?: AttentionNotifySkipReason;
+}
+export interface Attention {
+    notify(options: AttentionNotifyOptions): Promise<AttentionNotifyResult>;
+}
+export type DialogSize = "medium" | "large" | "xlarge";
+export interface DialogOptions {
+    readonly size?: DialogSize;
+    readonly centered?: boolean;
+}
+export interface DialogAlertOptions {
+    readonly title: string;
+    readonly message: string;
+}
+export interface DialogConfirmOptions {
+    readonly title: string;
+    readonly message: string;
+    readonly label?: {
+        readonly confirm?: string;
+        readonly cancel?: string;
+    };
+}
+export interface DialogPromptOptions {
+    readonly title: string;
+    readonly description?: string;
+    readonly placeholder?: string;
+    readonly value?: string;
+}
+export interface DialogSelectOption<Value> {
+    readonly title: string;
+    readonly value: Value;
+    readonly description?: string;
+    readonly footer?: string;
+    readonly category?: string;
+    readonly disabled?: boolean;
+}
+export interface DialogSelectOptions<Value> {
+    readonly title: string;
+    readonly placeholder?: string;
+    readonly options: readonly DialogSelectOption<Value>[];
+    readonly current?: Value;
+}
+export interface Dialog {
+    /** Shows a dialog. */
+    show(render: () => JSX.Element, onClose?: () => void): void;
+    /** Sets the active dialog's presentation options. */
+    set(options: DialogOptions): void;
+    /** Closes the active dialog. */
+    clear(): void;
+    alert(options: DialogAlertOptions): Promise<void>;
+    confirm(options: DialogConfirmOptions): Promise<boolean | undefined>;
+    prompt(options: DialogPromptOptions): Promise<string | undefined>;
+    select<Value>(options: DialogSelectOptions<Value>): Promise<Value | undefined>;
+}
+export interface KeymapCommand {
+    /** Stable command and config keybind identifier. Omit for an inline command. */
+    readonly id?: string;
+    /** Optional label used by command discovery and keyboard-help UI. */
+    readonly title?: string;
+    /** Optional longer description. */
+    readonly description?: string;
+    /** Groups the command in discovery and keyboard-help UI. */
+    readonly group?: string;
+    /** Enables or disables the command. */
+    readonly enabled?: boolean | (() => boolean);
+    /** Configures automatic binding, or disables it for a named command. */
+    readonly bind?: false | string;
+    /** Adds a named command to the command palette. */
+    readonly palette?: true;
+    /** Adds a named command to prompt slash completion. */
+    readonly slash?: {
+        readonly name: string;
+        readonly aliases?: string[];
+        /** Keeps the slash command in the prompt and passes its raw input to run. */
+        readonly arguments?: true;
+    };
+    /** Promotes the command in discovery UI. */
+    readonly suggested?: boolean | (() => boolean);
+    /** Executes the command. Keyboard dispatch includes its event; programmatic dispatch does not. Return false to continue. */
+    readonly run: (input?: string, event?: KeyEvent) => void | false | Promise<void>;
+}
+export interface KeymapLayer {
+    /** Limits the layer to one OpenCode input mode. Use global to opt out; defaults to base. */
+    readonly mode?: string;
+    /** Enables or disables the complete layer. */
+    readonly enabled?: boolean | (() => boolean);
+    /** Limits the layer to a focused renderable. */
+    readonly target?: () => Renderable | null | undefined;
+    /** Resolves conflicts with other active layers. */
+    readonly priority?: number;
+    /** Commands owned by this layer. */
+    readonly commands?: readonly KeymapCommand[];
+    /** IDs of commands whose configured bindings should be active in this layer. */
+    readonly bindings?: readonly string[];
+}
+export interface KeymapPending {
+    readonly key: string;
+    readonly token?: string;
+}
+export interface KeymapActive {
+    readonly key: string;
+    readonly title?: string;
+    readonly description?: string;
+    readonly group?: string;
+    readonly continues: boolean;
+}
+export interface Keymap {
+    /** Creates a reactive keymap layer owned by the calling component. */
+    layer(input: () => KeymapLayer): void;
+    /** Dispatches a reachable command by ID. */
+    dispatch(id: string, input?: string): void;
+    /** Returns every formatted shortcut for a registered command. */
+    shortcuts(id: string): readonly string[];
+    /** Returns the currently reachable commands. Reactive when read in a Solid computation. */
+    commands(): readonly KeymapCommand[];
+    /** Returns the pending key sequence. Reactive when read in a Solid computation. */
+    pending(): readonly KeymapPending[];
+    /** Returns bindings reachable from the pending key sequence. Reactive when read in a Solid computation. */
+    active(): readonly KeymapActive[];
+    /** Controls mutually exclusive OpenCode input modes. */
+    readonly mode: {
+        /** Returns the active mode. */
+        current(): string;
+        /** Pushes a mode until the returned cleanup is called. */
+        push(mode: string): () => void;
+    };
+}
+export interface UI {
+    readonly dialog: Dialog;
+    readonly toast: Toast;
+    readonly format: {
+        path(value: string): string;
+    };
+    readonly router: {
+        register(page: Page): () => void;
+        navigate(destination: Destination): void;
+        current(): Route;
+    };
+    readonly panel: {
+        /** Opens the session.panel slot in the current session. */
+        open(name: string, options?: {
+            readonly presentation?: PanelPresentation;
+        }): boolean;
+        /** Closes this plugin's active panel. Other plugins' panels are unaffected. */
+        close(): void;
+        /** This plugin's active panel, if any. Reactive when read in a Solid computation. */
+        current(): {
+            readonly name: string;
+            readonly sessionID: string;
+        } | undefined;
+    };
+    readonly tabs: {
+        /** Returns whether session tabs are enabled for this TUI. */
+        enabled(): boolean;
+        /** Returns the currently open root-session tabs. Reactive when read in a Solid computation. */
+        list(): readonly {
+            readonly sessionID: string;
+            readonly title?: string;
+            readonly active: boolean;
+            readonly busy: boolean;
+            readonly attention: boolean;
+            readonly unread?: "activity" | "error";
+        }[];
+        /** Opens a tab for a session without focusing it. Returns false when tabs are disabled. */
+        open(sessionID: string): boolean;
+        /** Opens a tab when needed, then focuses it. Returns false when tabs are disabled. */
+        focus(sessionID: string): boolean;
+        /** Moves an open tab to an index and returns false when it is not open. */
+        move(sessionID: string, index: number): boolean;
+        /** Closes an open tab, or the active tab when omitted, and returns false when no tab matched. */
+        close(sessionID?: string): boolean;
+    };
+    /** Claims a place in the slot tree; see SlotClaim. */
+    readonly slot: (claim: SlotClaim) => () => void;
+}
+export interface Context {
+    readonly options: Readonly<Record<string, any>>;
+    readonly location: LocationRef | undefined;
+    readonly app: App;
+    readonly renderer: CliRenderer;
+    readonly client: OpenCodeClient;
+    readonly data: Data;
+    readonly attention: Attention;
+    readonly theme: ResolvedTheme;
+    readonly themeMode: "dark" | "light";
+    readonly markdown: {
+        registerCodeBlockRenderer(language: string, render: MarkdownCodeBlockRenderer): () => void;
+    };
+    readonly keymap: Keymap;
+    readonly storage: Storage;
+    readonly ui: UI;
+}
+export {};

package/dist/tui/index.d.ts

@@ -0,0 +1,2 @@
+export * as Plugin from "./plugin.js";
+export { PluginContextProvider, usePlugin } from "./solid.js";

package/dist/tui/index.js

@@ -0,0 +1,2 @@
+export * as Plugin from "./plugin.js";
+export { PluginContextProvider, usePlugin } from "./solid.js";

package/dist/tui/plugin.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from "./context.js";
+export type { Context };
+export type Cleanup = () => Promise<void> | void;
+export interface Definition {
+    readonly id: string;
+    readonly setup: (context: Context) => Promise<Cleanup | void> | Cleanup | void;
+}
+export declare function define(plugin: Definition): Definition;

package/dist/tui/plugin.js

@@ -0,0 +1,3 @@
+export function define(plugin) {
+    return plugin;
+}

package/dist/tui/solid.d.ts

@@ -0,0 +1,7 @@
+import { type JSX } from "solid-js";
+import type { Context } from "./context.js";
+export declare function PluginContextProvider(props: {
+    readonly value: Context;
+    readonly children: JSX.Element;
+}): JSX.Element;
+export declare function usePlugin(): Context;

package/dist/tui/solid.js

@@ -0,0 +1,16 @@
+import { createComponent, createContext, useContext } from "solid-js";
+const PluginContext = createContext();
+export function PluginContextProvider(props) {
+    return createComponent(PluginContext.Provider, {
+        value: props.value,
+        get children() {
+            return props.children;
+        },
+    });
+}
+export function usePlugin() {
+    const context = useContext(PluginContext);
+    if (!context)
+        throw new Error("PluginContextProvider is missing");
+    return context;
+}

package/dist/worktree.d.ts

@@ -0,0 +1,18 @@
+export interface WorktreeCreateInput {
+    readonly sourceDirectory: string;
+    /** Suggested destination after naming and collision handling. Strategies may return a different directory. */
+    readonly directory: string;
+    /** Starting ref, not the name of a new branch. Reject unsupported refs rather than ignoring them. */
+    readonly branch?: string;
+}
+export interface WorktreeRemoveInput {
+    readonly directory: string;
+    readonly force: boolean;
+}
+export interface WorktreeResult {
+    /** Actual directory created by the strategy, used for inventory and startup commands. */
+    readonly directory: string;
+}
+export interface WorktreeEntry extends WorktreeResult {
+    readonly type: "root" | "worktree";
+}

package/package.json

@@ -1,15 +1,87 @@
 {
+  "$schema": "https://json.schemastore.org/package.json",
   "name": "@opencode/plugin",
-  "version": "0.0.0-reserved",
-  "description": "OpenCode package bootstrap — not a functional release",
+  "version": "2.0.1",
+  "type": "module",
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/anomalyco/opencode.git"
-  },
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org",
-    "access": "public",
-    "tag": "reserved"
+  "scripts": {
+    "test": "bun test --only-failures",
+    "typecheck": "tsgo --noEmit",
+    "build": "tsc -p tsconfig.build.json"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/promise/index.js",
+      "types": "./dist/promise/index.d.ts"
+    },
+    "./effect": {
+      "import": "./dist/effect/index.js",
+      "types": "./dist/effect/index.d.ts"
+    },
+    "./host": {
+      "import": "./dist/host.js",
+      "types": "./dist/host.d.ts"
+    },
+    "./tui": {
+      "import": "./dist/tui/index.js",
+      "types": "./dist/tui/index.d.ts"
+    },
+    "./*": {
+      "import": "./dist/*.js",
+      "types": "./dist/*.d.ts"
+    }
+  },
+  "imports": {
+    "#plugin-source": {
+      "bun": "./dist/source.bun.js",
+      "node": "./dist/source.node.js",
+      "default": "./dist/source.node.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@ai-sdk/provider": "3.0.8",
+    "@opencode/ai": "2.0.1",
+    "@opencode/client": "2.0.1",
+    "@opencode/protocol": "2.0.1",
+    "@opencode/schema": "2.0.1",
+    "@opencode/util": "2.0.1",
+    "@standard-schema/spec": "1.1.0",
+    "effect": "4.0.0-rc.112",
+    "zod": "4.1.8"
+  },
+  "peerDependencies": {
+    "@opencode/theme": "2.0.1",
+    "@opentui/core": ">=0.5.10",
+    "@opentui/solid": ">=0.5.10",
+    "solid-js": ">=1.9.0"
+  },
+  "peerDependenciesMeta": {
+    "@opencode/theme": {
+      "optional": true
+    },
+    "@opentui/core": {
+      "optional": true
+    },
+    "@opentui/solid": {
+      "optional": true
+    },
+    "solid-js": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@opencode/theme": "2.0.1",
+    "@opentui/core": "0.5.10",
+    "@opentui/solid": "0.5.10",
+    "@tsconfig/bun": "1.0.9",
+    "@tsconfig/node22": "22.0.2",
+    "@types/bun": "1.4.0",
+    "@types/node": "24.12.2",
+    "solid-js": "1.9.15",
+    "typescript": "5.8.2",
+    "@typescript/native-preview": "7.0.0-dev.20251207.1"
   }
-}
+}

package/README.md

@@ -1,5 +0,0 @@
-# @opencode/plugin
-
-Bootstrap placeholder for the official [OpenCode](https://opencode.ai) release pipeline.
-
-This version contains no implementation or executable. Do not use it as a functional release.