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

package/src/dialogs.tsx

@@ -576,6 +576,32 @@ export function MenuDialog<Value>(props: {
   )
 }
 
+/** Guard against stacked plugin dialogs. `dialog.replace` is documented as
+ * an atomic swap, but on some host builds a second replace while a dialog is
+ * still pending leaves BOTH renderers mounted - the reader sees two menus
+ * with two highlighted rows and keys go to a stale layer ("/share does
+ * nothing"). Cancelling the pending dialog and clearing before the next
+ * replace keeps exactly one dialog alive. The normal single-dialog path is
+ * untouched, so the esc-to-parent flicker fix stays intact. */
+let pendingDialog: (() => void) | undefined
+function claimDialog(api: TuiPluginApi): () => void {
+  if (pendingDialog) {
+    try {
+      pendingDialog()
+    } catch {}
+    try {
+      api.ui.dialog.clear()
+    } catch {}
+  }
+  let released = false
+  const release = () => {
+    if (released) return
+    released = true
+    if (pendingDialog === release) pendingDialog = undefined
+  }
+  pendingDialog = release
+  return release
+}
 /** showMenuOnce, family discipline with the flicker fix (2026-10-19):
  * done() does NOT clear the host stack — the next dialog's replace() is an
  * atomic swap, so clearing first paints one empty frame (the esc-to-parent
@@ -584,9 +610,11 @@ export function MenuDialog<Value>(props: {
 export function showMenuOnce<Value>(api: TuiPluginApi, props: { title: string; options: MenuOption<Value>[]; current?: Value; hint?: string }): Promise<Value | undefined> {
   return new Promise((resolve) => {
     let settled = false
+    const release = claimDialog(api)
     const done = (value: Value | undefined, _clear = false) => {
       if (settled) return
       settled = true
+      release()
       dbgLog(`menu(${props.title}) -> ${value === undefined ? "cancel" : String(value)}`)
       resolve(value)
     }
@@ -610,9 +638,11 @@ export type DialogAction = { title: string; value: string; key?: string; danger?
 export function showInfoDialog(api: TuiPluginApi, props: { title: string; message: string; actions?: DialogAction[] }): Promise<string | undefined> {
   return new Promise((resolve) => {
     let settled = false
+    const release = claimDialog(api)
     const done = (value: string | undefined) => {
       if (settled) return
       settled = true
+      release()
       resolve(value)
     }
     api.ui.dialog.replace(
@@ -703,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>
@@ -799,9 +838,11 @@ export function PromptDialog(props: {
 export function showPromptOnce(api: TuiPluginApi, props: { title: string; placeholder?: string; value?: string }): Promise<string | undefined> {
   return new Promise((resolve) => {
     let settled = false
+    const release = claimDialog(api)
     const done = (value: string | undefined, _clear = false) => {
       if (settled) return
       settled = true
+      release()
       dbgLog(`prompt(${props.title}) -> ${value === undefined ? "cancel" : `len=${value.length}`}`)
       resolve(value)
     }
@@ -829,9 +870,11 @@ export type SizePickerResult = { width: DialogWidth; heightPercent: number }
 export function showSizePickerOnce(api: TuiPluginApi, current: SizePickerResult): Promise<SizePickerResult | undefined> {
   return new Promise((resolve) => {
     let settled = false
+    const release = claimDialog(api)
     const done = (value: SizePickerResult | undefined) => {
       if (settled) return
       settled = true
+      release()
       resolve(value)
     }
     api.ui.dialog.replace(

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,24 +16,11 @@
 // 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"
 import type { TuiPluginApi, TuiSlotContext } from "@opencode-ai/plugin/tui"
 import type { Session } from "@opencode-ai/sdk/v2"
-import { appendFileSync } from "node:fs"
-import { tmpdir } from "node:os"
-import { join } from "node:path"
-
-const DBG_FILE = join(tmpdir(), "openshare-tui-debug.log")
-
 /** value -> `kind:preview` so the log shows TYPES (the crash was a type bug) */
 export function dbg(v: unknown, depth = 0): string {
   const t = typeof v
@@ -52,30 +39,9 @@ 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)}`
-  }
-}
-
-export function dbgLog(line: string): void {
-  try {
-    appendFileSync(DBG_FILE, `${new Date().toISOString()} ${line}\n`)
-  } catch {}
-}
-
-let renderSeq = 0
+/** 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 {}
 
 /** Share liveness cache for the chip: a binding can claim "shared" long
  * after the page died server-side (purge/TTL/delete with no event ever
@@ -102,13 +68,10 @@ type SidebarTitleProps = {
 }
 
 export function createSidebarSlot(api: TuiPluginApi, opts?: { onShareCommand?: () => void }) {
-  dbgLog(`createSidebarSlot called; api.state=${!!api.state} api.theme=${!!api.theme} api.version=${dbg(api.app?.version)}`)
   return {
     slots: {
       sidebar_title: (ctx: TuiSlotContext, props: SidebarTitleProps): JSX.Element => {
-        const seq = ++renderSeq
         try {
-          dbgLog(`render#${seq} ctx=${dbg(ctx)} props=${dbg(props)}`)
           const sid = typeof props?.session_id === "string" ? props.session_id : ""
           const title = String(props?.title ?? "") || "Session"
           const session = sid ? api.state.session.get(sid) : undefined
@@ -122,9 +85,7 @@ export function createSidebarSlot(api: TuiPluginApi, opts?: { onShareCommand?: (
           const anyGone = verdicts.some((v) => v?.status === "gone")
           const multi = liveCount > 1 ? `·${liveCount} ` : ""
           const theme = ctx?.theme?.current ?? api.theme.current
-          dbgLog(
-            `render#${seq} sid=${dbg(sid)} title=${dbg(title)} session=${session ? "found" : "MISSING"} binding=${binding ? `id=${dbg(binding.id)} enabled=${dbg(binding.enabled)}` : "none"} status=${dbg(status)} theme=${dbg(theme)}`,
-          )
+
           // chip on its own line under the title (takes the blank line that
           // separated the title block from the context blocks); clicking it
           // copies the share link — proven pattern: onMouseDown on a box.
@@ -175,10 +136,8 @@ export function createSidebarSlot(api: TuiPluginApi, opts?: { onShareCommand?: (
               ) : null}
             </box>
           )
-          dbgLog(`render#${seq} RETURNS ${dbgEl(el)}`)
           return el
         } catch (error) {
-          dbgLog(`render#${seq} THREW ${(error as Error)?.stack ?? dbg(error)} — rethrowing`)
           throw error
         }
       },