@mirrowel/opencode-openshare 0.0.0-stage → 0.1.1

package/dist/ui-prefs.d.ts

@@ -0,0 +1,16 @@
+export declare const UI_WIDTH_KV = "openshare.ui-width";
+export declare const UI_HEIGHT_PERCENT_KV = "openshare.ui-height-percent";
+export type DialogWidth = "medium" | "large" | "xlarge";
+export declare const HEIGHT_PERCENT_MIN = 25;
+export declare const HEIGHT_PERCENT_MAX = 100;
+/** what each width means in columns (opencode's fixed dialog widths) */
+export declare const DIALOG_WIDTH_COLUMNS: Record<DialogWidth, number>;
+export declare function clampHeightPercent(value: number): number;
+export declare function nextDialogWidth(width: DialogWidth): DialogWidth;
+/** kv read with validation; falls back to the default on garbage. */
+export declare function kvWidthOf(kv: {
+    get<Value = unknown>(key: string, fallback?: Value): Value;
+}): DialogWidth;
+export declare function kvHeightPercentOf(kv: {
+    get<Value = unknown>(key: string, fallback?: Value): Value;
+}): number;

package/dist/ui-prefs.js

@@ -0,0 +1,27 @@
+// Host-agnostic dialog size preferences (owner decision 2026-10-19: host
+// kv, not the config file — UI settings are per-host and synced by
+// opencode itself). dialog width maps to the host's fixed dialog widths;
+// height is a percent of terminal rows. v1 dialogs apply these directly
+// (dialogs.tsx); the settings dialog edits them through this module so the
+// flows stay host-agnostic.
+export const UI_WIDTH_KV = "openshare.ui-width";
+export const UI_HEIGHT_PERCENT_KV = "openshare.ui-height-percent";
+export const HEIGHT_PERCENT_MIN = 25;
+export const HEIGHT_PERCENT_MAX = 100;
+/** what each width means in columns (opencode's fixed dialog widths) */
+export const DIALOG_WIDTH_COLUMNS = { medium: 60, large: 88, xlarge: 116 };
+export function clampHeightPercent(value) {
+    return Math.max(HEIGHT_PERCENT_MIN, Math.min(HEIGHT_PERCENT_MAX, Math.round(value)));
+}
+export function nextDialogWidth(width) {
+    return width === "medium" ? "large" : width === "large" ? "xlarge" : "medium";
+}
+/** kv read with validation; falls back to the default on garbage. */
+export function kvWidthOf(kv) {
+    const value = kv.get(UI_WIDTH_KV, "large");
+    return value === "medium" || value === "large" || value === "xlarge" ? value : "large";
+}
+export function kvHeightPercentOf(kv) {
+    const value = kv.get(UI_HEIGHT_PERCENT_KV, 50);
+    return typeof value === "number" && Number.isFinite(value) ? clampHeightPercent(value) : 50;
+}

package/dist/v2-server.d.ts

@@ -0,0 +1,81 @@
+import { type MessageInfo, type PartInfo } from "./core.js";
+type V2Event = {
+    type: string;
+    data?: Record<string, unknown>;
+    [key: string]: unknown;
+};
+type V2Message = {
+    id: string;
+    type: string;
+    time?: {
+        created?: number;
+        completed?: number;
+        streamed?: number;
+    };
+    text?: string;
+    agent?: string;
+    model?: {
+        providerID: string;
+        id?: string;
+        modelID?: string;
+    };
+    content?: Array<Record<string, unknown>>;
+    error?: {
+        message?: string;
+    } | null;
+    metadata?: Record<string, unknown>;
+};
+type V2SessionClient = {
+    get(input: {
+        sessionID: string;
+    }): Promise<unknown>;
+    update(input: {
+        sessionID: string;
+        title?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<unknown>;
+    list(input?: {
+        directory?: string;
+        parentID?: string;
+        cursor?: string;
+        limit?: number;
+    }): Promise<unknown>;
+    diff(input: {
+        sessionID: string;
+    }): Promise<unknown>;
+    remove?(input: {
+        sessionID: string;
+    }): Promise<unknown>;
+};
+type V2MessageClient = {
+    list(input: {
+        sessionID: string;
+        limit?: number;
+        cursor?: string;
+    }): Promise<unknown>;
+};
+type V2Context = {
+    event?: {
+        subscribe(options?: {
+            signal?: AbortSignal;
+        }): AsyncIterable<V2Event>;
+    };
+    client?: {
+        session?: V2SessionClient;
+        message?: V2MessageClient;
+    };
+    options?: Record<string, unknown>;
+    app?: {
+        name?: string;
+        version?: string;
+        channel?: string;
+    };
+    signal?: AbortSignal;
+};
+/** v2 flat message -> { info, parts } in the v1 shapes the viewer speaks. */
+export declare function convertV2Message(message: V2Message, sessionID: string): {
+    info: MessageInfo;
+    parts: PartInfo[];
+} | undefined;
+export declare function createV2ServerSetup(): (context: V2Context) => Promise<(() => void) | void>;
+export {};

package/dist/v2-server.js

@@ -0,0 +1,402 @@
+// Open(code)Share — OpenCode v2 server setup.
+//
+// The v2 host validates `default` as `{ id, setup }` and calls setup with
+// the v2 plugin context (packages/plugin/src/promise). The v2 world is
+// shaped differently from v1 in three places this adapter bridges:
+//
+//  1. Events: v2 publishes fine-grained domain events
+//     (session.metadata.updated, session.text.started, session.tool.*,
+//     session.step.*) — not v1's coarse session/message/part updates.
+//     Mapping strategy: structural events (created/deleted/metadata/
+//     status) pass into the engine directly; content events trigger a
+//     debounced re-sync that pulls the fresh message list through the
+//     client. The engine's keyed queue makes re-syncs idempotent, and
+//     correctness never depends on decoding every fine-grained shape.
+//
+//  2. Client: the v2 client speaks /api/session with {sessionID} inputs,
+//     unwrapped outputs and cursor pagination. The adapter below presents
+//     the v1-shaped ClientApi the engine already speaks, including the
+//     v2-message -> v1 message+parts conversion (the worker/viewer
+//     contract is the v1 Data[] format).
+//
+//  3. Share mode: v2 auto-discovers the package's ./tui entrypoint, so
+//     presence detection cannot scan tui.json. The adapter applies the
+//     v2-native rule instead: when the plugin's own package declares the
+//     tui entrypoint (oc-plugin), a human drives sharing -> manual; the
+//     single-file build (no package) stays all-mode. Explicit shareMode
+//     config still wins.
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { METADATA_KEY, moduleDir, packageRoot } from "./config.js";
+import { createEngine } from "./core.js";
+// --- v2 message -> v1 items ---------------------------------------------------
+function toolContentText(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((item) => {
+            if (typeof item === "string")
+                return item;
+            if (item && typeof item === "object") {
+                const record = item;
+                if (typeof record.text === "string")
+                    return record.text;
+            }
+            return "";
+        })
+            .join("");
+    }
+    return "";
+}
+function convertToolState(state) {
+    if (!state || typeof state !== "object")
+        return { status: "pending" };
+    const record = state;
+    const status = String(record.status ?? "pending");
+    const mapped = {};
+    if (status === "streaming" || status === "running")
+        mapped.status = "running";
+    else if (status === "completed")
+        mapped.status = "completed";
+    else if (status === "failed" || status === "error")
+        mapped.status = "error";
+    else
+        mapped.status = "pending";
+    if (record.input !== undefined)
+        mapped.input = record.input;
+    if (record.output !== undefined)
+        mapped.output = toolContentText(record.output);
+    if (record.error !== undefined)
+        mapped.error = record.error;
+    if (record.time !== undefined)
+        mapped.time = record.time;
+    return mapped;
+}
+/** v2 flat message -> { info, parts } in the v1 shapes the viewer speaks. */
+export function convertV2Message(message, sessionID) {
+    if (!message || typeof message.id !== "string")
+        return undefined;
+    const base = {
+        id: message.id,
+        sessionID,
+    };
+    if (message.type === "user") {
+        return {
+            info: {
+                ...base,
+                role: "user",
+                time: { created: message.time?.created ?? 0 },
+                text: message.text ?? "",
+            },
+            parts: [],
+        };
+    }
+    if (message.type === "assistant") {
+        const parts = [];
+        const content = Array.isArray(message.content) ? message.content : [];
+        content.forEach((block, index) => {
+            const record = block;
+            const kind = String(record.type ?? "");
+            if (kind === "text") {
+                parts.push({
+                    id: `${message.id}_t${index}`,
+                    messageID: message.id,
+                    sessionID,
+                    type: "text",
+                    text: String(record.text ?? ""),
+                    synthetic: false,
+                    time: { start: message.time?.created ?? 0, end: message.time?.completed ?? 0 },
+                });
+            }
+            else if (kind === "reasoning") {
+                parts.push({
+                    id: `${message.id}_r${index}`,
+                    messageID: message.id,
+                    sessionID,
+                    type: "reasoning",
+                    text: String(record.text ?? ""),
+                    synthetic: false,
+                    time: { start: message.time?.created ?? 0, end: message.time?.completed ?? 0 },
+                });
+            }
+            else if (kind === "tool") {
+                parts.push({
+                    id: String(record.id ?? `${message.id}_tool${index}`),
+                    messageID: message.id,
+                    sessionID,
+                    type: "tool",
+                    tool: String(record.name ?? "unknown"),
+                    state: convertToolState(record.state),
+                    synthetic: false,
+                });
+            }
+        });
+        return {
+            info: {
+                ...base,
+                role: "assistant",
+                agent: message.agent,
+                model: message.model
+                    ? { providerID: message.model.providerID, modelID: message.model.modelID ?? message.model.id }
+                    : undefined,
+                time: { created: message.time?.created ?? 0, completed: message.time?.completed ?? 0 },
+            },
+            parts,
+        };
+    }
+    return undefined;
+}
+// --- v2 client -> engine ClientApi ---------------------------------------------
+function adaptSessionClient(session, message, directory) {
+    if (!session)
+        return undefined;
+    const loc = () => (directory ? { directory } : undefined);
+    const listAll = async () => {
+        const out = [];
+        let cursor;
+        for (let page = 0; page < 50; page++) {
+            const res = (await session.list({ ...loc(), cursor, limit: 100 }));
+            const data = res?.data;
+            if (Array.isArray(data))
+                out.push(...data);
+            const next = res?.cursor?.next ?? undefined;
+            if (!next || !Array.isArray(data) || data.length === 0)
+                break;
+            cursor = next;
+        }
+        return out;
+    };
+    const listMessages = async (sessionID) => {
+        if (!message)
+            return [];
+        const out = [];
+        let cursor;
+        for (let page = 0; page < 50; page++) {
+            const res = (await message.list({ sessionID, limit: 100, cursor }));
+            const data = res?.data;
+            if (!Array.isArray(data))
+                break;
+            for (const raw of data) {
+                const converted = convertV2Message(raw, sessionID);
+                if (converted)
+                    out.push(converted);
+            }
+            const next = res?.cursor?.next ?? undefined;
+            if (!next || data.length === 0)
+                break;
+            cursor = next;
+        }
+        return out;
+    };
+    return {
+        session: {
+            async get(input) {
+                const res = await session.get({ sessionID: input.path.id });
+                return { data: res };
+            },
+            async update(input) {
+                const body = input.body;
+                const res = await session.update({ sessionID: input.path.id, title: body.title, metadata: body.metadata });
+                return { data: res };
+            },
+            async list() {
+                return { data: await listAll() };
+            },
+            async messages(input) {
+                return { data: await listMessages(input.path.id) };
+            },
+            async diff(input) {
+                const res = await session.diff({ sessionID: input.path.id });
+                return { data: res };
+            },
+        },
+    };
+}
+// --- event classification --------------------------------------------------------
+const SESSION_ITEM_EVENTS = new Set([
+    "session.created",
+    "session.renamed",
+    "session.metadata.updated",
+    "session.agent.selected",
+    "session.model.selected",
+    "session.moved",
+    "session.permissions",
+    "session.compaction.started",
+    "session.compaction.ended",
+]);
+const CONTENT_EVENTS_PREFIXES = [
+    "session.text.",
+    "session.reasoning.",
+    "session.tool.",
+    "session.message.",
+    "session.step.streamed",
+];
+const BUSY_EVENTS = new Set(["session.step.started", "session.execution.started"]);
+const IDLE_EVENTS = new Set(["session.step.ended", "session.execution.succeeded", "session.execution.interrupted"]);
+const ERROR_EVENTS = new Set(["session.step.failed", "session.tool.failed", "session.retry.scheduled"]);
+function eventSessionID(event) {
+    const data = event.data;
+    if (data && typeof data === "object" && typeof data.sessionID === "string") {
+        return data.sessionID;
+    }
+    return undefined;
+}
+// --- the setup ---------------------------------------------------------------------
+function resolveV2ShareMode(options) {
+    const explicit = options?.["shareMode"] ?? process.env.OPENSHARE_SHARE_MODE;
+    if (explicit === "all" || explicit === "manual")
+        return explicit;
+    // v2-native presence: the v2 host auto-loads ./tui for packages that
+    // declare it. The single-file build ships no package.json next to it.
+    try {
+        const root = packageRoot(moduleDir());
+        const pkgPath = join(root, "package.json");
+        if (existsSync(pkgPath)) {
+            const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+            const declared = pkg["oc-plugin"];
+            if (Array.isArray(declared) && declared.includes("tui"))
+                return "manual";
+        }
+    }
+    catch { }
+    return undefined;
+}
+export function createV2ServerSetup() {
+    return async (context) => {
+        if (!context?.event?.subscribe || !context.client?.session) {
+            // v1 directory loads call BOTH `server` and `setup` on the default
+            // export; the v1 input arrives here and trips this guard. That is
+            // expected on v1 — stay inert and quiet (debug file only).
+            if (process.env.OPENSHARE_DEBUG_FILE) {
+                try {
+                    console.error(`[${METADATA_KEY}] v2 setup not applicable on this host — sharing handled by the server entry`);
+                }
+                catch { }
+            }
+            return () => { };
+        }
+        const directory = context.directory;
+        const client = adaptSessionClient(context.client.session, context.client.message, directory);
+        const modeOverride = resolveV2ShareMode(context.options);
+        const engine = createEngine({
+            client,
+            pluginDir: moduleDir(),
+            directory,
+            options: modeOverride ? { ...context.options, shareMode: modeOverride } : context.options,
+        });
+        if (!engine.hooks.event) {
+            return () => { };
+        }
+        // debounced content re-sync per session: fetch info + messages through
+        // the client adapter and feed them into the engine as the v1 events it
+        // understands (session.updated / message.updated / message.part.updated).
+        // The engine's keyed queue makes repeated re-syncs idempotent.
+        const pendingRefresh = new Map();
+        const refresh = (sessionID) => {
+            let timer = pendingRefresh.get(sessionID);
+            if (timer)
+                clearTimeout(timer);
+            timer = setTimeout(() => {
+                pendingRefresh.delete(sessionID);
+                void (async () => {
+                    try {
+                        const info = await client.session.get({ path: { id: sessionID } });
+                        await engine.hooks.event({
+                            event: { type: "session.updated", properties: { sessionID, info: info.data ?? info } },
+                        });
+                        const messages = await client.session.messages?.({ path: { id: sessionID } });
+                        const list = (messages?.data ?? []);
+                        for (const message of list) {
+                            await engine.hooks.event({
+                                event: { type: "message.updated", properties: { sessionID, info: message.info } },
+                            });
+                            for (const part of message.parts ?? []) {
+                                await engine.hooks.event({
+                                    event: { type: "message.part.updated", properties: { sessionID, part } },
+                                });
+                            }
+                        }
+                    }
+                    catch {
+                        /* refresh is best-effort; the next event retries */
+                    }
+                })();
+            }, 400);
+            pendingRefresh.set(sessionID, timer);
+        };
+        const unsubscribe = (() => {
+            let stopped = false;
+            const run = async () => {
+                try {
+                    const stream = context.event.subscribe({ signal: context.signal });
+                    for await (const event of stream) {
+                        if (stopped)
+                            break;
+                        if (!event || typeof event.type !== "string")
+                            continue;
+                        const sid = eventSessionID(event);
+                        if (!sid)
+                            continue;
+                        const type = event.type;
+                        if (type === "session.deleted") {
+                            await engine.hooks.event({ event: { type, properties: { sessionID: sid } } });
+                            continue;
+                        }
+                        if (type === "message.removed" || type === "message.part.removed") {
+                            // undo cleanup: forwarded verbatim — the engine emits the
+                            // tombstones that purge the reverted items from the share
+                            const data = (event.data ?? {});
+                            await engine.hooks.event({
+                                event: { type, properties: { sessionID: sid, messageID: data.messageID, partID: data.partID } },
+                            });
+                            continue;
+                        }
+                        if (SESSION_ITEM_EVENTS.has(type)) {
+                            refresh(sid);
+                            continue;
+                        }
+                        if (BUSY_EVENTS.has(type)) {
+                            await engine.hooks.event({ event: { type: "session.status", properties: { sessionID: sid, status: { type: "busy" } } } });
+                            refresh(sid);
+                            continue;
+                        }
+                        if (IDLE_EVENTS.has(type)) {
+                            await engine.hooks.event({ event: { type: "session.status", properties: { sessionID: sid, status: { type: "idle" } } } });
+                            refresh(sid);
+                            continue;
+                        }
+                        if (type === "session.error" || type === "session.execution.failed") {
+                            // terminal failure: the share says error at the next idle
+                            // (recovered retries never set it)
+                            await engine.hooks.event({ event: { type: "session.error", properties: { sessionID: sid } } });
+                            continue;
+                        }
+                        if (ERROR_EVENTS.has(type)) {
+                            await engine.hooks.event({ event: { type: "session.status", properties: { sessionID: sid, status: { type: "retry" } } } });
+                            continue;
+                        }
+                        if (CONTENT_EVENTS_PREFIXES.some((prefix) => type.startsWith(prefix))) {
+                            refresh(sid);
+                            continue;
+                        }
+                    }
+                }
+                catch {
+                    /* stream ended or aborted */
+                }
+            };
+            void run();
+            return () => {
+                stopped = true;
+            };
+        })();
+        return () => {
+            unsubscribe();
+            for (const timer of pendingRefresh.values())
+                clearTimeout(timer);
+            pendingRefresh.clear();
+            void engine.hooks.dispose();
+        };
+    };
+}

package/dist/v2-tui.d.ts

@@ -0,0 +1,24 @@
+/**
+ * OpenCode v2 TUI plugin implementation: builds a ShareHostApi adapter
+ * over the v2 TUI plugin context so the unchanged share flows and settings
+ * dialog run on both hosts, and registers the same commands (one reactive
+ * keymap layer).
+ *
+ * Dialog bridging (family pattern): the v1 api exposes dialog components
+ * that RETURN JSX rendered inside an enclosing `dialog.replace(render)`
+ * entry; the v2 api only offers promise-based dialogs that open their own
+ * host entry. The bridge reconciles the two — `replace()` invokes the
+ * render thunk synchronously; if it returned nothing (a DialogX bridge
+ * already opened the host's own dialog), the caller's onClose is parked
+ * and invoked when that nested dialog is dismissed without a result.
+ */
+import type { ShareHostApi } from "./tui-host.js";
+import type { V2TuiContext, V2TuiSetup } from "./v2-types.js";
+/** Builds the v1-shaped ShareHostApi facade over a v2 TUI plugin context. */
+export declare function buildV2HostApi(context: V2TuiContext): ShareHostApi;
+/**
+ * v2 TUI plugin setup: registers the share commands (one reactive keymap
+ * layer). Session-context wiring (currentSessionID) finalizes in phase 4
+ * once the beta's session/route surface is verified.
+ */
+export declare function createV2TuiSetup(): V2TuiSetup;