@wenrwa/marketplace-cli 0.4.4 → 0.4.6

package/dist/__tests__/bridge-local-add-core.test.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * TDD — lws-05: shared idempotent-add core behind POST /local/add (the
+ * bridge-side twin of `wen-market local add`, PRD D3). Deps-injected — no
+ * real fs/network — server.ts wires the real folderRegistry + apiClient.
+ */
+const localAdd_1 = require("../bridge/localAdd");
+function deps(registry, overrides = {}) {
+    let state = registry;
+    return {
+        loadRegistry: () => state,
+        saveRegistry: (r) => { state = r; },
+        createWorkspace: jest.fn().mockResolvedValue({ workspace: { id: 'ws-1', name: 'my-app' } }),
+        ...overrides,
+    };
+}
+describe('addLocalWorkspaceCore', () => {
+    it('creates a new workspace and registers the path when not already registered', async () => {
+        const d = deps({ v: 1, entries: {} });
+        const result = await (0, localAdd_1.addLocalWorkspaceCore)('/Users/x/my-app', undefined, d);
+        expect(result).toEqual({ status: 'created', workspace: { id: 'ws-1', name: 'my-app' } });
+        expect(d.createWorkspace).toHaveBeenCalledWith('my-app');
+        expect(d.loadRegistry().entries['/Users/x/my-app']).toMatchObject({ workspaceId: 'ws-1', name: 'my-app' });
+    });
+    it('is idempotent — re-adding the same path returns the existing workspace without creating a new one', async () => {
+        const d = deps({
+            v: 1,
+            entries: { '/Users/x/my-app': { workspaceId: 'ws-existing', name: 'my-app', addedAt: 'now' } },
+        });
+        const result = await (0, localAdd_1.addLocalWorkspaceCore)('/Users/x/my-app', undefined, d);
+        expect(result).toEqual({ status: 'existing', workspace: { id: 'ws-existing', name: 'my-app' } });
+        expect(d.createWorkspace).not.toHaveBeenCalled();
+    });
+    it('uses a name override when provided, falling back to basename otherwise', async () => {
+        const d = deps({ v: 1, entries: {} });
+        await (0, localAdd_1.addLocalWorkspaceCore)('/Users/x/my-app', 'Custom Name', d);
+        expect(d.createWorkspace).toHaveBeenCalledWith('Custom Name');
+    });
+    it('surfaces a typed error without leaving a half-registered entry when creation fails', async () => {
+        const d = deps({ v: 1, entries: {} }, {
+            createWorkspace: jest.fn().mockRejectedValue(new Error('device offline')),
+        });
+        const result = await (0, localAdd_1.addLocalWorkspaceCore)('/Users/x/my-app', undefined, d);
+        expect(result).toEqual({ status: 'error', message: 'device offline' });
+        expect(d.loadRegistry().entries['/Users/x/my-app']).toBeUndefined();
+    });
+});

package/dist/__tests__/bridge-local-path-validation-fs.test.d.ts

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

package/dist/__tests__/bridge-local-path-validation-fs.test.js

@@ -0,0 +1,88 @@
+"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-05: the real fs-backed LocalPathDeps (node:fs), used by
+ * commands/bridge.ts to wire POST /local/validate-path. Exercises actual
+ * temp directories — no mocking fs itself (prior art: bridge-repo-checkout
+ * tests use real tmp dirs for the same reason: path/fs edge cases are worth
+ * testing for real).
+ */
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const localPathValidationFs_1 = require("../bridge/localPathValidationFs");
+const localPathValidation_1 = require("../bridge/localPathValidation");
+describe('realLocalPathDeps (fs-backed)', () => {
+    let dir;
+    beforeEach(() => {
+        dir = fs.mkdtempSync(path.join(os.tmpdir(), 'lws05-validate-'));
+    });
+    afterEach(() => {
+        fs.rmSync(dir, { recursive: true, force: true });
+    });
+    it('validates a real folder: exists, is a dir, readable, counts files, no .git', async () => {
+        fs.writeFileSync(path.join(dir, 'a.ts'), '');
+        fs.writeFileSync(path.join(dir, 'b.ts'), '');
+        fs.mkdirSync(path.join(dir, 'sub'));
+        fs.writeFileSync(path.join(dir, 'sub', 'c.ts'), '');
+        const result = await (0, localPathValidation_1.validateLocalPath)(dir, (0, localPathValidationFs_1.realLocalPathDeps)());
+        expect(result).toEqual({ ok: true, name: path.basename(dir), fileCount: 3, isGitRepo: false });
+    });
+    it('detects a git repo via .git directory', async () => {
+        fs.mkdirSync(path.join(dir, '.git'));
+        const result = await (0, localPathValidation_1.validateLocalPath)(dir, (0, localPathValidationFs_1.realLocalPathDeps)());
+        expect(result.ok && result.isGitRepo).toBe(true);
+    });
+    it('reports not-exists for a missing path', async () => {
+        const result = await (0, localPathValidation_1.validateLocalPath)(path.join(dir, 'does-not-exist'), (0, localPathValidationFs_1.realLocalPathDeps)());
+        expect(result).toEqual({ ok: false, error: 'not-exists' });
+    });
+    it('reports not-dir when the path is a plain file', async () => {
+        const filePath = path.join(dir, 'file.txt');
+        fs.writeFileSync(filePath, 'x');
+        const result = await (0, localPathValidation_1.validateLocalPath)(filePath, (0, localPathValidationFs_1.realLocalPathDeps)());
+        expect(result).toEqual({ ok: false, error: 'not-dir' });
+    });
+    it('skips node_modules and .git when counting files', async () => {
+        fs.mkdirSync(path.join(dir, 'node_modules'));
+        fs.writeFileSync(path.join(dir, 'node_modules', 'huge.js'), '');
+        fs.mkdirSync(path.join(dir, '.git'));
+        fs.writeFileSync(path.join(dir, '.git', 'HEAD'), '');
+        fs.writeFileSync(path.join(dir, 'index.ts'), '');
+        const result = await (0, localPathValidation_1.validateLocalPath)(dir, (0, localPathValidationFs_1.realLocalPathDeps)());
+        expect(result).toEqual({ ok: true, name: path.basename(dir), fileCount: 1, isGitRepo: true });
+    });
+});

package/dist/__tests__/bridge-local-path-validation.test.d.ts

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

package/dist/__tests__/bridge-local-path-validation.test.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * TDD — lws-05: POST /local/validate-path support. Pure validation logic
+ * (fs injected — no real disk I/O in tests), backing the create-modal's
+ * typed-path fallback (PRD D3c): "my-app — 214 files, git repo detected".
+ */
+const localPathValidation_1 = require("../bridge/localPathValidation");
+function deps(overrides = {}) {
+    return {
+        exists: () => true,
+        isDirectory: () => true,
+        readable: () => true,
+        countFiles: () => 3,
+        isGitRepo: () => false,
+        ...overrides,
+    };
+}
+describe('validateLocalPath', () => {
+    it('returns ok:false not-exists when the path does not exist', async () => {
+        const result = await (0, localPathValidation_1.validateLocalPath)('/nope', deps({ exists: () => false }));
+        expect(result).toEqual({ ok: false, error: 'not-exists' });
+    });
+    it('returns ok:false not-dir when the path is a file, not a folder', async () => {
+        const result = await (0, localPathValidation_1.validateLocalPath)('/some/file.txt', deps({ isDirectory: () => false }));
+        expect(result).toEqual({ ok: false, error: 'not-dir' });
+    });
+    it('returns ok:false unreadable when the folder cannot be read', async () => {
+        const result = await (0, localPathValidation_1.validateLocalPath)('/locked', deps({ readable: () => false }));
+        expect(result).toEqual({ ok: false, error: 'unreadable' });
+    });
+    it('returns ok:true with name (basename), file count, and git-repo flag', async () => {
+        const result = await (0, localPathValidation_1.validateLocalPath)('/Users/x/my-app', deps({ countFiles: () => 214, isGitRepo: () => true }));
+        expect(result).toEqual({ ok: true, name: 'my-app', fileCount: 214, isGitRepo: true });
+    });
+    it('reports isGitRepo:false for a plain folder-of-code with no .git', async () => {
+        const result = await (0, localPathValidation_1.validateLocalPath)('/Users/x/scratch', deps({ isGitRepo: () => false }));
+        expect(result.ok && result.isGitRepo).toBe(false);
+    });
+    it('checks existence before directory-ness before readability (short-circuits, does not call later checks)', async () => {
+        const isDirectory = jest.fn(() => true);
+        await (0, localPathValidation_1.validateLocalPath)('/nope', deps({ exists: () => false, isDirectory }));
+        expect(isDirectory).not.toHaveBeenCalled();
+    });
+});

package/dist/__tests__/bridge-login-status.test.d.ts

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

package/dist/__tests__/bridge-login-status.test.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * pucc-14 — in-box login-validity check (ADR-0028 boundary).
+ *
+ * The bridge reduces the on-volume Claude Code login to a single BOOLEAN so the
+ * platform can render connected / needs_relogin without ever handling the
+ * credential. These tests pin: valid / expired / missing → boolean, and that
+ * the token value is NEVER extracted or returned — only the expiry is read.
+ */
+const loginStatus_1 = require("../bridge/loginStatus");
+const CLAUDE_DIR = '/data/.claude';
+const CRED_PATH = `${CLAUDE_DIR}/${loginStatus_1.CLAUDE_CREDENTIALS_FILE}`;
+const NOW = 1_000_000_000_000;
+const SECRET = 'sk-ant-oat-SUPER-SECRET-TOKEN-must-never-leak';
+function makeDeps(over) {
+    const { file, missing, ...rest } = over;
+    return {
+        claudeDir: CLAUDE_DIR,
+        exists: (p) => !missing && p === CRED_PATH,
+        readJson: () => file,
+        now: () => NOW,
+        ...rest,
+    };
+}
+describe('checkClaudeLoginValid — existence + expiry only → boolean', () => {
+    it('returns false when the credentials file is missing (never logged in)', () => {
+        expect((0, loginStatus_1.checkClaudeLoginValid)(makeDeps({ missing: true }))).toBe(false);
+    });
+    it('returns true for a non-expired login (expiry in the future)', () => {
+        const file = { claudeAiOauth: { accessToken: SECRET, refreshToken: SECRET, expiresAt: NOW + 60_000 } };
+        expect((0, loginStatus_1.checkClaudeLoginValid)(makeDeps({ file }))).toBe(true);
+    });
+    it('returns false for an expired login (expiry in the past)', () => {
+        const file = { claudeAiOauth: { accessToken: SECRET, expiresAt: NOW - 1 } };
+        expect((0, loginStatus_1.checkClaudeLoginValid)(makeDeps({ file }))).toBe(false);
+    });
+    it('treats a present file with no expiry field as valid (existence is the signal)', () => {
+        const file = { claudeAiOauth: { accessToken: SECRET } };
+        expect((0, loginStatus_1.checkClaudeLoginValid)(makeDeps({ file }))).toBe(true);
+    });
+    it('tolerates a flat (un-nested) shape', () => {
+        expect((0, loginStatus_1.checkClaudeLoginValid)(makeDeps({ file: { expiresAt: NOW + 5 } }))).toBe(true);
+        expect((0, loginStatus_1.checkClaudeLoginValid)(makeDeps({ file: { expiresAt: NOW - 5 } }))).toBe(false);
+    });
+    it('returns false when the file is corrupt / unparseable', () => {
+        const deps = makeDeps({});
+        deps.readJson = () => {
+            throw new Error('unexpected token');
+        };
+        expect((0, loginStatus_1.checkClaudeLoginValid)(deps)).toBe(false);
+    });
+    it('always returns a boolean and NEVER the token value', () => {
+        const file = { claudeAiOauth: { accessToken: SECRET, refreshToken: SECRET, expiresAt: NOW + 1 } };
+        const result = (0, loginStatus_1.checkClaudeLoginValid)(makeDeps({ file }));
+        expect(typeof result).toBe('boolean');
+        // The return type is boolean, so the token can never ride out through it.
+        expect(JSON.stringify(result)).not.toContain(SECRET);
+    });
+});

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

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

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

@@ -0,0 +1,283 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ws_1 = require("ws");
+const relayClient_1 = require("../bridge/relayClient");
+const sessionManager_1 = require("../bridge/sessionManager");
+// ── Fake PTY (no real shells in CI) ──────────────────────────────────
+class FakePty {
+    written = [];
+    resizes = [];
+    killed = false;
+    dataCb = null;
+    write(data) { this.written.push(data); }
+    resize(cols, rows) { this.resizes.push({ cols, rows }); }
+    kill() { this.killed = true; }
+    onData(cb) { this.dataCb = cb; }
+    onExit(_cb) { }
+    emitData(d) { this.dataCb?.(d); }
+}
+const makeFactory = () => {
+    const ptys = [];
+    const factory = {
+        spawn: () => {
+            const p = new FakePty();
+            ptys.push(p);
+            return p;
+        },
+    };
+    return { factory, ptys };
+};
+/** Collects parsed frames and lets tests await the next one (mirrors bridge-server.test.ts). */
+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((resolve) => waiters.push(resolve)),
+    };
+}
+/** A loopback ws server standing in for the platform relay. */
+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 — dial-out handshake', () => {
+    it('connects to the relay URL and sends the v1 auth frame first', 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: 'relay-token-abc',
+            sessions,
+        });
+        const serverSideWs = await relay.nextConnection();
+        const q = frameQueue(serverSideWs);
+        const authFrame = await q.next();
+        expect(authFrame).toEqual({ v: 1, relayToken: 'relay-token-abc' });
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+});
+describe('relay client — frame service through the SessionManager', () => {
+    it('open -> opened; input reaches the PTY; PTY data streams back over the single socket', 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 frame
+        ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24 }));
+        const opened = await q.next();
+        expect(opened.t).toBe('opened');
+        expect(opened.sessionId).toBeTruthy();
+        ws.send(JSON.stringify({ t: 'input', sessionId: opened.sessionId, data: 'ls\r' }));
+        await new Promise((r) => setTimeout(r, 20));
+        expect(ptys[0].written).toEqual(['ls\r']);
+        ptys[0].emitData('result');
+        const data = await q.next();
+        expect(data).toMatchObject({ t: 'data', sessionId: opened.sessionId, data: 'result' });
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('second attach takes over: prior sink gets takeover, new one gets replay', 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 }));
+        const opened = await q.next();
+        ptys[0].emitData('history');
+        await q.next(); // 'history' data frame
+        ws.send(JSON.stringify({ t: 'attach', sessionId: opened.sessionId }));
+        const [takeover, replay] = [await q.next(), await q.next()];
+        // Order isn't guaranteed between takeover-to-old-sink and replay-to-new
+        // sink over the SAME socket, so match by type.
+        const byType = (t) => [takeover, replay].find((f) => f.t === t);
+        expect(byType('takeover')).toMatchObject({ t: 'takeover', sessionId: opened.sessionId });
+        expect(byType('replay')).toMatchObject({ t: 'replay', sessionId: opened.sessionId, data: 'history' });
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('multiplexes multiple concurrent sessions over the one outbound socket', 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 }));
+        const openedA = await q.next();
+        ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24 }));
+        const openedB = await q.next();
+        expect(openedA.sessionId).not.toBe(openedB.sessionId);
+        ws.send(JSON.stringify({ t: 'input', sessionId: openedA.sessionId, data: 'to-a' }));
+        ws.send(JSON.stringify({ t: 'input', sessionId: openedB.sessionId, data: 'to-b' }));
+        await new Promise((r) => setTimeout(r, 20));
+        expect(ptys[0].written).toEqual(['to-a']);
+        expect(ptys[1].written).toEqual(['to-b']);
+        ws.send(JSON.stringify({ t: 'resize', sessionId: openedB.sessionId, cols: 100, rows: 40 }));
+        await new Promise((r) => setTimeout(r, 20));
+        expect(ptys[1].resizes).toEqual([{ cols: 100, rows: 40 }]);
+        ws.send(JSON.stringify({ t: 'close', sessionId: openedA.sessionId }));
+        await new Promise((r) => setTimeout(r, 20));
+        expect(ptys[0].killed).toBe(true);
+        expect(sessions.list()).toEqual([openedB.sessionId]);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+});
+describe('relay client — reconnect with backoff + jitter', () => {
+    it('on drop, schedules a reconnect using the computed backoff delay (injectable timer)', async () => {
+        const relay = await startFakeRelay();
+        const { factory } = makeFactory();
+        const sessions = new sessionManager_1.SessionManager(factory);
+        const scheduled = [];
+        const setTimeoutFn = (cb, ms) => {
+            scheduled.push({ cb, ms });
+            return scheduled.length; // opaque handle
+        };
+        const clearTimeoutFn = () => { };
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            backoff: { initialMs: 100, maxMs: 1000, factor: 2, jitter: () => 1 }, // deterministic: full ceiling
+            setTimeoutFn,
+            clearTimeoutFn,
+        });
+        const ws = await relay.nextConnection(); // already open by the time 'connection' fires
+        // Drop the connection from the relay side.
+        ws.terminate();
+        await new Promise((r) => setTimeout(r, 30));
+        expect(scheduled.length).toBe(1);
+        expect(scheduled[0].ms).toBe(100); // attempt 0: 100 * 2^0 * jitter(1) = 100
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('backoff grows exponentially per attempt, capped at maxMs', async () => {
+        // A relay that never accepts a connection (nothing listens on this port)
+        // means every attempt fails before 'open' — so attempt count never
+        // resets, and we can observe pure exponential growth without racing a
+        // real handshake's success-resets-backoff behavior.
+        const probe = await startFakeRelay();
+        const deadPort = probe.port;
+        await closeRelay(probe.wss);
+        const { factory } = makeFactory();
+        const sessions = new sessionManager_1.SessionManager(factory);
+        const scheduled = [];
+        const setTimeoutFn = (cb, ms) => {
+            scheduled.push({ cb, ms });
+            return scheduled.length;
+        };
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${deadPort}`,
+            relayToken: 'tok',
+            sessions,
+            backoff: { initialMs: 100, maxMs: 350, factor: 2, jitter: () => 1 },
+            setTimeoutFn,
+            clearTimeoutFn: () => { },
+        });
+        await new Promise((r) => setTimeout(r, 50));
+        expect(scheduled[0]?.ms).toBe(100); // 100 * 2^0
+        scheduled[0].cb();
+        await new Promise((r) => setTimeout(r, 50));
+        expect(scheduled[1]?.ms).toBe(200); // 100 * 2^1
+        scheduled[1].cb();
+        await new Promise((r) => setTimeout(r, 50));
+        expect(scheduled[2]?.ms).toBe(350); // 100 * 2^2 = 400, capped at 350
+        handle.close();
+    });
+    it('reconnects and re-pairs: PTY survives the drop, replay reflects everything that happened while down', async () => {
+        const relay = await startFakeRelay();
+        const { factory, ptys } = makeFactory();
+        const sessions = new sessionManager_1.SessionManager(factory);
+        const scheduled = [];
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            backoff: { initialMs: 1, jitter: () => 0.01 },
+            setTimeoutFn: (cb) => {
+                scheduled.push(cb);
+                return scheduled.length;
+            },
+            clearTimeoutFn: () => { },
+        });
+        const ws1 = await relay.nextConnection();
+        const q1 = frameQueue(ws1);
+        await q1.next(); // auth
+        ws1.send(JSON.stringify({ t: 'open', cols: 80, rows: 24 }));
+        const opened = await q1.next();
+        // Drop the relay connection — the PTY must NOT be killed.
+        ws1.terminate();
+        await new Promise((r) => setTimeout(r, 20));
+        expect(ptys[0].killed).toBe(false);
+        expect(sessions.list()).toEqual([opened.sessionId]);
+        // Session produces output while the relay link is down.
+        ptys[0].emitData('while-down');
+        // Fire the scheduled reconnect (simulates backoff timer elapsing).
+        expect(scheduled.length).toBe(1);
+        scheduled[0]();
+        const ws2 = await relay.nextConnection();
+        const q2 = frameQueue(ws2);
+        await q2.next(); // fresh auth frame on the new socket
+        ws2.send(JSON.stringify({ t: 'attach', sessionId: opened.sessionId }));
+        const replay = await q2.next();
+        expect(replay).toMatchObject({ t: 'replay', sessionId: opened.sessionId, data: 'while-down' });
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+});

package/dist/__tests__/bridge-relay-mode.test.d.ts

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

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bridge_1 = require("../commands/bridge");
+describe('resolveRelayMode — CLI/env wiring for `wen-market bridge --relay`', () => {
+    it('no --relay flag and no RELAY_URL env → local mode', () => {
+        expect((0, bridge_1.resolveRelayMode)({}, {})).toEqual({ mode: 'local' });
+    });
+    it('--relay without --relay-token → a clear startup error, no env fallback', () => {
+        const result = (0, bridge_1.resolveRelayMode)({ relay: 'wss://relay.hiveop.io/agent' }, {});
+        expect(result.mode).toBe('relay-error');
+        expect(result.message).toMatch(/relay-token/i);
+    });
+    it('--relay with --relay-token → relay mode with both values', () => {
+        const result = (0, bridge_1.resolveRelayMode)({ relay: 'wss://relay.hiveop.io/agent', relayToken: 'rt_abc123' }, {});
+        expect(result).toEqual({
+            mode: 'relay',
+            relayUrl: 'wss://relay.hiveop.io/agent',
+            relayToken: 'rt_abc123',
+        });
+    });
+    it('RELAY_URL + RELAY_TOKEN env vars (container-friendly) → relay mode, no flags needed', () => {
+        const result = (0, bridge_1.resolveRelayMode)({}, { RELAY_URL: 'wss://relay.internal/x', RELAY_TOKEN: 'rt_env' });
+        expect(result).toEqual({ mode: 'relay', relayUrl: 'wss://relay.internal/x', relayToken: 'rt_env' });
+    });
+    it('RELAY_URL env with no token anywhere → clear startup error', () => {
+        const result = (0, bridge_1.resolveRelayMode)({}, { RELAY_URL: 'wss://relay.internal/x' });
+        expect(result.mode).toBe('relay-error');
+    });
+    it('flag values win over env vars when both present', () => {
+        const result = (0, bridge_1.resolveRelayMode)({ relay: 'wss://flag-wins/', relayToken: 'flag-token' }, { RELAY_URL: 'wss://env-loses/', RELAY_TOKEN: 'env-token' });
+        expect(result).toEqual({ mode: 'relay', relayUrl: 'wss://flag-wins/', relayToken: 'flag-token' });
+    });
+});

package/dist/__tests__/bridge-relay-pucc14.test.d.ts

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