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

package/dist/__tests__/bridge-activity-parser.test.d.ts

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

package/dist/__tests__/bridge-activity-tap.test.d.ts

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

package/dist/__tests__/bridge-activity-tap.test.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * pucc-int-03 — the bridge's read-only PTY activity tap (ADR-0032).
+ *
+ * Proves the relay client observes Claude Code tool-use in the PTY output and
+ * emits a coalesced `activity` frame ({ filePaths, thinking }) to the relay —
+ * WITHOUT altering the `data` frames forwarded to the browser, and never on a
+ * parse miss. Same faked-PTY / fake-relay harness as bridge-relay-pucc14.test.
+ */
+const ws_1 = require("ws");
+const relayClient_1 = require("../bridge/relayClient");
+const sessionManager_1 = require("../bridge/sessionManager");
+const ESC = '\u001b'; // ESC byte
+class FakePty {
+    opts;
+    written = [];
+    killed = false;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    write(data) { this.written.push(data); }
+    resize() { }
+    kill() { this.killed = true; }
+    dataCb = null;
+    onData(cb) { this.dataCb = cb; }
+    onExit(_cb) { }
+    emitData(d) { this.dataCb?.(d); }
+}
+const makeFactory = () => {
+    const ptys = [];
+    const factory = { spawn: (o) => { const p = new FakePty(o); ptys.push(p); return p; } };
+    return { factory, ptys };
+};
+function collectFrames(ws) {
+    const frames = [];
+    ws.on('message', (raw) => frames.push(JSON.parse(String(raw))));
+    return frames;
+}
+function startFakeRelay() {
+    return new Promise((resolve) => {
+        const wss = new ws_1.WebSocketServer({ port: 0, host: '127.0.0.1' });
+        const queue = [];
+        const waiters = [];
+        wss.on('connection', (ws) => { const w = waiters.shift(); if (w)
+            w(ws);
+        else
+            queue.push(ws); });
+        wss.on('listening', () => {
+            const addr = wss.address();
+            const port = typeof addr === 'object' && addr ? addr.port : 0;
+            resolve({ wss, port, nextConnection: () => (queue.length > 0 ? Promise.resolve(queue.shift()) : new Promise((r) => waiters.push(r))) });
+        });
+    });
+}
+function closeRelay(wss) {
+    return new Promise((resolve, reject) => {
+        for (const client of wss.clients)
+            client.terminate();
+        wss.close((err) => (err ? reject(err) : resolve()));
+    });
+}
+const settle = () => new Promise((r) => setTimeout(r, 20));
+describe('bridge activity tap (pucc-int-03)', () => {
+    it('emits an activity frame with filePaths/thinking parsed from PTY output', async () => {
+        const relay = await startFakeRelay();
+        const { factory, ptys } = makeFactory();
+        const sessions = new sessionManager_1.SessionManager(factory);
+        // throttle 0 → emit immediately so the assertion is deterministic.
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`, relayToken: 'tok', sessions, activityThrottleMs: 0,
+        });
+        const ws = await relay.nextConnection();
+        const frames = collectFrames(ws);
+        ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, sessionId: 'agent-A' }));
+        await settle();
+        ptys[0].emitData(`${ESC}[1m⏺${ESC}[0m Edit(src/foo.ts)\r\n`);
+        await settle();
+        const activity = frames.find((f) => f.t === 'activity');
+        expect(activity).toMatchObject({ t: 'activity', sessionId: 'agent-A', filePaths: ['src/foo.ts'], thinking: 'Editing foo.ts' });
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('still forwards the raw data frame to the browser UNALTERED', async () => {
+        const relay = await startFakeRelay();
+        const { factory, ptys } = makeFactory();
+        const sessions = new sessionManager_1.SessionManager(factory);
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`, relayToken: 'tok', sessions, activityThrottleMs: 0,
+        });
+        const ws = await relay.nextConnection();
+        const frames = collectFrames(ws);
+        ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, sessionId: 'agent-A' }));
+        await settle();
+        const raw = `${ESC}[1m⏺${ESC}[0m Read(a.ts)\r\n`;
+        ptys[0].emitData(raw);
+        await settle();
+        // The data frame is byte-identical to the PTY output — the tap did not touch it.
+        const data = frames.find((f) => f.t === 'data');
+        expect(data).toEqual({ t: 'data', sessionId: 'agent-A', data: raw });
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('coalesces a burst of tool-use into a single throttled activity frame', async () => {
+        const relay = await startFakeRelay();
+        const { factory, ptys } = makeFactory();
+        const sessions = new sessionManager_1.SessionManager(factory);
+        let clock = 1000;
+        let scheduled = null;
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`, relayToken: 'tok', sessions,
+            activityThrottleMs: 1000,
+            nowFn: () => clock,
+            setTimeoutFn: (cb) => { scheduled = cb; return 1; },
+            clearTimeoutFn: () => { },
+        });
+        const ws = await relay.nextConnection();
+        const frames = collectFrames(ws);
+        ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, sessionId: 'agent-A' }));
+        await settle();
+        // First signal fires immediately (lastEmit=0, elapsed >= throttle).
+        ptys[0].emitData('⏺ Edit(one.ts)\n');
+        await settle();
+        // Two more within the SAME window are coalesced behind the timer, not sent.
+        ptys[0].emitData('⏺ Edit(two.ts)\n');
+        ptys[0].emitData('⏺ Read(three.ts)\n');
+        await settle();
+        let activities = frames.filter((f) => f.t === 'activity');
+        expect(activities).toHaveLength(1);
+        expect(activities[0].filePaths).toEqual(['one.ts']);
+        // Advance the clock and fire the pending flush → the coalesced batch emits.
+        clock += 1000;
+        scheduled();
+        await settle();
+        activities = frames.filter((f) => f.t === 'activity');
+        expect(activities).toHaveLength(2);
+        expect(activities[1].filePaths).toEqual(['two.ts', 'three.ts']);
+        expect(activities[1].thinking).toBe('Reading three.ts'); // latest thinking wins
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('a parse miss (ordinary output) emits NO activity frame', async () => {
+        const relay = await startFakeRelay();
+        const { factory, ptys } = makeFactory();
+        const sessions = new sessionManager_1.SessionManager(factory);
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`, relayToken: 'tok', sessions, activityThrottleMs: 0,
+        });
+        const ws = await relay.nextConnection();
+        const frames = collectFrames(ws);
+        ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, sessionId: 'agent-A' }));
+        await settle();
+        ptys[0].emitData('$ ls -la\r\ntotal 24\r\ndrwxr-xr-x  5 me  staff\r\n');
+        await settle();
+        expect(frames.some((f) => f.t === 'activity')).toBe(false);
+        expect(frames.some((f) => f.t === 'data')).toBe(true); // data still flowed
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('emitActivity:false disables the tap entirely (data still flows)', async () => {
+        const relay = await startFakeRelay();
+        const { factory, ptys } = makeFactory();
+        const sessions = new sessionManager_1.SessionManager(factory);
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`, relayToken: 'tok', sessions, emitActivity: false, activityThrottleMs: 0,
+        });
+        const ws = await relay.nextConnection();
+        const frames = collectFrames(ws);
+        ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, sessionId: 'agent-A' }));
+        await settle();
+        ptys[0].emitData('⏺ Edit(src/foo.ts)\n');
+        await settle();
+        expect(frames.some((f) => f.t === 'activity')).toBe(false);
+        expect(frames.some((f) => f.t === 'data')).toBe(true);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+});

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-api-client.test.d.ts

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

package/dist/__tests__/bridge-api-client.test.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * TDD — lws-03: bridge/apiClient.ts. A thin, injectable fetch wrapper the
+ * bridge daemon uses to talk to the backend AS ITSELF (Bearer Connect Token)
+ * — distinct from utils/client.ts, which authenticates the interactive CLI
+ * via the legacy X-Wallet-Pubkey login flow (~/.wen-market/config.json).
+ */
+const apiClient_1 = require("../bridge/apiClient");
+const OPTS = { apiUrl: 'https://api.x', connectToken: 'wm_ct_' + 'a'.repeat(64) };
+function fakeFetch(status, body) {
+    const fetchImpl = jest.fn().mockResolvedValue({
+        ok: status >= 200 && status < 300,
+        status,
+        json: async () => body,
+    });
+    return fetchImpl;
+}
+describe('bridge apiClient', () => {
+    it('registerDevice posts to /me/devices with the Bearer connect token', async () => {
+        const fetchImpl = fakeFetch(201, { success: true, device: { id: 'd1', name: 'bunny-mbp' } });
+        const result = await (0, apiClient_1.registerDevice)({ ...OPTS, fetchImpl }, 'bunny-mbp');
+        expect(result.device.id).toBe('d1');
+        const [url, init] = fetchImpl.mock.calls[0];
+        expect(url).toBe('https://api.x/me/devices');
+        expect(init.method).toBe('POST');
+        expect(init.headers.Authorization).toBe(`Bearer ${OPTS.connectToken}`);
+        expect(JSON.parse(init.body)).toEqual({ name: 'bunny-mbp' });
+    });
+    it('listDevices gets /me/devices', async () => {
+        const fetchImpl = fakeFetch(200, { success: true, devices: [{ id: 'd1' }] });
+        const result = await (0, apiClient_1.listDevices)({ ...OPTS, fetchImpl });
+        expect(result.devices).toHaveLength(1);
+        expect(fetchImpl.mock.calls[0][0]).toBe('https://api.x/me/devices');
+        expect(fetchImpl.mock.calls[0][1].method).toBe('GET');
+    });
+    it('revokeDevice deletes /me/devices/:id', async () => {
+        const fetchImpl = fakeFetch(200, { success: true });
+        await (0, apiClient_1.revokeDevice)({ ...OPTS, fetchImpl }, 'd1');
+        expect(fetchImpl.mock.calls[0][0]).toBe('https://api.x/me/devices/d1');
+        expect(fetchImpl.mock.calls[0][1].method).toBe('DELETE');
+    });
+    it('createLocalWorkspace posts kind:local to /workspaces', async () => {
+        const fetchImpl = fakeFetch(201, { success: true, workspace: { id: 'ws-1', name: 'my-app' } });
+        const result = await (0, apiClient_1.createLocalWorkspace)({ ...OPTS, fetchImpl }, { name: 'my-app' });
+        expect(result.workspace.id).toBe('ws-1');
+        const [url, init] = fetchImpl.mock.calls[0];
+        expect(url).toBe('https://api.x/workspaces');
+        expect(JSON.parse(init.body)).toEqual({ name: 'my-app', kind: 'local' });
+    });
+    it('deleteWorkspace deletes /workspaces/:id', async () => {
+        const fetchImpl = fakeFetch(200, { success: true });
+        await (0, apiClient_1.deleteWorkspace)({ ...OPTS, fetchImpl }, 'ws-1');
+        expect(fetchImpl.mock.calls[0][0]).toBe('https://api.x/workspaces/ws-1');
+        expect(fetchImpl.mock.calls[0][1].method).toBe('DELETE');
+    });
+    it('throws a BridgeApiError carrying the backend error code on failure', async () => {
+        const fetchImpl = fakeFetch(401, { success: false, error: { code: 'INVALID_CONNECT_TOKEN', message: 'Connect token is invalid or revoked.' } });
+        await expect((0, apiClient_1.listDevices)({ ...OPTS, fetchImpl })).rejects.toThrow(apiClient_1.BridgeApiError);
+        try {
+            await (0, apiClient_1.listDevices)({ ...OPTS, fetchImpl });
+        }
+        catch (err) {
+            expect(err).toBeInstanceOf(apiClient_1.BridgeApiError);
+            expect(err.code).toBe('INVALID_CONNECT_TOKEN');
+            expect(err.status).toBe(401);
+        }
+    });
+});

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

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