@dinoxx/dinox-cli 2.2.0 → 2.4.0

package/dist/gateway/deviceHost.d.ts

@@ -0,0 +1,82 @@
+import { wsconnect } from '@nats-io/nats-core';
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import type { GatewayAdapter, GatewayDefinition } from './types.js';
+export declare const DEFAULT_NATS_CREDENTIALS_URL = "https://aisdk.chatgo.pro/api/nats/credentials";
+type Logger = (message: string, details?: Record<string, unknown>) => void;
+export type DeviceHostState = 'idle' | 'connecting' | 'connected' | 'reconnecting' | 'error';
+export type DeviceHostStatus = {
+    gatewayId: string;
+    name: string;
+    deviceId: string;
+    kind: string;
+    state: DeviceHostState;
+    connectedAt: string | null;
+    lastError: string | null;
+    busyThreadIds: string[];
+    agentName: string | null;
+};
+export type DeviceHostDeps = {
+    gateway: GatewayDefinition;
+    db: AbstractPowerSyncDatabase;
+    userId: string;
+    authorization: string;
+    adapter: GatewayAdapter;
+    appVersion: string;
+    log: Logger;
+    credentialsUrl?: string;
+    connect?: typeof wsconnect;
+    fetchImpl?: typeof fetch;
+};
+/**
+ * Hosts one gateway as a `dinox.remote-device.v2` device over NATS, the same
+ * contract Dinox desktop serves, so the app drives it with no client changes.
+ * Each gateway is its own device id (the credential service scopes a desktop
+ * credential to a single device subtree).
+ */
+export declare class GatewayDeviceHost {
+    private readonly deps;
+    private readonly executor;
+    private connection;
+    private subscriptions;
+    private userNo;
+    private state;
+    private connectedAt;
+    private lastError;
+    private generation;
+    private attempt;
+    private presenceSequence;
+    private presenceTimer;
+    private refreshTimer;
+    private reconnectTimer;
+    private stopped;
+    private retryBlocked;
+    private readonly ackCache;
+    /** Latest event per run while offline; the snapshot model makes older ones redundant. */
+    private readonly pendingEvents;
+    constructor(deps: DeviceHostDeps);
+    start(): void;
+    stop(): Promise<void>;
+    status(): DeviceHostStatus;
+    private connect;
+    private watchConnection;
+    private scheduleReconnect;
+    /** Short-lived credentials: reconnect with fresh ones before they expire (runs keep going). */
+    private scheduleCredentialRefresh;
+    private disconnect;
+    private fetchCredentials;
+    private deviceInfo;
+    private subscribe;
+    private publishPresence;
+    private publishRunEvent;
+    private flushPendingEvents;
+    private handleDiscover;
+    /** Only the gateway's own query is served; desktop queries (skills, workspace) are not advertised. */
+    private handleQuery;
+    private handleInfo;
+    private respondAck;
+    private cacheAck;
+    private handleRunRequest;
+    private handleCancel;
+    private handleApprove;
+}
+export {};

package/dist/gateway/deviceHost.js

@@ -0,0 +1,530 @@
+import os from 'node:os';
+import { credsAuthenticator, wsconnect, } from '@nats-io/nats-core';
+import { toAuthorizationHeaderValue } from '../utils/authToken.js';
+import { REMOTE_DEVICE_PRESENCE_INTERVAL_MS, REMOTE_DEVICE_PROTOCOL_NAME, REMOTE_DEVICE_PROTOCOL_VERSION, remoteDeviceSubject, remoteDiscoverSubject, remotePresenceSubject, remoteRunStreamSubject, } from '../vendor/electron/shared/remote-device-agent.js';
+import { projectPendingApprovals } from './assistantProjection.js';
+import { isAgentConfigQuery, isCancelRequest, isRunStatusRequest, reconnectDelayMs, validateApprovalRequest, validateRunRequest, } from './protocol.js';
+import { GatewayRunExecutor, MAX_QUEUED_TURNS, QueueFullError } from './runExecutor.js';
+import { RunStreamPublisher } from './streamPublisher.js';
+import { findRun, resolveTrustedResource, TERMINAL_RUN_STATUSES, threadExists } from './threadStore.js';
+export const DEFAULT_NATS_CREDENTIALS_URL = 'https://aisdk.chatgo.pro/api/nats/credentials';
+const CREDENTIALS_TIMEOUT_MS = 10_000;
+const CREDENTIALS_REFRESH_LEAD_MS = 60_000;
+const ACK_CACHE_TTL_MS = 10 * 60 * 1000;
+const ACK_CACHE_MAX = 1000;
+const DRAIN_TIMEOUT_MS = 3_000;
+class CredentialsHttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+const encoder = new TextEncoder();
+function encode(value) {
+    return encoder.encode(JSON.stringify(value));
+}
+function decode(msg) {
+    try {
+        return { value: msg.json(), byteLength: msg.data.byteLength };
+    }
+    catch {
+        return { value: null, byteLength: msg.data.byteLength };
+    }
+}
+/**
+ * Hosts one gateway as a `dinox.remote-device.v2` device over NATS, the same
+ * contract Dinox desktop serves, so the app drives it with no client changes.
+ * Each gateway is its own device id (the credential service scopes a desktop
+ * credential to a single device subtree).
+ */
+export class GatewayDeviceHost {
+    deps;
+    executor;
+    connection = null;
+    subscriptions = [];
+    userNo = null;
+    state = 'idle';
+    connectedAt = null;
+    lastError = null;
+    generation = 0;
+    attempt = 0;
+    presenceSequence = 0;
+    presenceTimer = null;
+    refreshTimer = null;
+    reconnectTimer = null;
+    stopped = false;
+    retryBlocked = false;
+    ackCache = new Map();
+    /** Latest event per run while offline; the snapshot model makes older ones redundant. */
+    pendingEvents = new Map();
+    constructor(deps) {
+        this.deps = deps;
+        this.executor = new GatewayRunExecutor({
+            db: deps.db,
+            userId: deps.userId,
+            gateway: deps.gateway,
+            adapter: deps.adapter,
+            log: deps.log,
+        });
+    }
+    start() {
+        this.stopped = false;
+        void this.connect();
+    }
+    async stop() {
+        this.stopped = true;
+        this.executor.cancelAll();
+        await this.disconnect({ publishOffline: true });
+        await this.deps.adapter.dispose();
+        this.state = 'idle';
+    }
+    status() {
+        return {
+            gatewayId: this.deps.gateway.id,
+            name: this.deps.gateway.name,
+            deviceId: this.deps.gateway.deviceId,
+            kind: this.deps.gateway.kind,
+            state: this.state,
+            connectedAt: this.connectedAt,
+            lastError: this.lastError,
+            busyThreadIds: this.executor.busyThreadIds(),
+            agentName: this.deps.adapter.info().agentName,
+        };
+    }
+    // ---- connection lifecycle -------------------------------------------------
+    async connect() {
+        if (this.stopped || this.retryBlocked)
+            return;
+        const generation = ++this.generation;
+        this.state = this.attempt > 0 ? 'reconnecting' : 'connecting';
+        try {
+            const credentials = await this.fetchCredentials();
+            if (generation !== this.generation || this.stopped)
+                return;
+            const connection = await (this.deps.connect ?? wsconnect)({
+                servers: credentials.url,
+                authenticator: credsAuthenticator(encoder.encode(credentials.credentials)),
+                inboxPrefix: credentials.inboxPrefix,
+                name: `dinox-gateway-${this.deps.gateway.deviceId}`,
+                noEcho: true,
+                maxReconnectAttempts: -1,
+                reconnectDelayHandler: () => reconnectDelayMs(this.attempt++),
+                timeout: CREDENTIALS_TIMEOUT_MS,
+            });
+            if (generation !== this.generation || this.stopped) {
+                await connection.close();
+                return;
+            }
+            this.connection = connection;
+            this.userNo = credentials.userNo;
+            this.attempt = 0;
+            this.state = 'connected';
+            this.connectedAt = new Date().toISOString();
+            this.lastError = null;
+            this.subscribe(connection, credentials.userNo);
+            this.publishPresence('online');
+            this.flushPendingEvents();
+            this.presenceTimer = setInterval(() => this.publishPresence('online'), REMOTE_DEVICE_PRESENCE_INTERVAL_MS);
+            this.scheduleCredentialRefresh(credentials.expiresAt, generation);
+            void this.watchConnection(connection, generation);
+            this.deps.log('gateway device online', { gateway: this.deps.gateway.name, deviceId: this.deps.gateway.deviceId });
+        }
+        catch (error) {
+            if (generation !== this.generation)
+                return;
+            this.state = 'error';
+            this.lastError = error instanceof Error ? error.message : String(error);
+            if (error instanceof CredentialsHttpError && error.status !== 429 && error.status < 500) {
+                // Auth or request errors will not heal on retry; wait for a reload.
+                this.retryBlocked = true;
+                this.deps.log('gateway credentials rejected', { status: error.status, error: this.lastError });
+                return;
+            }
+            this.scheduleReconnect();
+        }
+    }
+    async watchConnection(connection, generation) {
+        const error = await connection.closed();
+        if (generation !== this.generation || this.stopped)
+            return;
+        this.lastError = error instanceof Error ? error.message : 'connection closed';
+        await this.disconnect({ publishOffline: false });
+        this.scheduleReconnect();
+    }
+    scheduleReconnect() {
+        if (this.stopped || this.reconnectTimer)
+            return;
+        this.state = 'reconnecting';
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            void this.connect();
+        }, reconnectDelayMs(this.attempt++));
+    }
+    /** Short-lived credentials: reconnect with fresh ones before they expire (runs keep going). */
+    scheduleCredentialRefresh(expiresAt, generation) {
+        const expiresAtMs = Date.parse(expiresAt);
+        const delay = Number.isFinite(expiresAtMs) ? Math.max(1_000, expiresAtMs - Date.now() - CREDENTIALS_REFRESH_LEAD_MS) : 60_000;
+        this.refreshTimer = setTimeout(() => {
+            if (generation !== this.generation || this.stopped)
+                return;
+            void this.disconnect({ publishOffline: false }).then(() => this.connect());
+        }, delay);
+    }
+    async disconnect(options) {
+        this.generation += 1;
+        for (const timer of [this.presenceTimer, this.refreshTimer, this.reconnectTimer]) {
+            if (timer)
+                clearTimeout(timer);
+        }
+        this.presenceTimer = this.refreshTimer = this.reconnectTimer = null;
+        const connection = this.connection;
+        this.connection = null;
+        for (const subscription of this.subscriptions)
+            subscription.unsubscribe();
+        this.subscriptions = [];
+        if (!connection)
+            return;
+        if (options.publishOffline)
+            this.publishPresence('offline', connection);
+        await Promise.race([
+            connection.drain().catch(() => undefined),
+            new Promise((resolve) => setTimeout(resolve, DRAIN_TIMEOUT_MS)),
+        ]);
+        await connection.close().catch(() => undefined);
+    }
+    async fetchCredentials() {
+        const fetchImpl = this.deps.fetchImpl ?? fetch;
+        const response = await fetchImpl(this.deps.credentialsUrl ?? DEFAULT_NATS_CREDENTIALS_URL, {
+            method: 'POST',
+            headers: {
+                Authorization: toAuthorizationHeaderValue(this.deps.authorization),
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+            },
+            body: JSON.stringify({ deviceId: this.deps.gateway.deviceId, role: 'desktop' }),
+            signal: AbortSignal.timeout(CREDENTIALS_TIMEOUT_MS),
+        });
+        const envelope = (await response.json().catch(() => null));
+        if (!response.ok || envelope?.code !== '000000' || !envelope.data) {
+            throw new CredentialsHttpError(response.status, envelope?.msg ?? `credentials request failed (${response.status})`);
+        }
+        const data = envelope.data;
+        if (data.role !== 'desktop' || data.deviceId !== this.deps.gateway.deviceId) {
+            throw new Error('credentials do not match this gateway device');
+        }
+        if (data.userNo !== this.deps.userId.trim().toLowerCase()) {
+            throw new CredentialsHttpError(403, 'credentials belong to another account');
+        }
+        return data;
+    }
+    // ---- protocol ---------------------------------------------------------------
+    deviceInfo() {
+        const adapterInfo = this.deps.adapter.info();
+        const info = {
+            protocolVersion: REMOTE_DEVICE_PROTOCOL_VERSION,
+            protocol: REMOTE_DEVICE_PROTOCOL_NAME,
+            deviceId: this.deps.gateway.deviceId,
+            deviceName: `${this.deps.gateway.name} · ${os.hostname()}`.slice(0, 64),
+            platform: process.platform,
+            appVersion: this.deps.appVersion,
+            connectedAt: this.connectedAt ?? new Date().toISOString(),
+            busyThreadIds: this.executor.busyThreadIds(),
+            capabilities: {
+                threadRun: true,
+                cancel: true,
+                stream: 'assistant-snapshot',
+                toolApproval: 'desktop',
+                remoteToolApproval: { respond: true, decisions: ['approve_once', 'deny'], recovery: 'run-status' },
+            },
+        };
+        // Additive v2 extension: tells clients this device is an external agent
+        // (the agent owns context; Dinox model/tool settings do not apply).
+        info.capabilities.executor = {
+            kind: 'gateway',
+            gatewayId: this.deps.gateway.id,
+            runtime: this.deps.gateway.kind,
+            agentName: adapterInfo.agentName,
+            agentVersion: adapterInfo.agentVersion,
+            context: 'agent-session',
+            // Gateway extension: `agent.config.get` lists the agent's models and modes.
+            config: Boolean(this.deps.adapter.describeConfig),
+            // Gateway extension: a busy thread queues turns instead of refusing them;
+            // waiting turns run together as one, and cancelling a waiting turn withdraws it.
+            queue: { maxQueued: MAX_QUEUED_TURNS, merge: true },
+        };
+        return info;
+    }
+    subscribe(connection, userNo) {
+        const deviceId = this.deps.gateway.deviceId;
+        const route = (subject, handler) => {
+            const subscription = connection.subscribe(subject);
+            this.subscriptions.push(subscription);
+            void (async () => {
+                for await (const msg of subscription) {
+                    try {
+                        await handler(msg);
+                    }
+                    catch (error) {
+                        this.deps.log('gateway handler failed', { subject, error: String(error) });
+                    }
+                }
+            })();
+        };
+        route(remoteDiscoverSubject(userNo), (msg) => this.handleDiscover(msg));
+        route(remoteDeviceSubject(userNo, deviceId, 'info'), (msg) => this.handleInfo(msg));
+        route(remoteDeviceSubject(userNo, deviceId, 'request'), (msg) => this.handleRunRequest(msg));
+        route(remoteDeviceSubject(userNo, deviceId, 'cancel'), (msg) => this.handleCancel(msg));
+        route(remoteDeviceSubject(userNo, deviceId, 'approve'), (msg) => this.handleApprove(msg));
+        route(remoteDeviceSubject(userNo, deviceId, 'query'), (msg) => this.handleQuery(msg));
+    }
+    publishPresence(status, connection = this.connection) {
+        if (!connection || !this.userNo)
+            return;
+        this.presenceSequence += 1;
+        try {
+            connection.publish(remotePresenceSubject(this.userNo, this.deps.gateway.deviceId), encode({
+                protocolVersion: REMOTE_DEVICE_PROTOCOL_VERSION,
+                type: 'device.presence',
+                status,
+                sequence: this.presenceSequence,
+                emittedAt: new Date().toISOString(),
+                device: this.deviceInfo(),
+            }));
+        }
+        catch (error) {
+            this.deps.log('presence publish failed', { error: String(error) });
+        }
+    }
+    publishRunEvent(subject, event) {
+        if (!this.connection) {
+            this.pendingEvents.set(event.runId, { subject, event });
+            return;
+        }
+        try {
+            this.connection.publish(subject, encode(event));
+        }
+        catch {
+            this.pendingEvents.set(event.runId, { subject, event });
+        }
+    }
+    flushPendingEvents() {
+        const pending = [...this.pendingEvents.values()];
+        this.pendingEvents.clear();
+        for (const { subject, event } of pending)
+            this.publishRunEvent(subject, event);
+    }
+    handleDiscover(msg) {
+        const { value } = decode(msg);
+        const requestId = value?.requestId;
+        if (typeof requestId !== 'string' || !msg.reply)
+            return;
+        msg.respond(encode({ protocolVersion: REMOTE_DEVICE_PROTOCOL_VERSION, type: 'device.discovered', requestId, device: this.deviceInfo() }));
+    }
+    /** Only the gateway's own query is served; desktop queries (skills, workspace) are not advertised. */
+    async handleQuery(msg) {
+        const { value } = decode(msg);
+        if (!msg.reply || !isAgentConfigQuery(value))
+            return;
+        const result = {
+            protocolVersion: REMOTE_DEVICE_PROTOCOL_VERSION,
+            type: 'agent.config.result',
+            requestId: value.requestId,
+            ok: false,
+            options: [],
+            fetchedAt: new Date().toISOString(),
+        };
+        const describe = this.deps.adapter.describeConfig?.bind(this.deps.adapter);
+        if (!describe) {
+            result.error = { code: 'unsupported', message: 'This agent has no session settings' };
+        }
+        else {
+            try {
+                result.options = await describe();
+                result.ok = true;
+            }
+            catch (error) {
+                result.error = { code: 'query_failed', message: error instanceof Error ? error.message : String(error) };
+            }
+        }
+        msg.respond(encode(result));
+    }
+    async handleInfo(msg) {
+        const { value } = decode(msg);
+        if (!msg.reply)
+            return;
+        if (isRunStatusRequest(value)) {
+            const run = await findRun(this.deps.db, { runId: value.runId, userId: this.deps.userId });
+            const found = Boolean(run && run.threadId === value.threadId);
+            msg.respond(encode({
+                protocolVersion: REMOTE_DEVICE_PROTOCOL_VERSION,
+                type: 'run.status.result',
+                requestId: value.requestId,
+                runId: value.runId,
+                threadId: value.threadId,
+                found,
+                ...(found && run
+                    ? {
+                        status: run.status,
+                        updatedAt: run.updatedAt ?? undefined,
+                        ...(run.assistant ? { assistant: { message: run.assistant } } : {}),
+                        pendingApprovals: run.status === 'waiting_approval'
+                            ? projectPendingApprovals(run.assistant, { runId: run.id, threadId: run.threadId })
+                            : [],
+                    }
+                    : {}),
+            }));
+            return;
+        }
+        const requestId = value?.requestId;
+        if (typeof requestId !== 'string')
+            return;
+        msg.respond(encode({ protocolVersion: REMOTE_DEVICE_PROTOCOL_VERSION, type: 'device.info.result', requestId, device: this.deviceInfo() }));
+    }
+    respondAck(msg, request, code, extra = {}) {
+        const ack = {
+            protocolVersion: REMOTE_DEVICE_PROTOCOL_VERSION,
+            type: 'run.ack',
+            requestId: request.requestId,
+            runId: request.runId,
+            threadId: request.threadId,
+            accepted: code === 'accepted',
+            code,
+            ...extra,
+        };
+        if (msg.reply)
+            msg.respond(encode(ack));
+        return ack;
+    }
+    cacheAck(ack) {
+        const now = Date.now();
+        for (const [key, entry] of this.ackCache) {
+            if (entry.expiresAt <= now || this.ackCache.size >= ACK_CACHE_MAX)
+                this.ackCache.delete(key);
+        }
+        this.ackCache.set(ack.requestId, { ack, expiresAt: now + ACK_CACHE_TTL_MS });
+    }
+    async handleRunRequest(msg) {
+        const { value, byteLength } = decode(msg);
+        const invalid = validateRunRequest(value, byteLength);
+        const raw = (value ?? {});
+        const ids = { requestId: String(raw.requestId ?? ''), runId: String(raw.runId ?? ''), threadId: String(raw.threadId ?? '') };
+        if (invalid) {
+            this.respondAck(msg, ids, 'invalid_request', { error: invalid });
+            return;
+        }
+        const request = value;
+        // Idempotent re-delivery: replay the ack, or recover it from the persisted run.
+        const cached = this.ackCache.get(request.requestId);
+        if (cached && cached.expiresAt > Date.now()) {
+            const sameRun = cached.ack.runId === request.runId && cached.ack.threadId === request.threadId;
+            if (msg.reply)
+                msg.respond(encode(sameRun ? cached.ack : { ...cached.ack, accepted: false, code: 'invalid_request' }));
+            return;
+        }
+        const existing = await findRun(this.deps.db, { runId: request.runId, userId: this.deps.userId });
+        if (existing) {
+            if (existing.requestId === request.requestId && existing.threadId === request.threadId) {
+                this.respondAck(msg, request, 'accepted', { status: existing.status });
+            }
+            else {
+                this.respondAck(msg, request, 'invalid_request', { error: 'runId already used by another request' });
+            }
+            return;
+        }
+        if (!this.deps.gateway.enabled) {
+            this.respondAck(msg, request, 'disabled');
+            return;
+        }
+        if (!request.createThread && !(await threadExists(this.deps.db, request.threadId, this.deps.userId))) {
+            this.respondAck(msg, request, 'thread_not_found');
+            return;
+        }
+        for (const part of request.userMessage.parts) {
+            if (part.type !== 'file')
+                continue;
+            const resourceId = part.providerMetadata?.dinox?.resourceId;
+            const resource = resourceId
+                ? await resolveTrustedResource(this.deps.db, { resourceId, userId: this.deps.userId })
+                : null;
+            if (!resource) {
+                this.respondAck(msg, request, 'attachment_unavailable');
+                return;
+            }
+        }
+        const subject = remoteRunStreamSubject(this.userNo ?? this.deps.userId, request.threadId, request.runId);
+        const publisher = new RunStreamPublisher(request, (event) => this.publishRunEvent(subject, event));
+        try {
+            const { threadCreated, queued } = await this.executor.accept(request, (snapshot) => {
+                publisher.push(snapshot);
+                if (TERMINAL_RUN_STATUSES.has(snapshot.status)) {
+                    publisher.dispose();
+                    this.publishPresence('online');
+                }
+            });
+            const ack = this.respondAck(msg, request, 'accepted', {
+                status: 'queued',
+                // Gateway extension: the turn waits behind the thread's active one.
+                ...(queued ? { waiting: true } : {}),
+                ...(request.createThread
+                    ? { threadDisposition: threadCreated ? 'created_desktop_local' : 'already_present_desktop_local' }
+                    : {}),
+            });
+            this.cacheAck(ack);
+            this.publishPresence('online');
+        }
+        catch (error) {
+            publisher.dispose();
+            if (error instanceof QueueFullError) {
+                this.respondAck(msg, request, 'busy', { error: error.message });
+                return;
+            }
+            this.respondAck(msg, request, 'enqueue_failed', { error: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    handleCancel(msg) {
+        const { value } = decode(msg);
+        if (!isCancelRequest(value))
+            return;
+        const cancelled = this.executor.cancel(value.runId, value.threadId);
+        msg.respond(encode({
+            protocolVersion: REMOTE_DEVICE_PROTOCOL_VERSION,
+            type: 'run.cancel.ack',
+            requestId: value.requestId,
+            runId: value.runId,
+            threadId: value.threadId,
+            cancelled,
+            ...(cancelled ? {} : { error: 'run is not active on this gateway' }),
+        }));
+    }
+    async handleApprove(msg) {
+        const { value, byteLength } = decode(msg);
+        const invalid = validateApprovalRequest(value, byteLength);
+        const raw = (value ?? {});
+        const base = {
+            protocolVersion: REMOTE_DEVICE_PROTOCOL_VERSION,
+            type: 'tool.approval.ack',
+            requestId: String(raw.requestId ?? ''),
+            runId: String(raw.runId ?? ''),
+            threadId: String(raw.threadId ?? ''),
+            approvalId: String(raw.approvalId ?? ''),
+        };
+        if (invalid) {
+            msg.respond(encode({ ...base, accepted: false, code: 'invalid_request', error: invalid }));
+            return;
+        }
+        const code = this.executor.respondApproval({
+            runId: base.runId,
+            threadId: base.threadId,
+            approvalId: base.approvalId,
+            approved: raw.approved === true,
+        });
+        const run = await findRun(this.deps.db, { runId: base.runId, userId: this.deps.userId });
+        msg.respond(encode({
+            ...base,
+            accepted: code === 'applied' || code === 'already_applied',
+            code,
+            ...(run ? { status: run.status, pendingApprovals: projectPendingApprovals(run.assistant, base) } : {}),
+        }));
+    }
+}

package/dist/gateway/mcpServer.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export type DaemonCall = (method: string, params?: unknown) => Promise<unknown>;
+export declare function createDinoxMcpServer(call?: DaemonCall): McpServer;
+export declare function serveDinoxMcpOverStdio(): Promise<void>;