@mirrowel/opencode-openshare 0.0.0-stage → 0.1.0

package/dist/v2-tui.js

@@ -0,0 +1,313 @@
+/**
+ * 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 { createSignal } from "solid-js";
+import { registerCommands } from "./commands.js";
+function pickThemeToken(source, ...path) {
+    let current = source;
+    for (const key of path) {
+        if (!current || typeof current !== "object")
+            return undefined;
+        current = current[key];
+    }
+    return current;
+}
+function buildV2Theme(context) {
+    // Read theme/mode live inside the getter so mid-session theme switches
+    // reach the flows.
+    return {
+        get current() {
+            const theme = context.theme;
+            const dark = context.themeMode === "dark";
+            const text = pickThemeToken(theme, "text", "default");
+            return {
+                text,
+                textMuted: pickThemeToken(theme, "text", "subdued") ?? text,
+                background: pickThemeToken(theme, "background", "default"),
+                backgroundPanel: pickThemeToken(theme, "background", "surface", "offset") ?? pickThemeToken(theme, "background", "default"),
+                primary: pickThemeToken(theme, "text", "action", "primary", "selected") ?? text,
+                secondary: pickThemeToken(theme, "hue", dark ? "interactive" : "neutral", dark ? 300 : 700) ?? text,
+                accent: pickThemeToken(theme, "hue", "accent", dark ? 200 : 800) ?? text,
+                success: pickThemeToken(theme, "text", "feedback", "success", "default") ?? text,
+                warning: pickThemeToken(theme, "text", "feedback", "warning", "default") ?? text,
+                error: pickThemeToken(theme, "text", "feedback", "error", "default") ?? text,
+                info: pickThemeToken(theme, "text", "feedback", "info", "default") ?? text,
+            };
+        },
+    };
+}
+function convertKeymapLayer(layer) {
+    const bindingsByName = new Map();
+    for (const binding of layer.bindings ?? []) {
+        if (!binding?.cmd)
+            continue;
+        const keys = bindingsByName.get(binding.cmd) ?? [];
+        keys.push(binding.key);
+        bindingsByName.set(binding.cmd, keys);
+    }
+    const commands = (layer.commands ?? []).map((command) => ({
+        id: command.name,
+        title: command.title ?? command.name,
+        description: command.desc,
+        group: command.group ?? command.category,
+        palette: true,
+        ...(command.slashName ? { slash: { name: command.slashName, ...(command.slashAliases?.length ? { aliases: command.slashAliases } : {}) } } : {}),
+        ...(command.suggested !== undefined ? { suggested: command.suggested } : {}),
+        ...(command.enabled !== undefined ? { enabled: command.enabled } : {}),
+        ...(bindingsByName.get(command.name)?.length ? { bind: bindingsByName.get(command.name).join(",") } : {}),
+        run: (_input, event) => command.run({
+            event: event
+                ? {
+                    preventDefault: () => event.preventDefault?.(),
+                    stopPropagation: () => event.stopPropagation?.(),
+                }
+                : undefined,
+        }),
+    }));
+    return { mode: layer.mode ?? "global", priority: layer.priority, commands };
+}
+/** Builds the v1-shaped ShareHostApi facade over a v2 TUI plugin context. */
+export function buildV2HostApi(context) {
+    const disposeFns = [];
+    // --- kv: synchronous read-your-writes mirror over the persistent store ---
+    const [kvStore, kvMutate] = context.storage.store("kv", { initial: {} });
+    const kvMirror = {};
+    for (const [key, value] of Object.entries(kvStore))
+        kvMirror[key] = value;
+    const kv = {
+        get(key, fallback) {
+            const value = key in kvMirror ? kvMirror[key] : kvStore[key];
+            return (value === undefined ? fallback : value);
+        },
+        set(key, value) {
+            kvMirror[key] = value;
+            void kvMutate((draft) => {
+                draft[key] = value;
+            }).catch(() => undefined);
+        },
+    };
+    // --- dialog bridging (see module doc comment) ---
+    const dialog = context.ui.dialog;
+    let nestedOnClose;
+    const settleNested = (dismissed) => {
+        const onClose = nestedOnClose;
+        nestedOnClose = undefined;
+        if (dismissed)
+            onClose?.();
+    };
+    return {
+        hostVersion: 2,
+        app: { version: context.app?.version },
+        client: context.client,
+        kv,
+        lifecycle: {
+            onDispose(fn) {
+                disposeFns.push(fn);
+            },
+        },
+        theme: buildV2Theme(context),
+        ui: {
+            toast: (input) => {
+                try {
+                    context.ui.toast.show({ title: input.title, message: input.message, variant: input.variant, duration: input.duration });
+                }
+                catch {
+                    /* toasts must never crash the flows */
+                }
+            },
+            dialog: {
+                replace(renderer, onClose) {
+                    nestedOnClose = undefined;
+                    let content;
+                    try {
+                        content = typeof renderer === "function" ? renderer() : renderer;
+                    }
+                    catch {
+                        content = undefined;
+                    }
+                    if (content === undefined || content === null) {
+                        nestedOnClose = onClose;
+                        return;
+                    }
+                    dialog.show(() => content, onClose);
+                },
+                clear() {
+                    nestedOnClose = undefined;
+                    dialog.clear();
+                },
+                setSize(size) {
+                    try {
+                        dialog.set({ size });
+                    }
+                    catch {
+                        /* size hints are best-effort */
+                    }
+                },
+            },
+            // Promise menus (v2 host dialogs are host-native and fully keyed).
+            async showMenu(props) {
+                const value = await dialog.select({
+                    title: props.title,
+                    placeholder: props.hint,
+                    current: props.current,
+                    options: props.options.map((option) => ({
+                        title: option.title,
+                        value: option.value,
+                        description: option.description,
+                        category: option.category,
+                        disabled: option.disabled,
+                    })),
+                });
+                return value;
+            },
+            async showConfirm(props) {
+                return (await dialog.confirm({ title: props.title, message: props.message, label: { confirm: props.confirmLabel } })) === true;
+            },
+            async showAlert(props) {
+                await dialog.alert({ title: props.title, message: props.message });
+            },
+            async showPrompt(props) {
+                return await dialog.prompt({ title: props.title, placeholder: props.placeholder, value: props.value });
+            },
+            DialogSelect(props) {
+                void dialog
+                    .select({
+                    title: props.title,
+                    placeholder: props.placeholder,
+                    current: props.current,
+                    options: props.options.map((option) => ({
+                        title: option.title,
+                        value: option.value,
+                        description: option.description,
+                        category: option.category,
+                        disabled: option.disabled,
+                    })),
+                })
+                    .then((value) => {
+                    if (value === undefined) {
+                        settleNested(true);
+                        return;
+                    }
+                    settleNested(false);
+                    const option = props.options.find((item) => item.value === value);
+                    if (option)
+                        props.onSelect(option);
+                })
+                    .catch(() => settleNested(true));
+            },
+            DialogPrompt(props) {
+                void dialog
+                    .prompt({ title: props.title, placeholder: props.placeholder, value: props.value })
+                    .then((value) => {
+                    settleNested(value === undefined);
+                    if (value === undefined)
+                        props.onCancel?.();
+                    else
+                        props.onConfirm(value);
+                })
+                    .catch(() => {
+                    settleNested(true);
+                    props.onCancel?.();
+                });
+            },
+            DialogConfirm(props) {
+                void dialog
+                    .confirm({ title: props.title, message: props.message, label: { confirm: props.confirmLabel } })
+                    .then((result) => {
+                    settleNested(result !== true);
+                    if (result === true)
+                        props.onConfirm();
+                    else
+                        props.onCancel?.();
+                })
+                    .catch(() => {
+                    settleNested(true);
+                    props.onCancel?.();
+                });
+            },
+            DialogAlert(props) {
+                void dialog
+                    .alert({ title: props.title, message: props.message })
+                    .then(() => {
+                    settleNested(false);
+                    props.onConfirm?.();
+                })
+                    .catch(() => {
+                    settleNested(true);
+                    props.onConfirm?.();
+                });
+            },
+        },
+        keymap: {
+            registerLayer(layer) {
+                // v2 layers are reactive: the input function re-evaluates when the
+                // signal flips, so "unregistering" disables the layer.
+                const [active, setActive] = createSignal(true);
+                try {
+                    context.keymap.layer(() => active()
+                        ? convertKeymapLayer(layer)
+                        : { mode: "global", enabled: false, commands: [], bindings: [] });
+                }
+                catch {
+                    return () => undefined;
+                }
+                return () => {
+                    setActive(false);
+                };
+            },
+        },
+        sessionInfo: () => undefined,
+        currentSessionID: undefined,
+        clipboard: {
+            // same belt-and-braces as the v1 facade: navigator may resolve as a
+            // silent no-op in the TUI runtime; OSC52 is the reliable path
+            async write(text) {
+                let ok = false;
+                try {
+                    const clip = navigator.clipboard;
+                    if (typeof clip?.writeText === "function") {
+                        await clip.writeText(text).then(() => {
+                            ok = true;
+                        }, () => { });
+                    }
+                }
+                catch { }
+                try {
+                    process.stdout.write(`\x1b]52;c;${Buffer.from(text, "utf8").toString("base64")}\x07`);
+                    ok = true;
+                }
+                catch { }
+                return ok;
+            },
+        },
+    };
+}
+/**
+ * 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 function createV2TuiSetup() {
+    return async (context) => {
+        const host = buildV2HostApi(context);
+        const sessionID = () => host.currentSessionID?.() ?? undefined;
+        const unregister = registerCommands(host, sessionID);
+        return () => {
+            try {
+                unregister();
+            }
+            catch { }
+        };
+    };
+}

package/dist/v2-types.d.ts

@@ -0,0 +1,134 @@
+/**
+ * Minimal structural types for the OpenCode v2 TUI plugin context subset
+ * used by this plugin. Hand-written on purpose (same policy as the server
+ * side and the family plugins): the v2 SDK is still beta and a v2 plugin
+ * module must not import the plugin SDK at runtime anyway. Keep in sync
+ * with the beta repo (packages/plugin/src/tui) when the API settles.
+ */
+export type V2TuiKeyEvent = {
+    preventDefault?(): void;
+    stopPropagation?(): void;
+    [key: string]: unknown;
+};
+export type V2KeymapCommand = {
+    id?: string;
+    title?: string;
+    description?: string;
+    group?: string;
+    enabled?: boolean | (() => boolean);
+    bind?: false | string;
+    palette?: true;
+    slash?: {
+        name: string;
+        aliases?: string[];
+        arguments?: true;
+    };
+    suggested?: boolean | (() => boolean);
+    run: (input?: string, event?: V2TuiKeyEvent) => void | false | Promise<void>;
+};
+export type V2KeymapLayer = {
+    mode?: string;
+    enabled?: boolean | (() => boolean);
+    priority?: number;
+    commands?: readonly V2KeymapCommand[];
+    bindings?: readonly string[];
+};
+export type V2DialogSelectOption<Value> = {
+    title: string;
+    value: Value;
+    description?: string;
+    category?: string;
+    disabled?: boolean;
+};
+export type V2LocationRef = {
+    directory: string;
+    workspaceID?: string;
+};
+export type V2TuiContext = {
+    options: Readonly<Record<string, unknown>>;
+    location?: unknown;
+    app: {
+        version?: string;
+        channel?: string;
+    };
+    renderer: {
+        root?: unknown;
+    };
+    client: any;
+    keymap: {
+        layer(input: () => V2KeymapLayer): void;
+        mode: {
+            current(): string;
+            push(mode: string): () => void;
+        };
+    };
+    storage: {
+        store<Value extends object>(key: string, options: {
+            initial: Value;
+        }): readonly [Value, (mutation: (draft: Value) => void) => Promise<void>];
+    };
+    theme: V2ResolvedTheme;
+    themeMode: "dark" | "light";
+    ui: {
+        dialog: {
+            show(render: () => unknown, onClose?: () => void): void;
+            set(options: {
+                size?: string;
+                centered?: boolean;
+            }): void;
+            clear(): void;
+            alert(options: {
+                title: string;
+                message: string;
+            }): Promise<void>;
+            confirm(options: {
+                title: string;
+                message: string;
+                label?: {
+                    confirm?: string;
+                    cancel?: string;
+                };
+            }): Promise<boolean | undefined>;
+            prompt(options: {
+                title: string;
+                description?: string;
+                placeholder?: string;
+                value?: string;
+            }): Promise<string | undefined>;
+            select<Value>(options: {
+                title: string;
+                placeholder?: string;
+                current?: Value;
+                options: readonly V2DialogSelectOption<Value>[];
+            }): Promise<Value | undefined>;
+        };
+        toast: {
+            show(options: {
+                title?: string;
+                message: string;
+                variant?: string;
+                duration?: number;
+            }): void;
+        };
+    };
+};
+export type V2ResolvedTheme = {
+    text: {
+        default: unknown;
+        subdued: unknown;
+        feedback: Record<string, {
+            default: unknown;
+        }>;
+        action: Record<string, Record<string, unknown>>;
+    };
+    background: {
+        default: unknown;
+        surface: {
+            offset: unknown;
+            overlay: unknown;
+        };
+    };
+    hue: Record<string, Record<string | number, unknown>>;
+    categorical?: ReadonlyArray<unknown>;
+};
+export type V2TuiSetup = (context: V2TuiContext) => Promise<(() => void) | void> | (() => void) | void;

package/dist/v2-types.js

@@ -0,0 +1,8 @@
+/**
+ * Minimal structural types for the OpenCode v2 TUI plugin context subset
+ * used by this plugin. Hand-written on purpose (same policy as the server
+ * side and the family plugins): the v2 SDK is still beta and a v2 plugin
+ * module must not import the plugin SDK at runtime anyway. Keep in sync
+ * with the beta repo (packages/plugin/src/tui) when the API settles.
+ */
+export {};

package/openshare.config.json

@@ -0,0 +1,16 @@
+{
+  "$comment": "Open(code)Share plugin config. Priority: OPENSHARE_* env vars > plugin options > this file > code defaults. Sync cadence keys are clamped into the worker's policy window (see worker SOCKET_POLICY/DEBOUNCE_MIN_MS/DEBOUNCE_MAX_MS/COMPLETED_DELAY_MAX_MS). Keys: workerUrl (your openshare-worker deployment; empty = plugin stays disabled), createToken (legacy: the worker's CREATE_TOKEN — keep OUT of git), servers (multi-server memberships: url -> {token, code, label, active}; the active entry (or the first) receives new sessions; with no token the plugin ENROLLS itself — public servers take anyone, private ones need a code from the hoster; enrolled tokens persist to ~/.config/opencode/openshare.config.json), debounceMs (sync interval: max time between syncs while streaming; default 10000), completedDelayMs (idle this long before the share says completed; default 5000, 0 = immediate), modelLabel ($Provider/$Model placeholders; literal text sends as-is; empty string hides the model), ttlDays (per-share TTL, capped by the worker), openTasksInNewTab (task rows open subagent pages in a new tab), authLogin/authPassword (optional read gate on the share pages; sent on create AND resume; empty on resume removes protection), spoolDir (temporary unacked-frame buffer; default XDG data home), urlFile (write each share URL to this file; empty = default openshare.urls.txt in the session's directory; \"none\" = no URL file), announceStderr (false silences the [openshare] live: / url file: log lines; the share itself is unaffected).",
+  "workerUrl": "",
+  "createToken": "",
+  "servers": {},
+  "debounceMs": 10000,
+  "completedDelayMs": 5000,
+  "modelLabel": "$Provider/$Model",
+  "ttlDays": 90,
+  "openTasksInNewTab": true,
+  "authLogin": "",
+  "authPassword": "",
+  "spoolDir": "",
+  "urlFile": "",
+  "announceStderr": true
+}

package/package.json

@@ -1,6 +1,100 @@
 {
   "name": "@mirrowel/opencode-openshare",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Open(code)Share — re:share: self-hosted session sharing for opencode. Server plugin (single file or package), optional TUI for interactive opt-in sharing.",
+  "license": "MIT",
+  "author": "Mirrowel",
+  "homepage": "https://github.com/Mirrowel/OpenShare#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Mirrowel/OpenShare.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Mirrowel/OpenShare/issues"
+  },
+  "main": "dist/server.js",
+  "types": "dist/server.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
+    },
+    "./tui": {
+      "types": "./dist/tui.d.ts",
+      "import": "./dist/tui.js"
+    },
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "import": "./dist/config.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "ci",
+    "openshare.config.json",
+    "tsconfig.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "share",
+    "session",
+    "sharing",
+    "collaboration"
+  ],
+  "oc-plugin": [
+    "server",
+    "tui"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "scripts": {
+    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build": "npm run clean && tsc --outDir dist --declaration && npm run build:tui && npm run build:standalone",
+    "build:tui": "bun scripts/build-tui.mjs",
+    "build:standalone": "bun scripts/build-standalone.mjs",
+    "typecheck": "tsc --noEmit",
+    "ci": "npm run release:intent:check && npm run ci:package",
+    "ci:package": "npm run typecheck && npm run build && npm run pack:dry-run",
+    "release:intent": "node scripts/set-release-intent.mjs",
+    "release:intent:check": "node scripts/check-release-intent.mjs",
+    "pack:dry-run": "node scripts/pack-dry-run.mjs",
+    "test:regression": "node scripts/regression-tests.mjs",
+    "prepublishOnly": "npm run typecheck && npm run build",
+    "test:manual": "node scripts/manual-tests.mjs",
+    "test:tui-flow": "node scripts/tui-flow-tests.mjs",
+    "test:v2": "node scripts/v2-mock-tests.mjs",
+    "test:auth": "node scripts/auth-tests.mjs",
+    "test:server-auth": "node scripts/auth-tests.mjs --backend bun",
+    "test:server-enroll": "node scripts/enroll-tests.mjs --backend bun",
+    "test:enroll": "node scripts/enroll-tests.mjs",
+    "test:fanout": "node scripts/fanout-tests.mjs",
+    "test": "node scripts/run-matrix.mjs",
+    "test:quick": "node scripts/run-matrix.mjs manual-core regression-tests tui-flow-tests v2-mock-tests auth-tests",
+    "test:cli": "node scripts/cli-test.mjs"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.8.0"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": ">=1.14.0",
+    "@opentui/solid": "^0.4.1"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=1.14.0"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}

package/src/banner.txt

@@ -0,0 +1,22 @@
+// Open(code)Share — re:share, session sharing for opencode. Self-hosted
+// replacement for the discontinued opencode share. Streams session events
+// over one WebSocket per main session to an openshare-worker; viewers
+// watch via hibernating sockets.
+//
+// This is the SINGLE-FILE build of the server plugin (generated by
+// scripts/build-standalone.mjs — do not edit; edit src/ and rebuild).
+// It behaves exactly like the package's dist/server.js.
+//
+// Install:
+//  - CI / share-everything: reference this file in the `plugin` array of
+//    your opencode config (no TUI part -> every session shares, the URL
+//    lands in the log and optionally in `urlFile`).
+//  - Interactive opt-in: install the package's TUI part (tui.json) too —
+//    the server detects its presence and switches to manual mode
+//    (`/share`, `/unshare` in the TUI).
+//
+// Config: env (OPENSHARE_*) > openshare.config.json (next to this file)
+// > code defaults. Keys: workerUrl, createToken, debounceMs, modelLabel,
+// ttlDays, openTasksInNewTab, authLogin, authPassword, spoolDir, urlFile,
+// shareMode ("all" | "manual"; default = TUI presence).
+//