@dinoxx/dinox-cli 2.3.0 → 2.4.0

package/dist/gateway/protocol.js

@@ -0,0 +1,127 @@
+import { REMOTE_DEVICE_PROTOCOL_VERSION, } from '../vendor/electron/shared/remote-device-agent.js';
+/** Request validation, rule-for-rule with the desktop host (RemoteDeviceHostModule). */
+const SUBJECT_ID = /^[a-z0-9][a-z0-9_-]{0,127}$/;
+const DEVICE_ID = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+const OPAQUE_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
+const MAX_REQUEST_BYTES = 900_000;
+const MAX_PROMPT_LENGTH = 100_000;
+const MAX_FILE_PARTS = 16;
+const MAX_APPROVAL_REQUEST_BYTES = 16 * 1024;
+const MAX_APPROVAL_REASON_LENGTH = 500;
+const MAX_AGENT_CONFIG_ENTRIES = 8;
+const MAX_AGENT_CONFIG_TEXT = 512;
+const isSubjectId = (value) => typeof value === 'string' && SUBJECT_ID.test(value);
+const isDeviceId = (value) => typeof value === 'string' && DEVICE_ID.test(value);
+function isMessageOfType(value, type) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const record = value;
+    return record.protocolVersion === REMOTE_DEVICE_PROTOCOL_VERSION && record.type === type && isSubjectId(record.requestId);
+}
+function isChatMessage(value, role) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const message = value;
+    return isSubjectId(message.id) && message.role === role && Array.isArray(message.parts);
+}
+function isHttpsUrl(value) {
+    if (typeof value !== 'string')
+        return false;
+    try {
+        return new URL(value.trim()).protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+}
+export function validateRunRequest(value, byteLength) {
+    if (!isMessageOfType(value, 'run.request'))
+        return 'invalid protocol version or type';
+    if (byteLength > MAX_REQUEST_BYTES)
+        return 'request payload too large';
+    if (!isDeviceId(value.clientDeviceId))
+        return 'invalid clientDeviceId';
+    if (!isSubjectId(value.runId) || !isSubjectId(value.threadId))
+        return 'invalid request ids';
+    if (typeof value.prompt !== 'string' || !value.prompt.trim())
+        return 'prompt is empty';
+    if (value.prompt.length > MAX_PROMPT_LENGTH)
+        return 'prompt too long';
+    if (!isChatMessage(value.userMessage, 'user'))
+        return 'invalid userMessage';
+    if (!isChatMessage(value.assistantMessage, 'assistant'))
+        return 'invalid assistantMessage';
+    const fileParts = value.userMessage.parts.filter((part) => part.type === 'file' && typeof part.url === 'string');
+    if (fileParts.length > MAX_FILE_PARTS)
+        return 'too many attachments';
+    for (const part of fileParts) {
+        const dinox = part.providerMetadata?.dinox;
+        if (!isSubjectId(dinox?.resourceId))
+            return 'invalid attachment resourceId';
+        if (!isHttpsUrl(part.url))
+            return 'attachment URL must use HTTPS';
+    }
+    if (value.createThread && value.createThread.id !== value.threadId)
+        return 'createThread.id must equal threadId';
+    if (readAgentConfig(value) === 'invalid')
+        return 'invalid agentConfig';
+    return null;
+}
+export function isAgentConfigQuery(value) {
+    return isMessageOfType(value, 'agent.config.get') && isDeviceId(value.clientDeviceId);
+}
+/** The run's chosen agent settings, `null` when none, `'invalid'` when malformed. */
+export function readAgentConfig(request) {
+    const raw = request.agentConfig;
+    if (raw === undefined || raw === null)
+        return null;
+    if (typeof raw !== 'object' || Array.isArray(raw))
+        return 'invalid';
+    const entries = Object.entries(raw);
+    if (entries.length > MAX_AGENT_CONFIG_ENTRIES)
+        return 'invalid';
+    const config = {};
+    for (const [id, value] of entries) {
+        if (!id || id.length > MAX_AGENT_CONFIG_TEXT)
+            return 'invalid';
+        if (typeof value !== 'string' || !value || value.length > MAX_AGENT_CONFIG_TEXT)
+            return 'invalid';
+        config[id] = value;
+    }
+    return entries.length > 0 ? config : null;
+}
+export function validateApprovalRequest(value, byteLength) {
+    if (byteLength > MAX_APPROVAL_REQUEST_BYTES)
+        return 'approval request too large';
+    if (!isMessageOfType(value, 'tool.approval.respond')) {
+        return 'invalid protocol version or type';
+    }
+    if (!isSubjectId(value.runId) ||
+        !isSubjectId(value.threadId) ||
+        typeof value.approvalId !== 'string' ||
+        !OPAQUE_ID.test(value.approvalId) ||
+        !isDeviceId(value.clientDeviceId)) {
+        return 'invalid approval ids';
+    }
+    if (typeof value.approved !== 'boolean')
+        return 'approved must be a boolean';
+    if (value.reason !== undefined &&
+        (typeof value.reason !== 'string' || value.reason.length > MAX_APPROVAL_REASON_LENGTH)) {
+        return 'invalid approval reason';
+    }
+    return null;
+}
+export function isCancelRequest(value) {
+    return (isMessageOfType(value, 'run.cancel') &&
+        isSubjectId(value.runId) &&
+        isSubjectId(value.threadId));
+}
+export function isRunStatusRequest(value) {
+    return (isMessageOfType(value, 'run.status') &&
+        isSubjectId(value.runId) &&
+        isSubjectId(value.threadId));
+}
+/** `Math.max(250, rand * min(60s, 1s * 2^attempt))`, the desktop's full-jitter backoff. */
+export function reconnectDelayMs(attempt, random = Math.random) {
+    return Math.max(250, Math.floor(random() * Math.min(60_000, 1000 * 2 ** attempt)));
+}

package/dist/gateway/runExecutor.d.ts

@@ -0,0 +1,67 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import type { RemoteDeviceRunRequest, RemoteDeviceToolApprovalAckCode } from '../vendor/electron/shared/remote-device-agent.js';
+import type { RunSnapshot } from './streamPublisher.js';
+import type { GatewayAdapter, GatewayDefinition } from './types.js';
+/** Turns waiting behind a thread's active one; more are refused as `busy`. */
+export declare const MAX_QUEUED_TURNS = 10;
+type Logger = (message: string, details?: Record<string, unknown>) => void;
+type Emit = (snapshot: RunSnapshot) => void;
+export declare class QueueFullError extends Error {
+    constructor();
+}
+export type RunExecutorDeps = {
+    db: AbstractPowerSyncDatabase;
+    userId: string;
+    gateway: GatewayDefinition;
+    adapter: GatewayAdapter;
+    log: Logger;
+};
+/**
+ * Runs accepted turns on one gateway. A thread has at most one active run;
+ * turns sent meanwhile wait in a per-thread FIFO and, when it ends, run
+ * together as one turn (each keeps its own message; the reply follows the
+ * last). The agent session is scoped to the thread's current topic: a "new
+ * topic" marker in Dinox starts a fresh agent session, everything else continues it.
+ */
+export declare class GatewayRunExecutor {
+    private readonly deps;
+    private readonly activeByThread;
+    /** The request each active run answers, for parenting turns queued behind it. */
+    private readonly activeRequests;
+    private readonly queuedByThread;
+    private queueIndex;
+    /** Accepts of one thread run one at a time, so two can never both start a turn. */
+    private readonly acceptChains;
+    constructor(deps: RunExecutorDeps);
+    /** Threads with an active or waiting turn. */
+    busyThreadIds(): string[];
+    isBusy(threadId: string): boolean;
+    /** Persists the turn, then runs it now or queues it behind the thread's active turn. */
+    accept(request: RemoteDeviceRunRequest, emit: Emit): Promise<{
+        threadCreated: boolean;
+        queued: boolean;
+    }>;
+    private acceptInOrder;
+    /** Stops the active turn, or withdraws a waiting one. */
+    cancel(runId: string, threadId: string): boolean;
+    cancelAll(): void;
+    /** A queued turn follows the last one waiting, else the reply being written. */
+    private queuedParentFor;
+    private setQueue;
+    private start;
+    /**
+     * Runs everything that waited as one turn: the agent reads the messages
+     * together, as the user meant them, instead of answering each in isolation.
+     * Earlier turns end as merged into the last, which carries the reply.
+     */
+    private drain;
+    respondApproval(input: {
+        runId: string;
+        threadId: string;
+        approvalId: string;
+        approved: boolean;
+    }): RemoteDeviceToolApprovalAckCode;
+    private execute;
+    private resolveResources;
+}
+export {};

package/dist/gateway/runExecutor.js

@@ -0,0 +1,316 @@
+import { AssistantProjection, projectPendingApprovals, toTranscriptMessage } from './assistantProjection.js';
+import { commitRunTerminal, enqueueRun, finishMergedRun, startQueuedRuns, withdrawQueuedRun, readCurrentTopicId, readSessionBinding, resolveTrustedResource, updateRunSnapshot, writeSessionBinding, } from './threadStore.js';
+import { readAgentConfig } from './protocol.js';
+const SNAPSHOT_PERSIST_INTERVAL_MS = 1_000;
+/** Turns waiting behind a thread's active one; more are refused as `busy`. */
+export const MAX_QUEUED_TURNS = 10;
+const APPROVAL_TIMEOUT_MS = 30 * 60 * 1000;
+export class QueueFullError extends Error {
+    constructor() {
+        super(`At most ${MAX_QUEUED_TURNS} messages can wait in one conversation`);
+        this.name = 'QueueFullError';
+    }
+}
+function statusForStop(stopReason) {
+    if (stopReason === 'cancelled')
+        return 'cancelled';
+    if (stopReason === 'error')
+        return 'failed';
+    return 'succeeded';
+}
+function withErrorText(message, error) {
+    return { ...message, metadata: { ...(message.metadata ?? {}), error } };
+}
+/**
+ * Runs accepted turns on one gateway. A thread has at most one active run;
+ * turns sent meanwhile wait in a per-thread FIFO and, when it ends, run
+ * together as one turn (each keeps its own message; the reply follows the
+ * last). The agent session is scoped to the thread's current topic: a "new
+ * topic" marker in Dinox starts a fresh agent session, everything else continues it.
+ */
+export class GatewayRunExecutor {
+    deps;
+    activeByThread = new Map();
+    /** The request each active run answers, for parenting turns queued behind it. */
+    activeRequests = new Map();
+    queuedByThread = new Map();
+    queueIndex = 0;
+    /** Accepts of one thread run one at a time, so two can never both start a turn. */
+    acceptChains = new Map();
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /** Threads with an active or waiting turn. */
+    busyThreadIds() {
+        return [...new Set([...this.activeByThread.keys(), ...this.queuedByThread.keys()])];
+    }
+    isBusy(threadId) {
+        return this.activeByThread.has(threadId) || this.queuedByThread.has(threadId);
+    }
+    /** Persists the turn, then runs it now or queues it behind the thread's active turn. */
+    accept(request, emit) {
+        const previous = this.acceptChains.get(request.threadId) ?? Promise.resolve();
+        const next = previous.catch(() => undefined).then(() => this.acceptInOrder(request, emit));
+        this.acceptChains.set(request.threadId, next);
+        void next
+            .catch(() => undefined)
+            .finally(() => {
+            if (this.acceptChains.get(request.threadId) === next)
+                this.acceptChains.delete(request.threadId);
+        });
+        return next;
+    }
+    async acceptInOrder(request, emit) {
+        const waiting = this.queuedByThread.get(request.threadId) ?? [];
+        const queued = this.isBusy(request.threadId);
+        if (queued && waiting.length >= MAX_QUEUED_TURNS)
+            throw new QueueFullError();
+        // Strictly increasing within this process, like the desktop's queue index.
+        this.queueIndex = Math.max(Date.now(), this.queueIndex + 1);
+        const { threadCreated } = await enqueueRun(this.deps.db, {
+            runId: request.runId,
+            threadId: request.threadId,
+            userId: this.deps.userId,
+            requestId: request.requestId,
+            userMessage: request.userMessage,
+            assistantMessage: request.assistantMessage,
+            parentMessageId: request.parentMessageId ?? null,
+            createThread: request.createThread ?? null,
+            requestPayload: { trigger: 'submit-message', gatewayId: this.deps.gateway.id, prompt: request.prompt },
+            queued,
+            queueIndex: this.queueIndex,
+            ...(queued ? { queuedAfterMessageId: this.queuedParentFor(request.threadId) } : {}),
+        });
+        // The active turn may have ended while this one was being persisted.
+        if (queued && this.isBusy(request.threadId)) {
+            this.queuedByThread.set(request.threadId, [...(this.queuedByThread.get(request.threadId) ?? []), { request, emit }]);
+            emit({ revision: 0, status: 'queued', assistant: request.assistantMessage, pendingApprovals: [] });
+            return { threadCreated, queued: true };
+        }
+        if (queued) {
+            // Persisted as queued but nothing is ahead any more: start it, dropping the marker.
+            await startQueuedRuns(this.deps.db, [request.userMessage.id]);
+        }
+        this.start(request, emit, []);
+        return { threadCreated, queued: false };
+    }
+    /** Stops the active turn, or withdraws a waiting one. */
+    cancel(runId, threadId) {
+        const active = this.activeByThread.get(threadId);
+        if (active?.runId === runId) {
+            active.controller.abort(new Error('cancelled by user'));
+            for (const approval of active.approvals.values())
+                approval.resolve(false);
+            return true;
+        }
+        const waiting = this.queuedByThread.get(threadId) ?? [];
+        const turn = waiting.find((item) => item.request.runId === runId);
+        if (!turn)
+            return false;
+        this.setQueue(threadId, waiting.filter((item) => item !== turn));
+        void withdrawQueuedRun(this.deps.db, {
+            runId,
+            userMessageId: turn.request.userMessage.id,
+            assistant: turn.request.assistantMessage,
+        })
+            .then((assistant) => turn.emit({ revision: 1, status: 'cancelled', assistant, pendingApprovals: [] }))
+            .catch((error) => this.deps.log('withdraw queued turn failed', { runId, error: String(error) }));
+        return true;
+    }
+    cancelAll() {
+        // Waiting turns are left to the next start, which marks them interrupted.
+        this.queuedByThread.clear();
+        for (const active of this.activeByThread.values())
+            this.cancel(active.runId, active.threadId);
+    }
+    /** A queued turn follows the last one waiting, else the reply being written. */
+    queuedParentFor(threadId) {
+        const waiting = this.queuedByThread.get(threadId);
+        return (waiting?.at(-1)?.request.userMessage.id ?? this.activeRequests.get(threadId)?.assistantMessage.id);
+    }
+    setQueue(threadId, turns) {
+        if (turns.length > 0)
+            this.queuedByThread.set(threadId, turns);
+        else
+            this.queuedByThread.delete(threadId);
+    }
+    start(request, emit, merged) {
+        const active = {
+            runId: request.runId,
+            threadId: request.threadId,
+            controller: new AbortController(),
+            approvals: new Map(),
+            answered: new Set(),
+        };
+        this.activeByThread.set(request.threadId, active);
+        this.activeRequests.set(request.threadId, request);
+        void this.execute(request, active, emit, merged).finally(() => {
+            if (this.activeByThread.get(request.threadId) === active) {
+                this.activeByThread.delete(request.threadId);
+                this.activeRequests.delete(request.threadId);
+            }
+            void this.drain(request.threadId).catch((error) => this.deps.log('start queued turns failed', { threadId: request.threadId, error: String(error) }));
+        });
+    }
+    /**
+     * Runs everything that waited as one turn: the agent reads the messages
+     * together, as the user meant them, instead of answering each in isolation.
+     * Earlier turns end as merged into the last, which carries the reply.
+     */
+    async drain(threadId) {
+        if (this.activeByThread.has(threadId))
+            return;
+        const waiting = this.queuedByThread.get(threadId) ?? [];
+        this.queuedByThread.delete(threadId);
+        const last = waiting.at(-1);
+        if (!last)
+            return;
+        const earlier = waiting.slice(0, -1);
+        await startQueuedRuns(this.deps.db, waiting.map((turn) => turn.request.userMessage.id));
+        for (const turn of earlier) {
+            const assistant = await finishMergedRun(this.deps.db, {
+                runId: turn.request.runId,
+                mergedIntoRunId: last.request.runId,
+                assistant: turn.request.assistantMessage,
+            });
+            turn.emit({ revision: 1, status: 'succeeded', assistant, pendingApprovals: [] });
+        }
+        this.start(last.request, last.emit, earlier.map((turn) => turn.request));
+    }
+    respondApproval(input) {
+        const active = this.activeByThread.get(input.threadId);
+        if (!active || active.runId !== input.runId)
+            return 'stale';
+        if (active.answered.has(input.approvalId))
+            return 'already_applied';
+        const pending = active.approvals.get(input.approvalId);
+        if (!pending)
+            return 'stale';
+        pending.resolve(input.approved);
+        return 'applied';
+    }
+    async execute(request, active, emit, 
+    /** Earlier queued turns answered together with this one. */
+    merged) {
+        const { db, gateway, adapter, log } = this.deps;
+        const projection = new AssistantProjection(request.assistantMessage);
+        let status = 'running';
+        let lastPersistedAt = 0;
+        const publish = (persist) => {
+            const assistant = projection.snapshot();
+            emit({
+                revision: projection.revision,
+                status,
+                assistant,
+                pendingApprovals: projectPendingApprovals(assistant, { runId: active.runId, threadId: active.threadId }),
+            });
+            const now = Date.now();
+            if (persist || now - lastPersistedAt >= SNAPSHOT_PERSIST_INTERVAL_MS) {
+                lastPersistedAt = now;
+                void updateRunSnapshot(db, { runId: active.runId, status, assistant }).catch((error) => log('persist run snapshot failed', { runId: active.runId, error: String(error) }));
+            }
+        };
+        // Registered when the approval request is emitted, so a reply that races
+        // ahead of the adapter's await is still applied.
+        const decisions = new Map();
+        const registerApproval = (approvalId) => {
+            const existing = decisions.get(approvalId);
+            if (existing)
+                return existing;
+            const decision = new Promise((resolve) => {
+                const finish = (approved) => {
+                    clearTimeout(timer);
+                    active.approvals.delete(approvalId);
+                    active.answered.add(approvalId);
+                    status = active.approvals.size > 0 ? 'waiting_approval' : 'running';
+                    resolve(approved);
+                };
+                const timer = setTimeout(() => finish(false), APPROVAL_TIMEOUT_MS);
+                active.approvals.set(approvalId, { resolve: finish, timer });
+                if (active.controller.signal.aborted)
+                    finish(false);
+            });
+            decisions.set(approvalId, decision);
+            return decision;
+        };
+        const awaitApproval = registerApproval;
+        let errorText = null;
+        try {
+            publish(true);
+            const [topicId, binding] = await Promise.all([
+                readCurrentTopicId(db, active.threadId),
+                readSessionBinding(db, active.threadId),
+            ]);
+            const sessionId = binding && binding.gatewayId === gateway.id && binding.topicId === topicId ? binding.sessionId : null;
+            const turns = [...merged, request];
+            const resources = (await Promise.all(turns.map((turn) => this.resolveResources(turn.userMessage)))).flat();
+            // Validated on receipt; a malformed value never reaches here.
+            const requestedConfig = readAgentConfig(request);
+            const agentConfig = requestedConfig && requestedConfig !== 'invalid' ? requestedConfig : undefined;
+            const result = await adapter.runTurn({
+                sessionId,
+                prompt: turns.map((turn) => turn.prompt.trim()).filter(Boolean).join('\n\n'),
+                resources,
+                signal: active.controller.signal,
+                config: agentConfig,
+                awaitApproval,
+                onEvent: (event) => {
+                    projection.apply(event);
+                    if (event.type === 'approval-request') {
+                        void registerApproval(event.approvalId);
+                        status = 'waiting_approval';
+                    }
+                    publish(event.type === 'approval-request' || event.type === 'approval-resolved');
+                },
+            });
+            if (result.sessionId !== sessionId) {
+                await writeSessionBinding(db, active.threadId, { sessionId: result.sessionId, topicId, gatewayId: gateway.id });
+            }
+            status = statusForStop(result.stopReason);
+            errorText = result.error ?? null;
+        }
+        catch (error) {
+            status = active.controller.signal.aborted ? 'cancelled' : 'failed';
+            errorText = error instanceof Error ? error.message : String(error);
+            log('gateway run failed', { runId: active.runId, error: errorText });
+        }
+        finally {
+            for (const approval of active.approvals.values())
+                clearTimeout(approval.timer);
+        }
+        projection.finish();
+        const assistant = errorText ? withErrorText(projection.snapshot(), errorText) : projection.snapshot();
+        try {
+            await commitRunTerminal(db, {
+                runId: active.runId,
+                threadId: active.threadId,
+                userId: this.deps.userId,
+                userMessageId: request.userMessage.id,
+                status,
+                assistant: toTranscriptMessage(assistant),
+                errorText,
+            });
+        }
+        catch (error) {
+            log('commit run terminal failed', { runId: active.runId, error: String(error) });
+        }
+        emit({ revision: projection.revision, status, assistant, pendingApprovals: [] });
+    }
+    async resolveResources(message) {
+        const resources = [];
+        for (const part of message.parts) {
+            if (part.type !== 'file')
+                continue;
+            const dinox = part.providerMetadata?.dinox;
+            if (typeof dinox?.resourceId !== 'string')
+                continue;
+            const resource = await resolveTrustedResource(this.deps.db, {
+                resourceId: dinox.resourceId,
+                userId: this.deps.userId,
+            });
+            if (resource)
+                resources.push({ uri: resource.url, name: resource.name, mediaType: resource.mediaType });
+        }
+        return resources;
+    }
+}

package/dist/gateway/service.d.ts

@@ -0,0 +1,26 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import { type DeviceHostStatus } from './deviceHost.js';
+type Logger = (message: string, details?: Record<string, unknown>) => void;
+export type GatewayServiceDeps = {
+    db: AbstractPowerSyncDatabase;
+    userId: string;
+    authorization: string;
+    log?: Logger;
+    credentialsUrl?: string;
+};
+/**
+ * Runs every enabled gateway inside the daemon: the daemon owns the PowerSync
+ * database, so gateway writes share its connection and upload queue.
+ */
+export declare class GatewayService {
+    private readonly deps;
+    private hosts;
+    private readonly log;
+    constructor(deps: GatewayServiceDeps);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /** Re-reads the account's gateways (after add/remove) without restarting the daemon. */
+    reload(): Promise<DeviceHostStatus[]>;
+    status(): DeviceHostStatus[];
+}
+export {};

package/dist/gateway/service.js

@@ -0,0 +1,82 @@
+import os from 'node:os';
+import { getPackageVersion } from '../utils/version.js';
+import { createGatewayAdapter } from './adapters/index.js';
+import { getMachineId, loadGateways } from './config.js';
+import { GatewayDeviceHost } from './deviceHost.js';
+import { interruptOrphanedRuns, retireRemovedRobots, upsertRobot } from './threadStore.js';
+const defaultLog = (message, details) => {
+    process.stderr.write(`[dinox-gateway] ${message}${details ? ` ${JSON.stringify(details)}` : ''}\n`);
+};
+/**
+ * Runs every enabled gateway inside the daemon: the daemon owns the PowerSync
+ * database, so gateway writes share its connection and upload queue.
+ */
+export class GatewayService {
+    deps;
+    hosts = [];
+    log;
+    constructor(deps) {
+        this.deps = deps;
+        this.log = deps.log ?? defaultLog;
+    }
+    async start() {
+        const configured = await loadGateways(this.deps.userId);
+        const machineId = await getMachineId();
+        // Reconcile before anything else, also when the last gateway was removed.
+        const retired = await retireRemovedRobots(this.deps.db, {
+            userId: this.deps.userId,
+            machineId,
+            keepIds: configured.map((gateway) => gateway.id),
+        }).catch((error) => {
+            this.log('retire removed robots failed', { error: String(error) });
+            return [];
+        });
+        if (retired.length > 0)
+            this.log('retired robots of removed gateways', { count: retired.length });
+        const gateways = configured.filter((gateway) => gateway.enabled);
+        if (gateways.length === 0)
+            return;
+        const interrupted = await interruptOrphanedRuns(this.deps.db, this.deps.userId);
+        if (interrupted > 0)
+            this.log('marked runs from a previous host as interrupted', { count: interrupted });
+        for (const gateway of gateways) {
+            await upsertRobot(this.deps.db, {
+                id: gateway.id,
+                userId: this.deps.userId,
+                name: gateway.name,
+                deviceId: gateway.deviceId,
+                agentType: gateway.kind,
+                cwd: gateway.cwd ?? null,
+                deviceName: os.hostname(),
+                machineId,
+                ...(gateway.agentId ? { agentId: gateway.agentId } : {}),
+            }).catch((error) => this.log('register robot failed', { gateway: gateway.name, error: String(error) }));
+            const host = new GatewayDeviceHost({
+                gateway,
+                db: this.deps.db,
+                userId: this.deps.userId,
+                authorization: this.deps.authorization,
+                adapter: createGatewayAdapter(gateway, (message, details) => this.log(message, { gateway: gateway.name, ...details })),
+                appVersion: getPackageVersion(),
+                log: (message, details) => this.log(message, { gateway: gateway.name, ...details }),
+                credentialsUrl: this.deps.credentialsUrl,
+            });
+            host.start();
+            this.hosts.push(host);
+        }
+    }
+    async stop() {
+        const hosts = this.hosts;
+        this.hosts = [];
+        await Promise.allSettled(hosts.map((host) => host.stop()));
+    }
+    /** Re-reads the account's gateways (after add/remove) without restarting the daemon. */
+    async reload() {
+        await this.stop();
+        await this.start();
+        return this.status();
+    }
+    status() {
+        return this.hosts.map((host) => host.status());
+    }
+}

package/dist/gateway/streamPublisher.d.ts

@@ -0,0 +1,33 @@
+import type { ChatUIMessage, ThreadRunEventStatus } from '../vendor/electron/shared/external-types.js';
+import { type RemoteDeviceRunStreamEvent, type RemoteToolApprovalPrompt } from '../vendor/electron/shared/remote-device-agent.js';
+export type RunSnapshot = {
+    revision: number;
+    status: ThreadRunEventStatus;
+    assistant: ChatUIMessage;
+    pendingApprovals: RemoteToolApprovalPrompt[];
+};
+/**
+ * Keeps an event under the NATS payload budget: drop parts (the snapshot is
+ * self-correcting and `run.status` recovers the rest), then drop extras.
+ */
+export declare function boundRunEvent(event: RemoteDeviceRunStreamEvent): RemoteDeviceRunStreamEvent;
+/**
+ * One per run. Streaming snapshots are coalesced to the latest per 100ms;
+ * approval and terminal states go out immediately (and supersede a pending one).
+ */
+export declare class RunStreamPublisher {
+    private readonly ids;
+    private readonly publish;
+    private sequence;
+    private pending;
+    private timer;
+    private disposed;
+    constructor(ids: {
+        runId: string;
+        threadId: string;
+    }, publish: (event: RemoteDeviceRunStreamEvent) => void);
+    push(snapshot: RunSnapshot): void;
+    dispose(): void;
+    private clearTimer;
+    private emit;
+}