yaver-feedback-react-native 0.9.2 → 0.9.3

package/dist/_core/ansi.js

@@ -0,0 +1,468 @@
+"use strict";
+// AUTO-SYNCED from shared/client-core/src/ansi.ts.
+// DO NOT EDIT IN PLACE. Edit the source and re-run
+// scripts/sync-client-core.sh. CI checks drift via `--check`.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ANSI_16_RGB = void 0;
+exports.paletteRgb = paletteRgb;
+exports.tokenizeAnsi = tokenizeAnsi;
+exports.ansiToPlain = ansiToPlain;
+exports.tokenStreamToLines = tokenStreamToLines;
+exports.classifyAnsiLine = classifyAnsiLine;
+exports.styleAnsiLines = styleAnsiLines;
+exports.summarizeRawConsole = summarizeRawConsole;
+/** The 16 standard ANSI colours as RGB (bright variants at 8-15). */
+exports.ANSI_16_RGB = [
+    [0, 0, 0], // 0 black
+    [194, 54, 33], // 1 red (opencode-ish)
+    [94, 164, 44], // 2 green
+    [163, 134, 52], // 3 yellow/orange
+    [0, 94, 168], // 4 blue
+    [101, 88, 186], // 5 magenta
+    [44, 142, 158], // 6 cyan
+    [190, 190, 190], // 7 white
+    [128, 128, 128], // 8 bright black
+    [255, 113, 89], // 9 bright red
+    [134, 214, 92], // 10 bright green
+    [229, 201, 84], // 11 bright yellow
+    [88, 156, 245], // 12 bright blue
+    [184, 146, 255], // 13 bright magenta
+    [112, 213, 226], // 14 bright cyan
+    [240, 240, 240], // 15 bright white
+];
+/** The xterm-256 colour cube / greys (index 16-255). */
+const PALETTE_RGB = (() => {
+    const out = [];
+    // 16-231: 6x6x6 colour cube.
+    for (let i = 0; i < 216; i++) {
+        const r = Math.round((i / 36) % 6) * 51;
+        const g = Math.round((i / 6) % 6) * 51;
+        const b = (i % 6) * 51;
+        out.push([r, g, b]);
+    }
+    // 232-255: 24-step grey ramp.
+    for (let i = 0; i < 24; i++) {
+        const v = 8 + i * 10;
+        out.push([v, v, v]);
+    }
+    return out;
+})();
+/** Map an xterm-256 palette index to RGB. */
+function paletteRgb(index) {
+    if (index >= 0 && index < 16)
+        return [...exports.ANSI_16_RGB[index]];
+    if (index >= 16 && index < 256)
+        return PALETTE_RGB[index - 16];
+    return [190, 190, 190];
+}
+/** Truecolor/rgb approximation of a 256-colour index (used when a surface
+ *  can't map the palette exactly). */
+const OSC_LINK_OPEN = /\x1b\]8;;([^\x07]*)\x07/;
+/** Schemes an OSC-8 hyperlink may carry. Anything else — `javascript:`,
+ *  `data:`, `vbscript:`, a bare protocol-relative `//`, or a scheme-less
+ *  string that React would still accept as a URL — is dropped so a
+ *  prompt-injected link can never execute in the dashboard origin. This is
+ *  the web-side half of the audit finding "OSC-8 `javascript:` href XSS"
+ *  (docs/audits/webui-chat-vibing-gui-2026-08-12.md §6.1): the tokenizer is
+ *  the single choke point every renderer (AnsiConsoleText, terminal views)
+ *  shares, so sanitising here protects all of them.
+ */
+// http(s):// and mailto: (mailto has no "//"). Everything else fails.
+const OSC_LINK_SAFE = /^(https?:\/\/|mailto:)/i;
+/** Returns the href to carry on the token, or "" when the URL is unsafe. */
+function sanitizeOscLink(url) {
+    const trimmed = (url || "").trim();
+    if (!trimmed)
+        return "";
+    // `javascript:alert(1)` fails the allowlist; `//evil.com` is
+    // protocol-relative and must not become a same-origin jump; a bare
+    // `alert(1)` without a scheme is not a URL at all. Only explicit
+    // http(s):// or mailto: links pass.
+    if (!OSC_LINK_SAFE.test(trimmed))
+        return "";
+    return trimmed;
+}
+/**
+ * Tokenize an ANSI/VT stream into styled runs. Pure, deterministic,
+ * dependency-free — unit-tested in ansi.test.ts.
+ */
+function tokenizeAnsi(input, opts) {
+    if (!input)
+        return [];
+    const keepEraseLines = opts?.keepEraseLines ?? true;
+    const tokens = [];
+    let fg;
+    let bg;
+    let bold = false;
+    let dim = false;
+    let italic = false;
+    let underline = false;
+    let strike = false;
+    let buf = "";
+    // Current open OSC-8 link (the ESC\ BEL...ST form), if any.
+    let linkUrl;
+    const pushBuf = (href) => {
+        if (!buf)
+            return;
+        tokens.push({
+            text: buf,
+            ...(href || linkUrl ? { href: href || linkUrl } : {}),
+            ...(fg ? { fg } : {}),
+            ...(bg ? { bg } : {}),
+            ...(bold ? { bold: true } : {}),
+            ...(dim ? { dim: true } : {}),
+            ...(italic ? { italic: true } : {}),
+            ...(underline ? { underline: true } : {}),
+            ...(strike ? { strike: true } : {}),
+        });
+        buf = "";
+    };
+    const applySgr = (params) => {
+        if (!params) { // bare \x1b[m === reset
+            fg = undefined;
+            bg = undefined;
+            bold = false;
+            dim = false;
+            italic = false;
+            underline = false;
+            strike = false;
+            return;
+        }
+        const parts = params.split(";");
+        let i = 0;
+        while (i < parts.length) {
+            const code = parts[i];
+            if (code === "") {
+                fg = undefined;
+                bg = undefined;
+                bold = false;
+                dim = false;
+                italic = false;
+                underline = false;
+                strike = false;
+                i++;
+                continue;
+            }
+            const n = parseInt(code, 10);
+            if (isNaN(n)) {
+                i++;
+                continue;
+            }
+            switch (n) {
+                case 0:
+                    fg = undefined;
+                    bg = undefined;
+                    bold = false;
+                    dim = false;
+                    italic = false;
+                    underline = false;
+                    strike = false;
+                    break;
+                case 1:
+                    bold = true;
+                    break;
+                case 2:
+                    dim = true;
+                    break;
+                case 3:
+                    italic = true;
+                    break;
+                case 4:
+                    underline = true;
+                    break;
+                case 7: /* reverse video — swap fg/bg */ {
+                    const t = fg;
+                    fg = bg;
+                    bg = t;
+                    break;
+                }
+                case 9:
+                    strike = true;
+                    break;
+                case 22:
+                    bold = false;
+                    dim = false;
+                    break;
+                case 23:
+                    italic = false;
+                    break;
+                case 24:
+                    underline = false;
+                    break;
+                case 29:
+                    strike = false;
+                    break;
+                case 30:
+                case 31:
+                case 32:
+                case 33:
+                case 34:
+                case 35:
+                case 36:
+                case 37:
+                    fg = { kind: "named", index: n - 30 };
+                    break;
+                case 38: {
+                    const t = parseExtendedColor(parts, i + 1);
+                    if (t) {
+                        fg = t.color;
+                        i = t.next;
+                    }
+                    break;
+                }
+                case 39:
+                    fg = undefined;
+                    break;
+                case 40:
+                case 41:
+                case 42:
+                case 43:
+                case 44:
+                case 45:
+                case 46:
+                case 47:
+                    bg = { kind: "named", index: n - 40 };
+                    break;
+                case 48: {
+                    const t = parseExtendedColor(parts, i + 1);
+                    if (t) {
+                        bg = t.color;
+                        i = t.next;
+                    }
+                    break;
+                }
+                case 49:
+                    bg = undefined;
+                    break;
+                case 90:
+                case 91:
+                case 92:
+                case 93:
+                case 94:
+                case 95:
+                case 96:
+                case 97:
+                    fg = { kind: "named", index: n - 90 + 8 };
+                    break;
+                case 100:
+                case 101:
+                case 102:
+                case 103:
+                case 104:
+                case 105:
+                case 106:
+                case 107:
+                    bg = { kind: "named", index: n - 100 + 8 };
+                    break;
+                default: /* unknown — ignore */ break;
+            }
+            i++;
+        }
+    };
+    /** Parse 38/48 extended colours: `;5;<idx>` (256) or `;2;r;g;b` (truecolor). */
+    const parseExtendedColor = (parts, from) => {
+        const mode = parts[from];
+        if (mode === "5") {
+            const idx = parseInt(parts[from + 1] ?? "", 10);
+            if (!isNaN(idx))
+                return { color: { kind: "palette", index: idx }, next: from + 1 };
+        }
+        else if (mode === "2") {
+            const r = parseInt(parts[from + 1] ?? "", 10);
+            const g = parseInt(parts[from + 2] ?? "", 10);
+            const b = parseInt(parts[from + 3] ?? "", 10);
+            if (!isNaN(r) && !isNaN(g) && !isNaN(b))
+                return { color: { kind: "rgb", rgb: [r, g, b] }, next: from + 3 };
+        }
+        return null;
+    };
+    // Master scan: match SGR/control escapes OR OSC-8 hyperlink shells in one
+    // pass so link offsets can never drift from the text they wrap.
+    const MASTER = /(\x1b\]8;;[^\x07]*\x07[\s\S]*?\x1b\]8;;\x07)|(\x1b\[[0-9;:]*[A-Za-z])/g;
+    MASTER.lastIndex = 0;
+    let m;
+    let prevEnd = 0;
+    while ((m = MASTER.exec(input)) !== null) {
+        const osc = m[1];
+        const esc = m[2];
+        const start = m.index;
+        // Accumulate the plain text since the previous escape into buf.
+        if (start > prevEnd) {
+            buf += input.slice(prevEnd, start);
+        }
+        if (osc) {
+            // OSC-8 hyperlink shell: \x1b]8;;<url>\x07<text>\x1b]8;;\x07
+            const open = osc.match(OSC_LINK_OPEN);
+            const url = sanitizeOscLink(open ? open[1] : "");
+            // Strip the shell, keep only the inner text.
+            const inner = osc.replace(/\x1b\]8;;[^\x07]*\x07/, "").replace(/\x1b\]8;;\x07$/, "");
+            buf += inner;
+            pushBuf(url || undefined);
+            linkUrl = undefined;
+        }
+        else if (esc) {
+            const params = esc.slice(2, -1);
+            const cmd = esc.slice(-1);
+            if (cmd === "m") {
+                pushBuf();
+                applySgr(params);
+            }
+            else {
+                // Non-SGR control (cursor move, erase, etc.). Keep text before it,
+                // then treat the sequence as a boundary.
+                pushBuf();
+                if (keepEraseLines && (cmd === "K" || cmd === "J" || cmd === "H" || cmd === "A")) {
+                    tokens.push({ text: "\n" });
+                }
+            }
+        }
+        prevEnd = MASTER.lastIndex;
+    }
+    if (prevEnd < input.length) {
+        buf += input.slice(prevEnd);
+    }
+    pushBuf();
+    // Merge adjacent tokens with identical style so a stream that toggles
+    // `\x1b[0m` between runs (the opencode banner does this constantly) stays
+    // readable as contiguous text instead of fragmenting into per-escape runs.
+    const merged = [];
+    for (const t of tokens) {
+        const last = merged[merged.length - 1];
+        if (last &&
+            last.href === t.href &&
+            last.bold === t.bold &&
+            last.dim === t.dim &&
+            last.italic === t.italic &&
+            last.underline === t.underline &&
+            last.strike === t.strike &&
+            JSON.stringify(last.fg) === JSON.stringify(t.fg) &&
+            JSON.stringify(last.bg) === JSON.stringify(t.bg)) {
+            last.text += t.text;
+        }
+        else {
+            merged.push({ ...t });
+        }
+    }
+    return merged;
+}
+/** Convenience: flatten tokens to plain text (strip all styling). */
+function ansiToPlain(input) {
+    return tokenizeAnsi(input)
+        .map((t) => t.text)
+        .join("");
+}
+function tokenStreamToLines(tokens) {
+    const lines = [];
+    let current = [];
+    for (const t of tokens) {
+        const parts = t.text.split("\n");
+        parts.forEach((seg, idx) => {
+            if (idx > 0) {
+                lines.push({ tokens: current });
+                current = [];
+            }
+            if (seg.length > 0) {
+                current.push({ ...t, text: seg });
+            }
+        });
+    }
+    if (current.length > 0)
+        lines.push({ tokens: current });
+    return lines;
+}
+const BANNER_RE = /^\s*>?\s*(build|plan|review|debug)\s*[·•|:]\s*\S+/;
+const PROMPT_RE = /^\s*\$[ \t]/;
+const DIFF_HEADER_RE = /^diff --git \S+ \S+$/;
+const DIFF_FILE_RE = /^(\+\+\+|---) [ab]\/\S+/;
+const DIFF_HUNK_RE = /^@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@/;
+const TOOL_TAIL_RE = /^\s*(⎿|└|├)\s*/;
+const STATUS_RE = /^\s*[✓✗]\s+\S/;
+function classifyAnsiLine(plain) {
+    const s = plain.replace(/\s+$/g, "");
+    if (!s)
+        return "plain";
+    if (BANNER_RE.test(s))
+        return "banner";
+    if (PROMPT_RE.test(s))
+        return "prompt";
+    if (DIFF_HEADER_RE.test(s))
+        return "diff-header";
+    if (DIFF_FILE_RE.test(s))
+        return "diff-file";
+    if (DIFF_HUNK_RE.test(s))
+        return "diff-hunk";
+    if (s.startsWith("+") && !s.startsWith("+++"))
+        return "diff-add";
+    if (s.startsWith("-") && !s.startsWith("---"))
+        return "diff-del";
+    if (TOOL_TAIL_RE.test(s) || STATUS_RE.test(s))
+        return "tool-call";
+    return "plain";
+}
+function styleAnsiLines(input) {
+    const lines = tokenStreamToLines(tokenizeAnsi(input));
+    return lines.map((l) => {
+        const plain = l.tokens.map((t) => t.text).join("");
+        return { hint: classifyAnsiLine(plain), plain, tokens: l.tokens };
+    });
+}
+const CONSOLE_NOISE_RE = [
+    /^\$\s+/, // `$ cmd` echo
+    /^(workdir|model|provider|approval|sandbox|reasoning effort|session id|project path|project):/i, // runner config banners
+    /^(diff --git|index [0-9a-f]+\.\.[0-9a-f]+|@@ |--- |\+\+\+ )/, // diff hunks
+    /^[{}[\];(),.=><:+\-/*\\|'"`_~]+$/, // TUI redraw edges
+];
+function summarizeRawConsole(raw, running, opts) {
+    if (!raw)
+        return "";
+    const budgetLines = opts?.budgetLines ?? (running ? 40 : 200);
+    const budgetChars = opts?.budgetChars ?? (running ? 6 * 1024 : 24 * 1024);
+    const lines = raw.split("\n");
+    // KEEP THE TAIL, NOT THE HEAD (2026-08-13, web chat live-console bug):
+    // the old loop dropped NEW lines once the budget was reached, so a
+    // running task past ~150 lines froze its console at the START of the
+    // run — the header said "N LINES · LIVE" while every line after the
+    // budget never rendered, and auto-scroll had nothing to follow. A live
+    // console shows the newest output; evict the OLDEST kept line instead
+    // of rejecting the newest.
+    const kept = [];
+    let keptChars = 0;
+    let dropped = 0;
+    let prevKey = "";
+    let runLen = 0;
+    for (const rawLine of lines) {
+        const plain = ansiToPlain(rawLine).trim();
+        if (!plain)
+            continue;
+        if (CONSOLE_NOISE_RE.some((re) => re.test(plain))) {
+            dropped += 1;
+            continue;
+        }
+        if (plain === prevKey) {
+            runLen += 1;
+            if (runLen > 2) {
+                dropped += 1;
+                continue;
+            } // 3+ repeats → one
+        }
+        else {
+            prevKey = plain;
+            runLen = 1;
+        }
+        if (kept.length >= budgetLines || keptChars >= budgetChars) {
+            // Budget full: make room for the newest line by evicting the oldest
+            // kept line (tracking its char weight so the char budget stays
+            // accurate). This is what makes a streaming console follow the tail.
+            dropped += 1;
+            const evicted = kept.shift();
+            if (evicted)
+                keptChars -= evicted.length + 1;
+        }
+        kept.push(rawLine);
+        keptChars += rawLine.length + 1;
+    }
+    let out = kept.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+    if (dropped > 0)
+        out = `${out}\n… ${dropped} noisy lines collapsed`;
+    return out;
+}

package/dist/_core/ansi.test.d.ts

@@ -0,0 +1 @@
+export {};