@mirrowel/opencode-openshare 0.0.0-stage → 0.1.1

package/dist/share-flow.js

@@ -0,0 +1,516 @@
+// OpenShare share flows — host-agnostic logic behind /share and
+// the settings dialog's "this session" actions. Runs against the
+// ShareHostApi facade (tui-host.ts) and the shared config module, so the
+// same compiled code serves the v1 TUI and the v2 adapter.
+//
+// Flow contracts (mirrored by scripts/manual-tests.mjs):
+//  /share     resolve root session -> config check (onboard to settings
+//             when unconfigured) -> consent once -> set the enabled flag
+//             (with per-session opts when present) -> wait for the server
+//             plugin to publish the binding URL into session metadata
+//             (~seconds; worker-down surfaces as a timeout toast) -> copy.
+//  stop-sharing   resolve root -> confirm -> read binding -> clear flag ->
+//             DELETE the share directly via the worker (belt and braces:
+//             works even if the server plugin never saw the flag event) ->
+//             the server-side flag-removal path cleans up on its own.
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { loadConfig, moduleDir, configPaths, configHomePath, resolveServer, saveServerEntry, deleteServerEntry, METADATA_KEY } from "./config.js";
+import { dbg, dbgLog } from "./sidebar.js";
+export const CONSENT_KV_KEY = "openshare_consent";
+export function pluginConfigPaths(baseDir = moduleDir()) {
+    return configPaths(baseDir);
+}
+export function currentConfig(baseDir = moduleDir()) {
+    return loadConfig(baseDir);
+}
+/** Writes the config file. Target rule (owner-directed): the global
+ * settings home by default, or an explicit existing file chosen in the
+ * TUI — NEVER "first existing in the read chain" (that wrote TUI edits
+ * into the tracked adjacent template, live-caught). $comment and foreign
+ * keys preserved. */
+export function saveConfig(cfg, target, baseDir = moduleDir()) {
+    const path = target ?? configHomePath();
+    if (!path)
+        return undefined;
+    try {
+        const previous = existsSync(path)
+            ? (() => {
+                try {
+                    return JSON.parse(readFileSync(path, "utf8"));
+                }
+                catch {
+                    return {};
+                }
+            })()
+            : {};
+        // preserve $comment and any foreign keys, override with our values
+        const next = { ...previous };
+        for (const key of [
+            "workerUrl",
+            "createToken",
+            "servers",
+            "debounceMs",
+            "completedDelayMs",
+            "modelLabel",
+            "ttlDays",
+            "openTasksInNewTab",
+            "authLogin",
+            "authPassword",
+            "spoolDir",
+            "urlFile",
+            "shareMode",
+            "announceStderr",
+        ]) {
+            next[key] = cfg[key];
+        }
+        writeFileSync(path, JSON.stringify(next, null, 2) + "\n");
+        return { path };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function isConfigured(cfg) {
+    // token optional: with none, the engine (or the TUI connect flow)
+    // enrolls on first contact — public servers take anyone, private ones
+    // need servers.{url}.code
+    return Boolean(resolveServer(cfg)?.url);
+}
+/** The resolved active server (url + entry), for the TUI server rows. */
+export function activeServer(cfg = currentConfig()) {
+    return resolveServer(cfg);
+}
+export function serverEntries(cfg = currentConfig()) {
+    const merged = {};
+    if (cfg.workerUrl)
+        merged[cfg.workerUrl] = { token: cfg.createToken || "", active: true };
+    if (cfg.servers)
+        for (const [url, entry] of Object.entries(cfg.servers))
+            merged[url] = { ...merged[url], ...entry };
+    const urls = Object.keys(merged);
+    const activeUrl = urls.find((u) => merged[u].active) ?? urls[0];
+    return urls.map((url) => ({ url, entry: merged[url], active: url === activeUrl }));
+}
+export { saveServerEntry, deleteServerEntry };
+// --- session metadata helpers -------------------------------------------------
+/** All live per-server bindings from a v2 (or legacy v1) metadata record. */
+export function bindingsOf(info) {
+    const raw = info?.metadata?.[METADATA_KEY];
+    if (!raw || typeof raw !== "object")
+        return [];
+    const record = raw;
+    const opts = record.opts ?? undefined;
+    const enabled = record.enabled === true ? true : undefined;
+    const out = [];
+    if (record.servers && typeof record.servers === "object") {
+        for (const [server, entry] of Object.entries(record.servers)) {
+            if (!entry || typeof entry !== "object")
+                continue;
+            const e = entry;
+            if (typeof e.id !== "string" || typeof e.secret !== "string" || !e.id)
+                continue;
+            const collided = typeof e.collided === "string" ? e.collided : undefined;
+            out.push({
+                id: e.id,
+                secret: e.secret,
+                rev: typeof e.rev === "number" ? e.rev : 0,
+                url: typeof e.url === "string" ? e.url : "",
+                enabled,
+                opts,
+                server,
+                collided,
+            });
+        }
+        return out;
+    }
+    // legacy flat binding
+    if (typeof record.id === "string" && typeof record.secret === "string" && record.id) {
+        const collided = typeof record.collided === "string" ? record.collided : undefined;
+        out.push({
+            id: record.id,
+            secret: record.secret,
+            rev: typeof record.rev === "number" ? record.rev : 0,
+            url: typeof record.url === "string" ? record.url : "",
+            enabled,
+            opts,
+            server: "",
+            collided,
+        });
+    }
+    return out;
+}
+/** Read every live binding for a session (fan-out aware). */
+export async function readBindings(client, sid) {
+    return bindingsOf(await getSession(client, sid));
+}
+export function hostOf(url) {
+    try {
+        return new URL(url).host;
+    }
+    catch {
+        return url;
+    }
+}
+/** Mutate metadata.openshare.servers[url] through a patcher (TUI per-
+ * server actions: opt-out entries, collision resolution). Reads-modifies-
+ * writes the whole metadata to keep foreign keys intact. */
+export async function patchSessionBinding(client, sid, mutator) {
+    const info = await getSession(client, sid);
+    if (!info)
+        return false;
+    const metadata = { ...(info.metadata ?? {}) };
+    const raw = info.metadata?.[METADATA_KEY];
+    const binding = raw && typeof raw === "object" ? { ...raw } : { v: 2, servers: {} };
+    const servers = binding.servers && typeof binding.servers === "object" ? { ...binding.servers } : {};
+    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
+ * there, else the first live entry (single-server configs are unchanged). */
+export function bindingOf(info) {
+    const all = bindingsOf(info);
+    if (!all.length)
+        return undefined;
+    const active = activeServer()?.url;
+    return all.find((b) => b.server === active) ?? all[0];
+}
+async function getSession(client, sid) {
+    if (!client?.session?.get)
+        return undefined;
+    try {
+        const res = await client.session.get({ path: { id: sid } });
+        const info = res?.data ?? res;
+        return info && typeof info === "object" ? info : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function patchMetadata(client, sid, metadata) {
+    if (!client?.session?.update) {
+        dbgLog(`patchMetadata(${sid}): no client.session.update`);
+        return false;
+    }
+    try {
+        const res = await client.session.update({ path: { id: sid }, body: { metadata } });
+        if (res && typeof res === "object" && "error" in res && res.error) {
+            const err = res.error;
+            dbgLog(`patchMetadata(${sid}) ERROR: ${err?.name}: ${err?.data?.message ?? ""} ref=${err?.data?.ref ?? ""}`);
+            return false;
+        }
+        dbgLog(`patchMetadata(${sid}): ok res=${dbg(res)}`);
+        return true;
+    }
+    catch (e) {
+        dbgLog(`patchMetadata(${sid}) THREW: ${e?.stack ?? e}`);
+        return false;
+    }
+}
+/** Walks parentID up to the root session (the share owns the whole tree). */
+export async function resolveRoot(client, sid) {
+    let current = sid;
+    for (let hops = 0; hops < 10; hops++) {
+        const info = await getSession(client, current);
+        const parent = info?.parentID;
+        if (typeof parent !== "string" || !parent || parent === current)
+            return current;
+        current = parent;
+    }
+    return current;
+}
+export async function readBinding(client, sid) {
+    return bindingOf(await getSession(client, sid));
+}
+/** Sets metadata.openshare = { ...existing(v2 structure preserved),
+ * enabled: true, opts? }. The per-server binding entries are the ENGINE's
+ * to manage; the flag just opts the session in. */
+export async function setShareFlag(client, sid, opts) {
+    const info = await getSession(client, sid);
+    if (!info)
+        return false;
+    const metadata = { ...(info.metadata ?? {}) };
+    const existing = info.metadata?.[METADATA_KEY];
+    const value = existing && typeof existing === "object"
+        ? { ...existing }
+        : { v: 2, servers: {} };
+    value.enabled = true;
+    if (opts && Object.keys(opts).length)
+        value.opts = opts;
+    metadata[METADATA_KEY] = value;
+    return patchMetadata(client, sid, metadata);
+}
+export async function clearShareFlag(client, sid) {
+    const info = await getSession(client, sid);
+    if (!info)
+        return false;
+    const metadata = { ...(info.metadata ?? {}) };
+    delete metadata[METADATA_KEY];
+    return patchMetadata(client, sid, metadata);
+}
+// --- worker direct access -------------------------------------------------------
+export async function workerDeleteShare(workerUrl, id, secret) {
+    try {
+        const res = await fetch(`${workerUrl.replace(/\/$/, "")}/api/share/${id}`, {
+            method: "DELETE",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ secret }),
+            signal: AbortSignal.timeout(8000),
+        });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/** Health probe for the settings dialog's connection test. */
+export async function probeWorker(workerUrl) {
+    if (!workerUrl)
+        return { ok: false, detail: "workerUrl is empty" };
+    try {
+        const res = await fetch(`${workerUrl.replace(/\/$/, "")}/health`, { signal: AbortSignal.timeout(6000) });
+        if (!res.ok)
+            return { ok: false, detail: `HTTP ${res.status}` };
+        const body = (await res.json().catch(() => ({})));
+        return { ok: true, detail: body.service ? `service: ${body.service}` : "reachable" };
+    }
+    catch (error) {
+        return { ok: false, detail: error.message };
+    }
+}
+/** Share liveness probe — the "session says shared but the link is dead"
+ * case (purged, TTL-expired, or deleted while the binding stayed in
+ * session metadata). GET /data answers 404 {status:"gone"} BEFORE the
+ * read-auth gate, so this is a credential-free existence check that
+ * works identically on the CF worker and the Bun server. Network errors
+ * return "unknown" — never auto-disable on unknown. */
+export async function verifyShare(workerUrl, shareId) {
+    const base = normServerUrl(workerUrl);
+    if (!base || !shareId)
+        return "unknown";
+    try {
+        const res = await fetch(`${base}/api/share/${shareId}/data`, { signal: AbortSignal.timeout(4000) });
+        if (res.status === 404) {
+            const body = (await res.json().catch(() => ({})));
+            return body.status === "gone" || Object.keys(body).length === 0 ? "gone" : "unknown";
+        }
+        // 200 = readable; 401 = read-gated but EXISTS. Both mean the page is there.
+        return "live";
+    }
+    catch {
+        return "unknown";
+    }
+}
+/** Remove the binding entries for shares that no longer exist server-side
+ * (the auto-disable half of gone detection). Entries are deleted outright —
+ * not optedOut — so a later prompt in the session can create a fresh share. */
+export async function clearGoneBindingEntries(host, root, servers) {
+    if (!servers.length)
+        return false;
+    return patchSessionBinding(host.client, root, (map) => {
+        for (const server of servers)
+            delete map[server];
+    });
+}
+// --- server identity ops (TUI) -----------------------------------------------
+export function normServerUrl(url) {
+    return url.trim().replace(/\/+$/, "");
+}
+/** /health probe including the auth mode (public enrolls anyone). */
+export async function probeAuthMode(workerUrl) {
+    const base = normServerUrl(workerUrl);
+    if (!base)
+        return { ok: false, detail: "no URL" };
+    try {
+        const res = await fetch(`${base}/health`, { signal: AbortSignal.timeout(6000) });
+        if (!res.ok)
+            return { ok: false, detail: `HTTP ${res.status}` };
+        const body = (await res.json().catch(() => ({})));
+        const mode = body.auth?.mode === "public" ? "public" : body.auth?.mode === "private" ? "private" : undefined;
+        return { ok: true, mode, detail: mode ? `auth: ${mode}` : "reachable (pre-auth server?)" };
+    }
+    catch (error) {
+        return { ok: false, detail: error.message };
+    }
+}
+export async function enrollAtServer(workerUrl, code) {
+    const base = normServerUrl(workerUrl);
+    try {
+        const res = await fetch(`${base}/api/enroll`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ code: code || undefined }),
+            signal: AbortSignal.timeout(10000),
+        });
+        const body = (await res.json().catch(() => ({})));
+        if (res.ok && body.ok && typeof body.token === "string") {
+            return { ok: true, token: body.token, userId: body.userId, label: body.label };
+        }
+        return { ok: false, error: body.error ?? `HTTP ${res.status}` };
+    }
+    catch (error) {
+        return { ok: false, error: error.message };
+    }
+}
+export async function rotateAtServer(workerUrl, token) {
+    const base = normServerUrl(workerUrl);
+    try {
+        const res = await fetch(`${base}/api/token/rotate`, {
+            method: "POST",
+            headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+            signal: AbortSignal.timeout(10000),
+        });
+        const body = (await res.json().catch(() => ({})));
+        if (res.ok && body.ok && typeof body.token === "string")
+            return { ok: true, token: body.token };
+        return { ok: false, error: body.error ?? `HTTP ${res.status}` };
+    }
+    catch (error) {
+        return { ok: false, error: error.message };
+    }
+}
+export async function disconnectAtServer(workerUrl, token) {
+    const base = normServerUrl(workerUrl);
+    try {
+        const res = await fetch(`${base}/api/token`, {
+            method: "DELETE",
+            headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+            signal: AbortSignal.timeout(10000),
+        });
+        const body = (await res.json().catch(() => ({})));
+        return { ok: res.ok && body.ok !== false, error: body.error };
+    }
+    catch (error) {
+        return { ok: false, error: error.message };
+    }
+}
+/** Thin typed client for the worker's /api/admin surface. `token` must be
+ * the server's root CREATE_TOKEN (user osk_ tokens get 403). */
+export function adminClient(workerUrl, token) {
+    const base = normServerUrl(workerUrl);
+    const call = async (method, path, body) => {
+        try {
+            const res = await fetch(`${base}${path}`, {
+                method,
+                headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+                body: body === undefined ? undefined : JSON.stringify(body),
+                signal: AbortSignal.timeout(12000),
+            });
+            const parsed = (await res.json().catch(() => ({})));
+            if (!res.ok)
+                return { ok: false, status: res.status, error: parsed?.error ?? `HTTP ${res.status}` };
+            return { ok: parsed?.ok !== false, status: res.status, data: parsed, error: parsed?.error };
+        }
+        catch (error) {
+            return { ok: false, status: 0, error: error.message };
+        }
+    };
+    return {
+        users: () => call("GET", "/api/admin/users"),
+        createUser: (label) => call("POST", "/api/admin/users", { label }),
+        freeze: (userId) => call("POST", `/api/admin/users/${userId}/freeze`),
+        unfreeze: (userId) => call("POST", `/api/admin/users/${userId}/unfreeze`),
+        deleteUser: (userId, mode) => call("DELETE", `/api/admin/users/${userId}`, { mode }),
+        tokens: () => call("GET", "/api/admin/tokens"),
+        mintToken: (userId, label, limits) => call("POST", "/api/admin/tokens", { userId, label, limits }),
+        revokeToken: (tokenId) => call("DELETE", `/api/admin/tokens/${tokenId}`),
+        codes: () => call("GET", "/api/admin/codes"),
+        createCode: (label, activations) => call("POST", "/api/admin/codes", { label, activations }),
+        disableCode: (codeId) => call("DELETE", `/api/admin/codes/${codeId}`),
+        shares: () => call("GET", "/api/admin/shares"),
+        deleteShare: (shareId) => call("DELETE", `/api/share/${shareId}`),
+        reassign: (shareId, userId) => call("POST", `/api/admin/shares/${shareId}/reassign`, { userId }),
+        purge: () => call("POST", "/api/admin/purge"),
+        health: () => call("GET", "/health"),
+    };
+}
+/** Resolve the admin credential for a server: the entry's adminToken, the
+ * legacy createToken (when it points at this server), or prompt. */
+export function adminTokenFor(url, cfg = currentConfig()) {
+    const base = normServerUrl(url);
+    const entry = serverEntries(cfg).find((s) => s.url === base);
+    return entry?.entry.adminToken ?? (cfg.workerUrl && normServerUrl(cfg.workerUrl) === base ? cfg.createToken : "") ?? "";
+}
+// --- the flows --------------------------------------------------------------------
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** Waits for the server plugin to publish the binding URL (poll; robust on
+ * both hosts). Resolves the binding, or undefined on timeout. */
+export async function waitForBinding(client, sid, timeoutMs = 25000) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        const binding = await readBinding(client, sid);
+        if (binding?.url)
+            return binding;
+        await sleep(600);
+    }
+    return undefined;
+}
+export async function runShareFlow(host, sessionID) {
+    if (!sessionID)
+        return { ok: false, message: "No active session to share." };
+    const cfg = currentConfig();
+    if (!isConfigured(cfg)) {
+        return { ok: false, message: "No share server connected — run /openshare to connect one.", unconfigured: true };
+    }
+    const root = await resolveRoot(host.client, sessionID);
+    const existing = await readBinding(host.client, root);
+    if (existing?.url && existing.enabled !== false) {
+        // already sharing: copy the link
+        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" };
+    }
+    return confirmShare(host, root);
+}
+/** Post-consent share: set the flag, wait for the URL, copy it. */
+export async function confirmShare(host, rootSessionID) {
+    dbgLog(`confirmShare: setShareFlag(${rootSessionID})`);
+    const set = await setShareFlag(host.client, rootSessionID);
+    dbgLog(`confirmShare: setShareFlag -> ${set}`);
+    if (!set)
+        return { ok: false, message: "Could not write the share flag into session metadata." };
+    const binding = await waitForBinding(host.client, rootSessionID);
+    dbgLog(`confirmShare: waitForBinding -> ${binding?.url ? binding.url : "timeout"}`);
+    if (!binding?.url) {
+        return {
+            ok: false,
+            message: "Share did not come up (timeout waiting for the URL). Is the worker reachable? Check the server plugin log for [openshare] lines.",
+        };
+    }
+    await host.clipboard.write(binding.url);
+    return { ok: true, message: `Share URL copied to clipboard: ${binding.url}`, url: binding.url };
+}
+export async function runUnshareFlow(host, sessionID) {
+    if (!sessionID)
+        return { ok: false, message: "No active session." };
+    const root = await resolveRoot(host.client, sessionID);
+    const info = await getSession(host.client, root);
+    const all = bindingsOf(info);
+    if (!all.length)
+        return { ok: false, message: "This session is not shared." };
+    // clear flag first (stops the forwarder), then delete every server's
+    // page directly — the direct delete also covers server plugins that
+    // never saw the event
+    await clearShareFlag(host.client, root);
+    let deleted = 0;
+    for (const b of all) {
+        // the binding URL carries the origin the share lives on (with
+        // multi-server that can differ from today's active entry)
+        const bindingOrigin = b.url ? b.url.slice(0, b.url.indexOf("/s/")) : "";
+        const deleteBase = bindingOrigin || b.server;
+        if (deleteBase && b.id && b.secret) {
+            if (await workerDeleteShare(deleteBase, b.id, b.secret))
+                deleted++;
+        }
+    }
+    return {
+        ok: true,
+        message: deleted === all.length
+            ? `Sharing stopped; ${deleted} share page${deleted === 1 ? "" : "s"} deleted.`
+            : `Sharing stopped (${deleted}/${all.length} pages deleted; the rest will follow via the sweeper).`,
+    };
+}

package/dist/sidebar.d.ts

@@ -0,0 +1,19 @@
+/** @jsxImportSource @opentui/solid */
+import type { JSX } from "@opentui/solid";
+import type { TuiPluginApi, TuiSlotContext } from "@opencode-ai/plugin/tui";
+/** value -> `kind:preview` so the log shows TYPES (the crash was a type bug) */
+export declare function dbg(v: unknown, depth?: number): string;
+export declare function dbgLog(line: string): void;
+type SidebarTitleProps = {
+    session_id: string;
+    title: string;
+    share_url?: string;
+};
+export declare function createSidebarSlot(api: TuiPluginApi, opts?: {
+    onShareCommand?: () => void;
+}): {
+    slots: {
+        sidebar_title: (ctx: TuiSlotContext, props: SidebarTitleProps) => JSX.Element;
+    };
+};
+export {};

package/dist/sidebar.js

@@ -0,0 +1,144 @@
+import { jsx as _jsx, jsxs as _jsxs } from "@opentui/solid/jsx-runtime";
+import { bindingsOf, bindingOf, verifyShare } from "./share-flow.js";
+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, depth = 0) {
+    const t = typeof v;
+    if (v === null)
+        return "null";
+    if (t === "string")
+        return `str(${v.length}):${JSON.stringify(v.slice(0, 60))}`;
+    if (t === "number" || t === "boolean" || t === "bigint")
+        return `${t}:${String(v)}`;
+    if (t === "undefined")
+        return "undef";
+    if (t === "function")
+        return `fn:${v.name || "anon"}`;
+    if (Array.isArray(v))
+        return `arr[${v.length}]:[${v.slice(0, 6).map((x) => dbg(x, depth + 1)).join(",")}]`;
+    if (depth >= 3)
+        return "obj:…";
+    try {
+        const keys = Object.keys(v);
+        return `obj{${keys.slice(0, 8).join(",")}}` + (depth < 2 ? `{${keys.slice(0, 8).map((k) => `${k}=${dbg(v[k], depth + 1)}`).join(",")}}` : "");
+    }
+    catch {
+        return "obj:?}";
+    }
+}
+/** shallow structural dump of a rendered element tree (type names, children kinds) */
+function dbgEl(el, depth = 0) {
+    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;
+        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) {
+    try {
+        appendFileSync(DBG_FILE, `${new Date().toISOString()} ${line}\n`);
+    }
+    catch { }
+}
+let renderSeq = 0;
+const GONE_TTL_MS = 60_000;
+const goneCache = new Map();
+function goneVerdict(sid, server, shareId) {
+    const key = `${sid}|${server}`;
+    const cached = goneCache.get(key);
+    if (cached && Date.now() - cached.at < GONE_TTL_MS)
+        return cached;
+    void verifyShare(server, shareId).then((status) => {
+        goneCache.set(key, { status, at: Date.now() });
+    });
+    return cached;
+}
+export function createSidebarSlot(api, opts) {
+    dbgLog(`createSidebarSlot called; api.state=${!!api.state} api.theme=${!!api.theme} api.version=${dbg(api.app?.version)}`);
+    return {
+        slots: {
+            sidebar_title: (ctx, props) => {
+                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;
+                    const binding = bindingOf(session);
+                    const allBindings = bindingsOf(session);
+                    const liveCount = allBindings.filter((b) => b.url && b.enabled !== false).length;
+                    const status = session?.time?.archived ? undefined : binding?.url ? (binding.enabled === false ? "attached" : "live") : undefined;
+                    // gone detection: any live-bound server whose page died server-side
+                    const checked = allBindings.filter((b) => b.url && b.enabled !== false && b.id && b.server);
+                    const verdicts = checked.map((b) => goneVerdict(sid, b.server, b.id));
+                    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.
+                    // A verified-gone share renders dim (⊘) and clicking opens the
+                    // share manager (verify + gone modal) instead of a dead copy.
+                    const copyLink = () => {
+                        if (anyGone) {
+                            opts?.onShareCommand?.();
+                            return;
+                        }
+                        const url = binding?.url;
+                        if (!url)
+                            return;
+                        // navigator first (no-op-resolves in the TUI runtime are
+                        // possible), then ALWAYS OSC52 — the empirically working path
+                        let copied = false;
+                        try {
+                            const clip = navigator.clipboard;
+                            if (typeof clip?.writeText === "function") {
+                                void clip.writeText(url).then(() => { }, () => { });
+                                copied = true;
+                            }
+                        }
+                        catch { }
+                        try {
+                            // OSC52 escape (most modern terminals, incl. Windows Terminal)
+                            process.stdout.write(`\x1b]52;c;${Buffer.from(url, "utf8").toString("base64")}\x07`);
+                            copied = true;
+                        }
+                        catch { }
+                        try {
+                            api.ui.toast({ variant: copied ? "success" : "info", title: "OpenShare", message: copied ? `Share link copied: ${url}` : `Share link: ${url}`, duration: 6000 });
+                        }
+                        catch { }
+                    };
+                    const el = (_jsxs("box", { flexDirection: "column", paddingRight: 1, children: [_jsx("text", { fg: theme.text, children: title }), status ? (_jsx("box", { onMouseDown: copyLink, children: _jsx("text", { fg: anyGone ? theme.error : binding?.enabled === false ? theme.warning : theme.success, children: anyGone
+                                        ? `⊘ re:share — gone (removed/expired) — click to fix`
+                                        : status === "live"
+                                            ? `◉ re:share ${multi}— click to copy link`
+                                            : "◉ re:share (dormant)" }) })) : null] }));
+                    dbgLog(`render#${seq} RETURNS ${dbgEl(el)}`);
+                    return el;
+                }
+                catch (error) {
+                    dbgLog(`render#${seq} THREW ${error?.stack ?? dbg(error)} — rethrowing`);
+                    throw error;
+                }
+            },
+        },
+    };
+}