@mirrowel/opencode-openshare 0.0.0-stage → 0.1.0

package/ci/openshare.js

@@ -0,0 +1,2265 @@
+// Open(code)Share — re:share, session sharing for opencode. Self-hosted
+// replacement for the discontinued opencode share. Streams session events
+// over one WebSocket per main session to an openshare-worker; viewers
+// watch via hibernating sockets.
+//
+// This is the SINGLE-FILE build of the server plugin (generated by
+// scripts/build-standalone.mjs — do not edit; edit src/ and rebuild).
+// It behaves exactly like the package's dist/server.js.
+//
+// Install:
+//  - CI / share-everything: reference this file in the `plugin` array of
+//    your opencode config (no TUI part -> every session shares, the URL
+//    lands in the log and optionally in `urlFile`).
+//  - Interactive opt-in: install the package's TUI part (tui.json) too —
+//    the server detects its presence and switches to manual mode
+//    (`/share`, `/unshare` in the TUI).
+//
+// Config: env (OPENSHARE_*) > openshare.config.json (next to this file)
+// > code defaults. Keys: workerUrl, createToken, debounceMs, modelLabel,
+// ttlDays, openTasksInNewTab, authLogin, authPassword, spoolDir, urlFile,
+// shareMode ("all" | "manual"; default = TUI presence).
+//
+// src/config.ts
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+var METADATA_KEY = "openshare";
+var URL_FILE_NONE = "none";
+var DEFAULTS = {
+  workerUrl: "",
+  createToken: "",
+  debounceMs: 1e4,
+  completedDelayMs: 5000,
+  modelLabel: "$Provider/$Model",
+  ttlDays: 90,
+  openTasksInNewTab: true,
+  authLogin: "",
+  authPassword: "",
+  spoolDir: "",
+  urlFile: "",
+  announceStderr: true
+};
+var CONFIG_NAME = "openshare.config.json";
+var LOCAL_NAME = "openshare.local.json";
+function moduleDir() {
+  return dirname(fileURLToPath(import.meta.pathname ?? import.meta.url));
+}
+function packageRoot(start) {
+  let current = start;
+  for (let guard = 0;guard < 16; guard++) {
+    if (existsSync(join(current, "package.json")))
+      return current;
+    const parent = dirname(current);
+    if (parent === current)
+      break;
+    current = parent;
+  }
+  return start;
+}
+function configPaths(pluginDir, env = process.env) {
+  const paths = [join(pluginDir, CONFIG_NAME)];
+  const root = packageRoot(pluginDir);
+  if (root !== pluginDir)
+    paths.push(join(root, CONFIG_NAME));
+  let current = pluginDir;
+  for (let i = 0;i < 5; i++) {
+    paths.push(join(current, LOCAL_NAME));
+    const parent = dirname(current);
+    if (parent === current)
+      break;
+    current = parent;
+  }
+  paths.push(join(globalConfigDir(env), CONFIG_NAME));
+  return paths;
+}
+function configHomePath(env = process.env) {
+  return join(globalConfigDir(env), CONFIG_NAME);
+}
+function num(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function str(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function normalizeServers(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return;
+  const out = {};
+  for (const [url, value] of Object.entries(raw)) {
+    if (!url.startsWith("http") || !value || typeof value !== "object")
+      continue;
+    const e = value;
+    const entry = {};
+    if (typeof e.token === "string" && e.token)
+      entry.token = e.token;
+    if (typeof e.code === "string" && e.code)
+      entry.code = e.code;
+    if (typeof e.label === "string" && e.label)
+      entry.label = e.label;
+    if (typeof e.adminToken === "string" && e.adminToken)
+      entry.adminToken = e.adminToken;
+    if (e.active === true)
+      entry.active = true;
+    out[url] = entry;
+  }
+  return Object.keys(out).length ? out : undefined;
+}
+function mergeServerGroups(base, add) {
+  const merged = { ...base ?? {} };
+  for (const [url, entry] of Object.entries(add))
+    merged[url] = { ...merged[url] ?? {}, ...entry };
+  return merged;
+}
+function resolveServer(cfg) {
+  const servers = {};
+  if (cfg.workerUrl)
+    servers[cfg.workerUrl] = { token: cfg.createToken || "", adminToken: cfg.createToken || "", active: true };
+  if (cfg.servers)
+    for (const [url2, entry] of Object.entries(cfg.servers))
+      servers[url2] = entry;
+  const urls = Object.keys(servers);
+  if (!urls.length)
+    return;
+  const url = urls.find((u) => servers[u].active) ?? urls[0];
+  return { url, token: servers[url].token ?? "", entry: servers[url] };
+}
+function saveServerEntry(url, patch, target) {
+  const path = target ?? configHomePath();
+  if (!path || !url.startsWith("http"))
+    return;
+  try {
+    let previous = {};
+    try {
+      previous = JSON.parse(readFileSync(path, "utf8"));
+      if (!previous || typeof previous !== "object")
+        previous = {};
+    } catch {}
+    const servers = normalizeServers(previous.servers) ?? {};
+    servers[url] = { ...servers[url], ...patch };
+    previous.servers = servers;
+    writeFileSync(path, JSON.stringify(previous, null, 2) + `
+`);
+    return path;
+  } catch {
+    return;
+  }
+}
+function saveServerToken(url, token, target) {
+  return saveServerEntry(url, { token }, target);
+}
+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")
+        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 (!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;
+      }
+    } catch {}
+  }
+  if (options && typeof options === "object") {
+    const serversOpt = normalizeServers(options.servers);
+    if (serversOpt)
+      cfg.servers = mergeServerGroups(cfg.servers, serversOpt);
+    for (const key of Object.keys(DEFAULTS)) {
+      const value = options[key];
+      if (value === undefined || value === null)
+        continue;
+      if (typeof value === "number" || typeof value === "boolean" || typeof value === "string") {
+        cfg[key] = value;
+      }
+    }
+    const mode = str(options.shareMode);
+    if (mode === "all" || mode === "manual")
+      cfg.shareMode = mode;
+  }
+  const env = process.env;
+  if (env.OPENSHARE_WORKER_URL)
+    cfg.workerUrl = env.OPENSHARE_WORKER_URL;
+  if (env.OPENSHARE_CREATE_TOKEN)
+    cfg.createToken = env.OPENSHARE_CREATE_TOKEN;
+  if (env.OPENSHARE_DEBOUNCE_MS)
+    cfg.debounceMs = num(env.OPENSHARE_DEBOUNCE_MS, cfg.debounceMs);
+  if (env.OPENSHARE_COMPLETED_DELAY_MS !== undefined)
+    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_DAYS)
+    cfg.ttlDays = num(env.OPENSHARE_TTL_DAYS, cfg.ttlDays);
+  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_SPOOL_DIR)
+    cfg.spoolDir = env.OPENSHARE_SPOOL_DIR;
+  if (env.OPENSHARE_ANNOUNCE_STDERR !== undefined)
+    cfg.announceStderr = !/^(0|false|no|off)$/i.test(env.OPENSHARE_ANNOUNCE_STDERR.trim());
+  if (env.OPENSHARE_SHARE_MODE === "all" || env.OPENSHARE_SHARE_MODE === "manual")
+    cfg.shareMode = env.OPENSHARE_SHARE_MODE;
+  if (cfg.urlFile.trim().toLowerCase() === URL_FILE_NONE)
+    cfg.urlFile = URL_FILE_NONE;
+  return cfg;
+}
+function spoolDirFor(cfg) {
+  if (cfg.spoolDir)
+    return cfg.spoolDir;
+  const base = process.env.XDG_DATA_HOME || (process.env.HOME ? join(process.env.HOME, ".local", "share") : "/tmp");
+  return join(base, "opencode", "openshare");
+}
+var NPM_NAME = "@mirrowel/opencode-openshare";
+function normalizePath(value) {
+  return value.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+}
+function specPath(spec) {
+  if (!spec.startsWith("file:"))
+    return;
+  try {
+    let url = spec;
+    if (!url.startsWith("file:///") && url.startsWith("file://"))
+      url = `file:///${url.slice("file://".length)}`;
+    return normalizePath(new URL(url).pathname);
+  } catch {
+    return;
+  }
+}
+function isOpenShareSpec(spec) {
+  if (typeof spec !== "string" || spec.length === 0)
+    return false;
+  if (spec === NPM_NAME || spec.startsWith(`${NPM_NAME}@`))
+    return true;
+  const path = specPath(spec);
+  if (path) {
+    if (path.endsWith("/opencode-openshare") || path.endsWith("/share-plugin"))
+      return true;
+    return path.includes("/opencode-openshare/") || path.includes("/share-plugin/");
+  }
+  const normalized = normalizePath(spec);
+  if (/^[a-z]:\//.test(normalized) || normalized.startsWith("/")) {
+    if (normalized.endsWith("/opencode-openshare") || normalized.endsWith("/share-plugin"))
+      return true;
+    return normalized.includes("/opencode-openshare/") || normalized.includes("/share-plugin/");
+  }
+  return false;
+}
+function readJson(path) {
+  try {
+    if (!existsSync(path))
+      return {};
+    const data = JSON.parse(readFileSync(path, "utf8"));
+    return data && typeof data === "object" ? data : {};
+  } catch {
+    return {};
+  }
+}
+function specStrings(data) {
+  const result = [];
+  for (const key of ["plugin", "plugins"]) {
+    const array = data[key];
+    if (!Array.isArray(array))
+      continue;
+    for (const entry of array) {
+      const spec = typeof entry === "string" ? entry : Array.isArray(entry) && typeof entry[0] === "string" ? entry[0] : entry && typeof entry === "object" && typeof entry.package === "string" ? entry.package : undefined;
+      if (spec !== undefined)
+        result.push(spec);
+    }
+  }
+  return result;
+}
+function globalConfigDir(env) {
+  if (env["OPENCODE_CONFIG_DIR"])
+    return env["OPENCODE_CONFIG_DIR"];
+  if (env["XDG_CONFIG_HOME"])
+    return join(env["XDG_CONFIG_HOME"], "opencode");
+  const home = process.env.USERPROFILE ?? process.env.HOME ?? "";
+  return join(home, ".config", "opencode");
+}
+function tuiLayerPaths(input) {
+  const env = input.env ?? process.env;
+  const paths = [];
+  const globalTui = join(globalConfigDir(env), "tui.json");
+  if (existsSync(globalTui))
+    paths.push(globalTui);
+  const envTui = env["OPENCODE_TUI_CONFIG"];
+  if (envTui && existsSync(envTui))
+    paths.push(envTui);
+  if (input.directory) {
+    const dir = normalizePath(input.directory);
+    const worktree = input.worktree ? normalizePath(input.worktree) : undefined;
+    const sane = worktree !== undefined && worktree !== "/" && !/^[a-z]:\/$/.test(worktree) && (dir === worktree || dir.startsWith(`${worktree}/`));
+    let current = dir;
+    for (let guard = 0;guard < 64 && current; guard++) {
+      for (const name of ["tui.json", ".opencode/tui.json"]) {
+        const candidate = `${current}/${name}`;
+        if (existsSync(candidate) && !paths.includes(candidate))
+          paths.push(candidate);
+      }
+      if (sane && current === worktree)
+        break;
+      const parent = dirname(current);
+      if (parent === current)
+        break;
+      current = parent;
+    }
+  }
+  return paths;
+}
+function detectTuiPresence(input) {
+  try {
+    for (const layer of tuiLayerPaths(input)) {
+      if (specStrings(readJson(layer)).some((spec) => isOpenShareSpec(spec)))
+        return true;
+    }
+  } catch {}
+  return false;
+}
+function resolveShareMode(cfg, input) {
+  if (cfg.shareMode === "all" || cfg.shareMode === "manual")
+    return cfg.shareMode;
+  return detectTuiPresence(input) ? "manual" : "all";
+}
+
+// src/core.ts
+import { appendFileSync, existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+var DEFAULT_POLICY = {
+  mode: "persistent",
+  turnGraceMs: 120000,
+  idleDropMs: 600000,
+  finalizeAfterMs: 300000,
+  debounceMinMs: 0,
+  debounceMaxMs: Infinity,
+  completedDelayMaxMs: Infinity
+};
+var stderrInfoAllowed = true;
+var log = (...a) => {
+  if (!stderrInfoAllowed)
+    return;
+  try {
+    console.error(`[${METADATA_KEY}]`, ...a);
+  } catch {}
+};
+var logError = (...a) => {
+  try {
+    console.error(`[${METADATA_KEY}]`, ...a);
+  } catch {}
+};
+function formatLabel(template, model) {
+  if (template === "")
+    return "";
+  if (!model)
+    return template ?? "";
+  return (template ?? "").replace(/\$Provider/g, model.providerID ?? "").replace(/\$provider/g, model.providerID ?? "").replace(/\$Model/g, model.modelID ?? "").replace(/\$model/g, model.modelID ?? "");
+}
+function itemFor(type, data, sessionID) {
+  if (type === "model")
+    return { key: `model/${sessionID}`, item: { type, sessionID, data } };
+  if (type === "prefs")
+    return { key: "prefs", item: { type, data } };
+  if (type === "session")
+    return { key: `session/${data?.id ?? ""}`, item: { type, data } };
+  if (type === "message")
+    return { key: `message/${data?.id ?? ""}`, item: { type, data } };
+  if (type === "part")
+    return { key: `part/${data?.messageID ?? ""}/${data?.id ?? ""}`, item: { type, data } };
+  if (type === "session_diff")
+    return { key: `session_diff/${sessionID}`, item: { type, sessionID, data } };
+  return;
+}
+function redact(info) {
+  if (!info?.metadata || typeof info.metadata !== "object")
+    return info;
+  if (!(METADATA_KEY in info.metadata))
+    return info;
+  const metadata = { ...info.metadata };
+  delete metadata[METADATA_KEY];
+  return { ...info, metadata };
+}
+function shareFlag(info) {
+  const raw = info?.metadata?.[METADATA_KEY];
+  if (!raw || typeof raw !== "object")
+    return { enabled: false, opts: undefined };
+  const record = raw;
+  if (record.enabled !== true)
+    return { enabled: false, opts: undefined };
+  const optsRaw = record.opts;
+  const opts = {};
+  if (optsRaw && typeof optsRaw === "object") {
+    const o = optsRaw;
+    if (typeof o.ttlDays === "number" && o.ttlDays > 0)
+      opts.ttlDays = o.ttlDays;
+    if (typeof o.authLogin === "string")
+      opts.authLogin = o.authLogin;
+    if (typeof o.authPassword === "string")
+      opts.authPassword = o.authPassword;
+    if (typeof o.modelLabel === "string")
+      opts.modelLabel = o.modelLabel;
+  }
+  return { enabled: true, opts: Object.keys(opts).length ? opts : undefined };
+}
+function createEngine(deps) {
+  let cfg = loadConfig(deps.pluginDir, deps.options);
+  const mode = resolveShareMode(cfg, deps);
+  if (mode === "manual")
+    stderrInfoAllowed = false;
+  if (process.env.OPENSHARE_DEBUG_FILE) {
+    try {
+      writeFileSync2(process.env.OPENSHARE_DEBUG_FILE, JSON.stringify({
+        mode,
+        directory: deps.directory,
+        worktree: deps.worktree,
+        pluginDir: deps.pluginDir,
+        shareModeCfg: cfg.shareMode ?? null
+      }, null, 2));
+    } catch {}
+  }
+  const server = resolveServer(cfg);
+  if (!server || !server.url) {
+    log("disabled: no share server configured (workerUrl or a servers entry)");
+    return {
+      mode,
+      config: () => cfg,
+      hooks: {
+        event: async () => {},
+        dispose: async () => {}
+      }
+    };
+  }
+  log(`share mode: ${mode} (directory: ${deps.directory ?? "?"} worktree: ${deps.worktree ?? "?"})`);
+  const resolveTargets = () => {
+    const merged = {};
+    if (cfg.workerUrl)
+      merged[cfg.workerUrl] = { token: cfg.createToken || "", active: true };
+    if (cfg.servers)
+      for (const [u, e] of Object.entries(cfg.servers))
+        merged[u] = { ...merged[u], ...e };
+    const urls = Object.keys(merged);
+    const actives = urls.filter((u) => merged[u].active);
+    const chosen = actives.length ? actives : urls.slice(0, 1);
+    return chosen.map((url) => ({ url, entry: merged[url] }));
+  };
+  let targets = resolveTargets();
+  const credState = new Map;
+  const credOf = (url) => {
+    let s = credState.get(url);
+    if (!s) {
+      s = { credential: "", error: "", lastEnrollAt: 0 };
+      credState.set(url, s);
+    }
+    return s;
+  };
+  const seedCredentials = () => {
+    for (const t of targets) {
+      const c = credOf(t.url);
+      if (t.entry.token) {
+        if (c.credential !== t.entry.token) {
+          c.credential = t.entry.token;
+          c.error = "";
+        }
+      } else if (!c.credential && !c.error) {
+        c.credential = "";
+      }
+    }
+  };
+  seedCredentials();
+  const ENROLL_RETRY_MS = 60000;
+  const ensureCredential = async (url) => {
+    const c = credOf(url);
+    const target = targets.find((t) => t.url === url);
+    if (c.credential)
+      return c.credential;
+    if (Date.now() - c.lastEnrollAt < ENROLL_RETRY_MS)
+      return "";
+    c.lastEnrollAt = Date.now();
+    try {
+      const h = await fetch(`${url}/health`, { signal: AbortSignal.timeout(8000) });
+      const hb = h.ok ? await h.json().catch(() => null) : null;
+      const authMode2 = hb?.auth?.mode;
+      const code = target?.entry.code ?? "";
+      if (authMode2 === "public" || code) {
+        const r = await fetch(`${url}/api/enroll`, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ code }),
+          signal: AbortSignal.timeout(1e4)
+        });
+        const b = r.ok ? await r.json().catch(() => null) : null;
+        if (b?.ok && typeof b.token === "string") {
+          c.credential = b.token;
+          c.error = "";
+          const savedTo = saveServerToken(url, c.credential);
+          log(`enrolled at ${url} (user ${b.userId} "${b.label}")${savedTo ? " - token saved" : ""}`);
+          return c.credential;
+        }
+        c.error = `enroll refused: ${b?.error ?? `HTTP ${r.status}`}`;
+      } else if (authMode2 === "private") {
+        c.error = "private server: add servers.{url}.code (or token) to enroll";
+      } else {
+        c.error = `server health unreachable (HTTP ${h.status})`;
+      }
+    } catch (e) {
+      c.error = `enrollment failed: ${e?.message || e}`;
+    }
+    logError(`no credential for ${url}: ${c.error}`);
+    return "";
+  };
+  const remoteFor = (st, url) => {
+    let r = st.remotes.get(url);
+    if (!r) {
+      r = {
+        url,
+        shareId: null,
+        secret: null,
+        ackedRev: 0,
+        ws: null,
+        wsReady: false,
+        connecting: false,
+        socketSeq: 0,
+        initTimer: null,
+        initWasAttach: false,
+        backoff: 1000,
+        reconnectTimer: null,
+        intentionalClose: false,
+        connectQueued: false,
+        authBlocked: false,
+        pending: [],
+        announced: false,
+        settleTimer: null,
+        idleDropTimer: null,
+        collided: null
+      };
+      st.remotes.set(url, r);
+    }
+    return r;
+  };
+  const policyMap = new Map;
+  const policyAsked = new Set;
+  const policyOf = (url) => policyMap.get(url) ?? DEFAULT_POLICY;
+  const clampToPolicy = () => {
+    const policies = [...policyMap.values()];
+    if (!policies.length)
+      return;
+    const min = Math.max(0, ...policies.map((p) => p.debounceMinMs));
+    const max = Math.min(...policies.map((p) => p.debounceMaxMs));
+    cfg.debounceMs = Math.min(Math.max(cfg.debounceMs, min), Math.max(min, max));
+    const cd = Math.min(...policies.map((p) => p.completedDelayMaxMs));
+    cfg.completedDelayMs = Math.min(Math.max(cfg.completedDelayMs, 0), cd);
+  };
+  const applyPolicy = (raw, url) => {
+    if (!raw || typeof raw !== "object")
+      return;
+    const p = raw;
+    const num2 = (v, d) => {
+      const n = Number(v);
+      return Number.isFinite(n) && n >= 0 ? n : d;
+    };
+    const prev = policyOf(url);
+    policyMap.set(url, {
+      mode: p.mode === "turn" ? "turn" : "persistent",
+      turnGraceMs: num2(p.turnGraceMs, prev.turnGraceMs),
+      idleDropMs: num2(p.idleDropMs, prev.idleDropMs),
+      finalizeAfterMs: num2(p.finalizeAfterMs, prev.finalizeAfterMs),
+      debounceMinMs: num2(p.debounceMinMs, 0),
+      debounceMaxMs: Math.max(num2(p.debounceMaxMs, Infinity), num2(p.debounceMinMs, 0)),
+      completedDelayMaxMs: num2(p.completedDelayMaxMs, Infinity)
+    });
+    clampToPolicy();
+    if (debugEvents)
+      log(`policy ${url}: ${JSON.stringify(policyOf(url))}`);
+  };
+  const askPolicy = (url) => {
+    if (policyAsked.has(url))
+      return;
+    policyAsked.add(url);
+    fetch(`${url}/health`, { signal: AbortSignal.timeout(8000) }).then((r) => r.ok ? r.json() : null).then((b) => {
+      if (b && typeof b === "object" && b.policy) {
+        applyPolicy(b.policy, url);
+      }
+    }).catch(() => {
+      policyAsked.delete(url);
+    });
+  };
+  const wsUrl = (url) => url.replace(/^http/, "ws");
+  let spoolRoot = spoolDirFor(cfg);
+  try {
+    mkdirSync(spoolRoot, { recursive: true });
+  } catch {}
+  const sessions = new Map;
+  const childToParent = new Map;
+  const bootTime = Date.now();
+  const preExistingRetired = new Set;
+  const verifying = new Set;
+  let chain = Promise.resolve();
+  let lastUrlFile = null;
+  let urlFileAnnounced = false;
+  const newSt = (sid) => ({
+    sid,
+    client: deps.client,
+    queue: new Map,
+    timer: null,
+    metaTimer: null,
+    completedTimer: null,
+    lastFlushAt: 0,
+    statusEpoch: 0,
+    remotes: new Map,
+    status: "live",
+    badSignal: false,
+    lastSentStatus: null,
+    closed: false,
+    prefsSent: false,
+    binding: null,
+    bindingQueried: false,
+    optOuts: new Set,
+    opts: undefined,
+    activated: false,
+    wroteBinding: false,
+    everConnected: false
+  });
+  const refreshConfig = () => {
+    const next = loadConfig(deps.pluginDir, deps.options);
+    const resolved = resolveServer(next);
+    if (resolved?.url) {
+      cfg = next;
+      spoolRoot = spoolDirFor(cfg);
+      const before = new Set(targets.map((t) => t.url));
+      targets = resolveTargets();
+      seedCredentials();
+      clampToPolicy();
+      if (debugEvents) {
+        const after = targets.map((t) => t.url);
+        const added = after.filter((u) => !before.has(u));
+        if (added.length)
+          log(`fan-out set grew: ${added.join(", ")}`);
+      }
+    }
+  };
+  const activate = (sid, opts, info, opts2) => {
+    refreshConfig();
+    let st = sessions.get(sid);
+    if (!st) {
+      st = newSt(sid);
+      sessions.set(sid, st);
+    } else if (st.activated) {
+      if (opts)
+        st.opts = opts;
+      return st;
+    }
+    st.activated = true;
+    st.opts = opts;
+    const gated = mode === "manual" || opts2?.gated === true;
+    if (gated) {
+      chain = chain.then(() => seedManualStatus(st)).then(() => backfill(st, info)).then(() => queueConnectAll(st)).catch((e) => logError("activation error", e?.message || e));
+    } else {
+      queueConnectAll(st);
+    }
+    return st;
+  };
+  const seedManualStatus = async (st) => {
+    if (!st.client || typeof st.client.session.status !== "function")
+      return;
+    try {
+      const map = unwrap(await st.client.session.status({
+        ...deps.directory ? { query: { directory: deps.directory } } : {}
+      }));
+      const type = map && typeof map === "object" ? map[st.sid]?.type : undefined;
+      if (type === "busy" || type === "retry") {
+        st.status = "live";
+        if (type === "retry")
+          st.badSignal = true;
+      } else {
+        st.status = "completed";
+      }
+    } catch {}
+  };
+  const stFor = (sid) => {
+    const main = childToParent.get(sid) ?? sid;
+    return sessions.get(main) ?? null;
+  };
+  const unwrap = (res) => {
+    if (res && typeof res === "object" && "error" in res && res.error) {
+      throw new Error(`client error: ${JSON.stringify(res.error).slice(0, 120)}`);
+    }
+    return res?.data ?? res;
+  };
+  async function sessionInfo(client, sid) {
+    if (!client)
+      return;
+    try {
+      const info = unwrap(await client.session.get({
+        path: { id: sid },
+        ...deps.directory ? { query: { directory: deps.directory } } : {}
+      }));
+      return info;
+    } catch {
+      return;
+    }
+  }
+  async function writeMetadata(st, value) {
+    if (!st.client)
+      return;
+    try {
+      const info = unwrap(await st.client.session.get({
+        path: { id: st.sid },
+        ...deps.directory ? { query: { directory: deps.directory } } : {}
+      }));
+      const metadata = { ...info?.metadata ?? {} };
+      if (value === null)
+        delete metadata[METADATA_KEY];
+      else
+        metadata[METADATA_KEY] = value;
+      unwrap(await st.client.session.update({
+        path: { id: st.sid },
+        body: { metadata },
+        ...deps.directory ? { query: { directory: deps.directory } } : {}
+      }));
+    } catch (e) {
+      log("metadata write failed (spool still covers reconnects):", e?.message || e);
+    }
+  }
+  const parseBinding = (record) => {
+    const out = new Map;
+    if (record.servers && typeof record.servers === "object") {
+      for (const [url, raw] of Object.entries(record.servers)) {
+        if (!raw || typeof raw !== "object")
+          continue;
+        const e = raw;
+        if (typeof e.id === "string" && typeof e.secret === "string" && e.id && e.secret) {
+          out.set(url, { id: e.id, secret: e.secret, rev: typeof e.rev === "number" ? e.rev : 0 });
+        } else if (e.optedOut === true) {
+          out.set(url, { id: "", secret: "", rev: 0, optedOut: true });
+        }
+      }
+      return out;
+    }
+    if (typeof record.id === "string" && typeof record.secret === "string" && record.id) {
+      const url = targets[0]?.url ?? "";
+      if (url)
+        out.set(url, { id: record.id, secret: record.secret, rev: typeof record.rev === "number" ? record.rev : 0 });
+    }
+    return out;
+  };
+  async function readBinding(st) {
+    if (!st.client || st.bindingQueried)
+      return;
+    st.bindingQueried = true;
+    try {
+      const info = await sessionInfo(st.client, st.sid);
+      const b = info?.metadata?.[METADATA_KEY];
+      if (b && typeof b === "object") {
+        const record = b;
+        if (mode === "manual" && record.enabled !== true) {
+          return;
+        }
+        const found = parseBinding(record);
+        if (found.size) {
+          for (const [url, e] of found) {
+            if (e.optedOut)
+              continue;
+            const r = remoteFor(st, url);
+            if (!r.shareId) {
+              r.shareId = e.id;
+              r.secret = e.secret;
+              r.ackedRev = e.rev;
+            }
+          }
+          if (mode === "manual")
+            st.opts = shareFlag(info).opts ?? st.opts;
+          log(`binding recovered from session metadata: ${[...found.keys()].join(", ")}`);
+        }
+      }
+    } catch (e) {
+      log("metadata read failed (degrading to spool):", e?.message || e);
+    }
+  }
+  async function writeBinding(st) {
+    if (!st.client)
+      return;
+    const servers = {};
+    let any = false;
+    for (const [url, r] of st.remotes) {
+      if (!r.shareId || !r.secret)
+        continue;
+      any = true;
+      const entry = { id: r.shareId, secret: r.secret, rev: r.ackedRev, url: `${url}/s/${r.shareId}` };
+      if (r.collided)
+        entry.collided = r.collided;
+      servers[url] = entry;
+    }
+    if (!any)
+      return;
+    for (const url of st.optOuts)
+      if (!servers[url])
+        servers[url] = { optedOut: true };
+    const value = { v: 2, servers, enabled: true };
+    if (mode === "manual" && st.opts)
+      value.opts = st.opts;
+    st.binding = value;
+    st.wroteBinding = true;
+    await writeMetadata(st, value);
+  }
+  const scheduleBindingWrite = (st) => {
+    if (st.metaTimer)
+      return;
+    st.metaTimer = setTimeout(() => {
+      st.metaTimer = null;
+      chain = chain.then(() => writeBinding(st)).catch(() => {});
+    }, 30000);
+  };
+  const h8 = (url) => {
+    let h = 5381;
+    for (let i = 0;i < url.length; i++)
+      h = (h << 5) + h + url.charCodeAt(i) >>> 0;
+    return h.toString(16).padStart(8, "0");
+  };
+  const metaPath = (st, url) => join2(spoolRoot, `${st.sid}.${h8(url)}.meta.json`);
+  const queuePath = (st, url) => join2(spoolRoot, `${st.sid}.${h8(url)}.queue.jsonl`);
+  const legacyMetaPath = (st) => join2(spoolRoot, `${st.sid}.meta.json`);
+  const legacyQueuePath = (st) => join2(spoolRoot, `${st.sid}.queue.jsonl`);
+  const spoolSave = (st, r) => {
+    try {
+      writeFileSync2(metaPath(st, r.url), JSON.stringify({ shareId: r.shareId, secret: r.secret, ackedRev: r.ackedRev, sid: st.sid, url: r.url }));
+      writeFileSync2(queuePath(st, r.url), r.pending.map((f) => JSON.stringify(f)).join(`
+`) + (r.pending.length ? `
+` : ""));
+    } catch (e) {
+      logError("spool save failed", e?.message || e);
+    }
+  };
+  const spoolLoad = (st, r) => {
+    try {
+      const meta = JSON.parse(readFileSync2(metaPath(st, r.url), "utf8"));
+      if (!r.shareId && meta.shareId) {
+        r.shareId = meta.shareId;
+        r.secret = meta.secret;
+        r.ackedRev = meta.ackedRev ?? 0;
+      }
+      if (existsSync2(queuePath(st, r.url))) {
+        r.pending = readFileSync2(queuePath(st, r.url), "utf8").split(`
+`).filter((l) => l.trim()).map((l) => JSON.parse(l));
+      }
+    } catch {
+      r.pending = [];
+    }
+    if (!r.shareId && targets[0]?.url === r.url) {
+      try {
+        const meta = JSON.parse(readFileSync2(legacyMetaPath(st), "utf8"));
+        if (meta.shareId && !r.shareId) {
+          r.shareId = meta.shareId;
+          r.secret = meta.secret;
+          r.ackedRev = meta.ackedRev ?? 0;
+          if (existsSync2(legacyQueuePath(st))) {
+            r.pending = readFileSync2(legacyQueuePath(st), "utf8").split(`
+`).filter((l) => l.trim()).map((l) => JSON.parse(l));
+          }
+          log(`migrated legacy spool for ${st.sid.slice(0, 18)} onto ${r.url}`);
+        }
+      } catch {}
+    }
+  };
+  const spoolClear = (st, r) => {
+    try {
+      rmSync(metaPath(st, r.url), { force: true });
+      rmSync(queuePath(st, r.url), { force: true });
+    } catch {}
+  };
+  const wsSend = (r, obj) => {
+    if (debugEvents)
+      log(`ws ${r.url.slice(0, 24)} #${r.socketSeq} send ${obj?.op} (ready=${r.wsReady})`);
+    try {
+      r.ws?.send(JSON.stringify(obj));
+    } catch {
+      return false;
+    }
+    return true;
+  };
+  const SYNC_CHUNK = 200;
+  const sendSync = (r, f) => {
+    if (!f.items.length)
+      return wsSend(r, { op: "sync", items: [], status: f.status });
+    for (let i = 0;i < f.items.length; i += SYNC_CHUNK) {
+      wsSend(r, { op: "sync", items: f.items.slice(i, i + SYNC_CHUNK), status: f.status });
+    }
+    return true;
+  };
+  const announceUrl = (st, r) => {
+    if (r.announced)
+      return;
+    r.announced = true;
+    const url = `${r.url}/s/${r.shareId}`;
+    if (cfg.announceStderr)
+      log(`live: ${url}`);
+    if (mode === "all" && cfg.urlFile !== URL_FILE_NONE) {
+      const file = cfg.urlFile || join2(deps.directory ?? process.cwd(), "openshare.urls.txt");
+      try {
+        appendFileSync(file, url + `
+`);
+        if (cfg.announceStderr && (file !== lastUrlFile || !urlFileAnnounced)) {
+          urlFileAnnounced = true;
+          lastUrlFile = file;
+          log(`url file: ${file}`);
+        }
+      } catch {}
+    }
+  };
+  const authFrame = (st) => {
+    const login = st.opts?.authLogin ?? cfg.authLogin ?? "";
+    const password = st.opts?.authPassword ?? cfg.authPassword ?? "";
+    return { authLogin: login, authPassword: password };
+  };
+  const ttlFor = (st) => st.opts?.ttlDays ?? cfg.ttlDays;
+  const deleteAbandoned = (r) => {
+    const id = r.shareId;
+    const secret = r.secret;
+    if (!id || !secret)
+      return;
+    fetch(`${r.url}/api/share/${id}`, {
+      method: "DELETE",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ secret }),
+      signal: AbortSignal.timeout(8000)
+    }).catch(() => {});
+  };
+  const queueConnect = (st, r) => {
+    if (st.closed || r.connectQueued || r.connecting || r.authBlocked || r.collided)
+      return;
+    r.connectQueued = true;
+    chain = chain.then(() => {
+      r.connectQueued = false;
+      return connect(st, r);
+    }).catch((e) => logError("connect error", e?.message || e));
+  };
+  const queueConnectAll = (st) => {
+    if (st.closed)
+      return;
+    for (const t of targets) {
+      if (st.optOuts.has(t.url))
+        continue;
+      queueConnect(st, remoteFor(st, t.url));
+    }
+    for (const r of st.remotes.values()) {
+      if (st.optOuts.has(r.url))
+        continue;
+      queueConnect(st, r);
+    }
+  };
+  const refreshOptOuts = async (st) => {
+    if (!st.client)
+      return;
+    try {
+      const info = await sessionInfo(st.client, st.sid);
+      const raw = info?.metadata?.[METADATA_KEY];
+      if (!raw || typeof raw !== "object")
+        return;
+      const servers = raw.servers;
+      if (!servers || typeof servers !== "object")
+        return;
+      const entryUrls = new Set;
+      for (const [url, e] of Object.entries(servers)) {
+        entryUrls.add(url);
+        const out = !!(e && typeof e === "object" && e.optedOut === true);
+        if (out)
+          st.optOuts.add(url);
+        else
+          st.optOuts.delete(url);
+      }
+      for (const url of [...st.optOuts]) {
+        const r = st.remotes.get(url);
+        if (!r)
+          continue;
+        if (debugEvents)
+          log(`remote ${url.slice(0, 24)} opted out for ${st.sid.slice(0, 18)} - retiring`);
+        r.intentionalClose = true;
+        try {
+          r.ws?.close(1000, "opted out");
+        } catch {}
+        spoolClear(st, r);
+        st.remotes.delete(url);
+      }
+      for (const r of [...st.remotes.values()]) {
+        if (!r.collided || st.optOuts.has(r.url))
+          continue;
+        if (entryUrls.has(r.url))
+          continue;
+        if (debugEvents)
+          log(`collision on ${r.url.slice(0, 24)} resolved - re-arming`);
+        r.collided = null;
+        r.shareId = null;
+        r.secret = null;
+        r.ackedRev = 0;
+        r.pending = [];
+        r.announced = false;
+        queueConnect(st, r);
+      }
+    } catch {}
+  };
+  const connect = async (st, r) => {
+    if (st.closed || r.connecting || r.authBlocked || r.collided)
+      return;
+    r.connecting = true;
+    r.socketSeq += 1;
+    const seq = r.socketSeq;
+    if (r.ws) {
+      const old = r.ws;
+      try {
+        old.close(4000, "superseded");
+      } catch {}
+    }
+    try {
+      await readBinding(st);
+      spoolLoad(st, r);
+      askPolicy(r.url);
+      r.initWasAttach = !!(r.shareId && r.secret);
+      if (debugEvents)
+        log(`ws ${r.url.slice(0, 24)} #${seq} opening (${r.initWasAttach ? `attach ${r.shareId}` : "create"})`);
+      const cred = credOf(r.url);
+      const token = r.initWasAttach ? cred.credential : cred.credential || await ensureCredential(r.url);
+      if (!r.initWasAttach && !token && cred.error) {
+        r.authBlocked = true;
+        r.connecting = false;
+        r.ws = null;
+        logError(`sharing to ${r.url} disabled (no credential): ${cred.error}`);
+        return;
+      }
+      const ws = new WebSocket(`${wsUrl(r.url)}/api/ws?token=${encodeURIComponent(token ?? "")}`);
+      r.ws = ws;
+      await new Promise((resolve, reject) => {
+        const t = setTimeout(() => reject(new Error("ws open timeout")), 15000);
+        ws.addEventListener("open", () => {
+          clearTimeout(t);
+          resolve(undefined);
+        }, { once: true });
+        ws.addEventListener("error", () => {
+          clearTimeout(t);
+          reject(new Error("ws open error"));
+        }, { once: true });
+      });
+      ws.addEventListener("message", (ev) => {
+        if (seq !== r.socketSeq)
+          return;
+        let frame;
+        try {
+          frame = JSON.parse(ev.data);
+        } catch {
+          return;
+        }
+        handleFrame(st, r, frame).catch((e) => logError("frame error", e?.message || e));
+      });
+      ws.addEventListener("close", () => {
+        if (seq !== r.socketSeq)
+          return;
+        r.wsReady = false;
+        r.connecting = false;
+        if (r.intentionalClose) {
+          r.intentionalClose = false;
+          return;
+        }
+        if (!st.closed)
+          scheduleReconnect(st, r);
+      });
+      if (r.initWasAttach) {
+        wsSend(r, { op: "init", attach: { id: r.shareId, secret: r.secret, ...authFrame(st) } });
+      } else {
+        wsSend(r, { op: "init", create: { sessionID: st.sid, ttlDays: ttlFor(st), ...authFrame(st) } });
+      }
+      r.initTimer = setTimeout(() => {
+        if (seq !== r.socketSeq)
+          return;
+        logError(`ws ${r.url.slice(0, 24)} #${seq} init ack timeout`);
+        r.connecting = false;
+        try {
+          ws.close(4000, "init timeout");
+        } catch {}
+        if (!st.closed)
+          scheduleReconnect(st, r);
+      }, 20000);
+    } catch (e) {
+      r.connecting = false;
+      logError("socket failed:", e?.message || e, "- falling back to HTTP, will retry");
+      r.wsReady = false;
+      flushViaHttp(st, r).catch(() => {});
+      scheduleReconnect(st, r);
+      return;
+    }
+  };
+  const scheduleReconnect = (st, r) => {
+    if (st.closed || r.reconnectTimer)
+      return;
+    const wait = r.backoff;
+    r.backoff = Math.min(r.backoff * 2, 60000);
+    r.reconnectTimer = setTimeout(() => {
+      r.reconnectTimer = null;
+      queueConnect(st, r);
+    }, wait);
+  };
+  const dropSocket = (st, r, why) => {
+    if (debugEvents)
+      log(`turn: drop socket (${why}) ${r.url.slice(0, 24)} sid=${st.sid.slice(0, 18)}`);
+    r.wsReady = false;
+    r.intentionalClose = true;
+    try {
+      r.ws?.close(1000, why);
+    } catch {}
+    r.ws = null;
+  };
+  const cancelSettleDrop = (r) => {
+    if (r.settleTimer) {
+      clearTimeout(r.settleTimer);
+      r.settleTimer = null;
+    }
+  };
+  const armSettleDrop = (st) => {
+    for (const r of st.remotes.values()) {
+      const p = policyOf(r.url);
+      if (p.mode !== "turn" || p.turnGraceMs <= 0)
+        continue;
+      cancelSettleDrop(r);
+      r.settleTimer = setTimeout(() => {
+        r.settleTimer = null;
+        if (st.closed || !r.ws)
+          return;
+        dropSocket(st, r, "turn end");
+      }, p.turnGraceMs);
+    }
+  };
+  const armIdleDrop = (st) => {
+    for (const r of st.remotes.values()) {
+      const p = policyOf(r.url);
+      if (p.mode !== "turn" || p.idleDropMs <= 0)
+        continue;
+      if (r.idleDropTimer)
+        clearTimeout(r.idleDropTimer);
+      r.idleDropTimer = setTimeout(() => {
+        r.idleDropTimer = null;
+        if (st.closed || !r.ws)
+          return;
+        dropSocket(st, r, "idle timeout");
+      }, p.idleDropMs);
+    }
+  };
+  const touch = (st) => {
+    for (const r of st.remotes.values())
+      cancelSettleDrop(r);
+    armIdleDrop(st);
+  };
+  let lastTargetsCheck = 0;
+  const ensureConnected = (st) => {
+    if (st.closed)
+      return;
+    if (Date.now() - lastTargetsCheck > 5000) {
+      lastTargetsCheck = Date.now();
+      refreshConfig();
+    }
+    for (const t of targets) {
+      if (st.optOuts.has(t.url))
+        continue;
+      const r = remoteFor(st, t.url);
+      if (r.connecting || r.reconnectTimer || r.wsReady || r.authBlocked || r.collided)
+        continue;
+      queueConnect(st, r);
+    }
+    for (const r of st.remotes.values()) {
+      if (st.optOuts.has(r.url))
+        continue;
+      if (r.connecting || r.reconnectTimer || r.wsReady || r.authBlocked || r.collided)
+        continue;
+      queueConnect(st, r);
+    }
+  };
+  const handleFrame = async (st, r, frame) => {
+    if (frame.op === "init") {
+      if (!frame.ok) {
+        const err = String(frame.error ?? "");
+        if (/frozen/i.test(err)) {
+          r.authBlocked = true;
+          logError(`${r.url}: share frozen by the hoster (owner frozen) - edits refused; contact the server admin`);
+          try {
+            r.ws?.close(4000, "frozen");
+          } catch {}
+          return;
+        }
+        if (/forbidden|bad secret/i.test(err) && r.initWasAttach && r.secret) {
+          r.collided = err;
+          r.connecting = false;
+          logError(`${r.url}: attach refused (${err}) - credential collision on share ${r.shareId}; not auto-recreating`);
+          try {
+            r.ws?.close(4000, "collision");
+          } catch {}
+          st.wroteBinding = false;
+          chain = chain.then(() => writeBinding(st)).catch(() => {});
+          if (mode === "all")
+            resolveCollision(st, r);
+          return;
+        }
+        if (/token|credential/i.test(err) && !r.initWasAttach) {
+          const cred = credOf(r.url);
+          if (cred.credential) {
+            cred.credential = "";
+            logError(`${r.url}: server rejected our token - re-enrolling`);
+          }
+          try {
+            r.ws?.close(4000, "auth");
+          } catch {}
+          r.connecting = false;
+          if (!st.closed)
+            queueConnect(st, r);
+          return;
+        }
+        logError(`${r.url}: init refused:`, frame.error, "- creating fresh share");
+        deleteAbandoned(r);
+        r.shareId = null;
+        r.secret = null;
+        r.ackedRev = 0;
+        wsSend(r, { op: "init", create: { sessionID: st.sid, ttlDays: ttlFor(st), ...authFrame(st) } });
+        return;
+      }
+      if (r.initWasAttach && typeof frame.rev === "number" && frame.rev < r.ackedRev) {
+        logError(`${r.url}: mismatch: worker rev ${frame.rev} < acked ${r.ackedRev} - recreating`);
+        deleteAbandoned(r);
+        r.shareId = null;
+        r.secret = null;
+        r.ackedRev = 0;
+        wsSend(r, { op: "init", create: { sessionID: st.sid, ttlDays: ttlFor(st), ...authFrame(st) } });
+        return;
+      }
+      const wasFanoutCreate = !r.initWasAttach && st.everConnected;
+      const shareChanged = !!frame.id && frame.id !== r.shareId;
+      if (shareChanged)
+        r.announced = false;
+      r.shareId = frame.id ?? r.shareId;
+      r.secret = frame.secret ?? r.secret;
+      r.ackedRev = frame.rev ?? 0;
+      r.wsReady = true;
+      r.connecting = false;
+      r.initWasAttach = false;
+      r.collided = null;
+      if (r.initTimer) {
+        clearTimeout(r.initTimer);
+        r.initTimer = null;
+      }
+      r.backoff = 1000;
+      st.everConnected = true;
+      if (frame.policy)
+        applyPolicy(frame.policy, r.url);
+      r.intentionalClose = false;
+      touch(st);
+      announceUrl(st, r);
+      if (!st.wroteBinding) {
+        chain = chain.then(() => writeBinding(st)).catch(() => {});
+      } else {
+        scheduleBindingWrite(st);
+      }
+      spoolSave(st, r);
+      if (r.pending.length) {
+        for (const f of r.pending)
+          sendSync(r, f);
+      } else if (st.queue.size) {
+        flush(st);
+      }
+      if (wasFanoutCreate) {
+        chain = chain.then(() => backfill(st)).catch((e) => logError("fan-out backfill error", e?.message || e));
+      }
+      return;
+    }
+    if (frame.op === "ack") {
+      r.ackedRev = frame.rev ?? r.ackedRev;
+      r.pending = [];
+      spoolSave(st, r);
+      scheduleBindingWrite(st);
+      return;
+    }
+    if (frame.op === "nack" || frame.op === "error") {
+      logError(`${r.url}: worker refused frame:`, JSON.stringify(frame).slice(0, 200));
+      if (frame.op === "error" && r.wsReady && !st.closed) {
+        r.wsReady = false;
+        try {
+          r.ws?.close();
+        } catch {}
+        scheduleReconnect(st, r);
+      }
+    }
+  };
+  const resolveCollision = (st, r) => {
+    logError(`collision debug: server=${r.url} share=${r.shareId} rev=${r.ackedRev} sid=${st.sid}`);
+    deleteAbandoned(r);
+    r.collided = null;
+    r.shareId = null;
+    r.secret = null;
+    r.ackedRev = 0;
+    r.pending = [];
+    r.announced = false;
+    queueConnect(st, r);
+  };
+  const frameFrom = (st) => {
+    const items = Array.from(st.queue.values());
+    st.queue.clear();
+    const statusChanged = st.status !== st.lastSentStatus;
+    if (!items.length && !statusChanged) {
+      if (debugEvents)
+        log(`flush skip (no items, status ${st.status}==${st.lastSentStatus})`);
+      return null;
+    }
+    st.lastSentStatus = st.status;
+    if (debugEvents)
+      log(`frame: ${items.length} items, status ${st.status}`);
+    return { items, status: st.status };
+  };
+  const flush = (st) => {
+    if (st.closed)
+      return;
+    const f = frameFrom(st);
+    if (!f)
+      return;
+    let httpWork;
+    for (const r of st.remotes.values()) {
+      r.pending.push(f);
+      spoolSave(st, r);
+      if (r.ws && !r.wsReady)
+        continue;
+      if (r.wsReady) {
+        sendSync(r, f);
+        continue;
+      }
+      const viaHttp = flushViaHttp(st, r);
+      if (viaHttp)
+        httpWork = (httpWork ?? Promise.resolve()).then(() => viaHttp);
+    }
+    if (st.remotes.size)
+      st.lastFlushAt = Date.now();
+    return httpWork;
+  };
+  const flushViaHttp = async (st, r) => {
+    if (!r.shareId || !r.pending.length)
+      return;
+    const items = [];
+    let status;
+    for (const f of r.pending) {
+      for (const it of f.items)
+        items.push(it);
+      if (f.status)
+        status = f.status;
+    }
+    const cred = credOf(r.url);
+    const res = await fetch(`${r.url}/api/share/${r.shareId}/sync`, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...cred.credential ? { authorization: `Bearer ${cred.credential}` } : {} },
+      body: JSON.stringify({ secret: r.secret ?? "", data: items, status }),
+      signal: AbortSignal.timeout(15000)
+    }).catch(() => null);
+    if (res && res.ok) {
+      const body = await res.json().catch(() => ({}));
+      r.ackedRev = body.rev ?? r.ackedRev;
+      r.pending = [];
+      spoolSave(st, r);
+    }
+  };
+  const scheduleFlush = (st) => {
+    if (st.timer)
+      return;
+    const elapsed = Date.now() - st.lastFlushAt;
+    const wait = Math.max(0, cfg.debounceMs - elapsed);
+    st.timer = setTimeout(() => {
+      st.timer = null;
+      if (debugEvents)
+        log(`flush timer fired sid=${st.sid.slice(0, 18)} queue=${st.queue.size} remotes=${st.remotes.size}`);
+      chain = chain.then(() => flush(st)).catch((e) => logError("flush error", e?.message || e));
+    }, wait);
+  };
+  const enqueue = (st, entry) => {
+    if (!st || !entry)
+      return;
+    st.queue.set(entry.key, entry.item);
+    if (debugEvents)
+      log(`enqueue sid=${st.sid.slice(0, 18)} ${entry.item.type} queue=${st.queue.size}`);
+    touch(st);
+    ensureConnected(st);
+    scheduleFlush(st);
+  };
+  const remove = (st) => {
+    st.closed = true;
+    st.activated = false;
+    if (st.timer)
+      clearTimeout(st.timer);
+    if (st.metaTimer)
+      clearTimeout(st.metaTimer);
+    if (st.completedTimer) {
+      clearTimeout(st.completedTimer);
+      st.completedTimer = null;
+    }
+    for (const r of st.remotes.values()) {
+      r.connecting = false;
+      r.connectQueued = false;
+      if (r.initTimer) {
+        clearTimeout(r.initTimer);
+        r.initTimer = null;
+      }
+      if (r.reconnectTimer) {
+        clearTimeout(r.reconnectTimer);
+        r.reconnectTimer = null;
+      }
+      cancelSettleDrop(r);
+      if (r.idleDropTimer) {
+        clearTimeout(r.idleDropTimer);
+        r.idleDropTimer = null;
+      }
+      if (r.wsReady)
+        wsSend(r, { op: "delete" });
+      else if (r.shareId && r.secret) {
+        fetch(`${r.url}/api/share/${r.shareId}`, {
+          method: "DELETE",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ secret: r.secret }),
+          signal: AbortSignal.timeout(8000)
+        }).catch(() => {});
+      }
+    }
+    setTimeout(() => {
+      for (const r of st.remotes.values()) {
+        try {
+          r.ws?.close();
+        } catch {}
+      }
+    }, 1000);
+    for (const r of st.remotes.values())
+      spoolClear(st, r);
+    sessions.delete(st.sid);
+    try {
+      chain = chain.then(async () => {
+        if (!st.client)
+          return;
+        const res = await st.client.session.get({
+          path: { id: st.sid },
+          ...deps.directory ? { query: { directory: deps.directory } } : {}
+        }).catch(() => null);
+        const info = res?.data ?? res;
+        if (info?.metadata?.[METADATA_KEY]) {
+          const metadata = { ...info.metadata };
+          delete metadata[METADATA_KEY];
+          await st.client.session.update({
+            path: { id: st.sid },
+            body: { metadata },
+            ...deps.directory ? { query: { directory: deps.directory } } : {}
+          }).catch(() => {});
+        }
+      });
+    } catch {}
+  };
+  const PAGE_SIZE = 100;
+  const MAX_PAGES = 50;
+  const query = () => deps.directory ? { directory: deps.directory } : {};
+  async function fetchMessages(client, sid) {
+    if (typeof client.session.messages !== "function")
+      return [];
+    const out = [];
+    let before;
+    for (let page = 0;page < MAX_PAGES; page++) {
+      const q = { ...query(), limit: PAGE_SIZE };
+      if (before !== undefined)
+        q.before = before;
+      const result = unwrap(await client.session.messages({
+        path: { id: sid },
+        query: q
+      }));
+      if (!Array.isArray(result) || result.length === 0)
+        break;
+      out.push(...result);
+      if (result.length < PAGE_SIZE)
+        break;
+      const last = result[result.length - 1];
+      const nextBefore = typeof last?.info?.id === "string" ? last.info.id : typeof last?.id === "string" ? last.id : undefined;
+      if (!nextBefore || nextBefore === before)
+        break;
+      before = nextBefore;
+    }
+    return out;
+  }
+  const backfillSession = async (st, client, sid, info) => {
+    const sessionInfoValue = info ?? await sessionInfo(client, sid);
+    if (sessionInfoValue)
+      enqueue(st, itemFor("session", redact(sessionInfoValue), sid));
+    const messages = await fetchMessages(client, sid);
+    let modelSeen = false;
+    for (const message of messages) {
+      const m = message.info ?? message;
+      if (!m || typeof m.id !== "string")
+        continue;
+      enqueue(st, itemFor("message", m, sid));
+      if (m.role === "user" && m.model) {
+        modelSeen = true;
+        const label = formatLabel(st.opts?.modelLabel ?? cfg.modelLabel, m.model);
+        enqueue(st, itemFor("model", [{ id: m.model.modelID, providerID: m.model.providerID, name: label }], sid));
+      }
+      for (const part of message.parts ?? []) {
+        const p = part;
+        if (!p || typeof p.id !== "string" || typeof p.messageID !== "string")
+          continue;
+        if (p.state?.status === "error")
+          st.badSignal = true;
+        enqueue(st, itemFor("part", p, sid));
+      }
+    }
+    if (!modelSeen && sessionInfoValue?.model) {
+      const label = formatLabel(st.opts?.modelLabel ?? cfg.modelLabel, sessionInfoValue.model);
+      enqueue(st, itemFor("model", [{ id: sessionInfoValue.model.modelID, providerID: sessionInfoValue.model.providerID, name: label }], sid));
+    }
+    return messages;
+  };
+  const backfill = async (st, info) => {
+    const client = st.client;
+    if (!client)
+      return;
+    const messages = await backfillSession(st, client, st.sid, info);
+    if (messages.length === 0 && !info) {
+      const fetched = await sessionInfo(client, st.sid);
+      if (fetched)
+        enqueue(st, itemFor("session", redact(fetched), st.sid));
+    }
+    if (typeof client.session.list === "function") {
+      try {
+        const result = unwrap(await client.session.list({ query: query() }));
+        if (Array.isArray(result)) {
+          for (const raw of result) {
+            if (!raw || typeof raw.id !== "string")
+              continue;
+            if (raw.parentID !== st.sid)
+              continue;
+            childToParent.set(raw.id, st.sid);
+            await backfillSession(st, client, raw.id, raw);
+          }
+        }
+      } catch (e) {
+        log("backfill child list failed:", e?.message || e);
+      }
+    }
+    if (typeof client.session.diff === "function") {
+      try {
+        const diff = unwrap(await client.session.diff({
+          path: { id: st.sid },
+          query: query()
+        }));
+        if (diff !== undefined)
+          enqueue(st, itemFor("session_diff", diff, st.sid));
+      } catch {}
+    }
+    if (st.status === "completed" && st.badSignal)
+      st.status = "error";
+  };
+  const debugEvents = !!process.env.OPENSHARE_DEBUG_EVENTS;
+  const trackChild = (sid, info) => {
+    if (info?.parentID) {
+      const parent = childToParent.get(sid) ?? info.parentID;
+      childToParent.set(sid, parent);
+      return parent;
+    }
+    return null;
+  };
+  const adoptStrayChild = (childSid, parentSid) => {
+    const stray = sessions.get(childSid);
+    const parent = sessions.get(parentSid);
+    if (!stray || stray.closed)
+      return;
+    if (parent && parent !== stray) {
+      for (const [key, item] of stray.queue)
+        parent.queue.set(key, item);
+      stray.queue.clear();
+      for (const [url, sr] of stray.remotes) {
+        const pr = remoteFor(parent, url);
+        if (!pr.shareId && sr.shareId) {
+          pr.shareId = sr.shareId;
+          pr.secret = sr.secret;
+          pr.ackedRev = sr.ackedRev;
+        }
+        for (const frame of sr.pending)
+          pr.pending.push(frame);
+        sr.pending = [];
+        sr.shareId = null;
+        sr.secret = null;
+      }
+      scheduleFlush(parent);
+    }
+    for (const sr of stray.remotes.values()) {
+      if (sr.shareId)
+        log(`stray child share ${sr.shareId} (${sr.url}) -> merging into ${parentSid}`);
+    }
+    remove(stray);
+  };
+  const handleSessionEvent = (t, sid, info) => {
+    const parent = trackChild(sid, info);
+    if (mode === "manual") {
+      if (parent) {
+        const st3 = sessions.get(parent);
+        if (st3?.activated && !st3.closed) {
+          if (!st3.prefsSent) {
+            st3.prefsSent = true;
+            enqueue(st3, itemFor("prefs", { openTasksInNewTab: cfg.openTasksInNewTab !== false }, sid));
+          }
+          if (info)
+            enqueue(st3, itemFor("session", redact(info), sid));
+        }
+        return;
+      }
+      const flag = shareFlag(info);
+      const st2 = sessions.get(sid);
+      if (flag.enabled) {
+        if (st2?.activated && !st2.closed) {
+          if (flag.opts)
+            st2.opts = flag.opts;
+          if (!st2.prefsSent) {
+            st2.prefsSent = true;
+            enqueue(st2, itemFor("prefs", { openTasksInNewTab: cfg.openTasksInNewTab !== false }, sid));
+          }
+          if (info)
+            enqueue(st2, itemFor("session", redact(info), sid));
+          if (t === "session.updated")
+            chain = chain.then(() => refreshOptOuts(st2)).catch(() => {});
+          return;
+        }
+        activate(sid, flag.opts, info);
+        const fresh = sessions.get(sid);
+        if (fresh && !fresh.prefsSent) {
+          fresh.prefsSent = true;
+          enqueue(fresh, itemFor("prefs", { openTasksInNewTab: cfg.openTasksInNewTab !== false }, sid));
+        }
+        return;
+      }
+      if (st2?.activated && !st2.closed && t === "session.updated") {
+        log(`share disabled for ${sid} - removing`);
+        chain = chain.then(() => remove(st2)).catch((e) => logError("remove error", e?.message || e));
+        return;
+      }
+      return;
+    }
+    const main = parent ?? sid;
+    if (parent && parent !== sid && sessions.has(sid)) {
+      if (!sessions.has(main)) {
+        const created = newSt(main);
+        created.activated = true;
+        sessions.set(main, created);
+        queueConnectAll(created);
+      }
+      adoptStrayChild(sid, main);
+    }
+    let st = sessions.get(main);
+    if (!st && !parent) {
+      const flag = shareFlag(info);
+      const hasBinding = !!info?.metadata?.[METADATA_KEY];
+      const createdMs = info?.time?.created;
+      const isPreExisting = typeof createdMs === "number" && createdMs < bootTime;
+      if (isPreExisting && !flag.enabled && !hasBinding) {
+        if (!preExistingRetired.has(main)) {
+          preExistingRetired.add(main);
+          log(`session ${main} predates plugin start - not shared (set the share flag to share it)`);
+        }
+        return;
+      }
+      if (flag.enabled) {
+        activate(main, flag.opts, info, { gated: true });
+        st = sessions.get(main);
+      } else {
+        const created = newSt(main);
+        created.activated = true;
+        sessions.set(main, created);
+        st = created;
+        queueConnectAll(created);
+      }
+    }
+    if (!st)
+      return;
+    if (!st.prefsSent) {
+      st.prefsSent = true;
+      enqueue(st, itemFor("prefs", { openTasksInNewTab: cfg.openTasksInNewTab !== false }, sid));
+    }
+    if (info)
+      enqueue(st, itemFor("session", redact(info), sid));
+    if (t === "session.updated" && st.activated && !st.closed) {
+      chain = chain.then(() => refreshOptOuts(st)).catch(() => {});
+    }
+  };
+  return {
+    mode,
+    config: () => cfg,
+    hooks: {
+      event: async ({ event }) => {
+        const t = event?.type;
+        const p = event?.properties || {};
+        const sid = p.sessionID;
+        if (!sid)
+          return;
+        if (debugEvents) {
+          const par = p.info?.parentID;
+          log(`event: ${t} ${sid}${par ? ` (child of ${par})` : ""}`);
+        }
+        if (t === "session.created" || t === "session.updated") {
+          handleSessionEvent(t, sid, p.info);
+        } else if (t === "session.status") {
+          const st = stFor(sid);
+          if (!st)
+            return;
+          const type = p.status?.type;
+          touch(st);
+          if (type === "busy") {
+            st.statusEpoch++;
+            if (st.completedTimer) {
+              clearTimeout(st.completedTimer);
+              st.completedTimer = null;
+            }
+            st.badSignal = false;
+            st.status = "live";
+            ensureConnected(st);
+            scheduleFlush(st);
+          } else if (type === "idle") {
+            if (st.timer)
+              clearTimeout(st.timer);
+            st.timer = null;
+            chain = chain.then(() => flush(st)).catch((e) => logError("idle flush error", e?.message || e));
+            const epoch = st.statusEpoch;
+            const settle = () => {
+              st.status = st.badSignal ? "error" : "completed";
+              st.badSignal = false;
+              if (st.timer)
+                clearTimeout(st.timer);
+              st.timer = null;
+              chain = chain.then(() => flush(st)).then(() => {
+                armSettleDrop(st);
+              }).catch((e) => logError("settle flush error", e?.message || e));
+            };
+            if (cfg.completedDelayMs <= 0) {
+              settle();
+            } else if (!st.completedTimer && !st.closed) {
+              st.completedTimer = setTimeout(() => {
+                st.completedTimer = null;
+                if (st.closed || st.statusEpoch !== epoch)
+                  return;
+                settle();
+              }, cfg.completedDelayMs);
+            }
+          } else if (type === "retry") {
+            st.badSignal = true;
+          }
+        } else if (t === "session.error") {
+          const st = stFor(sid);
+          if (st) {
+            st.badSignal = true;
+            touch(st);
+          }
+        } else if (t === "message.removed" || t === "message.part.removed") {
+          const st = stFor(sid);
+          if (!st || !st.activated || st.closed)
+            return;
+          const messageID = p.messageID;
+          if (!messageID)
+            return;
+          if (t === "message.removed") {
+            enqueue(st, { key: `message/${messageID}`, item: { type: "message", del: true, data: { id: messageID } } });
+          } else {
+            const partID = p.partID;
+            if (!partID)
+              return;
+            enqueue(st, { key: `part/${messageID}/${partID}`, item: { type: "part", del: true, data: { id: partID, messageID } } });
+          }
+        } else if (t === "message.updated") {
+          const main = childToParent.get(sid) ?? sid;
+          let st = sessions.get(main);
+          if (!st && mode === "all" && !preExistingRetired.has(main)) {
+            const created = newSt(main);
+            created.activated = true;
+            sessions.set(main, created);
+            st = created;
+            if (!verifying.has(main)) {
+              verifying.add(main);
+              chain = chain.then(async () => {
+                if (created.closed)
+                  return;
+                const info2 = await sessionInfo(created.client, main);
+                verifying.delete(main);
+                if (created.closed)
+                  return;
+                const flag = shareFlag(info2);
+                const hasBinding = !!info2?.metadata?.[METADATA_KEY];
+                const createdMs = info2?.time?.created;
+                const isPreExisting = typeof createdMs === "number" && createdMs < bootTime;
+                if (debugEvents) {
+                  log(`verify ${main}: created=${createdMs} boot=${bootTime} pre=${isPreExisting} flag=${flag.enabled} binding=${hasBinding} infoMissing=${!info2}`);
+                }
+                if (isPreExisting && !flag.enabled && !hasBinding) {
+                  preExistingRetired.add(main);
+                  log(`session ${main} predates plugin start - not shared (set the share flag to share it)`);
+                  remove(created);
+                  return;
+                }
+                queueConnectAll(created);
+              }).catch((e) => {
+                verifying.delete(main);
+                logError("verify error", e?.message || e);
+              });
+            }
+          }
+          if (!st || !st.activated || st.closed)
+            return;
+          enqueue(st, itemFor("message", p.info, sid));
+          const info = p.info;
+          if (info?.role === "user" && info?.model) {
+            const label = formatLabel(st.opts?.modelLabel ?? cfg.modelLabel, info.model);
+            enqueue(st, itemFor("model", [{ id: info.model.modelID, providerID: info.model.providerID, name: label }], sid));
+          }
+          if (info?.role === "assistant" && info.finish === "error") {
+            st.badSignal = true;
+          }
+        } else if (t === "message.part.updated") {
+          const st = stFor(sid);
+          if (!st || !st.activated || st.closed)
+            return;
+          const part = p.part;
+          if (part?.state?.status === "error")
+            st.badSignal = true;
+          enqueue(st, itemFor("part", part, sid));
+        } else if (t === "session.diff") {
+          const st = stFor(sid);
+          if (!st || !st.activated || st.closed)
+            return;
+          enqueue(st, itemFor("session_diff", p.diff, sid));
+        } else if (t === "session.deleted") {
+          const isChild = childToParent.has(sid);
+          if (isChild) {
+            if (debugEvents)
+              log("event: child session.deleted (ignored)", sid);
+            return;
+          }
+          const st = sessions.get(sid);
+          if (!st)
+            return;
+          chain = chain.then(() => remove(st)).catch((e) => logError("remove error", e?.message || e));
+        }
+      },
+      dispose: async () => {
+        for (const st of sessions.values()) {
+          if (st.completedTimer) {
+            clearTimeout(st.completedTimer);
+            st.completedTimer = null;
+            st.status = st.badSignal ? "error" : "completed";
+            st.badSignal = false;
+          }
+          if (st.timer)
+            clearTimeout(st.timer);
+          st.timer = null;
+          for (const r of st.remotes.values()) {
+            if (r.initTimer) {
+              clearTimeout(r.initTimer);
+              r.initTimer = null;
+            }
+            cancelSettleDrop(r);
+            if (r.idleDropTimer) {
+              clearTimeout(r.idleDropTimer);
+              r.idleDropTimer = null;
+            }
+          }
+          const flushed = flush(st);
+          if (flushed && typeof flushed.then === "function")
+            await flushed.catch(() => {});
+          for (const r of st.remotes.values()) {
+            if (!r.wsReady && r.shareId && r.pending.length) {
+              await flushViaHttp(st, r).catch(() => {});
+            }
+          }
+          if (st.metaTimer)
+            clearTimeout(st.metaTimer);
+          st.metaTimer = null;
+          await writeBinding(st).catch(() => {});
+        }
+        for (const st of sessions.values()) {
+          for (const r of st.remotes.values()) {
+            try {
+              r.ws?.close();
+            } catch {}
+          }
+        }
+      }
+    }
+  };
+}
+
+// src/v2-server.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { join as join3 } from "node:path";
+function toolContentText(content) {
+  if (typeof content === "string")
+    return content;
+  if (Array.isArray(content)) {
+    return content.map((item) => {
+      if (typeof item === "string")
+        return item;
+      if (item && typeof item === "object") {
+        const record = item;
+        if (typeof record.text === "string")
+          return record.text;
+      }
+      return "";
+    }).join("");
+  }
+  return "";
+}
+function convertToolState(state) {
+  if (!state || typeof state !== "object")
+    return { status: "pending" };
+  const record = state;
+  const status = String(record.status ?? "pending");
+  const mapped = {};
+  if (status === "streaming" || status === "running")
+    mapped.status = "running";
+  else if (status === "completed")
+    mapped.status = "completed";
+  else if (status === "failed" || status === "error")
+    mapped.status = "error";
+  else
+    mapped.status = "pending";
+  if (record.input !== undefined)
+    mapped.input = record.input;
+  if (record.output !== undefined)
+    mapped.output = toolContentText(record.output);
+  if (record.error !== undefined)
+    mapped.error = record.error;
+  if (record.time !== undefined)
+    mapped.time = record.time;
+  return mapped;
+}
+function convertV2Message(message, sessionID) {
+  if (!message || typeof message.id !== "string")
+    return;
+  const base = {
+    id: message.id,
+    sessionID
+  };
+  if (message.type === "user") {
+    return {
+      info: {
+        ...base,
+        role: "user",
+        time: { created: message.time?.created ?? 0 },
+        text: message.text ?? ""
+      },
+      parts: []
+    };
+  }
+  if (message.type === "assistant") {
+    const parts = [];
+    const content = Array.isArray(message.content) ? message.content : [];
+    content.forEach((block, index) => {
+      const record = block;
+      const kind = String(record.type ?? "");
+      if (kind === "text") {
+        parts.push({
+          id: `${message.id}_t${index}`,
+          messageID: message.id,
+          sessionID,
+          type: "text",
+          text: String(record.text ?? ""),
+          synthetic: false,
+          time: { start: message.time?.created ?? 0, end: message.time?.completed ?? 0 }
+        });
+      } else if (kind === "reasoning") {
+        parts.push({
+          id: `${message.id}_r${index}`,
+          messageID: message.id,
+          sessionID,
+          type: "reasoning",
+          text: String(record.text ?? ""),
+          synthetic: false,
+          time: { start: message.time?.created ?? 0, end: message.time?.completed ?? 0 }
+        });
+      } else if (kind === "tool") {
+        parts.push({
+          id: String(record.id ?? `${message.id}_tool${index}`),
+          messageID: message.id,
+          sessionID,
+          type: "tool",
+          tool: String(record.name ?? "unknown"),
+          state: convertToolState(record.state),
+          synthetic: false
+        });
+      }
+    });
+    return {
+      info: {
+        ...base,
+        role: "assistant",
+        agent: message.agent,
+        model: message.model ? { providerID: message.model.providerID, modelID: message.model.modelID ?? message.model.id } : undefined,
+        time: { created: message.time?.created ?? 0, completed: message.time?.completed ?? 0 }
+      },
+      parts
+    };
+  }
+  return;
+}
+function adaptSessionClient(session, message, directory) {
+  if (!session)
+    return;
+  const loc = () => directory ? { directory } : undefined;
+  const listAll = async () => {
+    const out = [];
+    let cursor;
+    for (let page = 0;page < 50; page++) {
+      const res = await session.list({ ...loc(), cursor, limit: 100 });
+      const data = res?.data;
+      if (Array.isArray(data))
+        out.push(...data);
+      const next = res?.cursor?.next ?? undefined;
+      if (!next || !Array.isArray(data) || data.length === 0)
+        break;
+      cursor = next;
+    }
+    return out;
+  };
+  const listMessages = async (sessionID) => {
+    if (!message)
+      return [];
+    const out = [];
+    let cursor;
+    for (let page = 0;page < 50; page++) {
+      const res = await message.list({ sessionID, limit: 100, cursor });
+      const data = res?.data;
+      if (!Array.isArray(data))
+        break;
+      for (const raw of data) {
+        const converted = convertV2Message(raw, sessionID);
+        if (converted)
+          out.push(converted);
+      }
+      const next = res?.cursor?.next ?? undefined;
+      if (!next || data.length === 0)
+        break;
+      cursor = next;
+    }
+    return out;
+  };
+  return {
+    session: {
+      async get(input) {
+        const res = await session.get({ sessionID: input.path.id });
+        return { data: res };
+      },
+      async update(input) {
+        const body = input.body;
+        const res = await session.update({ sessionID: input.path.id, title: body.title, metadata: body.metadata });
+        return { data: res };
+      },
+      async list() {
+        return { data: await listAll() };
+      },
+      async messages(input) {
+        return { data: await listMessages(input.path.id) };
+      },
+      async diff(input) {
+        const res = await session.diff({ sessionID: input.path.id });
+        return { data: res };
+      }
+    }
+  };
+}
+var SESSION_ITEM_EVENTS = new Set([
+  "session.created",
+  "session.renamed",
+  "session.metadata.updated",
+  "session.agent.selected",
+  "session.model.selected",
+  "session.moved",
+  "session.permissions",
+  "session.compaction.started",
+  "session.compaction.ended"
+]);
+var CONTENT_EVENTS_PREFIXES = [
+  "session.text.",
+  "session.reasoning.",
+  "session.tool.",
+  "session.message.",
+  "session.step.streamed"
+];
+var BUSY_EVENTS = new Set(["session.step.started", "session.execution.started"]);
+var IDLE_EVENTS = new Set(["session.step.ended", "session.execution.succeeded", "session.execution.interrupted"]);
+var ERROR_EVENTS = new Set(["session.step.failed", "session.tool.failed", "session.retry.scheduled"]);
+function eventSessionID(event) {
+  const data = event.data;
+  if (data && typeof data === "object" && typeof data.sessionID === "string") {
+    return data.sessionID;
+  }
+  return;
+}
+function resolveV2ShareMode(options) {
+  const explicit = options?.["shareMode"] ?? process.env.OPENSHARE_SHARE_MODE;
+  if (explicit === "all" || explicit === "manual")
+    return explicit;
+  try {
+    const root = packageRoot(moduleDir());
+    const pkgPath = join3(root, "package.json");
+    if (existsSync3(pkgPath)) {
+      const pkg = JSON.parse(readFileSync3(pkgPath, "utf8"));
+      const declared = pkg["oc-plugin"];
+      if (Array.isArray(declared) && declared.includes("tui"))
+        return "manual";
+    }
+  } catch {}
+  return;
+}
+function createV2ServerSetup() {
+  return async (context) => {
+    if (!context?.event?.subscribe || !context.client?.session) {
+      if (process.env.OPENSHARE_DEBUG_FILE) {
+        try {
+          console.error(`[${METADATA_KEY}] v2 setup not applicable on this host — sharing handled by the server entry`);
+        } catch {}
+      }
+      return () => {};
+    }
+    const directory = context.directory;
+    const client = adaptSessionClient(context.client.session, context.client.message, directory);
+    const modeOverride = resolveV2ShareMode(context.options);
+    const engine = createEngine({
+      client,
+      pluginDir: moduleDir(),
+      directory,
+      options: modeOverride ? { ...context.options, shareMode: modeOverride } : context.options
+    });
+    if (!engine.hooks.event) {
+      return () => {};
+    }
+    const pendingRefresh = new Map;
+    const refresh = (sessionID) => {
+      let timer = pendingRefresh.get(sessionID);
+      if (timer)
+        clearTimeout(timer);
+      timer = setTimeout(() => {
+        pendingRefresh.delete(sessionID);
+        (async () => {
+          try {
+            const info = await client.session.get({ path: { id: sessionID } });
+            await engine.hooks.event({
+              event: { type: "session.updated", properties: { sessionID, info: info.data ?? info } }
+            });
+            const messages = await client.session.messages?.({ path: { id: sessionID } });
+            const list = messages?.data ?? [];
+            for (const message of list) {
+              await engine.hooks.event({
+                event: { type: "message.updated", properties: { sessionID, info: message.info } }
+              });
+              for (const part of message.parts ?? []) {
+                await engine.hooks.event({
+                  event: { type: "message.part.updated", properties: { sessionID, part } }
+                });
+              }
+            }
+          } catch {}
+        })();
+      }, 400);
+      pendingRefresh.set(sessionID, timer);
+    };
+    const unsubscribe = (() => {
+      let stopped = false;
+      const run = async () => {
+        try {
+          const stream = context.event.subscribe({ signal: context.signal });
+          for await (const event of stream) {
+            if (stopped)
+              break;
+            if (!event || typeof event.type !== "string")
+              continue;
+            const sid = eventSessionID(event);
+            if (!sid)
+              continue;
+            const type = event.type;
+            if (type === "session.deleted") {
+              await engine.hooks.event({ event: { type, properties: { sessionID: sid } } });
+              continue;
+            }
+            if (type === "message.removed" || type === "message.part.removed") {
+              const data = event.data ?? {};
+              await engine.hooks.event({
+                event: { type, properties: { sessionID: sid, messageID: data.messageID, partID: data.partID } }
+              });
+              continue;
+            }
+            if (SESSION_ITEM_EVENTS.has(type)) {
+              refresh(sid);
+              continue;
+            }
+            if (BUSY_EVENTS.has(type)) {
+              await engine.hooks.event({ event: { type: "session.status", properties: { sessionID: sid, status: { type: "busy" } } } });
+              refresh(sid);
+              continue;
+            }
+            if (IDLE_EVENTS.has(type)) {
+              await engine.hooks.event({ event: { type: "session.status", properties: { sessionID: sid, status: { type: "idle" } } } });
+              refresh(sid);
+              continue;
+            }
+            if (type === "session.error" || type === "session.execution.failed") {
+              await engine.hooks.event({ event: { type: "session.error", properties: { sessionID: sid } } });
+              continue;
+            }
+            if (ERROR_EVENTS.has(type)) {
+              await engine.hooks.event({ event: { type: "session.status", properties: { sessionID: sid, status: { type: "retry" } } } });
+              continue;
+            }
+            if (CONTENT_EVENTS_PREFIXES.some((prefix) => type.startsWith(prefix))) {
+              refresh(sid);
+              continue;
+            }
+          }
+        } catch {}
+      };
+      run();
+      return () => {
+        stopped = true;
+      };
+    })();
+    return () => {
+      unsubscribe();
+      for (const timer of pendingRefresh.values())
+        clearTimeout(timer);
+      pendingRefresh.clear();
+      engine.hooks.dispose();
+    };
+  };
+}
+
+// src/server.ts
+var PLUGIN_ID = "openshare";
+var OpenSharePlugin = async (input, options) => {
+  const deps = {
+    client: input?.client,
+    directory: typeof input?.directory === "string" ? input.directory : undefined,
+    worktree: typeof input?.worktree === "string" ? input.worktree : undefined,
+    pluginDir: moduleDir(),
+    options
+  };
+  const engine = createEngine(deps);
+  return engine.hooks;
+};
+var server = OpenSharePlugin;
+var server_default = {
+  id: PLUGIN_ID,
+  server,
+  setup: createV2ServerSetup()
+};
+export {
+  server_default as default,
+  PLUGIN_ID,
+  OpenSharePlugin
+};