repoburg 1.3.254 → 1.3.256

package/daemon/dist/tabtape/mcp/params.js

@@ -0,0 +1,345 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFloat64 = parseFloat64;
+exports.atoi = atoi;
+exports.parseDuration = parseDuration;
+exports.parseRFC3339 = parseRFC3339;
+exports.parseOffset = parseOffset;
+exports.parseSpan = parseSpan;
+exports.parseSince = parseSince;
+exports.statusMatcher = statusMatcher;
+/**
+ * Readers for tool parameters: replay offsets, window lengths, "since" and
+ * status filters. They accept what the Go server accepted, so the number and
+ * duration parsers follow Go's strconv.ParseFloat, strconv.Atoi and
+ * time.ParseDuration rather than JavaScript's Number().
+ */
+const gofmt_1 = require("./gofmt");
+const CLOCK_RE = /^(?:(\d+):)?(\d{1,2}):(\d{1,2})(?:\.(\d{1,3}))?$/;
+const MAX_INT64 = (1n << 63n) - 1n;
+const MIN_INT64 = -(1n << 63n);
+/**
+ * Go's int64(f) for a float, as arm64 does it: truncates toward zero,
+ * saturates out of range values and maps NaN to 0. Results beyond what a
+ * JavaScript number holds exactly are capped at Number.MAX_SAFE_INTEGER.
+ */
+function toInt64(f) {
+    if (Number.isNaN(f))
+        return 0;
+    const n = Math.trunc(f);
+    if (n > Number.MAX_SAFE_INTEGER)
+        return Number.MAX_SAFE_INTEGER;
+    if (n < -Number.MAX_SAFE_INTEGER)
+        return -Number.MAX_SAFE_INTEGER;
+    return n || 0; // no -0
+}
+/** The same conversion to int64 nanoseconds, exactly. */
+function toInt64Big(f) {
+    if (Number.isNaN(f))
+        return 0n;
+    if (f >= 2 ** 63)
+        return MAX_INT64;
+    if (f <= -(2 ** 63))
+        return MIN_INT64;
+    return BigInt(Math.trunc(f));
+}
+// ---------- Go number syntax ----------
+const DECIMAL_RE = /^[+-]?(?:\d+(?:_\d+)*(?:\.(?:\d+(?:_\d+)*)?)?|\.\d+(?:_\d+)*)(?:[eE][+-]?\d+(?:_\d+)*)?$/;
+const HEX_RE = /^([+-]?)0[xX](?:_?([0-9a-fA-F]+(?:_[0-9a-fA-F]+)*)(?:\.([0-9a-fA-F]+(?:_[0-9a-fA-F]+)*)?)?|_?\.([0-9a-fA-F]+(?:_[0-9a-fA-F]+)*))[pP]([+-]?\d+(?:_\d+)*)$/;
+const SPECIAL_RE = /^(?:[+-]?(?:inf|infinity)|nan)$/i;
+/**
+ * Go's strconv.ParseFloat(s, 64): decimal and hexadecimal literals with
+ * optional underscores between digits, inf, infinity and nan. Returns null
+ * for a syntax error or an out of range value.
+ */
+function parseFloat64(s) {
+    if (SPECIAL_RE.test(s)) {
+        const t = s.toLowerCase();
+        if (t === 'nan')
+            return NaN;
+        return t[0] === '-' ? -Infinity : Infinity;
+    }
+    let f;
+    if (DECIMAL_RE.test(s)) {
+        f = Number(s.split('_').join(''));
+    }
+    else {
+        const m = HEX_RE.exec(s);
+        if (!m)
+            return null;
+        const int = (m[2] ?? '').split('_').join('');
+        const frac = (m[3] ?? m[4] ?? '').split('_').join('');
+        const mant = int + frac;
+        const exp = Number(m[5].split('_').join('')) - 4 * frac.length;
+        f = Number(BigInt('0x' + (mant || '0'))) * 2 ** exp;
+        if (m[1] === '-')
+            f = -f;
+    }
+    return Number.isFinite(f) ? f : null; // overflow is Go's ErrRange
+}
+/** Go's strconv.Atoi: base 10, optional sign, int64 range. Returns null on error. */
+function atoi(s) {
+    if (!/^[+-]?\d+$/.test(s))
+        return null;
+    const n = BigInt(s);
+    if (n > MAX_INT64 || n < MIN_INT64)
+        return null;
+    return Number(n);
+}
+// ---------- time.ParseDuration ----------
+const UNITS = {
+    ns: 1n,
+    us: 1000n,
+    [String.fromCharCode(0xb5) + 's']: 1000n, // U+00B5 micro sign
+    [String.fromCharCode(0x3bc) + 's']: 1000n, // U+03BC Greek mu
+    ms: 1000000n,
+    s: 1000000000n,
+    m: 60000000000n,
+    h: 3600000000000n,
+};
+const TWO63 = 1n << 63n;
+const isDigit = (c) => c >= '0' && c <= '9';
+/**
+ * Go's time.ParseDuration: a signed sequence of decimal numbers with
+ * optional fractions and a unit each, like "300ms", "-1.5h" or "2h45m".
+ * Returns nanoseconds, or null when s is not a duration.
+ */
+function parseDuration(input) {
+    let s = input;
+    let neg = false;
+    if (s !== '' && (s[0] === '-' || s[0] === '+')) {
+        neg = s[0] === '-';
+        s = s.slice(1);
+    }
+    if (s === '0')
+        return 0n; // special case: no unit needed
+    if (s === '')
+        return null;
+    let d = 0n;
+    while (s !== '') {
+        // The next character must be [0-9.].
+        if (!(s[0] === '.' || isDigit(s[0])))
+            return null;
+        // [0-9]*
+        let i = 0;
+        let v = 0n;
+        while (i < s.length && isDigit(s[i])) {
+            if (v > TWO63 / 10n)
+                return null; // overflow
+            v = v * 10n + BigInt(s.charCodeAt(i) - 48);
+            if (v > TWO63)
+                return null;
+            i++;
+        }
+        const pre = i > 0;
+        s = s.slice(i);
+        // (\.[0-9]*)?
+        let f = 0n;
+        let scale = 1;
+        let post = false;
+        if (s !== '' && s[0] === '.') {
+            s = s.slice(1);
+            let j = 0;
+            let overflow = false;
+            while (j < s.length && isDigit(s[j])) {
+                if (!overflow) {
+                    if (f > (TWO63 - 1n) / 10n) {
+                        overflow = true; // stop accumulating precision
+                    }
+                    else {
+                        const y = f * 10n + BigInt(s.charCodeAt(j) - 48);
+                        if (y > TWO63)
+                            overflow = true;
+                        else {
+                            f = y;
+                            scale *= 10;
+                        }
+                    }
+                }
+                j++;
+            }
+            post = j > 0;
+            s = s.slice(j);
+        }
+        if (!pre && !post)
+            return null; // no digits, e.g. ".s"
+        // The unit: everything up to the next number.
+        let k = 0;
+        while (k < s.length && !(s[k] === '.' || isDigit(s[k])))
+            k++;
+        if (k === 0)
+            return null; // missing unit
+        const unit = Object.prototype.hasOwnProperty.call(UNITS, s.slice(0, k)) ? UNITS[s.slice(0, k)] : undefined;
+        if (unit === undefined)
+            return null; // unknown unit
+        s = s.slice(k);
+        if (v > TWO63 / unit)
+            return null; // overflow
+        v *= unit;
+        if (f > 0n) {
+            // A float is nanosecond accurate for fractions of hours.
+            v += BigInt(Math.trunc(Number(f) * (Number(unit) / scale)));
+            if (v > TWO63)
+                return null;
+        }
+        d += v;
+        if (d > TWO63)
+            return null;
+    }
+    if (neg)
+        return -d;
+    if (d > TWO63 - 1n)
+        return null;
+    return d;
+}
+// ---------- RFC 3339 ----------
+const RFC3339_RE = /^(\d{4})-(\d{2})-(\d{2})T(\d{1,2}):(\d{2}):(\d{2})(?:[.,](\d+))?(Z|([+-])(\d{2}):(\d{2}))$/;
+function daysIn(month, year) {
+    if (month === 2)
+        return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0) ? 29 : 28;
+    return [4, 6, 9, 11].includes(month) ? 30 : 31;
+}
+/** Days since 1970-01-01 of a proleptic Gregorian date. */
+function daysFromCivil(y, m, d) {
+    y -= m <= 2 ? 1 : 0;
+    const era = Math.floor(y / 400);
+    const yoe = y - era * 400;
+    const doy = Math.floor((153 * (m + (m > 2 ? -3 : 9)) + 2) / 5) + d - 1;
+    const doe = yoe * 365 + Math.floor(yoe / 4) - Math.floor(yoe / 100) + doy;
+    return era * 146097 + doe - 719468;
+}
+/**
+ * Go's time.Parse(time.RFC3339, s), which also takes a one-digit hour, a
+ * comma before the fraction and zone offsets up to 24:60. Returns epoch
+ * milliseconds (Go's UnixMilli), or null.
+ */
+function parseRFC3339(s) {
+    const m = RFC3339_RE.exec(s);
+    if (!m)
+        return null;
+    const [year, month, day, hour, minute, second] = [1, 2, 3, 4, 5, 6].map((i) => Number(m[i]));
+    if (month < 1 || month > 12 || day < 1 || day > daysIn(month, year))
+        return null;
+    if (hour > 23 || minute > 59 || second > 59)
+        return null;
+    let offset = 0;
+    if (m[8] !== 'Z') {
+        const oh = Number(m[10]);
+        const om = Number(m[11]);
+        if (oh > 24 || om > 60)
+            return null;
+        offset = (oh * 60 + om) * 60 * (m[9] === '-' ? -1 : 1);
+    }
+    const millis = Number((m[7] ?? '').slice(0, 3).padEnd(3, '0'));
+    const secs = daysFromCivil(year, month, day) * 86400 + hour * 3600 + minute * 60 + second - offset;
+    return secs * 1000 + millis;
+}
+// ---------- parameters ----------
+/**
+ * Reads a position in a replay: "01:23", "01:23.4", "1:02:03", a duration
+ * ("83.4s", "1500ms", "2m") or a plain number of milliseconds. Empty means
+ * unset (-1).
+ */
+function parseOffset(input) {
+    const s = (0, gofmt_1.goTrimSpace)(input);
+    if (s === '')
+        return -1;
+    const m = CLOCK_RE.exec(s);
+    if (m) {
+        const h = Number(m[1] || '0');
+        const mins = Number(m[2]);
+        const sec = Number(m[3]);
+        const ms = Number((m[4] ?? '').padEnd(3, '0'));
+        return ((h * 60 + mins) * 60 + sec) * 1000 + ms;
+    }
+    const n = parseFloat64(s);
+    if (n !== null && n >= 0)
+        return toInt64(n);
+    const d = parseDuration(s);
+    if (d !== null && d >= 0n)
+        return Number(d / 1000000n);
+    throw new Error(`cannot read ${(0, gofmt_1.goQuote)(s)} as a time in the replay; use mm:ss(.mmm), a duration like 90s, or milliseconds`);
+}
+/**
+ * Reads a window length in milliseconds: a duration ("10s", "1500ms") or a
+ * plain number of seconds. Empty returns defMs.
+ */
+function parseSpan(input, defMs) {
+    const s = (0, gofmt_1.goTrimSpace)(input);
+    if (s === '')
+        return defMs;
+    const n = parseFloat64(s);
+    if (n !== null && n >= 0)
+        return toInt64(n * 1000);
+    const d = parseDuration(s);
+    if (d !== null && d >= 0n)
+        return Number(d / 1000000n);
+    throw new Error(`cannot read ${(0, gofmt_1.goQuote)(s)} as a duration; use e.g. 10s or 1500ms`);
+}
+/** Go's Time.UnixMilli of epoch nanoseconds: rounds down. */
+function unixMilli(ns) {
+    const q = ns / 1000000n;
+    return Number(ns < 0n && q * 1000000n !== ns ? q - 1n : q);
+}
+/**
+ * Reads "2h", "30m", "3d" or an RFC 3339 time, relative to now (epoch ms).
+ * Returns epoch milliseconds, or null when s is empty.
+ */
+function parseSince(input, nowMs) {
+    const s = (0, gofmt_1.goTrimSpace)(input);
+    if (s === '')
+        return null;
+    const t = parseRFC3339(s);
+    if (t !== null)
+        return t;
+    const nowNs = BigInt(Math.trunc(nowMs)) * 1000000n;
+    if (s.endsWith('d')) {
+        const n = parseFloat64(s.slice(0, -1));
+        if (n !== null)
+            return unixMilli(nowNs - toInt64Big(n * 86400000000000));
+    }
+    const d = parseDuration(s);
+    if (d !== null)
+        return unixMilli(nowNs - d);
+    throw new Error(`cannot read since=${(0, gofmt_1.goQuote)(s)}; use e.g. 2h, 30m, 3d or an RFC 3339 time`);
+}
+/**
+ * Reads a status filter: "500", "5xx", ">=400", "failed" (status >= 400 or a
+ * transport error), "error" (transport errors only).
+ */
+function statusMatcher(input) {
+    const s = (0, gofmt_1.goToLower)((0, gofmt_1.goTrimSpace)(input));
+    if (s === '')
+        return () => true;
+    if (s === 'failed' || s === 'failures')
+        return (st, e) => e || st >= 400;
+    if (s === 'error' || s === 'errors')
+        return (_st, e) => e;
+    if (s.length === 3 && s.endsWith('xx') && s[0] >= '1' && s[0] <= '5') {
+        const base = Number(s[0]) * 100;
+        return (st) => st >= base && st < base + 100;
+    }
+    for (const op of ['>=', '<=', '>', '<', '=']) {
+        if (!s.startsWith(op))
+            continue;
+        const n = atoi((0, gofmt_1.goTrimSpace)(s.slice(op.length)));
+        if (n === null)
+            break;
+        switch (op) {
+            case '>=':
+                return (st) => st >= n;
+            case '<=':
+                return (st) => st > 0 && st <= n;
+            case '>':
+                return (st) => st > n;
+            case '<':
+                return (st) => st > 0 && st < n;
+            default:
+                return (st) => st === n;
+        }
+    }
+    const n = atoi(s);
+    if (n !== null)
+        return (st) => st === n;
+    throw new Error(`cannot read status=${(0, gofmt_1.goQuote)(s)}; use e.g. 500, 5xx, >=400, failed`);
+}

package/daemon/dist/tabtape/mcp/params.spec.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const gofmt_1 = require("./gofmt");
+const params_1 = require("./params");
+const ch = (code) => String.fromCharCode(code);
+describe('parseOffset', () => {
+    it('reads clocks, durations and milliseconds', () => {
+        const cases = [
+            ['', -1],
+            ['  ', -1],
+            ['01:23', 83000],
+            ['01:23.4', 83400],
+            ['1:02:03.004', 3723004],
+            ['90s', 90000],
+            ['1500ms', 1500],
+            ['2500', 2500],
+            ['2.5', 2],
+            ['1_000', 1000],
+            ['1m30s', 90000],
+            ['-0', 0],
+            [' 00:05 ', 5000],
+        ];
+        for (const [input, want] of cases)
+            expect([input, (0, params_1.parseOffset)(input)]).toEqual([input, want]);
+    });
+    it('rejects other text and negative times', () => {
+        expect(() => (0, params_1.parseOffset)('soon')).toThrow('cannot read "soon" as a time in the replay; use mm:ss(.mmm), a duration like 90s, or milliseconds');
+        for (const s of ['-1s', '-', '-5', '1:2:3:4', '00:60.1234'])
+            expect(() => (0, params_1.parseOffset)(s)).toThrow('cannot read');
+    });
+});
+describe('parseSpan and parseSince', () => {
+    it('reads spans in seconds or as durations', () => {
+        expect((0, params_1.parseSpan)('', 10000)).toBe(10000);
+        expect((0, params_1.parseSpan)('2.5', 0)).toBe(2500);
+        expect((0, params_1.parseSpan)('1500ms', 0)).toBe(1500);
+        expect((0, params_1.parseSpan)('0.1', 0)).toBe(100);
+        expect(() => (0, params_1.parseSpan)('-1', 0)).toThrow('cannot read "-1" as a duration; use e.g. 10s or 1500ms');
+    });
+    it('reads days, durations and RFC 3339 times', () => {
+        const now = Date.UTC(2026, 9, 6, 12, 0, 0);
+        expect((0, params_1.parseSince)('', now)).toBeNull();
+        expect((0, params_1.parseSince)('2d', now)).toBe(now - 48 * 3600000);
+        expect((0, params_1.parseSince)('1.5d', now)).toBe(now - 36 * 3600000);
+        expect((0, params_1.parseSince)('30m', now)).toBe(now - 30 * 60000);
+        expect((0, params_1.parseSince)('-1h', now)).toBe(now + 3600000);
+        expect((0, params_1.parseSince)('2026-10-06T10:00:00Z', now)).toBe(now - 2 * 3600000);
+        expect((0, params_1.parseSince)('2026-10-06T12:00:00+02:00', now)).toBe(now - 2 * 3600000);
+        expect((0, params_1.parseSince)('2026-10-06T10:00:00.25Z', now)).toBe(now - 2 * 3600000 + 250);
+        expect(() => (0, params_1.parseSince)('yesterday', now)).toThrow('cannot read since="yesterday"; use e.g. 2h, 30m, 3d or an RFC 3339 time');
+    });
+    it('parses RFC 3339 like Go', () => {
+        expect((0, params_1.parseRFC3339)('1970-01-01T00:00:00Z')).toBe(0);
+        expect((0, params_1.parseRFC3339)('1969-12-31T23:59:59.5Z')).toBe(-500);
+        expect((0, params_1.parseRFC3339)('2026-10-06T1:02:03Z')).toBe(Date.UTC(2026, 9, 6, 1, 2, 3)); // one-digit hour
+        expect((0, params_1.parseRFC3339)('2024-02-29T00:00:00Z')).toBe(Date.UTC(2024, 1, 29));
+        for (const bad of ['2026-02-29T00:00:00Z', '2026-10-06 12:00:00Z', '2026-10-06T24:00:00Z', '2026-10-06T12:00:00', '2026-10-06t12:00:00z', '26-10-06T12:00:00Z']) {
+            expect([bad, (0, params_1.parseRFC3339)(bad)]).toEqual([bad, null]);
+        }
+    });
+});
+describe('Go number parsing', () => {
+    it('parses durations like time.ParseDuration', () => {
+        const ms = 1000000n;
+        const cases = [
+            ['0', 0n],
+            ['-0', 0n],
+            ['+5s', 5000n * ms],
+            ['1h30m', 5400000n * ms],
+            ['1500ms', 1500n * ms],
+            ['2.5s', 2500n * ms],
+            ['.5s', 500n * ms],
+            ['5.s', 5000n * ms],
+            ['1.5h', 5400000n * ms],
+            ['-1.5h', -5400000n * ms],
+            ['3us', 3000n],
+            ['3' + ch(0xb5) + 's', 3000n],
+            ['3' + ch(0x3bc) + 's', 3000n],
+            ['9223372036854775807ns', 9223372036854775807n],
+            ['-9223372036854775808ns', -9223372036854775808n],
+            ['9223372036854775808ns', null],
+            ['', null],
+            ['-', null],
+            ['1', null],
+            ['1x', null],
+            ['1h 30m', null],
+            ['.s', null],
+            ['1d', null],
+        ];
+        for (const [input, want] of cases)
+            expect([input, (0, params_1.parseDuration)(input)]).toEqual([input, want]);
+    });
+    it('parses floats like strconv.ParseFloat', () => {
+        const cases = [
+            ['1', 1],
+            ['1.', 1],
+            ['.5', 0.5],
+            ['-2.5e3', -2500],
+            ['1_000.5', 1000.5],
+            ['0x1p4', 16],
+            ['0x1.8p1', 3],
+            ['inf', Infinity],
+            ['-Infinity', -Infinity],
+            ['1e400', null],
+            ['0x10', null],
+            ['_1', null],
+            ['1__0', null],
+            ['+nan', null],
+            ['', null],
+            [' 1', null],
+            ['0b101', null],
+        ];
+        for (const [input, want] of cases)
+            expect([input, (0, params_1.parseFloat64)(input)]).toEqual([input, want]);
+        expect((0, params_1.parseFloat64)('NaN')).toBeNaN();
+        expect([(0, params_1.atoi)('+42'), (0, params_1.atoi)('-7'), (0, params_1.atoi)('4_2'), (0, params_1.atoi)('9223372036854775808'), (0, params_1.atoi)('')]).toEqual([42, -7, null, null, null]);
+    });
+});
+describe('statusMatcher', () => {
+    it('matches statuses like the Go server', () => {
+        const cases = [
+            ['failed', 500, false, true],
+            ['failed', 0, true, true],
+            ['failed', 200, false, false],
+            ['5xx', 503, false, true],
+            ['5XX', 404, false, false],
+            ['>=400', 404, false, true],
+            ['>= 400', 399, false, false],
+            ['<500', 0, true, false],
+            ['<500', 200, false, true],
+            ['=204', 204, false, true],
+            ['404', 404, false, true],
+            ['error', 0, true, true],
+            ['error', 500, false, false],
+            ['', 0, false, true],
+        ];
+        for (const [filter, status, err, want] of cases)
+            expect([filter, status, err, (0, params_1.statusMatcher)(filter)(status, err)]).toEqual([filter, status, err, want]);
+        expect(() => (0, params_1.statusMatcher)('>=abc')).toThrow('cannot read status=">=abc"; use e.g. 500, 5xx, >=400, failed');
+    });
+});
+describe('Go text helpers', () => {
+    it('quotes like strconv.Quote', () => {
+        const bs = '\\';
+        expect((0, gofmt_1.goQuote)('Acme "Shop"')).toBe('"Acme ' + bs + '"Shop' + bs + '""');
+        expect((0, gofmt_1.goQuote)('a' + bs + 'b\n\t' + ch(7) + ch(0))).toBe('"a' + bs + bs + 'b' + bs + 'n' + bs + 't' + bs + 'a' + bs + 'x00"');
+        expect((0, gofmt_1.goQuote)('Ünïcode 😀')).toBe('"Ünïcode 😀"');
+        expect((0, gofmt_1.goQuote)(ch(0xa0) + ch(0x200b))).toBe('"' + bs + 'u00a0' + bs + 'u200b"');
+        expect((0, gofmt_1.goQuote)(ch(0xd800))).toBe('"' + ch(0xfffd) + '"');
+        expect((0, gofmt_1.goQuote)('')).toBe('""');
+    });
+    it('pads, trims and lowers like Go', () => {
+        expect((0, gofmt_1.padRight)('click', 9)).toBe('click    ');
+        expect((0, gofmt_1.padRight)('çğ', 4)).toBe('çğ  ');
+        expect((0, gofmt_1.padRight)('toolongkind', 9)).toBe('toolongkind');
+        expect((0, gofmt_1.runeCount)('😀a')).toBe(2);
+        expect((0, gofmt_1.goTrimSpace)(ch(0x85) + ' x ' + ch(0x3000))).toBe('x');
+        expect((0, gofmt_1.goTrimSpace)(ch(0xfeff) + 'x')).toBe(ch(0xfeff) + 'x');
+        expect((0, gofmt_1.goToLower)(ch(0x130) + 'STANBUL')).toBe('istanbul');
+        expect((0, gofmt_1.goToLower)('ΟΔΟΣ')).toBe('οδοσ');
+    });
+    it('formats times in a zone like Go', () => {
+        const t0 = 1759650432000; // 2025-10-05 07:47:12 UTC
+        expect((0, gofmt_1.formatRFC3339)(t0, 'UTC')).toBe('2025-10-05T07:47:12Z');
+        expect((0, gofmt_1.formatRFC3339)(t0 + 999, 'Europe/Istanbul')).toBe('2025-10-05T10:47:12+03:00');
+        expect((0, gofmt_1.formatRFC3339)(t0, 'America/New_York')).toBe('2025-10-05T03:47:12-04:00');
+        expect((0, gofmt_1.formatRFC3339)(t0, 'Asia/Kolkata')).toBe('2025-10-05T13:17:12+05:30');
+        expect((0, gofmt_1.rfc3339DateTime)((0, gofmt_1.formatRFC3339)(t0, 'America/New_York'))).toBe('2025-10-05 03:47:12');
+        expect((0, gofmt_1.formatStamp)(t0, 'UTC')).toBe('Oct 5 07:47');
+        expect((0, gofmt_1.formatStamp)(t0 + 17 * 3600000, 'UTC')).toBe('Oct 6 00:47');
+    });
+});

package/daemon/dist/tabtape/mcp/recordLink.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRecordLink = getRecordLink;
+/**
+ * get_record_link hands out record links (see the /tabtape/record page):
+ * the start link carries the daemon's record token, which the extension
+ * checks before it records.
+ */
+const gofmt_1 = require("./gofmt");
+function getRecordLink(opts, input) {
+    if (opts.recordToken === '')
+        throw new Error('record links are turned off in this Repoburg daemon');
+    const target = (0, gofmt_1.goTrimSpace)(input.url);
+    if (target !== '' && !recordableURL(target)) {
+        throw new Error(`url ${(0, gofmt_1.goQuote)(target)}: only http, https and file pages can be recorded`);
+    }
+    const start = [['token', opts.recordToken]];
+    const name = (0, gofmt_1.goTrimSpace)(input.name);
+    if (name !== '')
+        start.push(['name', name]);
+    if (target !== '')
+        start.push(['url', target]);
+    const out = {
+        start: `${opts.baseURL}/record?${encodeValues(start)}`,
+        stop: `${opts.baseURL}/record/stop?${encodeValues([['token', opts.recordToken]])}`,
+    };
+    let b = 'Open the start link in the browser to record (with Playwright MCP: browser_navigate). The tabtape extension must be loaded in that browser.\n\n';
+    b += `Start: ${out.start}\n`;
+    if (target !== '') {
+        b += `The tab then opens ${target} and is recorded from its first request.`;
+    }
+    else {
+        b += 'The tab then says "Recording <session id>": open the page to test in that tab, it is recorded from its first request.';
+    }
+    b += ' If the tab stays on the start page ("Nothing happened" after 5 s), the extension is not loaded there and nothing is recorded.\n\n';
+    b += `Stop: ${out.stop}\n`;
+    b +=
+        'Open it in the same browser when you are done: the page names the session id and links the replay, for the user and for get_session_summary. Closing the tab also stops the recording.\n\n';
+    b += 'One recording runs at a time per browser: a new start link ends the previous one. The links stop working when the Repoburg daemon restarts.';
+    return { text: b, out };
+}
+/** Go's url.QueryEscape: only letters, digits and -_.~ stay; a space becomes "+". */
+function queryEscape(s) {
+    return encodeURIComponent((0, gofmt_1.wellFormed)(s))
+        .replace(/[!'()*]/g, (c) => '%' + c.charCodeAt(0).toString(16).toUpperCase())
+        .replace(/%20/g, '+');
+}
+/** Go's url.Values.Encode: sorted by key. */
+function encodeValues(values) {
+    return values
+        .slice()
+        .sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))
+        .map(([k, v]) => `${queryEscape(k)}=${queryEscape(v)}`)
+        .join('&');
+}
+const RECORDABLE = new Set(['http', 'https', 'file']);
+const BAD_ESCAPE = /%(?![0-9A-Fa-f]{2})/;
+/** ASCII that Go's url.Parse rejects in a host. */
+const BAD_HOST_CHAR = /[ \\^`{|}]/;
+/** Go's url.getScheme: the scheme, "" when there is none, or null for a leading colon. */
+function getScheme(raw) {
+    for (let i = 0; i < raw.length; i++) {
+        const c = raw[i];
+        if ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
+            continue;
+        if ((c >= '0' && c <= '9') || c === '+' || c === '-' || c === '.') {
+            if (i === 0)
+                return { scheme: '', rest: raw };
+            continue;
+        }
+        if (c === ':')
+            return i === 0 ? null : { scheme: raw.slice(0, i), rest: raw.slice(i + 1) };
+        return { scheme: '', rest: raw };
+    }
+    return { scheme: '', rest: raw };
+}
+/** Go's validOptionalPort. */
+function validPort(port) {
+    return port === '' || /^:\d*$/.test(port);
+}
+/**
+ * Whether target is an http, https or file URL that Go's url.Parse accepts.
+ * The syntax checks cover control characters, percent escapes, ports, IPv6
+ * brackets and the characters a host cannot contain.
+ */
+function recordableURL(target) {
+    for (let i = 0; i < target.length; i++) {
+        const c = target.charCodeAt(i);
+        if (c < 0x20 || c === 0x7f)
+            return false;
+    }
+    const hash = target.indexOf('#');
+    const u = hash < 0 ? target : target.slice(0, hash);
+    if (hash >= 0 && BAD_ESCAPE.test(target.slice(hash + 1)))
+        return false;
+    const parsed = getScheme(u);
+    if (!parsed || !RECORDABLE.has(parsed.scheme.toLowerCase()))
+        return false;
+    let rest = parsed.rest;
+    const q = rest.indexOf('?');
+    if (q >= 0)
+        rest = rest.slice(0, q);
+    if (rest.startsWith('//')) {
+        const slash = rest.indexOf('/', 2);
+        const authority = slash < 0 ? rest.slice(2) : rest.slice(2, slash);
+        rest = slash < 0 ? '' : rest.slice(slash);
+        const host = authority.slice(authority.lastIndexOf('@') + 1);
+        if (BAD_HOST_CHAR.test(host) || BAD_ESCAPE.test(host))
+            return false;
+        if (host.startsWith('[')) {
+            const end = host.indexOf(']');
+            if (end < 0 || !validPort(host.slice(end + 1)))
+                return false;
+        }
+        else {
+            const colon = host.lastIndexOf(':');
+            if (colon >= 0 && !validPort(host.slice(colon)))
+                return false;
+        }
+    }
+    return !BAD_ESCAPE.test(rest);
+}