@wenrwa/marketplace-cli 0.7.3 → 0.7.4

package/dist/__tests__/bridge-launch-supervisor.test.d.ts

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

package/dist/__tests__/bridge-launch-supervisor.test.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const launchSupervisor_1 = require("../bridge/launchSupervisor");
+const sessionManager_1 = require("../bridge/sessionManager");
+const ID = '445be432-0000-4000-8000-000000000001';
+// Verbatim shapes from Claude Code 2.1.289 (stderr is red-wrapped; the resume
+// miss is drawn by the TUI with a truecolor escape).
+const IN_USE = `\x1b[31mError: Session ID ${ID} is already in use.\x1b[39m\r\n`;
+const NO_CONVO = `\x1b[?2026h\x1b[38;2;255;107;128mNo conversation found with session ID: ${ID}\x1b[39m\r\r\n`;
+class FakePty {
+    args;
+    written = [];
+    killed = false;
+    dataCb = null;
+    exitCb = null;
+    constructor(args) {
+        this.args = args;
+    }
+    write(d) { this.written.push(d); }
+    resize() { }
+    kill() { this.killed = true; }
+    onData(cb) { this.dataCb = cb; }
+    onExit(cb) { this.exitCb = cb; }
+    emit(d) { this.dataCb?.(d); }
+    exit(code) { this.exitCb?.(code); }
+}
+function harness(args) {
+    const spawned = [];
+    const factory = {
+        spawn: (o) => {
+            const p = new FakePty(o.args ?? []);
+            spawned.push(p);
+            return p;
+        },
+    };
+    let t = 0;
+    const logs = [];
+    const pty = (0, launchSupervisor_1.superviseLaunch)(factory, { cols: 80, rows: 24, command: 'claude', args }, { now: () => t, log: (m) => logs.push(m), settle: (fn) => fn(), windowMs: 10_000 });
+    const out = [];
+    const exits = [];
+    pty.onData((d) => out.push(d));
+    pty.onExit((c) => exits.push(c));
+    return { pty, spawned, out, exits, logs, advance: (ms) => { t += ms; } };
+}
+describe('launchSupervisor — pure helpers', () => {
+    it('session-in-use on --session-id → swap to --resume, keeping every other arg', () => {
+        expect((0, launchSupervisor_1.retryArgsFor)(['--dangerously-skip-permissions', '--settings', '/s.json', '--session-id', ID], IN_USE))
+            .toEqual(['--dangerously-skip-permissions', '--settings', '/s.json', '--resume', ID]);
+    });
+    it('no-conversation on --resume → swap to --session-id', () => {
+        expect((0, launchSupervisor_1.retryArgsFor)(['--resume', ID], NO_CONVO)).toEqual(['--session-id', ID]);
+    });
+    it('no session flag, or an unrelated error → no retry', () => {
+        expect((0, launchSupervisor_1.retryArgsFor)([], IN_USE)).toBeNull();
+        expect((0, launchSupervisor_1.retryArgsFor)(['--session-id', ID], 'Error: Invalid session ID. Must be a valid UUID.')).toBeNull();
+        expect((0, launchSupervisor_1.retryArgsFor)(['--resume', ID], IN_USE)).toBeNull();
+    });
+    it('firstMeaningfulLine strips ANSI, "Error:" and stack frames', () => {
+        expect((0, launchSupervisor_1.firstMeaningfulLine)(IN_USE)).toBe(`Session ID ${ID} is already in use`);
+        expect((0, launchSupervisor_1.firstMeaningfulLine)('\r\n\x1b[1m\x1b[0m\r\nError: boom.\n    at foo (x.js:1:1)\n')).toBe('boom');
+        expect((0, launchSupervisor_1.firstMeaningfulLine)('\x1b[?25h\r\n')).toBeNull();
+    });
+    it('friendly line is one short sentence with no stack trace', () => {
+        const line = (0, launchSupervisor_1.friendlyStartFailure)('Error: kaput\n    at a (b.js:1:1)\n    at c (d.js:2:2)', 1);
+        expect(line).toContain("Claude couldn't start: kaput. Reopen the pane to try again.");
+        expect(line).not.toContain('at a (');
+        expect((0, launchSupervisor_1.friendlyStartFailure)('', 3)).toContain("Claude couldn't start: it exited with code 3.");
+    });
+});
+describe('launchSupervisor — supervised PTY', () => {
+    it('session-in-use → exactly one relaunch with --resume; the healthy retry is passed through', () => {
+        const h = harness(['--session-id', ID]);
+        h.spawned[0].emit(IN_USE);
+        h.advance(800);
+        h.spawned[0].exit(1);
+        expect(h.spawned).toHaveLength(2);
+        expect(h.spawned[1].args).toEqual(['--resume', ID]);
+        expect(h.exits).toEqual([]); // the pane never sees the first exit
+        expect(h.out.join('')).not.toContain("couldn't start");
+        h.pty.write('hi');
+        expect(h.spawned[1].written).toEqual(['hi']);
+        h.spawned[1].emit('welcome back');
+        expect(h.out[h.out.length - 1]).toBe('welcome back');
+        expect(h.logs.join('\n')).toMatch(/already in use/);
+    });
+    it('resume-missing → exactly one relaunch with --session-id', () => {
+        const h = harness(['--dangerously-skip-permissions', '--resume', ID]);
+        h.spawned[0].emit(NO_CONVO);
+        h.spawned[0].exit(1);
+        expect(h.spawned).toHaveLength(2);
+        expect(h.spawned[1].args).toEqual(['--dangerously-skip-permissions', '--session-id', ID]);
+        expect(h.exits).toEqual([]);
+    });
+    it('never loops: a retry that fails the same way gets the friendly line and the exit, no third spawn', () => {
+        const h = harness(['--session-id', ID]);
+        h.spawned[0].emit(IN_USE);
+        h.spawned[0].exit(1);
+        h.spawned[1].emit(NO_CONVO);
+        h.spawned[1].exit(1);
+        expect(h.spawned).toHaveLength(2);
+        expect(h.exits).toEqual([1]);
+        expect(h.out.join('')).toContain(`Claude couldn't start: No conversation found with session ID: ${ID}. Reopen the pane to try again.`);
+    });
+    it('generic fast non-zero exit → friendly line, then the exit; raw error kept in the log', () => {
+        const h = harness(['--session-id', ID]);
+        h.spawned[0].emit('\x1b[31mError: Invalid session ID. Must be a valid UUID.\x1b[39m\r\n');
+        h.advance(300);
+        h.spawned[0].exit(1);
+        expect(h.spawned).toHaveLength(1);
+        expect(h.exits).toEqual([1]);
+        const last = h.out[h.out.length - 1];
+        expect(last).toContain("Claude couldn't start: Invalid session ID. Must be a valid UUID. Reopen the pane to try again.");
+        expect(h.logs.join('\n')).toContain('Error: Invalid session ID. Must be a valid UUID.');
+    });
+    it('a long-running session that exits later is untouched — no retry, no friendly line', () => {
+        const h = harness(['--session-id', ID]);
+        h.spawned[0].emit('working...');
+        h.advance(60_000);
+        h.spawned[0].emit(IN_USE); // even matching text, outside the window
+        h.spawned[0].exit(1);
+        expect(h.spawned).toHaveLength(1);
+        expect(h.exits).toEqual([1]);
+        expect(h.out.join('')).not.toContain("couldn't start");
+        expect(h.logs).toEqual([]);
+    });
+    it('a fast clean exit (code 0) passes straight through', () => {
+        const h = harness(['--resume', ID]);
+        h.spawned[0].exit(0);
+        expect(h.spawned).toHaveLength(1);
+        expect(h.exits).toEqual([0]);
+        expect(h.out).toEqual([]);
+    });
+    it('a bridge kill is never retried or annotated', () => {
+        const h = harness(['--session-id', ID]);
+        h.spawned[0].emit(IN_USE);
+        h.pty.kill();
+        expect(h.spawned[0].killed).toBe(true);
+        h.spawned[0].exit(1);
+        expect(h.spawned).toHaveLength(1);
+        expect(h.exits).toEqual([1]);
+        expect(h.out.join('')).not.toContain("couldn't start");
+    });
+});
+describe('launchSupervisor — wired through SessionManager', () => {
+    const fakeSnapshot = () => ({
+        write: () => Promise.resolve(),
+        resize: () => { },
+        serialize: () => Promise.resolve(''),
+        dispose: () => { },
+    });
+    function manager() {
+        const spawned = [];
+        const factory = { spawn: (o) => { const p = new FakePty(o.args ?? []); spawned.push(p); return p; } };
+        const mgr = new sessionManager_1.SessionManager(factory, {
+            snapshotFactory: fakeSnapshot,
+            launchSupervisor: { now: () => 0, log: () => { }, settle: (fn) => fn() },
+        });
+        const exits = [];
+        mgr.setOnSessionExit((id, code) => exits.push([id, code]));
+        return { mgr, spawned, exits };
+    }
+    it('a claude launch self-heals inside one session: same id, one exit only when the retry dies', async () => {
+        const { mgr, spawned, exits } = manager();
+        const id = mgr.open({ cols: 80, rows: 24, id: ID, command: 'claude', args: ['--session-id', ID] });
+        const seen = [];
+        await mgr.attach(id, (f) => { if (f.t === 'data')
+            seen.push(f.data); });
+        spawned[0].emit(IN_USE);
+        spawned[0].exit(1);
+        expect(spawned).toHaveLength(2);
+        expect(mgr.list()).toEqual([ID]);
+        expect(exits).toEqual([]);
+        spawned[1].emit('boom\r\n');
+        spawned[1].exit(2);
+        expect(exits).toEqual([[ID, 2]]);
+        expect(seen.join('')).toContain("Claude couldn't start: boom. Reopen the pane to try again.");
+    });
+    it('a shell launch (no command) is not supervised', () => {
+        const { mgr, spawned, exits } = manager();
+        mgr.open({ cols: 80, rows: 24 });
+        spawned[0].emit('Error: nope\r\n');
+        spawned[0].exit(1);
+        expect(spawned).toHaveLength(1);
+        expect(exits).toHaveLength(1);
+    });
+});

package/dist/bridge/launchSupervisor.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Launch supervisor — makes a `claude` that dies at startup either heal
+ * itself or say so in plain words, instead of leaving its raw stderr as the
+ * last thing in the pane.
+ *
+ * Wraps ONE agent launch (SessionManager.open with `command: 'claude'`) in a
+ * PtyLike that the session manager cannot tell apart from a plain PTY. Inside,
+ * it watches the first `windowMs` of the process's life:
+ *
+ *  - `--session-id <id>` exits early with "Session ID <id> is already in use"
+ *    → the conversation already exists (e.g. it was recorded under a project
+ *    dir the existence check missed), so relaunch ONCE with `--resume <id>`.
+ *  - `--resume <id>` exits early with "No conversation found with session ID"
+ *    → there is nothing to resume, so relaunch ONCE with `--session-id <id>`.
+ *  - any other early non-zero exit (or a retry that also fails) → write one
+ *    short line into the stream ("Claude couldn't start: …") and let the exit
+ *    through. The raw output goes to the bridge log, not into a second copy.
+ *
+ * At most one retry per open — the retry itself is never retried, so no loop.
+ * A process that outlives the window, exits 0, or was killed by the bridge is
+ * passed through untouched.
+ *
+ * Wording checked against Claude Code 2.1.289: the session-in-use error is
+ * `Error: Session ID <uuid> is already in use.` (stderr); the resume miss is
+ * `No conversation found with session ID: <uuid>` (rendered by the TUI).
+ * Both arrive on the PTY, so matching the combined output catches both.
+ *
+ * Both lanes: the local bridge (loopback + crew relay on a laptop) spawns
+ * `claude` through here. The hosted container does NOT — it spawns $SHELL and
+ * infra/terminal-image/autolaunch.sh runs `claude`, so the same rules live
+ * there too.
+ */
+import { PtyFactory, PtyLike } from './sessionManager';
+/** How long after launch an exit still counts as "couldn't start". */
+export declare const DEFAULT_LAUNCH_WINDOW_MS = 10000;
+export declare const SESSION_IN_USE_RE: RegExp;
+export declare const RESUME_MISSING_RE: RegExp;
+export declare function stripAnsi(s: string): string;
+/**
+ * The first line of `output` worth showing a person: ANSI stripped, blank
+ * lines and stack frames skipped, a leading "Error:" dropped, trailing period
+ * dropped (the caller adds its own punctuation), clipped to ~160 chars.
+ */
+export declare function firstMeaningfulLine(output: string): string | null;
+/**
+ * Pure decision for an EARLY exit (caller has already checked the window and
+ * the retry budget): the argv to relaunch with, or null for "don't retry".
+ */
+export declare function retryArgsFor(args: string[], output: string): string[] | null;
+export declare function friendlyStartFailure(output: string, code: number): string;
+export interface LaunchSupervisorOptions {
+    windowMs?: number;
+    now?: () => number;
+    log?: (msg: string) => void;
+    /** node-pty can report exit before the last output chunk is read; an early
+     *  failure is judged after this short settle. Tests pass a synchronous one. */
+    settle?: (fn: () => void) => void;
+}
+type SpawnOpts = Parameters<PtyFactory['spawn']>[0];
+export declare function superviseLaunch(factory: PtyFactory, spawnOpts: SpawnOpts, opts?: LaunchSupervisorOptions): PtyLike;
+export {};

package/dist/bridge/launchSupervisor.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESUME_MISSING_RE = exports.SESSION_IN_USE_RE = exports.DEFAULT_LAUNCH_WINDOW_MS = void 0;
+exports.stripAnsi = stripAnsi;
+exports.firstMeaningfulLine = firstMeaningfulLine;
+exports.retryArgsFor = retryArgsFor;
+exports.friendlyStartFailure = friendlyStartFailure;
+exports.superviseLaunch = superviseLaunch;
+/** How long after launch an exit still counts as "couldn't start". */
+exports.DEFAULT_LAUNCH_WINDOW_MS = 10_000;
+/** Cap on how much early output is kept for matching/logging. */
+const MAX_CAPTURE = 16 * 1024;
+exports.SESSION_IN_USE_RE = /Session ID \S+ is already in use/i;
+exports.RESUME_MISSING_RE = /No conversation found/i;
+// CSI, OSC (BEL- or ST-terminated), and lone two-char escapes.
+// eslint-disable-next-line no-control-regex
+const ANSI_RE = /\x1b\[[0-?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[@-Z\\-_()#%][0-9A-Za-z]?/g;
+function stripAnsi(s) {
+    // eslint-disable-next-line no-control-regex
+    return s.replace(ANSI_RE, '').replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, '');
+}
+/**
+ * The first line of `output` worth showing a person: ANSI stripped, blank
+ * lines and stack frames skipped, a leading "Error:" dropped, trailing period
+ * dropped (the caller adds its own punctuation), clipped to ~160 chars.
+ */
+function firstMeaningfulLine(output) {
+    const lines = stripAnsi(output).split(/\r?\n|\r/);
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (!line)
+            continue;
+        if (/^at\s+\S/.test(line))
+            continue;
+        if (/^[-─━═_=*·•\s]+$/.test(line))
+            continue;
+        let msg = line.replace(/^(?:error|fatal)\s*:\s*/i, '').replace(/[.\s]+$/, '');
+        if (!msg)
+            continue;
+        if (msg.length > 160)
+            msg = `${msg.slice(0, 157)}...`;
+        return msg;
+    }
+    return null;
+}
+/** Where `--resume`/`--session-id` sits in argv, or null. */
+function sessionFlagIndex(args) {
+    for (let i = 0; i < args.length - 1; i++) {
+        if (args[i] === '--resume' || args[i] === '--session-id')
+            return i;
+    }
+    return null;
+}
+/**
+ * Pure decision for an EARLY exit (caller has already checked the window and
+ * the retry budget): the argv to relaunch with, or null for "don't retry".
+ */
+function retryArgsFor(args, output) {
+    const i = sessionFlagIndex(args);
+    if (i === null)
+        return null;
+    const text = stripAnsi(output);
+    const flag = args[i];
+    if (flag === '--session-id' && exports.SESSION_IN_USE_RE.test(text)) {
+        const next = [...args];
+        next[i] = '--resume';
+        return next;
+    }
+    if (flag === '--resume' && exports.RESUME_MISSING_RE.test(text)) {
+        const next = [...args];
+        next[i] = '--session-id';
+        return next;
+    }
+    return null;
+}
+function friendlyStartFailure(output, code) {
+    const reason = firstMeaningfulLine(output) ?? `it exited with code ${code}`;
+    return `\r\n\x1b[33mClaude couldn't start: ${reason}. Reopen the pane to try again.\x1b[0m\r\n`;
+}
+/** Clears the pane before the retry so the raw error from the first attempt
+ *  doesn't sit above the healthy session. */
+const RETRY_CLEAR = '\x1b[2J\x1b[3J\x1b[H';
+function superviseLaunch(factory, spawnOpts, opts = {}) {
+    const windowMs = opts.windowMs ?? exports.DEFAULT_LAUNCH_WINDOW_MS;
+    const now = opts.now ?? Date.now;
+    const log = opts.log ?? ((m) => console.error(m));
+    const settle = opts.settle ?? ((fn) => { setTimeout(fn, 100); });
+    const dataListeners = [];
+    const exitListeners = [];
+    const emitData = (d) => { for (const cb of dataListeners)
+        cb(d); };
+    const emitExit = (code) => { for (const cb of exitListeners)
+        cb(code); };
+    let cols = spawnOpts.cols;
+    let rows = spawnOpts.rows;
+    let args = spawnOpts.args ?? [];
+    let retried = false;
+    let killed = false;
+    let current;
+    const start = () => {
+        const startedAt = now();
+        let captured = '';
+        const pty = factory.spawn({ ...spawnOpts, cols, rows, args });
+        current = pty;
+        pty.onData((d) => {
+            if (pty !== current)
+                return;
+            if (captured.length < MAX_CAPTURE && now() - startedAt < windowMs)
+                captured += d;
+            emitData(d);
+        });
+        pty.onExit((code) => {
+            if (pty !== current)
+                return;
+            const early = now() - startedAt < windowMs;
+            if (killed || !early || code === 0) {
+                emitExit(code);
+                return;
+            }
+            settle(() => onEarlyFailure(code));
+        });
+        const onEarlyFailure = (code) => {
+            if (pty !== current)
+                return;
+            if (killed) {
+                emitExit(code);
+                return;
+            }
+            const raw = stripAnsi(captured).trim();
+            log(`[bridge] claude exited at startup (code ${code}, args: ${args.join(' ')}): ${raw || '(no output)'}`);
+            const nextArgs = retried ? null : retryArgsFor(args, captured);
+            if (nextArgs) {
+                retried = true;
+                log(`[bridge] relaunching claude once with: ${nextArgs.join(' ')}`);
+                args = nextArgs;
+                emitData(RETRY_CLEAR);
+                try {
+                    start();
+                    return;
+                }
+                catch (err) {
+                    log(`[bridge] claude relaunch failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            emitData(friendlyStartFailure(captured, code));
+            emitExit(code);
+        };
+    };
+    start();
+    return {
+        write: (d) => current.write(d),
+        resize: (c, r) => { cols = c; rows = r; current.resize(c, r); },
+        kill: () => { killed = true; current.kill(); },
+        onData: (cb) => { dataListeners.push(cb); },
+        onExit: (cb) => { exitListeners.push(cb); },
+    };
+}

package/dist/bridge/sessionManager.d.ts

@@ -1,4 +1,5 @@
 import { TermSnapshot } from './termSnapshot';
+import { LaunchSupervisorOptions } from './launchSupervisor';
 export interface PtyLike {
     write(data: string): void;
     resize(cols: number, rows: number): void;
@@ -83,6 +84,10 @@ export interface SessionManagerOptions {
     snapshotFactory?: (cols: number, rows: number, opts?: {
         scrollback?: number;
     }) => TermSnapshot;
+    /** Startup supervision for `claude` launches (launchSupervisor.ts): one
+     *  self-healing retry for a session-id/resume mismatch, else a plain
+     *  "Claude couldn't start" line. Injectable clock/settle for tests. */
+    launchSupervisor?: LaunchSupervisorOptions;
 }
 /**
  * lws-07 (ADR-0033 port): validates a client-supplied size pair for the
@@ -106,6 +111,7 @@ export declare class SessionManager {
     private scheduleTimeout;
     private cancelTimeout;
     private snapshotFactory;
+    private launchSupervisor;
     /** twr-16: cumulative count of attach-pipeline wedges (any stage timeout,
      *  or a serialize-wedge whose recovery retry ALSO timed out) since this
      *  SessionManager was created. Surfaced via attachFailures() into the

package/dist/bridge/sessionManager.js

@@ -21,6 +21,7 @@ exports.validSize = validSize;
  */
 const crypto_1 = __importDefault(require("crypto"));
 const termSnapshot_1 = require("./termSnapshot");
+const launchSupervisor_1 = require("./launchSupervisor");
 /** Default settle window (lws-07): after a resize-on-attach, how long we give
  *  the PTY's SIGWINCH-triggered repaint to land in the snapshot before
  *  serializing. Small — this only needs to cover one render tick, not a
@@ -73,6 +74,7 @@ class SessionManager {
     scheduleTimeout;
     cancelTimeout;
     snapshotFactory;
+    launchSupervisor;
     /** twr-16: cumulative count of attach-pipeline wedges (any stage timeout,
      *  or a serialize-wedge whose recovery retry ALSO timed out) since this
      *  SessionManager was created. Surfaced via attachFailures() into the
@@ -89,6 +91,7 @@ class SessionManager {
         this.scheduleTimeout = opts.scheduleTimeout ?? ((cb, ms) => setTimeout(cb, ms));
         this.cancelTimeout = opts.cancelTimeout ?? ((h) => clearTimeout(h));
         this.snapshotFactory = opts.snapshotFactory ?? termSnapshot_1.createTermSnapshot;
+        this.launchSupervisor = opts.launchSupervisor ?? {};
     }
     /** twr-16: see attachFailureCount. */
     attachFailures() {
@@ -123,7 +126,12 @@ class SessionManager {
             prior.snapshot.dispose();
             this.sessions.delete(id);
         }
-        const pty = this.factory.spawn(opts);
+        // A `claude` launch (agent panes, crew members) is supervised through its
+        // startup window so a fast failure heals or explains itself; a shell is
+        // spawned exactly as before.
+        const pty = opts.command === 'claude'
+            ? (0, launchSupervisor_1.superviseLaunch)(this.factory, opts, this.launchSupervisor)
+            : this.factory.spawn(opts);
         const snapshot = this.snapshotFactory(opts.cols, opts.rows, { scrollback: this.snapshotScrollback });
         const session = {
             pty,

package/package.json

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