super-dsh 0.3.0-e → 0.3.0-g

package/superd-hub/dist/remote-job-client.js

@@ -0,0 +1,197 @@
+import { randomUUID } from 'node:crypto';
+import { ByteTailRing, readUtf8Tail } from '../../remote/plugin.js';
+import { REMOTE_JOB_PATH, TASK_LEASE_MS, TASK_RENEW_STEP_MS, TASK_CLEANUP_MS, TASK_CONTROL_TIMEOUT_MS, TASK_LEASE_PROTOCOL } from './remote-job-rpc.js';
+/** Event-driven output; the only periodic operation renews this task's bounded resource lease. */
+export function startRemoteProcess(origin, cookie, input, owner) {
+    const id = randomUUID(), started = performance.now();
+    const rings = { stdout: new ByteTailRing(), stderr: new ByteTailRing() };
+    const offsets = { stdout: 0, stderr: 0 };
+    const stats = {};
+    const streamAbort = new AbortController();
+    let diagnostic, cancelled = false, finished = false, stopping = false;
+    let lease, cleanupDeadline = 0, nextRenewAt = 0;
+    let renewTimer, renewal;
+    let stopWork, result;
+    let prepared, acknowledge;
+    const preparation = new Promise(resolve => { prepared = resolve; });
+    const cleaned = new Promise(resolve => { acknowledge = resolve; });
+    let acknowledged = false, startDispatched = false, outputComplete = false;
+    const confirm = () => { acknowledged = true; acknowledge(); };
+    const note = (error) => { const text = error instanceof Error ? error.message : String(error); diagnostic = diagnostic ? `${diagnostic}; ${text}` : text; };
+    const headers = { 'content-type': 'application/json', cookie };
+    // Header/control time bounds stop new ownership extension; they never prove process cleanup.
+    const request = async (body, controller, consumeJson, timeoutMs = TASK_CONTROL_TIMEOUT_MS) => {
+        const timer = setTimeout(() => controller.abort(new Error('remote task control timeout')), timeoutMs);
+        try {
+            const response = await fetch(`${origin}${REMOTE_JOB_PATH}`, { method: 'POST', headers, body: JSON.stringify(body), signal: controller.signal });
+            if (!response.ok)
+                throw new Error(`remote task: ${response.status} ${await response.text()}`);
+            return consumeJson ? await response.json() : response;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    };
+    const control = (op, extra = {}) => request({ op, owner, id, ...extra }, new AbortController(), true, op === 'cancel' ? TASK_CLEANUP_MS + TASK_CONTROL_TIMEOUT_MS : TASK_CONTROL_TIMEOUT_MS);
+    const parseLease = (value) => {
+        const l = value?.lease;
+        if (!l || l.protocol !== TASK_LEASE_PROTOCOL || l.leaseMs !== TASK_LEASE_MS || l.renewStepMs !== TASK_RENEW_STEP_MS || l.cleanupMs !== TASK_CLEANUP_MS || typeof l.token !== 'string')
+            throw new Error('remote task: bounded lease protocol unsupported');
+        return l;
+    };
+    // Full cancel snapshots and incremental stream frames share absolute byte coordinates.
+    // Append only the unseen suffix; stale/overlapping frames cannot rewind or duplicate output.
+    const mergeOutput = (channel, read) => {
+        if (read.nextOffset < offsets[channel])
+            return;
+        const delta = readUtf8Tail(Buffer.from(read.text), read.nextOffset, offsets[channel]);
+        if (delta.lossy)
+            rings[channel] = new ByteTailRing();
+        rings[channel].push(Buffer.from(delta.text));
+        offsets[channel] = delta.nextOffset;
+        stats[channel] = read.stats;
+        if (read.diagnostic)
+            diagnostic = read.diagnostic;
+    };
+    const stopRenewing = () => { stopping = true; clearTimeout(renewTimer); };
+    const waitForCleanup = async () => {
+        if (acknowledged || !lease)
+            return;
+        // Monotonic upper bound: prepare receipt + initial lease + every dispatched renewal step
+        // + canonical group cleanup. In-flight renewals were accounted BEFORE sending, so loss is safe.
+        let timer;
+        await Promise.race([cleaned, new Promise(resolve => { timer = setTimeout(resolve, Math.max(0, cleanupDeadline - performance.now())); })]);
+        clearTimeout(timer);
+        if (!acknowledged)
+            note('remote task lease expired; receiver cleanup bound elapsed');
+    };
+    const stop = () => {
+        stopRenewing();
+        return stopWork ??= (async () => {
+            await preparation;
+            if (!lease || acknowledged)
+                return;
+            try {
+                const response = await control('cancel');
+                if (response.done !== true)
+                    throw new Error('remote task: invalid cleanup acknowledgement');
+                if (response.snapshot) {
+                    mergeOutput('stdout', response.snapshot.stdout);
+                    mergeOutput('stderr', response.snapshot.stderr);
+                    result = response.snapshot.result;
+                    outputComplete = true;
+                }
+                else if (response.notStarted)
+                    outputComplete = true;
+                confirm();
+            }
+            catch (error) {
+                note(error);
+            }
+            // Closing the reader helps a reachable receiver observe disconnection. The lease/ack barrier,
+            // NOT this abort, determines completion even if the receiver has not observed that close.
+            streamAbort.abort();
+            await waitForCleanup();
+        })();
+    };
+    const scheduleRenewal = () => {
+        if (stopping || finished)
+            return;
+        renewTimer = setTimeout(() => {
+            if (stopping || finished || !lease)
+                return;
+            cleanupDeadline += TASK_RENEW_STEP_MS; // include possibly-applied renewal even when its response is lost
+            const token = lease.token;
+            renewal = (async () => {
+                try {
+                    lease = parseLease(await control('renew', { token }));
+                }
+                catch (error) {
+                    if (!stopping && !acknowledged) {
+                        note(error);
+                        void stop();
+                    }
+                }
+                finally {
+                    nextRenewAt += TASK_RENEW_STEP_MS;
+                    scheduleRenewal();
+                }
+            })();
+        }, Math.max(0, nextRenewAt - performance.now()));
+    };
+    const done = (async () => {
+        try {
+            lease = parseLease(await control('prepare'));
+            cleanupDeadline = performance.now() + TASK_LEASE_MS + TASK_CLEANUP_MS;
+            nextRenewAt = performance.now() + TASK_RENEW_STEP_MS;
+            prepared();
+            if (cancelled) {
+                await stop();
+                return { exit: null, timedOut: false, cancelled: true, durationMs: Math.round(performance.now() - started) };
+            }
+            // No start may be admitted without the bounded token received above. Delayed starts cannot
+            // outlive that token or resurrect a cancelled/expired record.
+            startDispatched = true;
+            const response = await request({ op: 'start', owner, id, token: lease.token, input: { cmd: input.cmd, stdin: input.stdin, timeoutSec: input.timeout } }, streamAbort, false);
+            scheduleRenewal();
+            if (!response.body)
+                throw new Error('remote task: missing output stream');
+            const reader = response.body.getReader(), decoder = new TextDecoder();
+            let pending = '';
+            try {
+                for (;;) {
+                    const chunk = await reader.read();
+                    if (chunk.done)
+                        break;
+                    pending += decoder.decode(chunk.value, { stream: true });
+                    let newline;
+                    while ((newline = pending.indexOf('\n')) >= 0) {
+                        const frame = JSON.parse(pending.slice(0, newline));
+                        pending = pending.slice(newline + 1);
+                        mergeOutput('stdout', frame.stdout);
+                        mergeOutput('stderr', frame.stderr);
+                        if (frame.done) {
+                            result = frame.done;
+                            outputComplete = true;
+                            stopRenewing();
+                            confirm();
+                        }
+                    }
+                }
+            }
+            finally {
+                await reader.cancel().catch(() => { });
+                reader.releaseLock();
+            }
+            if (!result)
+                throw new Error('remote task stream ended before cleanup acknowledgement');
+            await stopWork;
+            return result;
+        }
+        catch (error) {
+            if (!stopping)
+                note(error);
+            prepared(); // A failed prepare never spawned anything; any successful prepare is bounded above.
+            await stop();
+            return result ?? { exit: null, timedOut: false, cancelled, durationMs: Math.round(performance.now() - started) };
+        }
+        finally {
+            finished = true;
+            stopRenewing();
+            prepared();
+            await renewal; // no in-flight transport resource or lease extension survives done
+            if (startDispatched && !outputComplete)
+                note('remote task final output unavailable; returned output and counters may be incomplete');
+        }
+    })();
+    return {
+        cancel() { if (cancelled || finished)
+            return; cancelled = true; void stop(); }, done,
+        read(channel, fromByte) {
+            const read = readUtf8Tail(rings[channel].tail(), offsets[channel], fromByte);
+            const incomplete = finished && startDispatched && !outputComplete;
+            const metric = incomplete ? undefined : stats[channel];
+            return { ...read, lossy: read.lossy || incomplete, ...(metric ? { stats: { ...metric, returned: Buffer.byteLength(read.text) } } : {}), ...(channel === 'stderr' && diagnostic ? { diagnostic } : {}) };
+        },
+    };
+}

package/superd-hub/dist/remote-job-rpc.d.ts

@@ -0,0 +1,21 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { type RemoteProcess } from '../../remote/plugin.js';
+export declare const REMOTE_JOB_PATH = "/api/superd/exec/task";
+export declare const TASK_LEASE_MS = 6000;
+export declare const TASK_RENEW_STEP_MS = 2000;
+export declare const TASK_CLEANUP_MS: number;
+export declare const TASK_CONTROL_TIMEOUT_MS = 1500;
+export declare const TASK_LEASE_PROTOCOL = 1;
+type Result = Awaited<RemoteProcess['done']>;
+export interface RemoteTaskSnapshot {
+    stdout: ReturnType<RemoteProcess['read']>;
+    stderr: ReturnType<RemoteProcess['read']>;
+    result: Result;
+}
+export declare function createRemoteJobExecutor(): {
+    handle(request: Request): Promise<Response>;
+    dispose(): Promise<void>;
+};
+/** Official connection fetch bridge supplies disconnect AbortSignal and auth/trust fence. */
+export declare function registerRemoteJobRpc(ctx: Context): void;
+export {};

package/superd-hub/dist/remote-job-rpc.js

@@ -0,0 +1,155 @@
+/** Owned execution resources, not a model job registry. Identity/lifecycle remain in native ctx.jobs. */
+import { createHash, randomUUID } from 'node:crypto';
+import { startOneShot, PROCESS_CLEANUP_BOUND_MS } from '../../remote/plugin.js';
+import { parseOneShotExecBody } from './exec.js';
+export const REMOTE_JOB_PATH = '/api/superd/exec/task';
+// Receiver lease deadlines use monotonic time. Renewal adds a fixed step to the previous deadline,
+// never to request arrival: even a delayed in-flight request has a client-accountable upper bound.
+export const TASK_LEASE_MS = 6000;
+export const TASK_RENEW_STEP_MS = 2000;
+// Canonical process cleanup: TERM, 2000ms grace, KILL, 100ms settle. Include scheduling margin.
+export const TASK_CLEANUP_MS = PROCESS_CLEANUP_BOUND_MS + 200;
+export const TASK_CONTROL_TIMEOUT_MS = 1500;
+export const TASK_LEASE_PROTOCOL = 1;
+const json = (status, body) => Response.json(body, { status });
+export function createRemoteJobExecutor() {
+    const active = new Map();
+    let disposed = false;
+    const stop = async (key, lease, remove = true) => {
+        lease.stopping = true;
+        if (remove)
+            clearTimeout(lease.timer);
+        lease.process?.cancel('remote task ownership released');
+        await lease.process?.done;
+        if (remove && active.get(key) === lease)
+            active.delete(key);
+    };
+    const arm = (key, lease) => {
+        clearTimeout(lease.timer);
+        lease.timer = setTimeout(() => { void stop(key, lease); }, Math.max(0, lease.expires - performance.now()));
+    };
+    const metadata = (lease) => ({ protocol: TASK_LEASE_PROTOCOL, token: lease.token, leaseMs: TASK_LEASE_MS, renewStepMs: TASK_RENEW_STEP_MS, cleanupMs: TASK_CLEANUP_MS });
+    return {
+        async handle(request) {
+            if (disposed)
+                return json(503, { error: 'remote executor disposed' });
+            if (request.method !== 'POST')
+                return json(405, { error: 'use POST' });
+            let body;
+            try {
+                body = await request.json();
+            }
+            catch {
+                return json(400, { error: 'invalid JSON' });
+            }
+            // Buffered parsing yields. Disposal closes admission permanently before it awaits owned processes.
+            if (disposed)
+                return json(503, { error: 'remote executor disposed' });
+            if (!body || typeof body.owner !== 'string' || typeof body.id !== 'string' || !/^[\w-]{1,128}$/.test(body.owner) || !/^[\w-]{1,128}$/.test(body.id))
+                return json(400, { error: 'owner and task id required' });
+            const credential = createHash('sha256').update(request.headers.get('cookie') ?? '').digest('hex');
+            const key = `${credential}:${body.owner}:${body.id}`;
+            if (body.op === 'cancel') {
+                const lease = active.get(key);
+                if (!lease)
+                    return json(200, { done: true, outputUnavailable: true }); // no foreign resource existence disclosed
+                await stop(key, lease);
+                const process = lease.process;
+                if (!process)
+                    return json(200, { done: true, notStarted: true });
+                const snapshot = { result: await process.done, stdout: process.read('stdout', 0), stderr: process.read('stderr', 0) };
+                return json(200, { done: true, snapshot });
+            }
+            if (body.op === 'prepare') {
+                if (active.has(key))
+                    return json(409, { error: 'task already prepared' });
+                if (request.signal.aborted)
+                    return json(499, { error: 'request disconnected before preparation' });
+                const lease = { token: randomUUID(), expires: performance.now() + TASK_LEASE_MS, stopping: false };
+                active.set(key, lease);
+                arm(key, lease);
+                // No subprocess exists yet. The client must receive this bounded token before it can send start.
+                return json(200, { lease: metadata(lease) });
+            }
+            const lease = active.get(key);
+            if (body.op === 'read') {
+                if (!lease?.process)
+                    return json(404, { error: 'unknown owned task' });
+                const out = body.stdout ?? 0, err = body.stderr ?? 0;
+                if (![out, err].every(n => Number.isSafeInteger(n) && n >= 0))
+                    return json(400, { error: 'invalid byte cursor' });
+                return json(200, { stdout: lease.process.read('stdout', out), stderr: lease.process.read('stderr', err) });
+            }
+            if (body.op !== 'start' && body.op !== 'renew')
+                return json(400, { error: 'unknown task operation' });
+            if (!lease || lease.stopping || lease.token !== body.token || performance.now() >= lease.expires)
+                return json(409, { error: 'task lease absent, expired or superseded; nothing started or renewed' });
+            if (body.op === 'renew') {
+                if (!lease.process)
+                    return json(409, { error: 'task has not started' });
+                lease.expires = Math.min(lease.expires + TASK_RENEW_STEP_MS, performance.now() + TASK_LEASE_MS);
+                lease.token = randomUUID();
+                arm(key, lease);
+                return json(200, { lease: metadata(lease) });
+            }
+            if (lease.process)
+                return json(409, { error: 'task already started' });
+            const parsed = parseOneShotExecBody(body.input);
+            if (!parsed.ok)
+                return json(400, { error: parsed.error });
+            if (request.signal.aborted) {
+                await stop(key, lease);
+                return json(499, { error: 'request disconnected before start' });
+            }
+            let wake;
+            let changed = true, result, streamClosed = false;
+            const notify = () => { changed = true; wake?.(); wake = undefined; };
+            const input = parsed.value;
+            const process = startOneShot(['bash', '-lc', input.cmd], { unit: 'bytes', stdin: input.stdin, cwd: input.cwd, timeoutSec: input.timeoutSec, onOutput: notify });
+            lease.process = process;
+            const cancel = () => { void stop(key, lease, false); };
+            request.signal.addEventListener('abort', cancel, { once: true });
+            const detach = () => request.signal.removeEventListener('abort', cancel);
+            // Keep the terminal ring available through the existing bounded lease window.
+            // Stream delivery is not end-to-end receipt: a proxy may still hold the final frame.
+            void process.done.then(value => { result = value; lease.stopping = true; detach(); notify(); });
+            let out = 0, err = 0;
+            const stream = new ReadableStream({
+                async pull(controller) {
+                    if (streamClosed)
+                        return;
+                    if (!changed && !result)
+                        await new Promise(resolve => { wake = resolve; });
+                    if (streamClosed)
+                        return;
+                    changed = false;
+                    const stdout = process.read('stdout', out), stderr = process.read('stderr', err);
+                    out = stdout.nextOffset;
+                    err = stderr.nextOffset;
+                    controller.enqueue(Buffer.from(JSON.stringify({ stdout, stderr, ...(result ? { done: result } : {}) }) + '\n'));
+                    if (result) {
+                        streamClosed = true;
+                        controller.close();
+                    }
+                },
+                async cancel() { streamClosed = true; notify(); await stop(key, lease, false); detach(); },
+            }, { highWaterMark: 0 });
+            return new Response(stream, { headers: { 'content-type': 'application/x-ndjson', 'cache-control': 'no-store' } });
+        },
+        async dispose() {
+            disposed = true;
+            await Promise.all([...active].map(([key, lease]) => stop(key, lease)));
+        },
+    };
+}
+/** Official connection fetch bridge supplies disconnect AbortSignal and auth/trust fence. */
+export function registerRemoteJobRpc(ctx) {
+    ctx.inject(['connection'], connectionCtx => {
+        const connection = Reflect.get(connectionCtx, 'connection');
+        if (!connection?.fetch)
+            return;
+        const executor = createRemoteJobExecutor();
+        connectionCtx.effect(() => () => executor.dispose(), 'remote task executor cleanup');
+        connectionCtx.effect(() => connection.fetch.register({ path: REMOTE_JOB_PATH, methods: ['POST'], requestBody: 'buffered', fetch: request => executor.handle(request) }), 'remote task authenticated route');
+    });
+}

package/superd-hub/dist/remote-provider.d.ts

@@ -0,0 +1,13 @@
+/** Hub transport implementation. HTTP/WS/pool mechanics stay in the existing exec modules. */
+import { type HubRemoteTransport } from '../../remote/plugin.js';
+import type { HubToolExecFace } from './hub-tool.js';
+import type { A2aLogFn } from './a2a-log.js';
+/** One shared initiator implementation for legacy tool and the optional remote service. */
+export declare function createHubExec(home: string, log?: A2aLogFn): {
+    face: HubToolExecFace;
+    releaseOwner(owner: string): Promise<void>;
+    dispose(): Promise<void>;
+};
+export declare function createHubRemoteTransport(home: string, log?: A2aLogFn): HubRemoteTransport & {
+    dispose(): Promise<void>;
+};

package/superd-hub/dist/remote-provider.js

@@ -0,0 +1,151 @@
+import { createRemoteFileEndpoint } from './remote-file-rpc.js';
+import { startRemoteProcess } from './remote-job-client.js';
+import { ensureSelf, listRemotes } from './machines.js';
+import { cookieOf } from './mesh-link.js';
+import { runOneShotExec, postOneShotExec, parseOneShotExecBody } from './exec.js';
+import { PtyPool } from './exec-pty-session.js';
+import { LocalScriptChannel, WsPtyChannel } from './exec-pty-channel.js';
+import { PTY_EXEC_PATH } from './exec-pty-rpc.js';
+/** One shared initiator implementation for legacy tool and the optional remote service. */
+export function createHubExec(home, log) {
+    const owners = new Map();
+    let closed = false;
+    const assertOpen = () => { if (closed)
+        throw new Error('Hub transport unavailable — provider has been disposed'); };
+    const remote = (machine) => {
+        assertOpen();
+        const row = listRemotes(home).find(r => r.id === machine);
+        if (!row)
+            throw new Error(`unknown machine "${machine}" — call roster for remote machines`);
+        if (!row.enabled || row.execEnabled === false)
+            throw new Error(`exec is disabled for machine "${machine}" on this registry row (enabled/execEnabled=false)`);
+        return row;
+    };
+    const face = {
+        selfM4: () => ensureSelf(home, 'local').id,
+        run: input => { assertOpen(); return runOneShotExec(input, log); },
+        post: async (machine, input) => {
+            const row = remote(machine);
+            log?.('info', 'exec.remote', { machine, cmd: input.cmd, timeoutSec: input.timeoutSec ?? 120 });
+            const result = await postOneShotExec(row.origin, input, { cookie: cookieOf(row.id, home) });
+            log?.('info', 'exec.remote.done', { machine, exit: result.exit ?? 'none', durationMs: result.durationMs, outcome: result.outcome });
+            return result;
+        },
+        pty: async (owner, machine, cmd, opts = {}) => {
+            assertOpen();
+            // Validate on EVERY dispatch, including a warm shell. Pairing may have changed.
+            const row = machine === face.selfM4() ? undefined : remote(machine);
+            let pool = owners.get(owner);
+            if (!pool)
+                owners.set(owner, pool = new PtyPool({ idleTtlSec: 600 }));
+            const key = `${machine}|${row?.origin ?? 'local'}`;
+            const session = pool.getOrCreate(key, () => row
+                ? new WsPtyChannel(`${row.origin.replace(/^http/, 'ws')}${PTY_EXEC_PATH}`, { cookie: cookieOf(row.id, home) })
+                : new LocalScriptChannel());
+            const result = await session.dispatch(cmd, opts);
+            log?.('info', 'exec.pty.run', { machine, cmd: cmd.slice(0, 120), exit: result.exit ?? 'none', durationMs: result.durationMs });
+            return result;
+        },
+    };
+    return {
+        face,
+        async releaseOwner(owner) {
+            const pool = owners.get(owner);
+            if (pool) {
+                await pool.disposeAll();
+                if (owners.get(owner) === pool)
+                    owners.delete(owner);
+            }
+        },
+        async dispose() { closed = true; await Promise.all([...owners.values()].map(p => p.disposeAll())); owners.clear(); },
+    };
+}
+export function createHubRemoteTransport(home, log) {
+    const exec = createHubExec(home, log);
+    let closed = false;
+    const released = new Set();
+    const fileAbort = new AbortController();
+    const files = new Set();
+    const processes = new Map();
+    const pending = new Map();
+    const requireRemote = (machine) => {
+        if (!machine || machine === exec.face.selfM4())
+            throw new Error('Select a remote machine from the Hub roster; local execution is not available through remote');
+    };
+    const track = async (owner, work) => {
+        let set = pending.get(owner);
+        if (!set)
+            pending.set(owner, set = new Set());
+        set.add(work);
+        try {
+            return await work;
+        }
+        finally {
+            set.delete(work);
+            if (!set.size)
+                pending.delete(owner);
+        }
+    };
+    return {
+        protocol: 1,
+        listTargets: () => listRemotes(home).filter(r => r.id !== exec.face.selfM4()).map(r => ({ id: r.id, label: r.name, execEnabled: r.enabled && r.execEnabled !== false })),
+        async start(machine, input, owner) {
+            requireRemote(machine);
+            const parsed = parseOneShotExecBody({ cmd: input.cmd, ...(input.stdin === undefined ? {} : { stdin: input.stdin }), ...(input.timeout === undefined ? {} : { timeoutSec: input.timeout }) });
+            if (!parsed.ok)
+                throw new Error(parsed.error);
+            if (closed || released.has(owner))
+                throw new Error('Hub remote owner disposed');
+            const row = listRemotes(home).find(r => r.id === machine);
+            if (!row)
+                throw new Error(`unknown machine "${machine}"`);
+            if (!row.enabled || row.execEnabled === false)
+                throw new Error(`exec is disabled for machine "${machine}"`);
+            const process = startRemoteProcess(row.origin, cookieOf(row.id, home) ?? '', input, owner);
+            let set = processes.get(owner);
+            if (!set)
+                processes.set(owner, set = new Set());
+            set.add(process);
+            void process.done.then(() => { set.delete(process); if (!set.size)
+                processes.delete(owner); });
+            return process;
+        },
+        async pty(machine, cmd, owner, options) {
+            requireRemote(machine);
+            if (closed || released.has(owner))
+                throw new Error('Hub remote owner disposed');
+            const { output, ...result } = await track(owner, exec.face.pty(owner, machine, cmd, { timeoutSec: options.timeout, stdin: options.stdin }));
+            return { mode: 'pty', target: `hub:${machine}`, ...result, stdout: output };
+        },
+        fileEndpoint(machine) {
+            requireRemote(machine);
+            return createRemoteFileEndpoint(() => {
+                if (closed)
+                    throw new Error('Hub remote provider disposed');
+                const row = listRemotes(home).find(r => r.id === machine);
+                if (!row)
+                    throw new Error(`unknown machine "${machine}"`);
+                if (!row.enabled || row.execEnabled === false)
+                    throw new Error(`exec is disabled for machine "${machine}"`);
+                return { origin: row.origin, cookie: cookieOf(row.id, home) ?? '' };
+            }, fileAbort.signal, done => { files.add(done); void done.finally(() => files.delete(done)); });
+        },
+        async releaseOwner(owner) {
+            released.add(owner);
+            const owned = [...processes.get(owner) ?? []];
+            for (const process of owned)
+                process.cancel('owner released');
+            await Promise.all([exec.releaseOwner(owner), ...owned.map(p => p.done), ...pending.get(owner) ?? []]);
+        },
+        async dispose() {
+            closed = true;
+            fileAbort.abort(new Error('Hub file provider disposed'));
+            await Promise.allSettled([...files]);
+            const owned = [...processes.values()].flatMap(s => [...s]);
+            for (const process of owned)
+                process.cancel('provider disposed');
+            await exec.dispose();
+            await Promise.allSettled([...owned.map(p => p.done), ...[...pending.values()].flatMap(s => [...s])]);
+        },
+    };
+}

package/superd-hub/dist/remote-row.d.ts

@@ -0,0 +1,6 @@
+export { createRemoteJobExecutor } from './remote-job-rpc.js';
+/** Hub-body capability, deliberately independent of model tool rows. */
+import type { Context } from '@deepseek-ai/cordis';
+export declare function installHubRemoteTransport(ctx: Context, options: {
+    home: string;
+}): void;

package/superd-hub/dist/remote-row.js

@@ -0,0 +1,13 @@
+import { registerRemoteJobRpc } from './remote-job-rpc.js';
+export { createRemoteJobExecutor } from './remote-job-rpc.js';
+import { createHubRemoteTransport } from './remote-provider.js';
+import { registerExecRpc } from './mesh-rpc.js';
+import { consoleA2aLog } from './a2a-log.js';
+export function installHubRemoteTransport(ctx, options) {
+    const log = consoleA2aLog();
+    const transport = createHubRemoteTransport(options.home, log);
+    ctx.effect(() => () => transport.dispose(), 'superd-hub: remote transport cleanup');
+    ctx.provide('superdRemoteTransport', transport);
+    registerExecRpc(ctx, log);
+    registerRemoteJobRpc(ctx);
+}