@shardflux/cli 0.13.6 → 0.14.1

package/dist/device-bridge.js

@@ -0,0 +1,409 @@
+import { createHash } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, rmSync, statSync } from 'node:fs';
+import { readFile, writeFile, mkdir, realpath, stat } from 'node:fs/promises';
+import { createConnection, createServer } from 'node:net';
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { WorkspaceTunnels } from '@shardflux/sdk';
+import { writePrivateFile } from "./credentials.js";
+import { conversationName, conversationWorkspace, getConversation, localConversations } from "./conversations.js";
+import { gitRunner } from "./agent-git.js";
+import { shardRemote } from "./git-remote.js";
+import { writeSyncBlob } from "./project-sync-transfer.js";
+import { UsageError } from "./errors.js";
+import { conversationClient } from "./conversation-commands.js";
+import { withTargetLock } from "./target-lock.js";
+import { checkConversationWorktree, rememberConversationWorktree } from "./conversation-worktree.js";
+const LIMIT = 256 << 20, OUTPUT = (192 << 10) - 128;
+const inside = (root, target) => target === root || target.startsWith(root + sep);
+const safeId = (value) => { if (!/^[a-zA-Z0-9_-]{1,96}$/.test(value))
+    throw new Error('Invalid device request identity'); return value; };
+function canonicalDevicePath(target) {
+    let ancestor = target;
+    while (!existsSync(ancestor)) {
+        const parent = dirname(ancestor);
+        if (parent === ancestor)
+            throw new UsageError('Device path is unavailable.');
+        ancestor = parent;
+    }
+    return resolve(realpathSync(ancestor), relative(ancestor, target));
+}
+/** Resolve existing ancestors even before the conversation worktree is created. */
+export function devicePath(root, requested = '.') {
+    if (/[\0\r\n]/.test(requested))
+        throw new UsageError('Device path contains invalid characters.');
+    const base = canonicalDevicePath(resolve(root)), target = isAbsolute(requested) ? resolve(requested) : resolve(base, requested);
+    const canonical = canonicalDevicePath(target);
+    return { path: canonical, outside: !inside(base, canonical) };
+}
+export class DeviceGrants {
+    file;
+    constructor(dir) { this.file = join(dir, 'device-grants.json'); }
+    key(api, project) { return JSON.stringify([api, project]); }
+    read() {
+        try {
+            if (lstatSync(this.file).isSymbolicLink() || (statSync(this.file).mode & 0o077))
+                throw new UsageError('Device grants must be a private file.');
+            const value = JSON.parse(readFileSync(this.file, 'utf8'));
+            if (!value || typeof value !== 'object' || Array.isArray(value))
+                throw new UsageError('Device grants must be an object.');
+            return value;
+        }
+        catch (e) {
+            if (e.code === 'ENOENT')
+                return {};
+            throw e;
+        }
+    }
+    allows(api, project, root, kind, outside) {
+        const grant = this.read()[this.key(api, project)];
+        return !outside && grant?.root === realpathSync(root) && Array.isArray(grant.kinds) && grant.kinds.includes(kind);
+    }
+    async save(api, project, root, kind) {
+        await withTargetLock(join(dirname(this.file), 'device-grants-lock'), () => {
+            const all = this.read(), key = this.key(api, project), canonical = realpathSync(root);
+            all[key] = { root: canonical, kinds: [...new Set([...(all[key]?.root === canonical ? all[key].kinds : []), kind])] };
+            writePrivateFile(dirname(this.file), this.file, JSON.stringify(all) + '\n');
+        });
+    }
+}
+export function deviceSummary(r) {
+    if (tryLocallyAction(r))
+        return tryLocallyAction(r) === 'stop' ? 'Stop this conversation’s local sync and ports.' : 'Try this conversation in an isolated local worktree with two-way sync and localhost ports.';
+    if (r.kind === 'exec')
+        return `Run on your Mac: ${JSON.stringify(r.exec?.argv)} · directory ${r.exec?.cwd_relative ?? '.'}`;
+    if (r.files)
+        return `${r.kind === 'files_pull' ? 'Send to VM' : 'Save on your Mac'}: ${r.files.local_path_relative} ↔ ${r.files.remote_path}`;
+    return `${r.kind === 'port_forward' ? 'Open VM port on your Mac' : 'Reach your Mac from VM'}: ${r.port?.remote_port} ↔ localhost:${r.port?.local_port}`;
+}
+export function tryLocallyAction(r) {
+    if (r.kind === 'try_locally')
+        return 'start';
+    const argv = r.exec?.argv;
+    if (r.kind !== 'exec' || !argv || argv[0] !== 'shard' || argv[1] !== 'conversations' || argv[2] !== 'try' || argv[3] !== r.conversation_id)
+        return null;
+    if (argv.length === 4)
+        return 'start';
+    return argv.length === 5 && argv[4] === '--stop' ? 'stop' : null;
+}
+export async function ensureConversationWorktree(ctx, c, folder, ws) {
+    return withTargetLock(join(ctx.store.dir, 'conversation-worktree-lock'), async () => {
+        const run = gitRunner(folder, { ...process.env, ...ctx.io.env, SHARDFLUX_CONFIG_DIR: ctx.store.dir, SHARDFLUX_API_URL: ctx.apiUrl }, ctx.signal);
+        const name = conversationName(c), worktree = join(folder, '.shard', 'worktrees', name);
+        if (existsSync(worktree))
+            checkConversationWorktree(ctx, c, folder, worktree);
+        const source = ws ?? await conversationWorkspace(ctx, c);
+        await run(['-c', 'core.hooksPath=/dev/null', 'fetch', '--no-tags', shardRemote(source.key, '/shardflux/project/git/hub.git'), `+refs/heads/${c.branch}:refs/remotes/shardflux/${name}`]);
+        if (!existsSync(worktree)) {
+            await mkdir(dirname(worktree), { recursive: true });
+            await run(['-c', 'core.hooksPath=/dev/null', 'worktree', 'add', '-b', c.branch, worktree, `refs/remotes/shardflux/${name}`]);
+            rememberConversationWorktree(ctx, c, folder, worktree);
+        }
+        else {
+            checkConversationWorktree(ctx, c, folder, worktree);
+            const work = gitRunner(worktree, { ...process.env, ...ctx.io.env }, ctx.signal);
+            if (await work(['symbolic-ref', '--short', 'HEAD']) !== c.branch || await work(['rev-parse', '--show-toplevel']) !== realpathSync(worktree))
+                throw new UsageError('Local conversation worktree belongs to other work.');
+        }
+        return realpathSync(worktree);
+    }, ctx.signal);
+}
+export async function deviceExec(argv, cwd, timeoutSeconds = 300, signal) {
+    if (!Array.isArray(argv) || argv.length < 1 || argv.length > 128 || argv.some(a => typeof a !== 'string' || a.includes('\0') || a.length > 65536) || !argv[0])
+        throw new UsageError('Device exec requires an argument array.');
+    if (!Number.isInteger(timeoutSeconds) || timeoutSeconds < 1 || timeoutSeconds > 3600)
+        throw new UsageError('Device timeout must be 1–3600 seconds.');
+    return new Promise((resolveResult, reject) => {
+        const child = spawn(argv[0], argv.slice(1), { cwd, stdio: ['ignore', 'pipe', 'pipe'], detached: process.platform !== 'win32', env: process.env });
+        const stdout = [], stderr = [];
+        let failure;
+        const stop = () => { try {
+            if (child.pid && process.platform !== 'win32')
+                process.kill(-child.pid, 'SIGKILL');
+            else
+                child.kill('SIGKILL');
+        }
+        catch { /* exited */ } };
+        const timeout = setTimeout(() => { failure = new Error('Device command timed out.'); stop(); }, timeoutSeconds * 1000);
+        const abort = () => { failure = new Error('Device command interrupted.'); stop(); };
+        signal?.addEventListener('abort', abort, { once: true });
+        const collect = (target) => { let bytes = 0; return (data) => { bytes += data.length; if (bytes > OUTPUT) {
+            failure = new Error('Device output exceeds 192 KiB per stream.');
+            stop();
+        }
+        else
+            target.push(data); }; };
+        child.stdout.on('data', collect(stdout));
+        child.stderr.on('data', collect(stderr));
+        child.once('error', error => { clearTimeout(timeout); signal?.removeEventListener('abort', abort); reject(error); });
+        child.once('close', code => {
+            clearTimeout(timeout);
+            signal?.removeEventListener('abort', abort);
+            resolveResult({ state: failure ? 'failed' : 'done', exit_code: code ?? 1, stdout_b64: Buffer.concat(stdout).toString('base64'), stderr_b64: Buffer.concat([...stderr, ...(failure ? [Buffer.from(failure.message)] : [])]).toString('base64') });
+        });
+        if (signal?.aborted)
+            abort();
+    });
+}
+export class DeviceExecutor {
+    #ctx;
+    #ask;
+    #deviceId;
+    #handles = new Map();
+    constructor(ctx, ask, deviceId) { this.#ctx = ctx; this.#ask = ask; this.#deviceId = deviceId; }
+    async result(r, result) {
+        await conversationClient(this.#ctx).deviceRequests.result(safeId(r.id), result, { idempotencyKey: `${this.#deviceId}:${r.id}:${result.state}`, signal: this.#ctx.signal });
+    }
+    async execute(r) {
+        const ctx = this.#ctx;
+        safeId(r.id);
+        if (r.state !== 'pending' || r.device_id !== this.#deviceId)
+            return;
+        const records = localConversations(ctx);
+        const matching = Object.values(records).filter(record => record.project_id === r.project_id);
+        const folders = new Set(matching.map(record => record.folder));
+        const record = records[r.conversation_id] ?? (folders.size === 1 ? matching[0] : undefined);
+        if (!record || record.project_id !== r.project_id)
+            return; // No inferred local path for unknown projects.
+        let c = await getConversation(ctx, r.conversation_id);
+        if (c.project_id !== r.project_id)
+            throw new Error('Device request project changed.');
+        const planned = devicePath(record.folder, join('.shard', 'worktrees', conversationName(c)));
+        const requested = r.exec?.cwd_relative ?? r.files?.local_path_relative ?? '.';
+        const target = devicePath(planned.path, requested), grants = new DeviceGrants(ctx.store.dir);
+        target.outside ||= planned.outside;
+        const choice = grants.allows(ctx.apiUrl, r.project_id, record.folder, r.kind, target.outside) ? 'once' : await this.#ask({ type: 'approval', request_id: r.id, project_id: r.project_id, conversation_id: c.id, summary: deviceSummary(r), outside: target.outside });
+        if (choice === 'deny') {
+            await this.result(r, { state: 'denied' });
+            return;
+        }
+        if (choice !== 'once' && choice !== 'always')
+            throw new Error('Device request was not approved.');
+        if (target.outside && choice === 'always')
+            throw new UsageError('An outside path requires Allow once for this request.');
+        if (choice === 'always')
+            await grants.save(ctx.apiUrl, r.project_id, record.folder, r.kind);
+        // Re-read after the approval, before claiming or touching data.
+        if (devicePath(record.folder, join('.shard', 'worktrees', conversationName(c))).path !== planned.path || devicePath(planned.path, requested).path !== target.path)
+            throw new Error('Device path changed during approval.');
+        const current = await getConversation(ctx, r.conversation_id);
+        if (current.project_id !== c.project_id || current.branch !== c.branch || current.state === 'done' || current.state === 'archived')
+            throw new Error('The conversation changed or ended during device approval.');
+        c = current;
+        await this.result(r, { state: 'approved' });
+        await this.result(r, { state: 'running' });
+        let ws;
+        try {
+            // Approval is independent of VM/Git availability. Bound setup and report its
+            // failure through the existing running -> failed transition.
+            const preparation = { ...ctx, signal: AbortSignal.any([ctx.signal, AbortSignal.timeout(30_000)]) };
+            ws = await conversationWorkspace(preparation, c);
+            const root = await ensureConversationWorktree(preparation, c, record.folder, ws);
+            if (root !== planned.path || devicePath(root, requested).path !== target.path)
+                throw new Error('Device path changed during preparation.');
+            const prepared = await getConversation(ctx, c.id);
+            if (prepared.project_id !== c.project_id || prepared.workspace_id !== c.workspace_id || prepared.branch !== c.branch || prepared.state === 'done' || prepared.state === 'archived')
+                throw new Error('The conversation changed or ended during device preparation.');
+            const cell = ws.cell();
+            let result;
+            if (r.kind === 'try_locally' || tryLocallyAction(r)) {
+                const action = tryLocallyAction(r);
+                for (const [id, handle] of this.#handles)
+                    if (handle.conversation === c.id) {
+                        await handle.stop();
+                        this.#handles.delete(id);
+                    }
+                if (action === 'stop') {
+                    await this.result(r, { state: 'done', stdout_b64: Buffer.from('Local sync and ports stopped.').toString('base64') });
+                    return;
+                }
+                const { tryConversationLocally } = await import("./conversation-local.js");
+                const handle = await tryConversationLocally(ctx, c, record.folder);
+                this.#handles.set(r.id, { conversation: c.id, workspace: ws.id, async stop() { await handle.stop(); cell.close(); } });
+                result = { state: 'done', files_artifact: handle.folder };
+            }
+            else if (r.kind === 'exec') {
+                if (!r.exec)
+                    throw new UsageError('Device exec has no command.');
+                result = await deviceExec(r.exec.argv, target.path, r.exec.timeout_seconds, ctx.signal);
+            }
+            else if (r.kind === 'files_pull' || r.kind === 'files_push') {
+                const f = r.files;
+                if (!f || !f.remote_path.startsWith('/') || /[\0\r\n]/.test(f.remote_path))
+                    throw new UsageError('Device transfer requires an absolute VM path.');
+                const max = f.max_bytes ?? LIMIT;
+                if (!Number.isSafeInteger(max) || max < 1 || max > LIMIT)
+                    throw new UsageError('Device transfer maximum is 256 MiB.');
+                if (r.kind === 'files_pull') {
+                    if (!(await stat(target.path)).isFile() || (await stat(target.path)).size > max)
+                        throw new UsageError('Local transfer file exceeds the requested size or is not a file.');
+                    const bytes = await readFile(target.path);
+                    if (bytes.length > max)
+                        throw new UsageError('Local transfer file grew during reading.');
+                    await writeSyncBlob(cell, f.remote_path, bytes);
+                }
+                else {
+                    const info = await cell.files.stat(f.remote_path);
+                    if (info.type !== 'file' || info.size > max)
+                        throw new UsageError('VM transfer file exceeds the requested size or is not a file.');
+                    const bytes = await cell.files.read(f.remote_path, { length: max + 1 });
+                    if (bytes.length > max || bytes.length !== info.size)
+                        throw new UsageError('VM transfer file changed during reading.');
+                    await mkdir(dirname(target.path), { recursive: true, mode: 0o700 });
+                    const parent = await realpath(dirname(target.path));
+                    if (!target.outside && !inside(root, parent))
+                        throw new Error('Transfer parent escaped the worktree.');
+                    await writeFile(target.path, bytes, { mode: 0o600, flag: 'wx' }); // Existing files need a fresh explicit request, never silent clobber.
+                }
+                result = { state: 'done', files_artifact: r.kind === 'files_pull' ? f.remote_path : relative(root, target.path) };
+            }
+            else {
+                if (!r.port || ![r.port.local_port, r.port.remote_port].every(p => Number.isInteger(p) && p > 0 && p <= 65535))
+                    throw new UsageError('Device ports must be 1–65535.');
+                const handle = await devicePort(ws, cell, r.kind, r.port, ctx.signal);
+                this.#handles.set(r.id, { conversation: c.id, workspace: ws.id, stop: () => handle.stop() });
+                result = { state: 'done' };
+            }
+            await this.result(r, result);
+        }
+        catch (e) {
+            await this.result(r, { state: 'failed', stderr_b64: Buffer.from(e instanceof Error ? e.message : String(e)).toString('base64') });
+        }
+        finally {
+            if (!this.#handles.has(r.id))
+                ws?.cell().close();
+        }
+    }
+    async reap() {
+        for (const [id, handle] of this.#handles) {
+            const c = await getConversation(this.#ctx, handle.conversation);
+            const file = join(this.#ctx.store.dir, 'device-stops', `${c.id}.json`);
+            let stopped = false;
+            if (existsSync(file)) {
+                const record = JSON.parse(readFileSync(file, 'utf8'));
+                stopped = record.api_url === this.#ctx.apiUrl;
+            }
+            if (stopped || c.state === 'done' || c.state === 'archived' || c.workspace_id !== handle.workspace) {
+                await handle.stop();
+                this.#handles.delete(id);
+                if (stopped)
+                    rmSync(file);
+            }
+        }
+    }
+    async close() { await Promise.all([...this.#handles.values()].map(h => h.stop())); this.#handles.clear(); }
+}
+export async function devicePort(ws, cell, kind, ports, signal) {
+    const tunnels = new WorkspaceTunnels(() => cell, () => ws.grantedTools);
+    if (kind === 'port_reverse') {
+        const handle = await tunnels.reverse({ remotePort: ports.remote_port, target: `127.0.0.1:${ports.local_port}`, bindAddress: '127.0.0.1', signal });
+        let stopping;
+        return { stop() { return stopping ??= handle.close().finally(() => cell.close()); } };
+    }
+    const peers = new Set();
+    const handles = new Set();
+    const server = createServer(socket => {
+        peers.add(socket);
+        socket.once('close', () => peers.delete(socket));
+        socket.on('error', () => socket.destroy());
+        void tunnels.forward({ remotePort: ports.remote_port, stream: socket, signal }).then(handle => { handles.add(handle); void handle.closed.finally(() => handles.delete(handle)).catch(() => socket.destroy()); }).catch(() => socket.destroy());
+    });
+    await new Promise((resolveListen, reject) => { server.once('error', reject); server.listen(ports.local_port, '127.0.0.1', resolveListen); });
+    let stopping;
+    const abort = () => { void stop().catch(() => undefined); };
+    const stop = () => stopping ??= (async () => { signal.removeEventListener('abort', abort); for (const socket of peers)
+        socket.destroy(); await Promise.all([...handles].map(h => h.close())); await new Promise(resolveClose => server.close(() => resolveClose())); cell.close(); })();
+    signal.addEventListener('abort', abort, { once: true });
+    if (signal.aborted)
+        abort();
+    return { stop };
+}
+const approvalSocket = (dir, id) => {
+    const hash = createHash('sha256').update(resolve(dir)).update(safeId(id)).digest('hex').slice(0, 20);
+    const path = join(dir, 'acp-device', `${hash}.sock`);
+    return Buffer.byteLength(path) < 100 ? path : join('/tmp', `sf-device-${process.getuid?.() ?? 'user'}`, `${hash}.sock`);
+};
+export async function serveAcpDeviceApprovals(dir, id, ask) {
+    const path = approvalSocket(dir, id);
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const parent = lstatSync(dirname(path));
+    if (parent.isSymbolicLink() || (parent.mode & 0o077) || (process.getuid && parent.uid !== process.getuid()))
+        throw new Error('Device approval socket directory must be private and owned by this user.');
+    const peers = new Set();
+    const server = createServer(socket => {
+        peers.add(socket);
+        socket.once('close', () => peers.delete(socket));
+        let body = '';
+        socket.setTimeout(3600_000, () => socket.destroy());
+        socket.on('error', () => socket.destroy());
+        socket.on('data', chunk => {
+            body += String(chunk);
+            if (body.length > 64 << 10)
+                socket.destroy();
+            if (!body.includes('\n'))
+                return;
+            socket.removeAllListeners('data');
+            let approval;
+            try {
+                approval = JSON.parse(body);
+                if (approval.conversation_id !== id || approval.type !== 'approval')
+                    throw new Error('Invalid approval');
+            }
+            catch {
+                socket.destroy();
+                return;
+            }
+            void ask(approval).then(choice => socket.end(JSON.stringify({ choice }) + '\n')).catch(() => socket.end('{"choice":"deny"}\n'));
+        });
+    });
+    await withTargetLock(join(dirname(path), `${id}-lock`), async () => {
+        if (existsSync(path)) {
+            const old = lstatSync(path);
+            if (!old.isSocket() || (process.getuid && old.uid !== process.getuid()))
+                throw new Error('Device approval socket belongs to other work.');
+            const active = await new Promise((resolveActive, reject) => {
+                const probe = createConnection(path);
+                probe.setTimeout(1000, () => { probe.destroy(); reject(new Error('Device approval socket owner is unverified.')); });
+                probe.once('connect', () => { probe.destroy(); resolveActive(true); });
+                probe.once('error', error => { if (error.code === 'ECONNREFUSED')
+                    resolveActive(false);
+                else
+                    reject(error); });
+            });
+            if (active)
+                throw new Error('This ACP conversation already has a laptop bridge.');
+            if (lstatSync(path).ino !== old.ino)
+                throw new Error('Device approval socket owner changed.');
+            rmSync(path);
+        }
+        await new Promise((resolveListen, reject) => { server.once('error', reject); server.listen(path, resolveListen); });
+        chmodSync(path, 0o600);
+    });
+    const inode = lstatSync(path).ino;
+    let stopping;
+    return { stop() { return stopping ??= (async () => { for (const peer of peers)
+            peer.destroy(); await new Promise(resolveClose => server.close(() => resolveClose())); if (existsSync(path) && lstatSync(path).ino === inode)
+            rmSync(path); })(); } };
+}
+export async function askConnectedAcp(dir, approval, signal) {
+    const path = approvalSocket(dir, approval.conversation_id);
+    if (!existsSync(path))
+        return null;
+    return new Promise((resolveChoice, reject) => {
+        const socket = createConnection(path);
+        let text = '';
+        const abort = () => { socket.destroy(); reject(signal.reason instanceof Error ? signal.reason : new Error('Device approval interrupted')); };
+        signal.addEventListener('abort', abort, { once: true });
+        socket.on('connect', () => socket.write(JSON.stringify(approval) + '\n'));
+        socket.on('data', bytes => { text += String(bytes); if (text.length > 1024)
+            socket.destroy(); });
+        socket.once('error', () => { signal.removeEventListener('abort', abort); resolveChoice(null); });
+        socket.once('end', () => { signal.removeEventListener('abort', abort); try {
+            const choice = JSON.parse(text).choice;
+            resolveChoice(['once', 'always', 'deny'].includes(choice) ? choice : 'deny');
+        }
+        catch {
+            resolveChoice('deny');
+        } });
+    });
+}

package/dist/device-helper.d.ts

@@ -0,0 +1,3 @@
+import type { Ctx } from './commands.js';
+/** The menu bar owns this helper and its stdin; VM data can request actions but cannot answer approvals. */
+export declare function runDeviceHelper(ctx: Ctx): Promise<number>;

package/dist/device-helper.js

@@ -0,0 +1,104 @@
+import { setTimeout as delay } from 'node:timers/promises';
+import { DeviceExecutor, askConnectedAcp } from "./device-bridge.js";
+import { mirrorProjectConversations } from "./conversation-stash.js";
+import { withTargetLock } from "./target-lock.js";
+import { join } from 'node:path';
+import { conversationsUnavailable } from "./conversations.js";
+import { localConversations } from "./conversations.js";
+import { randomUUID } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { writePrivateFile } from "./credentials.js";
+import { conversationClient } from "./conversation-commands.js";
+import { Readable } from 'node:stream';
+/** The menu bar owns this helper and its stdin; VM data can request actions but cannot answer approvals. */
+export async function runDeviceHelper(ctx) {
+    const abort = new AbortController(), signal = AbortSignal.any([ctx.signal, abort.signal]);
+    ctx = { ...ctx, signal };
+    const pending = new Map();
+    const inputSource = Readable.from(ctx.io.stdin, { objectMode: false, signal });
+    const input = (async () => {
+        let tail = '';
+        for await (const bytes of inputSource) {
+            tail += Buffer.from(bytes).toString();
+            if (tail.length > 64 << 10)
+                throw new Error('Device approval input exceeds 64 KiB.');
+            for (let newline; (newline = tail.indexOf('\n')) >= 0;) {
+                const line = tail.slice(0, newline);
+                tail = tail.slice(newline + 1);
+                const approval = JSON.parse(line);
+                const resolve = pending.get(approval.request_id);
+                if (resolve && ['once', 'always', 'deny'].includes(approval.choice)) {
+                    pending.delete(approval.request_id);
+                    resolve(approval.choice);
+                }
+            }
+        }
+    })().finally(() => abort.abort());
+    void input.catch(() => abort.abort());
+    const ask = async (approval) => {
+        const acp = await askConnectedAcp(ctx.store.dir, approval, signal);
+        if (acp)
+            return acp;
+        return new Promise(resolve => {
+            const denied = () => { pending.delete(approval.request_id); resolve('deny'); };
+            signal.addEventListener('abort', denied, { once: true });
+            pending.set(approval.request_id, choice => { signal.removeEventListener('abort', denied); resolve(choice); });
+            ctx.io.stdout.write(JSON.stringify(approval) + '\n');
+            if (signal.aborted)
+                denied();
+        });
+    };
+    const working = new Map();
+    const mirrored = new Map();
+    const deviceFile = join(ctx.store.dir, 'device-id');
+    let deviceId;
+    try {
+        deviceId = readFileSync(deviceFile, 'utf8').trim();
+    }
+    catch {
+        deviceId = randomUUID();
+        writePrivateFile(ctx.store.dir, deviceFile, deviceId + '\n');
+    }
+    const executor = new DeviceExecutor(ctx, ask, deviceId);
+    const report = (e) => { ctx.io.stderr.write(`Device bridge: ${e instanceof Error ? e.message : String(e)}\n`); };
+    try {
+        return await withTargetLock(join(ctx.store.dir, 'device-helper-lock'), async () => {
+            while (!signal.aborted) {
+                try {
+                    for (const projectId of new Set(Object.values(localConversations(ctx)).map(r => r.project_id))) {
+                        await conversationClient(ctx).deviceRequests.heartbeat({ projectId, deviceId, leaseSeconds: 30 });
+                        let cursor;
+                        do {
+                            const page = await conversationClient(ctx).deviceRequests.list({ projectId, state: 'pending', limit: 200, ...(cursor ? { cursor } : {}) });
+                            for (const r of page.data) {
+                                if (r.device_id !== deviceId || working.has(r.id) || working.size >= 8)
+                                    continue;
+                                const work = executor.execute(r).catch(report).finally(() => working.delete(r.id));
+                                working.set(r.id, work);
+                            }
+                            cursor = page.nextCursor ?? undefined;
+                        } while (cursor && !signal.aborted);
+                    }
+                    await executor.reap();
+                    await mirrorProjectConversations(ctx, mirrored);
+                }
+                catch (e) {
+                    if (!signal.aborted && !conversationsUnavailable(e))
+                        report(e);
+                }
+                await delay(1000, undefined, { signal }).catch(() => undefined);
+            }
+            return 0;
+        }, signal);
+    }
+    finally {
+        abort.abort();
+        inputSource.destroy();
+        for (const resolve of pending.values())
+            resolve('deny');
+        pending.clear();
+        await executor.close();
+        await Promise.all([...working.values()]);
+        await input.catch(() => undefined);
+    }
+}

package/dist/errors.js

@@ -146,6 +146,11 @@ function isNamed(err, name) {
     return typeof err === 'object' && err !== null && err.name === name;
 }
 export function describeError(err) {
+    // Tunnel teardown and cleanup failures aggregate their causes: name them all, and let the first decide the code.
+    if (err instanceof AggregateError && err.errors.length) {
+        const inner = err.errors.map(e => describeError(e));
+        return { ...inner[0], message: `${err.message}: ${inner.map(i => i.message).join('; ')}` };
+    }
     // A processful command that could not start (0.5.1; the SDK's ExecStartError): the workspace's reason, no HTTP status
     // (the start itself was answered 201) and details.error, details.session_id.
     if (err instanceof ExecStartError)

package/dist/format.js

@@ -960,15 +960,16 @@ export function dataExportText(e, out) {
     ]);
 }
 export function volumeTable(rows) {
-    return table(['ID', 'NAME', 'STATE', 'QUOTA', 'SHARED', 'ATTACHED', 'CREATED'], rows.map((v) => [v.id, v.name, `${v.state}${v.deleted_at ? ' (deleted)' : ''}`, `${v.quota_gib} GiB`, v.org_shared ? 'organization' : 'project', String(v.live_attachments), time(v.created_at)]));
+    return table(['ID', 'NAME', 'KIND', 'STATE', 'QUOTA', 'SHARED', 'ATTACHED', 'CREATED'], rows.map((v) => [v.id, v.name, v.kind ?? 'shared', `${v.state}${v.deleted_at ? ' (deleted)' : ''}`, v.kind === 'project_space' ? 'platform managed' : `${v.quota_gib} GiB`, v.org_shared ? 'organization' : 'project', String(v.live_attachments), time(v.created_at)]));
 }
 export function volumeDetail(v) {
     const err = v.error;
     return kv([
         ['id', v.id],
         ['name', v.name],
+        ['kind', v.kind ?? 'shared'],
         ['state', `${v.state}${v.state_reason ? ` (${v.state_reason})` : ''}`],
-        ['quota', `${v.quota_gib} GiB`],
+        ['quota', v.kind === 'project_space' ? 'platform managed' : `${v.quota_gib} GiB`],
         ['shared', v.org_shared ? 'every project of the organization' : `project ${v.project_id}`],
         ['attachments', String(v.live_attachments)],
         ['usage', pairs(v.usage)],

package/dist/git-remote-bin.js

@@ -22,7 +22,9 @@ try {
         if (!ws)
             throw new Error(`workspace ${remote.key} does not exist`);
         cell = ws.cell({ agentLabel: 'git-remote-shard', transitionTimeoutMs: 120_000 });
-        return cell.exec;
+        const capability = await cell.exec.run(['/usr/local/bin/sf-agent', 'git-bridge-info'], { timeoutMs: 10_000, maxOutputBytes: 4096, signal: controller.signal });
+        const platformGitBridge = capability.exitCode === 0 && JSON.parse(capability.stdout).version === 1;
+        return { ...cell.exec, platformGitBridge };
     }, controller.signal);
 }
 catch (error) {

package/dist/git-remote.d.ts

@@ -7,7 +7,9 @@ export interface ShardRemote {
 /** Keys have two segments (K9). Everything after the agent is an absolute guest path. */
 export declare function parseShardRemote(url: string): ShardRemote;
 export declare function shardRemote(key: string, path: string): string;
-export type GitExec = Pick<CellClient['exec'], 'start' | 'input' | 'output' | 'cancel'>;
+export type GitExec = Pick<CellClient['exec'], 'start' | 'input' | 'output' | 'cancel'> & {
+    platformGitBridge?: boolean;
+};
 /** No text decoding of the pack stream; offsets are acknowledged bytes, including partial stdin writes. */
 export declare function bridgeGit(exec: GitExec, service: string, path: string, input: AsyncIterable<Uint8Array>, stdout: Writable, stderr: Writable, signal: AbortSignal): Promise<number>;
 /** Git's `connect` capability switches from newline commands to a full-duplex smart protocol. */

package/dist/git-remote.js

@@ -28,7 +28,8 @@ export async function bridgeGit(exec, service, path, input, stdout, stderr, sign
         throw new UsageError('unsupported Git service');
     const controller = new AbortController();
     const combined = AbortSignal.any([signal, controller.signal]);
-    const session = await exec.start({ argv: [service, path], stdin_open: true, timeout_ms: 600_000 }, combined);
+    const argv = exec.platformGitBridge ? ['/usr/local/bin/sf-agent', 'git-bridge', '--service', service, '--path', path] : [service, path];
+    const session = await exec.start({ argv, stdin_open: true, timeout_ms: 600_000 }, combined);
     let ended = false, offset = 0;
     const send = async () => {
         for await (const chunk of input) {

package/dist/handlers.js

@@ -1,4 +1,5 @@
 import { CREDENTIAL_HANDLERS } from "./credential-prompts.js";
+import { CONVERSATION_HANDLERS } from "./conversation-commands.js";
 /**
  * Every command's handler, keyed by its path ("workspaces open", "auth login"): the project-key commands of
  * commands.ts and the account plane of account-commands.ts (0.5.0). args.test.ts checks that it matches COMMANDS.
@@ -13,4 +14,5 @@ import { AGENT_GIT_HANDLERS } from "./agent-git-commands.js";
 import { MENUBAR_HANDLERS } from "./menubar.js";
 import { UPDATE_HANDLERS } from "./update.js";
 import { FILESYSTEM_HANDLERS } from "./filesystem-commands.js";
-export const HANDLERS = { ...CREDENTIAL_HANDLERS, ...AGENT_CREDENTIAL_HANDLERS, ...KEY_HANDLERS, ...ACCOUNT_HANDLERS, ...AGENT_HANDLERS, ...CENTER_HANDLERS, ...TARGET_HANDLERS, ...AGENT_GIT_HANDLERS, ...MENUBAR_HANDLERS, ...FILESYSTEM_HANDLERS, ...UPDATE_HANDLERS };
+import { CONVERSATION_HANDLERS as LOCAL_CONVERSATION_HANDLERS } from "./conversation-local.js";
+export const HANDLERS = { ...CONVERSATION_HANDLERS, ...LOCAL_CONVERSATION_HANDLERS, ...CREDENTIAL_HANDLERS, ...AGENT_CREDENTIAL_HANDLERS, ...KEY_HANDLERS, ...ACCOUNT_HANDLERS, ...AGENT_HANDLERS, ...CENTER_HANDLERS, ...TARGET_HANDLERS, ...AGENT_GIT_HANDLERS, ...MENUBAR_HANDLERS, ...FILESYSTEM_HANDLERS, ...UPDATE_HANDLERS };