@wenrwa/marketplace-cli 0.8.11 → 0.8.13

package/dist/__tests__/bridge-cleanup-frame.test.d.ts

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

package/dist/__tests__/bridge-cleanup-frame.test.js

@@ -0,0 +1,217 @@
+"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 });
+/**
+ * stc-05 — the relay client reports what Clean up can free (`cleanup-report`,
+ * on connect and on every `inventory-scan`) and runs it on `cleanup-run`,
+ * answering `cleanup-result` and then a fresh report. A box whose bridge was
+ * built without cleanup answers `unsupported` and touches nothing.
+ *
+ * Faked relay (same harness as bridge-reclaim-frame.test.ts), real temp fs.
+ */
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const ws_1 = require("ws");
+const relayClient_1 = require("../bridge/relayClient");
+const sessionManager_1 = require("../bridge/sessionManager");
+class FakePty {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    write() { }
+    resize() { }
+    kill() { }
+    onData() { }
+    onExit() { }
+}
+const makeFactory = () => ({ spawn: (o) => new FakePty(o) });
+function frameQueue(ws) {
+    const frames = [];
+    const waiters = [];
+    ws.on('message', (raw) => {
+        const f = JSON.parse(String(raw));
+        const i = waiters.findIndex((w) => w.t === f.t);
+        if (i >= 0)
+            waiters.splice(i, 1)[0].resolve(f);
+        else
+            frames.push(f);
+    });
+    return {
+        /** The next frame of type `t` (earlier frames of other types are kept). */
+        nextOf: (t) => {
+            const i = frames.findIndex((f) => f.t === t);
+            if (i >= 0)
+                return Promise.resolve(frames.splice(i, 1)[0]);
+            return new Promise((resolve) => waiters.push({ t, resolve }));
+        },
+    };
+}
+function startFakeRelay() {
+    return new Promise((resolve) => {
+        const wss = new ws_1.WebSocketServer({ port: 0, host: '127.0.0.1' });
+        const queue = [];
+        const waiters = [];
+        wss.on('connection', (ws) => { const w = waiters.shift(); if (w)
+            w(ws);
+        else
+            queue.push(ws); });
+        wss.on('listening', () => {
+            const addr = wss.address();
+            const port = typeof addr === 'object' && addr ? addr.port : 0;
+            resolve({ wss, port, nextConnection: () => (queue.length > 0 ? Promise.resolve(queue.shift()) : new Promise((r) => waiters.push(r))) });
+        });
+    });
+}
+function closeRelay(wss) {
+    return new Promise((resolve, reject) => {
+        for (const client of wss.clients)
+            client.terminate();
+        wss.close((err) => (err ? reject(err) : resolve()));
+    });
+}
+let root;
+let repos;
+let cache;
+beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'stc05-frame-'));
+    repos = path.join(root, 'repos');
+    cache = path.join(root, 'home', '.npm', '_cacache');
+    fs.mkdirSync(repos);
+    fs.mkdirSync(cache, { recursive: true });
+    fs.writeFileSync(path.join(cache, 'blob'), Buffer.alloc(64 * 1024, 1));
+});
+afterEach(() => fs.rmSync(root, { recursive: true, force: true }));
+const noGit = async () => ({ stdout: '', code: 1 });
+function start(port, extra = {}) {
+    return (0, relayClient_1.startRelayClient)({
+        relayUrl: `ws://127.0.0.1:${port}`,
+        relayToken: 'tok',
+        sessions: new sessionManager_1.SessionManager(makeFactory()),
+        reposBaseDir: repos,
+        enableStorageCleanup: true,
+        storageCleanupDeps: { cacheDirs: [cache], run: noGit },
+        resolveWorkspaceCwd: async () => null,
+        ...extra,
+    });
+}
+describe('relay client — storage cleanup (stc-05)', () => {
+    it('reports the reclaimable figure on connect, stamped with the cleanup version', async () => {
+        const relay = await startFakeRelay();
+        const handle = start(relay.port);
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        const report = await q.nextOf('cleanup-report');
+        expect(report.cleanupVersion).toBe(1);
+        expect(report.reclaimableBytes).toBeGreaterThanOrEqual(64 * 1024);
+        expect(report.byCategory.caches).toBe(report.reclaimableBytes);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('runs Clean up on `cleanup-run`, answers what it freed, then reports nothing left', async () => {
+        const relay = await startFakeRelay();
+        const handle = start(relay.port);
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        const first = await q.nextOf('cleanup-report');
+        ws.send(JSON.stringify({ t: 'cleanup-run' }));
+        const result = await q.nextOf('cleanup-result');
+        expect(result).toMatchObject({ outcome: 'done', freedBytes: first.reclaimableBytes });
+        expect(fs.existsSync(cache)).toBe(false);
+        const after = await q.nextOf('cleanup-report');
+        expect(after.reclaimableBytes).toBe(0);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('re-reports on `inventory-scan` (the storage view opening)', async () => {
+        const relay = await startFakeRelay();
+        const handle = start(relay.port);
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.nextOf('cleanup-report');
+        fs.writeFileSync(path.join(cache, 'more'), Buffer.alloc(32 * 1024, 2));
+        ws.send(JSON.stringify({ t: 'inventory-scan' }));
+        const again = await q.nextOf('cleanup-report');
+        expect(again.reclaimableBytes).toBeGreaterThanOrEqual(96 * 1024);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('wires attachment to the live sessions: an open session keeps its checkout’s leftovers', async () => {
+        const leftover = path.join(repos, 'ws-1');
+        fs.mkdirSync(path.join(leftover, 'node_modules'), { recursive: true });
+        fs.writeFileSync(path.join(leftover, 'node_modules', 'x.js'), 'x');
+        const relay = await startFakeRelay();
+        const handle = start(relay.port);
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        await q.nextOf('cleanup-report');
+        ws.send(JSON.stringify({ t: 'open', cols: 80, rows: 24, sessionId: 'agent-1', workspaceId: 'ws-1' }));
+        await q.nextOf('opened');
+        ws.send(JSON.stringify({ t: 'cleanup-run' }));
+        await q.nextOf('cleanup-result');
+        expect(fs.existsSync(path.join(leftover, 'node_modules', 'x.js'))).toBe(true);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('a bridge without cleanup answers `unsupported`, sends no report, and deletes nothing', async () => {
+        const relay = await startFakeRelay();
+        const handle = (0, relayClient_1.startRelayClient)({
+            relayUrl: `ws://127.0.0.1:${relay.port}`,
+            relayToken: 'tok',
+            sessions: new sessionManager_1.SessionManager(makeFactory()),
+        });
+        const ws = await relay.nextConnection();
+        const q = frameQueue(ws);
+        ws.send(JSON.stringify({ t: 'cleanup-run' }));
+        const result = await q.nextOf('cleanup-result');
+        expect(result.outcome).toBe('unsupported');
+        expect(fs.existsSync(path.join(cache, 'blob'))).toBe(true);
+        handle.close();
+        await closeRelay(relay.wss);
+    });
+    it('exposes runAutomaticCleanup for growth (stc-06), off unless the kill switch is on', async () => {
+        const relay = await startFakeRelay();
+        const off = start(relay.port);
+        expect(await off.runAutomaticCleanup()).toEqual({ ran: false, reason: 'disabled' });
+        expect(fs.existsSync(path.join(cache, 'blob'))).toBe(true);
+        off.close();
+        const on = start(relay.port, { storageCleanupDeps: { cacheDirs: [cache], run: noGit, autoCleanupEnabled: true } });
+        expect(await on.runAutomaticCleanup()).toMatchObject({ ran: true });
+        expect(fs.existsSync(cache)).toBe(false);
+        on.close();
+        await closeRelay(relay.wss);
+    });
+});

package/dist/__tests__/bridge-clone-grow-quote.test.d.ts

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

package/dist/__tests__/bridge-clone-grow-quote.test.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * stc-04 (docs/prd/storage-billed-in-credits.md) — the clone preflight's
+ * growth QUOTE travels from the backend's 409 to the pane's error frame
+ * unchanged, so the arena can ask "Grow / Cancel". The bridge never calls
+ * the grow route itself: it spends money and is deliberately not on the
+ * connect-token allowlist — the arena's Grow click does it with the user's
+ * session. No quote (old backend, flag off) → the frame is byte-identical
+ * to the old refusal.
+ */
+const storageQuotaFetch_1 = require("../bridge/storageQuotaFetch");
+const repoCheckout_1 = require("../bridge/repoCheckout");
+const diskPreflight_1 = require("../bridge/diskPreflight");
+const storageQuotaPreflight_1 = require("../bridge/storageQuotaPreflight");
+const relayClient_1 = require("../bridge/relayClient");
+const sessionManager_1 = require("../bridge/sessionManager");
+const QUOTE = { addGb: 5, newDiskGb: 15, newCreditsPerDay: 50 };
+const REFUSAL_BODY = {
+    code: 'STORAGE_QUOTA_EXCEEDED',
+    tier: 'payg',
+    capGb: 10,
+    usedGb: 9.2,
+    additionalGb: 3.1,
+    suggestedTier: 'pro',
+    suggestedCapGb: 25,
+    tierName: 'Pay-as-you-go',
+    suggestedTierName: 'Pro',
+};
+function fetch409(error) {
+    return async () => ({ ok: false, status: 409, json: async () => ({ success: false, error }) });
+}
+describe('fetchStorageQuotaFact — the growth quote (stc-04)', () => {
+    const base = { apiUrl: 'https://api.test', connectToken: 'tok', usedGb: 9.2, additionalGb: 3.1 };
+    it('a 409 with a quote resolves a blocked fact carrying the quote unchanged', async () => {
+        const fact = await (0, storageQuotaFetch_1.fetchStorageQuotaFact)({ ...base, fetchImpl: fetch409({ ...REFUSAL_BODY, quote: QUOTE }) });
+        expect(fact?.allowed).toBe(false);
+        expect(fact?.quote).toEqual(QUOTE);
+    });
+    it('a 409 without a quote (old backend, billing off) carries no quote key at all', async () => {
+        const fact = await (0, storageQuotaFetch_1.fetchStorageQuotaFact)({ ...base, fetchImpl: fetch409(REFUSAL_BODY) });
+        expect(fact?.allowed).toBe(false);
+        expect(fact && 'quote' in fact).toBe(false);
+    });
+    it('a malformed quote is dropped, never half-passed', async () => {
+        for (const quote of [{ addGb: 5 }, { addGb: '5', newDiskGb: 15, newCreditsPerDay: 50 }, null, 'x', { addGb: 0, newDiskGb: 15, newCreditsPerDay: 50 }]) {
+            const fact = await (0, storageQuotaFetch_1.fetchStorageQuotaFact)({ ...base, fetchImpl: fetch409({ ...REFUSAL_BODY, quote }) });
+            expect(fact?.allowed).toBe(false);
+            expect(fact && 'quote' in fact).toBe(false);
+        }
+    });
+});
+const OVER = {
+    allowed: false,
+    tier: 'payg',
+    capGb: 10,
+    usedGb: 9.2,
+    additionalGb: 3.1,
+    suggestedTier: 'pro',
+    suggestedCapGb: 25,
+    tierName: 'Pay-as-you-go',
+    suggestedTierName: 'Pro',
+};
+function repoDeps(fact) {
+    const runs = [];
+    return {
+        runs,
+        deps: {
+            reposBaseDir: '/data/repos',
+            exists: () => false,
+            mkdir: () => { },
+            run: async (cmd, args) => { runs.push([cmd, ...args]); return { stdout: '', code: 0 }; },
+            freeMb: () => 999_999,
+            estimateSizeMb: () => 3200,
+            checkStorageQuota: async () => fact,
+        },
+    };
+}
+describe('ensureWorkspaceRepo — a quoted refusal (stc-04)', () => {
+    it('refuses with the quota code and passes the quote through; git never runs', async () => {
+        const { deps, runs } = repoDeps({ ...OVER, quote: QUOTE });
+        const result = await (0, repoCheckout_1.ensureWorkspaceRepo)({ workspaceId: 'ws-q', repoUrl: 'https://github.com/acme/w.git' }, deps);
+        expect(result.action).toBe('refused');
+        expect(result.code).toBe(storageQuotaPreflight_1.CLONE_QUOTA_PREFLIGHT_REFUSED);
+        expect(result.quote).toEqual(QUOTE);
+        expect(runs).toHaveLength(0);
+    });
+    it('no quote → the old refusal exactly, with no quote key', async () => {
+        const { deps } = repoDeps(OVER);
+        const result = await (0, repoCheckout_1.ensureWorkspaceRepo)({ workspaceId: 'ws-q', repoUrl: 'https://github.com/acme/w.git' }, deps);
+        expect(result.action).toBe('refused');
+        expect(result.code).toBe(storageQuotaPreflight_1.CLONE_QUOTA_PREFLIGHT_REFUSED);
+        expect('quote' in result).toBe(false);
+    });
+});
+class FakePty {
+    write() { }
+    resize() { }
+    kill() { }
+    onData() { }
+    onExit() { }
+}
+function fakeSocket() {
+    const handlers = new Map();
+    const sock = {
+        readyState: 1,
+        sent: [],
+        send(raw) { sock.sent.push(JSON.parse(raw)); },
+        close() { handlers.get('close')?.(1006); },
+        terminate() { handlers.get('close')?.(1006); },
+        on(event, cb) { handlers.set(event, cb); },
+        fire(event, ...a) { handlers.get(event)?.(...a); },
+    };
+    return sock;
+}
+async function refusalFrame(err) {
+    const socket = fakeSocket();
+    const spawned = [];
+    const factory = { spawn: () => { spawned.push('pty'); return new FakePty(); } };
+    const handle = (0, relayClient_1.startRelayClient)({
+        relayUrl: 'ws://relay.test',
+        relayToken: 'tok',
+        sessions: new sessionManager_1.SessionManager(factory),
+        wsFactory: () => socket,
+        resolveWorkspaceCwd: async () => { throw err; },
+        setTimeoutFn: () => 0,
+        clearTimeoutFn: () => { },
+    });
+    socket.fire('open');
+    socket.fire('message', JSON.stringify({ t: 'open', cols: 80, rows: 24, workspaceId: 'ws-1', repoUrl: 'https://github.com/acme/w', sessionId: 'agt-1' }));
+    await new Promise((r) => setImmediate(r));
+    handle.close();
+    return { frame: socket.sent.find((f) => f.t === 'error'), spawned };
+}
+describe('relay client — the quote reaches the pane on the error frame (stc-04)', () => {
+    it('a quoted refusal sends the quote unchanged beside code and message', async () => {
+        const { frame, spawned } = await refusalFrame(new diskPreflight_1.ClonePreflightRefusalError('Your plan…', storageQuotaPreflight_1.CLONE_QUOTA_PREFLIGHT_REFUSED, QUOTE));
+        expect(spawned).toHaveLength(0);
+        expect(frame).toEqual({ t: 'error', sessionId: 'agt-1', code: storageQuotaPreflight_1.CLONE_QUOTA_PREFLIGHT_REFUSED, message: 'Your plan…', quote: QUOTE });
+    });
+    it('no quote → the old frame exactly', async () => {
+        const { frame } = await refusalFrame(new diskPreflight_1.ClonePreflightRefusalError('Your plan…', storageQuotaPreflight_1.CLONE_QUOTA_PREFLIGHT_REFUSED));
+        expect(frame).toEqual({ t: 'error', sessionId: 'agt-1', code: storageQuotaPreflight_1.CLONE_QUOTA_PREFLIGHT_REFUSED, message: 'Your plan…' });
+    });
+});

package/dist/__tests__/bridge-disk-pressure-frame.test.d.ts

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

package/dist/__tests__/bridge-disk-pressure-frame.test.js

@@ -0,0 +1,179 @@
+"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 });
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const relayClient_1 = require("../bridge/relayClient");
+const sessionManager_1 = require("../bridge/sessionManager");
+/**
+ * stc-06 — the bridge's half of automatic growth.
+ *
+ * - `disk: { freeGb, totalGb }` rides the periodic `sessions` frame when the
+ *   embedder supplies `readDiskSpace` (the container lane). Its presence is
+ *   the backend's capability flag; a null read (unknown) omits it.
+ * - `cleanup-auto` runs AUTOMATIC cleanup — behind the bridge's own kill
+ *   switch (HIVEOP_AUTO_CLEANUP) — and answers `cleanup-auto-result`.
+ */
+class FakePty {
+    write() { }
+    resize() { }
+    kill() { }
+    onData() { }
+    onExit() { }
+}
+const factory = { spawn: () => new FakePty() };
+function fakeSocket() {
+    const handlers = new Map();
+    const sock = {
+        readyState: 1,
+        sent: [],
+        send(raw) { sock.sent.push(JSON.parse(raw)); },
+        close() { handlers.get('close')?.(1006); },
+        terminate() { handlers.get('close')?.(1006); },
+        on(event, cb) { handlers.set(event, cb); },
+        fire(event, ...a) { handlers.get(event)?.(...a); },
+    };
+    return sock;
+}
+let root;
+let repos;
+let cache;
+beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'stc06-frame-'));
+    repos = path.join(root, 'repos');
+    cache = path.join(root, 'home', '.npm', '_cacache');
+    fs.mkdirSync(repos);
+    fs.mkdirSync(cache, { recursive: true });
+    fs.writeFileSync(path.join(cache, 'blob'), Buffer.alloc(64 * 1024, 1));
+});
+afterEach(() => fs.rmSync(root, { recursive: true, force: true }));
+const noGit = async () => ({ stdout: '', code: 1 });
+function start(extra = {}) {
+    const socket = fakeSocket();
+    const intervals = [];
+    const handle = (0, relayClient_1.startRelayClient)({
+        relayUrl: 'ws://relay.test',
+        relayToken: 'tok',
+        sessions: new sessionManager_1.SessionManager(factory),
+        wsFactory: () => socket,
+        reportSessions: true,
+        setSessionsIntervalFn: (cb) => { intervals.push(cb); return intervals.length; },
+        clearSessionsIntervalFn: () => { },
+        setTimeoutFn: () => 0,
+        clearTimeoutFn: () => { },
+        ...extra,
+    });
+    socket.fire('open');
+    const tick = () => { for (const cb of intervals)
+        cb(); };
+    const ofType = (t) => socket.sent.filter((f) => f.t === t);
+    const receive = (frame) => socket.fire('message', JSON.stringify(frame));
+    return { handle, socket, tick, ofType, receive };
+}
+const until = async (cond) => {
+    for (let i = 0; i < 200 && !cond(); i++)
+        await new Promise((r) => setTimeout(r, 10));
+};
+describe('stc-06 — disk space on the sessions frame', () => {
+    it('carries { freeGb, totalGb } on connect and every tick, rounded to 0.01 GB', () => {
+        let free = 0.4567;
+        const b = start({ readDiskSpace: () => ({ freeGb: free, totalGb: 10.0001 }) });
+        expect(b.ofType('sessions')[0]).toEqual({ t: 'sessions', ids: [], disk: { freeGb: 0.46, totalGb: 10 } });
+        free = 3;
+        b.tick();
+        expect(b.ofType('sessions')[1].disk).toEqual({ freeGb: 3, totalGb: 10 });
+        b.handle.close();
+    });
+    it('an unknown read (null) or a throwing read omits the field — never a guess', () => {
+        const a = start({ readDiskSpace: () => null });
+        expect(a.ofType('sessions')[0]).toEqual({ t: 'sessions', ids: [] });
+        a.handle.close();
+        const b = start({ readDiskSpace: () => { throw new Error('EIO'); } });
+        expect(b.ofType('sessions')[0]).toEqual({ t: 'sessions', ids: [] });
+        b.handle.close();
+    });
+    it('without readDiskSpace (the laptop lane, old embedders) the frame is unchanged', () => {
+        const b = start();
+        expect(b.ofType('sessions')[0]).toEqual({ t: 'sessions', ids: [] });
+        b.handle.close();
+    });
+});
+describe('stc-06 — cleanup-auto', () => {
+    it('kill switch off → answers ran:false and deletes nothing', async () => {
+        const b = start({ reposBaseDir: repos, enableStorageCleanup: true, storageCleanupDeps: { cacheDirs: [cache], run: noGit } });
+        b.receive({ t: 'cleanup-auto' });
+        await until(() => b.ofType('cleanup-auto-result').length > 0);
+        expect(b.ofType('cleanup-auto-result')).toEqual([{ t: 'cleanup-auto-result', ran: false, reason: 'disabled' }]);
+        expect(fs.existsSync(path.join(cache, 'blob'))).toBe(true);
+        b.handle.close();
+    });
+    it('kill switch on → runs automatic cleanup and answers what it freed', async () => {
+        const b = start({
+            reposBaseDir: repos,
+            enableStorageCleanup: true,
+            storageCleanupDeps: { cacheDirs: [cache], run: noGit, autoCleanupEnabled: true },
+        });
+        b.receive({ t: 'cleanup-auto' });
+        await until(() => b.ofType('cleanup-auto-result').length > 0);
+        const [r] = b.ofType('cleanup-auto-result');
+        expect(r).toMatchObject({ t: 'cleanup-auto-result', ran: true });
+        expect(r.freedBytes).toBeGreaterThanOrEqual(64 * 1024);
+        expect(fs.existsSync(cache)).toBe(false);
+        b.handle.close();
+    });
+    it('a bridge without cleanup answers ran:false', async () => {
+        const b = start();
+        b.receive({ t: 'cleanup-auto' });
+        await until(() => b.ofType('cleanup-auto-result').length > 0);
+        expect(b.ofType('cleanup-auto-result')).toEqual([{ t: 'cleanup-auto-result', ran: false, reason: 'disabled' }]);
+        b.handle.close();
+    });
+});
+describe('stc-06 — readVolumeSpaceGb (the real statfs read)', () => {
+    it('reads a real volume: total > 0 and 0 ≤ free ≤ total', () => {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const { readVolumeSpaceGb } = require('../commands/bridge');
+        const r = readVolumeSpaceGb(os.tmpdir());
+        expect(r).not.toBeNull();
+        expect(r.totalGb).toBeGreaterThan(0);
+        expect(r.freeGb).toBeGreaterThanOrEqual(0);
+        expect(r.freeGb).toBeLessThanOrEqual(r.totalGb);
+    });
+    it('a missing path is unknown (null), never zero', () => {
+        const { readVolumeSpaceGb } = require('../commands/bridge');
+        expect(readVolumeSpaceGb(path.join(os.tmpdir(), 'no-such-dir-stc06', 'x'))).toBeNull();
+    });
+});

package/dist/__tests__/bridge-preview-checkout.test.js

@@ -201,6 +201,15 @@ describe('PreviewRunner (tp-05) — real git, real processes', () => {
         expect(fs.existsSync(path.join(fx.workingCopy, 'scratch.txt'))).toBe(true);
         expect(git(fx.workingCopy, 'rev-parse', 'HEAD').trim()).not.toBe(v2);
     });
+    it('stc-05 — activity() says what storage cleanup must not touch: in flight while starting, the serving workspace after, nothing once stopped', async () => {
+        expect(runner.activity()).toEqual({ opInFlight: false, activeWorkspaces: [] });
+        const starting = runner.start({ workspaceId: 'ws-1', repoUrl: fx.remote });
+        expect(runner.activity().opInFlight).toBe(true);
+        await starting;
+        expect(runner.activity()).toEqual({ opInFlight: false, activeWorkspaces: ['ws-1'] });
+        await runner.stop({ workspaceId: 'ws-1' });
+        expect(runner.activity()).toEqual({ opInFlight: false, activeWorkspaces: [] });
+    });
     it('a broken build keeps the old sha serving and reports build_failed', async () => {
         const first = await runner.start({ workspaceId: 'ws-1', repoUrl: fx.remote });
         const v1 = first.runningSha;

package/dist/__tests__/bridge-storage-cleanup-real-fs.test.d.ts

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