@dinoxx/dinox-cli 2.3.0 → 2.5.2

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,222 @@
+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>;
+/**
+ * One gateway's agent session on a thread, scoped to the thread's topic when it
+ * started. The thread can switch agents, so every gateway keeps its own session
+ * and remembers the last transcript message it saw.
+ */
+export type GatewaySessionBinding = {
+    sessionId: string;
+    topicId: string | null;
+    /** Newest transcript message the session has seen; null when it has seen nothing of the topic yet. */
+    lastSeenMessageId: string | null;
+    /** Directory the session works in; absent for bindings written before it was recorded. */
+    cwd?: string;
+    /** Written before seen messages were tracked: the session is assumed to be up to date. */
+    legacy?: true;
+};
+export declare function readSessionBinding(db: Tx, threadId: string, gatewayId: string): Promise<GatewaySessionBinding | null>;
+/** Replaces this gateway's binding and keeps every other gateway's. */
+export declare function writeSessionBinding(db: AbstractPowerSyncDatabase, threadId: string, gatewayId: string, binding: GatewaySessionBinding): Promise<void>;
+/** Directories this gateway's sessions worked in, most recently used first. */
+export declare function readRecentSessionFolders(db: Tx, gatewayId: string, limit?: number): Promise<string[]>;
+/** The instructions the user wrote for the thread's agent (`c_project.agent_md`); empty when none. */
+export declare function readAgentInstructions(db: Tx, threadId: string): Promise<string>;
+/**
+ * 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; like the app, it covers rows written after the marker.
+ */
+export declare function readCurrentTopic(db: Tx, threadId: string): Promise<{
+    id: string;
+    createdAt: string | null;
+} | null>;
+/** Marks a reply with the agent session that wrote it (`metadata.gateway`). */
+export declare function withGatewaySession(message: ChatUIMessage, gateway: {
+    gatewayId: string;
+    sessionId: string;
+}): ChatUIMessage;
+/**
+ * Waits until a message exists in the local replica (deleted or not), e.g. the
+ * last message the client saw before sending a turn. False when it has not
+ * synced within the timeout or the wait was aborted.
+ */
+export declare function waitForMessage(db: Tx, messageId: string, options: {
+    timeoutMs: number;
+    signal?: AbortSignal;
+}): Promise<boolean>;
+/** A transcript message reduced to what another agent needs: who said what. */
+export type TranscriptMessage = {
+    id: string;
+    role: 'user' | 'assistant';
+    /** The answering agent's name; null for the user or an unknown agent. */
+    speaker: string | null;
+    text: string;
+    createdAt: string | null;
+};
+/**
+ * The newest transcript messages in a window, oldest first, with how many
+ * matching messages lie before the page. Bounds are exclusive: `since` is a
+ * topic start (by `created_at`, as the app scopes topics), `afterMessageId` and
+ * `beforeMessageId` are transcript positions; an id that no longer exists is no bound.
+ */
+export declare function readTranscriptPage(db: Tx, input: {
+    threadId: string;
+    since?: string | null;
+    afterMessageId?: string | null;
+    beforeMessageId?: string | null;
+    /** Leaves out the turns this agent session answered itself (its replies and their prompts). */
+    excludeSessionId?: string | null;
+    limit: number;
+}): Promise<{
+    messages: TranscriptMessage[];
+    earlier: number;
+}>;
+/** 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;
+    /** Owner-facing settings, synced so the app can show them while the computer is offline. */
+    settings?: RobotSettings;
+};
+export type RobotSettings = {
+    approval: 'ask' | 'auto_read';
+    paused: boolean;
+    dinoxTools: boolean;
+};
+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 {};