@wenrwa/marketplace-cli 0.6.5 → 0.7.0

package/dist/__tests__/bridge-park-remove-frame.test.js

@@ -349,4 +349,65 @@ describe('relay client — park-remove frame (hcs-06)', () => {
             await closeRelay(relay.wss);
         }
     });
+    it('park-save backs up and KEEPS the checkout: committing, pushing, then a saved result — no remove', async () => {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        const gitFixture = makeGitFixture();
+        const reclaimFs = makeReclaimFsFixture([`${REPOS}/ws-1`]);
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            enableReclaim: true,
+            reposBaseDir: REPOS,
+            checkoutReclaimDeps: reclaimFs,
+            enableParkAndRemove: true,
+            checkoutParkAndRemoveDeps: { exists: reclaimFs.exists, run: gitFixture.run },
+        });
+        try {
+            const ws = await relay.nextConnection();
+            const q = frameQueue(ws);
+            await q.next(); // auth
+            ws.send(JSON.stringify({ t: 'park-save', workspaceId: 'ws-1' }));
+            expect(await q.next()).toMatchObject({ t: 'park-remove-progress', phase: 'committing' });
+            expect(await q.next()).toMatchObject({ t: 'park-remove-progress', phase: 'pushing' });
+            expect(await q.next()).toMatchObject({ t: 'park-remove-result', workspaceId: 'ws-1', outcome: 'saved', branch: 'park/ws-1' });
+            expect(reclaimFs.removed).toEqual([]);
+        }
+        finally {
+            handle.close();
+            await closeRelay(relay.wss);
+        }
+    });
+    it('inventory-scan re-scans and sends a fresh checkout-inventory frame', async () => {
+        const relay = await startFakeRelay();
+        const sessions = new sessionManager_1.SessionManager(makeFactory());
+        let lists = 0;
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            reportCheckoutInventory: true,
+            reposBaseDir: REPOS,
+            checkoutInventoryDeps: {
+                listCheckouts: () => { lists += 1; return []; },
+                statMtimeMs: () => 1,
+                sizeBytes: async () => 0,
+                run: async () => ({ stdout: '', code: 0 }),
+            },
+        });
+        try {
+            const ws = await relay.nextConnection();
+            const q = frameQueue(ws);
+            await q.next(); // auth
+            expect(await q.next()).toMatchObject({ t: 'checkout-inventory' }); // on-connect scan
+            ws.send(JSON.stringify({ t: 'inventory-scan' }));
+            expect(await q.next()).toEqual({ t: 'checkout-inventory', checkouts: [] });
+            expect(lists).toBe(2);
+        }
+        finally {
+            handle.close();
+            await closeRelay(relay.wss);
+        }
+    });
 });

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

@@ -127,7 +127,7 @@ describe('relay client — checkout inventory scan never blocks connect (hcs-02
         const inventory = await q.next();
         expect(inventory).toEqual({
             t: 'checkout-inventory',
-            checkouts: [{ workspaceId: 'ws-a', unparseable: false, bytes: 4096, dirty: false, mtimeMs: 100 }],
+            checkouts: [{ workspaceId: 'ws-a', unparseable: false, bytes: 4096, dirty: false, mtimeMs: 100, dirtyKinds: [], noUpstream: false, scanVersion: 2 }],
         });
         handle.close();
         await closeRelay(relay.wss);

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

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const bridge_1 = require("../commands/bridge");
-describe('resolveRelayMode — CLI/env wiring for `wen-market bridge --relay`', () => {
+describe('resolveRelayMode — CLI/env wiring for `hiveop bridge --relay`', () => {
     it('no --relay flag and no RELAY_URL env → local mode', () => {
         expect((0, bridge_1.resolveRelayMode)({}, {})).toEqual({ mode: 'local' });
     });

package/dist/__tests__/bridge-rival-touch-forwarder.test.d.ts

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

package/dist/__tests__/bridge-rival-touch-forwarder.test.js

@@ -0,0 +1,266 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * rival-10 — a LOCAL agent's live file touches reach a ranked rival, like a
+ * hosted agent's. What leaves the laptop: agent id + file paths, only for a
+ * workspace the server says is a live ranked match this user owns. Nothing
+ * else, and nothing at all for any other workspace.
+ */
+const ws_1 = __importDefault(require("ws"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const server_1 = require("../bridge/server");
+const sessionManager_1 = require("../bridge/sessionManager");
+const rivalTouchForwarder_1 = require("../bridge/rivalTouchForwarder");
+const apiClient_1 = require("../bridge/apiClient");
+const MATCH_WS = 'bbbbbbbb-0000-4000-8000-00000000000b';
+const OTHER_WS = 'dddddddd-0000-4000-8000-00000000000d';
+const CHECKOUT = '/Users/bob/wenrwa-workspaces/m-11111111-b';
+function harness(statusOf, opts = {}) {
+    let now = 1_000_000;
+    const asked = [];
+    const sent = [];
+    const fwd = (0, rivalTouchForwarder_1.createRivalTouchForwarder)({
+        status: async (ws) => {
+            asked.push(ws);
+            const s = statusOf[ws] ?? { live: false, recheckMs: 600_000 };
+            if (s instanceof Error)
+                throw s;
+            return s;
+        },
+        send: async (workspaceId, touches) => {
+            if (opts.sendFails)
+                throw new Error('409 RANKED_RIVAL_CLOSED');
+            sent.push({ workspaceId, touches });
+        },
+        now: () => now,
+        scheduleInterval: () => 'h',
+        cancelInterval: () => undefined,
+    });
+    return { fwd, asked, sent, advance: (ms) => void (now += ms) };
+}
+describe('forwardablePaths — only paths, and only inside the checkout', () => {
+    it('relativises an absolute path under the checkout; keeps relative paths', () => {
+        expect((0, rivalTouchForwarder_1.forwardablePaths)([`${CHECKOUT}/src/planner.ts`, 'src/b.ts'], CHECKOUT)).toEqual(['src/planner.ts', 'src/b.ts']);
+    });
+    it('drops a path outside the checkout, climbing out, non-strings, duplicates', () => {
+        expect((0, rivalTouchForwarder_1.forwardablePaths)(['/etc/hosts', `${CHECKOUT}/../x.ts`, '../up.ts', 42, null, 'a.ts', 'a.ts'], CHECKOUT)).toEqual(['a.ts']);
+        expect((0, rivalTouchForwarder_1.forwardablePaths)('src/a.ts', CHECKOUT)).toEqual([]);
+    });
+    it('no known checkout: an absolute path is kept for the server to place (or drop)', () => {
+        expect((0, rivalTouchForwarder_1.forwardablePaths)(['/home/x/m-b/src/a.ts'])).toEqual(['/home/x/m-b/src/a.ts']);
+    });
+    it('caps paths per touch', () => {
+        expect((0, rivalTouchForwarder_1.forwardablePaths)(Array.from({ length: 40 }, (_, i) => `f${i}.ts`))).toHaveLength(20);
+    });
+});
+describe('createRivalTouchForwarder', () => {
+    it('a live match workspace: the touch goes up as agent id + paths — nothing else', async () => {
+        const h = harness({ [MATCH_WS]: { live: true, recheckMs: 15_000 } });
+        h.fwd.touch({
+            workspaceId: MATCH_WS,
+            agentId: 'agent-1',
+            filePaths: [`${CHECKOUT}/src/planner.ts`],
+            cwd: CHECKOUT,
+            // A caller passing more than it should: never forwarded.
+            ...{ thinking: 'Editing planner.ts', tool: 'Edit', content: 'secret code' },
+        });
+        await h.fwd.flush();
+        expect(h.asked).toEqual([MATCH_WS]);
+        expect(h.sent).toEqual([{ workspaceId: MATCH_WS, touches: [{ agentId: 'agent-1', filePaths: ['src/planner.ts'] }] }]);
+        const json = JSON.stringify(h.sent);
+        for (const w of ['Editing', 'Edit"', 'secret code', '/Users/bob'])
+            expect(json).not.toContain(w);
+    });
+    it('any other workspace: asked once (workspace id only), then nothing sent — and not asked again until recheck', async () => {
+        const h = harness({ [OTHER_WS]: { live: false, recheckMs: 600_000 } });
+        h.fwd.touch({ workspaceId: OTHER_WS, agentId: 'agent-1', filePaths: ['src/a.ts'] });
+        await h.fwd.flush();
+        h.fwd.touch({ workspaceId: OTHER_WS, agentId: 'agent-1', filePaths: ['src/b.ts'] });
+        await h.fwd.flush();
+        expect(h.sent).toEqual([]);
+        expect(h.asked).toEqual([OTHER_WS]);
+    });
+    it('before GO the server says "ask again soon"; touches then are dropped, the ones after GO fly', async () => {
+        const status = { [MATCH_WS]: { live: false, recheckMs: 5_000 } };
+        const h = harness(status);
+        h.fwd.touch({ workspaceId: MATCH_WS, agentId: 'a', filePaths: ['early.ts'] });
+        await h.fwd.flush();
+        expect(h.sent).toEqual([]);
+        status[MATCH_WS] = { live: true, recheckMs: 15_000 };
+        h.advance(5_001);
+        h.fwd.touch({ workspaceId: MATCH_WS, agentId: 'a', filePaths: ['late.ts'] });
+        await h.fwd.flush();
+        expect(h.sent.flatMap((s) => s.touches)).toEqual([{ agentId: 'a', filePaths: ['late.ts'] }]);
+    });
+    it('the match ends: the next status says no, and forwarding stops', async () => {
+        const status = { [MATCH_WS]: { live: true, recheckMs: 15_000 } };
+        const h = harness(status);
+        h.fwd.touch({ workspaceId: MATCH_WS, agentId: 'a', filePaths: ['one.ts'] });
+        await h.fwd.flush();
+        status[MATCH_WS] = { live: false, recheckMs: 600_000 };
+        h.advance(15_001);
+        h.fwd.touch({ workspaceId: MATCH_WS, agentId: 'a', filePaths: ['two.ts'] });
+        await h.fwd.flush();
+        expect(h.sent.flatMap((s) => s.touches.flatMap((t) => t.filePaths))).toEqual(['one.ts']);
+    });
+    it('a status failure is "not live": nothing is sent', async () => {
+        const h = harness({ [MATCH_WS]: new Error('offline') });
+        h.fwd.touch({ workspaceId: MATCH_WS, agentId: 'a', filePaths: ['x.ts'] });
+        await h.fwd.flush();
+        expect(h.sent).toEqual([]);
+    });
+    it('a refused POST stops forwarding for that workspace until it is asked again', async () => {
+        const h = harness({ [MATCH_WS]: { live: true, recheckMs: 15_000 } }, { sendFails: true });
+        h.fwd.touch({ workspaceId: MATCH_WS, agentId: 'a', filePaths: ['x.ts'] });
+        await h.fwd.flush();
+        h.fwd.touch({ workspaceId: MATCH_WS, agentId: 'a', filePaths: ['y.ts'] });
+        await h.fwd.flush();
+        expect(h.asked).toEqual([MATCH_WS]); // backed off: y.ts was dropped, not re-asked at once
+    });
+    it('a touch with no forwardable path, or no workspace, leaves nothing and asks nothing', async () => {
+        const h = harness({ [MATCH_WS]: { live: true, recheckMs: 15_000 } });
+        h.fwd.touch({ workspaceId: MATCH_WS, agentId: 'a', filePaths: ['/etc/hosts'], cwd: CHECKOUT });
+        h.fwd.touch({ workspaceId: '', agentId: 'a', filePaths: ['x.ts'] });
+        h.fwd.touch({ workspaceId: MATCH_WS, agentId: 'a', filePaths: undefined });
+        await h.fwd.flush();
+        expect(h.asked).toEqual([]);
+        expect(h.sent).toEqual([]);
+    });
+    it('batches: many touches in one flush go in requests of at most 50', async () => {
+        const h = harness({ [MATCH_WS]: { live: true, recheckMs: 15_000 } });
+        for (let i = 0; i < 120; i++)
+            h.fwd.touch({ workspaceId: MATCH_WS, agentId: 'a', filePaths: [`f${i}.ts`] });
+        await h.fwd.flush();
+        expect(h.sent.map((s) => s.touches.length)).toEqual([50, 50, 20]);
+    });
+});
+describe('apiClient — the two calls, over the Connect Token', () => {
+    it('status sends the workspace id only; POST sends { touches: [{ agentId, filePaths }] } only', async () => {
+        const calls = [];
+        const fetchImpl = async (url, init) => {
+            calls.push({ url, init });
+            return { ok: true, status: 200, json: async () => ({ success: true, data: { live: true, recheckMs: 15_000 } }) };
+        };
+        const api = { apiUrl: 'https://api.example/api/v1', connectToken: 'wm_ct_x', fetchImpl };
+        await expect((0, apiClient_1.getRivalTouchStatus)(api, MATCH_WS)).resolves.toEqual({ live: true, recheckMs: 15_000 });
+        await (0, apiClient_1.postRivalTouches)(api, MATCH_WS, [{ agentId: 'a', filePaths: ['src/x.ts'], thinking: 'no' }]);
+        expect(calls[0].url).toBe(`https://api.example/api/v1/ranked/workspaces/${MATCH_WS}/touches`);
+        expect(calls[0].init.method).toBe('GET');
+        expect(calls[0].init.body).toBeUndefined();
+        expect(calls[0].init.headers.Authorization).toBe('Bearer wm_ct_x');
+        expect(calls[1].init.method).toBe('POST');
+        expect(JSON.parse(calls[1].init.body)).toEqual({ touches: [{ agentId: 'a', filePaths: ['src/x.ts'] }] });
+    });
+});
+// ── the loopback server: which records reach the forwarder ──────────────────
+class FakePty {
+    write() { }
+    resize() { }
+    kill() { }
+    onData() { }
+    onExit() { }
+}
+const ORIGIN = 'https://app.hiveop.io';
+const TOKEN = 'session-token-123';
+describe('bridge server → forwardRivalTouch', () => {
+    it("a local workspace agent's tailed record hands on workspace + agent + paths (never thinking/tool); a record for any other session hands on nothing", async () => {
+        const file = fs.mkdtempSync(path.join(os.tmpdir(), 'rival10-activity-')) + '/activity.jsonl';
+        fs.writeFileSync(file, '');
+        const tick = { fn: null };
+        const forwarded = [];
+        const handle = await (0, server_1.startBridgeServer)({
+            sessionToken: TOKEN,
+            allowedOrigin: ORIGIN,
+            sessions: new sessionManager_1.SessionManager({ spawn: () => new FakePty() }),
+            resolveLocalAgentCwd: () => CHECKOUT,
+            activityFile: file,
+            hiveOpSettingsPath: '/Users/t/.wen-market/claude-hooks-settings.json',
+            activityScheduleInterval: (cb) => { tick.fn = cb; return 'h'; },
+            activityCancelInterval: () => { },
+            forwardRivalTouch: (t) => forwarded.push(t),
+        });
+        try {
+            const ws = new ws_1.default(`ws://127.0.0.1:${handle.port}`, { headers: { origin: ORIGIN } });
+            const frames = [];
+            ws.on('message', (raw) => frames.push(JSON.parse(String(raw))));
+            await new Promise((r) => ws.on('open', r));
+            ws.send(JSON.stringify({ v: 1, token: TOKEN }));
+            ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, agentId: 'agent-1', workspaceId: MATCH_WS }));
+            await waitFor(() => frames.some((f) => f.t === 'opened'));
+            fs.appendFileSync(file, [
+                { sessionId: 'agent-1', filePaths: [`${CHECKOUT}/src/planner.ts`], thinking: 'Editing planner.ts', tool: 'Edit' },
+                { sessionId: 'agent-1', thinking: 'Running npm test', tool: 'Bash' }, // no paths: nothing to forward
+                { sessionId: 'crew-member-9', filePaths: ['src/other.ts'] }, // not a loopback agent of a workspace
+            ].map((r) => JSON.stringify(r)).join('\n') + '\n');
+            tick.fn?.();
+            await waitFor(() => frames.filter((f) => f.t === 'activity').length === 3);
+            expect(forwarded).toEqual([
+                { workspaceId: MATCH_WS, agentId: 'agent-1', filePaths: [`${CHECKOUT}/src/planner.ts`], cwd: CHECKOUT },
+            ]);
+            // The pilot's own browser still gets the full frame, unchanged.
+            expect(frames.find((f) => f.t === 'activity')).toEqual({
+                t: 'activity',
+                sessionId: 'agent-1',
+                filePaths: [`${CHECKOUT}/src/planner.ts`],
+                thinking: 'Editing planner.ts',
+            });
+            // Closed: its later records are not forwarded.
+            ws.send(JSON.stringify({ t: 'close', sessionId: 'agent-1' }));
+            await new Promise((r) => setTimeout(r, 30));
+            fs.appendFileSync(file, JSON.stringify({ sessionId: 'agent-1', filePaths: ['src/late.ts'] }) + '\n');
+            tick.fn?.();
+            await new Promise((r) => setTimeout(r, 30));
+            expect(forwarded).toHaveLength(1);
+            ws.close();
+        }
+        finally {
+            await handle.close();
+        }
+    });
+});
+async function waitFor(cond, ms = 2_000) {
+    const until = Date.now() + ms;
+    while (!cond()) {
+        if (Date.now() > until)
+            throw new Error('timed out');
+        await new Promise((r) => setTimeout(r, 5));
+    }
+}

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

@@ -182,7 +182,7 @@ describe('bridge WebSocket server', () => {
         });
         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.
+        // Simulate `hiveop 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' }]);

package/dist/__tests__/config.test.js

@@ -98,7 +98,7 @@ describe('requireConfig()', () => {
         (0, config_1.requireConfig)();
         expect(exitSpy).toHaveBeenCalledWith(1);
         const messages = errSpy.mock.calls.map(c => c.join(' ')).join('\n');
-        expect(messages).toContain('wen-market auth login');
+        expect(messages).toContain('hiveop auth login');
         exitSpy.mockRestore();
         errSpy.mockRestore();
     });

package/dist/__tests__/devices.test.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
- * TDD — lws-03: `wen-market devices` list/revoke. Uses this machine's own
+ * TDD — lws-03: `hiveop devices` list/revoke. Uses this machine's own
  * Connect Token (bridge-config.json) — no interactive login required.
  */
 const chalk_1 = __importDefault(require("chalk"));

package/dist/__tests__/local.test.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
- * TDD — lws-03: `wen-market local add/list/remove`. Folder→workspace
+ * TDD — lws-03: `hiveop local add/list/remove`. Folder→workspace
  * registry commands. Mocks the bridge config/apiClient/folderRegistry
  * modules — no real network, no real fs (prior art: workspace.test.ts).
  */

package/dist/__tests__/openBrowser.test.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
- * TDD — wha-08: `wen-market auth login` tries to open the approval URL in a
+ * TDD — wha-08: `hiveop auth login` tries to open the approval URL in a
  * browser as best-effort convenience. The code + URL are always printed
  * regardless (works over SSH), so any failure here must be swallowed, never
  * surfaced. spawnFn is injectable so this never touches a real process.

package/dist/__tests__/websocket.test.js

@@ -117,7 +117,7 @@ describe('connectWebSocket() handshake (sio-07)', () => {
         err.data = { code: 'CREDENTIAL_INVALID' };
         fake.emit('connect_error', err);
         const printed = errorSpy.mock.calls.map((c) => c.join(' ')).join('\n');
-        expect(printed).toMatch(/wen-market auth login/);
+        expect(printed).toMatch(/hiveop auth login/);
         errorSpy.mockRestore();
     });
     it('shows a clear message and tells the user to log in again on SESSION_REVOKED', () => {
@@ -129,7 +129,7 @@ describe('connectWebSocket() handshake (sio-07)', () => {
         err.data = { code: 'SESSION_REVOKED' };
         fake.emit('connect_error', err);
         const printed = errorSpy.mock.calls.map((c) => c.join(' ')).join('\n');
-        expect(printed).toMatch(/wen-market auth login/);
+        expect(printed).toMatch(/hiveop auth login/);
         errorSpy.mockRestore();
     });
     it('falls back to a generic message for other connect errors', () => {
@@ -140,7 +140,7 @@ describe('connectWebSocket() handshake (sio-07)', () => {
         fake.emit('connect_error', new Error('ECONNREFUSED'));
         const printed = errorSpy.mock.calls.map((c) => c.join(' ')).join('\n');
         expect(printed).toContain('ECONNREFUSED');
-        expect(printed).not.toMatch(/wen-market auth login/);
+        expect(printed).not.toMatch(/hiveop auth login/);
         errorSpy.mockRestore();
     });
     it('subscribes to the requested channel on connect, unaffected by the auth change', () => {

package/dist/auth/identity.d.ts

@@ -1,5 +1,5 @@
 /**
- * wha-08 — the one authenticated call `wen-market auth login` (device flow,
+ * wha-08 — the one authenticated call `hiveop auth login` (device flow,
  * to print "Signed in as <name>") and `auth login --api-key` (CI, to verify
  * the key before saving it) both need. Sends the key as X-API-Key — never
  * X-Wallet-Pubkey, the retired header this whole PRD exists to remove.

package/dist/auth/login.d.ts

@@ -1,11 +1,11 @@
 /**
- * wha-08 — `wen-market auth login`: CLI browser login. Device-code pairing
+ * wha-08 — `hiveop auth login`: CLI browser login. Device-code pairing
  * (purpose=cli_login on the shared lws-14 mechanism), same GitHub-CLI /
  * Apple-TV pattern as bridge pairing (bridge/pairing.ts) — a code is minted,
  * printed with the approval URL, and polled until a human decides in the
  * browser.
  *
- * Deliberately NOT shared with bridge/pairing.ts: `wen-market pair` (bridge
+ * Deliberately NOT shared with bridge/pairing.ts: `hiveop pair` (bridge
  * pairing) must keep working byte-for-byte unchanged, and cli_login has an
  * outcome bridge pairing's loop never handles — the approval screen lets the
  * human DENY a CLI login, and this CLI needs to say so plainly rather than

package/dist/bridge/apiClient.d.ts

@@ -107,3 +107,17 @@ export declare function createLocalWorkspace(opts: BridgeApiOpts, params: {
 export declare function deleteWorkspace(opts: BridgeApiOpts, workspaceId: string): Promise<{
     success: boolean;
 }>;
+/**
+ * rival-10 — should this bridge forward its agents' file touches in
+ * `workspaceId`? Sends the workspace id only. `live` is true only for a ranked
+ * match workspace this user owns while the match is in play.
+ */
+export declare function getRivalTouchStatus(opts: BridgeApiOpts, workspaceId: string): Promise<{
+    live: boolean;
+    recheckMs: number;
+}>;
+/** rival-10 — forward live touches: agent id + file paths per touch, nothing else. */
+export declare function postRivalTouches(opts: BridgeApiOpts, workspaceId: string, touches: Array<{
+    agentId: string;
+    filePaths: string[];
+}>): Promise<void>;

package/dist/bridge/apiClient.js

@@ -8,6 +8,8 @@ exports.listDevices = listDevices;
 exports.revokeDevice = revokeDevice;
 exports.createLocalWorkspace = createLocalWorkspace;
 exports.deleteWorkspace = deleteWorkspace;
+exports.getRivalTouchStatus = getRivalTouchStatus;
+exports.postRivalTouches = postRivalTouches;
 class BridgeApiError extends Error {
     code;
     status;
@@ -25,12 +27,12 @@ exports.BridgeApiError = BridgeApiError;
  * machines) comes back PAT_FORBIDDEN with a route-allowlist message that
  * means nothing to an end user. Map it here, at the one place every bridge
  * API error is constructed, so EVERY call site (registerDevice, MCP
- * registration, local workspace create/delete, `wen-market devices`, ...)
+ * registration, local workspace create/delete, `hiveop devices`, ...)
  * gets the same actionable hint with no per-call-site plumbing.
  */
 function errorMessageFor(code, rawMessage, status) {
     if (code === 'PAT_FORBIDDEN') {
-        return 'your pairing is out of date — run `wen-market pair` again';
+        return 'your pairing is out of date — run `hiveop pair` again';
     }
     return rawMessage || `HTTP ${status}`;
 }
@@ -96,3 +98,18 @@ function createLocalWorkspace(opts, params) {
 function deleteWorkspace(opts, workspaceId) {
     return bridgeRequest(opts, 'DELETE', `/workspaces/${workspaceId}`);
 }
+/**
+ * rival-10 — should this bridge forward its agents' file touches in
+ * `workspaceId`? Sends the workspace id only. `live` is true only for a ranked
+ * match workspace this user owns while the match is in play.
+ */
+async function getRivalTouchStatus(opts, workspaceId) {
+    const json = await bridgeRequest(opts, 'GET', `/ranked/workspaces/${encodeURIComponent(workspaceId)}/touches`);
+    return { live: json.data?.live === true, recheckMs: Number(json.data?.recheckMs) || 30_000 };
+}
+/** rival-10 — forward live touches: agent id + file paths per touch, nothing else. */
+async function postRivalTouches(opts, workspaceId, touches) {
+    await bridgeRequest(opts, 'POST', `/ranked/workspaces/${encodeURIComponent(workspaceId)}/touches`, {
+        touches: touches.map((t) => ({ agentId: t.agentId, filePaths: t.filePaths })),
+    });
+}

package/dist/bridge/autostart.d.ts

@@ -1,6 +1,6 @@
 /**
  * Bridge autostart (bct follow-up, 2026-07-30; PATH/pin fix, 2026-08-13) —
- * `wen-market bridge install`.
+ * `hiveop bridge install`.
  *
  * Turns the one-liner into one-time-EVER setup: a macOS LaunchAgent starts
  * the bridge at login and keeps it alive, so the Terminal pane always finds

package/dist/bridge/autostart.js

@@ -1,7 +1,7 @@
 "use strict";
 /**
  * Bridge autostart (bct follow-up, 2026-07-30; PATH/pin fix, 2026-08-13) —
- * `wen-market bridge install`.
+ * `hiveop bridge install`.
  *
  * Turns the one-liner into one-time-EVER setup: a macOS LaunchAgent starts
  * the bridge at login and keeps it alive, so the Terminal pane always finds

package/dist/bridge/checkoutInventory.d.ts

@@ -38,9 +38,6 @@
  * (Promise.all) per checkout, and why the whole scan is fire-and-forget from
  * relayClient's point of view.
  */
-/** `cmd args...` runner — same shape used across repoCheckout.ts /
- *  changesReport.ts's injected `run` (git invoked as `git -C <path> ...`,
- *  never via a shell cwd option, so this stays a flat argv runner). */
 export type InventoryRun = (cmd: string, args: string[]) => Promise<{
     stdout: string;
     code: number;
@@ -63,37 +60,71 @@ export interface CheckoutInventoryDeps {
     /** git runner, invoked as `run('git', ['-C', path, ...])` — see the module
      *  doc comment. */
     run: InventoryRun;
+    /** Reads a checkout file (CLAUDE.md, for the managed-region check).
+     *  Defaults to the real filesystem. */
+    readText?: ReadText;
 }
+/**
+ * Inventory format version. 2 (cli 0.6.9) adds `dirtyKinds`/`noUpstream`, a
+ * dirty check that ignores the bridge's own CLAUDE.md region, and the
+ * `park-save` / `inventory-scan` frames. Stamped on EVERY entry so the arena
+ * and backend can tell a box that understands Save from one that does not —
+ * an old bridge would treat an unknown frame as an error, never as a park.
+ */
+export declare const INVENTORY_SCAN_VERSION = 2;
+export type DirtyKind = 'uncommitted' | 'unpushed' | 'stashed';
 export interface ParsedCheckoutEntry {
     workspaceId: string;
     unparseable: false;
     bytes: number;
     dirty: boolean;
     mtimeMs: number;
+    /** Which of the three conditions made it dirty (empty when clean). */
+    dirtyKinds: DirtyKind[];
+    /** The branch tracks nothing (never pushed, or its remote branch is gone). */
+    noUpstream: boolean;
+    scanVersion: number;
 }
 export interface UnparseableCheckoutEntry {
     workspaceId: string;
     unparseable: true;
     reason: string;
+    scanVersion: number;
 }
 export type CheckoutInventoryEntry = ParsedCheckoutEntry | UnparseableCheckoutEntry;
+/** Reads a text file, or null when it cannot. Injected in tests. */
+export type ReadText = (absPath: string) => string | null;
+/** CLAUDE.md with the bridge's managed region (contextWriter.ts) cut out. */
+export declare function stripManagedRegion(text: string): string;
+export interface DirtyReport {
+    dirty: boolean;
+    kinds: DirtyKind[];
+    noUpstream: boolean;
+}
 /**
- * PRD "Dirty means" section: uncommitted changes (`git status --porcelain`
- * non-empty), unpushed commits (`git rev-list @{u}..HEAD --count` > 0), OR
- * stashes (`git stash list` non-empty) — any ONE independently marks the
- * checkout dirty. `status`/`stash` failing outright (non-zero exit) means the
- * directory isn't a usable git checkout at all — 'unparseable', not clean.
- * `rev-list @{u}..HEAD` failing is the ordinary "no upstream configured"
- * case (a branch with nothing to compare against) and is treated as simply
- * "not unpushed" rather than a parse failure — every real checkout has a
- * working `status`/`stash`, so those two staying reliable is what actually
- * distinguishes a healthy checkout from a broken one.
+ * PRD "Dirty means" section: uncommitted changes, unpushed commits, OR
+ * stashes — any ONE independently marks the checkout dirty.
  *
- * Exported (hcs-05) — checkoutReclaim.ts reuses this EXACT function for its
- * immediate-pre-delete dirty re-check, rather than reimplementing the three
- * conditions a second time. One dirty definition, two callers.
+ *   uncommitted — `git status --porcelain`, minus the bridge's own writes
+ *                 (isBridgeManagedChange).
+ *   unpushed    — commits on HEAD that no remote-tracking ref contains
+ *                 (`rev-list HEAD --not --remotes`). NOT `@{u}..HEAD`: that
+ *                 failed outright with no upstream, and counted work pushed
+ *                 to any other branch (a park branch included) as unpushed —
+ *                 so park-and-remove's own pre-delete re-check aborted every
+ *                 park that had committed something.
+ *   stashed     — `git stash list` non-empty.
+ *
+ * `status`/`stash` failing means the directory isn't a usable git checkout —
+ * 'unparseable', not clean.
+ */
+export declare function inspectDirty(path: string, run: InventoryRun, readText?: ReadText): Promise<DirtyReport | 'unparseable'>;
+/**
+ * The boolean form — checkoutReclaim.ts's immediate-pre-delete re-check uses
+ * this EXACT definition rather than reimplementing it. One dirty definition,
+ * every caller.
  */
-export declare function checkDirty(path: string, run: InventoryRun): Promise<boolean | 'unparseable'>;
+export declare function checkDirty(path: string, run: InventoryRun, readText?: ReadText): Promise<boolean | 'unparseable'>;
 /**
  * PURE full-inventory scan. One record per checkout under `reposBaseDir`; a
  * checkout that can't be read/parsed is reported as `unparseable: true`