@mirrowel/opencode-openshare 0.1.1 → 0.2.0-dev.2

package/dist/binding-queue.d.ts

@@ -0,0 +1 @@
+export declare function queueBindingWrite<T>(sid: string, fn: () => Promise<T>): Promise<T>;

package/dist/binding-queue.js

@@ -0,0 +1,22 @@
+/** Serialize session-metadata binding writes.
+ *
+ * Two writers read-modify-write `metadata.openshare` on the same session:
+ * the engine (`writeMetadata` in core.ts — preserves foreign keys, sets
+ * the servers map) and the TUI (`patchSessionBinding` in share-flow.ts —
+ * opt-outs, collision resolution). Their PATCHes interleave at the host:
+ * writer A reads at T0, writer B reads at T1, A PATCHes at T2, B PATCHes
+ * at T3 — A's change is silently lost (live-caught class: a TUI opt-out
+ * erased by the engine's binding refresh).
+ *
+ * Both route their whole read-modify-write through this per-session FIFO.
+ * The queue never breaks on errors; entries drop when the process exits.
+ */
+const queues = new Map();
+export function queueBindingWrite(sid, fn) {
+    const prev = queues.get(sid) ?? Promise.resolve();
+    // run regardless of the previous slot's outcome — one failed write must
+    // not wedge the session's binding updates forever
+    const run = prev.then(fn, fn);
+    queues.set(sid, run.catch(() => { }));
+    return run;
+}

package/dist/commands.js

@@ -1,8 +1,9 @@
 // OpenShare command registration. ONE user-facing /share command shadows
 // the deprecated built-in (opncd.ai) by registering the same command name
-// on a plugin keymap layer; running it on a shared session opens the
-// share manager (copy link / stop sharing) instead — you can't share
-// twice, so /share is a toggle. /openshare opens settings.
+// on a plugin keymap layer. Running it on a shared session opens the SAME
+// session menu as /openshare → This session (copy / stop / TTL / read
+// auth — one surface, no duplicated manager); on an unshared session it
+// asks consent and creates the share. /openshare opens settings.
 //
 // LAYER SHAPE (live-caught 2026-10-19): the v1 host keymap gates layers
 // that declare `mode` on the mode stack (resting mode is "base"), so a
@@ -12,7 +13,7 @@
 // is exactly what the proven family plugins use: {commands, bindings},
 // commands with only defined fields, category "OpenShare" (own group,
 // deliberately NOT joined into the shared family palette category).
-import { CONSENT_KV_KEY, clearGoneBindingEntries, confirmShare, currentConfig, isConfigured, hostOf, patchSessionBinding, readBindings, resolveRoot, runShareFlow, runUnshareFlow, serverEntries, verifyShare, workerDeleteShare, } from "./share-flow.js";
+import { clearGoneBindingEntries, currentConfig, hostOf, isConfigured, patchSessionBinding, readBindings, resolveRoot, shareWithConsent, verifyShare, } from "./share-flow.js";
 import { onboardingDialog, settingsDialog } from "./settings.js";
 import { dbgLog } from "./sidebar.js";
 export const PALETTE_CATEGORY = "OpenShare";
@@ -31,30 +32,26 @@ function finish(host, result) {
         duration: result.ok ? 8000 : 15000,
     });
 }
-/** The already-shared state: per-server management for the fan-out era.
- * Single binding keeps the compact classic menu; multiple bindings get a
- * per-server submenu (copy / stop here / leave as-is) plus all-stop.
- * Opens with a liveness sweep: bindings whose page died server-side
- * (purge/TTL/delete) are auto-cleared and surfaced in a gone modal. */
-async function showShareManager(host, sessionID) {
-    const sid = sessionID();
-    if (!sid)
-        return;
-    const root = await resolveRoot(host.client, sid);
+/** Shared pre-menu pass: collision check + liveness sweep. Bindings whose
+ * page died server-side (purge/TTL/delete) are auto-cleared and surfaced
+ * in a gone modal offering a re-share. Returns null when a dialog flow
+ * took over (collision / re-share) and already finished; otherwise the
+ * surviving bindings and whether any gone modal was shown. */
+async function sweepBindings(host, sid, root) {
     let all = await readBindings(host.client, root);
+    let goneShown = false;
     // collision first: the engine marked a server's credentials as rejected
     const collided = all.find((b) => b.collided);
-    if (collided)
-        return showCollisionDialog(host, root, collided.server, collided.id, collided.collided ?? "");
-    // liveness sweep: probe every live-bound server (credential-free /data
-    // check). GONE entries are removed from the binding automatically; the
-    // modal says what happened and offers to re-share. Network errors are
-    // "unknown" and never treated as gone.
+    if (collided) {
+        await showCollisionDialog(host, root, collided.server, collided.id, collided.collided ?? "");
+        return null;
+    }
     const live = all.filter((b) => b.url && b.enabled !== false && b.id);
     if (live.length) {
         const verdicts = await Promise.all(live.map((b) => verifyShare(b.server, b.id)));
         const gone = live.filter((b, i) => verdicts[i] === "gone");
         if (gone.length) {
+            goneShown = true;
             await clearGoneBindingEntries(host, root, gone.map((b) => b.server));
             all = all.filter((b) => !gone.some((g) => g.server === b.server));
             const list = gone.map((b) => `• ${hostOf(b.url || b.server)} — ${b.url}`).join("\n");
@@ -67,242 +64,15 @@ async function showShareManager(host, sessionID) {
                 ],
             });
             if (choice === "again") {
-                finish(host, await runShareFlow(host, sid));
-                return;
+                finish(host, await shareWithConsent(host, sid));
+                return null;
             }
             if (all.length === 0)
-                return;
-        }
-    }
-    if (all.length === 0)
-        return;
-    const otherServers = serverEntries().filter((s) => !all.some((b) => b.server === s.url));
-    if (all.length === 1 && otherServers.length === 0) {
-        // the classic single-server menu
-        const b = all[0];
-        void host.ui
-            .showMenu({
-            title: "Session is shared",
-            hint: b.url,
-            options: [
-                {
-                    title: "Copy share link",
-                    value: "copy",
-                    description: "copy the share URL to the clipboard",
-                    help: `Copies the share URL to the clipboard (navigator + OSC52 fallback).\n\nURL: ${b.url}\nServer: ${b.server}\nShare id: ${b.id}\n\nAnyone with the link can read the page (plus the login, if read auth is set).`,
-                },
-                {
-                    title: "Stop sharing",
-                    value: "stop",
-                    description: "Delete the share page — the link stops working for everyone",
-                    help: `Deletes the page on ${hostOf(b.url || b.server)} server-side and clears this session's share flag. Viewers with the link see a final "gone" state. This cannot be undone — sharing again creates a NEW page with a new URL.`,
-                },
-                { title: "Cancel", value: "cancel" },
-            ],
-        })
-            .then(async (choice) => {
-            if (choice === "copy") {
-                const ok = await host.clipboard.write(b.url);
-                finish(host, ok ? { ok: true, message: `Share URL copied to clipboard: ${b.url}`, url: b.url } : { ok: false, message: `Could not write the clipboard — link: ${b.url}`, url: b.url });
-                return;
-            }
-            if (choice === "stop") {
-                const how = await host.ui.showMenu({
-                    title: "Stop sharing",
-                    hint: b.url,
-                    options: [
-                        {
-                            title: "Delete the page",
-                            value: "delete",
-                            description: "the link stops working for everyone",
-                            danger: true,
-                            help: `Deletes the page on ${hostOf(b.url || b.server)} and clears this session's share flag. Viewers with the link see a final "gone" state. Sharing again later creates a fresh page with a new URL.`,
-                        },
-                        {
-                            title: "Leave as-is (snapshot)",
-                            value: "leave",
-                            description: "stop updating; the page stays until its TTL",
-                            help: `Stops mirroring WITHOUT deleting anything — viewers keep reading the snapshot until the share's TTL expires. Useful for handing someone a frozen copy while you keep working.`,
-                        },
-                        { title: "Cancel", value: "cancel" },
-                    ],
-                });
-                if (!how || how === "cancel")
-                    return;
-                if (how === "leave") {
-                    await patchSessionBinding(host.client, root, (servers) => {
-                        delete servers[b.server];
-                        servers[b.server] = { optedOut: true };
-                    });
-                    finish(host, { ok: true, message: `${hostOf(b.url || b.server)} left as-is — a snapshot until its TTL.` });
-                    return;
-                }
-                const yes = await host.ui.showConfirm({
-                    title: "Delete the share page",
-                    message: `Delete the page on ${hostOf(b.url || b.server)}?\nThe link stops working for everyone.`,
-                    confirmLabel: "Delete",
-                    danger: true,
-                });
-                if (!yes) {
-                    host.ui.dialog.clear();
-                    return;
-                }
-                finish(host, await runUnshareFlow(host, sessionID()));
-            }
-        });
-        return;
-    }
-    // fan-out menu
-    const options = all.map((b) => ({
-        title: `Copy link — ${hostOf(b.url || b.server)}`,
-        value: `copy:${b.server}`,
-        description: b.url,
-        help: `Copies this server's share URL to the clipboard.\n\nURL: ${b.url}\nServer: ${b.server}\nShare id: ${b.id}\n\nEach server carries an independent page of the same session.`,
-    }));
-    options.push({
-        title: "Manage per server…",
-        value: "manage",
-        description: `${all.length} servers — stop one, leave a snapshot`,
-        help: `Per-server actions: copy the link, stop sharing there (page deleted), or leave it as a read-only snapshot (updates stop, the page lives out its TTL). Other servers are unaffected.\n\nBound servers:\n${all.map((b) => `• ${b.server} — ${b.url}`).join("\n")}`,
-    });
-    if (otherServers.length) {
-        options.push({
-            title: "Share to another server…",
-            value: "more",
-            description: otherServers.map((s) => hostOf(s.url)).join(", "),
-            help: `Adds one of your other configured servers as a destination for THIS session: it becomes the active server and the full history is mirrored there within seconds.\n\nAvailable:\n${otherServers.map((s) => `• ${s.url}`).join("\n")}`,
-        });
-    }
-    options.push({
-        title: "Stop sharing (all)",
-        value: "stop-all",
-        description: "delete every server's page, or leave snapshots",
-        danger: true,
-        help: `Deletes the page on all ${all.length} servers (or leaves them as read-only snapshots — your choice on the next screen) and clears the share flag. Sharing again creates fresh pages.`,
-    });
-    options.push({ title: "Cancel", value: "cancel" });
-    const choice = await host.ui.showMenu({ title: `Session is shared · ${all.length} servers`, options });
-    if (!choice || choice === "cancel")
-        return;
-    if (choice.startsWith("copy:")) {
-        const b = all.find((x) => `copy:${x.server}` === choice);
-        if (b) {
-            const ok = await host.clipboard.write(b.url);
-            finish(host, ok ? { ok: true, message: `Share URL copied: ${b.url}`, url: b.url } : { ok: false, message: `Clipboard failed — ${b.url}`, url: b.url });
-        }
-        return;
-    }
-    if (choice === "stop-all") {
-        const how = await host.ui.showMenu({
-            title: `Stop sharing · ${all.length} servers`,
-            options: [
-                { title: "Delete every page", value: "delete", description: "all links stop working", danger: true, help: `Deletes the page on every bound server (${all.map((b) => hostOf(b.url || b.server)).join(", ")}) and clears the share flag.` },
-                { title: "Leave all as-is (snapshots)", value: "leave", description: "stop updating; pages stay until their TTLs", help: `Stops mirroring everywhere without deleting anything — every page stays readable as a frozen snapshot until its TTL expires.` },
-                { title: "Cancel", value: "cancel" },
-            ],
-        });
-        if (!how || how === "cancel")
-            return;
-        if (how === "leave") {
-            await patchSessionBinding(host.client, root, (servers) => {
-                for (const b of all) {
-                    delete servers[b.server];
-                    servers[b.server] = { optedOut: true };
-                }
-            });
-            finish(host, { ok: true, message: `${all.length} server(s) left as-is — snapshots until their TTLs.` });
-            return;
-        }
-        const yes = await host.ui.showConfirm({
-            title: "Stop sharing",
-            message: `Delete the share pages on all ${all.length} servers? The links stop working for everyone.`,
-            confirmLabel: "Stop all",
-            danger: true,
-        });
-        if (!yes)
-            return;
-        finish(host, await runUnshareFlow(host, sessionID()));
-        return;
-    }
-    if (choice === "more") {
-        const pick = await host.ui.showMenu({
-            title: "Share to another server",
-            options: [...otherServers.map((s) => ({ title: hostOf(s.url), value: s.url, description: s.entry.label })), { title: "Cancel", value: "__cancel" }],
-        });
-        if (!pick || pick === "__cancel")
-            return;
-        const { saveServerEntry } = await import("./share-flow.js");
-        for (const s of serverEntries())
-            if (s.url !== pick)
-                saveServerEntry(s.url, { active: undefined });
-        saveServerEntry(pick, { active: true });
-        finish(host, { ok: true, message: `${hostOf(pick)} activated — this session mirrors there within seconds (new sessions share to it too).` });
-        return;
-    }
-    if (choice === "manage") {
-        const pick = await host.ui.showMenu({
-            title: "Manage server",
-            options: [...all.map((b) => ({ title: hostOf(b.url || b.server), value: b.server, description: b.url })), { title: "Cancel", value: "__cancel" }],
-        });
-        if (!pick || pick === "__cancel")
-            return;
-        const b = all.find((x) => x.server === pick);
-        if (!b)
-            return;
-        const action = await host.ui.showMenu({
-            title: `${hostOf(b.url || b.server)}`,
-            hint: b.url,
-            options: [
-                {
-                    title: "Copy link",
-                    value: "copy",
-                    description: "copy the share URL",
-                    help: `Copies this server's share URL to the clipboard.\n\nURL: ${b.url}\nShare id: ${b.id}`,
-                },
-                {
-                    title: "Stop sharing here",
-                    value: "stop",
-                    description: "delete THIS server's page; other servers unaffected",
-                    help: `Deletes the page on ${hostOf(b.url || b.server)} and retires this server for the session (the engine stops mirroring here). Other servers keep streaming. Sharing here again later creates a new page.`,
-                },
-                {
-                    title: "Leave as-is (snapshot)",
-                    value: "leave",
-                    description: "stop updating it; the page stays until its TTL",
-                    help: `Stops mirroring to ${hostOf(b.url || b.server)} WITHOUT deleting anything — viewers keep reading the snapshot until the share's TTL expires. Useful for handing someone a frozen copy while you keep working.`,
-                },
-                { title: "Cancel", value: "cancel" },
-            ],
-        });
-        if (!action || action === "cancel")
-            return;
-        if (action === "copy") {
-            const ok = await host.clipboard.write(b.url);
-            finish(host, ok ? { ok: true, message: `Share URL copied: ${b.url}`, url: b.url } : { ok: false, message: `Clipboard failed — ${b.url}`, url: b.url });
-            return;
-        }
-        if (action === "stop") {
-            const deleted = await workerDeleteShare(b.server || b.url.slice(0, b.url.indexOf("/s/")), b.id, b.secret);
-            await patchSessionBinding(host.client, root, (servers) => {
-                delete servers[b.server];
-                servers[b.server] = { optedOut: true };
-            });
-            finish(host, { ok: true, message: deleted ? `Stopped sharing on ${hostOf(b.url || b.server)} — page deleted.` : `Stopped sharing on ${hostOf(b.url || b.server)} (page deletion follows via the sweeper).` });
-            return;
-        }
-        if (action === "leave") {
-            await patchSessionBinding(host.client, root, (servers) => {
-                delete servers[b.server];
-                servers[b.server] = { optedOut: true };
-            });
-            finish(host, { ok: true, message: `${hostOf(b.url || b.server)} left as-is — a snapshot until its TTL.` });
-            return;
+                return { all, goneShown };
         }
     }
+    return { all, goneShown };
 }
-/** Credential collision: the engine refused to auto-recreate. The user
- * chooses: copy debug info (for the hoster/issue), share on a new share,
- * or don't share. */
 async function showCollisionDialog(host, root, server, shareId, error) {
     const debugInfo = JSON.stringify({ server, shareId, error, sessionID: root, plugin: "openshare", time: new Date().toISOString() }, null, 2);
     const choice = await host.ui.showMenu({
@@ -375,44 +145,30 @@ export function buildShareCommand(host, sessionID) {
                 return;
             }
             const root = await resolveRoot(host.client, sid);
-            const bindings = await readBindings(host.client, root);
-            const binding = bindings[0];
-            dbgLog(`/share gate: sid=${sid} root=${root} bindings=${bindings.length}`);
+            // collision + gone sweep, then the gate. null = a dialog flow took
+            // over (collision / gone re-share) and already finished.
+            const swept = await sweepBindings(host, sid, root);
+            if (swept === null)
+                return;
+            const { all, goneShown } = swept;
             // live ⇔ url && enabled !== false (all-mode bindings carry
-            // enabled:true since the fix; legacy all-mode bindings without the
-            // field are live too — only an explicit false is dormant)
-            if (bindings.some((b) => b.url && b.enabled !== false)) {
-                await showShareManager(host, sessionID);
-                host.ui.dialog.clear();
+            // enabled:true; legacy all-mode bindings without the field are live
+            // too — only an explicit false is dormant)
+            if (all.some((b) => b.url && b.enabled !== false)) {
+                // THE session menu — identical to /openshare → This session by
+                // construction (one surface, no duplicated manager). No
+                // dialog.clear() after: settings owns its chain end-to-end (the
+                // old fire-and-forget menu + immediate clear wiped it instantly —
+                // live-caught as "/share did nothing" on a shared session).
+                await settingsDialog(host, sid);
                 return;
             }
-            // not shared (or dormant): the normal flow — consent once, then share
-            const result = await runShareFlow(host, sid);
-            if (result.message === "consent required") {
-                const yes = await host.ui.showConfirm({
-                    title: "Share Session",
-                    message: "Publish this session (and its subagent sessions) to your openshare worker?\nThe link lets anyone with it read the conversation.",
-                    confirmLabel: "Share",
-                });
-                if (!yes)
-                    return;
-                try {
-                    host.kv.set(CONSENT_KV_KEY, true);
-                    dbgLog("consent kv.set ok");
-                }
-                catch (e) {
-                    dbgLog(`consent kv.set THREW: ${e?.message ?? e}`);
-                }
-                try {
-                    finish(host, await confirmShare(host, root));
-                }
-                catch (e) {
-                    dbgLog(`confirmShare rejected: ${e?.stack ?? e}`);
-                    finish(host, { ok: false, message: "Share failed (see debug log)." });
-                }
+            // everything was just cleared by the gone modal and the user chose
+            // Close — leaving it unshared is the answer, do not offer a share
+            if (goneShown && all.length === 0)
                 return;
-            }
-            finish(host, result);
+            // not shared (or dormant): explicit consent, every time
+            finish(host, await shareWithConsent(host, sid));
         },
     };
 }

package/dist/contract.d.ts

@@ -0,0 +1,156 @@
+export declare const CONTRACT_VERSION = 2;
+/** Message tombstone item. sessionID MUST ride along: viewers key
+ * messages as message/<sessionID>/<id> — an unstamped del misses the
+ * key and undone turns resurrect on the live page (live-caught
+ * 2026-10-21, refresh-correct because the worker keys differently). */
+export declare function messageTombstone(sessionID: string, messageID: string): {
+    readonly type: "message";
+    readonly del: true;
+    readonly sessionID: string;
+    readonly data: {
+        readonly id: string;
+    };
+};
+export type V2ToolState = {
+    status: "streaming";
+    input: string;
+} | {
+    status: "running";
+    input: Record<string, unknown>;
+    metadata: Record<string, unknown>;
+} | {
+    status: "completed";
+    input: Record<string, unknown>;
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    metadata?: Record<string, unknown>;
+} | {
+    status: "error";
+    input: Record<string, unknown>;
+    error: {
+        type: string;
+        message: string;
+    };
+    content?: Array<{
+        type: "text";
+        text: string;
+    }>;
+    metadata?: Record<string, unknown>;
+};
+export type V2Content = {
+    type: "text";
+    text: string;
+    state?: string;
+} | {
+    type: "reasoning";
+    text: string;
+    state?: string;
+    time?: {
+        created?: number;
+        completed?: number;
+    };
+} | {
+    type: "tool";
+    id: string;
+    name: string;
+    executed?: boolean;
+    state: V2ToolState;
+    time: {
+        created?: number;
+        ran?: number;
+        completed?: number;
+    };
+};
+export type V2FileAttachment = {
+    data: string;
+    mime: string;
+    source: {
+        type: "inline";
+    } | {
+        type: "uri";
+        uri: string;
+    };
+    name?: string;
+};
+export interface V2UserMessage {
+    id: string;
+    type: "user";
+    time: {
+        created: number;
+    };
+    text: string;
+    files?: V2FileAttachment[];
+    agents?: Array<{
+        name: string;
+    }>;
+    metadata?: Record<string, unknown>;
+}
+export interface V2AssistantMessage {
+    id: string;
+    type: "assistant";
+    agent: string;
+    model: {
+        id: string;
+        providerID: string;
+        variant?: string;
+    };
+    time: {
+        created: number;
+        streamed?: number;
+        completed?: number;
+    };
+    content: V2Content[];
+    cost?: number;
+    tokens?: Record<string, unknown>;
+    finish?: string;
+    error?: {
+        type: string;
+        message: string;
+        status?: number;
+    };
+    retry?: {
+        attempt: number;
+        at: number;
+        error?: {
+            type: string;
+            message: string;
+        };
+    };
+}
+export interface V2CompactionMessage {
+    id: string;
+    type: "compaction";
+    status: "completed";
+    reason: "auto" | "manual";
+    summary: string;
+    recent: string;
+    time: {
+        created: number;
+    };
+}
+export type V2Message = V2UserMessage | V2AssistantMessage | V2CompactionMessage | Record<string, unknown>;
+/** True when the object is already a v2 session message (v2 hosts pass
+ * messages through verbatim; v1 infos carry `role`). */
+export declare function isV2NativeMessage(x: unknown): boolean;
+/** v1 message + its parts → v2 message. Returns:
+ *  - { message }          — emit as a message item
+ *  - { refill, summary }  — v1 compaction summary assistant: do not emit;
+ *                           rewrite the parent compaction message instead
+ *  - undefined            — nothing to emit (should not happen in practice) */
+export declare function normalizeV1Message(info: Record<string, unknown>, parts: Array<Record<string, unknown>>): {
+    message: V2Message;
+} | {
+    refill: string;
+    summary: string;
+} | undefined;
+/** v1 session diff (FileDiff.Info[]) → v2 FileDiffInfo[]: the v2 shape
+ * REQUIRES numeric additions/deletions (renderers read them unguarded) —
+ * compute from the patch when the host didn't provide counts. */
+export declare function normalizeV1Diff(diff: unknown): unknown;
+/** v1 hosts paginate messages with an opaque cursor: base64url of
+ * {id, time} where time = the page tail's time_created (message-v2.ts
+ * cursor codec). A bare message id is rejected with 400 — that silently
+ * truncated every v1 backfill to one page (live-caught). */
+export declare function cursorFor(id: string, time: number): string;