@wenrwa/marketplace-cli 0.4.5 → 0.4.6

package/dist/__tests__/bridge-browser-frames.test.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * cbs-01 — v1 cloud browser session frame protocol (types + guards only).
+ *
+ * These are the pane<->container frame shapes for streaming a headless
+ * Chromium session (docs/prd/cloud-browser-session.md). This slice defines
+ * the shapes and runtime type guards ONLY — no relay/backend wiring, no CDP
+ * driver. See cli/src/bridge/browserFrames.ts for the contract doc block.
+ */
+const browserFrames_1 = require("../bridge/browserFrames");
+describe('browser frame protocol v1 — type guards (cbs-01)', () => {
+    it('pins the protocol version', () => {
+        expect(browserFrames_1.BROWSER_FRAME_PROTOCOL_VERSION).toBe(1);
+    });
+    describe('browser-open (pane -> container)', () => {
+        it('accepts a valid frame', () => {
+            const frame = { t: 'browser-open', sessionId: 'browser:c-1', url: 'https://example.com' };
+            expect((0, browserFrames_1.isBrowserOpenFrame)(frame)).toBe(true);
+            expect((0, browserFrames_1.isBrowserFrame)(frame)).toBe(true);
+        });
+        it('rejects wrong t, missing sessionId, missing/non-string url', () => {
+            expect((0, browserFrames_1.isBrowserOpenFrame)({ t: 'browser-input', sessionId: 'x', url: 'https://x' })).toBe(false);
+            expect((0, browserFrames_1.isBrowserOpenFrame)({ t: 'browser-open', url: 'https://x' })).toBe(false);
+            expect((0, browserFrames_1.isBrowserOpenFrame)({ t: 'browser-open', sessionId: 'x' })).toBe(false);
+            expect((0, browserFrames_1.isBrowserOpenFrame)({ t: 'browser-open', sessionId: 'x', url: 42 })).toBe(false);
+            expect((0, browserFrames_1.isBrowserOpenFrame)(null)).toBe(false);
+            expect((0, browserFrames_1.isBrowserOpenFrame)('nope')).toBe(false);
+            expect((0, browserFrames_1.isBrowserOpenFrame)(undefined)).toBe(false);
+        });
+    });
+    describe('browser-input (pane -> container) — event discriminated union', () => {
+        it('accepts a mouse event', () => {
+            const frame = {
+                t: 'browser-input',
+                sessionId: 'browser:c-1',
+                event: { kind: 'mouse', type: 'down', x: 10, y: 20, button: 'left', modifiers: { shift: true } },
+            };
+            expect((0, browserFrames_1.isBrowserInputFrame)(frame)).toBe(true);
+            expect((0, browserFrames_1.isBrowserInputEvent)(frame.event)).toBe(true);
+        });
+        it('accepts a mouse move without button/modifiers (both optional)', () => {
+            const event = { kind: 'mouse', type: 'move', x: 1, y: 2 };
+            expect((0, browserFrames_1.isBrowserInputEvent)(event)).toBe(true);
+        });
+        it('rejects a mouse event with a bad button or non-numeric coords', () => {
+            expect((0, browserFrames_1.isBrowserInputEvent)({ kind: 'mouse', type: 'down', x: '1', y: 2 })).toBe(false);
+            expect((0, browserFrames_1.isBrowserInputEvent)({ kind: 'mouse', type: 'down', x: 1, y: 2, button: 'nope' })).toBe(false);
+            expect((0, browserFrames_1.isBrowserInputEvent)({ kind: 'mouse', type: 'sideways', x: 1, y: 2 })).toBe(false);
+        });
+        it('accepts a key event', () => {
+            const event = { kind: 'key', type: 'down', key: 'a', code: 'KeyA', modifiers: { ctrl: true } };
+            expect((0, browserFrames_1.isBrowserInputEvent)(event)).toBe(true);
+        });
+        it('rejects a key event missing key/code or bad type', () => {
+            expect((0, browserFrames_1.isBrowserInputEvent)({ kind: 'key', type: 'down', code: 'KeyA' })).toBe(false);
+            expect((0, browserFrames_1.isBrowserInputEvent)({ kind: 'key', type: 'down', key: 'a' })).toBe(false);
+            expect((0, browserFrames_1.isBrowserInputEvent)({ kind: 'key', type: 'held', key: 'a', code: 'KeyA' })).toBe(false);
+        });
+        it('accepts an insertText event', () => {
+            expect((0, browserFrames_1.isBrowserInputEvent)({ kind: 'insertText', text: 'hunter2' })).toBe(true);
+        });
+        it('rejects an insertText event with a non-string text', () => {
+            expect((0, browserFrames_1.isBrowserInputEvent)({ kind: 'insertText', text: 5 })).toBe(false);
+            expect((0, browserFrames_1.isBrowserInputEvent)({ kind: 'insertText' })).toBe(false);
+        });
+        it('accepts a wheel event', () => {
+            expect((0, browserFrames_1.isBrowserInputEvent)({ kind: 'wheel', x: 1, y: 2, deltaX: 0, deltaY: 12.5 })).toBe(true);
+        });
+        it('rejects a wheel event with a missing delta', () => {
+            expect((0, browserFrames_1.isBrowserInputEvent)({ kind: 'wheel', x: 1, y: 2, deltaX: 0 })).toBe(false);
+        });
+        it('rejects an unknown event kind', () => {
+            expect((0, browserFrames_1.isBrowserInputEvent)({ kind: 'gesture', x: 1, y: 2 })).toBe(false);
+            expect((0, browserFrames_1.isBrowserInputEvent)(null)).toBe(false);
+            expect((0, browserFrames_1.isBrowserInputEvent)({})).toBe(false);
+        });
+        it('rejects a browser-input frame with an invalid event or missing sessionId', () => {
+            expect((0, browserFrames_1.isBrowserInputFrame)({ t: 'browser-input', sessionId: 'x', event: { kind: 'bogus' } })).toBe(false);
+            expect((0, browserFrames_1.isBrowserInputFrame)({ t: 'browser-input', event: { kind: 'insertText', text: 'a' } })).toBe(false);
+            expect((0, browserFrames_1.isBrowserInputFrame)({ t: 'browser-open', sessionId: 'x', event: { kind: 'insertText', text: 'a' } })).toBe(false);
+        });
+    });
+    describe('browser-frame (container -> pane) — JPEG screencast frame', () => {
+        it('accepts a valid frame', () => {
+            const frame = { t: 'browser-frame', sessionId: 'browser:c-1', seq: 42, data: 'YmFzZTY0', w: 1280, h: 720 };
+            expect((0, browserFrames_1.isBrowserScreenFrame)(frame)).toBe(true);
+            expect((0, browserFrames_1.isBrowserFrame)(frame)).toBe(true);
+        });
+        it('rejects a non-numeric seq/w/h or non-string data', () => {
+            expect((0, browserFrames_1.isBrowserScreenFrame)({ t: 'browser-frame', sessionId: 'x', seq: '1', data: 'a', w: 1, h: 1 })).toBe(false);
+            expect((0, browserFrames_1.isBrowserScreenFrame)({ t: 'browser-frame', sessionId: 'x', seq: 1, data: 1, w: 1, h: 1 })).toBe(false);
+            expect((0, browserFrames_1.isBrowserScreenFrame)({ t: 'browser-frame', sessionId: 'x', seq: 1, data: 'a', w: -1, h: 1 })).toBe(false);
+            expect((0, browserFrames_1.isBrowserScreenFrame)({ t: 'browser-frame', sessionId: 'x', seq: -1, data: 'a', w: 1, h: 1 })).toBe(false);
+        });
+    });
+    describe('browser-state (container -> pane)', () => {
+        it('accepts every valid state value', () => {
+            for (const state of ['opening', 'open', 'asleep', 'closed']) {
+                expect((0, browserFrames_1.isBrowserStateFrame)({ t: 'browser-state', sessionId: 'browser:c-1', state })).toBe(true);
+            }
+        });
+        it('accepts optional url/title/reason', () => {
+            const frame = {
+                t: 'browser-state',
+                sessionId: 'browser:c-1',
+                state: 'open',
+                url: 'https://example.com',
+                title: 'Example',
+                reason: undefined,
+            };
+            expect((0, browserFrames_1.isBrowserStateFrame)(frame)).toBe(true);
+            expect((0, browserFrames_1.isBrowserStateFrame)({ t: 'browser-state', sessionId: 'x', state: 'closed', reason: 'idle-timeout' })).toBe(true);
+        });
+        it('rejects an invalid state value', () => {
+            expect((0, browserFrames_1.isBrowserStateFrame)({ t: 'browser-state', sessionId: 'x', state: 'sleeping' })).toBe(false);
+            expect((0, browserFrames_1.isBrowserStateFrame)({ t: 'browser-state', sessionId: 'x' })).toBe(false);
+        });
+    });
+    // cbs-06 — CLI mirror of arena's cbs-05 addition (lib/browserFrames.ts on
+    // arena master). The pane's keep-newest ack contract needs a frame shape
+    // cbs-01 didn't define; this pins the CLI side to the EXACT same shape so
+    // the two repos' hand-maintained mirrors don't drift.
+    describe('browser-frame-ack (pane -> container) — cbs-06 mirror of arena cbs-05', () => {
+        it('accepts a valid frame', () => {
+            const frame = { t: 'browser-frame-ack', sessionId: 'browser:c-1', seq: 3 };
+            expect((0, browserFrames_1.isBrowserFrameAckFrame)(frame)).toBe(true);
+            expect((0, browserFrames_1.isBrowserFrame)(frame)).toBe(true);
+        });
+        it('rejects wrong t, missing sessionId, missing/non-number seq', () => {
+            expect((0, browserFrames_1.isBrowserFrameAckFrame)({ t: 'browser-frame', sessionId: 'x', seq: 1 })).toBe(false);
+            expect((0, browserFrames_1.isBrowserFrameAckFrame)({ t: 'browser-frame-ack', seq: 1 })).toBe(false);
+            expect((0, browserFrames_1.isBrowserFrameAckFrame)({ t: 'browser-frame-ack', sessionId: 'x' })).toBe(false);
+            expect((0, browserFrames_1.isBrowserFrameAckFrame)({ t: 'browser-frame-ack', sessionId: 'x', seq: '1' })).toBe(false);
+            expect((0, browserFrames_1.isBrowserFrameAckFrame)(null)).toBe(false);
+        });
+        it('accepts seq: 0 (a valid monotonic starting point)', () => {
+            expect((0, browserFrames_1.isBrowserFrameAckFrame)({ t: 'browser-frame-ack', sessionId: 'x', seq: 0 })).toBe(true);
+        });
+        it('rejects a negative seq', () => {
+            expect((0, browserFrames_1.isBrowserFrameAckFrame)({ t: 'browser-frame-ack', sessionId: 'x', seq: -1 })).toBe(false);
+        });
+    });
+    // cbs-06 — CLI mirror of arena's cbs-05 addition. The pane's explicit 💤
+    // sleep control needs a minimal control frame cbs-01 didn't define.
+    describe('browser-sleep (pane -> container) — cbs-06 mirror of arena cbs-05', () => {
+        it('accepts a valid frame (no payload beyond identity)', () => {
+            const frame = { t: 'browser-sleep', sessionId: 'browser:c-1' };
+            expect((0, browserFrames_1.isBrowserSleepFrame)(frame)).toBe(true);
+            expect((0, browserFrames_1.isBrowserFrame)(frame)).toBe(true);
+        });
+        it('rejects wrong t and missing sessionId', () => {
+            expect((0, browserFrames_1.isBrowserSleepFrame)({ t: 'browser-open', sessionId: 'x' })).toBe(false);
+            expect((0, browserFrames_1.isBrowserSleepFrame)({ t: 'browser-sleep' })).toBe(false);
+            expect((0, browserFrames_1.isBrowserSleepFrame)(null)).toBe(false);
+        });
+    });
+    describe('isBrowserFrame — top-level discriminator', () => {
+        it('rejects frames with an unrelated or missing t', () => {
+            expect((0, browserFrames_1.isBrowserFrame)({ t: 'open', sessionId: 'x' })).toBe(false);
+            expect((0, browserFrames_1.isBrowserFrame)({ sessionId: 'x' })).toBe(false);
+            expect((0, browserFrames_1.isBrowserFrame)(null)).toBe(false);
+            expect((0, browserFrames_1.isBrowserFrame)(42)).toBe(false);
+        });
+    });
+});

package/dist/__tests__/bridge-browser-idle.test.d.ts

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

package/dist/__tests__/bridge-browser-idle.test.js

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * cbs-06 — browser idle timer (pure-ish, injectable clocks + interval).
+ *
+ * Tracks two liveness signals for a cloud browser session — last INPUT
+ * (browser-input frames) and last ACK (browser-frame-ack frames, a proxy
+ * for "someone is actually looking at the stream") — and fires onIdle()
+ * once BOTH have been stale past the threshold (PRD: 15 minutes), mirroring
+ * the container-level idle convention (container-lifecycle.service.ts:
+ * "Idle is (a) AND (b) both true; either signal alone is enough to stay
+ * awake").
+ *
+ * Suspend-safety (docs/prd/cloud-browser-session.md, issues/cbs-06): the
+ * container RAM-suspends when idle. A resume after hours must not insta-fire
+ * from a stale wall-clock delta. Every periodic check compares the WALL
+ * delta since the last check against the MONOTONIC delta — a suspend
+ * freezes CLOCK_MONOTONIC but not CLOCK_REALTIME, so a wall delta far
+ * exceeding the monotonic delta is the suspend's signature; the tracker
+ * resets its idle baseline instead of evaluating/firing that tick.
+ */
+const browserIdle_1 = require("../bridge/browserIdle");
+function fakeClocks(startMs = 1_000_000) {
+    let wall = startMs;
+    let mono = 0;
+    return {
+        nowFn: () => wall,
+        monotonicNowFn: () => mono,
+        advanceBoth(ms) {
+            wall += ms;
+            mono += ms;
+        },
+        /** Simulates a suspend: wall jumps by `ms`, monotonic barely moves. */
+        advanceWallOnly(ms, monoTickMs = 0) {
+            wall += ms;
+            mono += monoTickMs;
+        },
+    };
+}
+function fakeInterval() {
+    let cb = null;
+    let ms = null;
+    return {
+        setIntervalFn: (fn, intervalMs) => {
+            cb = fn;
+            ms = intervalMs;
+            return 'handle';
+        },
+        clearIntervalFn: () => {
+            cb = null;
+        },
+        tick: () => cb?.(),
+        intervalMs: () => ms,
+        isCancelled: () => cb === null,
+    };
+}
+describe('createBrowserIdleTracker (cbs-06)', () => {
+    it('pins the default threshold to 15 minutes', () => {
+        expect(browserIdle_1.DEFAULT_BROWSER_IDLE_THRESHOLD_MS).toBe(15 * 60_000);
+    });
+    it('does not fire before the threshold elapses on either signal', () => {
+        const clocks = fakeClocks();
+        const interval = fakeInterval();
+        const onIdle = jest.fn();
+        const tracker = (0, browserIdle_1.createBrowserIdleTracker)({
+            onIdle,
+            thresholdMs: 15 * 60_000,
+            checkIntervalMs: 30_000,
+            nowFn: clocks.nowFn,
+            monotonicNowFn: clocks.monotonicNowFn,
+            setIntervalFn: interval.setIntervalFn,
+            clearIntervalFn: interval.clearIntervalFn,
+        });
+        tracker.start();
+        clocks.advanceBoth(14 * 60_000);
+        interval.tick();
+        expect(onIdle).not.toHaveBeenCalled();
+    });
+    it('fires onIdle once BOTH lastInputAt and lastAckAt are stale past the threshold', () => {
+        const clocks = fakeClocks();
+        const interval = fakeInterval();
+        const onIdle = jest.fn();
+        const tracker = (0, browserIdle_1.createBrowserIdleTracker)({
+            onIdle,
+            thresholdMs: 15 * 60_000,
+            checkIntervalMs: 30_000,
+            nowFn: clocks.nowFn,
+            monotonicNowFn: clocks.monotonicNowFn,
+            setIntervalFn: interval.setIntervalFn,
+            clearIntervalFn: interval.clearIntervalFn,
+        });
+        tracker.start();
+        clocks.advanceBoth(15 * 60_000 + 1);
+        interval.tick();
+        expect(onIdle).toHaveBeenCalledTimes(1);
+    });
+    it('either signal alone (recent input OR recent ack) keeps it awake', () => {
+        const clocks = fakeClocks();
+        const interval = fakeInterval();
+        const onIdle = jest.fn();
+        const tracker = (0, browserIdle_1.createBrowserIdleTracker)({
+            onIdle,
+            thresholdMs: 15 * 60_000,
+            checkIntervalMs: 30_000,
+            nowFn: clocks.nowFn,
+            monotonicNowFn: clocks.monotonicNowFn,
+            setIntervalFn: interval.setIntervalFn,
+            clearIntervalFn: interval.clearIntervalFn,
+        });
+        tracker.start();
+        // Input goes stale, but ack keeps arriving — someone is watching.
+        clocks.advanceBoth(10 * 60_000);
+        tracker.recordAck();
+        clocks.advanceBoth(10 * 60_000);
+        tracker.recordAck();
+        clocks.advanceBoth(10 * 60_000);
+        interval.tick();
+        expect(onIdle).not.toHaveBeenCalled(); // ack signal alone: 10min stale, not 15
+        // Now let ack go stale too, past the threshold from its last bump.
+        clocks.advanceBoth(15 * 60_000 + 1);
+        interval.tick();
+        expect(onIdle).toHaveBeenCalledTimes(1);
+    });
+    it('recordInput() resets the input baseline independent of the ack baseline', () => {
+        const clocks = fakeClocks();
+        const interval = fakeInterval();
+        const onIdle = jest.fn();
+        const tracker = (0, browserIdle_1.createBrowserIdleTracker)({
+            onIdle,
+            thresholdMs: 15 * 60_000,
+            checkIntervalMs: 30_000,
+            nowFn: clocks.nowFn,
+            monotonicNowFn: clocks.monotonicNowFn,
+            setIntervalFn: interval.setIntervalFn,
+            clearIntervalFn: interval.clearIntervalFn,
+        });
+        tracker.start();
+        clocks.advanceBoth(10 * 60_000);
+        tracker.recordInput();
+        clocks.advanceBoth(10 * 60_000);
+        interval.tick();
+        expect(onIdle).not.toHaveBeenCalled(); // input reset 10min ago, ack 20min ago -> input signal keeps it awake
+        clocks.advanceBoth(5 * 60_000 + 1);
+        interval.tick();
+        expect(onIdle).toHaveBeenCalledTimes(1);
+    });
+    it('a suspend-sized wall/monotonic gap resets the idle baseline instead of firing', () => {
+        const clocks = fakeClocks();
+        const interval = fakeInterval();
+        const onIdle = jest.fn();
+        const tracker = (0, browserIdle_1.createBrowserIdleTracker)({
+            onIdle,
+            thresholdMs: 15 * 60_000,
+            checkIntervalMs: 30_000,
+            suspendGapToleranceMs: 5_000,
+            nowFn: clocks.nowFn,
+            monotonicNowFn: clocks.monotonicNowFn,
+            setIntervalFn: interval.setIntervalFn,
+            clearIntervalFn: interval.clearIntervalFn,
+        });
+        tracker.start();
+        // Some real idle time accrues first (10 min, still under threshold).
+        clocks.advanceBoth(10 * 60_000);
+        interval.tick();
+        expect(onIdle).not.toHaveBeenCalled();
+        // Container suspends for 5 hours: wall jumps 5h, monotonic barely moves
+        // (a single ~30s tick's worth, simulating the resume tick).
+        clocks.advanceWallOnly(5 * 60 * 60_000, 30_000);
+        interval.tick();
+        // Must NOT fire — this is a suspend gap, not real idle time.
+        expect(onIdle).not.toHaveBeenCalled();
+        // Baseline was reset on resume: only a further NORMAL 30s has passed
+        // since the reset, nowhere near the 15-minute threshold.
+        clocks.advanceBoth(30_000);
+        interval.tick();
+        expect(onIdle).not.toHaveBeenCalled();
+        // But real elapsed time from the reset point DOES eventually fire.
+        clocks.advanceBoth(15 * 60_000);
+        interval.tick();
+        expect(onIdle).toHaveBeenCalledTimes(1);
+    });
+    it('normal small scheduling jitter (well within tolerance) is not mistaken for a suspend gap', () => {
+        const clocks = fakeClocks();
+        const interval = fakeInterval();
+        const onIdle = jest.fn();
+        const tracker = (0, browserIdle_1.createBrowserIdleTracker)({
+            onIdle,
+            thresholdMs: 15 * 60_000,
+            checkIntervalMs: 30_000,
+            suspendGapToleranceMs: 5_000,
+            nowFn: clocks.nowFn,
+            monotonicNowFn: clocks.monotonicNowFn,
+            setIntervalFn: interval.setIntervalFn,
+            clearIntervalFn: interval.clearIntervalFn,
+        });
+        tracker.start();
+        // 16 minutes of idle time accrued across ticks that each run a couple
+        // hundred ms "late" (wall slightly ahead of monotonic each tick, but
+        // always under the 5s tolerance) — must still fire normally.
+        for (let i = 0; i < 32; i++) {
+            clocks.advanceWallOnly(30_000 + 200, 30_000);
+            interval.tick();
+        }
+        expect(onIdle).toHaveBeenCalledTimes(1);
+    });
+    it('onIdle fires at most once (latched) even if further ticks arrive', () => {
+        const clocks = fakeClocks();
+        const interval = fakeInterval();
+        const onIdle = jest.fn();
+        const tracker = (0, browserIdle_1.createBrowserIdleTracker)({
+            onIdle,
+            thresholdMs: 15 * 60_000,
+            checkIntervalMs: 30_000,
+            nowFn: clocks.nowFn,
+            monotonicNowFn: clocks.monotonicNowFn,
+            setIntervalFn: interval.setIntervalFn,
+            clearIntervalFn: interval.clearIntervalFn,
+        });
+        tracker.start();
+        clocks.advanceBoth(16 * 60_000);
+        interval.tick();
+        interval.tick();
+        clocks.advanceBoth(60_000);
+        interval.tick();
+        expect(onIdle).toHaveBeenCalledTimes(1);
+    });
+    it('stop() cancels the interval', () => {
+        const clocks = fakeClocks();
+        const interval = fakeInterval();
+        const tracker = (0, browserIdle_1.createBrowserIdleTracker)({
+            onIdle: jest.fn(),
+            nowFn: clocks.nowFn,
+            monotonicNowFn: clocks.monotonicNowFn,
+            setIntervalFn: interval.setIntervalFn,
+            clearIntervalFn: interval.clearIntervalFn,
+        });
+        tracker.start();
+        expect(interval.isCancelled()).toBe(false);
+        tracker.stop();
+        expect(interval.isCancelled()).toBe(true);
+    });
+    it('start() is idempotent (calling twice does not double-register the interval)', () => {
+        const clocks = fakeClocks();
+        let registrations = 0;
+        const tracker = (0, browserIdle_1.createBrowserIdleTracker)({
+            onIdle: jest.fn(),
+            nowFn: clocks.nowFn,
+            monotonicNowFn: clocks.monotonicNowFn,
+            setIntervalFn: (fn) => {
+                registrations += 1;
+                return fn;
+            },
+            clearIntervalFn: () => { },
+        });
+        tracker.start();
+        tracker.start();
+        expect(registrations).toBe(1);
+    });
+});

package/dist/__tests__/bridge-browser-relay.test.d.ts

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