@wenrwa/marketplace-cli 0.4.4 → 0.4.6

package/dist/__tests__/bridge-context-writer.test.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * pucc-int-01 — container context writer (fenced managed region in CLAUDE.md).
+ *
+ * The arena pushes a `context-manifest` (a single formatted string) to the
+ * container; the bridge writes it into a FENCED MANAGED REGION of
+ * /data/repos/<workspaceId>/CLAUDE.md so Claude Code reads it natively
+ * (ADR-0028: a FILE, never PTY input). These tests exercise the PURE writer
+ * (fake fs) so path-safety + idempotency are proven without touching disk.
+ */
+const contextWriter_1 = require("../bridge/contextWriter");
+const BASE = '/data/repos';
+const makeFs = (seed = {}) => {
+    const files = new Map(Object.entries(seed));
+    const dirs = new Set();
+    return {
+        files,
+        dirs,
+        deps: {
+            reposBaseDir: BASE,
+            exists: (p) => files.has(p),
+            readFile: (p) => files.get(p) ?? '',
+            writeFile: (p, content) => { files.set(p, content); },
+            mkdirp: (dir) => { dirs.add(dir); },
+        },
+    };
+};
+const CLAUDE = '/data/repos/ws-7/CLAUDE.md';
+const region = (body) => `${contextWriter_1.CONTEXT_START_MARKER}\n${body}\n${contextWriter_1.CONTEXT_END_MARKER}`;
+describe('writeContext — creates / updates the fenced managed region', () => {
+    it('creates CLAUDE.md holding just the region when none exists', () => {
+        const { files, deps } = makeFs();
+        const result = (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: '## Selected files\n- a.ts' }, deps);
+        expect(result.workspaceRoot).toBe('/data/repos/ws-7');
+        expect(result.claudeMdPath).toBe(CLAUDE);
+        expect(result.action).toBe('created');
+        expect(files.get(CLAUDE)).toBe(region('## Selected files\n- a.ts') + '\n');
+        // The markers fence the pushed content.
+        expect(files.get(CLAUDE)).toContain(contextWriter_1.CONTEXT_START_MARKER);
+        expect(files.get(CLAUDE)).toContain(contextWriter_1.CONTEXT_END_MARKER);
+    });
+    it('appends the region to an existing CLAUDE.md, preserving all user content', () => {
+        const user = '# My project\n\nHand-written guidance the user maintains.\n';
+        const { files, deps } = makeFs({ [CLAUDE]: user });
+        const result = (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: 'pushed context' }, deps);
+        expect(result.action).toBe('appended');
+        const out = files.get(CLAUDE);
+        expect(out.startsWith(user)).toBe(true); // user content untouched, still first
+        expect(out).toContain(region('pushed context'));
+    });
+    it('replaces an existing region in place — idempotent, no duplication on re-send', () => {
+        const { files, deps } = makeFs();
+        // First send creates it.
+        (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: 'v1' }, deps);
+        const afterFirst = files.get(CLAUDE);
+        // Re-sending the SAME content is byte-identical (idempotent).
+        const same = (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: 'v1' }, deps);
+        expect(same.action).toBe('replaced');
+        expect(files.get(CLAUDE)).toBe(afterFirst);
+        // Re-sending DIFFERENT content updates the region in place (no second region).
+        const updated = (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: 'v2' }, deps);
+        expect(updated.action).toBe('replaced');
+        const out = files.get(CLAUDE);
+        expect(out).toContain(region('v2'));
+        expect(out).not.toContain('v1');
+        // Exactly one region.
+        expect(out.split(contextWriter_1.CONTEXT_START_MARKER).length - 1).toBe(1);
+        expect(out.split(contextWriter_1.CONTEXT_END_MARKER).length - 1).toBe(1);
+    });
+    it('updates the region but keeps user content on both sides intact', () => {
+        const before = '# Header the user wrote\n\n';
+        const after = '\n## A user section BELOW the region\nkeep me\n';
+        const { files, deps } = makeFs({ [CLAUDE]: before + region('old') + after });
+        (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: 'new' }, deps);
+        const out = files.get(CLAUDE);
+        expect(out.startsWith(before)).toBe(true);
+        expect(out.endsWith(after)).toBe(true);
+        expect(out).toContain(region('new'));
+        expect(out).not.toContain(region('old'));
+    });
+    it('re-send with new content does not touch user CLAUDE.md text outside the region', () => {
+        const user = '# Keep me\ncustom rule\n';
+        const { files, deps } = makeFs({ [CLAUDE]: user });
+        (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: 'a' }, deps);
+        (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: 'b' }, deps);
+        (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: 'c' }, deps);
+        const out = files.get(CLAUDE);
+        expect(out).toContain('# Keep me');
+        expect(out).toContain('custom rule');
+        expect(out).toContain(region('c'));
+        expect(out).not.toContain(region('a'));
+        expect(out).not.toContain(region('b'));
+    });
+});
+describe('writeContext — empty content removes the region', () => {
+    it('removes the region and keeps the user content when content is empty', () => {
+        const user = '# My project\ncustom rule\n';
+        const { files, deps } = makeFs({ [CLAUDE]: user + '\n' + region('pushed') + '\n' });
+        const result = (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: '' }, deps);
+        expect(result.action).toBe('removed');
+        const out = files.get(CLAUDE);
+        expect(out).not.toContain(contextWriter_1.CONTEXT_START_MARKER);
+        expect(out).not.toContain(contextWriter_1.CONTEXT_END_MARKER);
+        expect(out).toContain('# My project');
+        expect(out).toContain('custom rule');
+    });
+    it('treats whitespace-only content as empty (removes the region)', () => {
+        const { files, deps } = makeFs();
+        (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: 'x' }, deps); // create region
+        const result = (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: '   \n\t ' }, deps);
+        expect(result.action).toBe('removed');
+        expect(files.get(CLAUDE)).not.toContain(contextWriter_1.CONTEXT_START_MARKER);
+    });
+    it('append-then-remove round-trips back to the original user content', () => {
+        const user = '# Project\ncustom rule\n';
+        const { files, deps } = makeFs({ [CLAUDE]: user });
+        (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: 'ctx' }, deps);
+        (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: '' }, deps);
+        expect(files.get(CLAUDE)).toBe(user);
+    });
+    it('is a no-op when there is no region and content is empty (no file created)', () => {
+        const { files, deps } = makeFs();
+        const result = (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: '' }, deps);
+        expect(result.action).toBe('noop');
+        expect(files.has(CLAUDE)).toBe(false);
+    });
+});
+describe('writeContext — path safety (writes nothing outside the workspace)', () => {
+    const badIds = [
+        ['parent traversal', '../..'],
+        ['slash injection', 'ws-7/../ws-8'],
+        ['climb to shared login', '../.claude'],
+        ['dot', '.'],
+        ['dotdot', '..'],
+        ['empty', ''],
+        ['backslash', 'ws-7\\..\\ws-8'],
+        ['null byte', 'ws-7\0'],
+    ];
+    it.each(badIds)('refuses workspaceId %s and writes nothing', (_label, badId) => {
+        const { files, dirs, deps } = makeFs();
+        const result = (0, contextWriter_1.writeContext)({ workspaceId: badId, content: 'malicious' }, deps);
+        expect(result.action).toBe('skipped');
+        expect(result.workspaceRoot).toBeNull();
+        expect(result.claudeMdPath).toBeNull();
+        expect(files.size).toBe(0);
+        expect(dirs.size).toBe(0);
+    });
+    it('never targets the shared /data/.claude login', () => {
+        const { deps } = makeFs();
+        const result = (0, contextWriter_1.writeContext)({ workspaceId: 'ws-7', content: 'x' }, deps);
+        // Only ever /data/repos/<id>/CLAUDE.md — never /data/.claude/*.
+        expect(result.claudeMdPath).toBe('/data/repos/ws-7/CLAUDE.md');
+        expect(result.claudeMdPath.startsWith('/data/repos/ws-7/')).toBe(true);
+    });
+    it('never writes into a sibling workspace via a crafted id', () => {
+        const { files, deps } = makeFs();
+        (0, contextWriter_1.writeContext)({ workspaceId: '../ws-OTHER', content: 'steal' }, deps);
+        expect(files.size).toBe(0);
+    });
+});

package/dist/__tests__/bridge-device-registration.test.d.ts

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

package/dist/__tests__/bridge-device-registration.test.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * TDD — lws-03: bridge/deviceRegistration.ts. "Connect this machine" — on
+ * first `wen-market bridge` run with a Connect Token configured, auto-
+ * register the device; idempotent thereafter (persisted deviceId short-
+ * circuits re-registration).
+ */
+const deviceRegistration_1 = require("../bridge/deviceRegistration");
+describe('ensureDeviceRegistered', () => {
+    const baseConfig = { connectToken: 'wm_ct_' + 'a'.repeat(64) };
+    it('registers a device using the hostname when none is bound yet', async () => {
+        const registerDevice = jest.fn().mockResolvedValue({ success: true, device: { id: 'd1', name: 'bunny-mbp' } });
+        const result = await (0, deviceRegistration_1.ensureDeviceRegistered)(baseConfig, 'https://api.x', {
+            registerDevice,
+            hostname: () => 'bunny-mbp',
+        });
+        expect(result).toMatchObject({ registered: true, deviceName: 'bunny-mbp', config: { deviceId: 'd1' } });
+        expect(registerDevice).toHaveBeenCalledWith(expect.objectContaining({ apiUrl: 'https://api.x', connectToken: baseConfig.connectToken }), 'bunny-mbp');
+    });
+    it('is idempotent — skips the network call when a deviceId is already persisted', async () => {
+        const registerDevice = jest.fn();
+        const config = { ...baseConfig, deviceId: 'd1' };
+        const result = await (0, deviceRegistration_1.ensureDeviceRegistered)(config, 'https://api.x', { registerDevice, hostname: () => 'x' });
+        expect(registerDevice).not.toHaveBeenCalled();
+        expect(result).toMatchObject({ registered: false, config: { deviceId: 'd1' } });
+    });
+    it('surfaces a clear error instead of throwing when registration fails', async () => {
+        const registerDevice = jest.fn().mockRejectedValue(new Error('device registration failed: HTTP 500'));
+        const result = await (0, deviceRegistration_1.ensureDeviceRegistered)(baseConfig, 'https://api.x', { registerDevice, hostname: () => 'x' });
+        expect('error' in result && result.error).toContain('device registration failed');
+    });
+});

package/dist/__tests__/bridge-folder-picker-runner.test.d.ts

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

package/dist/__tests__/bridge-folder-picker-runner.test.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * TDD — lws-05: the real execFile-backed PickFolderRunner and the zenity
+ * presence probe used by commands/bridge.ts to wire POST /local/pick-folder.
+ * child_process is mocked — this test never spawns a real process.
+ */
+const mockExecFile = jest.fn();
+jest.mock('child_process', () => ({
+    execFile: (...args) => mockExecFile(...args),
+}));
+const folderPickerRunner_1 = require("../bridge/folderPickerRunner");
+beforeEach(() => {
+    jest.clearAllMocks();
+});
+describe('execFileRunner', () => {
+    it('resolves with stdout and exit code 0 on success', async () => {
+        mockExecFile.mockImplementation((cmd, args, cb) => cb(null, '/Users/x/app\n', ''));
+        const result = await (0, folderPickerRunner_1.execFileRunner)('osascript', ['-e', 'POSIX path of (choose folder)']);
+        expect(result).toEqual({ stdout: '/Users/x/app\n', code: 0 });
+        expect(mockExecFile).toHaveBeenCalledWith('osascript', ['-e', 'POSIX path of (choose folder)'], expect.any(Function));
+    });
+    it('rejects when the process errors (e.g. user cancelled)', async () => {
+        mockExecFile.mockImplementation((cmd, args, cb) => cb(new Error('User canceled'), '', ''));
+        await expect((0, folderPickerRunner_1.execFileRunner)('osascript', ['-e', 'x'])).rejects.toThrow('User canceled');
+    });
+});
+describe('hasZenityInstalled', () => {
+    it('true when `which zenity` (or equivalent probe) succeeds', async () => {
+        mockExecFile.mockImplementation((cmd, args, cb) => cb(null, '/usr/bin/zenity\n', ''));
+        expect(await (0, folderPickerRunner_1.hasZenityInstalled)()).toBe(true);
+    });
+    it('false when the probe fails (zenity not installed)', async () => {
+        mockExecFile.mockImplementation((cmd, args, cb) => cb(new Error('not found'), '', ''));
+        expect(await (0, folderPickerRunner_1.hasZenityInstalled)()).toBe(false);
+    });
+});

package/dist/__tests__/bridge-folder-picker.test.d.ts

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

package/dist/__tests__/bridge-folder-picker.test.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * TDD — lws-05: OS-native folder picker (PRD D3b) behind POST
+ * /local/pick-folder. `pickerCommandFor` is a pure command table (no spawn —
+ * directly testable per platform). `pickFolder` spawns it with an injected
+ * runner (NO real osascript/PowerShell/zenity in tests, per the issue).
+ */
+const folderPicker_1 = require("../bridge/folderPicker");
+describe('pickerCommandFor — platform command table', () => {
+    it('macOS uses osascript "choose folder"', () => {
+        expect((0, folderPicker_1.pickerCommandFor)('darwin', { hasZenity: false })).toEqual({
+            cmd: 'osascript',
+            args: ['-e', 'POSIX path of (choose folder)'],
+        });
+    });
+    it('Windows uses a PowerShell FolderBrowserDialog one-liner', () => {
+        const table = (0, folderPicker_1.pickerCommandFor)('win32', { hasZenity: false });
+        expect(table?.cmd).toBe('powershell.exe');
+        expect(table?.args.join(' ')).toMatch(/FolderBrowserDialog/);
+    });
+    it('Linux with zenity available uses zenity --file-selection --directory', () => {
+        expect((0, folderPicker_1.pickerCommandFor)('linux', { hasZenity: true })).toEqual({
+            cmd: 'zenity',
+            args: ['--file-selection', '--directory'],
+        });
+    });
+    it('Linux without zenity is unsupported (null) — falls through to typed path', () => {
+        expect((0, folderPicker_1.pickerCommandFor)('linux', { hasZenity: false })).toBeNull();
+    });
+    it('any other platform is unsupported', () => {
+        expect((0, folderPicker_1.pickerCommandFor)('freebsd', { hasZenity: false })).toBeNull();
+    });
+});
+function fakeRunner(behavior) {
+    return (cmd, args) => new Promise((resolve, reject) => {
+        const b = behavior(cmd, args);
+        if (b.err)
+            reject(b.err);
+        else
+            resolve({ stdout: b.stdout ?? '', code: b.code ?? 0 });
+    });
+}
+describe('pickFolder', () => {
+    it('returns the chosen path, trimmed, on success', async () => {
+        const run = fakeRunner(() => ({ stdout: '/Users/x/my-app\n', code: 0 }));
+        const result = await (0, folderPicker_1.pickFolder)({ platform: 'darwin', hasZenity: false, run });
+        expect(result).toEqual({ path: '/Users/x/my-app' });
+    });
+    it('returns {cancelled:true} when the user dismisses the dialog (non-zero exit, no path)', async () => {
+        const run = fakeRunner(() => { throw Object.assign(new Error('User canceled'), { code: 1 }); });
+        const result = await (0, folderPicker_1.pickFolder)({ platform: 'darwin', hasZenity: false, run });
+        expect(result).toEqual({ cancelled: true });
+    });
+    it('returns {unsupported:true} on Linux without zenity — never spawns', async () => {
+        const run = jest.fn();
+        const result = await (0, folderPicker_1.pickFolder)({ platform: 'linux', hasZenity: false, run });
+        expect(result).toEqual({ unsupported: true });
+        expect(run).not.toHaveBeenCalled();
+    });
+    it('treats empty stdout as a cancel (some pickers exit 0 with nothing chosen)', async () => {
+        const run = fakeRunner(() => ({ stdout: '   \n', code: 0 }));
+        const result = await (0, folderPicker_1.pickFolder)({ platform: 'darwin', hasZenity: false, run });
+        expect(result).toEqual({ cancelled: true });
+    });
+});

package/dist/__tests__/bridge-folder-registry.test.d.ts

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

package/dist/__tests__/bridge-folder-registry.test.js

@@ -0,0 +1,107 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * TDD — lws-03: bridge/folderRegistry.ts. Persisted path→workspaceId map
+ * (`~/.wen-market/local-workspaces.json`), survives daemon restart, backs
+ * `wen-market local add/list/remove` and the discovery advertisement.
+ */
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const folderRegistry_1 = require("../bridge/folderRegistry");
+describe('folder registry — pure in-memory ops', () => {
+    it('upsertEntry adds a path→workspace entry, idempotent by path', () => {
+        let registry = loadFolderRegistryFrom({});
+        registry = (0, folderRegistry_1.upsertEntry)(registry, '/Users/x/my-app', { workspaceId: 'ws-1', name: 'my-app', addedAt: '2026-08-11T00:00:00.000Z' });
+        expect((0, folderRegistry_1.findEntryByPath)(registry, '/Users/x/my-app')?.workspaceId).toBe('ws-1');
+        expect(Object.keys(registry.entries)).toHaveLength(1);
+    });
+    it('findEntryByPath returns null when unregistered', () => {
+        const registry = loadFolderRegistryFrom({});
+        expect((0, folderRegistry_1.findEntryByPath)(registry, '/nope')).toBeNull();
+    });
+    it('findEntryByWorkspaceId looks up by the bound workspace id', () => {
+        let registry = loadFolderRegistryFrom({});
+        registry = (0, folderRegistry_1.upsertEntry)(registry, '/Users/x/my-app', { workspaceId: 'ws-1', name: 'my-app', addedAt: 'now' });
+        expect((0, folderRegistry_1.findEntryByWorkspaceId)(registry, 'ws-1')?.path).toBe('/Users/x/my-app');
+        expect((0, folderRegistry_1.findEntryByWorkspaceId)(registry, 'nope')).toBeNull();
+    });
+    it('removeEntryByPath drops exactly that entry', () => {
+        let registry = loadFolderRegistryFrom({});
+        registry = (0, folderRegistry_1.upsertEntry)(registry, '/a', { workspaceId: 'ws-a', name: 'a', addedAt: 'now' });
+        registry = (0, folderRegistry_1.upsertEntry)(registry, '/b', { workspaceId: 'ws-b', name: 'b', addedAt: 'now' });
+        registry = (0, folderRegistry_1.removeEntryByPath)(registry, '/a');
+        expect((0, folderRegistry_1.findEntryByPath)(registry, '/a')).toBeNull();
+        expect((0, folderRegistry_1.findEntryByPath)(registry, '/b')).not.toBeNull();
+    });
+    it('removeEntryByWorkspaceId drops the entry bound to that workspace', () => {
+        let registry = loadFolderRegistryFrom({});
+        registry = (0, folderRegistry_1.upsertEntry)(registry, '/a', { workspaceId: 'ws-a', name: 'a', addedAt: 'now' });
+        registry = (0, folderRegistry_1.removeEntryByWorkspaceId)(registry, 'ws-a');
+        expect((0, folderRegistry_1.findEntryByPath)(registry, '/a')).toBeNull();
+    });
+    function loadFolderRegistryFrom(entries) {
+        return { v: 1, entries };
+    }
+});
+describe('folder registry — file-backed (survives daemon restart)', () => {
+    let dir;
+    beforeEach(() => {
+        dir = fs.mkdtempSync(path.join(os.tmpdir(), 'folder-registry-test-'));
+    });
+    afterEach(() => {
+        fs.rmSync(dir, { recursive: true, force: true });
+    });
+    it('returns an empty registry when no file exists yet', () => {
+        const registry = (0, folderRegistry_1.loadFolderRegistry)(dir);
+        expect(registry).toEqual({ v: 1, entries: {} });
+    });
+    it('saves and reloads entries 0600, round-tripping across a fresh load (restart)', () => {
+        let registry = (0, folderRegistry_1.loadFolderRegistry)(dir);
+        registry = (0, folderRegistry_1.upsertEntry)(registry, '/Users/x/my-app', { workspaceId: 'ws-1', name: 'my-app', addedAt: '2026-08-11T00:00:00.000Z' });
+        (0, folderRegistry_1.saveFolderRegistry)(registry, dir);
+        const file = path.join(dir, 'local-workspaces.json');
+        expect(fs.statSync(file).mode & 0o777).toBe(0o600);
+        // Simulate the daemon restarting: reload from disk.
+        const reloaded = (0, folderRegistry_1.loadFolderRegistry)(dir);
+        expect((0, folderRegistry_1.findEntryByPath)(reloaded, '/Users/x/my-app')?.workspaceId).toBe('ws-1');
+    });
+    it('returns an empty registry on corrupt JSON rather than throwing', () => {
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(path.join(dir, 'local-workspaces.json'), 'not json{');
+        expect((0, folderRegistry_1.loadFolderRegistry)(dir)).toEqual({ v: 1, entries: {} });
+    });
+});

package/dist/__tests__/bridge-frame-pacer.test.d.ts

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

package/dist/__tests__/bridge-frame-pacer.test.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * cbs-01 — keep-newest frame pacer (pure, no I/O, no timers).
+ *
+ * The cloud browser session streams JPEG screencast frames from a headless
+ * Chromium down to the pane. The relay/bridge/pane chain must never let a
+ * slow consumer balloon memory: at most ONE undelivered frame may sit ahead
+ * of the consumer at any time, and a fresh frame arriving while one is
+ * already queued REPLACES it (the replaced frame counts as dropped, never
+ * queued). Delivery of the queued frame is gated entirely on the consumer's
+ * ack — the pacer holds no timers/cadence of its own (see framePacer.ts).
+ */
+const framePacer_1 = require("../bridge/framePacer");
+describe('createFramePacer (cbs-01)', () => {
+    it('delivers the first pushed frame immediately', () => {
+        const delivered = [];
+        const pacer = (0, framePacer_1.createFramePacer)({ onDeliver: (f) => delivered.push(f) });
+        pacer.push(1);
+        expect(delivered).toEqual([1]);
+        expect(pacer.deliveredCount).toBe(1);
+        expect(pacer.droppedCount).toBe(0);
+    });
+    it('slow consumer: drops accumulate while memory stays constant (only one frame ever held)', () => {
+        const delivered = [];
+        const pacer = (0, framePacer_1.createFramePacer)({ onDeliver: (f) => delivered.push(f) });
+        // Push 10 frames back-to-back with ZERO acks — simulates a consumer that
+        // never catches up (slow render / stalled network).
+        for (let i = 1; i <= 10; i++)
+            pacer.push(i);
+        // Only the very first frame was ever delivered (awaiting ack for it).
+        expect(delivered).toEqual([1]);
+        expect(pacer.deliveredCount).toBe(1);
+        // Frame 2 fills the empty queue slot (not a drop); frames 3..10 each
+        // replace the previously queued frame (8 drops).
+        expect(pacer.droppedCount).toBe(8);
+        // Acking now delivers the NEWEST queued frame (10), not frame 2 — proof
+        // the queue never grew past one slot and always held the latest.
+        pacer.ack();
+        expect(delivered).toEqual([1, 10]);
+        expect(pacer.deliveredCount).toBe(2);
+        expect(pacer.droppedCount).toBe(8); // unchanged — the ack didn't drop anything
+        // Nothing left queued — a further ack with no new push is a no-op.
+        pacer.ack();
+        expect(delivered).toEqual([1, 10]);
+        expect(pacer.deliveredCount).toBe(2);
+    });
+    it('fast consumer (acks before the next frame arrives): zero drops', () => {
+        const delivered = [];
+        const pacer = (0, framePacer_1.createFramePacer)({ onDeliver: (f) => delivered.push(f) });
+        for (let i = 1; i <= 20; i++) {
+            pacer.push(i);
+            pacer.ack(); // consumer keeps up — always acks before the next push
+        }
+        expect(delivered).toEqual(Array.from({ length: 20 }, (_, i) => i + 1));
+        expect(pacer.deliveredCount).toBe(20);
+        expect(pacer.droppedCount).toBe(0);
+    });
+    it('burst then idle: drops during the burst, one final deliver on ack, then silence', () => {
+        const delivered = [];
+        const pacer = (0, framePacer_1.createFramePacer)({ onDeliver: (f) => delivered.push(f) });
+        // Burst of 5 with no acks.
+        for (let i = 1; i <= 5; i++)
+            pacer.push(i);
+        expect(delivered).toEqual([1]);
+        expect(pacer.droppedCount).toBe(3); // frame 2 queued free, 3/4/5 each drop the prior queued
+        // Idle period: consumer finally acks. Delivers the newest queued (5).
+        pacer.ack();
+        expect(delivered).toEqual([1, 5]);
+        // True idle: no more pushes, repeated acks are no-ops (nothing queued,
+        // and nothing in flight to re-deliver).
+        pacer.ack();
+        pacer.ack();
+        expect(delivered).toEqual([1, 5]);
+        expect(pacer.deliveredCount).toBe(2);
+        expect(pacer.droppedCount).toBe(3);
+    });
+    it('ack-after-close is a safe no-op', () => {
+        const delivered = [];
+        const pacer = (0, framePacer_1.createFramePacer)({ onDeliver: (f) => delivered.push(f) });
+        pacer.push(1); // delivered, awaiting ack
+        pacer.push(2); // queued
+        pacer.close();
+        expect(() => pacer.ack()).not.toThrow();
+        // Nothing further delivered — the queued frame is discarded by close,
+        // not force-delivered.
+        expect(delivered).toEqual([1]);
+        expect(pacer.deliveredCount).toBe(1);
+        // A second ack-after-close is equally inert.
+        expect(() => pacer.ack()).not.toThrow();
+        expect(delivered).toEqual([1]);
+    });
+    it('push-after-close is also a safe no-op (no delivery, no counter growth)', () => {
+        const delivered = [];
+        const pacer = (0, framePacer_1.createFramePacer)({ onDeliver: (f) => delivered.push(f) });
+        pacer.close();
+        expect(() => pacer.push(1)).not.toThrow();
+        expect(delivered).toEqual([]);
+        expect(pacer.deliveredCount).toBe(0);
+        expect(pacer.droppedCount).toBe(0);
+    });
+});

package/dist/__tests__/bridge-install-bundle-frame.test.d.ts

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

package/dist/__tests__/bridge-install-bundle-frame.test.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * pucc-int-04 — the relay client honors the `install-bundle` frame.
+ *
+ * platform (pane/arena) → relay → container bridge: the bridge routes an
+ * `install-bundle` frame to the injected installer (which writes the FileMap
+ * into /data/repos/<workspaceId>) and acks with `bundle-installed`. No PTY /
+ * session is involved — installing a crew bundle is purely writing files
+ * (ADR-0032: Claude Code picks them up natively; no crewExecutionEngine).
+ *
+ * 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 — install-bundle frame (pucc-int-04)', () => {
+    it('routes an install-bundle frame to the injected installer and acks', 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,
+            installBundle: (bundle) => {
+                calls.push(bundle);
+                return { written: Object.keys(bundle.files), skipped: [] };
+            },
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        const files = { 'CLAUDE.md': 'crew', '.claude/agents/a.md': 'a' };
+        ws.send(JSON.stringify({ t: 'install-bundle', workspaceId: 'ws-7', files, sessionId: 'agent-A' }));
+        const ack = await q.next();
+        expect(calls).toEqual([{ workspaceId: 'ws-7', files }]);
+        expect(ack).toMatchObject({ t: 'bundle-installed', workspaceId: 'ws-7', sessionId: 'agent-A' });
+        expect(ack.written.sort()).toEqual(['.claude/agents/a.md', 'CLAUDE.md']);
+        // Installing a bundle must not open a PTY session.
+        expect(sessions.list()).toEqual([]);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('errors (never crashes) when no installer 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: 'install-bundle', workspaceId: 'ws-7', files: {} }));
+        expect((await q.next()).t).toBe('error');
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+});

package/dist/__tests__/bridge-local-add-core.test.d.ts

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