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

package/src/dialogs.tsx

@@ -733,8 +733,17 @@ function InfoDialog(props: { api: TuiPluginApi; title: string; message: string;
         <box flexDirection="row" gap={1}>
           <For each={actions()}>
             {(action) => (
-              <box paddingLeft={2} paddingRight={2} backgroundColor={action.danger ? theme().error : theme().primary} onMouseUp={() => props.onDone(action.value)}>
-                <text fg={theme().background}><b>{action.title}</b></text>
+              <box
+                paddingLeft={2}
+                paddingRight={2}
+                backgroundColor={action.key === "enter" ? (action.danger ? theme().error : theme().primary) : undefined}
+                border={action.key === "enter" ? undefined : true}
+                borderColor={action.danger ? theme().error : theme().textMuted}
+                onMouseUp={() => props.onDone(action.value)}
+              >
+                <text fg={action.key === "enter" ? theme().background : action.danger ? theme().error : theme().textMuted}>
+                  <b>{action.title}</b>
+                </text>
               </box>
             )}
           </For>

package/src/settings.ts

@@ -30,6 +30,8 @@ import {
   saveServerEntry,
   serverEntries,
   setShareFlag,
+  shareWithConsent,
+  workerDeleteShare,
   type AdminShare,
   type AdminUser,
 } from "./share-flow.js"
@@ -917,26 +919,68 @@ export async function settingsDialog(host: ShareHostApi, startAtSession?: string
 
   const sessionRows = async (): Promise<ShareDialogSelectOption<string>[]> => {
     if (!startAtSession) return []
-    const binding = await readBinding(host.client, await resolveRoot(host.client, startAtSession))
-    const rows: ShareDialogSelectOption<string>[] = [
-      {
-        title: binding?.url ? "Copy share link" : "Share this session",
+    const root = await resolveRoot(host.client, startAtSession)
+    const bindings = await readBindings(host.client, root)
+    const live = bindings.filter((b) => b.url && b.enabled !== false)
+    const rows: ShareDialogSelectOption<string>[] = []
+    if (live.length === 0) {
+      rows.push({
+        title: "Share this session",
         value: "session:share",
-        description: binding?.url ? "copy the share URL to the clipboard" : "Set the share flag; the server plugin creates the page",
-        help: binding?.url
-          ? `Copies the share URL to the clipboard.\n\nURL: ${binding.url}\nShare id: ${binding.id ?? "?"}`
-          : "Publishes this session (and its subagent sessions) to the active server. The full history lands in the page — sharing mid-session is first-class, nothing is missed.",
-      },
-    ]
-    if (binding?.url) {
+        description: "set the share flag; the server plugin creates the page",
+        help: "Publishes this session (and its subagent sessions) to the active server. The full history lands in the page — sharing mid-session is first-class, nothing is missed. You will be asked to confirm before anything is published.",
+      })
+    } else if (live.length === 1) {
+      const b = live[0]
+      rows.push({
+        title: "Copy share link",
+        value: "session:copy",
+        description: "copy the share URL to the clipboard",
+        help: `Copies the share URL to the clipboard.\n\nURL: ${b.url}\nShare id: ${b.id ?? "?"}`,
+      })
+    } else {
+      for (const b of live) {
+        rows.push({
+          title: `Copy link — ${hostOf(b.url || b.server)}`,
+          value: `session:copy:${b.server}`,
+          description: b.url,
+          help: `Copies this server's share URL to the clipboard.\n\nURL: ${b.url}\nShare id: ${b.id}\n\nEach server carries an independent page of the same session.`,
+        })
+      }
+      rows.push({
+        title: "Copy all links",
+        value: "session:copyall",
+        description: `${live.length} servers`,
+        help: `Copies every bound server's share URL.\n\n${live.map((b) => `• ${b.url}`).join("\n")}`,
+      })
+    }
+    if (live.length) {
       rows.push({
         title: "Stop sharing",
         value: "session:unshare",
-        description: "delete the page(s), or leave a snapshot",
+        description: live.length > 1 ? `delete every page (${live.length} servers), or leave snapshots` : "delete the page, or leave a snapshot",
         danger: true,
-        help: `Choose per run: DELETE every page server-side (links stop working — final "gone" state), or LEAVE AS-IS (stop updating; pages stay readable until their TTL — a frozen snapshot).\n\nURLs:\n${[binding.url].join("\n")}\n\nSharing again later always creates fresh page(s) with new URLs.`,
+        help: `Choose per run: DELETE every page server-side (links stop working — final "gone" state), or LEAVE AS-IS (stop updating; pages stay readable until their TTL — a frozen snapshot).\n\nURLs:\n${live.map((b) => b.url).join("\n")}\n\nSharing again later always creates fresh page(s) with new URLs.`,
       })
+      if (live.length > 1) {
+        rows.push({
+          title: "Stop on one server…",
+          value: "session:unshare:one",
+          description: "delete or snapshot a single server's page",
+          help: `Per-server stop: pick the server, then delete its page or leave it as a read-only snapshot. Other servers are unaffected.\n\nBound servers:\n${live.map((b) => `• ${b.server} — ${b.url}`).join("\n")}`,
+        })
+        const otherServers = serverEntries().filter((s) => !live.some((b) => b.server === s.url))
+        if (otherServers.length) {
+          rows.push({
+            title: "Share to another server…",
+            value: "session: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")}`,
+          })
+        }
+      }
     }
+    const binding = bindings[0]
     rows.push({
       title: "Session TTL override (days)",
       value: "session:ttl",
@@ -1054,16 +1098,90 @@ export async function settingsDialog(host: ShareHostApi, startAtSession?: string
 
     if (choice.startsWith("session:") && startAtSession) {
       const root = await resolveRoot(host.client, startAtSession)
-      const current = await readBinding(host.client, root)
+      const all = await readBindings(host.client, root)
+      const live = all.filter((b) => b.url && b.enabled !== false)
+      const current = all[0]
       if (choice === "session:share") {
         if (!isConfigured(cfg)) {
           await showInfo(host.ui, { title: "Not configured", message: "Connect a server (Servers group) first, then share." })
           return
         }
-        const result = await confirmShare(host, root)
+        const result = await shareWithConsent(host, startAtSession)
         host.ui.toast({ variant: result.ok ? "success" : "error", title: "OpenShare", message: result.message, duration: result.ok ? 8000 : 15000 })
         return
       }
+      if (choice === "session:copy" && live[0]) {
+        const okw = await host.clipboard.write(live[0].url!)
+        host.ui.toast({ variant: okw ? "success" : "error", title: "OpenShare", message: okw ? `Share URL copied: ${live[0].url}` : `Clipboard failed — ${live[0].url}` })
+        return
+      }
+      if (choice.startsWith("session:copy:") ) {
+        const b = live.find((x) => `session:copy:${x.server}` === choice)
+        if (b) {
+          const okw = await host.clipboard.write(b.url!)
+          host.ui.toast({ variant: okw ? "success" : "error", title: "OpenShare", message: okw ? `Share URL copied: ${b.url}` : `Clipboard failed — ${b.url}` })
+        }
+        return
+      }
+      if (choice === "session:copyall") {
+        const joined = live.map((b) => b.url).filter(Boolean).join("\n")
+        const okw = await host.clipboard.write(joined)
+        host.ui.toast({ variant: okw ? "success" : "error", title: "OpenShare", message: okw ? `${live.length} share URL(s) copied` : "Clipboard failed" })
+        return
+      }
+      if (choice === "session:unshare:one") {
+        const pick = await showSelect(host.ui, {
+          title: "Stop on which server",
+          options: [...live.map((b) => ({ title: hostOf(b.url || b.server), value: b.server, description: b.url })), { title: "Cancel", value: "__cancel" }],
+        })
+        if (!pick || pick === "__cancel") return
+        const target = live.find((b) => b.server === pick)
+        if (!target) return
+        const how = await showSelect(host.ui, {
+          title: `Stop sharing — ${hostOf(target.url || target.server)}`,
+          options: [
+            { title: "Delete the page", value: "delete", description: "this link stops working for everyone", danger: true },
+            { title: "Leave as-is (snapshot)", value: "leave", description: "stop updating; the page stays until its TTL" },
+            { title: "Cancel", value: "__cancel" },
+          ],
+        })
+        if (!how || how === "__cancel") return
+        if (how === "leave") {
+          await patchSessionBinding(host.client, root, (servers) => {
+            delete servers[target.server]
+            servers[target.server] = { optedOut: true }
+          })
+          host.ui.toast({ variant: "success", title: "OpenShare", message: `${hostOf(target.url || target.server)} left as-is — a snapshot until its TTL.` })
+          return
+        }
+        const targetEntry = all.find((b) => b.server === target.server)
+        if (!targetEntry?.secret) {
+          host.ui.toast({ variant: "error", title: "OpenShare", message: "No secret for this page — cannot delete it server-side; binding cleared." })
+          await patchSessionBinding(host.client, root, (servers) => {
+            delete servers[target.server]
+          })
+          return
+        }
+        const gone = await workerDeleteShare(target.server, target.id!, targetEntry.secret)
+        await patchSessionBinding(host.client, root, (servers) => {
+          delete servers[target.server]
+        })
+        host.ui.toast({ variant: gone ? "success" : "warning", title: "OpenShare", message: gone ? `Page deleted on ${hostOf(target.url || target.server)}.` : `Could not delete the page (it may already be gone) — binding cleared.` })
+        return
+      }
+      if (choice === "session:more") {
+        const otherServers = serverEntries().filter((s) => !live.some((b) => b.server === s.url))
+        if (!otherServers.length) return
+        const pick = await showSelect(host.ui, {
+          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
+        for (const s of serverEntries()) if (s.url !== pick) saveServerEntry(s.url, { active: undefined })
+        saveServerEntry(pick, { active: true })
+        host.ui.toast({ variant: "success", title: "OpenShare", message: `${hostOf(pick)} activated — this session mirrors there within seconds.` })
+        return
+      }
       if (choice === "session:unshare") {
         const how = await showSelect(host.ui, {
           title: "Stop sharing",

package/src/share-flow.ts

@@ -18,6 +18,7 @@ import { existsSync, readFileSync, writeFileSync } from "node:fs"
 import { loadConfig, moduleDir, configPaths, configHomePath, resolveServer, saveServerEntry, deleteServerEntry, METADATA_KEY, type ShareConfig, type ServerEntry } from "./config.js"
 import { dbg, dbgLog } from "./sidebar.js"
 import type { ClientApi, SessionInfo, SessionOpts } from "./core.js"
+import { queueBindingWrite } from "./binding-queue.js"
 import type { ShareHostApi } from "./tui-host.js"
 
 export type SessionBinding = {
@@ -29,8 +30,6 @@ export type SessionBinding = {
   opts?: SessionOpts
 }
 
-export const CONSENT_KV_KEY = "openshare_consent"
-
 export function pluginConfigPaths(baseDir: string = moduleDir()): string[] {
   return configPaths(baseDir)
 }
@@ -174,18 +173,23 @@ export async function patchSessionBinding(
   sid: string,
   mutator: (servers: Record<string, unknown>, binding: Record<string, unknown>) => void,
 ): Promise<boolean> {
-  const info = await getSession(client, sid)
-  if (!info) return false
-  const metadata: Record<string, unknown> = { ...(info.metadata ?? {}) }
-  const raw = info.metadata?.[METADATA_KEY]
-  const binding: Record<string, unknown> =
-    raw && typeof raw === "object" ? { ...(raw as Record<string, unknown>) } : { v: 2, servers: {} }
-  const servers: Record<string, unknown> =
-    binding.servers && typeof binding.servers === "object" ? { ...(binding.servers as Record<string, unknown>) } : {}
-  mutator(servers, binding)
-  binding.servers = servers
-  metadata[METADATA_KEY] = binding
-  return patchMetadata(client, sid, metadata)
+  // the whole read-modify-write runs inside the shared per-session queue:
+  // the engine patches the same metadata (binding refresh) and interleaved
+  // RMWs silently lose one side's update (see binding-queue.ts)
+  return queueBindingWrite(sid, async () => {
+    const info = await getSession(client, sid)
+    if (!info) return false
+    const metadata: Record<string, unknown> = { ...(info.metadata ?? {}) }
+    const raw = info.metadata?.[METADATA_KEY]
+    const binding: Record<string, unknown> =
+      raw && typeof raw === "object" ? { ...(raw as Record<string, unknown>) } : { v: 2, servers: {} }
+    const servers: Record<string, unknown> =
+      binding.servers && typeof binding.servers === "object" ? { ...(binding.servers as Record<string, unknown>) } : {}
+    mutator(servers, binding)
+    binding.servers = servers
+    metadata[METADATA_KEY] = binding
+    return patchMetadata(client, sid, metadata)
+  })
 }
 
 /** The display/primary binding: the active server's entry when bound
@@ -482,7 +486,20 @@ export async function waitForBinding(
 
 export type FlowResult = { ok: boolean; message: string; url?: string; unconfigured?: boolean }
 
-export async function runShareFlow(host: ShareHostApi, sessionID: string | undefined): Promise<FlowResult> {
+/** Consent gate: EVERY share creation asks explicitly (per owner
+ * directive — no remembered consent, no silent creates). */
+export async function requestShareConsent(host: ShareHostApi): Promise<boolean> {
+  return 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",
+  })
+}
+
+/** runShareFlow with the consent gate applied: share copies the link,
+ * unshared asks consent once, then creates. Every create path routes
+ * through here (/share, settings, gone-again). */
+export async function shareWithConsent(host: ShareHostApi, sessionID: string | undefined): Promise<FlowResult> {
   if (!sessionID) return { ok: false, message: "No active session to share." }
   const cfg = currentConfig()
   if (!isConfigured(cfg)) {
@@ -495,10 +512,7 @@ export async function runShareFlow(host: ShareHostApi, sessionID: string | undef
     await host.clipboard.write(existing.url)
     return { ok: true, message: `Share URL copied to clipboard: ${existing.url}`, url: existing.url }
   }
-  if (!host.kv.get(CONSENT_KV_KEY, false)) {
-    // caller shows the consent dialog before invoking confirmShare()
-    return { ok: false, message: "consent required" }
-  }
+  if (!(await requestShareConsent(host))) return { ok: false, message: "Share cancelled." }
   return confirmShare(host, root)
 }
 

package/src/sidebar.tsx

@@ -16,13 +16,6 @@
 // proven consumer returns box-rooted trees (opencode's own default
 // children, magic-context's sidebar, the host's slot self-test); text
 // nodes stay LEAVES here — string content only.
-//
-// TEMPORARY crash-hunt instrumentation (owner-approved 2026-10-19): every
-// render logs its inputs (with TYPES), the computed locals, and a dump of
-// the returned element tree to %TEMP%/openshare-tui-debug.log via
-// synchronous appends, so a crash mid-render still leaves evidence. Any
-// throw inside the renderer is logged with its stack, then rethrown.
-// Remove once the live crash is cornered.
 
 import type { JSX } from "@opentui/solid"
 import { bindingsOf, bindingOf, verifyShare } from "./share-flow.js"
@@ -46,23 +39,6 @@ export function dbg(v: unknown, depth = 0): string {
   }
 }
 
-/** shallow structural dump of a rendered element tree (type names, children kinds) */
-function dbgEl(el: unknown, depth = 0): string {
-  if (el === null || el === undefined || typeof el === "string" || typeof el === "number" || typeof el === "boolean") return dbg(el)
-  if (Array.isArray(el)) return `[${el.map((x) => dbgEl(x, depth)).join(",")}]`
-  if (typeof el === "function") return "fn-node"
-  if (depth >= 4) return "…"
-  try {
-    const rec = el as Record<string, unknown>
-    const t = dbg(rec.t ?? rec.type, 2)
-    const kids = rec.children
-    const props = Object.keys(rec).filter((k) => !["t", "type", "children"].includes(k))
-    return `<${t} ${props.join(" ")}>${kids === undefined ? "" : dbgEl(kids, depth + 1)}</${t}>`
-  } catch (e) {
-    return `el?-${dbg(e)}`
-  }
-}
-
 /** no-op: the TUI debug log file was a crash-hunt aid and must not write
  * to temp any more (owner request 2026-10-21) */
 export function dbgLog(_line: string): void {}

package/src/v2-server.ts

@@ -229,7 +229,20 @@ export function createV2ServerSetup() {
     // 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.
+    // NOTE: no content-hash dedupe here — a refresh that runs while the
+    // session is still dormant (pre-flag) would poison the cache without
+    // emitting anything, and the flag-time refresh would then SKIP the
+    // unchanged messages (live-caught in the v2 mock suite: the share's
+    // first assistant content arrived only as the next change). The dedupe
+    // belongs engine-side, where dormancy is known, if it's ever needed.
     const pendingRefresh = new Map<string, ReturnType<typeof setTimeout>>()
+    // queued inbox inputs per session: v2 persists the prompt in the inbox
+    // (delivery "queue") while the current turn still runs — the message
+    // row can exist before the model ever sees it, and a mid-turn refresh
+    // would surface it early. Held here until session.inbox.delivered
+    // fires (the turn actually starts); "steer" inputs inject into the
+    // live run, so they pass straight through.
+    const queuedInbox = new Map<string, Set<string>>()
     const refresh = (sessionID: string) => {
       let timer = pendingRefresh.get(sessionID)
       if (timer) clearTimeout(timer)
@@ -243,7 +256,9 @@ export function createV2ServerSetup() {
             })
             const messages = await (client as NonNullable<typeof client>).session.messages?.({ path: { id: sessionID } })
             const list = ((messages as { data?: unknown })?.data ?? []) as Array<{ info: MessageInfo; parts: PartInfo[] }>
+            const held = queuedInbox.get(sessionID)
             for (const message of list) {
+              if (held?.has(message.info.id)) continue // still queued — not sent to the model yet
               await engine.hooks.event({
                 event: { type: "message.updated", properties: { sessionID, info: message.info } },
               })
@@ -277,6 +292,41 @@ export function createV2ServerSetup() {
               await engine.hooks.event({ event: { type, properties: { sessionID: sid } } })
               continue
             }
+            if (type.startsWith("session.inbox.")) {
+              // queued-prompt lifecycle: hold delivery="queue" inputs off
+              // the share until they are actually delivered to the model
+              // (cancelled ones never appear). inboxID shares the message
+              // id space (the inbox item promotes into that message row).
+              const data = (event.data ?? {}) as { inboxID?: string; item?: { delivery?: string } }
+              const inboxID = data.inboxID
+              if (inboxID) {
+                let set = queuedInbox.get(sid)
+                if (!set) {
+                  set = new Set()
+                  queuedInbox.set(sid, set)
+                }
+                if (type === "session.inbox.enqueued" && data.item?.delivery === "queue") {
+                  set.add(inboxID)
+                } else if (type === "session.inbox.delivered") {
+                  set.delete(inboxID)
+                  refresh(sid) // the held prompt's turn is starting now
+                } else if (type === "session.inbox.cancelled") {
+                  // cancelled-before-run: the prompt never reaches the
+                  // model — keep it held forever so no later refresh
+                  // surfaces the orphaned row
+                  set.add(inboxID)
+                } else if (type === "session.inbox.delivery.changed") {
+                  // steer inputs inject into the live run — the model
+                  // sees them; only "queue" holds
+                  if (data.item?.delivery === "queue") set.add(inboxID)
+                  else {
+                    set.delete(inboxID)
+                    refresh(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