@dinoxx/dinox-cli 2.2.0 → 2.4.0

package/dist/commands/templates/repo.js

@@ -0,0 +1,78 @@
+import { DinoxError } from '../../utils/errors.js';
+import { fetchDomainReadModel, previewInRolledBackTransaction, runDomainCommand, } from '../domain/run.js';
+import { mapNoteTemplateRow } from './model.js';
+function nowIso() {
+    return new Date().toISOString();
+}
+function notFound(id) {
+    return new DinoxError(`Note template not found: ${id}`, {
+        code: 'NOTE_TEMPLATE_NOT_FOUND',
+        details: { templateId: id },
+        suggestion: 'Run `dino template list --format json` to see template ids.',
+    });
+}
+export async function listNoteTemplates(db, input) {
+    const rows = await fetchDomainReadModel(db, 'noteTemplates.catalog', {
+        userId: input.userId,
+        ...(input.limit === undefined ? {} : { limit: input.limit }),
+    });
+    return rows.map(mapNoteTemplateRow);
+}
+export async function getNoteTemplate(db, input) {
+    const row = await db.getOptional(`
+      SELECT id, user_id, name, content, priority, is_show, extra_data, property_def,
+        insert_at, update_at, is_del
+      FROM c_note_template
+      WHERE id = ? AND user_id = ? AND (is_del IS NULL OR is_del = 0)
+      LIMIT 1
+    `, [input.id.trim(), input.userId]);
+    if (!row)
+        throw notFound(input.id);
+    return mapNoteTemplateRow(row);
+}
+async function runCreate(db, input) {
+    const { result: id } = await runDomainCommand(db, 'noteTemplates.create', {
+        userId: input.userId,
+        name: input.name,
+        propertyKeys: input.propertyKeys ?? [],
+        ...(input.content === undefined ? {} : { content: input.content }),
+        updatedAt: nowIso(),
+    });
+    return getNoteTemplate(db, { userId: input.userId, id });
+}
+async function runUpdate(db, input) {
+    await getNoteTemplate(db, input);
+    await runDomainCommand(db, 'noteTemplates.update', {
+        id: input.id,
+        userId: input.userId,
+        ...(input.name === undefined ? {} : { name: input.name }),
+        ...(input.propertyKeys === undefined ? {} : { propertyKeys: input.propertyKeys }),
+        ...(input.content === undefined ? {} : { content: input.content }),
+        updatedAt: nowIso(),
+    });
+    return getNoteTemplate(db, input);
+}
+async function runDelete(db, input) {
+    const before = await getNoteTemplate(db, input);
+    const { result: changed } = await runDomainCommand(db, 'noteTemplates.softDelete', {
+        id: input.id,
+        userId: input.userId,
+        updatedAt: nowIso(),
+    });
+    if (!changed)
+        throw notFound(input.id);
+    return before;
+}
+export const createNoteTemplate = runCreate;
+export const updateNoteTemplate = runUpdate;
+export const deleteNoteTemplate = runDelete;
+export async function previewCreateNoteTemplate(db, input) {
+    return previewInRolledBackTransaction(db, (tx) => runCreate(tx, input), async (_tx, after) => ({ before: null, after }));
+}
+export async function previewUpdateNoteTemplate(db, input) {
+    const before = await getNoteTemplate(db, input);
+    return previewInRolledBackTransaction(db, (tx) => runUpdate(tx, input), async (_tx, after) => ({ before, after }));
+}
+export async function previewDeleteNoteTemplate(db, input) {
+    return previewInRolledBackTransaction(db, (tx) => runDelete(tx, input), async (_tx, before) => ({ before, after: null }));
+}

package/dist/config/paths.d.ts

@@ -1,3 +1,4 @@
+export declare function normalizeUserPathSegment(userId: string): string;
 export declare function getConfigDir(): string;
 export declare function getConfigFilePath(): string;
 export declare function getDataDir(): string;

package/dist/config/paths.js

@@ -1,7 +1,7 @@
 import os from 'node:os';
 import path from 'node:path';
 const POWERSYNC_DB_FILENAME = 'dinox-cli.sqlite';
-function normalizeUserPathSegment(userId) {
+export function normalizeUserPathSegment(userId) {
     const normalized = userId.trim();
     const encoded = encodeURIComponent(normalized);
     if (encoded === '.' || encoded === '..') {

package/dist/daemon/server.d.ts

@@ -12,6 +12,7 @@ export declare class DaemonServer {
     private ownsArtifacts;
     private releaseOwner;
     private stopPromise;
+    private gateways;
     initialize(): Promise<void>;
     handleRequest(req: DaemonRequest): Promise<DaemonResponse>;
     private isCacheStale;

package/dist/daemon/server.js

@@ -6,6 +6,7 @@ import { fingerprintDaemonRuntimeConfig, resolveConfig } from '../config/resolve
 import { hydrateResolvedAuthIdentity } from '../auth/userInfo.js';
 import { closePowerSyncAndReleaseOwner, connectPowerSync, getStatusSnapshot, } from '../powersync/runtime.js';
 import { executeNoteSearch } from '../commands/notes/repo.js';
+import { getNoteDetail } from '../commands/notes/repo/read.js';
 import { getBacklinks, getGraphStats, getOutlinks, getRelatedNotes } from '../commands/graph/repo.js';
 import { executeTodoSearch } from '../commands/todo/repo.js';
 import { ensureDaemonDir, getDaemonSocketPath, isProcessRunning, readPid, removePid, savePid, } from './pid.js';
@@ -13,6 +14,7 @@ import { getPackageVersion } from '../utils/version.js';
 import { syncNoteTokenIndex } from '../powersync/tokenIndex.js';
 import { buildStructuredErrorPayload, DinoxError } from '../utils/errors.js';
 import { getDaemonInfo } from './client.js';
+import { GatewayService } from '../gateway/service.js';
 const MAX_DAEMON_REQUEST_BYTES = 1 * 1024 * 1024;
 const DAEMON_PROCESS_VERSION = getPackageVersion();
 async function readJsonBody(req) {
@@ -68,6 +70,7 @@ export class DaemonServer {
     ownsArtifacts = false;
     releaseOwner = null;
     stopPromise = null;
+    gateways = null;
     async initialize() {
         const baseConfig = resolveConfig(await loadConfig());
         const { config } = await hydrateResolvedAuthIdentity(baseConfig, { timeoutMs: baseConfig.sync.timeoutMs });
@@ -83,6 +86,19 @@ export class DaemonServer {
         });
         this.db = db;
         this.releaseOwner = releaseOwner;
+        if (config.auth.userId && config.auth.authorization) {
+            // Agent gateways share the daemon's PowerSync connection; a gateway
+            // failure must never take the daemon down.
+            this.gateways = new GatewayService({
+                db,
+                userId: config.auth.userId,
+                authorization: config.auth.authorization,
+                credentialsUrl: process.env.DINOX_NATS_CREDENTIALS_URL || undefined,
+            });
+            await this.gateways.start().catch((error) => {
+                process.stderr.write(`[dinox-gateway] start failed: ${String(error)}\n`);
+            });
+        }
         // PowerSync keeps the local cache in sync continuously while connected,
         // so no background polling loop is needed here.
     }
@@ -147,6 +163,18 @@ export class DaemonServer {
                 case 'graph.stats':
                     const graphStats = await getGraphStats(this.db);
                     return { id: req.id, ok: true, result: { ...graphStats, stale: this.isCacheStale() } };
+                case 'note.detail': {
+                    const note = await getNoteDetail(this.db, String(params?.id ?? ''));
+                    return { id: req.id, ok: true, result: { note, stale: this.isCacheStale() } };
+                }
+                case 'gateway.status':
+                    return { id: req.id, ok: true, result: { gateways: this.gateways?.status() ?? [] } };
+                case 'gateway.reload': {
+                    if (!this.gateways) {
+                        throw new DinoxError('Gateways need a signed-in daemon', { code: 'AUTH_REQUIRED' });
+                    }
+                    return { id: req.id, ok: true, result: { gateways: await this.gateways.reload() } };
+                }
                 case 'todo.search': {
                     // Same executor as the local `dino todo search` path — no option/result drift.
                     const result = await executeTodoSearch(this.db, params);
@@ -258,6 +286,9 @@ export class DaemonServer {
         }
     }
     async stopInternal() {
+        const gateways = this.gateways;
+        this.gateways = null;
+        await gateways?.stop().catch(() => undefined);
         const db = this.db;
         const releaseOwner = this.releaseOwner;
         if (db) {

package/dist/gateway/adapters/acp.d.ts

@@ -0,0 +1,42 @@
+import { type McpServer, type SessionConfigOption } from '@agentclientprotocol/sdk';
+import type { GatewayAdapter, GatewayAdapterInfo, GatewayConfigOption, GatewayDefinition, GatewayTurnInput, GatewayTurnResult } from '../types.js';
+type Logger = (message: string, details?: Record<string, unknown>) => void;
+/** Select options only; boolean toggles have no use in the app yet. */
+export declare function normalizeConfigOptions(options: SessionConfigOption[] | null | undefined): GatewayConfigOption[];
+/**
+ * Drives any Agent Client Protocol agent over stdio (`hermes acp`, `openclaw acp`,
+ * `claude-code-acp`, `codex-acp`, `pi-acp`, ...). One long-lived process per
+ * gateway hosts every thread's session; the agent keeps the conversation, so
+ * each turn sends only the new prompt.
+ */
+export declare class AcpGatewayAdapter implements GatewayAdapter {
+    private readonly gateway;
+    private readonly log;
+    /** MCP servers offered to every session, e.g. the Dinox knowledge tools. */
+    private readonly mcpServers;
+    readonly kind: "acp";
+    private process;
+    private starting;
+    private readonly turns;
+    /** The latest settings any session reported: the agent-wide choices the app lists. */
+    private catalog;
+    constructor(gateway: GatewayDefinition, log?: Logger, 
+    /** MCP servers offered to every session, e.g. the Dinox knowledge tools. */
+    mcpServers?: McpServer[]);
+    info(): GatewayAdapterInfo;
+    runTurn(input: GatewayTurnInput): Promise<GatewayTurnResult>;
+    describeConfig(): Promise<GatewayConfigOption[]>;
+    dispose(): Promise<void>;
+    private resolveSession;
+    /**
+     * Brings the session to the requested settings before its turn. Entries the
+     * agent does not offer are skipped, so a stale choice never fails the run.
+     */
+    private applyConfig;
+    private rememberConfig;
+    private ensureProcess;
+    private startProcess;
+    private handleSessionUpdate;
+    private handlePermission;
+}
+export {};

package/dist/gateway/adapters/acp.js

@@ -0,0 +1,285 @@
+import { spawn } from 'node:child_process';
+import os from 'node:os';
+import { Readable, Writable } from 'node:stream';
+import { ClientSideConnection, ndJsonStream, PROTOCOL_VERSION, } from '@agentclientprotocol/sdk';
+import { generateId } from '../../utils/id.js';
+import { getPackageVersion } from '../../utils/version.js';
+const TOOL_STATUS = {
+    pending: 'pending',
+    in_progress: 'running',
+    completed: 'completed',
+    failed: 'failed',
+};
+const STOP_REASON = {
+    end_turn: 'end_turn',
+    max_tokens: 'max_tokens',
+    max_turn_requests: 'max_tokens',
+    refusal: 'refusal',
+    cancelled: 'cancelled',
+};
+function toolContentText(content) {
+    const text = (content ?? [])
+        .map((item) => (item.type === 'content' && item.content.type === 'text' ? item.content.text : ''))
+        .filter(Boolean)
+        .join('\n');
+    return text || undefined;
+}
+/** Select options only; boolean toggles have no use in the app yet. */
+export function normalizeConfigOptions(options) {
+    const normalized = [];
+    for (const option of options ?? []) {
+        if (option.type !== 'select')
+            continue;
+        const values = [];
+        for (const entry of option.options) {
+            if ('group' in entry) {
+                for (const value of entry.options) {
+                    values.push({ value: value.value, name: value.name, description: value.description ?? null, group: entry.name });
+                }
+            }
+            else {
+                values.push({ value: entry.value, name: entry.name, description: entry.description ?? null, group: null });
+            }
+        }
+        normalized.push({
+            id: option.id,
+            name: option.name,
+            category: option.category ?? null,
+            description: option.description ?? null,
+            currentValue: option.currentValue,
+            values,
+        });
+    }
+    return normalized;
+}
+function pickOption(options, approved) {
+    const preferred = approved ? ['allow_once', 'allow_always'] : ['reject_once', 'reject_always'];
+    for (const kind of preferred) {
+        const option = options.find((item) => item.kind === kind);
+        if (option)
+            return option;
+    }
+    return undefined;
+}
+/**
+ * Drives any Agent Client Protocol agent over stdio (`hermes acp`, `openclaw acp`,
+ * `claude-code-acp`, `codex-acp`, `pi-acp`, ...). One long-lived process per
+ * gateway hosts every thread's session; the agent keeps the conversation, so
+ * each turn sends only the new prompt.
+ */
+export class AcpGatewayAdapter {
+    gateway;
+    log;
+    mcpServers;
+    kind = 'acp';
+    process = null;
+    starting = null;
+    turns = new Map();
+    /** The latest settings any session reported: the agent-wide choices the app lists. */
+    catalog = null;
+    constructor(gateway, log = () => { }, 
+    /** MCP servers offered to every session, e.g. the Dinox knowledge tools. */
+    mcpServers = []) {
+        this.gateway = gateway;
+        this.log = log;
+        this.mcpServers = mcpServers;
+    }
+    info() {
+        const agentInfo = this.process?.init.agentInfo;
+        return { kind: this.kind, agentName: agentInfo?.name ?? null, agentVersion: agentInfo?.version ?? null };
+    }
+    async runTurn(input) {
+        const agent = await this.ensureProcess();
+        const sessionId = await this.resolveSession(agent, input.sessionId);
+        await this.applyConfig(agent, sessionId, input.config);
+        this.turns.set(sessionId, { onEvent: input.onEvent, awaitApproval: input.awaitApproval });
+        const onAbort = () => {
+            void agent.connection.cancel({ sessionId }).catch(() => undefined);
+        };
+        input.signal.addEventListener('abort', onAbort, { once: true });
+        try {
+            const prompt = [{ type: 'text', text: input.prompt }];
+            for (const resource of input.resources) {
+                prompt.push({ type: 'resource_link', uri: resource.uri, name: resource.name, mimeType: resource.mediaType ?? null });
+            }
+            const response = await agent.connection.prompt({ sessionId, prompt });
+            return { sessionId, stopReason: STOP_REASON[response.stopReason] ?? 'end_turn' };
+        }
+        catch (error) {
+            if (input.signal.aborted)
+                return { sessionId, stopReason: 'cancelled' };
+            return { sessionId, stopReason: 'error', error: error instanceof Error ? error.message : String(error) };
+        }
+        finally {
+            input.signal.removeEventListener('abort', onAbort);
+            this.turns.delete(sessionId);
+        }
+    }
+    async describeConfig() {
+        if (this.catalog)
+            return this.catalog;
+        const agent = await this.ensureProcess();
+        if (this.catalog)
+            return this.catalog;
+        // No session yet: open one only to read the agent's choices. It never runs a turn.
+        const created = await agent.connection.newSession({ cwd: this.gateway.cwd ?? os.homedir(), mcpServers: [] });
+        this.rememberConfig(agent, created.sessionId, created.configOptions);
+        return this.catalog ?? [];
+    }
+    async dispose() {
+        const agent = this.process;
+        this.process = null;
+        this.starting = null;
+        if (!agent)
+            return;
+        agent.child.stdin.end();
+        agent.child.kill('SIGTERM');
+    }
+    async resolveSession(agent, sessionId) {
+        const cwd = this.gateway.cwd ?? os.homedir();
+        if (sessionId && agent.liveSessions.has(sessionId))
+            return sessionId;
+        if (sessionId && agent.init.agentCapabilities?.loadSession) {
+            try {
+                // No turn is registered yet, so the history the agent replays is ignored.
+                const loaded = await agent.connection.loadSession({ sessionId, cwd, mcpServers: this.mcpServers });
+                agent.liveSessions.add(sessionId);
+                this.rememberConfig(agent, sessionId, loaded.configOptions);
+                return sessionId;
+            }
+            catch (error) {
+                this.log('session/load failed; starting a new session', { sessionId, error: String(error) });
+            }
+        }
+        const created = await agent.connection.newSession({ cwd, mcpServers: this.mcpServers });
+        agent.liveSessions.add(created.sessionId);
+        this.rememberConfig(agent, created.sessionId, created.configOptions);
+        return created.sessionId;
+    }
+    /**
+     * Brings the session to the requested settings before its turn. Entries the
+     * agent does not offer are skipped, so a stale choice never fails the run.
+     */
+    async applyConfig(agent, sessionId, config) {
+        for (const [configId, value] of Object.entries(config ?? {})) {
+            const option = agent.sessionConfig.get(sessionId)?.find((item) => item.id === configId);
+            if (!option || option.currentValue === value)
+                continue;
+            if (!option.values.some((item) => item.value === value)) {
+                this.log('agent setting not offered; skipped', { configId, value });
+                continue;
+            }
+            try {
+                const response = await agent.connection.setSessionConfigOption({ sessionId, configId, value });
+                this.rememberConfig(agent, sessionId, response.configOptions);
+            }
+            catch (error) {
+                this.log('agent setting failed; continuing with the current one', { configId, error: String(error) });
+            }
+        }
+    }
+    rememberConfig(agent, sessionId, options) {
+        if (!options)
+            return;
+        const normalized = normalizeConfigOptions(options);
+        agent.sessionConfig.set(sessionId, normalized);
+        this.catalog = normalized;
+    }
+    ensureProcess() {
+        if (this.process)
+            return Promise.resolve(this.process);
+        this.starting ??= this.startProcess().finally(() => {
+            this.starting = null;
+        });
+        return this.starting;
+    }
+    async startProcess() {
+        const command = this.gateway.command;
+        if (!command)
+            throw new Error(`Gateway ${this.gateway.name} has no ACP command`);
+        const child = spawn(command, this.gateway.args ?? [], {
+            cwd: this.gateway.cwd ?? os.homedir(),
+            env: { ...process.env, ...(this.gateway.env ?? {}) },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        child.stderr.on('data', (chunk) => this.log('agent stderr', { text: chunk.toString('utf8').slice(0, 2000) }));
+        const exited = new Promise((_, reject) => {
+            child.once('error', reject);
+            child.once('exit', (code, signal) => reject(new Error(`agent exited (code ${code}, signal ${signal})`)));
+        });
+        child.once('exit', () => {
+            if (this.process?.child === child)
+                this.process = null;
+        });
+        const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
+        const connection = new ClientSideConnection(() => ({
+            sessionUpdate: (params) => this.handleSessionUpdate(params),
+            requestPermission: (params) => this.handlePermission(params),
+        }), stream);
+        const init = await Promise.race([
+            connection.initialize({
+                protocolVersion: PROTOCOL_VERSION,
+                clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
+                clientInfo: { name: 'dinox-gateway', version: getPackageVersion() },
+            }),
+            exited,
+        ]);
+        exited.catch(() => undefined);
+        const agent = { child, connection, init, liveSessions: new Set(), sessionConfig: new Map() };
+        this.process = agent;
+        this.log('agent connected', { agent: init.agentInfo?.name ?? command, protocol: init.protocolVersion });
+        return agent;
+    }
+    handleSessionUpdate(params) {
+        const update = params.update;
+        if (update.sessionUpdate === 'config_option_update' && this.process) {
+            this.rememberConfig(this.process, params.sessionId, update.configOptions);
+            return;
+        }
+        const turn = this.turns.get(params.sessionId);
+        if (!turn)
+            return;
+        switch (update.sessionUpdate) {
+            case 'agent_message_chunk':
+                if (update.content.type === 'text')
+                    turn.onEvent({ type: 'text-delta', text: update.content.text });
+                break;
+            case 'agent_thought_chunk':
+                if (update.content.type === 'text')
+                    turn.onEvent({ type: 'reasoning-delta', text: update.content.text });
+                break;
+            case 'tool_call':
+            case 'tool_call_update':
+                turn.onEvent({
+                    type: 'tool',
+                    toolCallId: update.toolCallId,
+                    ...(update.title ? { title: update.title } : {}),
+                    ...(update.status ? { status: TOOL_STATUS[update.status] } : {}),
+                    ...(update.rawInput !== undefined ? { input: update.rawInput } : {}),
+                    ...(update.rawOutput !== undefined || update.content
+                        ? { output: update.rawOutput ?? toolContentText(update.content) }
+                        : {}),
+                });
+                break;
+            default:
+                break;
+        }
+    }
+    async handlePermission(params) {
+        const turn = this.turns.get(params.sessionId);
+        if (!turn)
+            return { outcome: { outcome: 'cancelled' } };
+        const approvalId = `acp-${generateId()}`;
+        turn.onEvent({
+            type: 'approval-request',
+            approvalId,
+            toolCallId: params.toolCall.toolCallId,
+            toolName: params.toolCall.title || params.toolCall.name || 'tool',
+            input: params.toolCall.rawInput,
+        });
+        const approved = await turn.awaitApproval(approvalId);
+        turn.onEvent({ type: 'approval-resolved', approvalId, approved });
+        const option = pickOption(params.options, approved);
+        return option ? { outcome: { outcome: 'selected', optionId: option.optionId } } : { outcome: { outcome: 'cancelled' } };
+    }
+}

package/dist/gateway/adapters/echo.d.ts

@@ -0,0 +1,12 @@
+import type { GatewayAdapter, GatewayAdapterInfo, GatewayTurnInput, GatewayTurnResult } from '../types.js';
+/**
+ * Loopback agent for end-to-end checks of the gateway path (app ⇄ NATS ⇄ CLI ⇄
+ * PowerSync) without a real runtime. Echoes the prompt; a prompt containing
+ * `/approve` exercises the tool-approval round trip first.
+ */
+export declare class EchoGatewayAdapter implements GatewayAdapter {
+    readonly kind: "echo";
+    info(): GatewayAdapterInfo;
+    runTurn(input: GatewayTurnInput): Promise<GatewayTurnResult>;
+    dispose(): Promise<void>;
+}

package/dist/gateway/adapters/echo.js

@@ -0,0 +1,51 @@
+import { generateId } from '../../utils/id.js';
+const CHUNK_DELAY_MS = 40;
+function delay(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal.aborted)
+            return reject(signal.reason);
+        const timer = setTimeout(resolve, ms);
+        signal.addEventListener('abort', () => {
+            clearTimeout(timer);
+            reject(signal.reason);
+        }, { once: true });
+    });
+}
+/**
+ * Loopback agent for end-to-end checks of the gateway path (app ⇄ NATS ⇄ CLI ⇄
+ * PowerSync) without a real runtime. Echoes the prompt; a prompt containing
+ * `/approve` exercises the tool-approval round trip first.
+ */
+export class EchoGatewayAdapter {
+    kind = 'echo';
+    info() {
+        return { kind: this.kind, agentName: 'echo', agentVersion: null };
+    }
+    async runTurn(input) {
+        const sessionId = input.sessionId ?? `echo-${generateId()}`;
+        try {
+            if (input.prompt.includes('/approve')) {
+                const toolCallId = `tool-${generateId()}`;
+                const approvalId = `approval-${generateId()}`;
+                input.onEvent({ type: 'tool', toolCallId, title: 'echo.write', status: 'pending', input: { text: input.prompt } });
+                input.onEvent({ type: 'approval-request', approvalId, toolCallId, toolName: 'echo.write', input: { text: input.prompt } });
+                const approved = await input.awaitApproval(approvalId);
+                input.onEvent({ type: 'approval-resolved', approvalId, approved });
+                input.onEvent(approved
+                    ? { type: 'tool', toolCallId, status: 'completed', output: 'approved' }
+                    : { type: 'tool', toolCallId, status: 'failed', output: 'denied by user' });
+            }
+            for (const word of `Echo: ${input.prompt}`.split(/(\s+)/)) {
+                await delay(CHUNK_DELAY_MS, input.signal);
+                input.onEvent({ type: 'text-delta', text: word });
+            }
+            return { sessionId, stopReason: 'end_turn' };
+        }
+        catch (error) {
+            if (input.signal.aborted)
+                return { sessionId, stopReason: 'cancelled' };
+            throw error;
+        }
+    }
+    async dispose() { }
+}

package/dist/gateway/adapters/index.d.ts

@@ -0,0 +1,9 @@
+import type { McpServer } from '@agentclientprotocol/sdk';
+import type { GatewayAdapter, GatewayDefinition } from '../types.js';
+/**
+ * The Dinox knowledge tools as a stdio MCP server: this same CLI, run as
+ * `dino gateway mcp`, reading through the daemon. DINOX_* variables are passed
+ * on so the child finds the same config, data dir and daemon socket.
+ */
+export declare function dinoxMcpServerConfig(): McpServer | null;
+export declare function createGatewayAdapter(gateway: GatewayDefinition, log: (message: string, details?: Record<string, unknown>) => void): GatewayAdapter;

package/dist/gateway/adapters/index.js

@@ -0,0 +1,30 @@
+import { AcpGatewayAdapter } from './acp.js';
+import { EchoGatewayAdapter } from './echo.js';
+/**
+ * The Dinox knowledge tools as a stdio MCP server: this same CLI, run as
+ * `dino gateway mcp`, reading through the daemon. DINOX_* variables are passed
+ * on so the child finds the same config, data dir and daemon socket.
+ */
+export function dinoxMcpServerConfig() {
+    const entrypoint = process.argv[1];
+    if (!entrypoint)
+        return null;
+    return {
+        name: 'dinox',
+        command: process.execPath,
+        args: [...process.execArgv, entrypoint, 'gateway', 'mcp'],
+        env: Object.entries(process.env)
+            .filter((entry) => entry[0].startsWith('DINOX_') && typeof entry[1] === 'string')
+            .map(([name, value]) => ({ name, value })),
+    };
+}
+export function createGatewayAdapter(gateway, log) {
+    switch (gateway.kind) {
+        case 'acp': {
+            const dinoxTools = gateway.dinoxTools === false ? null : dinoxMcpServerConfig();
+            return new AcpGatewayAdapter(gateway, log, dinoxTools ? [dinoxTools] : []);
+        }
+        case 'echo':
+            return new EchoGatewayAdapter();
+    }
+}

package/dist/gateway/assistantProjection.d.ts

@@ -0,0 +1,32 @@
+import type { ChatUIMessage } from '../vendor/electron/shared/external-types.js';
+import type { RemoteToolApprovalPrompt } from '../vendor/electron/shared/remote-device-agent.js';
+import type { GatewayEvent } from './types.js';
+export declare class AssistantProjection {
+    private readonly base;
+    private readonly parts;
+    private readonly toolIndex;
+    private readonly approvals;
+    private revisionCounter;
+    constructor(base: ChatUIMessage);
+    get revision(): number;
+    apply(event: GatewayEvent): void;
+    /** Closes streaming parts; called once when the turn ends. */
+    finish(): void;
+    snapshot(): ChatUIMessage;
+    private appendText;
+    private ensureTool;
+    private findToolByApproval;
+    private applyTool;
+}
+/** Same projection the desktop host sends: open approval requests found in the snapshot. */
+/**
+ * The reply as it is kept in the synced transcript. A computer agent's
+ * reasoning and tool calls are working state: they stream to the client while
+ * the turn runs and stay in the local run snapshot, but only the answer is
+ * stored in `c_chat_message`.
+ */
+export declare function toTranscriptMessage(message: ChatUIMessage): ChatUIMessage;
+export declare function projectPendingApprovals(message: ChatUIMessage | null | undefined, ids: {
+    runId: string;
+    threadId: string;
+}): RemoteToolApprovalPrompt[];