@wenrwa/marketplace-cli 0.7.7 → 0.7.8

package/dist/__tests__/bridge-attach-screenshot.test.d.ts

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

package/dist/__tests__/bridge-attach-screenshot.test.js

@@ -0,0 +1,250 @@
+"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 });
+/**
+ * Screenshot drop — `attach-screenshot {rid, sessionId, name}` (local bridge
+ * only). The browser cannot read a dropped macOS screenshot thumbnail, so the
+ * bridge reads `<screenshot folder>/<name>` once macOS has written it.
+ *
+ * Fake fs + fake clock: the folder is a Map, sleep advances the clock, so the
+ * ~6s poll runs instantly and deterministically. The attachment WRITE is real
+ * (temp dir), so the bytes on disk are compared with the bytes "dropped".
+ */
+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 relayClient_1 = require("../bridge/relayClient");
+const sessionManager_1 = require("../bridge/sessionManager");
+const attachmentWriter_1 = require("../bridge/attachmentWriter");
+const screenshotAttach_1 = require("../bridge/screenshotAttach");
+class FakePty {
+    written = [];
+    write(d) { this.written.push(d); }
+    resize() { }
+    kill() { }
+    onData() { }
+    onExit() { }
+}
+const PNG = Buffer.from('89504e470d0a1a0a0000000d49484452000000010000000108060000001f15c4890000000d4944415478da63f8cfc0f01f0005000201a5f3b4d60000000049454e44ae426082', 'hex');
+const HOME = '/Users/me';
+const NAME = 'Screenshot 2026-10-04 at 9.41.12 AM.png';
+/** A fake screenshot folder: files appear at a given fake time. */
+function fakeDeps(opts) {
+    let clock = 0;
+    const reads = [];
+    const deps = {
+        platform: opts.platform ?? 'darwin',
+        homedir: () => HOME,
+        readScreencaptureLocation: async () => (opts.location === undefined ? null : opts.location),
+        stat: (p) => {
+            const f = opts.files?.[p];
+            if (!f || clock < (f.at ?? 0))
+                return null;
+            return { isFile: f.isFile ?? true, size: f.data.length };
+        },
+        readFile: (p) => { reads.push(p); return opts.files[p].data; },
+        sleep: async (ms) => { clock += ms; },
+        now: () => clock,
+        attachment: attachmentWriter_1.realAttachmentDeps,
+    };
+    return { deps, reads, clock: () => clock };
+}
+let tmp;
+const sessions = () => ({ list: () => ['agent-1'], cwdOf: () => tmp });
+beforeEach(() => { tmp = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'shot-'))); });
+afterEach(() => { fs.rmSync(tmp, { recursive: true, force: true }); });
+describe('screenshot folder resolution', () => {
+    it('defaults to ~/Desktop, expands ~, ignores relative junk', () => {
+        expect((0, screenshotAttach_1.resolveScreenshotFolder)(null, HOME)).toBe('/Users/me/Desktop');
+        expect((0, screenshotAttach_1.resolveScreenshotFolder)('  \n', HOME)).toBe('/Users/me/Desktop');
+        expect((0, screenshotAttach_1.resolveScreenshotFolder)('~/Pictures/Screenshots\n', HOME)).toBe('/Users/me/Pictures/Screenshots');
+        expect((0, screenshotAttach_1.resolveScreenshotFolder)('~', HOME)).toBe('/Users/me');
+        expect((0, screenshotAttach_1.resolveScreenshotFolder)('/Volumes/Shots/', HOME)).toBe('/Volumes/Shots/');
+        expect((0, screenshotAttach_1.resolveScreenshotFolder)('Pictures', HOME)).toBe('/Users/me/Desktop');
+    });
+    it('accepts only a plain image basename', () => {
+        expect((0, screenshotAttach_1.isSafeScreenshotName)(NAME)).toBe(true);
+        expect((0, screenshotAttach_1.isSafeScreenshotName)('shot.JPEG')).toBe(true);
+        expect((0, screenshotAttach_1.isSafeScreenshotName)('shot.webp')).toBe(true);
+        expect((0, screenshotAttach_1.isSafeScreenshotName)('../secret.png')).toBe(false);
+        expect((0, screenshotAttach_1.isSafeScreenshotName)('a/b.png')).toBe(false);
+        expect((0, screenshotAttach_1.isSafeScreenshotName)('a\\b.png')).toBe(false);
+        expect((0, screenshotAttach_1.isSafeScreenshotName)('..png')).toBe(false);
+        expect((0, screenshotAttach_1.isSafeScreenshotName)('.hidden.png')).toBe(false);
+        expect((0, screenshotAttach_1.isSafeScreenshotName)('x.png\0.txt')).toBe(false);
+        expect((0, screenshotAttach_1.isSafeScreenshotName)('shot.heic')).toBe(false);
+        expect((0, screenshotAttach_1.isSafeScreenshotName)('notes.txt')).toBe(false);
+        expect((0, screenshotAttach_1.isSafeScreenshotName)('noext')).toBe(false);
+        expect((0, screenshotAttach_1.isSafeScreenshotName)(42)).toBe(false);
+    });
+});
+describe('handleScreenshotFrame', () => {
+    it('finds the file after macOS writes it (delay) and saves it via the attach writer', async () => {
+        const file = path.join('/Users/me/Pictures/Shots', NAME);
+        const f = fakeDeps({ location: '~/Pictures/Shots', files: { [file]: { data: PNG, at: 1500 } } });
+        const reply = await (0, screenshotAttach_1.handleScreenshotFrame)({ rid: 'r1', sessionId: 'agent-1', name: NAME }, sessions(), f.deps);
+        expect(reply).toMatchObject({ t: 'file-attached', rid: 'r1', sessionId: 'agent-1', ok: true, bytes: PNG.length });
+        expect(f.clock()).toBe(1500);
+        const saved = String(reply.path);
+        expect(path.dirname(saved)).toBe(path.join(tmp, attachmentWriter_1.ATTACHMENTS_DIR));
+        expect(saved.endsWith('-Screenshot-2026-10-04-at-9.41.12-AM.png')).toBe(true);
+        expect(fs.readFileSync(saved).equals(PNG)).toBe(true);
+        expect(f.reads).toEqual([file]);
+    });
+    it('defaults to ~/Desktop when no location is set', async () => {
+        const f = fakeDeps({ files: { [path.join('/Users/me/Desktop', NAME)]: { data: PNG } } });
+        const reply = await (0, screenshotAttach_1.handleScreenshotFrame)({ rid: 'r', sessionId: 'agent-1', name: NAME }, sessions(), f.deps);
+        expect(reply.ok).toBe(true);
+        expect(f.clock()).toBe(0);
+    });
+    it('gives up with not-found after ~6s', async () => {
+        const f = fakeDeps({});
+        expect(await (0, screenshotAttach_1.handleScreenshotFrame)({ rid: 'r', sessionId: 'agent-1', name: NAME }, sessions(), f.deps))
+            .toEqual({ t: 'file-attached', rid: 'r', sessionId: 'agent-1', ok: false, reason: 'not-found' });
+        expect(f.clock()).toBe(screenshotAttach_1.SCREENSHOT_POLL_MS);
+        expect(fs.existsSync(path.join(tmp, '.hiveop'))).toBe(false);
+    });
+    it('rejects path traversal without touching the disk', async () => {
+        const f = fakeDeps({ files: { '/Users/me/secret.png': { data: PNG } } });
+        for (const name of ['../secret.png', '/Users/me/secret.png', 'sub/../../secret.png']) {
+            expect(await (0, screenshotAttach_1.handleScreenshotFrame)({ rid: 'r', sessionId: 'agent-1', name }, sessions(), f.deps))
+                .toMatchObject({ ok: false, reason: 'bad-name' });
+        }
+        expect(f.reads).toEqual([]);
+    });
+    it('rejects non-image names and non-image bytes', async () => {
+        const file = path.join('/Users/me/Desktop', 'shot.png');
+        const f = fakeDeps({ files: { [file]: { data: Buffer.from('not an image at all') } } });
+        expect(await (0, screenshotAttach_1.handleScreenshotFrame)({ rid: 'r', sessionId: 'agent-1', name: 'notes.txt' }, sessions(), f.deps))
+            .toMatchObject({ ok: false, reason: 'bad-name' });
+        expect(await (0, screenshotAttach_1.handleScreenshotFrame)({ rid: 'r', sessionId: 'agent-1', name: 'shot.heic' }, sessions(), f.deps))
+            .toMatchObject({ ok: false, reason: 'bad-name' });
+        expect(await (0, screenshotAttach_1.handleScreenshotFrame)({ rid: 'r', sessionId: 'agent-1', name: 'shot.png' }, sessions(), f.deps))
+            .toMatchObject({ ok: false, reason: 'not-image' });
+        expect(fs.existsSync(path.join(tmp, '.hiveop'))).toBe(false);
+    });
+    it('refuses a symlink/dir by that name, an oversize file, an unknown session, and non-macOS', async () => {
+        const file = path.join('/Users/me/Desktop', 'shot.png');
+        const link = fakeDeps({ files: { [file]: { data: PNG, isFile: false } } });
+        expect(await (0, screenshotAttach_1.handleScreenshotFrame)({ rid: 'r', sessionId: 'agent-1', name: 'shot.png' }, sessions(), link.deps))
+            .toMatchObject({ ok: false, reason: 'not-image' });
+        expect(link.reads).toEqual([]);
+        const big = fakeDeps({ files: { [file]: { data: Buffer.alloc(attachmentWriter_1.MAX_ATTACHMENT_BYTES + 1) } } });
+        expect(await (0, screenshotAttach_1.handleScreenshotFrame)({ rid: 'r', sessionId: 'agent-1', name: 'shot.png' }, sessions(), big.deps))
+            .toMatchObject({ ok: false, reason: 'too-large' });
+        expect(big.reads).toEqual([]);
+        const ok = fakeDeps({ files: { [file]: { data: PNG } } });
+        expect(await (0, screenshotAttach_1.handleScreenshotFrame)({ rid: 'r', sessionId: 'nope', name: 'shot.png' }, sessions(), ok.deps))
+            .toMatchObject({ ok: false, reason: 'no-session' });
+        const linux = fakeDeps({ platform: 'linux', files: { [file]: { data: PNG } } });
+        expect(await (0, screenshotAttach_1.handleScreenshotFrame)({ rid: 'r', sessionId: 'agent-1', name: 'shot.png' }, sessions(), linux.deps))
+            .toMatchObject({ ok: false, reason: 'not-supported' });
+    });
+});
+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 ? Promise.resolve(frames.shift()) : new Promise((r) => waiters.push(r))) };
+}
+describe('local bridge server — attach-screenshot frame', () => {
+    let handle;
+    afterEach(async () => { await handle?.close(); });
+    it('answers over the loopback socket and advertises attach-screenshot on macOS', async () => {
+        const pty = new FakePty();
+        const mgr = new sessionManager_1.SessionManager({ spawn: () => pty });
+        const f = fakeDeps({ files: { [path.join('/Users/me/Desktop', NAME)]: { data: PNG, at: 500 } } });
+        handle = await (0, server_1.startBridgeServer)({ sessionToken: 'tok', allowedOrigin: 'https://app.hiveop.io', sessions: mgr, screenshotDeps: f.deps });
+        const sessionId = mgr.open({ cols: 80, rows: 24, cwd: tmp, id: 'agent-1' });
+        const res = await fetch(`http://127.0.0.1:${handle.port}/discovery`, { headers: { origin: 'https://app.hiveop.io' } });
+        expect((await res.json()).capabilities).toEqual(expect.arrayContaining(['terminal-attach', 'attach-screenshot']));
+        const ws = new ws_1.default(`ws://127.0.0.1:${handle.port}`, { headers: { origin: 'https://app.hiveop.io' } });
+        await new Promise((r) => ws.on('open', r));
+        const q = frameQueue(ws);
+        ws.send(JSON.stringify({ v: 1, token: 'tok' }));
+        ws.send(JSON.stringify({ t: 'attach-screenshot', rid: 's1', sessionId, name: NAME }));
+        const reply = await q.next();
+        expect(reply).toMatchObject({ t: 'file-attached', rid: 's1', sessionId, ok: true });
+        expect(fs.readFileSync(reply.path).equals(PNG)).toBe(true);
+        expect(pty.written).toEqual([]);
+        ws.close();
+    });
+    it('does not advertise attach-screenshot off macOS', async () => {
+        const mgr = new sessionManager_1.SessionManager({ spawn: () => new FakePty() });
+        handle = await (0, server_1.startBridgeServer)({
+            sessionToken: 'tok', allowedOrigin: 'https://app.hiveop.io', sessions: mgr,
+            screenshotDeps: fakeDeps({ platform: 'linux' }).deps,
+        });
+        const res = await fetch(`http://127.0.0.1:${handle.port}/discovery`, { headers: { origin: 'https://app.hiveop.io' } });
+        const caps = (await res.json()).capabilities;
+        expect(caps).toContain('terminal-attach');
+        expect(caps).not.toContain('attach-screenshot');
+    });
+});
+describe('relay client (hosted) — never answers attach-screenshot', () => {
+    it('sends no file-attached for the frame', async () => {
+        const { WebSocketServer } = await Promise.resolve().then(() => __importStar(require('ws')));
+        const wss = new WebSocketServer({ port: 0, host: '127.0.0.1' });
+        await new Promise((r) => wss.on('listening', r));
+        const port = wss.address().port;
+        const conn = new Promise((r) => wss.on('connection', r));
+        const mgr = new sessionManager_1.SessionManager({ spawn: () => new FakePty() });
+        mgr.open({ cols: 80, rows: 24, cwd: tmp, id: 'agent-H' });
+        const client = (0, relayClient_1.startRelayClient)({ relayUrl: `ws://127.0.0.1:${port}`, relayToken: 'tok', sessions: mgr });
+        const ws = await conn;
+        const got = [];
+        ws.on('message', (raw) => got.push(JSON.parse(String(raw))));
+        await new Promise((r) => setTimeout(r, 50)); // auth frame
+        ws.send(JSON.stringify({ t: 'attach-screenshot', rid: 'h1', sessionId: 'agent-H', name: 'shot.png' }));
+        await new Promise((r) => setTimeout(r, 200));
+        expect(got.filter((f) => f.t === 'file-attached')).toEqual([]);
+        client.close();
+        for (const c of wss.clients)
+            c.terminate();
+        await new Promise((r) => wss.close(r));
+    });
+});

package/dist/bridge/screenshotAttach.d.ts

@@ -0,0 +1,33 @@
+import { AttachmentDeps } from './attachmentWriter';
+export declare const SCREENSHOT_POLL_MS = 6000;
+export declare const SCREENSHOT_POLL_INTERVAL_MS = 250;
+export type ScreenshotReason = 'not-supported' | 'bad-name' | 'not-found' | 'not-image' | 'too-large' | 'no-session' | 'error';
+export interface ScreenshotDeps {
+    platform: NodeJS.Platform;
+    homedir: () => string;
+    /** Raw output of `defaults read com.apple.screencapture location`, or null when unset/failed. */
+    readScreencaptureLocation: () => Promise<string | null>;
+    /** lstat-style: null when absent. Never follows a symlink. */
+    stat: (p: string) => {
+        isFile: boolean;
+        size: number;
+    } | null;
+    readFile: (p: string) => Buffer;
+    sleep: (ms: number) => Promise<void>;
+    now: () => number;
+    attachment: AttachmentDeps;
+}
+export declare const realScreenshotDeps: ScreenshotDeps;
+/** `~` expansion + absolute check; anything odd falls back to ~/Desktop (macOS's own default). */
+export declare function resolveScreenshotFolder(raw: string | null, home: string): string;
+/** A plain image basename: no path separators, no traversal, no NUL, image extension. */
+export declare function isSafeScreenshotName(name: unknown): name is string;
+/** The `attach-screenshot` frame → `file-attached` reply. */
+export declare function handleScreenshotFrame(frame: {
+    rid?: unknown;
+    sessionId?: unknown;
+    name?: unknown;
+}, sessions: {
+    list(): string[];
+    cwdOf(id: string): string | undefined;
+}, deps?: ScreenshotDeps): Promise<Record<string, unknown>>;

package/dist/bridge/screenshotAttach.js

@@ -0,0 +1,171 @@
+"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 });
+exports.realScreenshotDeps = exports.SCREENSHOT_POLL_INTERVAL_MS = exports.SCREENSHOT_POLL_MS = void 0;
+exports.resolveScreenshotFolder = resolveScreenshotFolder;
+exports.isSafeScreenshotName = isSafeScreenshotName;
+exports.handleScreenshotFrame = handleScreenshotFrame;
+/**
+ * Screenshot drop — LOCAL bridge only.
+ *
+ * Dragging the macOS floating screenshot thumbnail onto a browser hands the
+ * page a File backed by a *file promise*: the browser cannot read its bytes
+ * (NotReadableError), and macOS writes the real PNG into the screenshot
+ * folder only after the drop. The browser still knows the file's NAME, so it
+ * sends `attach-screenshot {rid, sessionId, name}` and this module:
+ *
+ *   1. resolves the screenshot folder (`defaults read com.apple.screencapture
+ *      location`, `~` expanded; default ~/Desktop; non-macOS → not-supported),
+ *   2. accepts `name` only as a plain image basename (no separators, no `..`,
+ *      png/jpg/jpeg/gif/webp),
+ *   3. polls for `<folder>/<name>` for up to ~6s (a regular file, ≤ 10 MB,
+ *      whose bytes sniff as an image — a half-written file keeps polling),
+ *   4. saves it through the SAME writer as `attach-file` (attachmentWriter).
+ *
+ * Never wired into the relay client: a hosted container cannot see the
+ * user's Desktop, and must not be asked to read its own disk by name.
+ */
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const attachmentWriter_1 = require("./attachmentWriter");
+exports.SCREENSHOT_POLL_MS = 6000;
+exports.SCREENSHOT_POLL_INTERVAL_MS = 250;
+const SCREENSHOT_EXTS = new Set(['png', 'jpg', 'jpeg', 'gif', 'webp']);
+exports.realScreenshotDeps = {
+    platform: process.platform,
+    homedir: () => os.homedir(),
+    readScreencaptureLocation: () => new Promise((resolve) => {
+        (0, child_process_1.execFile)('defaults', ['read', 'com.apple.screencapture', 'location'], { timeout: 2000 }, (err, stdout) => {
+            resolve(err ? null : String(stdout));
+        });
+    }),
+    stat: (p) => {
+        try {
+            const s = fs.lstatSync(p);
+            return { isFile: s.isFile(), size: s.size };
+        }
+        catch {
+            return null;
+        }
+    },
+    readFile: (p) => fs.readFileSync(p),
+    sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
+    now: () => Date.now(),
+    attachment: attachmentWriter_1.realAttachmentDeps,
+};
+/** `~` expansion + absolute check; anything odd falls back to ~/Desktop (macOS's own default). */
+function resolveScreenshotFolder(raw, home) {
+    const fallback = path.join(home, 'Desktop');
+    const v = (raw ?? '').trim();
+    if (!v)
+        return fallback;
+    let expanded = v;
+    if (v === '~')
+        expanded = home;
+    else if (v.startsWith('~/'))
+        expanded = path.join(home, v.slice(2));
+    if (!path.isAbsolute(expanded))
+        return fallback;
+    return path.normalize(expanded);
+}
+/** A plain image basename: no path separators, no traversal, no NUL, image extension. */
+function isSafeScreenshotName(name) {
+    if (typeof name !== 'string' || name.length === 0 || name.length > 255)
+        return false;
+    if (/[\\/\0]/.test(name))
+        return false;
+    if (name === '.' || name === '..' || name.includes('..'))
+        return false;
+    if (name.startsWith('.'))
+        return false;
+    const ext = /\.([A-Za-z0-9]+)$/.exec(name)?.[1]?.toLowerCase();
+    return !!ext && SCREENSHOT_EXTS.has(ext);
+}
+/** The `attach-screenshot` frame → `file-attached` reply. */
+async function handleScreenshotFrame(frame, sessions, deps = exports.realScreenshotDeps) {
+    const head = {
+        t: 'file-attached',
+        rid: frame.rid,
+        ...(typeof frame.sessionId === 'string' ? { sessionId: frame.sessionId } : {}),
+    };
+    const fail = (reason) => ({ ...head, ok: false, reason });
+    if (deps.platform !== 'darwin')
+        return fail('not-supported');
+    const root = (0, attachmentWriter_1.attachmentRootFor)(sessions, frame.sessionId);
+    if (!root)
+        return fail('no-session');
+    if (!isSafeScreenshotName(frame.name))
+        return fail('bad-name');
+    const name = frame.name;
+    try {
+        const folder = resolveScreenshotFolder(await deps.readScreencaptureLocation(), deps.homedir());
+        const file = path.join(folder, name);
+        // Belt and braces: the joined path must sit directly in the folder.
+        if (path.dirname(file) !== folder)
+            return fail('bad-name');
+        const deadline = deps.now() + exports.SCREENSHOT_POLL_MS;
+        let last = 'not-found';
+        for (;;) {
+            const st = deps.stat(file);
+            if (st && st.isFile) {
+                if (st.size > attachmentWriter_1.MAX_ATTACHMENT_BYTES)
+                    return fail('too-large');
+                if (st.size > 0) {
+                    const data = deps.readFile(file);
+                    if (data.length > attachmentWriter_1.MAX_ATTACHMENT_BYTES)
+                        return fail('too-large');
+                    if ((0, attachmentWriter_1.sniffImageExt)(data)) {
+                        const r = (0, attachmentWriter_1.writeAttachment)({ root, name, dataBase64: data.toString('base64') }, deps.attachment);
+                        return r.ok ? { ...head, ok: true, path: r.path, bytes: r.bytes } : fail(r.reason);
+                    }
+                    // Present but not (yet) an image — maybe still being written.
+                    last = 'not-image';
+                }
+            }
+            else if (st && !st.isFile) {
+                // A directory or symlink by that name is never a screenshot.
+                return fail('not-image');
+            }
+            if (deps.now() >= deadline)
+                return fail(last);
+            await deps.sleep(exports.SCREENSHOT_POLL_INTERVAL_MS);
+        }
+    }
+    catch {
+        return fail('error');
+    }
+}

package/dist/bridge/server.d.ts

@@ -9,10 +9,13 @@ import { WriteGitignoreResult } from './writeGitignore';
 import { LocalContextWriteResult } from './localContextWriter';
 import { GitRun } from './changesReporter';
 import { buildChangesReport as buildChangesReportReal } from './changesReport';
+import { ScreenshotDeps } from './screenshotAttach';
 export interface BridgeServerOpts {
     sessionToken: string;
     allowedOrigin: string;
     sessions: SessionManager;
+    /** Screenshot drop (`attach-screenshot`) seams — tests only; defaults to the real macOS/fs. */
+    screenshotDeps?: ScreenshotDeps;
     /** 0 (default) = ephemeral port. */
     port?: number;
     /** Workspace-scoped terminals: resolve a repo URL to a local checkout dir

package/dist/bridge/server.js

@@ -63,6 +63,7 @@ const sessionAnchor_1 = require("./sessionAnchor");
 // the SAME activity records fcct-24's tail already parses below.
 const sessionTouchTracker_1 = require("./sessionTouchTracker");
 const attachmentWriter_1 = require("./attachmentWriter");
+const screenshotAttach_1 = require("./screenshotAttach");
 const PROTOCOL_VERSION = 1;
 function send(ws, frame) {
     if (ws.readyState === ws_1.WebSocket.OPEN)
@@ -392,6 +393,8 @@ function startBridgeServer(opts) {
                     ...(opts.writeLocalFile ? ['local-file-write'] : []),
                     // Terminal attach — this bridge answers `attach-file` frames.
                     'terminal-attach',
+                    // Screenshot drop — answers `attach-screenshot` (macOS only).
+                    ...((opts.screenshotDeps ?? screenshotAttach_1.realScreenshotDeps).platform === 'darwin' ? ['attach-screenshot'] : []),
                 ],
             });
             return;
@@ -938,6 +941,13 @@ function startBridgeServer(opts) {
                         // input. Shared handler with relayClient.ts (both lanes).
                         send(ws, (0, attachmentWriter_1.handleAttachFrame)(frame, opts.sessions));
                         break;
+                    case 'attach-screenshot':
+                        // Local lane ONLY (never relayClient.ts): reads the user's macOS
+                        // screenshot folder by a validated basename, then the same writer.
+                        void (0, screenshotAttach_1.handleScreenshotFrame)(frame, opts.sessions, opts.screenshotDeps ?? screenshotAttach_1.realScreenshotDeps)
+                            .then((reply) => send(ws, reply))
+                            .catch(() => send(ws, { t: 'file-attached', rid: frame.rid, sessionId: frame.sessionId, ok: false, reason: 'error' }));
+                        break;
                     default:
                         send(ws, { t: 'error', message: 'unknown frame type' });
                 }

package/package.json

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