@wenrwa/marketplace-cli 0.4.6 → 0.5.0-lws.0

package/dist/__tests__/bridge-agent-launch.test.d.ts

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

package/dist/__tests__/bridge-agent-launch.test.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const agentLaunch_1 = require("../bridge/agentLaunch");
+/**
+ * TDD — lws-06: pure decision of what the bridge spawns for an agent-scoped
+ * PTY (ADR-0035 D4). `claude`, never $SHELL — autonomous maps to
+ * --dangerously-skip-permissions ONLY when the agent opts in; default OFF.
+ *
+ * lws-08 (PRD D9) — every agent-scoped launch also carries a minimal env
+ * pointer at `.hiveop/context.md` (relative to the spawn cwd, the project
+ * root). This is the ONLY mechanism used to point a spawned `claude` at the
+ * manifest: no args, no stdin injection, no CLAUDE.md edit. `claude` itself
+ * doesn't read this var natively today — it exists so the context file's
+ * location is a documented, stable contract other tooling (a future MCP
+ * resource, a slash command, a system-prompt append) can rely on instead of
+ * hardcoding the path, and so a human/agent inspecting `env` in the PTY can
+ * discover it. Deliberately NOT wired into --append-system-prompt or similar
+ * — keeping this additive-only avoids coupling the launch decision to
+ * `claude` CLI flag churn.
+ */
+describe('resolveAgentLaunch (lws-06)', () => {
+    it('defaults to a bare `claude` invocation (autonomous OFF)', () => {
+        expect((0, agentLaunch_1.resolveAgentLaunch)({ autonomous: false })).toEqual({
+            command: 'claude',
+            args: [],
+            env: { [agentLaunch_1.HIVEOP_CONTEXT_ENV_VAR]: agentLaunch_1.HIVEOP_CONTEXT_ENV_VALUE },
+        });
+    });
+    it('an agent-scoped launch with autonomous unset also defaults OFF', () => {
+        expect((0, agentLaunch_1.resolveAgentLaunch)({})).toEqual({
+            command: 'claude',
+            args: [],
+            env: { [agentLaunch_1.HIVEOP_CONTEXT_ENV_VAR]: agentLaunch_1.HIVEOP_CONTEXT_ENV_VALUE },
+        });
+    });
+    it('autonomous:true maps to --dangerously-skip-permissions', () => {
+        expect((0, agentLaunch_1.resolveAgentLaunch)({ autonomous: true })).toEqual({
+            command: 'claude',
+            args: ['--dangerously-skip-permissions'],
+            env: { [agentLaunch_1.HIVEOP_CONTEXT_ENV_VAR]: agentLaunch_1.HIVEOP_CONTEXT_ENV_VALUE },
+        });
+    });
+    it('the context env var always points at the relative .hiveop/context.md path', () => {
+        expect(agentLaunch_1.HIVEOP_CONTEXT_ENV_VALUE).toBe('.hiveop/context.md');
+        expect((0, agentLaunch_1.resolveAgentLaunch)({}).env).toEqual({ HIVEOP_CONTEXT_FILE: '.hiveop/context.md' });
+    });
+});

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

@@ -210,6 +210,71 @@ describe('createBrowserDriver (cbs-02)', () => {
         expect(calls[0].params).toEqual({ text: 'hunter2' });
         expect(calls[0].sessionId).toBe('sess-1');
     });
+    // Live bug fix: Page.startScreencast only emits Page.screencastFrame on
+    // an actual repaint, so an idle/already-loaded page (or a pane that
+    // reattaches to one) gets nothing new. refresh() is the forcing
+    // function: re-emit whatever we last delivered, then restart the
+    // screencast so Chromium produces a genuinely fresh frame.
+    describe('refresh()', () => {
+        it('re-emits the cached last-delivered frame synchronously', async () => {
+            const { driver, endpoint } = setup({ existingPageTargetId: 't1' });
+            const frames = [];
+            driver.onFrame((f) => frames.push(f));
+            await driver.start('https://example.com');
+            endpoint.emitEvent('Page.screencastFrame', { data: 'first', sessionId: 1, metadata: {} }, 'sess-1');
+            expect(frames.map((f) => f.data)).toEqual(['first']);
+            void driver.refresh();
+            // The cached frame is re-emitted synchronously, before any CDP
+            // round-trip for the forced-fresh frame completes.
+            expect(frames.map((f) => f.data)).toEqual(['first', 'first']);
+        });
+        it('restarts the screencast (stopScreencast then startScreencast, same params) on the attached session', async () => {
+            const { driver, endpoint } = setup({ existingPageTargetId: 't1' });
+            await driver.start('https://example.com');
+            endpoint.sent.length = 0;
+            await driver.refresh();
+            const methods = endpoint.sent.map((m) => m.method);
+            expect(methods).toEqual(['Page.stopScreencast', 'Page.startScreencast']);
+            const stop = endpoint.sentCalls('Page.stopScreencast')[0];
+            expect(stop.sessionId).toBe('sess-1');
+            expect(stop.params).toEqual({});
+            const start = endpoint.sentCalls('Page.startScreencast')[0];
+            expect(start.sessionId).toBe('sess-1');
+            expect(start.params).toEqual({ format: 'jpeg', quality: 60, maxWidth: 1280, maxHeight: 800 });
+        });
+        it('a restarted screencast delivers the forced-fresh frame through onFrame once Chromium emits it', async () => {
+            const { driver, endpoint } = setup({ existingPageTargetId: 't1' });
+            const frames = [];
+            driver.onFrame((f) => frames.push(f));
+            await driver.start('https://example.com');
+            endpoint.emitEvent('Page.screencastFrame', { data: 'stale', sessionId: 1, metadata: {} }, 'sess-1');
+            await driver.refresh();
+            endpoint.emitEvent('Page.screencastFrame', { data: 'fresh', sessionId: 2, metadata: {} }, 'sess-1');
+            expect(frames.map((f) => f.data)).toEqual(['stale', 'stale', 'fresh']);
+        });
+        it('called before start() resolves is a safe no-op (nothing cached, no session to restart)', async () => {
+            const { driver } = setup({ existingPageTargetId: 't1' });
+            await expect(driver.refresh()).resolves.toBeUndefined();
+        });
+        it('un-wedges a pacer stuck on a previous consumer\'s unacked frame, so the next pushed frame delivers immediately', async () => {
+            const { driver, endpoint } = setup({ existingPageTargetId: 't1' });
+            const frames = [];
+            driver.onFrame((f) => frames.push(f));
+            await driver.start('https://example.com');
+            // One frame lands and is delivered; nobody ever acks it (the pane
+            // that received it is gone) and — matching the real idle-page bug —
+            // nothing further is pushed, so nothing is queued behind it either.
+            // The pacer is left permanently "awaitingAck" with no live consumer.
+            endpoint.emitEvent('Page.screencastFrame', { data: 'stale', sessionId: 1, metadata: {} }, 'sess-1');
+            expect(frames.map((f) => f.data)).toEqual(['stale']);
+            await driver.refresh();
+            // A newly (re)attached pane must see the next captured frame land
+            // immediately — WITHOUT anyone having called ackFrame() — instead of
+            // it silently queuing behind a phantom ack that will never come.
+            endpoint.emitEvent('Page.screencastFrame', { data: 'new-attach-frame', sessionId: 2, metadata: {} }, 'sess-1');
+            expect(frames[frames.length - 1].data).toBe('new-attach-frame');
+        });
+    });
     it('navigate(url) after start sends Page.navigate again on the attached target session', async () => {
         const { driver, endpoint } = setup({ existingPageTargetId: 't1' });
         await driver.start('https://example.com');

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

@@ -31,6 +31,7 @@ const makeFactory = () => ({ spawn: (o) => new FakePty(o) });
 class FakeBrowserDriver {
     startCalls = [];
     navigateCalls = [];
+    refreshCalls = 0;
     inputCalls = [];
     stopCalls = 0;
     sleepCalls = [];
@@ -43,6 +44,9 @@ class FakeBrowserDriver {
     async navigate(url) {
         this.navigateCalls.push(url);
     }
+    async refresh() {
+        this.refreshCalls += 1;
+    }
     input(event) {
         this.inputCalls.push(event);
     }
@@ -208,6 +212,72 @@ describe('relay client — browser-open/browser-input (cbs-02)', () => {
         expect(drivers).toHaveLength(1);
         expect(drivers[0].startCalls).toEqual(['https://example.com']);
         expect(drivers[0].navigateCalls).toEqual(['https://example.com/other']);
+        expect(drivers[0].refreshCalls).toBe(0);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    // Live bug fix: a pane that closes and reopens the Browser view for the
+    // SAME session/url is a reattach, not a navigation — navigate()-ing an
+    // already-loaded page is a correct-but-useless no-visible-effect call
+    // (see browserDriver's refresh() doc comment for why). refresh() is what
+    // actually gets the returning pane a frame.
+    it('browser-open on an already-open session with the SAME url calls refresh(), not navigate()', async () => {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        const drivers = [];
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            createBrowserDriver: () => {
+                const d = new FakeBrowserDriver();
+                drivers.push(d);
+                return d;
+            },
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c1', url: 'https://example.com' }));
+        await new Promise((r) => setTimeout(r, 20));
+        // Reattach: same sessionId, same url.
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c1', url: 'https://example.com' }));
+        await new Promise((r) => setTimeout(r, 20));
+        expect(drivers).toHaveLength(1);
+        expect(drivers[0].startCalls).toEqual(['https://example.com']);
+        expect(drivers[0].navigateCalls).toEqual([]);
+        expect(drivers[0].refreshCalls).toBe(1);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    // A url change after a same-url reattach must still navigate — refresh()
+    // is only for the no-op-navigation case.
+    it('browser-open with a DIFFERENT url after a same-url reattach still navigates', async () => {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        const drivers = [];
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            createBrowserDriver: () => {
+                const d = new FakeBrowserDriver();
+                drivers.push(d);
+                return d;
+            },
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c1', url: 'https://example.com' }));
+        await new Promise((r) => setTimeout(r, 20));
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c1', url: 'https://example.com' })); // reattach
+        await new Promise((r) => setTimeout(r, 20));
+        ws.send(JSON.stringify({ t: 'browser-open', sessionId: 'browser:c1', url: 'https://example.com/other' })); // real nav
+        await new Promise((r) => setTimeout(r, 20));
+        expect(drivers).toHaveLength(1);
+        expect(drivers[0].refreshCalls).toBe(1);
+        expect(drivers[0].navigateCalls).toEqual(['https://example.com/other']);
         handle.close();
         await closeRelay(relay.wss);
     });

package/dist/__tests__/bridge-cdp-transport-race.test.d.ts

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

package/dist/__tests__/bridge-cdp-transport-race.test.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const browserDriver_1 = require("../bridge/browserDriver");
+/**
+ * Regression test for the first-light hang: the driver sends its first CDP
+ * command (Target.getTargets) the moment the transport is constructed, while
+ * the DevTools socket is still CONNECTING. The original transport dropped
+ * anything sent before OPEN, so that command never reached Chromium and
+ * start() hung forever with no error. Frames never flowed.
+ *
+ * The real `ws` path is otherwise untested by design (mocks are injected at
+ * wsFactory), which is exactly why the bug survived to production — so this
+ * test drives a fake WebSocket through the real transport instead.
+ */
+class FakeSocket {
+    url;
+    static CONNECTING = 0;
+    static OPEN = 1;
+    static CLOSING = 2;
+    static CLOSED = 3;
+    readyState = FakeSocket.CONNECTING;
+    sent = [];
+    handlers = new Map();
+    constructor(url) {
+        this.url = url;
+    }
+    send(d) { this.sent.push(d); }
+    close() { this.readyState = FakeSocket.CLOSED; }
+    on(event, cb) {
+        const set = this.handlers.get(event) ?? [];
+        set.push(cb);
+        this.handlers.set(event, set);
+    }
+    /** simulate the socket finishing its handshake */
+    fireOpen() {
+        this.readyState = FakeSocket.OPEN;
+        for (const cb of this.handlers.get('open') ?? [])
+            cb();
+    }
+}
+// The transport reads OPEN/CONNECTING off the constructor it is given.
+function makeTransport() {
+    let created;
+    class Tracked extends FakeSocket {
+        constructor(url) { super(url); created = this; }
+    }
+    const transport = (0, browserDriver_1.createDefaultTransport)('ws://127.0.0.1:1/devtools/browser/x', Tracked);
+    return { transport, socket: created };
+}
+describe('CDP default transport — connect race', () => {
+    it('buffers a command sent while CONNECTING and flushes it on open', () => {
+        const { transport, socket } = makeTransport();
+        transport.send('{"id":1,"method":"Target.getTargets"}');
+        expect(socket.sent).toEqual([]); // still connecting — must NOT be lost
+        socket.fireOpen();
+        expect(socket.sent).toEqual(['{"id":1,"method":"Target.getTargets"}']);
+    });
+    it('preserves order across the open boundary', () => {
+        const { transport, socket } = makeTransport();
+        transport.send('a');
+        transport.send('b');
+        socket.fireOpen();
+        transport.send('c');
+        expect(socket.sent).toEqual(['a', 'b', 'c']);
+    });
+    it('sends straight through once open', () => {
+        const { transport, socket } = makeTransport();
+        socket.fireOpen();
+        transport.send('x');
+        expect(socket.sent).toEqual(['x']);
+    });
+    it('drops (without throwing) once the socket is closed', () => {
+        const { transport, socket } = makeTransport();
+        socket.fireOpen();
+        socket.close();
+        expect(() => transport.send('late')).not.toThrow();
+        expect(socket.sent).toEqual([]);
+    });
+});

package/dist/__tests__/bridge-dev-server-detect.test.d.ts

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

package/dist/__tests__/bridge-dev-server-detect.test.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * TDD — lws-08 (PRD D7 nice-to-have): pure dev-server-banner matcher over
+ * agent PTY output. Table-driven per common framework so the false-positive
+ * surface stays small (a bare "listening on" fallback would false-trigger on
+ * ordinary chatter); every framework line must ALSO resolve to a
+ * localhost/127.0.0.1/0.0.0.0/[::1] URL, since that is the whole point
+ * (offer a Browser pane at a port on THIS machine).
+ */
+const devServerDetect_1 = require("../bridge/devServerDetect");
+describe('matchDevServerLine — per-framework banner table', () => {
+    it('Next.js — "- Local:        http://localhost:3000"', () => {
+        expect((0, devServerDetect_1.matchDevServerLine)('   - Local:        http://localhost:3000')).toEqual({
+            framework: 'Next.js', port: 3000, url: 'http://localhost:3000',
+        });
+    });
+    it('Vite — "➜  Local:   http://localhost:5173/"', () => {
+        expect((0, devServerDetect_1.matchDevServerLine)('  ➜  Local:   http://localhost:5173/')).toEqual({
+            framework: 'Vite', port: 5173, url: 'http://localhost:5173/',
+        });
+    });
+    it('Create React App — "Local:            http://localhost:3000"', () => {
+        expect((0, devServerDetect_1.matchDevServerLine)('You can now view app in the browser.\n  Local:            http://localhost:3000')).toEqual({
+            framework: 'CRA', port: 3000, url: 'http://localhost:3000',
+        });
+    });
+    it('Rails/Puma — "Listening on http://127.0.0.1:3000"', () => {
+        expect((0, devServerDetect_1.matchDevServerLine)('* Listening on http://127.0.0.1:3000')).toEqual({
+            framework: 'Rails', port: 3000, url: 'http://127.0.0.1:3000',
+        });
+    });
+    it('Django — "Starting development server at http://127.0.0.1:8000/"', () => {
+        expect((0, devServerDetect_1.matchDevServerLine)('Starting development server at http://127.0.0.1:8000/')).toEqual({
+            framework: 'Django', port: 8000, url: 'http://127.0.0.1:8000/',
+        });
+    });
+    it('generic fallback — "Server ready on http://localhost:4000"', () => {
+        expect((0, devServerDetect_1.matchDevServerLine)('Server ready on http://localhost:4000')).toEqual({
+            framework: 'generic', port: 4000, url: 'http://localhost:4000',
+        });
+    });
+    it('generic fallback — "App listening on 0.0.0.0:8080"', () => {
+        expect((0, devServerDetect_1.matchDevServerLine)('App listening on 0.0.0.0:8080')).toEqual({
+            framework: 'generic', port: 8080, url: 'http://0.0.0.0:8080',
+        });
+    });
+    it('strips ANSI color codes before matching', () => {
+        const line = '\x1b[32m  - Local:\x1b[39m        \x1b[1mhttp://localhost:3000\x1b[22m';
+        expect((0, devServerDetect_1.matchDevServerLine)(line)).toEqual({ framework: 'Next.js', port: 3000, url: 'http://localhost:3000' });
+    });
+    it('a non-localhost URL never matches (the point is offering a pane on THIS machine)', () => {
+        expect((0, devServerDetect_1.matchDevServerLine)('- Local:  http://example.com:3000')).toBeNull();
+    });
+    it('no false positives on ordinary agent chatter', () => {
+        expect((0, devServerDetect_1.matchDevServerLine)('Running tests...')).toBeNull();
+        expect((0, devServerDetect_1.matchDevServerLine)('$ npm install')).toBeNull();
+        expect((0, devServerDetect_1.matchDevServerLine)('Reading file src/index.ts')).toBeNull();
+        expect((0, devServerDetect_1.matchDevServerLine)('I will now start the server for you.')).toBeNull();
+        expect((0, devServerDetect_1.matchDevServerLine)('See http://localhost:3000 for more info in the README')).toBeNull();
+        expect((0, devServerDetect_1.matchDevServerLine)('')).toBeNull();
+    });
+});
+describe('createDevServerWatcher — feed(chunk), dedupe/debounce per session', () => {
+    it('emits a match once a full banner line arrives', () => {
+        const w = (0, devServerDetect_1.createDevServerWatcher)();
+        const matches = w.feed('some output\n- Local:  http://localhost:3000\nmore output\n');
+        expect(matches).toEqual([{ framework: 'Next.js', port: 3000, url: 'http://localhost:3000' }]);
+    });
+    it('dedupes — the same port is never emitted twice for one watcher instance', () => {
+        const w = (0, devServerDetect_1.createDevServerWatcher)();
+        expect(w.feed('- Local:  http://localhost:3000\n')).toHaveLength(1);
+        expect(w.feed('- Local:  http://localhost:3000\n')).toHaveLength(0);
+        // Even framed differently (Vite banner, same port) — still a dupe on port.
+        expect(w.feed('➜  Local:  http://localhost:3000/\n')).toHaveLength(0);
+    });
+    it('emits separately for genuinely different ports', () => {
+        const w = (0, devServerDetect_1.createDevServerWatcher)();
+        expect(w.feed('- Local:  http://localhost:3000\n')).toHaveLength(1);
+        expect(w.feed('- Local:  http://localhost:5173\n')).toEqual([
+            { framework: 'Next.js', port: 5173, url: 'http://localhost:5173' },
+        ]);
+    });
+    it('handles a banner split across two chunks (buffers the incomplete line)', () => {
+        const w = (0, devServerDetect_1.createDevServerWatcher)();
+        expect(w.feed('- Local:  http://localhost:')).toHaveLength(0);
+        expect(w.feed('3000\n')).toEqual([{ framework: 'Next.js', port: 3000, url: 'http://localhost:3000' }]);
+    });
+    it('no false positives from a burst of ordinary PTY output', () => {
+        const w = (0, devServerDetect_1.createDevServerWatcher)();
+        const chunk = ['$ npm install', 'added 200 packages', '$ npm run build', 'Compiled successfully.'].join('\n');
+        expect(w.feed(chunk)).toHaveLength(0);
+    });
+});

package/dist/__tests__/bridge-fail-fast.test.d.ts

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