@wenrwa/marketplace-cli 0.4.4 → 0.4.6

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

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * pucc-14 — bridge completion: relay-owned sessionId (multiplex v1), the
+ * per-session env contract (connectToken/gitCredential/autonomous), and the
+ * login_valid report. Uses the same faked-PTY / fake-relay harness as
+ * bridge-relay-client.test.ts — no docker, no real shells.
+ */
+const ws_1 = require("ws");
+const relayClient_1 = require("../bridge/relayClient");
+const sessionManager_1 = require("../bridge/sessionManager");
+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 frameQueue(ws) {
+    const frames = [];
+    const waiters = [];
+    ws.on('message', (raw) => {
+        const f = JSON.parse(String(raw));
+        const w = waiters.shift();
+        if (w)
+            w(f);
+        else
+            frames.push(f);
+    });
+    return {
+        next: () => frames.length > 0 ? Promise.resolve(frames.shift()) : new Promise((r) => waiters.push(r)),
+    };
+}
+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()));
+    });
+}
+// ── assembleSessionEnv (pure) ──────────────────────────────────────────────
+describe('assembleSessionEnv — per-session env contract (pucc-04/14)', () => {
+    it('merges relay-injected env + connectToken (MCP) + git credential + autonomous flag', () => {
+        const env = (0, relayClient_1.assembleSessionEnv)({
+            workspaceId: 'ws-7',
+            autonomous: true,
+            connectToken: 'wm_ct_abc',
+            gitCredential: { token: 'ghs_zzz', repoFullName: 'acme/widgets', expiresAt: 'later' },
+            env: { WENRWA_WORKSPACE_ID: 'ws-7', WENRWA_CONNECT_TOKEN: 'wm_ct_abc', PRESERVED: '1' },
+        });
+        expect(env).toEqual({
+            WENRWA_WORKSPACE_ID: 'ws-7',
+            WENRWA_CONNECT_TOKEN: 'wm_ct_abc',
+            PRESERVED: '1',
+            HT_AUTONOMOUS: '1',
+            WENRWA_GIT_TOKEN: 'ghs_zzz',
+            WENRWA_GIT_REPO: 'acme/widgets',
+        });
+    });
+    it('defaults HT_AUTONOMOUS to 0 (supervised) and omits git vars when no credential', () => {
+        const env = (0, relayClient_1.assembleSessionEnv)({ workspaceId: 'ws-1' });
+        expect(env).toEqual({ WENRWA_WORKSPACE_ID: 'ws-1', HT_AUTONOMOUS: '0' });
+        expect(env).not.toHaveProperty('WENRWA_GIT_TOKEN');
+    });
+});
+// ── multiplex v1: honor the relay-owned sessionId ──────────────────────────
+describe('relay client — honors the relay-owned sessionId (multiplex v1)', () => {
+    it('registers the PTY under the relay-supplied sessionId and echoes it back', async () => {
+        const relay = await startFakeRelay();
+        const { factory } = 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 });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        // The relay OWNS this id (== agentId) and stamps it on the open frame.
+        ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, sessionId: 'agent-A' }));
+        const opened = await q.next();
+        expect(opened).toMatchObject({ t: 'opened', sessionId: 'agent-A' });
+        expect(sessions.list()).toEqual(['agent-A']);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('routes input/data by the relay-owned id across N concurrent sessions (isolation)', 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 });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, sessionId: 'agent-A' }));
+        expect((await q.next()).sessionId).toBe('agent-A');
+        ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, sessionId: 'agent-B' }));
+        expect((await q.next()).sessionId).toBe('agent-B');
+        // Input stamped with the relay-owned id reaches ONLY that session's PTY.
+        ws.send(JSON.stringify({ t: 'input', sessionId: 'agent-A', data: 'to-a' }));
+        ws.send(JSON.stringify({ t: 'input', sessionId: 'agent-B', data: 'to-b' }));
+        await new Promise((r) => setTimeout(r, 20));
+        expect(ptys[0].written).toEqual(['to-a']);
+        expect(ptys[1].written).toEqual(['to-b']);
+        // PTY output streams back tagged with the SAME relay-owned id so the relay
+        // can demux to the right pane.
+        ptys[1].emitData('from-b');
+        expect(await q.next()).toMatchObject({ t: 'data', sessionId: 'agent-B', data: 'from-b' });
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('workspace-scoped open injects connectToken + git credential into the PTY env', 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,
+            resolveWorkspaceCwd: async ({ workspaceId }) => `/data/repos/${workspaceId}`,
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({
+            t: 'open', cols: 80, rows: 24, sessionId: 'agent-A',
+            workspaceId: 'ws-7', autonomous: true,
+            connectToken: 'wm_ct_xyz',
+            gitCredential: { token: 'ghs_secret', repoFullName: 'acme/widgets' },
+            env: { WENRWA_WORKSPACE_ID: 'ws-7', WENRWA_CONNECT_TOKEN: 'wm_ct_xyz' },
+        }));
+        await q.next();
+        expect(ptys[0].opts.cwd).toBe('/data/repos/ws-7');
+        expect(ptys[0].opts.env).toMatchObject({
+            WENRWA_WORKSPACE_ID: 'ws-7',
+            WENRWA_CONNECT_TOKEN: 'wm_ct_xyz',
+            HT_AUTONOMOUS: '1',
+            WENRWA_GIT_TOKEN: 'ghs_secret',
+            WENRWA_GIT_REPO: 'acme/widgets',
+        });
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+});
+// ── login_valid report ─────────────────────────────────────────────────────
+describe('relay client — login_valid report (pucc-14)', () => {
+    it('emits a login-status frame (boolean only) on connect', async () => {
+        const relay = await startFakeRelay();
+        const { factory } = 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,
+            checkLoginValid: () => true,
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        expect(await q.next()).toEqual({ v: 1, relayToken: 'tok' }); // auth first
+        expect(await q.next()).toEqual({ t: 'login-status', valid: true }); // then login-status
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('never emits a login-status frame when no checkLoginValid is provided', async () => {
+        const relay = await startFakeRelay();
+        const { factory } = 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 });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        expect(await q.next()).toEqual({ v: 1, relayToken: 'tok' });
+        // Prove no login-status follows: open a session and the next frame is 'opened'.
+        ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24 }));
+        expect((await q.next()).t).toBe('opened');
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('re-emits only when the login validity CHANGES (poll interval)', async () => {
+        const relay = await startFakeRelay();
+        const { factory } = makeFactory();
+        const sessions = new sessionManager_1.SessionManager(factory);
+        let valid = false;
+        let pollCb = null;
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            checkLoginValid: () => valid,
+            setIntervalFn: (cb) => { pollCb = cb; return 1; },
+            clearIntervalFn: () => { },
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        expect(await q.next()).toEqual({ t: 'login-status', valid: false }); // connect force-emit
+        // Poll with no change → no frame. Then flip → exactly one frame.
+        pollCb();
+        valid = true;
+        pollCb();
+        expect(await q.next()).toEqual({ t: 'login-status', valid: true });
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+});

package/dist/__tests__/bridge-server-local-endpoints.test.d.ts

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

package/dist/__tests__/bridge-server-local-endpoints.test.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * TDD — lws-05: the three loopback HTTP endpoints backing the arena
+ * create-modal's local mode (PRD D3): POST /local/validate-path,
+ * POST /local/pick-folder, POST /local/add. Same server as bridge-server
+ * .test.ts (discovery/WS) — split into its own file since these are a
+ * distinct vertical slice. All handlers are injected opts (no real fs,
+ * osascript, or network — per the issue's "no real osascript in tests").
+ */
+const server_1 = require("../bridge/server");
+const sessionManager_1 = require("../bridge/sessionManager");
+class FakePty {
+    write() { }
+    resize() { }
+    kill() { }
+    onData() { }
+    onExit() { }
+}
+const ORIGIN = 'https://app.hiveop.io';
+const TOKEN = 'session-token-123';
+const factory = { spawn: () => new FakePty() };
+async function postJson(port, path, body, opts = {}) {
+    const headers = {
+        'content-type': 'application/json',
+        origin: opts.origin ?? ORIGIN,
+    };
+    if (opts.sessionToken !== undefined)
+        headers['x-bridge-session-token'] = opts.sessionToken;
+    const res = await fetch(`http://127.0.0.1:${port}${path}`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body),
+    });
+    return { status: res.status, json: await res.json().catch(() => null) };
+}
+describe('POST /local/validate-path', () => {
+    let handle;
+    afterEach(async () => {
+        await handle.close();
+    });
+    it('returns the validator result for a valid folder', async () => {
+        handle = await (0, server_1.startBridgeServer)({
+            sessionToken: TOKEN,
+            allowedOrigin: ORIGIN,
+            sessions: new sessionManager_1.SessionManager(factory),
+            validatePath: async () => ({ ok: true, name: 'my-app', fileCount: 214, isGitRepo: true }),
+        });
+        const { status, json } = await postJson(handle.port, '/local/validate-path', { path: '/Users/x/my-app' });
+        expect(status).toBe(200);
+        expect(json).toEqual({ ok: true, name: 'my-app', fileCount: 214, isGitRepo: true });
+    });
+    it('returns a typed error for an invalid path', async () => {
+        handle = await (0, server_1.startBridgeServer)({
+            sessionToken: TOKEN,
+            allowedOrigin: ORIGIN,
+            sessions: new sessionManager_1.SessionManager(factory),
+            validatePath: async () => ({ ok: false, error: 'not-exists' }),
+        });
+        const { status, json } = await postJson(handle.port, '/local/validate-path', { path: '/nope' });
+        expect(status).toBe(200);
+        expect(json).toEqual({ ok: false, error: 'not-exists' });
+    });
+    it('rejects a request from a non-arena Origin', async () => {
+        handle = await (0, server_1.startBridgeServer)({
+            sessionToken: TOKEN,
+            allowedOrigin: ORIGIN,
+            sessions: new sessionManager_1.SessionManager(factory),
+            validatePath: async () => ({ ok: true, name: 'x', fileCount: 1, isGitRepo: false }),
+        });
+        const { status } = await postJson(handle.port, '/local/validate-path', { path: '/x' }, { origin: 'https://evil.example' });
+        expect(status).toBe(403);
+    });
+    it('500s cleanly when the endpoint is not wired', async () => {
+        handle = await (0, server_1.startBridgeServer)({ sessionToken: TOKEN, allowedOrigin: ORIGIN, sessions: new sessionManager_1.SessionManager(factory) });
+        const { status } = await postJson(handle.port, '/local/validate-path', { path: '/x' });
+        expect(status).toBe(500);
+    });
+});
+describe('POST /local/pick-folder', () => {
+    let handle;
+    afterEach(async () => {
+        await handle.close();
+    });
+    it('returns the chosen path', async () => {
+        handle = await (0, server_1.startBridgeServer)({
+            sessionToken: TOKEN,
+            allowedOrigin: ORIGIN,
+            sessions: new sessionManager_1.SessionManager(factory),
+            pickFolder: async () => ({ path: '/Users/x/my-app' }),
+        });
+        const { status, json } = await postJson(handle.port, '/local/pick-folder', {});
+        expect(status).toBe(200);
+        expect(json).toEqual({ path: '/Users/x/my-app' });
+    });
+    it('surfaces {cancelled:true} when the user dismisses the dialog', async () => {
+        handle = await (0, server_1.startBridgeServer)({
+            sessionToken: TOKEN,
+            allowedOrigin: ORIGIN,
+            sessions: new sessionManager_1.SessionManager(factory),
+            pickFolder: async () => ({ cancelled: true }),
+        });
+        const { json } = await postJson(handle.port, '/local/pick-folder', {});
+        expect(json).toEqual({ cancelled: true });
+    });
+    it('surfaces {unsupported:true} on platforms with no native picker', async () => {
+        handle = await (0, server_1.startBridgeServer)({
+            sessionToken: TOKEN,
+            allowedOrigin: ORIGIN,
+            sessions: new sessionManager_1.SessionManager(factory),
+            pickFolder: async () => ({ unsupported: true }),
+        });
+        const { json } = await postJson(handle.port, '/local/pick-folder', {});
+        expect(json).toEqual({ unsupported: true });
+    });
+    it('one picker at a time — a second concurrent call gets 409 busy without invoking the picker again', async () => {
+        let resolvePick;
+        const pending = new Promise((resolve) => { resolvePick = resolve; });
+        const pickFolder = jest.fn().mockReturnValue(pending);
+        handle = await (0, server_1.startBridgeServer)({
+            sessionToken: TOKEN,
+            allowedOrigin: ORIGIN,
+            sessions: new sessionManager_1.SessionManager(factory),
+            pickFolder,
+        });
+        const first = postJson(handle.port, '/local/pick-folder', {});
+        await new Promise((r) => setTimeout(r, 10)); // let the first request start the picker
+        const second = await postJson(handle.port, '/local/pick-folder', {});
+        expect(second.status).toBe(409);
+        expect(second.json).toEqual({ busy: true });
+        expect(pickFolder).toHaveBeenCalledTimes(1);
+        resolvePick({ path: '/Users/x/app' });
+        const firstResult = await first;
+        expect(firstResult.json).toEqual({ path: '/Users/x/app' });
+        // The gate releases after completion — a third call runs the picker again.
+        const third = await postJson(handle.port, '/local/pick-folder', {});
+        expect(pickFolder).toHaveBeenCalledTimes(2);
+        expect(third.status).toBe(200);
+    });
+});
+describe('POST /local/add', () => {
+    let handle;
+    afterEach(async () => {
+        await handle.close();
+    });
+    it('requires the session token — missing/wrong is rejected with 401', async () => {
+        const addLocalWorkspace = jest.fn();
+        handle = await (0, server_1.startBridgeServer)({
+            sessionToken: TOKEN,
+            allowedOrigin: ORIGIN,
+            sessions: new sessionManager_1.SessionManager(factory),
+            addLocalWorkspace,
+        });
+        const missing = await postJson(handle.port, '/local/add', { path: '/x' });
+        expect(missing.status).toBe(401);
+        const wrong = await postJson(handle.port, '/local/add', { path: '/x' }, { sessionToken: 'wrong' });
+        expect(wrong.status).toBe(401);
+        expect(addLocalWorkspace).not.toHaveBeenCalled();
+    });
+    it('creates and returns the workspace summary with a valid session token', async () => {
+        handle = await (0, server_1.startBridgeServer)({
+            sessionToken: TOKEN,
+            allowedOrigin: ORIGIN,
+            sessions: new sessionManager_1.SessionManager(factory),
+            addLocalWorkspace: async ({ path, name }) => {
+                expect(path).toBe('/Users/x/my-app');
+                expect(name).toBeUndefined();
+                return { status: 'created', workspace: { id: 'ws-1', name: 'my-app' } };
+            },
+        });
+        const { status, json } = await postJson(handle.port, '/local/add', { path: '/Users/x/my-app' }, { sessionToken: TOKEN });
+        expect(status).toBe(201);
+        expect(json).toEqual({ ok: true, status: 'created', workspace: { id: 'ws-1', name: 'my-app' } });
+    });
+    it('is idempotent — an already-registered path returns 200 existing, not 201', async () => {
+        handle = await (0, server_1.startBridgeServer)({
+            sessionToken: TOKEN,
+            allowedOrigin: ORIGIN,
+            sessions: new sessionManager_1.SessionManager(factory),
+            addLocalWorkspace: async () => ({ status: 'existing', workspace: { id: 'ws-1', name: 'my-app' } }),
+        });
+        const { status, json } = await postJson(handle.port, '/local/add', { path: '/x' }, { sessionToken: TOKEN });
+        expect(status).toBe(200);
+        expect(json).toEqual({ ok: true, status: 'existing', workspace: { id: 'ws-1', name: 'my-app' } });
+    });
+    it('surfaces a creation error as ok:false without a 2xx status', async () => {
+        handle = await (0, server_1.startBridgeServer)({
+            sessionToken: TOKEN,
+            allowedOrigin: ORIGIN,
+            sessions: new sessionManager_1.SessionManager(factory),
+            addLocalWorkspace: async () => ({ status: 'error', message: 'device offline' }),
+        });
+        const { status, json } = await postJson(handle.port, '/local/add', { path: '/x' }, { sessionToken: TOKEN });
+        expect(status).toBe(500);
+        expect(json).toEqual({ ok: false, message: 'device offline' });
+    });
+});

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

@@ -125,6 +125,28 @@ describe('bridge WebSocket server', () => {
         expect(bad.status).toBe(403);
         expect(bad.headers.get('access-control-allow-origin')).toBeNull();
     });
+    it('lws-03: discovery advertises registered local workspaces, empty by default', async () => {
+        const res = await fetch(`http://127.0.0.1:${handle.port}/discovery`, { headers: { origin: ORIGIN } });
+        const body = await res.json();
+        expect(body.localWorkspaces).toEqual([]);
+    });
+    it('lws-03: discovery reflects the registry live — no restart needed — via a getter closure', async () => {
+        await handle.close();
+        const factory = { spawn: () => { const p = new FakePty(); ptys.push(p); return p; } };
+        let entries = [];
+        handle = await (0, server_1.startBridgeServer)({
+            sessionToken: TOKEN,
+            allowedOrigin: ORIGIN,
+            sessions: new sessionManager_1.SessionManager(factory),
+            getLocalWorkspaces: () => entries,
+        });
+        const before = await (await fetch(`http://127.0.0.1:${handle.port}/discovery`, { headers: { origin: ORIGIN } })).json();
+        expect(before.localWorkspaces).toEqual([]);
+        // Simulate `wen-market local add` mutating the registry mid-run.
+        entries = [{ workspaceId: 'ws-1', name: 'my-app', path: 'my-app' }];
+        const after = await (await fetch(`http://127.0.0.1:${handle.port}/discovery`, { headers: { origin: ORIGIN } })).json();
+        expect(after.localWorkspaces).toEqual([{ workspaceId: 'ws-1', name: 'my-app', path: 'my-app' }]);
+    });
     it('answers the Chrome Private-Network-Access preflight for the arena origin', async () => {
         const res = await fetch(`http://127.0.0.1:${handle.port}/discovery`, {
             method: 'OPTIONS',

package/dist/__tests__/bridge-workspace-multirepo.test.d.ts

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