@dinoxx/dinox-cli 2.3.0 → 2.4.0

package/README.md

@@ -52,7 +52,7 @@ Dinox CLI 适合这几类场景：
 
 安装前请先确认：
 
-- 推荐使用 Node.js 24 LTS；支持 Node.js 20.18.1+、22、23、24、25（不支持 Node.js 21 或 26+）
+- 推荐使用 Node.js 24 LTS；支持 Node.js 22、23、24、25（不支持 Node.js 21 及以下或 26+）
 - 已安装 npm
 - 你的系统可以正常执行全局 npm 命令
 
@@ -937,13 +937,27 @@ daemon 通过用户数据目录下的私有 Unix domain socket 通信，Windows
 
 需要在当前进程打开 PowerSync SQLite 的命令（例如写命令、`sync`、在线 `auth status`、`--offline` 或 `--require-sync` 读取）会先取得跨进程生命周期锁。如果同一用户数据库正由健康 daemon 持有，CLI 会暂时停止该实例；只有在命令结束、数据库关闭且 owner lease 成功释放后，才会按原端口恢复它。使用其他用户数据库的 daemon 不会被停止；如果关闭或释放失败，CLI 会保留 daemon 为停止状态并在 stderr 报告警告，避免两个运行时同时持有同一 SQLite 数据库。
 
-### 6.15 `info`：查看版本与技能仓库地址
+### 6.15 `gateway`：把本机 Agent 挂成远程设备
+
+```bash
+dino gateway detect
+dino gateway detect --add
+dino gateway add Hermes --command hermes --arg acp
+dino gateway list
+dino gateway status
+dino gateway reload
+dino gateway remove Hermes
+```
+
+`detect` 会在 `PATH` 上查找 ACP agent，并用真实握手确认能否启动。`--add` 把已确认的 agent 写入当前账号的 gateway 配置，并由 daemon 托管。`gateway list` 只显示环境变量名，不显示值。`dino gateway mcp` 由这些 agent 拉起，对外提供只读的 Dinox 知识工具。
+
+### 6.16 `info`：查看版本与技能仓库地址
 
 ```bash
 dino info
 ```
 
-### 6.16 `update`：升级 CLI
+### 6.17 `update`：升级 CLI
 
 ```bash
 dino update

package/dist/cli.js

@@ -3,6 +3,7 @@ import { registerAuthCommands } from './commands/auth/index.js';
 import { registerBoxesCommand } from './commands/boxes/index.js';
 import { registerConfigCommands } from './commands/config/index.js';
 import { registerDaemonCommands } from './daemon/index.js';
+import { registerGatewayCommands } from './commands/gateway/index.js';
 import { registerDoctorCommand } from './commands/doctor.js';
 import { registerGraphCommands } from './commands/graph/index.js';
 import { registerInfoCommand } from './commands/info/index.js';
@@ -79,6 +80,7 @@ export function createCli() {
     registerBoxesCommand(program);
     registerConfigCommands(program);
     registerDaemonCommands(program);
+    registerGatewayCommands(program);
     registerDoctorCommand(program);
     registerGraphCommands(program);
     registerInfoCommand(program);

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

@@ -0,0 +1,4 @@
+import { Command } from 'commander';
+import type { CommandGroupDescriptor } from '../descriptor/types.js';
+export declare const gatewayCommandGroup: CommandGroupDescriptor;
+export declare function registerGatewayCommands(program: Command): void;

package/dist/commands/gateway/index.js

@@ -0,0 +1,300 @@
+import { isDaemonRunning, sendDaemonRequest } from '../../daemon/client.js';
+import { ensureDaemonRunning } from '../../daemon/ensure.js';
+import { loadConfig } from '../../config/store.js';
+import { addGateway, adoptDetectedAgent, getGatewaysFilePath, loadGateways, removeGateway, } from '../../gateway/config.js';
+import { detectAcpAgents, inferAgentId } from '../../gateway/detect.js';
+import { serveDinoxMcpOverStdio } from '../../gateway/mcpServer.js';
+import { DinoxError } from '../../utils/errors.js';
+import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess } from '../../utils/output.js';
+import { registerCommandGroup } from '../descriptor/register.js';
+import { FORMAT_OPTIONS } from '../schema/globalOptions.js';
+const GATEWAY_KINDS = ['acp', 'echo'];
+function collect(value, previous) {
+    return [...(Array.isArray(previous) ? previous : []), value];
+}
+function parseEnv(entries) {
+    const env = {};
+    for (const entry of Array.isArray(entries) ? entries : []) {
+        const separator = entry.indexOf('=');
+        if (separator <= 0) {
+            throw new DinoxError(`--env expects KEY=VALUE, got "${entry}"`, { code: 'INVALID_ARGUMENT' });
+        }
+        env[entry.slice(0, separator)] = entry.slice(separator + 1);
+    }
+    return env;
+}
+/** Gateways belong to the logged-in account. */
+async function currentUserId() {
+    return (await loadConfig()).auth?.userId ?? '';
+}
+/** Public view: never echoes env values (they may hold API keys). */
+function describeGateway(gateway) {
+    return {
+        id: gateway.id,
+        name: gateway.name,
+        kind: gateway.kind,
+        agentId: gateway.agentId ?? null,
+        deviceId: gateway.deviceId,
+        command: gateway.command ?? null,
+        args: gateway.args ?? [],
+        cwd: gateway.cwd ?? null,
+        envKeys: Object.keys(gateway.env ?? {}),
+        enabled: gateway.enabled,
+    };
+}
+/** Applies the account's gateways to the running daemon, starting it when needed. */
+async function applyToDaemon() {
+    if (!(await isDaemonRunning())) {
+        await ensureDaemonRunning();
+        return (await sendDaemonRequest('gateway.status')).gateways;
+    }
+    return (await sendDaemonRequest('gateway.reload', undefined, { timeoutMs: 30_000 })).gateways;
+}
+function printStatuses(statuses) {
+    if (statuses.length === 0) {
+        printHumanReadableLine('No gateways are running.');
+        return;
+    }
+    for (const status of statuses) {
+        const busy = status.busyThreadIds.length ? ` · ${status.busyThreadIds.length} running` : '';
+        const error = status.lastError ? ` · ${status.lastError}` : '';
+        printHumanReadableLine(`${status.name} (${status.kind}, ${status.deviceId}): ${status.state}${busy}${error}`);
+    }
+}
+async function runAdd(context) {
+    const kind = context.options.kind ?? 'acp';
+    if (!GATEWAY_KINDS.includes(kind)) {
+        throw new DinoxError(`--kind must be one of ${GATEWAY_KINDS.join(', ')}`, { code: 'INVALID_ARGUMENT' });
+    }
+    const command = context.options.command;
+    const args = context.options.arg;
+    const gateway = await addGateway(await currentUserId(), {
+        name: context.args.name ?? '',
+        kind,
+        // A manual launch of a known agent counts as that agent, so detect never hosts it twice.
+        agentId: kind === 'acp' ? inferAgentId(command, args) : undefined,
+        command,
+        args,
+        cwd: context.options.cwd,
+        env: parseEnv(context.options.env),
+    });
+    const statuses = await applyToDaemon();
+    if (getRequestedStructuredOutputFormat()) {
+        printSuccess({ gateway: describeGateway(gateway), status: statuses.find((item) => item.gatewayId === gateway.id) ?? null });
+        return;
+    }
+    printHumanReadableLine(`Added gateway "${gateway.name}" as device ${gateway.deviceId}.`);
+    printStatuses(statuses);
+}
+async function runDetect(context) {
+    const detected = await detectAcpAgents({ probe: true });
+    const added = [];
+    const updated = [];
+    if (context.options.add) {
+        const userId = await currentUserId();
+        for (const agent of detected) {
+            if (!agent.verified)
+                continue;
+            const result = await adoptDetectedAgent(userId, agent);
+            if (result.change === 'added')
+                added.push(result.gateway);
+            if (result.change === 'updated')
+                updated.push(result.gateway);
+        }
+    }
+    const statuses = added.length || updated.length ? await applyToDaemon() : [];
+    if (getRequestedStructuredOutputFormat()) {
+        printSuccess({
+            agents: detected,
+            added: added.map(describeGateway),
+            updated: updated.map(describeGateway),
+            gateways: statuses,
+        });
+        return;
+    }
+    if (detected.length === 0) {
+        printHumanReadableLine('No ACP agents found on PATH.');
+        return;
+    }
+    for (const agent of detected) {
+        const launch = [agent.command, ...agent.args].join(' ');
+        const label = agent.verified
+            ? `ready${agent.agentVersion ? ` (${agent.agentName ?? agent.name} ${agent.agentVersion})` : ''}`
+            : agent.installHint
+                ? `installed, needs its ACP adapter: ${agent.installHint}`
+                : `not responding: ${agent.error ?? 'unknown'}`;
+        printHumanReadableLine(`${agent.name}: ${label} · ${launch}`);
+    }
+    for (const gateway of added)
+        printHumanReadableLine(`Added gateway "${gateway.name}" (${gateway.deviceId}).`);
+    for (const gateway of updated) {
+        printHumanReadableLine(`Updated gateway "${gateway.name}": ${[gateway.command, ...(gateway.args ?? [])].join(' ')}`);
+    }
+    if (!context.options.add && detected.some((agent) => agent.verified)) {
+        printHumanReadableLine('Run `dino gateway detect --add` to host the ready agents.');
+    }
+}
+async function runList() {
+    const userId = await currentUserId();
+    const gateways = (await loadGateways(userId)).map(describeGateway);
+    if (getRequestedStructuredOutputFormat()) {
+        printSuccess({ gateways, file: getGatewaysFilePath(userId) });
+        return;
+    }
+    if (gateways.length === 0) {
+        printHumanReadableLine('No gateways configured. Add one with `dino gateway add <name> --command <agent>`.');
+        return;
+    }
+    for (const gateway of gateways) {
+        const command = gateway.command ? ` · ${[gateway.command, ...gateway.args].join(' ')}` : '';
+        printHumanReadableLine(`${gateway.name} (${gateway.kind}, ${gateway.deviceId})${command}`);
+    }
+}
+async function runRemove(context) {
+    const gateway = await removeGateway(await currentUserId(), context.args.gateway ?? '');
+    const statuses = (await isDaemonRunning()) ? await applyToDaemon() : [];
+    if (getRequestedStructuredOutputFormat()) {
+        printSuccess({ removed: describeGateway(gateway), gateways: statuses });
+        return;
+    }
+    printHumanReadableLine(`Removed gateway "${gateway.name}".`);
+}
+async function runStatus() {
+    await ensureDaemonRunning();
+    const { gateways } = (await sendDaemonRequest('gateway.status'));
+    if (getRequestedStructuredOutputFormat()) {
+        printSuccess({ gateways });
+        return;
+    }
+    printStatuses(gateways);
+}
+async function runReload() {
+    const gateways = await applyToDaemon();
+    if (getRequestedStructuredOutputFormat()) {
+        printSuccess({ gateways });
+        return;
+    }
+    printStatuses(gateways);
+}
+const STATUS_FIELDS = ['gatewayId', 'name', 'deviceId', 'kind', 'state', 'connectedAt', 'lastError', 'busyThreadIds', 'agentName'];
+export const gatewayCommandGroup = {
+    name: 'gateway',
+    description: 'Host external agents (Hermes, OpenClaw, pi, Claude Code, ...) as Dinox remote devices',
+    commands: [
+        {
+            name: 'add',
+            description: 'Add an agent gateway and start hosting it in the daemon',
+            arguments: [{ syntax: '<name>', description: 'Display name shown in the Dinox app' }],
+            options: [
+                { flags: '--kind <kind>', description: 'Agent runtime protocol', type: 'string', enum: GATEWAY_KINDS, defaultValue: 'acp' },
+                { flags: '--command <command>', description: 'ACP agent executable (e.g. hermes, openclaw, claude-code-acp)', type: 'string' },
+                { flags: '--arg <value>', description: 'Argument passed to the agent (repeatable, e.g. --arg acp)', type: 'string[]', parser: collect },
+                { flags: '--cwd <dir>', description: 'Working directory for the agent sessions', type: 'string' },
+                { flags: '--env <KEY=VALUE>', description: 'Environment for the agent process, stored locally (repeatable)', type: 'string[]', parser: collect },
+            ],
+            schema: {
+                path: 'gateway.add',
+                risk: 'write',
+                auth: 'required',
+                globalOptions: FORMAT_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'The added gateway and its live device status',
+                    fields: ['gateway', 'status'],
+                },
+                examples: [
+                    'dino gateway add Hermes --command hermes --arg acp --format json',
+                    'dino gateway add Echo --kind echo --format json',
+                ],
+            },
+            action: runAdd,
+        },
+        {
+            name: 'detect',
+            description: 'Find ACP agents installed on this machine (verified with a real handshake)',
+            options: [{ flags: '--add', description: 'Add every verified agent that is not configured yet', type: 'boolean' }],
+            schema: {
+                path: 'gateway.detect',
+                risk: 'write',
+                auth: 'none',
+                globalOptions: FORMAT_OPTIONS,
+                output: {
+                    type: 'structured',
+                    summary: 'Detected agents, gateways added, and their live statuses',
+                    fields: ['agents', 'added', 'gateways'],
+                },
+                examples: ['dino gateway detect --format json', 'dino gateway detect --add --format json'],
+            },
+            action: runDetect,
+        },
+        {
+            name: 'list',
+            description: 'List configured agent gateways (environment values are never shown)',
+            schema: {
+                path: 'gateway.list',
+                risk: 'read',
+                auth: 'none',
+                globalOptions: FORMAT_OPTIONS,
+                output: { type: 'structured', summary: 'Configured gateways', fields: ['gateways', 'file'] },
+                examples: ['dino gateway list --format json'],
+            },
+            action: runList,
+        },
+        {
+            name: 'remove',
+            description: 'Remove an agent gateway and stop hosting it',
+            arguments: [{ syntax: '<gateway>', description: 'Gateway name, id, or device id' }],
+            schema: {
+                path: 'gateway.remove',
+                risk: 'write',
+                auth: 'none',
+                globalOptions: FORMAT_OPTIONS,
+                output: { type: 'structured', summary: 'The removed gateway and remaining statuses', fields: ['removed', 'gateways'] },
+                examples: ['dino gateway remove Hermes --format json'],
+            },
+            action: runRemove,
+        },
+        {
+            name: 'status',
+            description: 'Show live connection status of each hosted gateway',
+            schema: {
+                path: 'gateway.status',
+                risk: 'read',
+                auth: 'required',
+                globalOptions: FORMAT_OPTIONS,
+                output: { type: 'structured', summary: 'Live gateway device statuses', fields: STATUS_FIELDS },
+                examples: ['dino gateway status --format json'],
+            },
+            action: runStatus,
+        },
+        {
+            name: 'mcp',
+            description: 'Serve read-only Dinox knowledge tools over stdio MCP (started by gateway agents)',
+            schema: {
+                path: 'gateway.mcp',
+                risk: 'read',
+                auth: 'required',
+                globalOptions: [],
+                output: { type: 'structured', summary: 'MCP JSON-RPC over stdio until stdin closes', fields: [] },
+                examples: ['dino gateway mcp'],
+            },
+            action: serveDinoxMcpOverStdio,
+        },
+        {
+            name: 'reload',
+            description: 'Re-read gateway configuration in the running daemon',
+            schema: {
+                path: 'gateway.reload',
+                risk: 'write',
+                auth: 'required',
+                globalOptions: FORMAT_OPTIONS,
+                output: { type: 'structured', summary: 'Live gateway device statuses after reload', fields: STATUS_FIELDS },
+                examples: ['dino gateway reload --format json'],
+            },
+            action: runReload,
+        },
+    ],
+};
+export function registerGatewayCommands(program) {
+    registerCommandGroup(program, gatewayCommandGroup);
+}

package/dist/commands/schema/renderSkills.js

@@ -5,6 +5,10 @@ import { listCommandSchemas } from './spec.js';
 const SECTION_ORDER = [
     { title: 'Auth', paths: ['auth.login', 'auth.logout', 'auth.status'] },
     { title: 'Daemon', paths: ['daemon.start', 'daemon.status', 'daemon.restart', 'daemon.stop'] },
+    {
+        title: 'Agent Gateways',
+        paths: ['gateway.detect', 'gateway.add', 'gateway.list', 'gateway.remove', 'gateway.status', 'gateway.reload', 'gateway.mcp'],
+    },
     { title: 'Doctor', paths: ['doctor'] },
     { title: 'Sync', paths: ['sync'] },
     { title: 'Schema', paths: ['schema'] },

package/dist/commands/schema/spec.js

@@ -3,6 +3,7 @@ import { boxCommandGroup } from '../boxes/index.js';
 import { commandSchemasFromGroupDescriptor } from '../descriptor/register.js';
 import { standaloneCommandSchemaFromDescriptor } from '../descriptor/register.js';
 import { configCommandGroup } from '../config/index.js';
+import { gatewayCommandGroup } from '../gateway/index.js';
 import { daemonCommandGroup } from '../../daemon/index.js';
 import { doctorCommandDescriptor } from '../doctor.js';
 import { graphCommandGroup } from '../graph/index.js';
@@ -23,6 +24,7 @@ import { updateCommandDescriptor } from '../update.js';
 export const COMMAND_SCHEMAS = [
     ...commandSchemasFromGroupDescriptor(authCommandGroup),
     ...commandSchemasFromGroupDescriptor(configCommandGroup),
+    ...commandSchemasFromGroupDescriptor(gatewayCommandGroup),
     ...commandSchemasFromGroupDescriptor(daemonCommandGroup),
     standaloneCommandSchemaFromDescriptor(doctorCommandDescriptor),
     standaloneCommandSchemaFromDescriptor(syncCommandDescriptor),

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