publishport-opencli 1.8.5-pp.2 → 1.8.5-pp.21

package/dist/src/browser/find.test.js

@@ -1,180 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { JSDOM } from 'jsdom';
-import { buildFindJs, buildSemanticFindJs, FIND_ATTR_WHITELIST, isFindError } from './find.js';
-/**
- * These tests validate the shape and options of the generated JS string
- * (no DOM available in the default vitest unit env). Runtime behavior of
- * the generated JS against a real DOM is covered by the browser e2e suite.
- */
-describe('buildFindJs', () => {
-    it('produces syntactically valid JS that can be parsed', () => {
-        expect(() => new Function(`return (${buildFindJs('.btn')});`)).not.toThrow();
-    });
-    it('embeds the selector via JSON.stringify (injection-safe)', () => {
-        const js = buildFindJs('[data-x="a\"b"]');
-        // Unescaped literal break-out must not appear
-        expect(js).not.toContain('[data-x="a"b"]');
-        // The JSON-encoded form (with escaped quotes) should
-        expect(js).toContain(JSON.stringify('[data-x="a\"b"]'));
-    });
-    it('emits invalid_selector + selector_not_found branches', () => {
-        const js = buildFindJs('.btn');
-        expect(js).toContain("code: 'invalid_selector'");
-        expect(js).toContain("code: 'selector_not_found'");
-    });
-    it('emits matches_n + entries + per-entry shape', () => {
-        const js = buildFindJs('.btn');
-        expect(js).toContain('matches_n: matches.length');
-        expect(js).toContain('entries.push(');
-        // Per-entry keys reviewers signed off on: nth, ref, tag, role, text, attrs, visible
-        expect(js).toContain('nth: i');
-        expect(js).toContain('ref: refNum');
-        expect(js).toContain('tag: el.tagName.toLowerCase()');
-        expect(js).toContain("el.getAttribute('role')");
-        expect(js).toContain('visible: isVisible(el)');
-    });
-    it('allocates fresh refs for untagged matches (write attribute + identity map)', () => {
-        const js = buildFindJs('.btn');
-        // On the just-annotated branch we must flip the attribute on the element
-        // so downstream `browser click <ref>` works off the find output.
-        expect(js).toContain("el.setAttribute('data-opencli-ref'");
-        // The fingerprint must also land in the shared identity map so the
-        // target resolver's stale-ref check has data to verify against.
-        expect(js).toContain('__opencli_ref_identity');
-        expect(js).toContain("identity['' + refNum] = fingerprintOf(el)");
-        // Allocation walks both the identity map and any existing data-opencli-ref
-        // annotations — guards against collisions after a soft nav.
-        expect(js).toContain("document.querySelectorAll('[data-opencli-ref]')");
-    });
-    it('fingerprint shape matches the snapshot / resolver contract', () => {
-        const js = buildFindJs('.btn');
-        // The six fields resolveTargetJs verifies in its stale_ref check.
-        for (const field of ['tag:', 'role:', 'text:', 'ariaLabel:', 'id:', 'testId:']) {
-            expect(js).toContain(field);
-        }
-    });
-    it('embeds defaults for limit and textMax', () => {
-        const js = buildFindJs('.btn');
-        expect(js).toContain('LIMIT = 50');
-        expect(js).toContain('TEXT_MAX = 120');
-    });
-    it('overrides limit and textMax when requested', () => {
-        const js = buildFindJs('.btn', { limit: 3, textMax: 20 });
-        expect(js).toContain('LIMIT = 3');
-        expect(js).toContain('TEXT_MAX = 20');
-    });
-    it('embeds the attribute whitelist verbatim (no style/onclick leaking)', () => {
-        const js = buildFindJs('.btn');
-        // Whitelist fields appear inside the generated JS
-        for (const key of FIND_ATTR_WHITELIST) {
-            expect(js).toContain(`"${key}"`);
-        }
-        // Sensitive / high-noise attrs must stay out of the whitelist
-        expect(FIND_ATTR_WHITELIST).not.toContain('style');
-        expect(FIND_ATTR_WHITELIST).not.toContain('onclick');
-        expect(FIND_ATTR_WHITELIST).not.toContain('onload');
-    });
-    it('inlines compoundInfoOf and attaches compound field per entry', () => {
-        const js = buildFindJs('input, select');
-        // Helper definition is inlined so each matched element can be classified.
-        expect(js).toContain('function compoundInfoOf(el)');
-        // The emitted entry opts in only when compound data is present — no noisy
-        // compound: null on every non-form element.
-        expect(js).toContain('const compound = compoundInfoOf(el);');
-        expect(js).toContain('if (compound) entry.compound = compound;');
-        // Spot-check all three compound families are covered in the inlined helper.
-        expect(js).toContain("'YYYY-MM-DD'");
-        expect(js).toContain("control: 'file'");
-        expect(js).toContain("control: 'select'");
-    });
-    it('keeps the whitelist small and explicit (guardrail against silent expansion)', () => {
-        expect(FIND_ATTR_WHITELIST).toEqual([
-            'id',
-            'class',
-            'name',
-            'type',
-            'placeholder',
-            'aria-label',
-            'title',
-            'href',
-            'value',
-            'role',
-            'data-testid',
-        ]);
-    });
-});
-describe('isFindError', () => {
-    it('narrows { error: ... } as FindError', () => {
-        const payload = { error: { code: 'invalid_selector', message: 'x' } };
-        expect(isFindError(payload)).toBe(true);
-        if (isFindError(payload)) {
-            const err = payload;
-            expect(err.error.code).toBe('invalid_selector');
-        }
-    });
-    it('rejects successful envelopes', () => {
-        expect(isFindError({ matches_n: 0, entries: [] })).toBe(false);
-        expect(isFindError(null)).toBe(false);
-        expect(isFindError(undefined)).toBe(false);
-        expect(isFindError('string')).toBe(false);
-    });
-});
-describe('buildSemanticFindJs', () => {
-    function runSemanticFind(html, opts) {
-        const dom = new JSDOM(html, { runScripts: 'outside-only' });
-        return {
-            dom,
-            result: dom.window.eval(buildSemanticFindJs(opts)),
-        };
-    }
-    it('produces syntactically valid JS and embeds semantic criteria safely', () => {
-        const js = buildSemanticFindJs({ role: 'button', name: 'Save "now"', testid: 'submit' });
-        expect(() => new Function(`return (${js});`)).not.toThrow();
-        expect(js).toContain(JSON.stringify({
-            role: 'button',
-            name: 'Save "now"',
-            label: '',
-            text: '',
-            testid: 'submit',
-        }));
-    });
-    it('matches native roles, accessible name, labels, text, and test ids', () => {
-        const js = buildSemanticFindJs({ role: 'button', name: 'Save', label: 'Category', text: 'Travel', testid: 'category' });
-        expect(js).toContain('function nativeRole(el)');
-        expect(js).toContain('function accessibleName(el)');
-        expect(js).toContain('function labelText(el)');
-        expect(js).toContain('CRITERIA.role');
-        expect(js).toContain('CRITERIA.name');
-        expect(js).toContain('CRITERIA.label');
-        expect(js).toContain('CRITERIA.text');
-        expect(js).toContain('CRITERIA.testid');
-    });
-    it('allocates refs exactly like CSS find so downstream actions can click them', () => {
-        const js = buildSemanticFindJs({ role: 'button', name: 'Save' });
-        expect(js).toContain("el.setAttribute('data-opencli-ref'");
-        expect(js).toContain('__opencli_ref_identity');
-        expect(js).toContain("identity['' + refNum] = fingerprintOf(el)");
-        expect(js).toContain("document.querySelectorAll('[data-opencli-ref]')");
-    });
-    it('executes semantic role/name/testid matching and allocates a clickable ref', () => {
-        const { dom, result } = runSemanticFind('<button aria-label="Save expense" data-testid="save-button">Ignored copy</button>', { role: 'button', name: 'Save', testid: 'save' });
-        expect(result).toMatchObject({
-            matches_n: 1,
-            entries: [
-                { nth: 0, ref: 1, tag: 'button', role: 'button', attrs: { 'aria-label': 'Save expense', 'data-testid': 'save-button' } },
-            ],
-        });
-        const button = dom.window.document.querySelector('button');
-        expect(button.getAttribute('data-opencli-ref')).toBe('1');
-        expect(dom.window.__opencli_ref_identity['1']).toMatchObject({ tag: 'button', ariaLabel: 'Save expense' });
-    });
-    it('matches associated labels and placeholders for form controls', () => {
-        const { result } = runSemanticFind('<label for="category">Category</label><input id="category" placeholder="Expense category" value="Travel" />', { role: 'textbox', label: 'Category', name: 'Expense category' });
-        expect(result).toMatchObject({
-            matches_n: 1,
-            entries: [
-                { nth: 0, ref: 1, tag: 'input', role: 'textbox' },
-            ],
-        });
-    });
-});

package/dist/src/browser/html-tree.test.js

@@ -1,181 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildHtmlTreeJs } from './html-tree.js';
-/**
- * The serializer runs in a page context via `page.evaluate`. In unit tests we
- * substitute `document` with a minimal stub that mirrors the DOM surface used
- * by the expression, then Function-eval the returned JS.
- */
-function runTreeJs(root, selectorMatches, selector, budgets = {}) {
-    const js = buildHtmlTreeJs({ selector, ...budgets });
-    const fakeDocument = {
-        querySelectorAll: () => selectorMatches,
-        documentElement: root,
-    };
-    const fn = new Function('document', `return ${js};`);
-    return fn(fakeDocument);
-}
-function runTreeJsInvalid(selector, errorMessage) {
-    const js = buildHtmlTreeJs({ selector });
-    const fakeDocument = {
-        querySelectorAll: () => { const e = new Error(errorMessage); e.name = 'SyntaxError'; throw e; },
-        documentElement: null,
-    };
-    const fn = new Function('document', `return ${js};`);
-    return fn(fakeDocument);
-}
-function el(tag, attrs, children, extras = {}) {
-    return {
-        nodeType: 1,
-        tagName: tag.toUpperCase(),
-        attributes: Object.entries(attrs).map(([name, value]) => ({ name, value })),
-        childNodes: children,
-        getAttribute: (name) => (name in attrs ? attrs[name] : null),
-        value: extras.value,
-        multiple: extras.multiple,
-        files: extras.files,
-        options: extras.options,
-    };
-}
-function txt(value) { return { nodeType: 3, nodeValue: value }; }
-describe('buildHtmlTreeJs', () => {
-    it('serializes a simple element into {tag, attrs, text, children}', () => {
-        const root = el('div', { class: 'hero', id: 'x' }, [txt('Hello')]);
-        const result = runTreeJs(root, [root], null);
-        expect(result.selector).toBeNull();
-        expect(result.matched).toBe(1);
-        expect(result.tree).toEqual({
-            tag: 'div',
-            attrs: { class: 'hero', id: 'x' },
-            text: 'Hello',
-            children: [],
-        });
-    });
-    it('collapses whitespace in direct text content only', () => {
-        const root = el('p', {}, [
-            txt('  line  \n  one  '),
-            el('span', {}, [txt('inner text')]),
-            txt('\tline two\t'),
-        ]);
-        const result = runTreeJs(root, [root], null);
-        expect(result.tree?.text).toBe('line one line two');
-        expect(result.tree?.children[0].text).toBe('inner text');
-    });
-    it('recurses into element children and preserves their attrs', () => {
-        const root = el('ul', { role: 'list' }, [
-            el('li', { 'data-id': '1' }, [txt('first')]),
-            el('li', { 'data-id': '2' }, [txt('second')]),
-        ]);
-        const result = runTreeJs(root, [root], null);
-        expect(result.tree?.children).toHaveLength(2);
-        expect(result.tree?.children[0]).toEqual({
-            tag: 'li',
-            attrs: { 'data-id': '1' },
-            text: 'first',
-            children: [],
-        });
-    });
-    it('returns matched=N and serializes only the first match', () => {
-        const first = el('article', { id: 'a' }, [txt('first')]);
-        const second = el('article', { id: 'b' }, [txt('second')]);
-        const result = runTreeJs(null, [first, second], 'article');
-        expect(result.matched).toBe(2);
-        expect(result.tree?.attrs.id).toBe('a');
-    });
-    it('returns tree=null and matched=0 when selector matches nothing', () => {
-        const result = runTreeJs(null, [], '.nothing');
-        expect(result.matched).toBe(0);
-        expect(result.tree).toBeNull();
-    });
-    it('catches SyntaxError from querySelectorAll and returns {invalidSelector:true, reason}', () => {
-        const result = runTreeJsInvalid('##$@@', "'##$@@' is not a valid selector");
-        expect(result.invalidSelector).toBe(true);
-        expect(result.selector).toBe('##$@@');
-        expect(result.reason).toContain('not a valid selector');
-    });
-    it('omits `truncated` when no budget is hit', () => {
-        const root = el('div', {}, [el('span', {}, [txt('ok')])]);
-        const result = runTreeJs(root, [root], null, { depth: 5, childrenMax: 10, textMax: 100 });
-        expect(result.truncated).toBeUndefined();
-    });
-});
-describe('buildHtmlTreeJs budget knobs', () => {
-    it('caps tree at `depth` and reports truncated.depth', () => {
-        const deep = el('a', {}, [
-            el('b', {}, [
-                el('c', {}, [el('d', {}, [txt('deep')])]),
-            ]),
-        ]);
-        // depth=1 → root + one level of children; grandchildren should be dropped.
-        const result = runTreeJs(deep, [deep], null, { depth: 1 });
-        expect(result.tree?.tag).toBe('a');
-        expect(result.tree?.children).toHaveLength(1);
-        expect(result.tree?.children[0].tag).toBe('b');
-        // The "b" node had element children but we hit the depth budget before
-        // recursing into them — children array is empty, truncated.depth is true.
-        expect(result.tree?.children[0].children).toEqual([]);
-        expect(result.truncated?.depth).toBe(true);
-    });
-    it('depth=0 keeps only the root', () => {
-        const root = el('ul', {}, [
-            el('li', {}, [txt('a')]),
-            el('li', {}, [txt('b')]),
-        ]);
-        const result = runTreeJs(root, [root], null, { depth: 0 });
-        expect(result.tree?.children).toEqual([]);
-        expect(result.truncated?.depth).toBe(true);
-    });
-    it('caps children per node at `childrenMax` and reports children_dropped count', () => {
-        const root = el('ul', {}, [
-            el('li', {}, [txt('1')]),
-            el('li', {}, [txt('2')]),
-            el('li', {}, [txt('3')]),
-            el('li', {}, [txt('4')]),
-            el('li', {}, [txt('5')]),
-        ]);
-        const result = runTreeJs(root, [root], null, { childrenMax: 2 });
-        expect(result.tree?.children).toHaveLength(2);
-        expect(result.truncated?.children_dropped).toBe(3);
-    });
-    it('caps direct text per node at `textMax` and reports text_truncated count', () => {
-        const root = el('p', {}, [
-            txt('a'.repeat(50)),
-            el('span', {}, [txt('b'.repeat(50))]),
-        ]);
-        const result = runTreeJs(root, [root], null, { textMax: 10 });
-        expect(result.tree?.text).toHaveLength(10);
-        expect(result.tree?.children[0].text).toHaveLength(10);
-        expect(result.truncated?.text_truncated).toBe(2);
-    });
-    // Blocker B regression: compound contract must ride along with the
-    // json tree so `browser get html --as json` surfaces the full contract
-    // to agents without an extra round-trip.
-    it('attaches compound info to date/file/select nodes and omits it elsewhere', () => {
-        const date = el('input', { type: 'date', min: '2026-01-01' }, [], { value: '2026-04-21' });
-        const file = el('input', { type: 'file', accept: 'image/*' }, [], { multiple: true, files: [{ name: 'a.png' }] });
-        const sel = el('select', { name: 'country' }, [], {
-            options: [
-                { value: 'us', label: 'United States', selected: true },
-                { value: 'ca', label: 'Canada' },
-            ],
-        });
-        const plain = el('input', { type: 'text' }, [], { value: 'hi' });
-        const root = el('form', {}, [date, file, sel, plain]);
-        const result = runTreeJs(root, [root], null);
-        expect(result.tree?.children[0].compound).toMatchObject({ control: 'date', format: 'YYYY-MM-DD', current: '2026-04-21', min: '2026-01-01' });
-        expect(result.tree?.children[1].compound).toMatchObject({ control: 'file', multiple: true, current: ['a.png'], accept: 'image/*' });
-        expect(result.tree?.children[2].compound).toMatchObject({ control: 'select', multiple: false, current: 'United States' });
-        expect(result.tree?.children[3].compound).toBeUndefined();
-    });
-    it('combines budgets and reports every hit', () => {
-        const root = el('ul', {}, [
-            el('li', {}, [txt('x'.repeat(20)), el('em', {}, [txt('y')])]),
-            el('li', {}, []),
-            el('li', {}, []),
-        ]);
-        const result = runTreeJs(root, [root], null, { depth: 1, childrenMax: 2, textMax: 5 });
-        expect(result.tree?.children).toHaveLength(2);
-        expect(result.truncated?.children_dropped).toBe(1);
-        expect(result.truncated?.text_truncated).toBe(1);
-        expect(result.truncated?.depth).toBe(true);
-    });
-});

package/dist/src/browser/network-cache.test.js

@@ -1,75 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { DEFAULT_TTL_MS, findEntry, getCachePath, loadNetworkCache, saveNetworkCache, } from './network-cache.js';
-function makeEntry(key, body = { ok: true }) {
-    return { key, url: `https://x.com/${key}`, method: 'GET', status: 200, size: 2, ct: 'application/json', body };
-}
-describe('network-cache', () => {
-    let baseDir;
-    beforeEach(() => {
-        baseDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opencli-netcache-'));
-    });
-    afterEach(() => {
-        fs.rmSync(baseDir, { recursive: true, force: true });
-    });
-    it('sanitizes session names into safe filenames', () => {
-        const p = getCachePath('twitter/agent 1', baseDir);
-        expect(path.basename(p)).toBe('twitter_agent_1.json');
-    });
-    it('round-trips entries through save + load', () => {
-        saveNetworkCache('ws', [makeEntry('UserTweets'), makeEntry('UserByScreenName')], baseDir);
-        const res = loadNetworkCache('ws', { baseDir });
-        expect(res.status).toBe('ok');
-        expect(res.file?.entries).toHaveLength(2);
-        expect(res.file?.entries[0].key).toBe('UserTweets');
-    });
-    it('reports missing when cache file does not exist', () => {
-        expect(loadNetworkCache('nope', { baseDir }).status).toBe('missing');
-    });
-    it('reports expired when the cache is older than ttl', () => {
-        saveNetworkCache('ws', [makeEntry('A')], baseDir);
-        const future = Date.now() + DEFAULT_TTL_MS + 60_000;
-        const res = loadNetworkCache('ws', { baseDir, now: future });
-        expect(res.status).toBe('expired');
-        expect(res.file?.entries).toHaveLength(1);
-    });
-    it('reports corrupt for malformed json', () => {
-        const file = getCachePath('ws', baseDir);
-        fs.mkdirSync(path.dirname(file), { recursive: true });
-        fs.writeFileSync(file, '{not json');
-        expect(loadNetworkCache('ws', { baseDir }).status).toBe('corrupt');
-    });
-    it('reports corrupt for wrong schema version', () => {
-        const file = getCachePath('ws', baseDir);
-        fs.mkdirSync(path.dirname(file), { recursive: true });
-        fs.writeFileSync(file, JSON.stringify({ version: 0, entries: [] }));
-        expect(loadNetworkCache('ws', { baseDir }).status).toBe('corrupt');
-    });
-    it('findEntry returns matching entry or null', () => {
-        const file = {
-            version: 1, session: 'ws', savedAt: new Date().toISOString(),
-            entries: [makeEntry('A'), makeEntry('B')],
-        };
-        expect(findEntry(file, 'B')?.key).toBe('B');
-        expect(findEntry(file, 'missing')).toBeNull();
-    });
-    it.skipIf(process.platform === 'win32')('writes the cache file with 0o600 owner-only permissions', () => {
-        saveNetworkCache('ws', [makeEntry('UserTweets')], baseDir);
-        const target = getCachePath('ws', baseDir);
-        const mode = fs.statSync(target).mode & 0o777;
-        expect(mode).toBe(0o600);
-    });
-    it.skipIf(process.platform === 'win32')('tightens an existing cache file before rewriting it', () => {
-        const target = getCachePath('ws', baseDir);
-        fs.mkdirSync(path.dirname(target), { recursive: true });
-        fs.writeFileSync(target, '{"version":1,"session":"ws","savedAt":"old","entries":[]}', { mode: 0o644 });
-        saveNetworkCache('ws', [makeEntry('UserTweets')], baseDir);
-        const mode = fs.statSync(target).mode & 0o777;
-        expect(mode).toBe(0o600);
-        const reloaded = loadNetworkCache('ws', { baseDir });
-        expect(reloaded.status).toBe('ok');
-        expect(reloaded.file?.entries[0].key).toBe('UserTweets');
-    });
-});

package/dist/src/browser/network-key.test.js

@@ -1,49 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { assignKeys, deriveKey } from './network-key.js';
-describe('deriveKey', () => {
-    it('extracts operationName from Twitter-style graphql URLs', () => {
-        expect(deriveKey({
-            method: 'GET',
-            url: 'https://x.com/i/api/graphql/6fWQaBPK51aGyC_VC7t9GQ/UserTweets?variables=...',
-        })).toBe('UserTweets');
-    });
-    it('handles graphql URLs without a query id', () => {
-        expect(deriveKey({
-            method: 'POST',
-            url: 'https://example.com/graphql/MyOp?vars=1',
-        })).toBe('MyOp');
-    });
-    it('uses METHOD host+pathname for REST calls', () => {
-        expect(deriveKey({
-            method: 'get',
-            url: 'https://api.example.com/v1/users?page=1',
-        })).toBe('GET api.example.com/v1/users');
-    });
-    it('falls back to truncated raw url when URL parsing fails', () => {
-        const key = deriveKey({ method: 'GET', url: 'not-a-valid-url' });
-        expect(key.startsWith('GET ')).toBe(true);
-        expect(key).toContain('not-a-valid-url');
-    });
-});
-describe('assignKeys', () => {
-    it('disambiguates collisions with #N suffixes', () => {
-        const out = assignKeys([
-            { url: 'https://x.com/i/api/graphql/a/UserTweets', method: 'GET' },
-            { url: 'https://x.com/i/api/graphql/b/UserTweets', method: 'GET' },
-            { url: 'https://api.example.com/v1/u', method: 'GET' },
-            { url: 'https://api.example.com/v1/u', method: 'GET' },
-            { url: 'https://api.example.com/v1/u', method: 'GET' },
-        ]);
-        expect(out.map(o => o.key)).toEqual([
-            'UserTweets',
-            'UserTweets#2',
-            'GET api.example.com/v1/u',
-            'GET api.example.com/v1/u#2',
-            'GET api.example.com/v1/u#3',
-        ]);
-    });
-    it('preserves extra fields on each request', () => {
-        const out = assignKeys([{ url: 'https://a.com/x', method: 'GET', status: 200 }]);
-        expect(out[0]).toMatchObject({ status: 200, key: 'GET a.com/x' });
-    });
-});