@dinoxx/dinox-cli 2.2.0 → 2.4.0

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;
+}

package/dist/gateway/streamPublisher.js

@@ -0,0 +1,93 @@
+import { REMOTE_DEVICE_MAX_EVENT_BYTES, REMOTE_DEVICE_PROTOCOL_VERSION, } from '../vendor/electron/shared/remote-device-agent.js';
+import { TERMINAL_RUN_STATUSES } from './threadStore.js';
+const COALESCE_MS = 100;
+const MAX_APPROVALS = 32;
+function byteLength(value) {
+    return Buffer.byteLength(JSON.stringify(value), 'utf8');
+}
+/**
+ * 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 function boundRunEvent(event) {
+    if (byteLength(event) <= REMOTE_DEVICE_MAX_EVENT_BYTES)
+        return event;
+    const metadata = event.assistant.message.metadata ?? {};
+    const stripped = {
+        ...event,
+        assistant: {
+            message: {
+                ...event.assistant.message,
+                parts: [],
+                metadata: { status: metadata.status, runId: metadata.runId },
+            },
+            truncated: true,
+        },
+        pendingApprovals: event.pendingApprovals?.slice(0, MAX_APPROVALS),
+    };
+    if (byteLength(stripped) <= REMOTE_DEVICE_MAX_EVENT_BYTES)
+        return stripped;
+    const minimal = { ...stripped, pendingApprovals: [], usage: null };
+    if (byteLength(minimal) <= REMOTE_DEVICE_MAX_EVENT_BYTES)
+        return minimal;
+    throw new Error('run.event exceeds the remote-device payload limit');
+}
+/**
+ * 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 class RunStreamPublisher {
+    ids;
+    publish;
+    sequence = 0;
+    pending = null;
+    timer = null;
+    disposed = false;
+    constructor(ids, publish) {
+        this.ids = ids;
+        this.publish = publish;
+    }
+    push(snapshot) {
+        if (this.disposed)
+            return;
+        if (TERMINAL_RUN_STATUSES.has(snapshot.status) || snapshot.status === 'waiting_approval') {
+            this.clearTimer();
+            this.pending = null;
+            this.emit(snapshot);
+            return;
+        }
+        this.pending = snapshot;
+        this.timer ??= setTimeout(() => {
+            this.timer = null;
+            const latest = this.pending;
+            this.pending = null;
+            if (latest)
+                this.emit(latest);
+        }, COALESCE_MS);
+    }
+    dispose() {
+        this.disposed = true;
+        this.clearTimer();
+        this.pending = null;
+    }
+    clearTimer() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+    }
+    emit(snapshot) {
+        this.sequence += 1;
+        this.publish(boundRunEvent({
+            protocolVersion: REMOTE_DEVICE_PROTOCOL_VERSION,
+            type: 'run.event',
+            runId: this.ids.runId,
+            threadId: this.ids.threadId,
+            sequence: this.sequence,
+            emittedAt: new Date().toISOString(),
+            revision: snapshot.revision,
+            status: snapshot.status,
+            assistant: { message: snapshot.assistant },
+            pendingApprovals: snapshot.pendingApprovals,
+        }));
+    }
+}

package/dist/gateway/threadStore.d.ts

@@ -0,0 +1,157 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import type { ChatUIMessage, ThreadRunCreateThreadRequest, ThreadRunEventStatus } from '../vendor/electron/shared/external-types.js';
+/**
+ * Persistence for gateway runs, written exactly like Dinox desktop's remote host
+ * (dinox-electron ThreadRunQueueService / ThreadRunCoordinatorHelpers) so every
+ * client reads identical rows:
+ * - the user message is written when the run is accepted;
+ * - live progress stays in the local-only `local_thread_run` snapshot;
+ * - the assistant message lands in `c_chat_message` once, when the run ends.
+ */
+type Tx = Pick<AbstractPowerSyncDatabase, 'execute' | 'getOptional' | 'getAll'>;
+export declare const TERMINAL_RUN_STATUSES: ReadonlySet<ThreadRunEventStatus>;
+export type StoredRun = {
+    id: string;
+    threadId: string;
+    status: ThreadRunEventStatus;
+    requestId: string | null;
+    assistant: ChatUIMessage | null;
+    updatedAt: string | null;
+};
+/** Mirrors desktop `withRunMetadata`: the UI reads `metadata.status` for streaming state. */
+export declare function withRunMetadata(message: ChatUIMessage, runId: string, status: ThreadRunEventStatus): ChatUIMessage;
+/**
+ * Synced queue marker on a user message (`metadata.queue`), shared by every
+ * client: the run that answers it has not started yet. It lives on the synced
+ * message because run rows (`local_thread_run`) are local to one process, so
+ * other devices could not otherwise show the queue. Removed when the run starts.
+ */
+export type MessageQueueMarker = {
+    state: 'queued' | 'withdrawn';
+    runId: string;
+    executor: 'gateway';
+    queuedAt: string;
+};
+/** The answering run merged this turn into a later one; it never gets its own reply. */
+export declare function withMergedInto(message: ChatUIMessage, mergedIntoRunId: string): ChatUIMessage;
+/** Next `order_index` after `parentId` (midpoint before its next sibling) or at the end. */
+export declare function resolveNextOrderIndex(tx: Tx, input: {
+    threadId: string;
+    parentId: string | null;
+}): Promise<number>;
+export declare function threadExists(db: Tx, threadId: string, userId: string): Promise<boolean>;
+export type EnqueueRunInput = {
+    runId: string;
+    threadId: string;
+    userId: string;
+    requestId: string;
+    userMessage: ChatUIMessage;
+    assistantMessage: ChatUIMessage;
+    parentMessageId: string | null;
+    createThread: ThreadRunCreateThreadRequest | null;
+    requestPayload: Record<string, unknown>;
+    /** Waits behind another turn of the same thread: marks the user message as queued. */
+    queued: boolean;
+    /** FIFO order within the thread. */
+    queueIndex: number;
+    /**
+     * Parent of a queued turn: the reply still being written, or the turn queued
+     * just before it. Absent for a turn that runs now, which follows the thread's
+     * last message.
+     */
+    queuedAfterMessageId?: string;
+};
+/** Persists the accepted turn atomically: thread (if new), user message, queued run. */
+export declare function enqueueRun(db: AbstractPowerSyncDatabase, input: EnqueueRunInput): Promise<{
+    threadCreated: boolean;
+}>;
+/** Live progress for `run.status` recovery; never touches synced tables. */
+export declare function updateRunSnapshot(db: Tx, input: {
+    runId: string;
+    status: ThreadRunEventStatus;
+    assistant: ChatUIMessage;
+}): Promise<void>;
+/** Ends the run and writes the final assistant message into the synced transcript. */
+export declare function commitRunTerminal(db: AbstractPowerSyncDatabase, input: {
+    runId: string;
+    threadId: string;
+    userId: string;
+    userMessageId: string;
+    status: ThreadRunEventStatus;
+    assistant: ChatUIMessage;
+    errorText: string | null;
+}): Promise<void>;
+export declare function findRun(db: Tx, input: {
+    runId: string;
+    userId: string;
+}): Promise<StoredRun | null>;
+/** The queued turns start now: their messages stop showing as queued. */
+export declare function startQueuedRuns(db: AbstractPowerSyncDatabase, userMessageIds: string[]): Promise<void>;
+/** Ends a queued turn that was merged into a later one: no reply of its own is written. */
+export declare function finishMergedRun(db: Tx, input: {
+    runId: string;
+    mergedIntoRunId: string;
+    assistant: ChatUIMessage;
+}): Promise<ChatUIMessage>;
+/**
+ * The user took a queued turn back before it ran: the run is cancelled and its
+ * message removed from the transcript (marked `withdrawn` so other devices can
+ * tell a withdrawal from a deletion).
+ */
+export declare function withdrawQueuedRun(db: AbstractPowerSyncDatabase, input: {
+    runId: string;
+    userMessageId: string;
+    assistant: ChatUIMessage;
+}): Promise<ChatUIMessage>;
+/** Runs left non-terminal by a previous process can never finish; mark them interrupted. */
+export declare function interruptOrphanedRuns(db: Tx, userId: string): Promise<number>;
+/** Agent session bound to a thread, scoped to the thread's current topic. */
+export type GatewaySessionBinding = {
+    sessionId: string;
+    topicId: string | null;
+    gatewayId: string;
+};
+export declare function readSessionBinding(db: Tx, threadId: string): Promise<GatewaySessionBinding | null>;
+export declare function writeSessionBinding(db: Tx, threadId: string, binding: GatewaySessionBinding): Promise<void>;
+/**
+ * The thread's current topic: the latest "new topic" marker the app wrote
+ * (`entry_type = 'internal'`, `meta_data.kind = 'context_reset'`). A new topic
+ * starts a fresh agent session.
+ */
+export declare function readCurrentTopicId(db: Tx, threadId: string): Promise<string | null>;
+/** File parts resolve only to resources this user owns with an https storage URL. */
+export declare function resolveTrustedResource(db: Tx, input: {
+    resourceId: string;
+    userId: string;
+}): Promise<{
+    url: string;
+    name: string;
+    mediaType: string | null;
+} | null>;
+/** Registers the gateway as a `c_robot` the app can list and bind agents to (no secrets). */
+export type RobotRegistration = {
+    id: string;
+    userId: string;
+    name: string;
+    deviceId: string;
+    agentType: string;
+    cwd: string | null;
+    /** This machine's hostname, shown with the robot. */
+    deviceName: string;
+    /** Marks the robot as hosted by this installation, for reconciliation. */
+    machineId: string;
+    agentId?: string;
+};
+export declare function upsertRobot(db: Tx, input: RobotRegistration): Promise<void>;
+/**
+ * Soft-deletes this machine's gateway robots that are no longer configured
+ * (removed, or replaced before ids were deterministic), so the app never
+ * offers an agent that nothing hosts. Robots from other machines are untouched.
+ */
+export declare function retireRemovedRobots(db: Tx, input: {
+    userId: string;
+    machineId: string;
+    keepIds: string[];
+}): Promise<string[]>;
+export declare function softDeleteRobot(db: Tx, robotId: string): Promise<void>;
+export {};