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

package/dist/dialogs.d.ts

@@ -11,11 +11,11 @@ export declare function setDialogHeightPercent(api: TuiPluginApi, value: number)
  * accounted); the estimator and the pre-wrapper both use this so heights
  * match what actually renders. */
 export declare function dialogContentWidth(api: TuiPluginApi): number;
-/** Deterministic character-level pre-wrap (parity lesson: opentui's
- * word wrap cannot break unbreakable tokens like a JSON policy blob, so
- * "wrapped" text still escaped the dialog border — live-caught). Both the
- * [i] pane and InfoDialog render THESE lines; the row estimate uses the
- * same output, so heights match what renders. */
+/** Deterministic character-level pre-wrap: opentui's word wrap cannot
+ * break unbreakable tokens like a JSON policy blob, so "wrapped" text still
+ * escapes the dialog border. Both the [i] pane and InfoDialog render THESE
+ * lines; the row estimate uses the same output, so heights match what
+ * renders. */
 export declare function preWrap(text: string, width: number): string[];
 export type MenuOption<Value = string> = {
     title: string;
@@ -41,11 +41,10 @@ export declare function MenuDialog<Value>(props: {
     hint?: string;
     onDone: (value: Value | undefined) => void;
 }): JSX.Element;
-/** showMenuOnce, family discipline with the flicker fix (2026-10-19):
- * done() does NOT clear the host stack — the next dialog's replace() is an
- * atomic swap, so clearing first paints one empty frame (the esc-to-parent
- * flicker, live-caught). Chain ends clear explicitly (command exits,
- * settings exit). */
+/** showMenuOnce, family discipline: done() does NOT clear the host stack,
+ * because the next dialog's replace() is an atomic swap and clearing first
+ * paints one empty frame (the esc-to-parent flicker). Chain ends clear
+ * explicitly (command exits, settings exit). */
 export declare function showMenuOnce<Value>(api: TuiPluginApi, props: {
     title: string;
     options: MenuOption<Value>[];

package/dist/dialogs.js

@@ -142,11 +142,11 @@ function cappedHeight(count, max, min = 1) {
 function estimatedVisualRows(message, width) {
     return message.split(/\r?\n/).reduce((rows, line) => rows + Math.max(1, Math.ceil(line.length / Math.max(1, width))), 0);
 }
-/** Deterministic character-level pre-wrap (parity lesson: opentui's
- * word wrap cannot break unbreakable tokens like a JSON policy blob, so
- * "wrapped" text still escaped the dialog border — live-caught). Both the
- * [i] pane and InfoDialog render THESE lines; the row estimate uses the
- * same output, so heights match what renders. */
+/** Deterministic character-level pre-wrap: opentui's word wrap cannot
+ * break unbreakable tokens like a JSON policy blob, so "wrapped" text still
+ * escapes the dialog border. Both the [i] pane and InfoDialog render THESE
+ * lines; the row estimate uses the same output, so heights match what
+ * renders. */
 export function preWrap(text, width) {
     const out = [];
     for (const raw of text.split(/\r?\n/)) {
@@ -200,10 +200,9 @@ function InfoLines(props) {
                 return line.length === 0 ? (_jsx("text", { children: " " })) : (_jsx("text", { fg: colorOf(attrs.fg), wrapMode: "none", children: attrs.bold ? _jsx("b", { children: line }) : line }));
             } }) }));
 }
-/** title column cap (family menuTitleWidth, live-caught need: a server URL
- * as a row title stretched the column toward half the dialog — the owner
- * capped it further: full URLs belong in the [i] pane, not the row).
- * Capped + ellipsized. */
+/** Title column cap (family menuTitleWidth): a server URL as a row title
+ * would otherwise stretch the column toward half the dialog. Full URLs
+ * belong in the [i] pane, not the row. Capped and ellipsized. */
 function menuTitleWidth(width, options) {
     const longest = Math.max(0, ...options.map((option) => option.title.length)) + 2;
     if (width === "xlarge")
@@ -217,13 +216,12 @@ function ellipsize(text, width) {
 }
 /** OpenShare visual frame: rounded accent border + accent title row. The
  * logic inside the menus stays the ported family pattern; this wrapper is
- * purely presentation (owner-preferred styling). Natural width — the host
- * dialog panel provides the container; the border hugs the content. */
-// Frame note (live-caught): the HOST dialog panel renders plugin content
-// with paddingTop=1 (opencode dialog.tsx), so a BORDERED frame always
-// showed a dead panel strip above its top border. Borderless family
-// shape + a solid accent rule under the title: zero dead space, accent
-// identity kept.
+ * purely presentation. Natural width: the host dialog panel provides the
+ * container and the border hugs the content. */
+// Frame note: the HOST dialog panel renders plugin content with
+// paddingTop=1 (opencode dialog.tsx), so a BORDERED frame always shows a
+// dead panel strip above its top border. Borderless family shape plus a
+// solid accent rule under the title: zero dead space, accent identity kept.
 function DialogFrame(props) {
     const theme = () => props.api.theme.current;
     return (_jsxs("box", { flexDirection: "column", width: "100%", paddingLeft: 2, paddingRight: 2, children: [_jsx("box", { width: "100%", marginBottom: 1, children: _jsx("text", { fg: theme().accent, children: _jsx("b", { children: props.title }) }) }), _jsx("box", { width: "100%", height: 1, backgroundColor: theme().accent, marginBottom: 1 }), props.children] }));
@@ -243,8 +241,8 @@ export function MenuDialog(props) {
     const dimensions = useTerminalDimensions();
     const listHeight = createMemo(() => cappedHeight(props.options.length, maxRows(props.api, dimensions().height, 12, 4), 4));
     // fixed title column shared by every row (family menuTitleWidth): flex
-    // columns stagger per-row because flex splits by content — a computed
-    // width is what makes the value/description column align (live-caught).
+    // columns stagger per row because flex splits by content, so a computed
+    // width is what makes the value/description column align.
     const width = dialogWidthOf(props.api);
     const titleWidth = createMemo(() => menuTitleWidth(width, props.options));
     const hasHelp = createMemo(() => props.options.some((option) => option.help));
@@ -272,8 +270,8 @@ export function MenuDialog(props) {
     });
     // [i] pane sections: "## Header" lines in help split sections; the pane
     // height comes from the CONTENT (pre-wrapped rows), capped by the same
-    // dialog metrics — no longer bound to the spawning menu's list height
-    // (live-caught: a 3-row menu gave a 3-row info pane).
+    // dialog metrics rather than the spawning menu's list height (which gave
+    // a 3-row menu a 3-row info pane).
     const helpSections = createMemo(() => {
         const raw = current()?.help ?? "";
         const sections = [{ title: "", lines: [] }];
@@ -465,11 +463,10 @@ function claimDialog(api) {
     pendingDialog = release;
     return release;
 }
-/** showMenuOnce, family discipline with the flicker fix (2026-10-19):
- * done() does NOT clear the host stack — the next dialog's replace() is an
- * atomic swap, so clearing first paints one empty frame (the esc-to-parent
- * flicker, live-caught). Chain ends clear explicitly (command exits,
- * settings exit). */
+/** showMenuOnce, family discipline: done() does NOT clear the host stack,
+ * because the next dialog's replace() is an atomic swap and clearing first
+ * paints one empty frame (the esc-to-parent flicker). Chain ends clear
+ * explicitly (command exits, settings exit). */
 export function showMenuOnce(api, props) {
     return new Promise((resolve) => {
         let settled = false;
@@ -579,9 +576,9 @@ export function showAlertMenu(api, props) {
     return showInfoDialog(api, { title: props.title, message: props.message }).then(() => undefined);
 }
 // --- prompt (text entry — the one custom piece) -------------------------------
-// Full printable ASCII (parity fix, live-caught class: the lowercase-only
-// set made uppercase CREATE_TOKENs and codes UNTYPEABLE). Space is bound
-// separately below; escape is the back binding, so it's excluded.
+// Full printable ASCII: a lowercase-only set makes uppercase
+// CREATE_TOKENs and codes UNTYPEABLE. Space is bound separately below;
+// escape is the back binding, so it is excluded.
 const PROMPT_CHARS = [
     ..."abcdefghijklmnopqrstuvwxyz",
     ..."ABCDEFGHIJKLMNOPQRSTUVWXYZ",

package/dist/redact.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Client-only redaction + light path transform (Wave 3 trust).
+ *
+ * Owner verdict: the server stays dumb - the client controls what leaves
+ * the machine. This pass runs once at enqueue (the single choke point
+ * every item crosses before any transport) on UNGATED shares only: a
+ * share with login+pass is private from casual observers already, and
+ * redacting there would corrupt content the server owner can see anyway
+ * (documented caveat: NOT private from the server owner until Wave 3b
+ * encryption lands).
+ *
+ * Extending: add a detector to BUILTINS (fork-friendly registry) or set
+ * `redact.patterns` in the config (regex source strings, global flag).
+ */
+/** A detector: stable `kind` names the marker, e.g. `[redacted:aws-key]`. */
+export type RedactRule = {
+    kind: string;
+    re: RegExp;
+};
+export declare const BUILTINS: RedactRule[];
+export type RedactionHit = {
+    kind: string;
+    sample: string;
+};
+/** Home-directory prefix -> `~`; applied consistently to session.directory
+ * AND tool path fields so viewer-side relativization still works (both
+ * ends share the ~-prefixed form). */
+export declare function tildePath(p: string, home: string): string;
+type Opts = {
+    rules: RedactRule[];
+    home: string;
+    enabled: boolean;
+};
+/**
+ * Apply redaction (when enabled) + the light path transform to one
+ * contract item. Returns the ORIGINAL untouched when nothing matched
+ * (zero-copy fast path for clean sessions); otherwise a mutated deep
+ * clone - the host's live object is never touched.
+ */
+export declare function redactItem(item: unknown, opts: Opts): {
+    item: unknown;
+    hits: RedactionHit[];
+};
+/** All active rules (built-ins + compiled user patterns). */
+export declare function activeRules(userPatterns: unknown): RedactRule[];
+export {};

package/dist/redact.js

@@ -0,0 +1,130 @@
+/**
+ * Client-only redaction + light path transform (Wave 3 trust).
+ *
+ * Owner verdict: the server stays dumb - the client controls what leaves
+ * the machine. This pass runs once at enqueue (the single choke point
+ * every item crosses before any transport) on UNGATED shares only: a
+ * share with login+pass is private from casual observers already, and
+ * redacting there would corrupt content the server owner can see anyway
+ * (documented caveat: NOT private from the server owner until Wave 3b
+ * encryption lands).
+ *
+ * Extending: add a detector to BUILTINS (fork-friendly registry) or set
+ * `redact.patterns` in the config (regex source strings, global flag).
+ */
+export const BUILTINS = [
+    { kind: "aws-key", re: /\bAKIA[0-9A-Z]{16}\b/g },
+    { kind: "gh-token", re: /\bgh[pousr]_[A-Za-z0-9]{36,255}\b/g },
+    { kind: "gh-token", re: /\bgithub_pat_[A-Za-z0-9_]{22,255}\b/g },
+    { kind: "api-key", re: /\bsk-[A-Za-z0-9_-]{20,}\b/g },
+    { kind: "slack-token", re: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g },
+    { kind: "google-key", re: /\bAIza[0-9A-Za-z_-]{35}\b/g },
+    { kind: "bearer", re: /\bBearer\s+[A-Za-z0-9._~+/=-]{20,}/gi },
+    // PEM private-key blocks (whole block)
+    { kind: "private-key", re: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g },
+    // .env style assignments for secret-shaped names
+    { kind: "env-secret", re: /(?<![A-Za-z0-9_])(?:export\s+)?[A-Z0-9_]*(?:API_?KEY|TOKEN|SECRET|PASSWORD|PASSWD|PASS|PWD|CREDENTIALS?)[A-Z0-9_]*\s*=\s*\S+/g },
+    // URL connection strings with embedded passwords (password masked)
+    { kind: "conn-string", re: /\b[a-z][a-z0-9+.-]*:\/\/[^:@/\s"']+:[^@/\s"']{4,}@/gi },
+];
+/** Config-supplied rules (regex source strings, applied globally). */
+function compile(patterns) {
+    if (!Array.isArray(patterns))
+        return [];
+    const out = [];
+    for (const p of patterns) {
+        if (typeof p !== "string" || !p)
+            continue;
+        try {
+            out.push({ kind: "user", re: new RegExp(p, "g") });
+        }
+        catch {
+            // a broken user regex must never kill sharing - skip it
+        }
+    }
+    return out;
+}
+/** Home-directory prefix -> `~`; applied consistently to session.directory
+ * AND tool path fields so viewer-side relativization still works (both
+ * ends share the ~-prefixed form). */
+export function tildePath(p, home) {
+    if (!p || !home || p.length <= home.length)
+        return p;
+    const norm = (s) => s.replace(/[\\/]+/g, "/").replace(/\/$/, "");
+    const np = norm(p);
+    const nh = norm(home);
+    if (np === nh)
+        return "~";
+    if (np.startsWith(nh + "/"))
+        return "~" + np.slice(nh.length);
+    return p;
+}
+const PATH_KEYS = new Set(["file", "path", "filePath", "cwd", "directory", "root"]);
+/**
+ * Apply redaction (when enabled) + the light path transform to one
+ * contract item. Returns the ORIGINAL untouched when nothing matched
+ * (zero-copy fast path for clean sessions); otherwise a mutated deep
+ * clone - the host's live object is never touched.
+ */
+export function redactItem(item, opts) {
+    const flat = JSON.stringify(item) ?? "null";
+    const needRedact = opts.enabled && opts.rules.some((r) => { r.re.lastIndex = 0; return r.re.test(flat); });
+    const needPaths = !!opts.home && flat.includes(opts.home);
+    if (!needRedact && !needPaths)
+        return { item, hits: [] };
+    const clone = JSON.parse(flat);
+    const stats = { hits: [], changed: false };
+    walk(clone, opts, stats);
+    return { item: clone, hits: stats.hits };
+}
+function walk(node, opts, stats, key) {
+    if (Array.isArray(node)) {
+        for (let i = 0; i < node.length; i++) {
+            const v = node[i];
+            if (typeof v === "string")
+                node[i] = applyString(v, opts, stats, key);
+            else
+                walk(v, opts, stats, key);
+        }
+        return;
+    }
+    if (node && typeof node === "object") {
+        for (const [k, v] of Object.entries(node)) {
+            if (typeof v === "string")
+                node[k] = applyString(v, opts, stats, k);
+            else
+                walk(v, opts, stats, k);
+        }
+    }
+}
+function applyString(v, opts, stats, key) {
+    let out = v;
+    if (opts.enabled) {
+        for (const r of opts.rules) {
+            r.re.lastIndex = 0;
+            out = out.replace(r.re, (full) => {
+                if (stats.hits.length < 8 && !stats.hits.some((h) => h.kind === r.kind)) {
+                    stats.hits.push({ kind: r.kind, sample: full.slice(0, 60) });
+                }
+                stats.changed = true;
+                if (r.kind === "conn-string") {
+                    // keep scheme://user, mask the password, keep @host
+                    const at = full.lastIndexOf("@");
+                    const colon = full.indexOf(":", full.indexOf("://") + 3) + 1;
+                    if (at > colon && colon > 0)
+                        return full.slice(0, colon) + "[redacted:conn-string]" + full.slice(at);
+                }
+                return `[redacted:${r.kind}]`;
+            });
+        }
+    }
+    if (key && PATH_KEYS.has(key) && opts.home && out.includes(opts.home)) {
+        out = tildePath(out, opts.home);
+        stats.changed = true;
+    }
+    return out;
+}
+/** All active rules (built-ins + compiled user patterns). */
+export function activeRules(userPatterns) {
+    return [...BUILTINS, ...compile(userPatterns)];
+}

package/dist/settings.d.ts

@@ -1,8 +1,12 @@
 import type { ShareHostApi } from "./tui-host.js";
-/** Connect (add + enroll) a server — the /share first-run flow and the
+/** Connect (add + enroll) a server - the /share first-run flow and the
  * settings "Connect to a server" row share it. Prompts the URL, probes
- * the auth mode, prompts a code for private servers, enrolls, persists
- * the token and makes it the active server. */
+ * the auth mode, then ASKS ONCE: onboard to an account, or stay anonymous
+ * (public servers only; anonymous shares sit under the server's global
+ * caps). Onboarding detects whether a code is needed and only then prompts
+ * for one (a code already in config is used without asking). The outcome is
+ * remembered per server: a token means onboarded, an anonymous flag means
+ * declined. */
 export declare function connectServerFlow(host: ShareHostApi): Promise<{
     ok: boolean;
     message: string;
@@ -13,10 +17,9 @@ export declare function connectServerFlow(host: ShareHostApi): Promise<{
  * per-server submenu (Admin panel); pinnedUrl skips the server picker. */
 export declare function adminConsole(host: ShareHostApi, pinnedUrl?: string): Promise<void>;
 /** The settings dialog: a compact ROOT of group entries (with live
- * summaries) opening focused submenus. Two-level by design — one flat
- * ~25-row dump was unreadable (owner-directed regroup 2026-10-19).
- * Save semantics unchanged: root Exit saves when dirty; submenu Back
- * just returns. */
+ * summaries) opening focused submenus. Two-level by design: one flat ~25-row
+ * dump is unreadable. Save semantics unchanged: root Exit saves when dirty;
+ * submenu Back just returns. */
 export declare function settingsDialog(host: ShareHostApi, startAtSession?: string, startGroup?: "session"): Promise<void>;
 /** Onboarding shown by /share when no server is connected: connect flow
  * first (URL + optional code = enrolled + active), full settings as the