@wenrwa/marketplace-cli 0.7.0 → 0.7.1

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

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

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

@@ -0,0 +1,194 @@
+"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 });
+/**
+ * Terminal attach — `attach-file` saves an image next to the session's agent
+ * and answers `file-attached` with its absolute path. Both lanes: the local
+ * loopback server and the relay client (hosted container) share one handler,
+ * and both are exercised here end to end against a REAL temp folder so the
+ * bytes on disk are compared with the bytes sent.
+ */
+const ws_1 = __importStar(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");
+class FakePty {
+    written = [];
+    write(d) { this.written.push(d); }
+    resize() { }
+    kill() { }
+    onData() { }
+    onExit() { }
+}
+// A real (tiny) PNG: signature + IHDR + IDAT + IEND for a 1x1 pixel, plus
+// every byte value so a lossy encoding would be caught.
+const PNG_1PX = Buffer.from('89504e470d0a1a0a0000000d49484452000000010000000108060000001f15c4890000000d4944415478da63f8cfc0f01f0005000201a5f3b4d60000000049454e44ae426082', 'hex');
+const PNG = Buffer.concat([PNG_1PX, Buffer.from(Array.from({ length: 256 }, (_, i) => i))]);
+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))) };
+}
+let tmp;
+beforeEach(() => { tmp = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'attach-'))); });
+afterEach(() => { fs.rmSync(tmp, { recursive: true, force: true }); });
+describe('attachmentWriter — pure rules', () => {
+    it('sniffs the type from magic bytes, never the name', () => {
+        expect((0, attachmentWriter_1.sniffImageExt)(PNG)).toBe('png');
+        expect((0, attachmentWriter_1.sniffImageExt)(Buffer.from([0xff, 0xd8, 0xff, 0xe0, 0, 0]))).toBe('jpg');
+        expect((0, attachmentWriter_1.sniffImageExt)(Buffer.from('GIF89a......'))).toBe('gif');
+        expect((0, attachmentWriter_1.sniffImageExt)(Buffer.concat([Buffer.from('RIFF'), Buffer.alloc(4), Buffer.from('WEBPVP8 ')]))).toBe('webp');
+        expect((0, attachmentWriter_1.sniffImageExt)(Buffer.from('<svg xmlns="http://www.w3.org/2000/svg"/>'))).toBeNull();
+        expect((0, attachmentWriter_1.sniffImageExt)(Buffer.from('%PDF-1.7'))).toBeNull();
+    });
+    it('makes a stem that needs no escaping and cannot traverse', () => {
+        expect((0, attachmentWriter_1.safeAttachmentStem)('Screenshot 2026-10-04 at 9.41.12 AM.png')).toBe('Screenshot-2026-10-04-at-9.41.12-AM');
+        expect((0, attachmentWriter_1.safeAttachmentStem)('../../etc/passwd')).toBe('passwd');
+        expect((0, attachmentWriter_1.safeAttachmentStem)('..\\..\\x.png')).toBe('x');
+        expect((0, attachmentWriter_1.safeAttachmentStem)('.hidden.png')).toBe('hidden');
+        expect((0, attachmentWriter_1.safeAttachmentStem)('日本語.png')).toBe('image');
+        expect((0, attachmentWriter_1.safeAttachmentStem)('')).toBe('image');
+        expect((0, attachmentWriter_1.safeAttachmentStem)('a'.repeat(90) + '.png')).toHaveLength(40);
+    });
+    it('writes byte-identical bytes under .hiveop/attachments with a self-ignoring .gitignore', () => {
+        const r = (0, attachmentWriter_1.writeAttachment)({ root: tmp, name: 'shot one.png', dataBase64: PNG.toString('base64') });
+        expect(r.ok).toBe(true);
+        if (!r.ok)
+            return;
+        expect(path.dirname(r.path)).toBe(path.join(tmp, attachmentWriter_1.ATTACHMENTS_DIR));
+        expect(path.basename(r.path)).toMatch(/^\d{8}-\d{6}-[0-9a-f]{4}-shot-one\.png$/);
+        expect(fs.readFileSync(r.path).equals(PNG)).toBe(true);
+        expect(fs.readFileSync(path.join(tmp, attachmentWriter_1.ATTACHMENTS_DIR, '.gitignore'), 'utf8')).toBe('*\n');
+        // No temp files left behind.
+        expect(fs.readdirSync(path.join(tmp, attachmentWriter_1.ATTACHMENTS_DIR)).filter((f) => f.endsWith('.tmp'))).toEqual([]);
+    });
+    it('names the extension from the bytes even when the name lies', () => {
+        const r = (0, attachmentWriter_1.writeAttachment)({ root: tmp, name: 'photo.jpg', dataBase64: PNG.toString('base64') });
+        expect(r.ok && r.path.endsWith('-photo.png')).toBe(true);
+    });
+    it('refuses non-images and oversize files without writing anything', () => {
+        expect((0, attachmentWriter_1.writeAttachment)({ root: tmp, name: 'x.png', dataBase64: Buffer.from('not an image').toString('base64') }))
+            .toEqual({ ok: false, reason: 'not-image' });
+        const big = Buffer.concat([PNG_1PX, Buffer.alloc(attachmentWriter_1.MAX_ATTACHMENT_BYTES)]);
+        expect((0, attachmentWriter_1.writeAttachment)({ root: tmp, name: 'x.png', dataBase64: big.toString('base64') }))
+            .toEqual({ ok: false, reason: 'too-large' });
+        expect(fs.existsSync(path.join(tmp, '.hiveop'))).toBe(false);
+    });
+    it('refuses to follow a planted .hiveop symlink out of the project', () => {
+        const outside = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'outside-')));
+        try {
+            fs.mkdirSync(path.join(outside, 'attachments'));
+            fs.symlinkSync(outside, path.join(tmp, '.hiveop'));
+            expect((0, attachmentWriter_1.writeAttachment)({ root: tmp, name: 'x.png', dataBase64: PNG.toString('base64') }))
+                .toEqual({ ok: false, reason: 'error' });
+            expect(fs.readdirSync(path.join(outside, 'attachments'))).toEqual([]);
+        }
+        finally {
+            fs.rmSync(outside, { recursive: true, force: true });
+        }
+    });
+    it('refuses an unknown session (the session decides the folder, not the frame)', () => {
+        const sessions = { list: () => ['a'], cwdOf: () => tmp };
+        expect((0, attachmentWriter_1.handleAttachFrame)({ rid: 'r', sessionId: 'b', data: PNG.toString('base64') }, sessions))
+            .toEqual({ t: 'file-attached', rid: 'r', sessionId: 'b', ok: false, reason: 'no-session' });
+    });
+});
+describe('local bridge server — attach-file frame', () => {
+    let handle;
+    let sessions;
+    let ptys;
+    beforeEach(async () => {
+        ptys = [];
+        const factory = { spawn: () => { const p = new FakePty(); ptys.push(p); return p; } };
+        sessions = new sessionManager_1.SessionManager(factory);
+        handle = await (0, server_1.startBridgeServer)({ sessionToken: 'tok', allowedOrigin: 'https://app.hiveop.io', sessions });
+    });
+    afterEach(async () => { await handle.close(); });
+    it('writes next to the session and replies with the absolute path; nothing reaches the PTY', async () => {
+        const sessionId = sessions.open({ cols: 80, rows: 24, cwd: tmp, id: 'agent-1' });
+        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-file', rid: 'r1', sessionId, name: 'Screen Shot.png', data: PNG.toString('base64') }));
+        const reply = await q.next();
+        expect(reply).toMatchObject({ t: 'file-attached', rid: 'r1', sessionId, ok: true, bytes: PNG.length });
+        expect(reply.path.startsWith(path.join(tmp, attachmentWriter_1.ATTACHMENTS_DIR) + path.sep)).toBe(true);
+        expect(fs.readFileSync(reply.path).equals(PNG)).toBe(true);
+        expect(ptys[0].written).toEqual([]);
+        ws.close();
+    });
+    it('advertises the terminal-attach capability in /discovery', async () => {
+        const res = await fetch(`http://127.0.0.1:${handle.port}/discovery`, { headers: { origin: 'https://app.hiveop.io' } });
+        const body = await res.json();
+        expect(body.capabilities).toContain('terminal-attach');
+    });
+});
+describe('relay client (hosted container) — attach-file frame', () => {
+    it('writes next to the relay session and echoes rid + sessionId for demux', async () => {
+        const wss = new ws_1.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 sessions = new sessionManager_1.SessionManager({ spawn: () => new FakePty() });
+        sessions.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 });
+        const ws = await conn;
+        const q = frameQueue(ws);
+        await q.next(); // auth
+        ws.send(JSON.stringify({ t: 'attach-file', rid: 'h1', sessionId: 'agent-H', name: 'x.png', data: PNG.toString('base64') }));
+        const reply = await q.next();
+        expect(reply).toMatchObject({ t: 'file-attached', rid: 'h1', sessionId: 'agent-H', ok: true });
+        expect(fs.readFileSync(reply.path).equals(PNG)).toBe(true);
+        ws.send(JSON.stringify({ t: 'attach-file', rid: 'h2', sessionId: 'agent-H', name: 'x.txt', data: Buffer.from('hello').toString('base64') }));
+        expect(await q.next()).toMatchObject({ t: 'file-attached', rid: 'h2', ok: false, reason: 'not-image' });
+        client.close();
+        for (const c of wss.clients)
+            c.terminate();
+        await new Promise((r) => wss.close(r));
+    });
+});

package/dist/bridge/attachmentWriter.d.ts

@@ -0,0 +1,54 @@
+export declare const ATTACHMENTS_DIR: string;
+export declare const MAX_ATTACHMENT_BYTES: number;
+export type ImageExt = 'png' | 'jpg' | 'gif' | 'webp';
+export type AttachmentReason = 'not-image' | 'too-large' | 'no-session' | 'error';
+export type AttachmentResult = {
+    ok: true;
+    path: string;
+    bytes: number;
+} | {
+    ok: false;
+    reason: AttachmentReason;
+};
+/** The image type, read from the bytes themselves — never from the name. */
+export declare function sniffImageExt(buf: Buffer): ImageExt | null;
+/**
+ * A filename stem that is safe on every filesystem AND needs no shell
+ * escaping in a prompt: letters, digits, dot, dash, underscore only; no
+ * leading dot; at most 40 chars; never empty.
+ */
+export declare function safeAttachmentStem(name: string): string;
+export interface AttachmentDeps {
+    mkdirp: (dir: string) => void;
+    exists: (p: string) => boolean;
+    realpath: (p: string) => string;
+    /** Real impl: temp file + rename, so Claude never reads half an image. */
+    writeFileAtomic: (p: string, data: Buffer) => void;
+    now: () => Date;
+    random: () => string;
+}
+export declare const realAttachmentDeps: AttachmentDeps;
+/** Write one image under `<root>/.hiveop/attachments/` and return its absolute path. */
+export declare function writeAttachment(input: {
+    root: string;
+    name: string;
+    dataBase64: string;
+}, deps?: AttachmentDeps): AttachmentResult;
+/** Where a session's attachments go: its project folder, else the bridge user's home. */
+export declare function attachmentRootFor(sessions: {
+    list(): string[];
+    cwdOf(id: string): string | undefined;
+}, sessionId: unknown): string | null;
+/**
+ * The whole `attach-file` frame → `file-attached` reply, shared verbatim by
+ * the local server and the relay client so the two lanes cannot drift.
+ */
+export declare function handleAttachFrame(frame: {
+    rid?: unknown;
+    sessionId?: unknown;
+    name?: unknown;
+    data?: unknown;
+}, sessions: {
+    list(): string[];
+    cwdOf(id: string): string | undefined;
+}, deps?: AttachmentDeps): Record<string, unknown>;

package/dist/bridge/attachmentWriter.js

@@ -0,0 +1,172 @@
+"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.realAttachmentDeps = exports.MAX_ATTACHMENT_BYTES = exports.ATTACHMENTS_DIR = void 0;
+exports.sniffImageExt = sniffImageExt;
+exports.safeAttachmentStem = safeAttachmentStem;
+exports.writeAttachment = writeAttachment;
+exports.attachmentRootFor = attachmentRootFor;
+exports.handleAttachFrame = handleAttachFrame;
+/**
+ * Terminal attach — save a screenshot NEXT TO the agent that will read it.
+ *
+ * Claude Code attaches an image when that image's file path lands in its
+ * prompt. So the browser ships the image bytes over the pane's own socket
+ * (`attach-file` frame — the local bridge's loopback WS, or the relay into the
+ * hosted container; same frame, same handler, both lanes) and this module
+ * writes them into the SESSION's project folder:
+ *
+ *     <session cwd>/.hiveop/attachments/<stamp>-<rand>-<safe-name>.<ext>
+ *
+ * Why there:
+ *   - `.hiveop/` is already the bridge-owned dir inside a checkout
+ *     (`.hiveop/context.md`), excluded from the tree scanner/watcher and from
+ *     the checkout inventory's "unsaved work" count — no new convention.
+ *   - It is inside Claude's cwd, so a follow-up Read of the file needs no
+ *     out-of-project permission prompt on either lane.
+ *   - The attachments dir carries its OWN `.gitignore` (`*`), so an agent's
+ *     `git add -A` never commits screenshots — without editing the user's
+ *     .gitignore.
+ *
+ * The browser's name and type are hints only: the extension comes from the
+ * file's magic bytes, and anything that is not png/jpeg/gif/webp is refused.
+ * The session — never the frame — decides the folder, so a pane can only
+ * write next to a session it may already address.
+ */
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+exports.ATTACHMENTS_DIR = path.join('.hiveop', 'attachments');
+exports.MAX_ATTACHMENT_BYTES = 10 * 1024 * 1024;
+/** The image type, read from the bytes themselves — never from the name. */
+function sniffImageExt(buf) {
+    if (buf.length >= 8 && buf.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])))
+        return 'png';
+    if (buf.length >= 3 && buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff)
+        return 'jpg';
+    if (buf.length >= 6 && (buf.subarray(0, 6).toString('latin1') === 'GIF87a' || buf.subarray(0, 6).toString('latin1') === 'GIF89a'))
+        return 'gif';
+    if (buf.length >= 12 && buf.subarray(0, 4).toString('latin1') === 'RIFF' && buf.subarray(8, 12).toString('latin1') === 'WEBP')
+        return 'webp';
+    return null;
+}
+/**
+ * A filename stem that is safe on every filesystem AND needs no shell
+ * escaping in a prompt: letters, digits, dot, dash, underscore only; no
+ * leading dot; at most 40 chars; never empty.
+ */
+function safeAttachmentStem(name) {
+    const base = String(name ?? '').split(/[\\/]/).pop() ?? '';
+    const stem = base.replace(/\.[A-Za-z0-9]{1,5}$/, '');
+    const cleaned = stem
+        .replace(/[^A-Za-z0-9._-]+/g, '-')
+        .replace(/-{2,}/g, '-')
+        .replace(/^[-.]+|[-.]+$/g, '')
+        .slice(0, 40)
+        .replace(/[-.]+$/g, '');
+    return cleaned || 'image';
+}
+function stamp(now) {
+    const p = (n) => String(n).padStart(2, '0');
+    return `${now.getFullYear()}${p(now.getMonth() + 1)}${p(now.getDate())}-${p(now.getHours())}${p(now.getMinutes())}${p(now.getSeconds())}`;
+}
+exports.realAttachmentDeps = {
+    mkdirp: (dir) => fs.mkdirSync(dir, { recursive: true }),
+    exists: (p) => fs.existsSync(p),
+    realpath: (p) => fs.realpathSync(p),
+    writeFileAtomic: (p, data) => {
+        const tmp = `${p}.${process.pid}.${crypto.randomBytes(4).toString('hex')}.tmp`;
+        fs.writeFileSync(tmp, data);
+        fs.renameSync(tmp, p);
+    },
+    now: () => new Date(),
+    random: () => crypto.randomBytes(2).toString('hex'),
+};
+/** Write one image under `<root>/.hiveop/attachments/` and return its absolute path. */
+function writeAttachment(input, deps = exports.realAttachmentDeps) {
+    const b64 = typeof input.dataBase64 === 'string' ? input.dataBase64 : '';
+    // Checked on the ENCODED length first, so an oversized frame is refused
+    // without allocating its decoded buffer.
+    if (b64.length > Math.ceil(exports.MAX_ATTACHMENT_BYTES / 3) * 4 + 4)
+        return { ok: false, reason: 'too-large' };
+    const data = Buffer.from(b64, 'base64');
+    if (data.length > exports.MAX_ATTACHMENT_BYTES)
+        return { ok: false, reason: 'too-large' };
+    const ext = sniffImageExt(data);
+    if (!ext)
+        return { ok: false, reason: 'not-image' };
+    try {
+        const root = deps.realpath(input.root);
+        const dir = path.join(root, exports.ATTACHMENTS_DIR);
+        deps.mkdirp(dir);
+        // A checkout's `.hiveop` could be a symlink planted by the repo — refuse
+        // to follow it anywhere outside the project.
+        const realDir = deps.realpath(dir);
+        if (realDir !== dir && !realDir.startsWith(root + path.sep))
+            return { ok: false, reason: 'error' };
+        const ignore = path.join(realDir, '.gitignore');
+        if (!deps.exists(ignore))
+            deps.writeFileAtomic(ignore, Buffer.from('*\n'));
+        const file = path.join(realDir, `${stamp(deps.now())}-${deps.random()}-${safeAttachmentStem(input.name)}.${ext}`);
+        deps.writeFileAtomic(file, data);
+        return { ok: true, path: file, bytes: data.length };
+    }
+    catch {
+        return { ok: false, reason: 'error' };
+    }
+}
+/** Where a session's attachments go: its project folder, else the bridge user's home. */
+function attachmentRootFor(sessions, sessionId) {
+    if (typeof sessionId !== 'string' || !sessions.list().includes(sessionId))
+        return null;
+    return sessions.cwdOf(sessionId) ?? os.homedir();
+}
+/**
+ * The whole `attach-file` frame → `file-attached` reply, shared verbatim by
+ * the local server and the relay client so the two lanes cannot drift.
+ */
+function handleAttachFrame(frame, sessions, deps = exports.realAttachmentDeps) {
+    const head = {
+        t: 'file-attached',
+        rid: frame.rid,
+        ...(typeof frame.sessionId === 'string' ? { sessionId: frame.sessionId } : {}),
+    };
+    const root = attachmentRootFor(sessions, frame.sessionId);
+    if (!root)
+        return { ...head, ok: false, reason: 'no-session' };
+    const result = writeAttachment({ root, name: typeof frame.name === 'string' ? frame.name : 'image', dataBase64: typeof frame.data === 'string' ? frame.data : '' }, deps);
+    return result.ok ? { ...head, ok: true, path: result.path, bytes: result.bytes } : { ...head, ok: false, reason: result.reason };
+}

package/dist/bridge/relayClient.js

@@ -110,6 +110,7 @@ const diskPreflight_1 = require("./diskPreflight");
 // hcs-05's checkoutReclaim executor for the actual delete. See
 // checkoutParkAndRemove.ts's doc comment for the full safety design.
 const checkoutParkAndRemove_1 = require("./checkoutParkAndRemove");
+const attachmentWriter_1 = require("./attachmentWriter");
 const PROTOCOL_VERSION = 1;
 /**
  * fcct-27 — typed refusal when `resolveLaunch` names a binary this machine does
@@ -133,6 +134,8 @@ exports.SESSION_NOT_RELAY_OWNED = 'SESSION_NOT_RELAY_OWNED';
 exports.SESSION_ADDRESSED_FRAMES = new Set([
     'attach', 'input', 'peek', 'resize', 'detach', 'close', 'read-handoff',
     'browser-input', 'browser-frame-ack', 'browser-resize', 'browser-sleep',
+    // Terminal attach writes next to a session — same consent boundary.
+    'attach-file',
 ]);
 /**
  * pucc-14 — assemble the per-session PTY env for a workspace-scoped `open`.
@@ -1501,6 +1504,10 @@ function startRelayClient(opts) {
                         });
                         break;
                     }
+                    case 'attach-file':
+                        // Terminal attach — shared verbatim with the local server.
+                        send(socket, (0, attachmentWriter_1.handleAttachFrame)(frame, opts.sessions));
+                        break;
                     case 'read-transcript': {
                         // wte-10 (docs/prd/work-this-epic.md D8): read ONE Claude Code
                         // agent's session transcript, live. Server-initiated (no pane,

package/dist/bridge/server.js

@@ -62,6 +62,7 @@ const sessionAnchor_1 = require("./sessionAnchor");
 // tchp-30 — per-session own-touch tracker (see its doc comment). Fed from
 // the SAME activity records fcct-24's tail already parses below.
 const sessionTouchTracker_1 = require("./sessionTouchTracker");
+const attachmentWriter_1 = require("./attachmentWriter");
 const PROTOCOL_VERSION = 1;
 function send(ws, frame) {
     if (ws.readyState === ws_1.WebSocket.OPEN)
@@ -389,6 +390,8 @@ function startBridgeServer(opts) {
                 // of failing at save time.
                 capabilities: [
                     ...(opts.writeLocalFile ? ['local-file-write'] : []),
+                    // Terminal attach — this bridge answers `attach-file` frames.
+                    'terminal-attach',
                 ],
             });
             return;
@@ -930,6 +933,11 @@ function startBridgeServer(opts) {
                         });
                         break;
                     }
+                    case 'attach-file':
+                        // Terminal attach — a FILE write next to the session, never PTY
+                        // input. Shared handler with relayClient.ts (both lanes).
+                        send(ws, (0, attachmentWriter_1.handleAttachFrame)(frame, opts.sessions));
+                        break;
                     default:
                         send(ws, { t: 'error', message: 'unknown frame type' });
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wenrwa/marketplace-cli",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "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",