@mirrowel/opencode-openshare 0.0.0-stage → 0.1.0

package/dist/commands.d.ts

@@ -0,0 +1,7 @@
+import type { ShareHostApi, ShareHostLayerCommand } from "./tui-host.js";
+export declare const PALETTE_CATEGORY = "OpenShare";
+export declare function buildShareCommand(host: ShareHostApi, sessionID: () => string | undefined): ShareHostLayerCommand;
+export declare function buildSettingsCommand(host: ShareHostApi, sessionID: () => string | undefined): ShareHostLayerCommand;
+/** Registers the /share toggle + /openshare settings on one keymap layer.
+ * Returns the unregister function. */
+export declare function registerCommands(host: ShareHostApi, sessionID: () => string | undefined): () => void;

package/dist/commands.js

@@ -0,0 +1,440 @@
+// OpenShare command registration. ONE user-facing /share command shadows
+// the deprecated built-in (opncd.ai) by registering the same command name
+// on a plugin keymap layer; running it on a shared session opens the
+// share manager (copy link / stop sharing) instead — you can't share
+// twice, so /share is a toggle. /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).
+import { CONSENT_KV_KEY, clearGoneBindingEntries, confirmShare, currentConfig, isConfigured, hostOf, patchSessionBinding, readBindings, resolveRoot, runShareFlow, runUnshareFlow, serverEntries, verifyShare, workerDeleteShare, } from "./share-flow.js";
+import { onboardingDialog, settingsDialog } from "./settings.js";
+import { dbgLog } from "./sidebar.js";
+export const PALETTE_CATEGORY = "OpenShare";
+function finish(host, result) {
+    // terminal point of a flow: the dialog chain is over — clear the host
+    // stack explicitly (done() no longer clears; replace-without-clear was
+    // the flicker fix, so chain ENDS own the clear)
+    try {
+        host.ui.dialog.clear();
+    }
+    catch { }
+    host.ui.toast({
+        variant: result.ok ? "success" : result.unconfigured ? "warning" : "error",
+        title: "OpenShare",
+        message: result.message,
+        duration: result.ok ? 8000 : 15000,
+    });
+}
+/** The already-shared state: per-server management for the fan-out era.
+ * Single binding keeps the compact classic menu; multiple bindings get a
+ * per-server submenu (copy / stop here / leave as-is) plus all-stop.
+ * Opens with a liveness sweep: bindings whose page died server-side
+ * (purge/TTL/delete) are auto-cleared and surfaced in a gone modal. */
+async function showShareManager(host, sessionID) {
+    const sid = sessionID();
+    if (!sid)
+        return;
+    const root = await resolveRoot(host.client, sid);
+    let all = await readBindings(host.client, root);
+    // collision first: the engine marked a server's credentials as rejected
+    const collided = all.find((b) => b.collided);
+    if (collided)
+        return showCollisionDialog(host, root, collided.server, collided.id, collided.collided ?? "");
+    // liveness sweep: probe every live-bound server (credential-free /data
+    // check). GONE entries are removed from the binding automatically; the
+    // modal says what happened and offers to re-share. Network errors are
+    // "unknown" and never treated as gone.
+    const live = all.filter((b) => b.url && b.enabled !== false && b.id);
+    if (live.length) {
+        const verdicts = await Promise.all(live.map((b) => verifyShare(b.server, b.id)));
+        const gone = live.filter((b, i) => verdicts[i] === "gone");
+        if (gone.length) {
+            await clearGoneBindingEntries(host, root, gone.map((b) => b.server));
+            all = all.filter((b) => !gone.some((g) => g.server === b.server));
+            const list = gone.map((b) => `• ${hostOf(b.url || b.server)} — ${b.url}`).join("\n");
+            const choice = await host.ui.showMenu({
+                title: "Share is gone",
+                hint: "The page was removed, expired, or purged on the server — sharing disabled for it.",
+                options: [
+                    { title: "Share again", value: "again", description: "create a fresh page with the full history", help: `The stale binding was already cleared. Sharing again creates a brand-new page on the ACTIVE server with this session's full history backfilled.\n\nGone:\n${list}` },
+                    { title: "Close", value: "close", description: "leave the session unshared", help: `The stale binding entries were cleared automatically; the session is not shared anymore. Run /share any time to share it fresh.\n\nGone:\n${list}` },
+                ],
+            });
+            if (choice === "again") {
+                finish(host, await runShareFlow(host, sid));
+                return;
+            }
+            if (all.length === 0)
+                return;
+        }
+    }
+    if (all.length === 0)
+        return;
+    const otherServers = serverEntries().filter((s) => !all.some((b) => b.server === s.url));
+    if (all.length === 1 && otherServers.length === 0) {
+        // the classic single-server menu
+        const b = all[0];
+        void host.ui
+            .showMenu({
+            title: "Session is shared",
+            hint: b.url,
+            options: [
+                {
+                    title: "Copy share link",
+                    value: "copy",
+                    description: "copy the share URL to the clipboard",
+                    help: `Copies the share URL to the clipboard (navigator + OSC52 fallback).\n\nURL: ${b.url}\nServer: ${b.server}\nShare id: ${b.id}\n\nAnyone with the link can read the page (plus the login, if read auth is set).`,
+                },
+                {
+                    title: "Stop sharing",
+                    value: "stop",
+                    description: "Delete the share page — the link stops working for everyone",
+                    help: `Deletes the page on ${hostOf(b.url || b.server)} server-side and clears this session's share flag. Viewers with the link see a final "gone" state. This cannot be undone — sharing again creates a NEW page with a new URL.`,
+                },
+                { title: "Cancel", value: "cancel" },
+            ],
+        })
+            .then(async (choice) => {
+            if (choice === "copy") {
+                const ok = await host.clipboard.write(b.url);
+                finish(host, ok ? { ok: true, message: `Share URL copied to clipboard: ${b.url}`, url: b.url } : { ok: false, message: `Could not write the clipboard — link: ${b.url}`, url: b.url });
+                return;
+            }
+            if (choice === "stop") {
+                const how = await host.ui.showMenu({
+                    title: "Stop sharing",
+                    hint: b.url,
+                    options: [
+                        {
+                            title: "Delete the page",
+                            value: "delete",
+                            description: "the link stops working for everyone",
+                            danger: true,
+                            help: `Deletes the page on ${hostOf(b.url || b.server)} and clears this session's share flag. Viewers with the link see a final "gone" state. Sharing again later creates a fresh page with a new URL.`,
+                        },
+                        {
+                            title: "Leave as-is (snapshot)",
+                            value: "leave",
+                            description: "stop updating; the page stays until its TTL",
+                            help: `Stops mirroring WITHOUT deleting anything — viewers keep reading the snapshot until the share's TTL expires. Useful for handing someone a frozen copy while you keep working.`,
+                        },
+                        { title: "Cancel", value: "cancel" },
+                    ],
+                });
+                if (!how || how === "cancel")
+                    return;
+                if (how === "leave") {
+                    await patchSessionBinding(host.client, root, (servers) => {
+                        delete servers[b.server];
+                        servers[b.server] = { optedOut: true };
+                    });
+                    finish(host, { ok: true, message: `${hostOf(b.url || b.server)} left as-is — a snapshot until its TTL.` });
+                    return;
+                }
+                const yes = await host.ui.showConfirm({
+                    title: "Delete the share page",
+                    message: `Delete the page on ${hostOf(b.url || b.server)}?\nThe link stops working for everyone.`,
+                    confirmLabel: "Delete",
+                    danger: true,
+                });
+                if (!yes) {
+                    host.ui.dialog.clear();
+                    return;
+                }
+                finish(host, await runUnshareFlow(host, sessionID()));
+            }
+        });
+        return;
+    }
+    // fan-out menu
+    const options = all.map((b) => ({
+        title: `Copy link — ${hostOf(b.url || b.server)}`,
+        value: `copy:${b.server}`,
+        description: b.url,
+        help: `Copies this server's share URL to the clipboard.\n\nURL: ${b.url}\nServer: ${b.server}\nShare id: ${b.id}\n\nEach server carries an independent page of the same session.`,
+    }));
+    options.push({
+        title: "Manage per server…",
+        value: "manage",
+        description: `${all.length} servers — stop one, leave a snapshot`,
+        help: `Per-server actions: copy the link, stop sharing there (page deleted), or leave it as a read-only snapshot (updates stop, the page lives out its TTL). Other servers are unaffected.\n\nBound servers:\n${all.map((b) => `• ${b.server} — ${b.url}`).join("\n")}`,
+    });
+    if (otherServers.length) {
+        options.push({
+            title: "Share to another server…",
+            value: "more",
+            description: otherServers.map((s) => hostOf(s.url)).join(", "),
+            help: `Adds one of your other configured servers as a destination for THIS session: it becomes the active server and the full history is mirrored there within seconds.\n\nAvailable:\n${otherServers.map((s) => `• ${s.url}`).join("\n")}`,
+        });
+    }
+    options.push({
+        title: "Stop sharing (all)",
+        value: "stop-all",
+        description: "delete every server's page, or leave snapshots",
+        danger: true,
+        help: `Deletes the page on all ${all.length} servers (or leaves them as read-only snapshots — your choice on the next screen) and clears the share flag. Sharing again creates fresh pages.`,
+    });
+    options.push({ title: "Cancel", value: "cancel" });
+    const choice = await host.ui.showMenu({ title: `Session is shared · ${all.length} servers`, options });
+    if (!choice || choice === "cancel")
+        return;
+    if (choice.startsWith("copy:")) {
+        const b = all.find((x) => `copy:${x.server}` === choice);
+        if (b) {
+            const ok = await host.clipboard.write(b.url);
+            finish(host, ok ? { ok: true, message: `Share URL copied: ${b.url}`, url: b.url } : { ok: false, message: `Clipboard failed — ${b.url}`, url: b.url });
+        }
+        return;
+    }
+    if (choice === "stop-all") {
+        const how = await host.ui.showMenu({
+            title: `Stop sharing · ${all.length} servers`,
+            options: [
+                { title: "Delete every page", value: "delete", description: "all links stop working", danger: true, help: `Deletes the page on every bound server (${all.map((b) => hostOf(b.url || b.server)).join(", ")}) and clears the share flag.` },
+                { title: "Leave all as-is (snapshots)", value: "leave", description: "stop updating; pages stay until their TTLs", help: `Stops mirroring everywhere without deleting anything — every page stays readable as a frozen snapshot until its TTL expires.` },
+                { title: "Cancel", value: "cancel" },
+            ],
+        });
+        if (!how || how === "cancel")
+            return;
+        if (how === "leave") {
+            await patchSessionBinding(host.client, root, (servers) => {
+                for (const b of all) {
+                    delete servers[b.server];
+                    servers[b.server] = { optedOut: true };
+                }
+            });
+            finish(host, { ok: true, message: `${all.length} server(s) left as-is — snapshots until their TTLs.` });
+            return;
+        }
+        const yes = await host.ui.showConfirm({
+            title: "Stop sharing",
+            message: `Delete the share pages on all ${all.length} servers? The links stop working for everyone.`,
+            confirmLabel: "Stop all",
+            danger: true,
+        });
+        if (!yes)
+            return;
+        finish(host, await runUnshareFlow(host, sessionID()));
+        return;
+    }
+    if (choice === "more") {
+        const pick = await host.ui.showMenu({
+            title: "Share to another server",
+            options: [...otherServers.map((s) => ({ title: hostOf(s.url), value: s.url, description: s.entry.label })), { title: "Cancel", value: "__cancel" }],
+        });
+        if (!pick || pick === "__cancel")
+            return;
+        const { saveServerEntry } = await import("./share-flow.js");
+        for (const s of serverEntries())
+            if (s.url !== pick)
+                saveServerEntry(s.url, { active: undefined });
+        saveServerEntry(pick, { active: true });
+        finish(host, { ok: true, message: `${hostOf(pick)} activated — this session mirrors there within seconds (new sessions share to it too).` });
+        return;
+    }
+    if (choice === "manage") {
+        const pick = await host.ui.showMenu({
+            title: "Manage server",
+            options: [...all.map((b) => ({ title: hostOf(b.url || b.server), value: b.server, description: b.url })), { title: "Cancel", value: "__cancel" }],
+        });
+        if (!pick || pick === "__cancel")
+            return;
+        const b = all.find((x) => x.server === pick);
+        if (!b)
+            return;
+        const action = await host.ui.showMenu({
+            title: `${hostOf(b.url || b.server)}`,
+            hint: b.url,
+            options: [
+                {
+                    title: "Copy link",
+                    value: "copy",
+                    description: "copy the share URL",
+                    help: `Copies this server's share URL to the clipboard.\n\nURL: ${b.url}\nShare id: ${b.id}`,
+                },
+                {
+                    title: "Stop sharing here",
+                    value: "stop",
+                    description: "delete THIS server's page; other servers unaffected",
+                    help: `Deletes the page on ${hostOf(b.url || b.server)} and retires this server for the session (the engine stops mirroring here). Other servers keep streaming. Sharing here again later creates a new page.`,
+                },
+                {
+                    title: "Leave as-is (snapshot)",
+                    value: "leave",
+                    description: "stop updating it; the page stays until its TTL",
+                    help: `Stops mirroring to ${hostOf(b.url || b.server)} WITHOUT deleting anything — viewers keep reading the snapshot until the share's TTL expires. Useful for handing someone a frozen copy while you keep working.`,
+                },
+                { title: "Cancel", value: "cancel" },
+            ],
+        });
+        if (!action || action === "cancel")
+            return;
+        if (action === "copy") {
+            const ok = await host.clipboard.write(b.url);
+            finish(host, ok ? { ok: true, message: `Share URL copied: ${b.url}`, url: b.url } : { ok: false, message: `Clipboard failed — ${b.url}`, url: b.url });
+            return;
+        }
+        if (action === "stop") {
+            const deleted = await workerDeleteShare(b.server || b.url.slice(0, b.url.indexOf("/s/")), b.id, b.secret);
+            await patchSessionBinding(host.client, root, (servers) => {
+                delete servers[b.server];
+                servers[b.server] = { optedOut: true };
+            });
+            finish(host, { ok: true, message: deleted ? `Stopped sharing on ${hostOf(b.url || b.server)} — page deleted.` : `Stopped sharing on ${hostOf(b.url || b.server)} (page deletion follows via the sweeper).` });
+            return;
+        }
+        if (action === "leave") {
+            await patchSessionBinding(host.client, root, (servers) => {
+                delete servers[b.server];
+                servers[b.server] = { optedOut: true };
+            });
+            finish(host, { ok: true, message: `${hostOf(b.url || b.server)} left as-is — a snapshot until its TTL.` });
+            return;
+        }
+    }
+}
+/** Credential collision: the engine refused to auto-recreate. The user
+ * chooses: copy debug info (for the hoster/issue), share on a new share,
+ * or don't share. */
+async function showCollisionDialog(host, root, server, shareId, error) {
+    const debugInfo = JSON.stringify({ server, shareId, error, sessionID: root, plugin: "openshare", time: new Date().toISOString() }, null, 2);
+    const choice = await host.ui.showMenu({
+        title: `Share conflict — ${hostOf(server)}`,
+        hint: `saved credentials for ${shareId.slice(0, 12)}… were rejected (${error})`,
+        options: [
+            {
+                title: "Copy debug info",
+                value: "debug",
+                description: "server, share id, error — for the hoster or an issue report",
+                help: `Copies a JSON blob with the server, share id, exact error, and session id — attach it when reporting to the hoster or filing an issue.\n\n${debugInfo}`,
+            },
+            {
+                title: "Share on a new share",
+                value: "new",
+                description: "abandon the old binding; create a fresh share with full history",
+                help: `Drops the rejected binding and lets the engine create a brand-new share on ${hostOf(server)} with the session's full history. The old page (whoever owns it now) is left untouched.`,
+            },
+            {
+                title: "Don't share here",
+                value: "no",
+                description: "leave the old page; this server stops receiving this session",
+                help: `Opts this session out on ${hostOf(server)}: the engine stops trying to attach. The rejected page stays as-is. Re-share here anytime via "Share to another server".`,
+            },
+            { title: "Cancel", value: "cancel" },
+        ],
+    });
+    if (!choice || choice === "cancel")
+        return;
+    if (choice === "debug") {
+        const ok = await host.clipboard.write(debugInfo);
+        finish(host, ok ? { ok: true, message: "Debug info copied to clipboard." } : { ok: false, message: `Clipboard failed:\n${debugInfo}` });
+        return;
+    }
+    if (choice === "new") {
+        await patchSessionBinding(host.client, root, (servers) => {
+            delete servers[server];
+        });
+        finish(host, { ok: true, message: `Re-sharing on ${hostOf(server)} — a new share appears within seconds.` });
+        return;
+    }
+    if (choice === "no") {
+        await patchSessionBinding(host.client, root, (servers) => {
+            delete servers[server];
+            servers[server] = { optedOut: true };
+        });
+        finish(host, { ok: true, message: `${hostOf(server)} opted out for this session.` });
+    }
+}
+export function buildShareCommand(host, sessionID) {
+    return {
+        name: "session.share",
+        title: "Share session (re:share)",
+        desc: "Share this session via openshare; on a shared session: copy the link or stop sharing",
+        slashName: "share",
+        slashAliases: ["reshare"],
+        category: PALETTE_CATEGORY,
+        group: PALETTE_CATEGORY,
+        run: async () => {
+            dbgLog(`/share run: entered (sid=${sessionID() ?? "none"})`);
+            host.ui.dialog.clear();
+            const cfg = currentConfig();
+            if (!isConfigured(cfg)) {
+                void onboardingDialog(host);
+                return;
+            }
+            const sid = sessionID();
+            if (!sid) {
+                finish(host, { ok: false, message: "No active session to share." });
+                return;
+            }
+            const root = await resolveRoot(host.client, sid);
+            const bindings = await readBindings(host.client, root);
+            const binding = bindings[0];
+            dbgLog(`/share gate: sid=${sid} root=${root} bindings=${bindings.length}`);
+            // live ⇔ url && enabled !== false (all-mode bindings carry
+            // enabled:true since the fix; legacy all-mode bindings without the
+            // field are live too — only an explicit false is dormant)
+            if (bindings.some((b) => b.url && b.enabled !== false)) {
+                await showShareManager(host, sessionID);
+                host.ui.dialog.clear();
+                return;
+            }
+            // not shared (or dormant): the normal flow — consent once, then share
+            const result = await runShareFlow(host, sid);
+            if (result.message === "consent required") {
+                const yes = await host.ui.showConfirm({
+                    title: "Share Session",
+                    message: "Publish this session (and its subagent sessions) to your openshare worker?\nThe link lets anyone with it read the conversation.",
+                    confirmLabel: "Share",
+                });
+                if (!yes)
+                    return;
+                try {
+                    host.kv.set(CONSENT_KV_KEY, true);
+                    dbgLog("consent kv.set ok");
+                }
+                catch (e) {
+                    dbgLog(`consent kv.set THREW: ${e?.message ?? e}`);
+                }
+                try {
+                    finish(host, await confirmShare(host, root));
+                }
+                catch (e) {
+                    dbgLog(`confirmShare rejected: ${e?.stack ?? e}`);
+                    finish(host, { ok: false, message: "Share failed (see debug log)." });
+                }
+                return;
+            }
+            finish(host, result);
+        },
+    };
+}
+export function buildSettingsCommand(host, sessionID) {
+    return {
+        name: "openshare.settings",
+        title: "OpenShare: Settings",
+        desc: "Worker connection, sharing defaults, read auth, this session",
+        slashName: "openshare",
+        category: PALETTE_CATEGORY,
+        group: PALETTE_CATEGORY,
+        run: async () => {
+            host.ui.dialog.clear();
+            await settingsDialog(host, sessionID());
+        },
+    };
+}
+/** Registers the /share toggle + /openshare settings on one keymap layer.
+ * Returns the unregister function. */
+export function registerCommands(host, sessionID) {
+    return host.keymap.registerLayer({
+        commands: [buildShareCommand(host, sessionID), buildSettingsCommand(host, sessionID)],
+        bindings: [],
+    });
+}

package/dist/config.d.ts

@@ -0,0 +1,134 @@
+export type ShareMode = "all" | "manual";
+/** One share-server membership. Keyed by server URL in the `servers`
+ * config group; the entry with `active: true` (or the first) is where
+ * new sessions share. `token` is the enrolled user token (osk_…) or the
+ * legacy root CREATE_TOKEN; `code` is an enrollment access code for
+ * private servers (used once when no token is held); `adminToken` is the
+ * server's root CREATE_TOKEN for the /openshare admin console (optional
+ * convenience — the hoster's own machines only). */
+export type ServerEntry = {
+    token?: string;
+    code?: string;
+    label?: string;
+    active?: boolean;
+    adminToken?: string;
+};
+export type ShareConfig = {
+    workerUrl: string;
+    createToken: string;
+    /** Multi-server memberships (URL -> entry). Legacy workerUrl/createToken
+     * synthesize into this group at load; the group is the canonical form. */
+    servers?: Record<string, ServerEntry>;
+    debounceMs: number;
+    completedDelayMs: number;
+    modelLabel: string;
+    ttlDays: number;
+    openTasksInNewTab: boolean;
+    authLogin: string;
+    authPassword: string;
+    spoolDir: string;
+    urlFile: string;
+    /** false silences the `[openshare] live:` (and `url file:`) stderr
+     * lines. The share itself is unaffected. */
+    announceStderr: boolean;
+    shareMode?: ShareMode;
+};
+export declare const METADATA_KEY = "openshare";
+/** Sentinel urlFile value that disables the URL file entirely
+ * (`""` stays "unset = default path"; "none" is an explicit opt-out). */
+export declare const URL_FILE_NONE = "none";
+export declare const DEFAULTS: ShareConfig;
+/** Directory of this module file (bundled standalone: the single file's
+ * directory; package: dist/). */
+export declare function moduleDir(): string;
+/** Nearest ancestor (starting at `start`) containing package.json. */
+export declare function packageRoot(start: string): string;
+/** Config file search paths for a plugin living at `pluginDir`.
+ *
+ * Order (first FOUND wins; env vars still override everything):
+ *  1. `openshare.config.json` adjacent to the plugin file (CI bundles
+ *     ship it alongside; the package ships a commented template).
+ *  2. `openshare.local.json` walking up from the plugin dir (repo-local
+ *     overrides for dev/testing; gitignored by convention).
+ *  3. `openshare.config.json` in the opencode config folder
+ *     (`~/.config/opencode/`) — the interactive settings home, same
+ *     sidecar pattern the family plugins use.
+ */
+export declare function configPaths(pluginDir: string, env?: NodeJS.ProcessEnv): string[];
+/** Canonical settings target (what the TUI dialog writes when no
+ * adjacent config exists): the opencode config folder. */
+export declare function configHomePath(env?: NodeJS.ProcessEnv): string;
+export type WriteCandidate = {
+    path: string;
+    label: string;
+    always?: boolean;
+};
+/** Write-target candidates for the TUI picker: the global settings home
+ * (always writable) plus every OTHER file in the read chain that already
+ * exists on disk (deploy-time overrides are never created from the TUI —
+ * owner rule). Order: global first (default), then the rest by read
+ * precedence (highest first). */
+export declare function writeCandidates(pluginDir: string, env?: NodeJS.ProcessEnv): WriteCandidate[];
+/** Per-key source attribution mirroring loadConfig precedence exactly
+ * (env > adjacent > package root > local walks > global > default).
+ * Values of "" count as unset for the credential/path keys. */
+export declare function configSourceMap(pluginDir: string, env?: NodeJS.ProcessEnv): Record<string, string>;
+/** Sanitized `servers` group from raw config JSON (invalid entries
+ * dropped; url keys kept verbatim). */
+export declare function normalizeServers(raw: unknown): Record<string, ServerEntry> | undefined;
+/** Field-level merge of servers groups: entries only carry present fields
+ * (normalizeServers), so a static `code` in plugin options and a persisted
+ * `token` in the settings home combine instead of shadowing — per-URL
+ * wholesale replacement would re-enroll on every boot (live-caught in
+ * suite design review). */
+export declare function mergeServerGroups(base: Record<string, ServerEntry> | undefined, add: Record<string, ServerEntry>): Record<string, ServerEntry>;
+/** The server new sessions share to: the `active` entry (or the first).
+ * Legacy workerUrl/createToken merge in as the implicit first entry — with
+ * the root token ALSO filed as adminToken (the createToken IS root; filing
+ * it only as `token` made the TUI offer user-actions like rotate to a root
+ * holder — live-caught "can either be admin or user but not both"). */
+export declare function resolveServer(cfg: ShareConfig): {
+    url: string;
+    token: string;
+    entry: ServerEntry;
+} | undefined;
+/** Persist a field patch for a server entry into the settings-home
+ * config's `servers` group — surgical merge (never rewrites other keys,
+ * never touches deploy-time files). */
+export declare function saveServerEntry(url: string, patch: Partial<ServerEntry>, target?: string): string | undefined;
+/** Token persistence (engine enrollment) — entry-patch special case. */
+export declare function saveServerToken(url: string, token: string, target?: string): string | undefined;
+/** Remove a server membership from the settings home (per-field merge
+ * means entries born in plugin options/env survive — that's the override
+ * owner's business, shown by the sources view). */
+export declare function deleteServerEntry(url: string, target?: string): string | undefined;
+/** Load the effective config. `options` is the plugin-array options tuple
+ * object (env still wins over it). Files MERGE lowest→highest priority
+ * (later files override per key); empty strings in credential/path keys
+ * mean "unset" — a shipped template with blank workerUrl/createToken
+ * never shadows the real config elsewhere. */
+export declare function loadConfig(pluginDir: string, options?: Record<string, unknown>): ShareConfig;
+export declare function spoolDirFor(cfg: ShareConfig): string;
+/** Does this plugin spec (tui.json entry) point at the openshare package? */
+export declare function isOpenShareSpec(spec: unknown): spec is string;
+/** tui.json layers the TUI reads (mirrors the family selfwire path rules,
+ * read-only). The walk runs from the session directory up to the worktree
+ * root when the host reports a sane worktree; hosts have been observed to
+ * report "/" for non-git dirs — in that case walk to the filesystem root. */
+export declare function tuiLayerPaths(input: {
+    directory?: string;
+    worktree?: string;
+    env?: NodeJS.ProcessEnv;
+}): string[];
+/** True when an openshare TUI part is registered in any tui.json layer. */
+export declare function detectTuiPresence(input: {
+    directory?: string;
+    worktree?: string;
+    env?: NodeJS.ProcessEnv;
+}): boolean;
+/** Resolve the effective share mode: explicit config wins, else presence. */
+export declare function resolveShareMode(cfg: ShareConfig, input: {
+    directory?: string;
+    worktree?: string;
+    env?: NodeJS.ProcessEnv;
+}): ShareMode;