@wenrwa/marketplace-cli 0.8.4 → 0.8.5

package/dist/__tests__/bridge-changes-reporter.test.js

@@ -1,4 +1,37 @@
 "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 });
 /**
  * tchp-02 — per-session working-tree change detector (`changes` frame).
@@ -703,4 +736,69 @@ describe('execGit — opts.env (tchp-21)', () => {
         expect(res.code).toBe(0);
         expect(res.stdout).toBe('true');
     });
+    // Not-a-repo model (live report 2026-10-11): a plain folder used to burn
+    // three "failures", get disabled, and leave the panel on "Waiting for
+    // changes…" forever.
+    describe('a folder that is not a git repo', () => {
+        const notGitRun = () => jest.fn().mockImplementation(async (_cmd, args) => ({ stdout: '', code: 128, args }));
+        it('emits ONE changes-untracked frame and keeps polling (never disabled)', async () => {
+            const run = notGitRun();
+            const build = jest.fn();
+            const { reporter, sent } = makeReporter({ run, buildChangesReport: build, now: () => 7 });
+            const sessions = [{ sessionId: 's1', workspaceId: 'w1', cwd: '/plain' }];
+            for (let i = 0; i < 5; i++)
+                await reporter.tick(sessions);
+            expect(build).not.toHaveBeenCalled();
+            expect(sent).toEqual([
+                { t: 'changes-untracked', reason: 'not-git', workspaceId: 'w1', agentId: 's1', sessionId: 's1', ts: 7 },
+            ]);
+            // still probing every tick — a later `git init` must be noticed
+            const statusCalls = run.mock.calls.filter((c) => c[1].includes('status'));
+            expect(statusCalls).toHaveLength(5);
+        });
+        it('replays the untracked notice to a fresh connection', async () => {
+            const { reporter, sent } = makeReporter({ run: notGitRun() });
+            const sessions = [{ sessionId: 's1', workspaceId: 'w1', cwd: '/plain' }];
+            await reporter.tick(sessions);
+            reporter.requestReplay();
+            await reporter.tick(sessions);
+            expect(sent).toHaveLength(2);
+            expect(sent[1]).toBe(sent[0]);
+        });
+        it('a later git init switches to a real report immediately', async () => {
+            let isRepo = false;
+            const run = jest.fn().mockImplementation(async () => (isRepo ? statusOk('?? a.R\n') : { stdout: '', code: 128 }));
+            const build = jest.fn().mockResolvedValue(fakeReport('sha-1'));
+            const { reporter, sent } = makeReporter({ run, buildChangesReport: build });
+            const sessions = [{ sessionId: 's1', workspaceId: 'w1', cwd: '/plain' }];
+            await reporter.tick(sessions);
+            isRepo = true;
+            await reporter.tick(sessions);
+            expect(sent.map((f) => f.t)).toEqual(['changes-untracked', 'changes']);
+        });
+        it('a non-128 git failure is still an ordinary failure (no untracked frame)', async () => {
+            const run = jest.fn().mockResolvedValue({ stdout: '', code: 1 });
+            const { reporter, sent } = makeReporter({ run });
+            const sessions = [{ sessionId: 's1', workspaceId: 'w1', cwd: '/x' }];
+            for (let i = 0; i < 4; i++)
+                await reporter.tick(sessions);
+            expect(sent).toEqual([]);
+            expect(run).toHaveBeenCalledTimes(3); // 3 strikes then disabled
+        });
+        it('real git: a temp plain folder is reported as not-git', async () => {
+            const fs = await Promise.resolve().then(() => __importStar(require('fs')));
+            const os = await Promise.resolve().then(() => __importStar(require('os')));
+            const path = await Promise.resolve().then(() => __importStar(require('path')));
+            const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'plain-'));
+            try {
+                const { reporter, sent } = makeReporter({ run: changesReporter_1.execGit });
+                await reporter.tick([{ sessionId: 's1', workspaceId: 'w1', cwd: dir }]);
+                expect(sent).toHaveLength(1);
+                expect(sent[0]).toMatchObject({ t: 'changes-untracked', reason: 'not-git' });
+            }
+            finally {
+                fs.rmSync(dir, { recursive: true, force: true });
+            }
+        });
+    });
 });

package/dist/__tests__/term-snapshot.test.js

@@ -1,6 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const termSnapshot_1 = require("../bridge/termSnapshot");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { Terminal } = require('@xterm/headless');
+/** A fresh client terminal at (cols, rows) with `data` replayed into it —
+ *  what a reattaching pane sees. */
+async function replay(data, cols, rows) {
+    const t = new Terminal({ cols, rows, allowProposedApi: true });
+    await new Promise((r) => t.write(data, () => r()));
+    return t;
+}
+function screenRows(t) {
+    const b = t.buffer.active;
+    const out = [];
+    for (let y = b.viewportY; y < b.viewportY + t.rows; y++)
+        out.push(b.getLine(y)?.translateToString(true) ?? '');
+    return out;
+}
 describe('TermSnapshot', () => {
     it('write then immediately serialize includes the written content', async () => {
         const snap = (0, termSnapshot_1.createTermSnapshot)(80, 24);
@@ -77,4 +93,124 @@ describe('TermSnapshot', () => {
         // without callers ever having held a reference to xterm internals).
         expect(Object.keys(snap).sort()).toEqual(['dispose', 'resize', 'serialize', 'write']);
     });
+    describe('reattach after the terminal shrank (OpenCode garble)', () => {
+        /** A full-screen TUI frame on the alt screen, every row full width, with
+         *  a coloured span — then the pane shrinks. */
+        async function wideFrameThenShrink(snap) {
+            await snap.write('\x1b[?1049h\x1b[H');
+            for (let r = 1; r <= 6; r++) {
+                const row = `${r}`.repeat(10) + '\x1b[31m' + 'R'.repeat(10) + '\x1b[0m' + `${r}`.repeat(20);
+                await snap.write(`\x1b[${r};1H${row}`);
+            }
+            snap.resize(20, 4);
+        }
+        it('clips every row to the new cols — no row overflows into the next', async () => {
+            const snap = (0, termSnapshot_1.createTermSnapshot)(40, 6);
+            await wideFrameThenShrink(snap);
+            const out = await snap.serialize();
+            const client = await replay(out, 20, 4);
+            expect(client.buffer.active.type).toBe('alternate');
+            // The live 20x4 screen after the shrink shows rows 3..6, first 20 cells.
+            const live = ['3', '4', '5', '6'].map((d) => d.repeat(10) + 'R'.repeat(10));
+            expect(screenRows(client)).toEqual(live);
+            // SGR state survives the clip: the red span is still red, the digits not.
+            const line = client.buffer.active.getLine(client.buffer.active.viewportY);
+            expect(line.getCell(12).getFgColor()).toBe(1);
+            expect(line.getCell(2).getFgColor()).not.toBe(1);
+            client.dispose();
+            snap.dispose();
+        });
+        it('replays to exactly the live screen of an emulator that saw the same bytes and shrink', async () => {
+            const bytes = ['\x1b[?1049h\x1b[H'];
+            for (let r = 1; r <= 6; r++)
+                bytes.push(`\x1b[${r};1H` + `${r}abcdefghi`.repeat(4));
+            const snap = (0, termSnapshot_1.createTermSnapshot)(40, 6);
+            const live = new Terminal({ cols: 40, rows: 6, allowProposedApi: true });
+            for (const chunk of bytes) {
+                await snap.write(chunk);
+                await new Promise((r) => live.write(chunk, () => r()));
+            }
+            snap.resize(20, 4);
+            live.resize(20, 4);
+            const client = await replay(await snap.serialize(), 20, 4);
+            // What the live pane displays: each row's first `cols` cells.
+            const b = live.buffer.active;
+            const liveScreen = [];
+            for (let y = b.viewportY; y < b.viewportY + live.rows; y++) {
+                liveScreen.push(b.getLine(y).translateToString(true, 0, live.cols));
+            }
+            expect(screenRows(client)).toEqual(liveScreen);
+            expect(client.buffer.active.length).toBe(4);
+            [client, live].forEach((t) => t.dispose());
+            snap.dispose();
+        });
+        it('never splits a wide character that straddles the new right edge', async () => {
+            const snap = (0, termSnapshot_1.createTermSnapshot)(40, 3);
+            await snap.write('\x1b[?1049h\x1b[H');
+            await snap.write('\x1b[1;1H' + 'a'.repeat(19) + '漢' + 'b'.repeat(19));
+            await snap.write('\x1b[2;1H' + 'c'.repeat(40));
+            snap.resize(20, 3);
+            const out = await snap.serialize();
+            const client = await replay(out, 20, 3);
+            const rows = screenRows(client);
+            expect(rows[0]).toBe('a'.repeat(19));
+            expect(rows[1]).toBe('c'.repeat(20));
+            client.dispose();
+            snap.dispose();
+        });
+        it('a soft-wrapped row of the wider frame does not glue onto its clipped predecessor', async () => {
+            const snap = (0, termSnapshot_1.createTermSnapshot)(30, 4);
+            await snap.write('\x1b[?1049h\x1b[H');
+            // 45 chars at 30 cols: row 0 full, row 1 is a soft wrap of it.
+            await snap.write('x'.repeat(30) + 'y'.repeat(15));
+            snap.resize(20, 4);
+            const out = await snap.serialize();
+            const client = await replay(out, 20, 4);
+            expect(screenRows(client).slice(0, 3)).toEqual(['x'.repeat(20), 'y'.repeat(15), '']);
+            client.dispose();
+            snap.dispose();
+        });
+    });
+    describe('terminal modes survive a reattach', () => {
+        it('re-emits mouse tracking + SGR encoding, bracketed paste, app cursor keys, alt screen and a hidden cursor', async () => {
+            const snap = (0, termSnapshot_1.createTermSnapshot)(40, 6);
+            await snap.write('\x1b[?1049h\x1b[?1002h\x1b[?1006h\x1b[?2004h\x1b[?1h\x1b[?25l');
+            await snap.write('\x1b[1;1Hopencode');
+            const out = await snap.serialize();
+            const client = await replay(out, 40, 6);
+            expect(client.buffer.active.type).toBe('alternate');
+            expect(client.modes.mouseTrackingMode).toBe('drag');
+            expect(client._core.coreMouseService.activeEncoding).toBe('SGR');
+            expect(client.modes.bracketedPasteMode).toBe(true);
+            expect(client.modes.applicationCursorKeysMode).toBe(true);
+            expect(client._core.coreService.isCursorHidden).toBe(true);
+            expect(screenRows(client)[0]).toBe('opencode');
+            // Modes come AFTER the screen content, so the replayed content can't
+            // be misread under them.
+            expect(out.lastIndexOf('opencode')).toBeLessThan(out.indexOf('\x1b[?1006h'));
+            client.dispose();
+            snap.dispose();
+        });
+        it('re-emits any-motion tracking (?1003) and SGR-pixels (?1016)', async () => {
+            const snap = (0, termSnapshot_1.createTermSnapshot)(40, 6);
+            await snap.write('\x1b[?1003h\x1b[?1016h');
+            const client = await replay(await snap.serialize(), 40, 6);
+            expect(client.modes.mouseTrackingMode).toBe('any');
+            expect(client._core.coreMouseService.activeEncoding).toBe('SGR_PIXELS');
+            client.dispose();
+            snap.dispose();
+        });
+        it('emits nothing for modes the app turned back off', async () => {
+            const snap = (0, termSnapshot_1.createTermSnapshot)(40, 6);
+            await snap.write('\x1b[?1000h\x1b[?1006h\x1b[?25l\x1b[?2004h');
+            await snap.write('\x1b[?1000l\x1b[?1006l\x1b[?25h\x1b[?2004l');
+            const out = await snap.serialize();
+            expect(out).not.toMatch(/\x1b\[\?(1000|1006|25|2004)[hl]/);
+            const client = await replay(out, 40, 6);
+            expect(client.modes.mouseTrackingMode).toBe('none');
+            expect(client._core.coreMouseService.activeEncoding).toBe('DEFAULT');
+            client.dispose();
+            snap.dispose();
+        });
+    });
 });

package/dist/bridge/termSnapshot.js

@@ -36,7 +36,10 @@ function createTermSnapshot(cols, rows, opts) {
     // stable public API).
     const term = new Terminal({ cols, rows, scrollback, allowProposedApi: true });
     const serializer = new SerializeAddon();
-    term.loadAddon(serializer);
+    // The addon reads the terminal through a CLIPPED VIEW, not the terminal
+    // itself — see clippedView below. activate() only stores the reference
+    // (the addon has no other loadAddon-time wiring); dispose() releases it.
+    serializer.activate(clippedView(term));
     // Terminal.write() is async: the parser runs on an internal write queue
     // and only calls the callback once that write has actually been applied
     // to the buffer. Resolving our promise from that callback means callers
@@ -56,7 +59,7 @@ function createTermSnapshot(cols, rows, opts) {
         },
         serialize: async () => {
             await flush();
-            return serializer.serialize({ scrollback });
+            return serializer.serialize({ scrollback }) + extraModes(term);
         },
         dispose: () => {
             serializer.dispose();
@@ -64,3 +67,112 @@ function createTermSnapshot(cols, rows, opts) {
         },
     };
 }
+// ---------------------------------------------------------------------------
+// Narrow-after-wide clipping.
+//
+// xterm does not truncate buffer lines when the terminal shrinks: the
+// alternate buffer (where full-screen TUIs like OpenCode draw) never reflows,
+// so after a 40→20 col shrink every alt row still holds 40 cells. The
+// serialize addon walks `line.length` cells per row, so the snapshot wrote
+// each row at its OLD width, the replay terminal (at the new width)
+// auto-wrapped the tail onto the next row, and the frame came back garbled
+// on reattach. The live screen only ever shows the first `cols` cells, so the
+// snapshot clips every row to `cols` — via a read-only view, never by
+// mutating the emulator (growing back must still reveal what xterm kept).
+// ---------------------------------------------------------------------------
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/** Forward every property of `target`, with functions bound to it, except the overrides. */
+function forwardingProxy(target, override) {
+    return new Proxy(target, {
+        get(t, prop) {
+            const o = override(prop);
+            if (o)
+                return o.value;
+            const v = Reflect.get(t, prop, t);
+            return typeof v === 'function' ? v.bind(t) : v;
+        },
+    });
+}
+/** The number of cells of `line` that are visible at `cols` — never splits a
+ *  wide (2-cell) character: one that straddles the edge is dropped whole. */
+function visibleLength(line, cols) {
+    if (!line || line.length <= cols)
+        return line ? line.length : 0;
+    const edge = line.getCell(cols - 1);
+    return edge && edge.getWidth() === 2 ? cols - 1 : cols;
+}
+function clippedBuffer(buffer, term) {
+    return forwardingProxy(buffer, (prop) => {
+        if (prop !== 'getLine')
+            return null;
+        return {
+            hit: true,
+            value: (y) => {
+                const line = buffer.getLine(y);
+                if (!line)
+                    return line;
+                const cols = term.cols;
+                const len = visibleLength(line, cols);
+                // A row that continued a now-clipped wider row is no longer a soft
+                // wrap of it at this width — the serializer must end the previous
+                // row with a hard CRLF, not rely on auto-wrap.
+                const prev = y > 0 ? buffer.getLine(y - 1) : undefined;
+                const wrapped = line.isWrapped && !(prev && prev.length > cols);
+                if (len === line.length && wrapped === line.isWrapped)
+                    return line;
+                return forwardingProxy(line, (p) => {
+                    if (p === 'length')
+                        return { hit: true, value: len };
+                    if (p === 'isWrapped')
+                        return { hit: true, value: wrapped };
+                    return null;
+                });
+            },
+        };
+    });
+}
+/** The terminal as the serialize addon sees it: same object, but every
+ *  buffer row is clipped to the CURRENT cols. Rows need no clipping: the
+ *  alt buffer is exactly `rows` long after a resize, and the normal buffer
+ *  pushes the overflow into scrollback (which the replay scrolls too). */
+function clippedView(term) {
+    // Resolved NOW, not on first serialize: xterm creates + registers the
+    // buffer namespace lazily, and doing that on a terminal already disposed
+    // (a serialize racing dispose) leaks a disposable with a warning.
+    const ns = term.buffer;
+    const view = forwardingProxy(ns, (prop) => {
+        if (prop === 'normal' || prop === 'alternate' || prop === 'active') {
+            return { hit: true, value: clippedBuffer(ns[prop], term) };
+        }
+        return null;
+    });
+    return forwardingProxy(term, (prop) => (prop === 'buffer' ? { hit: true, value: view } : null));
+}
+// ---------------------------------------------------------------------------
+// Terminal modes the serialize addon drops.
+//
+// The addon re-emits mouse TRACKING (?9/?1000/?1002/?1003), bracketed paste,
+// application cursor/keypad, focus, insert/origin/wrap and the alt screen
+// (?1049) — but not the mouse ENCODING (?1006 SGR / ?1016 SGR-pixels) nor a
+// hidden cursor (?25l). Without ?1006 a reattached client reports wheel and
+// clicks in the legacy X10 byte encoding, which an SGR-expecting TUI
+// (OpenCode) ignores — so mouse-wheel scroll silently died after a reattach,
+// and the hidden cursor reappeared as a stray block.
+//
+// Read from the emulator's own state (the same `_core` internals the addon
+// itself reads), so resets (RIS/DECSTR) are honoured exactly as xterm
+// applies them — no shadow parser that could drift.
+// ---------------------------------------------------------------------------
+/** Escape sequences restoring the modes the serialize addon does not emit. */
+function extraModes(term) {
+    const core = term?._core;
+    let out = '';
+    const encoding = core?.coreMouseService?.activeEncoding;
+    if (encoding === 'SGR')
+        out += '\x1b[?1006h';
+    else if (encoding === 'SGR_PIXELS')
+        out += '\x1b[?1016h';
+    if (core?.coreService?.isCursorHidden === true)
+        out += '\x1b[?25l';
+    return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wenrwa/marketplace-cli",
-  "version": "0.8.4",
+  "version": "0.8.5",
   "description": "CLI tool for the Wenrwa Agent Marketplace — monitor bounties, agents, workspaces, and treasury from your terminal",
   "author": "Wenrwa <dev@wenrwa.com>",
   "license": "MIT",