@wenrwa/marketplace-cli 0.4.4 → 0.4.6

package/dist/__tests__/bridge-bundle-installer.test.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * pucc-int-04 — crew `.claude`-bundle installer (container writer).
+ *
+ * The bridge receives a forged crew bundle (Agent-Builder Forge `format=map`
+ * FileMap) over a relay frame and writes it into the agent's workspace checkout
+ * at /data/repos/<workspaceId>. Claude Code then picks up the subagents/skills/
+ * CLAUDE.md natively on its next run (ADR-0032) — no crewExecutionEngine.
+ *
+ * These tests exercise the PURE writer (fake fs) so path-safety + idempotency
+ * are proven without touching disk.
+ */
+const bundleInstaller_1 = require("../bridge/bundleInstaller");
+const BASE = '/data/repos';
+const makeFs = () => {
+    const files = new Map();
+    const dirs = new Set();
+    return {
+        files,
+        dirs,
+        deps: {
+            reposBaseDir: BASE,
+            mkdirp: (dir) => { dirs.add(dir); },
+            writeFile: (p, content) => { files.set(p, content); },
+        },
+    };
+};
+describe('installBundle — writes the bundle into the workspace checkout', () => {
+    it('writes each FileMap entry under /data/repos/<workspaceId>/<path>', () => {
+        const { files, deps } = makeFs();
+        const result = (0, bundleInstaller_1.installBundle)({
+            workspaceId: 'ws-7',
+            files: {
+                'CLAUDE.md': '# crew\n',
+                '.claude/agents/reviewer.md': 'reviewer subagent',
+                '.claude/skills/run-crew/SKILL.md': 'run the crew',
+                '.claude/handoff/PROTOCOL.md': 'blackboard protocol',
+            },
+        }, deps);
+        expect(result.workspaceRoot).toBe('/data/repos/ws-7');
+        expect(files.get('/data/repos/ws-7/CLAUDE.md')).toBe('# crew\n');
+        expect(files.get('/data/repos/ws-7/.claude/agents/reviewer.md')).toBe('reviewer subagent');
+        expect(files.get('/data/repos/ws-7/.claude/skills/run-crew/SKILL.md')).toBe('run the crew');
+        expect(files.get('/data/repos/ws-7/.claude/handoff/PROTOCOL.md')).toBe('blackboard protocol');
+        expect(result.written.sort()).toEqual([
+            '.claude/agents/reviewer.md',
+            '.claude/handoff/PROTOCOL.md',
+            '.claude/skills/run-crew/SKILL.md',
+            'CLAUDE.md',
+        ]);
+        expect(result.skipped).toEqual([]);
+    });
+    it('is idempotent — re-install overwrites managed files with identical result', () => {
+        const { files, deps } = makeFs();
+        const bundle = {
+            workspaceId: 'ws-7',
+            files: { 'CLAUDE.md': 'v1', '.claude/agents/a.md': 'agent-a' },
+        };
+        const first = (0, bundleInstaller_1.installBundle)(bundle, deps);
+        const firstSnapshot = new Map(files);
+        const second = (0, bundleInstaller_1.installBundle)(bundle, deps);
+        expect(second.written).toEqual(first.written);
+        expect(new Map(files)).toEqual(firstSnapshot); // byte-identical state
+        // A re-send with updated content simply overwrites the managed file.
+        (0, bundleInstaller_1.installBundle)({ workspaceId: 'ws-7', files: { 'CLAUDE.md': 'v2' } }, deps);
+        expect(files.get('/data/repos/ws-7/CLAUDE.md')).toBe('v2');
+    });
+    it('leaves pre-existing user files alone (only writes bundle entries)', () => {
+        const { files, deps } = makeFs();
+        files.set('/data/repos/ws-7/src/index.ts', 'user code'); // a user file already in the checkout
+        (0, bundleInstaller_1.installBundle)({ workspaceId: 'ws-7', files: { 'CLAUDE.md': 'crew' } }, deps);
+        expect(files.get('/data/repos/ws-7/src/index.ts')).toBe('user code'); // untouched
+        expect(files.get('/data/repos/ws-7/CLAUDE.md')).toBe('crew');
+    });
+});
+describe('installBundle — path safety (writes nothing outside the workspace)', () => {
+    const traversals = [
+        ['parent-relative', '../evil.md'],
+        ['deep parent-relative', '.claude/../../../../etc/cron.d/evil'],
+        ['absolute path', '/etc/passwd'],
+        ['absolute into shared login', '/data/.claude/settings.json'],
+        ['sibling workspace', '../ws-OTHER/.claude/agents/steal.md'],
+        ['null byte', '.claude/x\0.md'],
+    ];
+    it.each(traversals)('rejects %s and writes nothing', (_label, badPath) => {
+        const { files, dirs, deps } = makeFs();
+        const result = (0, bundleInstaller_1.installBundle)({ workspaceId: 'ws-7', files: { [badPath]: 'malicious' } }, deps);
+        expect(files.size).toBe(0);
+        expect(dirs.size).toBe(0);
+        expect(result.written).toEqual([]);
+        expect(result.skipped).toEqual([{ path: badPath, reason: 'unsafe' }]);
+    });
+    it('never touches the shared /data/.claude login even via a crafted workspaceId', () => {
+        const { files, deps } = makeFs();
+        // A workspaceId that tries to climb to the shared login must be refused wholesale.
+        const result = (0, bundleInstaller_1.installBundle)({ workspaceId: '../..', files: { '.claude/settings.json': 'x' } }, deps);
+        expect(result.workspaceRoot).toBeNull();
+        expect(files.size).toBe(0);
+    });
+    it('rejects a workspaceId containing a slash (path injection)', () => {
+        const { files, deps } = makeFs();
+        const result = (0, bundleInstaller_1.installBundle)({ workspaceId: 'ws-7/../ws-8', files: { 'CLAUDE.md': 'x' } }, deps);
+        expect(result.workspaceRoot).toBeNull();
+        expect(files.size).toBe(0);
+    });
+    it('skips safe-but-unmanaged paths (only .claude/** + CLAUDE.md are managed)', () => {
+        const { files, deps } = makeFs();
+        const result = (0, bundleInstaller_1.installBundle)({
+            workspaceId: 'ws-7',
+            files: {
+                'CLAUDE.md': 'managed',
+                '.claude/agents/a.md': 'managed',
+                'install.mjs': 'forge installer — not needed; bridge does the install',
+                'package.json': 'do not clobber',
+            },
+        }, deps);
+        expect(result.written.sort()).toEqual(['.claude/agents/a.md', 'CLAUDE.md']);
+        expect(result.skipped).toEqual(expect.arrayContaining([
+            { path: 'install.mjs', reason: 'unmanaged' },
+            { path: 'package.json', reason: 'unmanaged' },
+        ]));
+        expect(files.has('/data/repos/ws-7/install.mjs')).toBe(false);
+        expect(files.has('/data/repos/ws-7/package.json')).toBe(false);
+    });
+});

package/dist/__tests__/bridge-cdp-client.test.d.ts

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

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

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * cbs-02 — hand-rolled CDP JSON-RPC client (id/method/params + events) over
+ * an injectable transport. No real socket: tests drive a FakeTransport that
+ * implements the same on('open'|'message'|'close'|'error') surface the real
+ * `ws`-backed transport will use, so the request/response and event-fanout
+ * logic is verified without Chromium or a network socket.
+ */
+const cdpClient_1 = require("../bridge/cdpClient");
+class FakeTransport {
+    sent = [];
+    closed = false;
+    handlers = {};
+    on(event, cb) {
+        (this.handlers[event] ??= []).push(cb);
+    }
+    send(data) {
+        this.sent.push(JSON.parse(data));
+    }
+    close() {
+        this.closed = true;
+    }
+    // test-only helpers to drive the fake server side
+    emitMessage(obj) {
+        for (const cb of this.handlers.message ?? [])
+            cb(JSON.stringify(obj));
+    }
+    emitRawMessage(raw) {
+        for (const cb of this.handlers.message ?? [])
+            cb(raw);
+    }
+    emitClose(info) {
+        for (const cb of this.handlers.close ?? [])
+            cb(info);
+    }
+    replyTo(id, result) {
+        this.emitMessage({ id, result });
+    }
+    replyError(id, message) {
+        this.emitMessage({ id, error: { message } });
+    }
+}
+describe('createCdpClient (cbs-02)', () => {
+    it('sends a request as {id, method, params} and resolves on the matching {id, result}', async () => {
+        const transport = new FakeTransport();
+        const cdp = (0, cdpClient_1.createCdpClient)(transport);
+        const pending = cdp.send('Target.getTargets', {});
+        expect(transport.sent).toEqual([{ id: 1, method: 'Target.getTargets', params: {} }]);
+        transport.replyTo(1, { targetInfos: [] });
+        await expect(pending).resolves.toEqual({ targetInfos: [] });
+    });
+    it('stamps sessionId on the request envelope when provided (flattened target session)', async () => {
+        const transport = new FakeTransport();
+        const cdp = (0, cdpClient_1.createCdpClient)(transport);
+        const pending = cdp.send('Page.enable', {}, 'sess-abc');
+        expect(transport.sent).toEqual([{ id: 1, method: 'Page.enable', params: {}, sessionId: 'sess-abc' }]);
+        transport.replyTo(1, {});
+        await pending;
+    });
+    it('assigns monotonically increasing ids across calls and resolves each independently', async () => {
+        const transport = new FakeTransport();
+        const cdp = (0, cdpClient_1.createCdpClient)(transport);
+        const p1 = cdp.send('A.one');
+        const p2 = cdp.send('A.two');
+        expect(transport.sent.map((m) => m.id)).toEqual([1, 2]);
+        transport.replyTo(2, { order: 'second-first' });
+        transport.replyTo(1, { order: 'first' });
+        await expect(p2).resolves.toEqual({ order: 'second-first' });
+        await expect(p1).resolves.toEqual({ order: 'first' });
+    });
+    it('rejects the pending promise on a {id, error} response', async () => {
+        const transport = new FakeTransport();
+        const cdp = (0, cdpClient_1.createCdpClient)(transport);
+        const pending = cdp.send('Target.attachToTarget', { targetId: 'nope' });
+        transport.replyError(1, 'No target with given id found');
+        await expect(pending).rejects.toThrow('No target with given id found');
+    });
+    it('dispatches {method, params} messages (no id) to onEvent subscribers by method name', () => {
+        const transport = new FakeTransport();
+        const cdp = (0, cdpClient_1.createCdpClient)(transport);
+        const received = [];
+        cdp.onEvent('Page.screencastFrame', (params, sessionId) => received.push({ params, sessionId }));
+        transport.emitMessage({ method: 'Page.screencastFrame', params: { data: 'abc', sessionId: 7 }, sessionId: 'target-sess-1' });
+        transport.emitMessage({ method: 'Target.targetInfoChanged', params: { targetInfo: {} } });
+        expect(received).toEqual([{ params: { data: 'abc', sessionId: 7 }, sessionId: 'target-sess-1' }]);
+    });
+    it('supports multiple subscribers to the same event method and unsubscribing via the returned function', () => {
+        const transport = new FakeTransport();
+        const cdp = (0, cdpClient_1.createCdpClient)(transport);
+        const a = [];
+        const b = [];
+        cdp.onEvent('Foo.bar', (p) => a.push(p));
+        const unsubB = cdp.onEvent('Foo.bar', (p) => b.push(p));
+        transport.emitMessage({ method: 'Foo.bar', params: { n: 1 } });
+        unsubB();
+        transport.emitMessage({ method: 'Foo.bar', params: { n: 2 } });
+        expect(a).toEqual([{ n: 1 }, { n: 2 }]);
+        expect(b).toEqual([{ n: 1 }]);
+    });
+    it('ignores malformed (non-JSON) messages instead of throwing', () => {
+        const transport = new FakeTransport();
+        const cdp = (0, cdpClient_1.createCdpClient)(transport);
+        cdp.onEvent('Foo.bar', () => {
+            throw new Error('should not be called');
+        });
+        expect(() => transport.emitRawMessage('not json')).not.toThrow();
+    });
+    it('on transport close: rejects all pending requests and notifies onClose listeners', async () => {
+        const transport = new FakeTransport();
+        const cdp = (0, cdpClient_1.createCdpClient)(transport);
+        const closes = [];
+        cdp.onClose((info) => closes.push(info));
+        const pending = cdp.send('Target.getTargets');
+        transport.emitClose({ code: 1006, reason: 'abnormal' });
+        await expect(pending).rejects.toThrow();
+        expect(closes).toEqual([{ code: 1006, reason: 'abnormal' }]);
+    });
+    it('a send() issued after close rejects immediately without touching the transport', async () => {
+        const transport = new FakeTransport();
+        const cdp = (0, cdpClient_1.createCdpClient)(transport);
+        transport.emitClose();
+        const sentBefore = transport.sent.length;
+        await expect(cdp.send('Page.reload')).rejects.toThrow();
+        expect(transport.sent.length).toBe(sentBefore);
+    });
+    it('close() delegates to the transport', () => {
+        const transport = new FakeTransport();
+        const cdp = (0, cdpClient_1.createCdpClient)(transport);
+        cdp.close();
+        expect(transport.closed).toBe(true);
+    });
+});

package/dist/__tests__/bridge-chromium-launcher.test.d.ts

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

package/dist/__tests__/bridge-chromium-launcher.test.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * cbs-02 — Chromium child-process launcher.
+ *
+ * Spawns headless Chromium with the container-required flags (no-sandbox,
+ * persistent `/data` profile) and resolves the DevTools websocket URL
+ * parsed from stderr (standard headless behavior with
+ * `--remote-debugging-port=0`). Uses an injectable spawn function so tests
+ * never touch a real process (docs/prd/cloud-browser-session.md: "no
+ * puppeteer", container sandbox flags, profile on `/data`).
+ */
+const chromiumLauncher_1 = require("../bridge/chromiumLauncher");
+class FakeChildProcess {
+    killed = false;
+    killSignal;
+    stderrHandlers = [];
+    exitHandlers = [];
+    errorHandlers = [];
+    stderr = {
+        on: (event, cb) => {
+            if (event === 'data')
+                this.stderrHandlers.push(cb);
+        },
+    };
+    on(event, cb) {
+        if (event === 'exit')
+            this.exitHandlers.push(cb);
+        else if (event === 'error')
+            this.errorHandlers.push(cb);
+    }
+    kill(signal) {
+        this.killed = true;
+        this.killSignal = signal;
+    }
+    emitStderr(chunk) {
+        for (const cb of this.stderrHandlers)
+            cb(chunk);
+    }
+    emitExit(code, signal = null) {
+        for (const cb of this.exitHandlers)
+            cb(code, signal);
+    }
+}
+describe('launchChromium (cbs-02)', () => {
+    it('spawns the binary with container-required flags and a persistent /data profile dir', () => {
+        const calls = [];
+        const fake = new FakeChildProcess();
+        (0, chromiumLauncher_1.launchChromium)({
+            spawnFn: (cmd, args) => {
+                calls.push({ cmd, args });
+                return fake;
+            },
+        });
+        expect(calls).toHaveLength(1);
+        const { cmd, args } = calls[0];
+        expect(cmd).toBe('chromium'); // default binary
+        expect(args).toEqual(expect.arrayContaining(['--no-sandbox', '--disable-setuid-sandbox', '--disable-gpu', '--hide-scrollbars', '--mute-audio']));
+        expect(args.some((a) => a.startsWith('--user-data-dir='))).toBe(true);
+        const profileArg = args.find((a) => a.startsWith('--user-data-dir='));
+        expect(profileArg).toBe('--user-data-dir=/data/chromium-profile');
+        expect(args.some((a) => a.startsWith('--remote-debugging-port='))).toBe(true);
+    });
+    it('honors an opts-overridable user-data-dir (for tests / non-container runs)', () => {
+        const fake = new FakeChildProcess();
+        let capturedArgs = [];
+        (0, chromiumLauncher_1.launchChromium)({
+            userDataDir: '/tmp/my-profile',
+            spawnFn: (_cmd, args) => {
+                capturedArgs = args;
+                return fake;
+            },
+        });
+        expect(capturedArgs).toContain('--user-data-dir=/tmp/my-profile');
+    });
+    it('resolves the binary path from opts.chromiumPath, falling back to CHROMIUM_PATH env, then "chromium"', () => {
+        const fake = new FakeChildProcess();
+        let capturedCmd = '';
+        (0, chromiumLauncher_1.launchChromium)({
+            chromiumPath: '/usr/bin/my-chromium',
+            spawnFn: (cmd) => {
+                capturedCmd = cmd;
+                return fake;
+            },
+        });
+        expect(capturedCmd).toBe('/usr/bin/my-chromium');
+        const prevEnv = process.env.CHROMIUM_PATH;
+        process.env.CHROMIUM_PATH = '/env/chromium';
+        try {
+            const fake2 = new FakeChildProcess();
+            let capturedCmd2 = '';
+            (0, chromiumLauncher_1.launchChromium)({
+                spawnFn: (cmd) => {
+                    capturedCmd2 = cmd;
+                    return fake2;
+                },
+            });
+            expect(capturedCmd2).toBe('/env/chromium');
+        }
+        finally {
+            if (prevEnv === undefined)
+                delete process.env.CHROMIUM_PATH;
+            else
+                process.env.CHROMIUM_PATH = prevEnv;
+        }
+    });
+    it('includes a --window-size flag derived from opts width/height', () => {
+        const fake = new FakeChildProcess();
+        let capturedArgs = [];
+        (0, chromiumLauncher_1.launchChromium)({
+            width: 1024,
+            height: 768,
+            spawnFn: (_cmd, args) => {
+                capturedArgs = args;
+                return fake;
+            },
+        });
+        expect(capturedArgs).toContain('--window-size=1024,768');
+    });
+    it('parses the DevTools websocket URL out of stderr (standard headless behavior)', async () => {
+        const fake = new FakeChildProcess();
+        const { wsUrl } = (0, chromiumLauncher_1.launchChromium)({ spawnFn: () => fake });
+        fake.emitStderr('[1234:5678:INFO] some preamble\n');
+        fake.emitStderr('DevTools listening on ws://127.0.0.1:34567/devtools/browser/abc-123-def\n');
+        await expect(wsUrl).resolves.toBe('ws://127.0.0.1:34567/devtools/browser/abc-123-def');
+    });
+    it('assembles the ws URL even if it arrives split across multiple stderr chunks', async () => {
+        const fake = new FakeChildProcess();
+        const { wsUrl } = (0, chromiumLauncher_1.launchChromium)({ spawnFn: () => fake });
+        fake.emitStderr('DevTools listening on ws://127.0.0.1:9');
+        fake.emitStderr('222/devtools/browser/xyz\n');
+        await expect(wsUrl).resolves.toBe('ws://127.0.0.1:9222/devtools/browser/xyz');
+    });
+    it('rejects wsUrl if the process exits before printing a DevTools URL', async () => {
+        const fake = new FakeChildProcess();
+        const { wsUrl } = (0, chromiumLauncher_1.launchChromium)({ spawnFn: () => fake });
+        fake.emitExit(1, null);
+        await expect(wsUrl).rejects.toThrow();
+    });
+    it('exposes the raw child process handle so callers can kill() it', () => {
+        const fake = new FakeChildProcess();
+        const { proc } = (0, chromiumLauncher_1.launchChromium)({ spawnFn: () => fake });
+        expect(proc).toBe(fake);
+        proc.kill();
+        expect(fake.killed).toBe(true);
+    });
+    // cbs-07: the container image does NOT bake /data/chromium-profile (it's
+    // under the /data volume mount, which the image can't pre-populate) — the
+    // launcher must create it on first launch, before spawning, so Chromium's
+    // very first run on a fresh volume doesn't depend on Chromium itself
+    // creating a nested dir under an as-yet-nonexistent parent.
+    it('creates the user-data-dir before spawning (not baked into the image)', () => {
+        const fake = new FakeChildProcess();
+        const mkdirCalls = [];
+        let spawnedAfterMkdir = false;
+        (0, chromiumLauncher_1.launchChromium)({
+            userDataDir: '/data/chromium-profile',
+            mkdirFn: (dir) => {
+                mkdirCalls.push(dir);
+            },
+            spawnFn: (_cmd, _args) => {
+                spawnedAfterMkdir = mkdirCalls.length === 1;
+                return fake;
+            },
+        });
+        expect(mkdirCalls).toEqual(['/data/chromium-profile']);
+        expect(spawnedAfterMkdir).toBe(true);
+    });
+    it('defaults mkdirFn to a real recursive mkdirSync when not injected', () => {
+        // Exercises the real default (not just the injected fake) against a
+        // scratch dir so the default wiring itself is covered, not only the
+        // injection seam.
+        const fs = require('fs');
+        const os = require('os');
+        const path = require('path');
+        const scratch = fs.mkdtempSync(path.join(os.tmpdir(), 'cbs07-launcher-'));
+        const profileDir = path.join(scratch, 'nested', 'chromium-profile');
+        const fake = new FakeChildProcess();
+        try {
+            (0, chromiumLauncher_1.launchChromium)({ userDataDir: profileDir, spawnFn: () => fake });
+            expect(fs.existsSync(profileDir)).toBe(true);
+        }
+        finally {
+            fs.rmSync(scratch, { recursive: true, force: true });
+        }
+    });
+    it('never blocks the launch if mkdirFn throws (best-effort — Chromium can create its own profile dir)', () => {
+        const fake = new FakeChildProcess();
+        let spawned = false;
+        expect(() => (0, chromiumLauncher_1.launchChromium)({
+            userDataDir: '/data/chromium-profile',
+            mkdirFn: () => {
+                throw new Error('EACCES: permission denied');
+            },
+            spawnFn: () => {
+                spawned = true;
+                return fake;
+            },
+        })).not.toThrow();
+        expect(spawned).toBe(true);
+    });
+});

package/dist/__tests__/bridge-command-browser-options.test.d.ts

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

package/dist/__tests__/bridge-command-browser-options.test.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * cbs-07 — pure resolver for the Chromium options the `wen-market bridge`
+ * (relay mode) command wires into `createBrowserDriver`. Mirrors
+ * resolveRelayMode's existing pattern in bridge.ts: the command shell itself
+ * is thin/untested, so the actual decision logic lives in a pure,
+ * env-in/options-out helper that's unit-tested directly instead of forcing a
+ * harness onto the commander action.
+ */
+const bridge_1 = require("../commands/bridge");
+describe('buildBrowserDriverOptions (cbs-07)', () => {
+    it('defaults to the image convention: chromium on PATH, profile on the /data volume', () => {
+        expect((0, bridge_1.buildBrowserDriverOptions)({})).toEqual({
+            chromiumPath: 'chromium',
+            userDataDir: '/data/chromium-profile',
+        });
+    });
+    it('honors CHROMIUM_PATH when set (the image bakes ENV CHROMIUM_PATH=/usr/bin/chromium)', () => {
+        expect((0, bridge_1.buildBrowserDriverOptions)({ CHROMIUM_PATH: '/usr/bin/chromium' })).toEqual({
+            chromiumPath: '/usr/bin/chromium',
+            userDataDir: '/data/chromium-profile',
+        });
+    });
+    it('honors an overridable CHROMIUM_USER_DATA_DIR (tests / non-container runs)', () => {
+        expect((0, bridge_1.buildBrowserDriverOptions)({ CHROMIUM_USER_DATA_DIR: '/tmp/profile' })).toEqual({
+            chromiumPath: 'chromium',
+            userDataDir: '/tmp/profile',
+        });
+    });
+    it('ignores unrelated env vars and blank overrides fall back to defaults', () => {
+        expect((0, bridge_1.buildBrowserDriverOptions)({ CHROMIUM_PATH: '', SOME_OTHER_VAR: 'x' })).toEqual({
+            chromiumPath: 'chromium',
+            userDataDir: '/data/chromium-profile',
+        });
+    });
+});

package/dist/__tests__/bridge-config-mcp.test.js

@@ -56,6 +56,10 @@ describe('bridge config', () => {
     it('returns null when no config exists', () => {
         expect((0, config_1.loadBridgeConfig)(dir)).toBeNull();
     });
+    it('lws-03: round-trips a bound deviceId alongside the connect token', () => {
+        (0, config_1.saveBridgeConfig)({ connectToken: 'wm_ct_' + 'a'.repeat(64), deviceId: 'device-1' }, dir);
+        expect((0, config_1.loadBridgeConfig)(dir)).toEqual({ connectToken: 'wm_ct_' + 'a'.repeat(64), deviceId: 'device-1' });
+    });
     it('writes the discovery file with port + session token, 0600', () => {
         (0, config_1.writeDiscoveryFile)({ port: 8377, sessionToken: 'st-1' }, dir);
         const file = path.join(dir, 'bridge.json');

package/dist/__tests__/bridge-context-manifest-frame.test.d.ts

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

package/dist/__tests__/bridge-context-manifest-frame.test.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * pucc-int-01 — the relay client honors the `context-manifest` frame.
+ *
+ * platform (arena) → relay → container bridge: the bridge routes a
+ * `context-manifest` frame to the injected context writer (which writes the
+ * pushed content into a fenced managed region of /data/repos/<workspaceId>/
+ * CLAUDE.md) and acks with `context-written`. No PTY / session is involved —
+ * the context reaches Claude Code as a FILE, never keystrokes (ADR-0028).
+ *
+ * Reuses the faked-relay harness (no docker, no real shell).
+ */
+const ws_1 = require("ws");
+const relayClient_1 = require("../bridge/relayClient");
+const sessionManager_1 = require("../bridge/sessionManager");
+class FakePty {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    write() { }
+    resize() { }
+    kill() { }
+    onData() { }
+    onExit() { }
+}
+const makeFactory = () => ({ spawn: (o) => new FakePty(o) });
+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()));
+    });
+}
+describe('relay client — context-manifest frame (pucc-int-01)', () => {
+    it('routes a context-manifest frame to the injected writer and acks context-written', async () => {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        const calls = [];
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            writeContext: (manifest) => {
+                calls.push(manifest);
+                return { action: 'created', claudeMdPath: `/data/repos/${manifest.workspaceId}/CLAUDE.md` };
+            },
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'context-manifest', workspaceId: 'ws-7', content: '## files\n- a.ts', sessionId: 'agent-A' }));
+        const ack = await q.next();
+        expect(calls).toEqual([{ workspaceId: 'ws-7', content: '## files\n- a.ts' }]);
+        expect(ack).toMatchObject({ t: 'context-written', workspaceId: 'ws-7', sessionId: 'agent-A', action: 'created' });
+        // Writing context must not open a PTY session (ADR-0028: a FILE, not input).
+        expect(sessions.list()).toEqual([]);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('forwards empty content (region removal) verbatim to the writer', async () => {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        const calls = [];
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            writeContext: (manifest) => { calls.push(manifest); return { action: 'removed', claudeMdPath: null }; },
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'context-manifest', workspaceId: 'ws-7', content: '' }));
+        const ack = await q.next();
+        expect(calls).toEqual([{ workspaceId: 'ws-7', content: '' }]);
+        expect(ack).toMatchObject({ t: 'context-written', workspaceId: 'ws-7', action: 'removed' });
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('errors (never crashes) when no context writer is wired', async () => {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        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: 'context-manifest', workspaceId: 'ws-7', content: 'x' }));
+        expect((await q.next()).t).toBe('error');
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+});

package/dist/__tests__/bridge-context-writer.test.d.ts

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