@mirrowel/opencode-openshare 0.2.1 → 0.3.0-dev.1

package/dist/tui.js

@@ -22,11 +22,13 @@ var DEFAULTS = {
   debounceMs: 1e4,
   completedDelayMs: 5000,
   modelLabel: "$Provider/$Model",
-  ttlDays: 90,
+  ttlHours: 90 * 24,
   authLogin: "",
   authPassword: "",
   spoolDir: "",
   urlFile: "",
+  urlFileFormat: "url",
+  configSet: "",
   announceStderr: true
 };
 var CONFIG_NAME = "openshare.config.json";
@@ -97,10 +99,13 @@ function configSourceMap(pluginDir, env = process.env) {
     debounceMs: env.OPENSHARE_DEBOUNCE_MS,
     completedDelayMs: env.OPENSHARE_COMPLETED_DELAY_MS,
     modelLabel: env.OPENSHARE_MODEL_LABEL,
+    ttlHours: env.OPENSHARE_TTL_HOURS,
     ttlDays: env.OPENSHARE_TTL_DAYS,
     authLogin: env.OPENSHARE_AUTH_LOGIN,
     authPassword: env.OPENSHARE_AUTH_PASSWORD,
     urlFile: env.OPENSHARE_URL_FILE,
+    urlFileFormat: env.OPENSHARE_URL_FILE_FORMAT,
+    configSet: env.OPENSHARE_CONFIG_SET,
     spoolDir: env.OPENSHARE_SPOOL_DIR,
     announceStderr: env.OPENSHARE_ANNOUNCE_STDERR,
     shareMode: env.OPENSHARE_SHARE_MODE
@@ -109,6 +114,24 @@ function configSourceMap(pluginDir, env = process.env) {
     if (value !== undefined && value !== "")
       sources[key] = "environment";
   }
+  if (sources.ttlDays && !sources.ttlHours)
+    sources.ttlHours = sources.ttlDays;
+  delete sources.ttlDays;
+  if (env.OPENSHARE_CONFIG_JSON) {
+    try {
+      const raw = JSON.parse(env.OPENSHARE_CONFIG_JSON);
+      if (raw && typeof raw === "object") {
+        for (const [key, value] of Object.entries(raw)) {
+          if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean")
+            continue;
+          if (sources[key] === "environment")
+            continue;
+          if (key === "servers" || known.has(key))
+            sources[key] = "OPENSHARE_CONFIG_JSON";
+        }
+      }
+    } catch {}
+  }
   for (const path of configPaths(pluginDir, env)) {
     let raw;
     try {
@@ -162,6 +185,8 @@ function normalizeServers(raw) {
       entry.adminToken = e.adminToken;
     if (e.active === true)
       entry.active = true;
+    if (e.anonymous === true)
+      entry.anonymous = true;
     out[url] = entry;
   }
   return Object.keys(out).length ? out : undefined;
@@ -231,26 +256,53 @@ function loadConfig(pluginDir, options) {
   const cfg = { ...DEFAULTS };
   const emptyMeansUnset = new Set(["workerUrl", "createToken", "urlFile", "spoolDir"]);
   const known = new Set([...Object.keys(DEFAULTS), "shareMode"]);
-  for (const path of [...configPaths(pluginDir)].reverse()) {
-    try {
-      const raw = JSON.parse(readFileSync(path, "utf8"));
-      if (!raw || typeof raw !== "object")
+  const applyObject = (raw) => {
+    if (!raw || typeof raw !== "object")
+      return;
+    for (const [key, value] of Object.entries(raw)) {
+      if (key === "servers") {
+        const servers = normalizeServers(value);
+        if (servers)
+          cfg.servers = mergeServerGroups(cfg.servers, servers);
         continue;
-      for (const [key, value] of Object.entries(raw)) {
-        if (key === "servers") {
-          const servers = normalizeServers(value);
-          if (servers)
-            cfg.servers = mergeServerGroups(cfg.servers, servers);
-          continue;
+      }
+      if (key === "redact") {
+        if (value && typeof value === "object" && Array.isArray(value.patterns)) {
+          const pats = value.patterns.filter((x) => typeof x === "string" && x.length > 0 && x.length < 500).slice(0, 50);
+          cfg.redact = { patterns: pats };
         }
-        if (!known.has(key))
-          continue;
-        if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean")
-          continue;
-        if (typeof value === "string" && value === "" && emptyMeansUnset.has(key))
-          continue;
-        cfg[key] = value;
+        continue;
       }
+      if (key === "meta") {
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+          const clean = {};
+          for (const [mk, mv] of Object.entries(value)) {
+            if (typeof mv === "string" && mv.length <= 500 && mk.length <= 64)
+              clean[mk] = mv;
+          }
+          if (Object.keys(clean).length)
+            cfg.meta = { ...cfg.meta, ...clean };
+        }
+        continue;
+      }
+      if (key === "ttlDays") {
+        const d = Math.floor(Number(value));
+        if (Number.isFinite(d) && d > 0)
+          cfg.ttlHours = d * 24;
+        continue;
+      }
+      if (!known.has(key))
+        continue;
+      if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean")
+        continue;
+      if (typeof value === "string" && value === "" && emptyMeansUnset.has(key))
+        continue;
+      cfg[key] = value;
+    }
+  };
+  for (const path of [...configPaths(pluginDir)].reverse()) {
+    try {
+      applyObject(JSON.parse(readFileSync(path, "utf8")));
     } catch (e) {
       if (existsSync(path))
         console.error(`[openshare] config file ${path} could not be parsed - ignored:`, e?.message ?? e);
@@ -273,6 +325,13 @@ function loadConfig(pluginDir, options) {
       cfg.shareMode = mode;
   }
   const env = process.env;
+  if (env.OPENSHARE_CONFIG_JSON) {
+    try {
+      applyObject(JSON.parse(env.OPENSHARE_CONFIG_JSON));
+    } catch (e) {
+      console.error("[openshare] OPENSHARE_CONFIG_JSON could not be parsed - ignored:", e?.message ?? e);
+    }
+  }
   if (env.OPENSHARE_WORKER_URL)
     cfg.workerUrl = env.OPENSHARE_WORKER_URL;
   if (env.OPENSHARE_CREATE_TOKEN)
@@ -283,14 +342,20 @@ function loadConfig(pluginDir, options) {
     cfg.completedDelayMs = num(env.OPENSHARE_COMPLETED_DELAY_MS, cfg.completedDelayMs);
   if (env.OPENSHARE_MODEL_LABEL !== undefined)
     cfg.modelLabel = env.OPENSHARE_MODEL_LABEL;
+  if (env.OPENSHARE_TTL_HOURS)
+    cfg.ttlHours = num(env.OPENSHARE_TTL_HOURS, cfg.ttlHours);
   if (env.OPENSHARE_TTL_DAYS)
-    cfg.ttlDays = num(env.OPENSHARE_TTL_DAYS, cfg.ttlDays);
+    cfg.ttlHours = Math.max(1, Math.floor(num(env.OPENSHARE_TTL_DAYS, 90) * 24));
   if (env.OPENSHARE_AUTH_LOGIN !== undefined)
     cfg.authLogin = env.OPENSHARE_AUTH_LOGIN;
   if (env.OPENSHARE_AUTH_PASSWORD !== undefined)
     cfg.authPassword = env.OPENSHARE_AUTH_PASSWORD;
   if (env.OPENSHARE_URL_FILE !== undefined)
     cfg.urlFile = env.OPENSHARE_URL_FILE;
+  if (env.OPENSHARE_URL_FILE_FORMAT === "json" || env.OPENSHARE_URL_FILE_FORMAT === "url")
+    cfg.urlFileFormat = env.OPENSHARE_URL_FILE_FORMAT;
+  if (env.OPENSHARE_CONFIG_SET)
+    cfg.configSet = env.OPENSHARE_CONFIG_SET;
   if (env.OPENSHARE_SPOOL_DIR)
     cfg.spoolDir = env.OPENSHARE_SPOOL_DIR;
   if (env.OPENSHARE_ANNOUNCE_STDERR !== undefined)
@@ -444,8 +509,18 @@ function queueBindingWrite(sid, fn) {
   return run;
 }
 
+// src/redact.ts
+var PATH_KEYS = new Set(["file", "path", "filePath", "cwd", "directory", "root"]);
+
 // src/core.ts
 var liveTargets = [];
+var statsProvider = null;
+var redactionLedger = new Map;
+function sessionStatsFor(sid) {
+  const led = redactionLedger.get(sid) ?? { count: 0, samples: [] };
+  const counts = statsProvider ? statsProvider(sid) : { messages: 0, toolCalls: 0 };
+  return { ...counts, redaction: led };
+}
 function engineTargetUrls() {
   return liveTargets;
 }
@@ -474,7 +549,7 @@ function saveConfig(cfg, target, baseDir = moduleDir()) {
       "debounceMs",
       "completedDelayMs",
       "modelLabel",
-      "ttlDays",
+      "ttlHours",
       "authLogin",
       "authPassword",
       "spoolDir",
@@ -562,6 +637,23 @@ function bindingsOf(info) {
 async function readBindings(client, sid) {
   return bindingsOf(await getSession(client, sid));
 }
+function fmtHours(hours) {
+  if (!Number.isFinite(hours) || hours <= 0)
+    return "?";
+  if (hours % 24 === 0)
+    return `${Math.floor(hours / 24)}d`;
+  return `${Math.floor(hours)}h`;
+}
+function parseTtlHours(raw) {
+  const m = /^\s*(\d+(?:\.\d+)?)\s*(h|d|hr|hours?|days?)?\s*$/i.exec(raw ?? "");
+  if (!m)
+    return;
+  const v = Number(m[1]);
+  if (!Number.isFinite(v) || v <= 0)
+    return;
+  const unit = (m[2] ?? "h").toLowerCase();
+  return Math.max(1, Math.floor(unit.startsWith("d") ? v * 24 : v));
+}
 function hostOf(url) {
   try {
     return new URL(url).host;
@@ -683,6 +775,27 @@ async function workerDeleteShare(workerUrl, id, secret) {
     return false;
   }
 }
+async function patchShareOpts(workerUrl, id, opts, secret) {
+  const body = { secret };
+  if (opts.authLogin !== undefined && opts.authPassword !== undefined) {
+    body.authLogin = opts.authLogin;
+    body.authPassword = opts.authPassword;
+  }
+  if (opts.ttlHours !== undefined)
+    body.ttlHours = opts.ttlHours;
+  try {
+    const res = await fetch(`${workerUrl.replace(/\/$/, "")}/api/share/${id}`, {
+      method: "PATCH",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(8000)
+    });
+    const json = await res.json().catch(() => ({}));
+    return res.ok && json.ok ? { ok: true } : { ok: false, error: json.error ?? `HTTP ${res.status}` };
+  } catch (e) {
+    return { ok: false, error: e?.message || String(e) };
+  }
+}
 async function probeWorker(workerUrl) {
   if (!workerUrl)
     return { ok: false, detail: "workerUrl is empty" };
@@ -866,8 +979,10 @@ async function requestShareConsent(host, context) {
     const bits = [];
     if (context.server)
       bits.push(`server: ${context.server}`);
-    if (context.ttlDays !== undefined)
-      bits.push(`TTL: ${context.ttlDays}d`);
+    if (context.ttlHours !== undefined)
+      bits.push(`TTL: ${fmtHours(context.ttlHours)}`);
+    if (context.redaction && context.redaction.hits > 0)
+      bits.push(`redaction: ${context.redaction.hits} hit(s)`);
     bits.push(`read auth: ${context.auth ? "on" : "off"}`);
     lines.push(bits.join(" - "));
   }
@@ -895,12 +1010,18 @@ async function shareWithConsent(host, sessionID) {
   }
   const opts = all[0]?.opts;
   const server = serverEntries(cfg).find((s) => s.active) ?? serverEntries(cfg)[0] ?? (engineTargetUrls()[0] ? { url: engineTargetUrls()[0] } : undefined);
-  if (!await requestShareConsent(host, {
-    server: server ? hostOf(server.url) : undefined,
-    ttlDays: opts?.ttlDays ?? cfg.ttlDays,
-    auth: !!(opts?.authLogin ?? cfg.authLogin) && !!(opts?.authPassword ?? cfg.authPassword)
-  }))
-    return { ok: false, message: "Share cancelled." };
+  {
+    const stats = sessionStatsFor(root);
+    const gated = !!(opts?.authLogin ?? cfg.authLogin) && !!(opts?.authPassword ?? cfg.authPassword);
+    if (!await requestShareConsent(host, {
+      server: server ? hostOf(server.url) : undefined,
+      ttlHours: opts?.ttlHours ?? cfg.ttlHours,
+      auth: gated,
+      counts: { messages: stats.messages, toolCalls: stats.toolCalls },
+      redaction: gated ? undefined : { hits: stats.redaction.count, samples: stats.redaction.samples.map((h) => `${h.sample} [${h.kind}]`) }
+    }))
+      return { ok: false, message: "Share cancelled." };
+  }
   return confirmShare(host, root);
 }
 async function confirmShare(host, rootSessionID) {
@@ -1070,15 +1191,15 @@ A graceful opencode exit flushes the pending flip, so CI runs land their final s
     info: 'How the model name appears on the share page. "$Provider/$Model" renders e.g. "closedrouter/zai/glm-5.3". Any literal text is used as-is; empty string hides the model line entirely.',
     def: '"$Provider/$Model"'
   },
-  ttlDays: {
-    label: "TTL (days)",
-    help: "Share lifetime; the worker caps it at its MAX_TTL_DAYS.",
+  ttlHours: {
+    label: "TTL (hours)",
+    help: "Share lifetime in hours (2d writes 48); capped server-side.",
     kind: "number",
     section: "Sharing",
-    info: `How long pages live before the server's sweeper deletes them. Capped server-side: the deployment's MAX_TTL_DAYS and the token's maxTtlDays limit both apply.
+    info: `How long pages live before the server's sweeper deletes them, in HOURS. Capped server-side: the deployment's MAX_TTL_HOURS (legacy MAX_TTL_DAYS converted) and the token's limit both apply; the floor is one hour.
 
-A per-session override lives in the This-session section; it is sent at create/attach time.`,
-    def: "worker cap (90 on the reference deployment)"
+A per-session override lives in the This-session section; it is sent at create/attach time. The session prompt takes 6h / 2d style input.`,
+    def: "worker cap (2160h = 90d on the reference deployment)"
   },
   authLogin: {
     label: "Read auth: login",
@@ -1203,26 +1324,74 @@ async function connectServerFlow(host) {
   const url = normServerUrl(raw);
   if (!/^https?:\/\//.test(url))
     return { ok: false, message: "URL must start with http:// or https://" };
-  host.ui.toast({ variant: "info", title: "OpenShare", message: `Probing ${url}\u2026` });
+  host.ui.toast({ variant: "info", title: "OpenShare", message: `Probing ${url}:` });
   const probe = await probeAuthMode(url);
   if (!probe.ok)
     return { ok: false, message: `${url}: ${probe.detail}` };
-  let code = "";
-  if (probe.mode === "private") {
-    const typed = await showPrompt(host.ui, { title: `${url} needs an access code`, placeholder: "osc_\u2026 (from the hoster)" });
+  const existing = serverEntries().find((sv) => sv.url === url)?.entry ?? {};
+  const deactivateOthers = () => {
+    for (const other of serverEntries()) {
+      if (other.url !== url)
+        saveServerEntry(other.url, { active: undefined });
+    }
+  };
+  if (probe.mode === "public") {
+    const picked = await showSelect(host.ui, {
+      title: `${url} - account?`,
+      options: [
+        {
+          value: "onboard",
+          title: "Onboard (get an account)",
+          description: "your own user, tokens and share limits; survives the server's anonymous caps",
+          help: "An account gives you a revocable identity with your own share registry and limits. Depending on the server you may need a one-time access code from the hoster - you'll be asked only if it's required."
+        },
+        {
+          value: "anon",
+          title: "Stay anonymous",
+          description: "share without an account; counts against the server-wide anonymous limits",
+          help: "No identity, no token to manage. Shares are ownerless: whoever holds the share's secret controls them, and the server may throttle anonymous creates globally. You can onboard later from Servers -> the server -> Enroll now."
+        }
+      ]
+    });
+    if (picked === "anon") {
+      saveServerEntry(url, { ...existing.token ? {} : { anonymous: true }, label: existing.label, active: true });
+      return { ok: true, message: `Connected to ${url} anonymously - sharing works, no account.`, url };
+    }
+    if (picked === undefined || picked === null)
+      return { ok: false, message: "Cancelled." };
+    let code = existing.code ?? "";
+    if (!code) {
+      const free = await enrollAtServer(url, "");
+      if (free.ok) {
+        deactivateOthers();
+        saveServerEntry(url, { token: free.token, label: free.label, anonymous: undefined, active: true });
+        return { ok: true, message: `Connected to ${url} as "${free.label}" - sharing goes there now.`, url };
+      }
+      const typed = await showPrompt(host.ui, { title: `${url} needs an access code`, placeholder: "osc_: (from the hoster)" });
+      if (typed === undefined)
+        return { ok: false, message: "Cancelled - this server needs a code to onboard." };
+      code = typed.trim();
+    }
+    const res = await enrollAtServer(url, code);
+    if (!res.ok)
+      return { ok: false, message: `Enrollment refused: ${res.error}` };
+    deactivateOthers();
+    saveServerEntry(url, { token: res.token, label: res.label, code: code || undefined, anonymous: undefined, active: true });
+    return { ok: true, message: `Connected to ${url} as "${res.label}" - sharing goes there now.`, url };
+  }
+  let code = existing.code ?? "";
+  if (!code) {
+    const typed = await showPrompt(host.ui, { title: `${url} needs an access code`, placeholder: "osc_: (from the hoster)" });
     if (typed === undefined)
-      return { ok: false, message: "Cancelled \u2014 private servers need a code." };
+      return { ok: false, message: "Cancelled - private servers need a code." };
     code = typed.trim();
   }
   const res = await enrollAtServer(url, code);
   if (!res.ok)
     return { ok: false, message: `Enrollment refused: ${res.error}` };
-  for (const other of serverEntries()) {
-    if (other.url !== url)
-      saveServerEntry(other.url, { active: undefined });
-  }
+  deactivateOthers();
   saveServerEntry(url, { token: res.token, label: res.label, code: code || undefined, active: true });
-  return { ok: true, message: `Connected to ${url} as "${res.label}" \u2014 sharing goes there now.`, url };
+  return { ok: true, message: `Connected to ${url} as "${res.label}" - sharing goes there now.`, url };
 }
 async function serverMenu(host, url) {
   while (true) {
@@ -1231,7 +1400,7 @@ async function serverMenu(host, url) {
     if (!mine)
       return;
     const holdsRoot = !!mine.entry.token && mine.entry.token === (mine.entry.adminToken ?? adminTokenFor(url));
-    const cred = holdsRoot ? `ROOT token ${mask(mine.entry.token)} \u2014 admin, no user identity` : mine.entry.token ? `token ${mask(mine.entry.token)}` : mine.entry.code ? "no token (code saved, enrolls on demand)" : "no token (public server, enrolls on demand)";
+    const cred = holdsRoot ? `ROOT token ${mask(mine.entry.token)} \u2014 admin, no user identity` : mine.entry.token ? `token ${mask(mine.entry.token)}` : mine.entry.code ? "no token (code saved, enrolls on demand)" : mine.entry.anonymous ? "anonymous (declined onboarding)" : "no token (public server, shares anonymously)";
     const options = [
       { title: url, value: "info", description: `${mine.entry.label ?? "(no label)"} \xB7 ${cred}${mine.active ? " \xB7 ACTIVE" : ""}`, disabled: true }
     ];
@@ -1311,8 +1480,18 @@ Needs the server's root CREATE_TOKEN (saved admin token used first; prompted oth
         continue;
       }
       let code = mine.entry.code ?? "";
-      if (probe.mode === "private" && !code) {
-        const typed = await showPrompt(host.ui, { title: `${url} needs an access code`, placeholder: "osc_\u2026 (from the hoster)" });
+      if (!code) {
+        const free = await enrollAtServer(url, "");
+        if (free.ok) {
+          saveServerEntry(url, { token: free.token, label: free.label, anonymous: undefined });
+          host.ui.toast({ variant: "success", title: "OpenShare", message: `Enrolled as "${free.label}".` });
+          continue;
+        }
+        if (!/code required/i.test(free.error ?? "")) {
+          await showInfo(host.ui, { title: "Enrollment refused", message: free.error ?? "unknown error" });
+          continue;
+        }
+        const typed = await showPrompt(host.ui, { title: `${url} needs an access code`, placeholder: "osc_: (from the hoster)" });
         if (typed === undefined)
           continue;
         code = typed.trim();
@@ -1321,7 +1500,7 @@ Needs the server's root CREATE_TOKEN (saved admin token used first; prompted oth
       }
       const res = await enrollAtServer(url, code);
       if (res.ok) {
-        saveServerEntry(url, { token: res.token, label: res.label });
+        saveServerEntry(url, { token: res.token, label: res.label, anonymous: undefined });
         host.ui.toast({ variant: "success", title: "OpenShare", message: `Enrolled as "${res.label}".` });
       } else {
         await showInfo(host.ui, { title: "Enrollment refused", message: res.error ?? "unknown error" });
@@ -1984,10 +2163,10 @@ The clamp note appears when the server or your token's policy reduced a requeste
     rows.push({
       title: "Session TTL override (days)",
       value: "session:ttl",
-      description: binding?.opts?.ttlDays !== undefined ? String(binding.opts.ttlDays) : "(worker default)",
-      help: `Per-session share lifetime. Overrides the config ttlDays for THIS session's pages; still capped by the server's MAX_TTL_DAYS and the token's maxTtlDays. On a live share it applies immediately (shortening may end an older page at once); otherwise it is used when you share.
+      description: binding?.opts?.ttlHours !== undefined ? fmtHours(binding.opts.ttlHours) : "(worker default)",
+      help: `Per-session share lifetime in HOURS (prompt accepts 6h / 2d / 48). Overrides the config TTL for THIS session's pages; still capped server-side. On a live share it applies immediately (shortening may end an older page at once); otherwise it is used when you share.
 
-Current: ${binding?.opts?.ttlDays !== undefined ? `${binding.opts.ttlDays} days` : "(none \u2014 config default)"}`
+Current: ${binding?.opts?.ttlHours !== undefined ? fmtHours(binding.opts.ttlHours) : "(none \u2014 config default)"}`
     });
     rows.push({
       title: "Session read auth",
@@ -2218,26 +2397,32 @@ Every link stops working for everyone. This cannot be undone.`,
         return;
       }
       if (choice === "session:ttl") {
-        const raw = await showPrompt(host.ui, { title: "Session TTL (days)", placeholder: "days", value: current?.opts?.ttlDays !== undefined ? String(current.opts.ttlDays) : "" });
+        const raw = await showPrompt(host.ui, { title: "Session TTL", placeholder: "hours: 6h, 2d or 48", value: current?.opts?.ttlHours !== undefined ? fmtHours(current.opts.ttlHours) : "" });
         if (raw === undefined)
           return;
         const opts = { ...current?.opts ?? {} };
         if (raw === "")
-          delete opts.ttlDays;
+          delete opts.ttlHours;
         else {
-          const days = Number(raw);
-          if (!Number.isFinite(days) || days <= 0) {
-            host.ui.toast({ variant: "error", title: "OpenShare", message: "TTL must be a positive number of days." });
+          const hours = parseTtlHours(raw);
+          if (hours === undefined) {
+            host.ui.toast({ variant: "error", title: "OpenShare", message: "TTL must be 6h / 2d style or a positive number of hours." });
             return;
           }
-          opts.ttlDays = Math.floor(days);
+          opts.ttlHours = hours;
         }
         await setShareOpts(host.client, root, opts);
         const liveNow = live.length > 0;
+        if (liveNow) {
+          const results = await Promise.all(live.map((b) => b.id && b.secret && b.server ? patchShareOpts(b.server, b.id, opts.ttlHours !== undefined ? { ttlHours: opts.ttlHours } : {}, b.secret) : Promise.resolve({ ok: false })));
+          const failed = results.filter((r) => !r.ok).length;
+          if (failed)
+            host.ui.toast({ variant: "error", title: "OpenShare", message: `TTL applied on ${results.length - failed}/${results.length} server(s) - the rest sync on next connect.` });
+        }
         host.ui.toast({
           variant: "success",
           title: "OpenShare",
-          message: liveNow ? `Session TTL: ${opts.ttlDays !== undefined ? `${opts.ttlDays}d - applied now (shortening may end an older page immediately)` : "(default) - applied now"}.` : `Session TTL: ${opts.ttlDays !== undefined ? `${opts.ttlDays}d` : "(default)"} - saved, applies when you share.`
+          message: liveNow ? `Session TTL: ${opts.ttlHours !== undefined ? `${fmtHours(opts.ttlHours)} - applied now (shortening may end an older page immediately)` : "(default) - applied now"}.` : `Session TTL: ${opts.ttlHours !== undefined ? fmtHours(opts.ttlHours) : "(default)"} - saved, applies when you share.`
         });
         return;
       }
@@ -2262,6 +2447,13 @@ Every link stops working for everyone. This cannot be undone.`,
         }
         await setShareOpts(host.client, root, opts);
         const liveNow2 = live.length > 0;
+        if (liveNow2) {
+          const pair = login === "" ? { authLogin: "", authPassword: "" } : { authLogin: login, authPassword: password };
+          const results2 = await Promise.all(live.map((b) => b.id && b.secret && b.server ? patchShareOpts(b.server, b.id, pair, b.secret) : Promise.resolve({ ok: false })));
+          const failed2 = results2.filter((r) => !r.ok).length;
+          if (failed2)
+            host.ui.toast({ variant: "error", title: "OpenShare", message: `Read auth applied on ${results2.length - failed2}/${results2.length} server(s) - the rest sync on next connect.` });
+        }
         host.ui.toast({ variant: "success", title: "OpenShare", message: liveNow2 ? `Read auth ${login === "" ? "removed" : "saved"} - applied now.` : `Read auth ${login === "" ? "cleared" : "saved"} - applies when you share.` });
         return;
       }
@@ -2312,7 +2504,7 @@ Every ACTIVE server receives new sessions (fan-out).`
     });
     groups.push({
       id: "sharing",
-      summary: `sync ${seconds(cfg.debounceMs, 1e4)} \xB7 completed ${seconds(cfg.completedDelayMs, 5000)} \xB7 TTL ${cfg.ttlDays ?? "server cap"}`,
+      summary: `sync ${seconds(cfg.debounceMs, 1e4)} \xB7 completed ${seconds(cfg.completedDelayMs, 5000)} \xB7 TTL ${fmtHours(cfg.ttlHours ?? 2160)}`,
       help: `What and how sessions stream: share mode (all/manual), sync cadence, the completed-delay, the model label on pages, share TTL, and the viewer's task-tab behavior.
 
 Cadence values are clamped by the server's policy window.`

package/dist/ui-prefs.js

@@ -1,9 +1,9 @@
-// Host-agnostic dialog size preferences (owner decision 2026-10-19: host
-// kv, not the config file — UI settings are per-host and synced by
-// opencode itself). dialog width maps to the host's fixed dialog widths;
-// height is a percent of terminal rows. v1 dialogs apply these directly
-// (dialogs.tsx); the settings dialog edits them through this module so the
-// flows stay host-agnostic.
+// Host-agnostic dialog size preferences, stored in host kv rather than the
+// config file because UI settings are per-host and synced by opencode
+// itself. Dialog width maps to the host's fixed dialog widths; height is a
+// percent of terminal rows. v1 dialogs apply these directly (dialogs.tsx);
+// the settings dialog edits them through this module so the flows stay
+// host-agnostic.
 export const UI_WIDTH_KV = "openshare.ui-width";
 export const UI_HEIGHT_PERCENT_KV = "openshare.ui-height-percent";
 export const HEIGHT_PERCENT_MIN = 25;

package/dist/v2-server.js

@@ -177,12 +177,11 @@ 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.
+        // NOTE: no content-hash dedupe here. A refresh running 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, so the share's first assistant content would only arrive on
+        // the next change. Dedupe belongs engine-side, where dormancy is known.
         const pendingRefresh = new Map();
         // queued inbox inputs per session: v2 persists the prompt in the inbox
         // (delivery "queue") while the current turn still runs — the message

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mirrowel/opencode-openshare",
-  "version": "0.2.1",
+  "version": "0.3.0-dev.1",
   "type": "module",
   "description": "Open(code)Share — re:share: self-hosted session sharing for opencode. Server plugin (single file or package), optional TUI for interactive opt-in sharing.",
   "license": "MIT",

package/src/binding-queue.ts

@@ -5,8 +5,8 @@
  * 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).
+ * at T3, and A's change is silently lost (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.

package/src/commands.ts

@@ -5,14 +5,14 @@
 // 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
-// plugin layer MUST NOT pass mode ("global" made the whole layer
-// unreachable — no palette entries, no slash commands, no shadow) and
-// must not carry undefined-valued command fields. The registration shape
-// 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).
+// LAYER SHAPE: the v1 host keymap gates layers that declare `mode` on the
+// mode stack (resting mode is "base"), so a plugin layer MUST NOT pass mode
+// ("global" made the whole layer unreachable: no palette entries, no slash
+// commands, no shadow) and must not carry undefined-valued command fields.
+// The registration shape 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 {
   clearGoneBindingEntries,