@dinoxx/dinox-cli 2.3.0 → 2.4.0

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

package/dist/gateway/mcpServer.js

@@ -0,0 +1,118 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { sendDaemonRequest } from '../daemon/client.js';
+import { getPackageVersion } from '../utils/version.js';
+/**
+ * Dinox knowledge tools for gateway agents, served over stdio MCP. The agent
+ * launches this as a child process (`dino gateway mcp`); every read goes
+ * through the daemon, which owns the database. Read-only by design: writes
+ * from a third-party agent would bypass the app's approval flow.
+ */
+const MAX_NOTE_CHARS = 20_000;
+const MAX_RESULTS = 50;
+function text(value) {
+    return { content: [{ type: 'text', text: typeof value === 'string' ? value : JSON.stringify(value, null, 2) }] };
+}
+function failure(error) {
+    return { ...text(`Dinox is unavailable: ${error instanceof Error ? error.message : String(error)}`), isError: true };
+}
+export function createDinoxMcpServer(call = (method, params) => sendDaemonRequest(method, params)) {
+    const server = new McpServer({ name: 'dinox', version: getPackageVersion() });
+    server.registerTool('search_notes', {
+        description: "Search the user's Dinox notes by keyword. Returns id, title, summary, tags and folders; use read_note for full content.",
+        inputSchema: {
+            query: z.string().describe('Keywords; empty string lists recent notes'),
+            tags: z.string().optional().describe('Tag filter expression, e.g. "work AND !draft"'),
+            createdFrom: z.string().optional().describe('ISO date lower bound'),
+            createdTo: z.string().optional().describe('ISO date upper bound'),
+            limit: z.number().int().min(1).max(MAX_RESULTS).optional(),
+        },
+    }, async ({ query, tags, createdFrom, createdTo, limit }) => {
+        try {
+            const result = (await call('note.search', {
+                keyword: query,
+                includeDeleted: false,
+                tagsExpression: tags || undefined,
+                createdAtFrom: createdFrom,
+                createdAtTo: createdTo,
+                boxValues: [],
+                matchEmptyZettelBoxes: false,
+                limit: limit ?? 10,
+                offset: 0,
+            }));
+            return text({ totalCount: result.totalCount, notes: result.rows });
+        }
+        catch (error) {
+            return failure(error);
+        }
+    });
+    server.registerTool('read_note', {
+        description: 'Read one Dinox note as Markdown, with title, tags, folders and properties.',
+        inputSchema: { id: z.string().describe('Note id from search_notes') },
+    }, async ({ id }) => {
+        try {
+            const { note } = (await call('note.detail', { id }));
+            if (!note)
+                return { ...text(`Note not found: ${id}`), isError: true };
+            const markdown = String(note.content_md ?? note.content_text ?? '');
+            return text({
+                id: note.id,
+                title: note.title,
+                tags: note.tags,
+                folders: note.zettel_boxes,
+                properties: note.properties,
+                createdAt: note.created_at,
+                updatedAt: note.updated_at,
+                truncated: markdown.length > MAX_NOTE_CHARS,
+                content: markdown.slice(0, MAX_NOTE_CHARS),
+            });
+        }
+        catch (error) {
+            return failure(error);
+        }
+    });
+    server.registerTool('search_todos', {
+        description: "Search the user's Dinox todo items.",
+        inputSchema: {
+            query: z.string().describe('Keywords; empty string lists all'),
+            status: z.enum(['all', 'completed', 'uncompleted']).optional(),
+            limit: z.number().int().min(1).max(MAX_RESULTS).optional(),
+        },
+    }, async ({ query, status, limit }) => {
+        try {
+            const result = await call('todo.search', {
+                query,
+                includeDeleted: false,
+                taskStatus: status ?? 'uncompleted',
+                taskTagFilter: [],
+                limit: limit ?? 20,
+                scanLimit: 500,
+            });
+            return text(result);
+        }
+        catch (error) {
+            return failure(error);
+        }
+    });
+    server.registerTool('related_notes', {
+        description: 'Notes linked to a note (backlinks and outlinks, up to the given depth).',
+        inputSchema: {
+            id: z.string().describe('Note id'),
+            depth: z.number().int().min(1).max(3).optional(),
+        },
+    }, async ({ id, depth }) => {
+        try {
+            return text(await call('graph.related', { id, depth: depth ?? 2 }));
+        }
+        catch (error) {
+            return failure(error);
+        }
+    });
+    return server;
+}
+export async function serveDinoxMcpOverStdio() {
+    const server = createDinoxMcpServer();
+    await server.connect(new StdioServerTransport());
+    await new Promise((resolve) => process.stdin.once('close', resolve));
+}

package/dist/gateway/protocol.d.ts

@@ -0,0 +1,29 @@
+import { REMOTE_DEVICE_PROTOCOL_VERSION, type RemoteDeviceCancelRequest, type RemoteDeviceRunRequest, type RemoteDeviceRunStatusRequest } from '../vendor/electron/shared/remote-device-agent.js';
+import type { GatewayConfigOption } from './types.js';
+export declare function validateRunRequest(value: unknown, byteLength: number): string | null;
+export type AgentConfigQuery = {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: 'agent.config.get';
+    requestId: string;
+    clientDeviceId: string;
+};
+export type AgentConfigResult = {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: 'agent.config.result';
+    requestId: string;
+    ok: boolean;
+    options: GatewayConfigOption[];
+    fetchedAt: string;
+    error?: {
+        code: 'unsupported' | 'query_failed';
+        message: string;
+    };
+};
+export declare function isAgentConfigQuery(value: unknown): value is AgentConfigQuery;
+/** The run's chosen agent settings, `null` when none, `'invalid'` when malformed. */
+export declare function readAgentConfig(request: RemoteDeviceRunRequest): Record<string, string> | null | 'invalid';
+export declare function validateApprovalRequest(value: unknown, byteLength: number): string | null;
+export declare function isCancelRequest(value: unknown): value is RemoteDeviceCancelRequest;
+export declare function isRunStatusRequest(value: unknown): value is RemoteDeviceRunStatusRequest;
+/** `Math.max(250, rand * min(60s, 1s * 2^attempt))`, the desktop's full-jitter backoff. */
+export declare function reconnectDelayMs(attempt: number, random?: () => number): number;