@wenrwa/marketplace-cli 0.4.4 → 0.4.6

package/dist/__tests__/bridge-workspace-multirepo.test.js

@@ -0,0 +1,317 @@
+"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 });
+/**
+ * pucc-03 — model B multi-repo + per-terminal workspace cwd/env (ADR-0031).
+ *
+ * One container holds many workspaces' repos under /data/repos/<workspaceId>,
+ * cloned on demand the first time a terminal for that workspace opens. Every
+ * workspace-scoped terminal carries WENRWA_WORKSPACE_ID (and a per-session
+ * HT_AUTONOMOUS) in its PTY env so downstream tooling (pucc-04) can resolve
+ * the workspace inside the shared box. This suite pins that contract with the
+ * existing faked-PTY / fake-relay harness — no docker, no real shells.
+ */
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const ws_1 = require("ws");
+const relayClient_1 = require("../bridge/relayClient");
+const sessionManager_1 = require("../bridge/sessionManager");
+const repoCheckout_1 = require("../bridge/repoCheckout");
+class FakePty {
+    opts;
+    written = [];
+    constructor(opts) {
+        this.opts = opts;
+    }
+    write(data) { this.written.push(data); }
+    resize() { }
+    kill() { }
+    dataCb = null;
+    onData(cb) { this.dataCb = cb; }
+    onExit(_cb) { }
+    emitData(d) { this.dataCb?.(d); }
+}
+const makeFactory = () => {
+    const ptys = [];
+    const factory = {
+        spawn: (opts) => {
+            const p = new FakePty(opts);
+            ptys.push(p);
+            return p;
+        },
+    };
+    return { factory, ptys };
+};
+// ── fake-relay + frame-queue helpers (mirror bridge-relay-client.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((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()));
+    });
+}
+// ── ensureWorkspaceRepo: /data/repos/<workspaceId> clone-on-demand ──────
+describe('ensureWorkspaceRepo — per-workspace clone-on-demand (ADR-0031 layout)', () => {
+    const REPOS = '/data/repos';
+    const makeDeps = (existing = [], cloneFails = false) => {
+        const runs = [];
+        return {
+            runs,
+            deps: {
+                reposBaseDir: REPOS,
+                exists: (p) => existing.includes(p),
+                mkdir: (_p) => { },
+                run: async (cmd, args) => {
+                    runs.push([cmd, ...args]);
+                    if (cloneFails)
+                        throw new Error('clone failed');
+                    return { stdout: '', code: 0 };
+                },
+            },
+        };
+    };
+    it('clones a missing workspace repo to /data/repos/<workspaceId>', async () => {
+        const { deps, runs } = makeDeps();
+        const result = await (0, repoCheckout_1.ensureWorkspaceRepo)({ workspaceId: 'ws-42', repoUrl: 'https://github.com/acme/widgets.git' }, deps);
+        expect(result).toEqual({ path: `${REPOS}/ws-42`, action: 'cloned' });
+        expect(runs[0].join(' ')).toBe(`git clone https://github.com/acme/widgets.git ${REPOS}/ws-42`);
+    });
+    it('reuses an existing checkout (.git present) without running git — no re-clone', async () => {
+        const { deps, runs } = makeDeps([`${REPOS}/ws-42/.git`]);
+        const result = await (0, repoCheckout_1.ensureWorkspaceRepo)({ workspaceId: 'ws-42', repoUrl: 'https://github.com/acme/widgets.git' }, deps);
+        expect(result).toEqual({ path: `${REPOS}/ws-42`, action: 'existing' });
+        expect(runs).toHaveLength(0);
+    });
+    it('is keyed by workspaceId, not repo name (distinct workspaces → distinct dirs)', async () => {
+        const { deps } = makeDeps();
+        const a = await (0, repoCheckout_1.ensureWorkspaceRepo)({ workspaceId: 'alpha', repoUrl: 'https://github.com/acme/widgets.git' }, deps);
+        const b = await (0, repoCheckout_1.ensureWorkspaceRepo)({ workspaceId: 'beta', repoUrl: 'https://github.com/acme/widgets.git' }, deps);
+        expect(a.path).toBe(`${REPOS}/alpha`);
+        expect(b.path).toBe(`${REPOS}/beta`);
+    });
+    it('reports failure (→ terminal falls back to home) when there is no url and no checkout', async () => {
+        const { deps, runs } = makeDeps();
+        const result = await (0, repoCheckout_1.ensureWorkspaceRepo)({ workspaceId: 'ws-42' }, deps);
+        expect(result.action).toBe('failed');
+        expect(runs).toHaveLength(0);
+    });
+    it('reports failure without throwing when the clone fails', async () => {
+        const { deps } = makeDeps([], true);
+        const result = await (0, repoCheckout_1.ensureWorkspaceRepo)({ workspaceId: 'ws-42', repoUrl: 'https://github.com/p/r' }, deps);
+        expect(result.action).toBe('failed');
+    });
+});
+// ── SessionManager: per-session env reaches the PTY factory ─────────────
+describe('SessionManager — per-session env passthrough (pucc-03)', () => {
+    it('forwards env to the PTY factory spawn opts', () => {
+        const { factory, ptys } = makeFactory();
+        const sm = new sessionManager_1.SessionManager(factory);
+        sm.open({ cols: 80, rows: 24, cwd: '/data/repos/ws-1', env: { WENRWA_WORKSPACE_ID: 'ws-1' } });
+        expect(ptys[0].opts.cwd).toBe('/data/repos/ws-1');
+        expect(ptys[0].opts.env).toEqual({ WENRWA_WORKSPACE_ID: 'ws-1' });
+    });
+});
+// ── relay client: the workspaceId → cwd + env contract pucc-04 builds on ──
+describe('relay client — workspace-scoped open (pucc-03 contract)', () => {
+    it('open with workspaceId+repoUrl spawns in the resolved cwd with WENRWA_WORKSPACE_ID env, echoes workspaceId', async () => {
+        const relay = await startFakeRelay();
+        const { factory, ptys } = makeFactory();
+        const sessions = new sessionManager_1.SessionManager(factory);
+        const resolveCalls = [];
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            resolveWorkspaceCwd: async (o) => {
+                resolveCalls.push(o);
+                return `/data/repos/${o.workspaceId}`;
+            },
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, workspaceId: 'ws-7', repoUrl: 'https://github.com/acme/w.git' }));
+        const opened = await q.next();
+        expect(opened.t).toBe('opened');
+        expect(opened.workspaceId).toBe('ws-7');
+        expect(opened.cwd).toBe('/data/repos/ws-7');
+        expect(resolveCalls).toEqual([{ workspaceId: 'ws-7', repoUrl: 'https://github.com/acme/w.git' }]);
+        expect(ptys[0].opts.cwd).toBe('/data/repos/ws-7');
+        expect(ptys[0].opts.env).toMatchObject({ WENRWA_WORKSPACE_ID: 'ws-7', HT_AUTONOMOUS: '0' });
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('autonomous:true selects HT_AUTONOMOUS=1 per session (claude --dangerously-skip-permissions)', async () => {
+        const relay = await startFakeRelay();
+        const { factory, ptys } = makeFactory();
+        const sessions = new sessionManager_1.SessionManager(factory);
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            resolveWorkspaceCwd: async ({ workspaceId }) => `/data/repos/${workspaceId}`,
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next();
+        ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, workspaceId: 'ws-9', autonomous: true }));
+        await q.next();
+        expect(ptys[0].opts.env).toMatchObject({ WENRWA_WORKSPACE_ID: 'ws-9', HT_AUTONOMOUS: '1' });
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('sets WENRWA_WORKSPACE_ID even when the checkout is unavailable (cwd falls back to home)', async () => {
+        const relay = await startFakeRelay();
+        const { factory, ptys } = makeFactory();
+        const sessions = new sessionManager_1.SessionManager(factory);
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            resolveWorkspaceCwd: async () => null, // clone failed / no url
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next();
+        ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, workspaceId: 'ws-x' }));
+        const opened = await q.next();
+        expect(opened.workspaceId).toBe('ws-x');
+        expect(opened.cwd).toBeUndefined();
+        expect(ptys[0].opts.cwd).toBeUndefined();
+        expect(ptys[0].opts.env).toMatchObject({ WENRWA_WORKSPACE_ID: 'ws-x' });
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('legacy fallback: open WITHOUT workspaceId spawns a plain shell (no cwd, no injected env)', async () => {
+        const relay = await startFakeRelay();
+        const { factory, ptys } = makeFactory();
+        const sessions = new sessionManager_1.SessionManager(factory);
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions,
+            resolveWorkspaceCwd: async () => '/should/not/be/used',
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.next();
+        ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24 }));
+        const opened = await q.next();
+        expect(opened.t).toBe('opened');
+        expect(opened.workspaceId).toBeUndefined();
+        expect(ptys[0].opts.cwd).toBeUndefined();
+        expect(ptys[0].opts.env).toBeUndefined();
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+});
+/**
+ * Env-gated integration (RUN_HT_INTEGRATION): proves clone-on-demand + reuse
+ * against a REAL git binary and temp dirs — no docker required, but skipped by
+ * default so CI/this-machine never blocks on it. The full docker-level check
+ * (RUN_HT_DOCKER) lands in the deploy/verify stage (pucc-09 cutover), where an
+ * actual image + Fly volume exist to exercise the shared-container path.
+ */
+const runIntegration = process.env.RUN_HT_INTEGRATION === '1';
+(runIntegration ? describe : describe.skip)('ensureWorkspaceRepo — real git clone-on-demand (env-gated)', () => {
+    it('clones on first call then reuses the checkout on the second (idempotent)', async () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'pucc03-'));
+        const origin = path.join(root, 'origin.git');
+        const repos = path.join(root, 'repos');
+        (0, child_process_1.execFileSync)('git', ['init', '--bare', origin]);
+        // seed the bare origin with one commit so `git clone` produces a checkout
+        const seed = path.join(root, 'seed');
+        (0, child_process_1.execFileSync)('git', ['clone', origin, seed]);
+        fs.writeFileSync(path.join(seed, 'README.md'), '# hi\n');
+        (0, child_process_1.execFileSync)('git', ['-C', seed, 'add', '.']);
+        (0, child_process_1.execFileSync)('git', ['-C', seed, '-c', 'user.email=t@t', '-c', 'user.name=t', 'commit', '-m', 'init']);
+        (0, child_process_1.execFileSync)('git', ['-C', seed, 'push', 'origin', 'HEAD:refs/heads/main']);
+        const deps = {
+            reposBaseDir: repos,
+            exists: (p) => fs.existsSync(p),
+            mkdir: (p) => fs.mkdirSync(p, { recursive: true }),
+            run: async (cmd, args) => {
+                (0, child_process_1.execFileSync)(cmd, args);
+                return { stdout: '', code: 0 };
+            },
+        };
+        const first = await (0, repoCheckout_1.ensureWorkspaceRepo)({ workspaceId: 'ws-int', repoUrl: origin }, deps);
+        expect(first.action).toBe('cloned');
+        expect(fs.existsSync(path.join(repos, 'ws-int', '.git'))).toBe(true);
+        const second = await (0, repoCheckout_1.ensureWorkspaceRepo)({ workspaceId: 'ws-int', repoUrl: origin }, deps);
+        expect(second.action).toBe('existing');
+        fs.rmSync(root, { recursive: true, force: true });
+    });
+});

package/dist/__tests__/devices.test.d.ts

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

package/dist/__tests__/devices.test.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * TDD — lws-03: `wen-market devices` list/revoke. Uses this machine's own
+ * Connect Token (bridge-config.json) — no interactive login required.
+ */
+const chalk_1 = __importDefault(require("chalk"));
+const mockLoadBridgeConfig = jest.fn();
+jest.mock('../bridge/config', () => ({
+    loadBridgeConfig: () => mockLoadBridgeConfig(),
+}));
+const mockListDevices = jest.fn();
+const mockRevokeDevice = jest.fn();
+jest.mock('../bridge/apiClient', () => ({
+    listDevices: (...args) => mockListDevices(...args),
+    revokeDevice: (...args) => mockRevokeDevice(...args),
+}));
+jest.mock('../commands/bridge', () => ({ bridgeApiUrl: () => 'https://api.x' }));
+const devices_1 = require("../commands/devices");
+async function runCommand(...args) {
+    await devices_1.devicesCommand.parseAsync(args, { from: 'user' });
+}
+beforeAll(() => {
+    chalk_1.default.level = 0;
+});
+beforeEach(() => {
+    jest.clearAllMocks();
+    mockLoadBridgeConfig.mockReturnValue({ connectToken: 'wm_ct_' + 'a'.repeat(64), deviceId: 'd-this' });
+});
+describe('devices list', () => {
+    it('lists devices and marks the current one', async () => {
+        mockListDevices.mockResolvedValue({ success: true, devices: [
+                { id: 'd-this', name: 'bunny-mbp', revokedAt: null },
+                { id: 'd-other', name: 'other-box', revokedAt: null },
+            ] });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand();
+        const output = spy.mock.calls.map((c) => c[0]).join('\n');
+        expect(output).toContain('bunny-mbp');
+        expect(output).toContain('other-box');
+        expect(output).toContain('this machine');
+        spy.mockRestore();
+    });
+    it('errors clearly with no Connect Token configured', async () => {
+        mockLoadBridgeConfig.mockReturnValue(null);
+        const errSpy = jest.spyOn(console, 'error').mockImplementation();
+        const exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => undefined);
+        await runCommand();
+        expect(mockListDevices).not.toHaveBeenCalled();
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        errSpy.mockRestore();
+        exitSpy.mockRestore();
+    });
+});
+describe('devices revoke', () => {
+    it('revokes a device by id', async () => {
+        mockRevokeDevice.mockResolvedValue({ success: true });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('revoke', 'd-other');
+        expect(mockRevokeDevice).toHaveBeenCalledWith(expect.anything(), 'd-other');
+        spy.mockRestore();
+    });
+});

package/dist/__tests__/local.test.d.ts

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

package/dist/__tests__/local.test.js

@@ -0,0 +1,147 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * TDD — lws-03: `wen-market 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).
+ */
+const chalk_1 = __importDefault(require("chalk"));
+const mockLoadBridgeConfig = jest.fn();
+jest.mock('../bridge/config', () => ({
+    loadBridgeConfig: () => mockLoadBridgeConfig(),
+}));
+const mockCreateLocalWorkspace = jest.fn();
+const mockDeleteWorkspace = jest.fn();
+jest.mock('../bridge/apiClient', () => ({
+    createLocalWorkspace: (...args) => mockCreateLocalWorkspace(...args),
+    deleteWorkspace: (...args) => mockDeleteWorkspace(...args),
+    BridgeApiError: class BridgeApiError extends Error {
+        code;
+        status;
+        constructor(message, code, status) { super(message); this.code = code; this.status = status; }
+    },
+}));
+jest.mock('../commands/bridge', () => ({ bridgeApiUrl: () => 'https://api.x' }));
+let registryState = { v: 1, entries: {} };
+jest.mock('../bridge/folderRegistry', () => {
+    const actual = jest.requireActual('../bridge/folderRegistry');
+    return {
+        ...actual,
+        loadFolderRegistry: () => registryState,
+        saveFolderRegistry: (registry) => { registryState = registry; },
+    };
+});
+const local_1 = require("../commands/local");
+async function runCommand(...args) {
+    await local_1.localCommand.parseAsync(args, { from: 'user' });
+}
+beforeAll(() => {
+    chalk_1.default.level = 0;
+});
+beforeEach(() => {
+    jest.clearAllMocks();
+    registryState = { v: 1, entries: {} };
+    mockLoadBridgeConfig.mockReturnValue({ connectToken: 'wm_ct_' + 'a'.repeat(64), deviceId: 'device-1' });
+});
+describe('local add', () => {
+    it('creates a local workspace and registers the resolved path', async () => {
+        mockCreateLocalWorkspace.mockResolvedValue({ success: true, workspace: { id: 'ws-1', name: 'wenrwa-arena' } });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('add', process.cwd());
+        expect(mockCreateLocalWorkspace).toHaveBeenCalledWith(expect.objectContaining({ apiUrl: 'https://api.x', connectToken: expect.stringMatching(/^wm_ct_/) }), { name: expect.any(String) });
+        expect(registryState.entries[process.cwd()]).toMatchObject({ workspaceId: 'ws-1' });
+        const output = spy.mock.calls.map((c) => c[0]).join('\n');
+        expect(output).toContain('ws-1');
+        spy.mockRestore();
+    });
+    it('is idempotent — re-adding the same path returns the existing workspace without creating a new one', async () => {
+        registryState = { v: 1, entries: { [process.cwd()]: { workspaceId: 'ws-existing', name: 'x', addedAt: 'now' } } };
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('add', process.cwd());
+        expect(mockCreateLocalWorkspace).not.toHaveBeenCalled();
+        const output = spy.mock.calls.map((c) => c[0]).join('\n');
+        expect(output).toContain('ws-existing');
+        spy.mockRestore();
+    });
+    it('errors clearly when this machine has not been connected yet (no deviceId)', async () => {
+        mockLoadBridgeConfig.mockReturnValue({ connectToken: 'wm_ct_' + 'a'.repeat(64) }); // no deviceId
+        const errSpy = jest.spyOn(console, 'error').mockImplementation();
+        const exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => undefined);
+        await runCommand('add', process.cwd());
+        expect(mockCreateLocalWorkspace).not.toHaveBeenCalled();
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        errSpy.mockRestore();
+        exitSpy.mockRestore();
+    });
+    it('surfaces a clear, non-crashing error when the device was revoked (401 mid-registration)', async () => {
+        const { BridgeApiError } = jest.requireMock('../bridge/apiClient');
+        mockCreateLocalWorkspace.mockRejectedValue(new BridgeApiError('Connect token is invalid or revoked.', 'INVALID_CONNECT_TOKEN', 401));
+        const errSpy = jest.spyOn(console, 'error').mockImplementation();
+        const exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => undefined);
+        await runCommand('add', process.cwd());
+        expect(exitSpy).toHaveBeenCalledWith(1);
+        const output = errSpy.mock.calls.map((c) => c[0]).join('\n');
+        expect(output.toLowerCase()).toContain('revoked');
+        errSpy.mockRestore();
+        exitSpy.mockRestore();
+    });
+});
+describe('local list', () => {
+    it('prints all registered folders', async () => {
+        registryState = {
+            v: 1,
+            entries: {
+                '/Users/x/app-a': { workspaceId: 'ws-a', name: 'app-a', addedAt: 'now' },
+                '/Users/x/app-b': { workspaceId: 'ws-b', name: 'app-b', addedAt: 'now' },
+            },
+        };
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('list');
+        const output = spy.mock.calls.map((c) => c[0]).join('\n');
+        expect(output).toContain('ws-a');
+        expect(output).toContain('ws-b');
+        spy.mockRestore();
+    });
+    it('says so when nothing is registered', async () => {
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('list');
+        expect(spy).toHaveBeenCalledWith(expect.stringContaining('No local workspaces registered'));
+        spy.mockRestore();
+    });
+});
+describe('local remove', () => {
+    it('removes the registration only — never deletes the workspace by default', async () => {
+        registryState = { v: 1, entries: { '/Users/x/app-a': { workspaceId: 'ws-a', name: 'app-a', addedAt: 'now' } } };
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('remove', '/Users/x/app-a');
+        expect(registryState.entries['/Users/x/app-a']).toBeUndefined();
+        expect(mockDeleteWorkspace).not.toHaveBeenCalled();
+        const output = spy.mock.calls.map((c) => c[0]).join('\n');
+        expect(output.toLowerCase()).toContain('files untouched');
+        spy.mockRestore();
+    });
+    it('finds the entry by workspaceId too, not just by path', async () => {
+        registryState = { v: 1, entries: { '/Users/x/app-a': { workspaceId: 'ws-a', name: 'app-a', addedAt: 'now' } } };
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('remove', 'ws-a');
+        expect(registryState.entries['/Users/x/app-a']).toBeUndefined();
+        spy.mockRestore();
+    });
+    it('--delete also deletes the workspace row server-side', async () => {
+        registryState = { v: 1, entries: { '/Users/x/app-a': { workspaceId: 'ws-a', name: 'app-a', addedAt: 'now' } } };
+        mockDeleteWorkspace.mockResolvedValue({ success: true });
+        const spy = jest.spyOn(console, 'log').mockImplementation();
+        await runCommand('remove', '/Users/x/app-a', '--delete');
+        expect(mockDeleteWorkspace).toHaveBeenCalledWith(expect.anything(), 'ws-a');
+        spy.mockRestore();
+    });
+    it('errors clearly when the path/id is not registered', async () => {
+        const errSpy = jest.spyOn(console, 'error').mockImplementation();
+        await runCommand('remove', '/nope');
+        expect(errSpy).toHaveBeenCalledWith(expect.stringContaining('not registered'));
+        errSpy.mockRestore();
+    });
+});

package/dist/bridge/activityParser.d.ts

@@ -0,0 +1,53 @@
+/**
+ * pucc-int-03 (ADR-0032) — Claude Code PTY activity parser (the PRODUCER).
+ *
+ * A Claude Code agent is a real PTY session the platform never drives
+ * (ADR-0028). To give it the same file-targeted drones/holograms a credits
+ * agent gets, the bridge OBSERVES its PTY output (read-only) and extracts the
+ * tool-use it renders — Edit/Write/Read/Bash targets + a short "thinking"
+ * summary — so the arena can swarm the files it touches.
+ *
+ * This module is PURE and defensive by contract:
+ *   - Input is raw PTY output: ANSI escapes, \r cursor redraws, and tool lines
+ *     split arbitrarily across chunks. It buffers partial lines across `push`.
+ *   - A parse MISS yields NOTHING (empty array). It NEVER throws — every code
+ *     path that could fail is caught and degraded to "no signal", because a
+ *     parser bug must never break the terminal it is only watching.
+ *   - The recognized markers are a SMALL, VERSIONED set (see TOOL_VERBS): if
+ *     Claude Code's output format drifts, this table is the one thing to bump.
+ *
+ * Recognized shape (best-effort): Claude Code renders a tool call as a bulleted
+ * line — `● Edit(src/foo.ts)`, `⏺ Read(package.json)`, `● Bash(npm test)`,
+ * `⏺ Update(src/x.ts)` — a bullet glyph, the Tool name, and a parenthesized
+ * arg. For file tools the arg's first token is the (repo-relative) path; for
+ * Bash it is a command (no path is extracted — the consumer degrades an empty
+ * `filePaths` to an ambient pulse). Every recognized tool also yields a
+ * human "thinking" phrase ("Editing foo.ts", "Running npm test").
+ */
+export interface ActivitySignal {
+    /** Repo-relative file targets extracted from a file-tool call (may be empty). */
+    filePaths: string[];
+    /** Short human summary of what the agent is doing, e.g. "Editing foo.ts". */
+    thinking?: string;
+}
+export interface ActivityParserOpts {
+    /** A single un-terminated line longer than this is abandoned (binary spew /
+     *  a pathological redraw) — the buffer is trimmed to its tail so a later
+     *  newline can still complete a plausible line. Default 16384. */
+    maxLineLength?: number;
+}
+export declare class ActivityParser {
+    private buf;
+    private maxLineLength;
+    /** Suppress consecutive identical signals (TUI re-renders the same line). */
+    private lastKey;
+    constructor(opts?: ActivityParserOpts);
+    /**
+     * Feed a chunk of PTY output. Returns every NEW tool-use signal completed by
+     * this chunk (usually 0 or 1). Never throws: any internal failure degrades
+     * to an empty result so the caller's PTY forwarding is never disturbed.
+     */
+    push(chunk: string): ActivitySignal[];
+    private pushUnsafe;
+    private parseLine;
+}