@dinoxx/dinox-cli 2.13.1 → 2.15.0

package/dist/daemon/supervisor.js

@@ -8,6 +8,8 @@ import { DinoxError } from '../utils/errors.js';
 /** Set in the service definition so the daemon can report who supervises it. */
 export const DAEMON_SERVICE_ENV = 'DINOX_DAEMON_SUPERVISOR';
 const DEFAULT_LABEL = 'com.dinox.cli.daemon';
+/** Windows: file in the daemon directory telling the supervisor not to restart. */
+export const SUPERVISOR_STOP_MARKER = 'supervisor.stop';
 const COMMAND_TIMEOUT_MS = 15_000;
 const LAUNCHD_BOOTSTRAP_ATTEMPTS = 5;
 const LAUNCHD_BOOTSTRAP_RETRY_MS = 300;
@@ -54,6 +56,21 @@ function xmlEscape(value) {
         .replace(/>/g, '>')
         .replace(/"/g, '"');
 }
+function xmlUnescape(value) {
+    return value
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&apos;/g, "'")
+        .replace(/&amp;/g, '&');
+}
+/** ProgramArguments of a plist written by renderLaunchdPlist. */
+export function parseLaunchdProgramArguments(plist) {
+    const array = /<key>ProgramArguments<\/key>\s*<array>([\s\S]*?)<\/array>/.exec(plist);
+    if (!array)
+        return null;
+    return [...array[1].matchAll(/<string>([\s\S]*?)<\/string>/g)].map((match) => xmlUnescape(match[1]));
+}
 export function renderLaunchdPlist(label, spec) {
     const string = (value) => `<string>${xmlEscape(value)}</string>`;
     const args = [spec.program, ...spec.args].map((arg) => `\t\t${string(arg)}`).join('\n');
@@ -80,10 +97,7 @@ ${env}
 \t<key>RunAtLoad</key>
 \t<true/>
 \t<key>KeepAlive</key>
-\t<dict>
-\t\t<key>SuccessfulExit</key>
-\t\t<false/>
-\t</dict>
+\t<true/>
 \t<key>ThrottleInterval</key>
 \t<integer>30</integer>
 \t<key>StandardOutPath</key>
@@ -117,6 +131,10 @@ class LaunchdService {
     isCurrent(spec) {
         return readDefinition(this.definitionPath) === this.render(spec);
     }
+    installedCommand() {
+        const plist = readDefinition(this.definitionPath);
+        return plist === null ? null : parseLaunchdProgramArguments(plist);
+    }
     async isLoaded() {
         return (await this.run('launchctl', ['print', this.target])).code === 0;
     }
@@ -147,6 +165,18 @@ class LaunchdService {
         if (result.code !== 0)
             throw failed(this.kind, 'kickstart', result);
     }
+    async stop() {
+        const result = await this.run('launchctl', ['bootout', this.target]);
+        if (result.code !== 0 && await this.isLoaded())
+            throw failed(this.kind, 'bootout', result);
+    }
+    async restart() {
+        if (!(await this.isLoaded()))
+            await this.bootstrap();
+        const result = await this.run('launchctl', ['kickstart', '-k', this.target]);
+        if (result.code !== 0)
+            throw failed(this.kind, 'kickstart', result);
+    }
     async uninstall() {
         const installed = this.isInstalled();
         if (await this.isLoaded()) {
@@ -170,6 +200,16 @@ function systemdQuote(value) {
         .replace(/\n/g, '\\n');
     return `"${escaped}"`;
 }
+/** The words of an ExecStart line written by renderSystemdUnit. */
+export function parseSystemdExecStart(unit) {
+    const line = /^ExecStart=(.*)$/m.exec(unit);
+    if (!line)
+        return null;
+    return [...line[1].matchAll(/"((?:[^"\\]|\\.)*)"/g)].map((match) => match[1]
+        .replace(/%%/g, '%')
+        .replace(/\$\$/g, '$')
+        .replace(/\\(.)/g, (_, char) => (char === 'n' ? '\n' : char)));
+}
 export function renderSystemdUnit(spec) {
     const execStart = [spec.program, ...spec.args].map(systemdQuote).join(' ');
     const env = Object.keys(spec.env)
@@ -185,8 +225,8 @@ Type=simple
 ExecStart=${execStart}
 WorkingDirectory=${spec.workingDirectory.replace(/%/g, '%%')}
 ${env}
-Restart=on-failure
-RestartSec=30
+Restart=always
+RestartSec=5
 StandardOutput=append:${spec.logPath}
 StandardError=append:${spec.logPath}
 
@@ -215,6 +255,10 @@ class SystemdService {
     isCurrent(spec) {
         return readDefinition(this.definitionPath) === this.render(spec);
     }
+    installedCommand() {
+        const unit = readDefinition(this.definitionPath);
+        return unit === null ? null : parseSystemdExecStart(unit);
+    }
     async systemctl(step, ...args) {
         const result = await this.run('systemctl', ['--user', ...args]);
         if (result.code !== 0)
@@ -229,6 +273,12 @@ class SystemdService {
     async start() {
         await this.systemctl('start', 'start', this.unit);
     }
+    async stop() {
+        await this.systemctl('stop', 'stop', this.unit);
+    }
+    async restart() {
+        await this.systemctl('restart', 'restart', this.unit);
+    }
     async uninstall() {
         if (!this.isInstalled())
             return false;
@@ -260,6 +310,57 @@ export function quoteWindowsArg(value) {
     }
     return `${quoted}${'\\'.repeat(backslashes * 2)}"`;
 }
+/** Splits a command line the way the Windows C runtime does (the inverse of quoteWindowsArg). */
+export function splitWindowsCommandLine(commandLine) {
+    const args = [];
+    let current = '';
+    let inArg = false;
+    let quoted = false;
+    for (let index = 0; index < commandLine.length; index += 1) {
+        const char = commandLine[index];
+        if (char === '\\') {
+            let backslashes = 0;
+            while (commandLine[index] === '\\') {
+                backslashes += 1;
+                index += 1;
+            }
+            if (commandLine[index] === '"') {
+                current += '\\'.repeat(Math.floor(backslashes / 2));
+                if (backslashes % 2 === 1)
+                    current += '"';
+                else
+                    quoted = !quoted;
+            }
+            else {
+                current += '\\'.repeat(backslashes);
+                index -= 1;
+            }
+            inArg = true;
+        }
+        else if (char === '"') {
+            quoted = !quoted;
+            inArg = true;
+        }
+        else if (/\s/.test(char) && !quoted) {
+            if (inArg)
+                args.push(current);
+            current = '';
+            inArg = false;
+        }
+        else {
+            current += char;
+            inArg = true;
+        }
+    }
+    if (inArg)
+        args.push(current);
+    return args;
+}
+/** The command line of a launcher written by renderWindowsLauncher. */
+export function parseWindowsLauncherCommand(launcher) {
+    const line = /^shell\.Run "((?:[^"]|"")*)", 0, False\r?$/m.exec(launcher);
+    return line ? splitWindowsCommandLine(line[1].replace(/""/g, '"')) : null;
+}
 function vbsString(value) {
     return `"${value.replace(/"/g, '""').replace(/\r?\n/g, '" & vbLf & "')}"`;
 }
@@ -366,6 +467,10 @@ class WindowsTaskService {
     isCurrent(spec) {
         return readUtf16(this.definitionPath) === this.render(spec);
     }
+    installedCommand() {
+        const launcher = readUtf16(this.definitionPath);
+        return launcher === null ? null : parseWindowsLauncherCommand(launcher);
+    }
     async isRegistered() {
         return (await this.run('schtasks', ['/Query', '/TN', this.taskName])).code === 0;
     }
@@ -398,15 +503,29 @@ class WindowsTaskService {
             throw failed(this.kind, 'run', result);
     }
     async install(spec) {
+        this.clearStopMarker();
         writeUtf16(this.definitionPath, this.render(spec));
         await this.register();
         await this.runTask();
     }
     async start() {
+        this.clearStopMarker();
         if (!(await this.isRegistered()))
             await this.register();
         await this.runTask();
     }
+    async stop() {
+        mkdirSync(this.launcherDir, { recursive: true });
+        writeFileSync(path.join(this.launcherDir, SUPERVISOR_STOP_MARKER), '');
+    }
+    async restart() {
+        this.clearStopMarker();
+    }
+    clearStopMarker() {
+        const marker = path.join(this.launcherDir, SUPERVISOR_STOP_MARKER);
+        if (existsSync(marker))
+            unlinkSync(marker);
+    }
     async uninstall() {
         const installed = this.isInstalled();
         if (await this.isRegistered()) {

package/dist/daemon/types.d.ts

@@ -12,6 +12,11 @@ export type DaemonResponse = {
 };
 export type DaemonShutdownParams = {
     expectedInstanceId: string;
+    requester?: {
+        pid: number;
+        version: string;
+        command?: string;
+    };
 };
 export type DaemonShutdownResult = {
     stopping: true;
@@ -47,3 +52,20 @@ export type DaemonPingResult = {
 };
 /** Kept only for old scripts that pass --port; the daemon transport is socket-based. */
 export declare const DEFAULT_DAEMON_PORT = 45678;
+export type CommandExecuteParams = {
+    argv: string[];
+    cwd: string;
+    clientVersion: string;
+    requestId?: string;
+    /** Answer as NDJSON: `{"progress": text}` frames while the command runs, then the response. */
+    stream?: boolean;
+};
+/** A frame the daemon streams ahead of a `stream: true` response. */
+export type CommandExecuteFrame = {
+    progress: string;
+};
+export type CommandExecuteResult = {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+};

package/dist/dinox.js

@@ -1,70 +1,49 @@
 #!/usr/bin/env node
-import { createCli } from './cli.js';
-import { buildStructuredErrorPayload, isDinoxError } from './utils/errors.js';
-import { clearRequestedStructuredOutputFormat, parseStructuredOutputFormatFromArgv, printError, printHumanReadableError, setRequestedStructuredOutputFormat, } from './utils/output.js';
+import { commandExecutionTarget, tryForwardToDaemon } from './daemon/forward.js';
+import { applyDefaultFormat } from './utils/defaultFormat.js';
+import { getPackageVersion } from './utils/version.js';
+import { requestIdFromArgv, runWithRequestId } from './requests/store.js';
+import { isDinoxError } from './utils/errors.js';
 import { exitProcessAfterFlushing } from './utils/processExit.js';
-function normalizeArgv(argv) {
-    // pnpm/npm script forwarding can prepend a standalone "--".
-    if (argv[0] === '--') {
-        return argv.slice(1);
-    }
-    return argv;
-}
-async function main() {
-    const program = createCli();
-    const argv = normalizeArgv(process.argv.slice(2));
-    const executable = process.argv[1] ?? 'dino';
-    await program.parseAsync(['node', executable, ...argv]);
+import { localCommandExecution } from './utils/requestContext.js';
+/** `--progress` before `--`: the daemon streams events back while it runs the command. */
+function wantsProgress(args) {
+    const end = args.indexOf('--');
+    return (end === -1 ? args : args.slice(0, end)).includes('--progress');
 }
-function isVerbose(argv) {
-    return argv.includes('--verbose');
+let argv = process.argv.slice(2);
+let fatalError;
+try {
+    argv = applyDefaultFormat(argv);
+    const versionOnly = argv.length === 1 && ['--version', '-V'].includes(argv[0]);
+    const forwarded = versionOnly
+        ? { stdout: `${getPackageVersion()}\n`, stderr: '', exitCode: 0 }
+        : await tryForwardToDaemon(argv, wantsProgress(argv) ? { onProgress: (text) => process.stderr.write(text) } : {});
+    if (forwarded) {
+        process.stdout.write(forwarded.stdout);
+        process.stderr.write(forwarded.stderr);
+        process.exitCode = forwarded.exitCode;
+    }
+    else {
+        const { runCli } = await import('./runCli.js');
+        const key = requestIdFromArgv(argv);
+        if (key && commandExecutionTarget(argv) === 'daemon') {
+            const { runCapturedInProcess } = await import('./requests/execute.js');
+            const result = await runWithRequestId(key, argv, () => runCapturedInProcess(argv, error => { fatalError = error; }));
+            process.stdout.write(result.stdout);
+            process.stderr.write(result.stderr);
+            process.exitCode = result.exitCode;
+        }
+        else {
+            process.exitCode = await localCommandExecution.run(true, () => runCli(argv, error => { fatalError = error; }));
+        }
+    }
 }
-function isCommanderError(error) {
-    return Boolean(error)
-        && typeof error === 'object'
-        && typeof error.code === 'string'
-        && error.code.startsWith('commander.')
-        && typeof error.exitCode === 'number';
+catch (error) {
+    // Routing failures use the same printer as command failures.
+    const { printCliError } = await import('./runCli.js');
+    process.exitCode = printCliError(error, argv);
 }
-async function exitAfterFatalCleanup(error, exitCode) {
-    if (isDinoxError(error) && error.requiresProcessExit) {
-        await exitProcessAfterFlushing(exitCode);
-    }
+if (isDinoxError(fatalError) && fatalError.requiresProcessExit) {
+    await exitProcessAfterFlushing(Number(process.exitCode));
 }
-main().catch(async (error) => {
-    if (isCommanderError(error)) {
-        process.exitCode = error.exitCode === 0 ? 0 : 2;
-        return;
-    }
-    const argv = normalizeArgv(process.argv.slice(2));
-    let format = null;
-    try {
-        format = parseStructuredOutputFormatFromArgv(argv);
-    }
-    catch {
-        format = null;
-    }
-    const verbose = isVerbose(argv);
-    const payload = buildStructuredErrorPayload(error, verbose);
-    const exitCode = isDinoxError(error) ? error.exitCode : 1;
-    process.exitCode = exitCode;
-    if (format) {
-        setRequestedStructuredOutputFormat(format);
-        printError(payload, format);
-        clearRequestedStructuredOutputFormat();
-        await exitAfterFatalCleanup(error, exitCode);
-        return;
-    }
-    printHumanReadableError(payload.message);
-    if (payload.suggested_action) {
-        printHumanReadableError(`suggested action: ${payload.suggested_action.command}`);
-        printHumanReadableError(`reason: ${payload.suggested_action.reason}`);
-    }
-    else if (payload.suggestion) {
-        printHumanReadableError(`suggestion: ${payload.suggestion}`);
-    }
-    if (verbose && payload.stack) {
-        printHumanReadableError(payload.stack);
-    }
-    await exitAfterFatalCleanup(error, exitCode);
-});

package/dist/gateway/deviceHost.js

@@ -1,5 +1,6 @@
 import os from 'node:os';
 import { credsAuthenticator, wsconnect, } from '@nats-io/nats-core';
+import { AI_SERVICE_URL } from '../config/serviceEndpoints.js';
 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';
@@ -9,7 +10,7 @@ import { RunStreamPublisher } from './streamPublisher.js';
 import { findRun, readRecentSessionFolders, resolveTrustedResource, TERMINAL_RUN_STATUSES, threadExists, } from './threadStore.js';
 import { uploadToOfficialStorage } from './fileUpload.js';
 import { agentHomeFolder, ensureAgentHomeFolder, existingWorkspaceFolders, listWorkspaceFolders, resolveWorkspaceFolder, WorkspaceFolderError, } from './workspaceFolders.js';
-export const DEFAULT_NATS_CREDENTIALS_URL = 'https://aisdk.chatgo.pro/api/nats/credentials';
+export const DEFAULT_NATS_CREDENTIALS_URL = `${AI_SERVICE_URL}/api/nats/credentials`;
 const CREDENTIALS_TIMEOUT_MS = 10_000;
 const CREDENTIALS_REFRESH_LEAD_MS = 60_000;
 const ACK_CACHE_TTL_MS = 10 * 60 * 1000;

package/dist/gateway/mcpCommandTools.d.ts

@@ -1,27 +1,46 @@
+import { type ExecFileOptionsWithStringEncoding } from 'node:child_process';
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 import type { CommandSchema } from '../commands/schema/types.js';
+import { tryForwardToDaemon } from '../daemon/forward.js';
+import { MCP_COMMAND_GROUPS, type McpCommandGroup } from './mcpGroups.js';
 /**
  * One MCP tool per command group, generated from the command schemas. Each runs
  * the real CLI as a child process without a shell, preserving the CLI's own
  * validation, dry-run and confirmation guards. Approval belongs to the agent's
  * permission flow, guided by the tool annotations.
  */
-/** Command groups exposed as MCP tools. */
-export declare const MCP_COMMAND_GROUPS: readonly ["note", "tag", "box", "todo", "view", "prop", "template", "prompt", "graph", "storage", "meta.stats"];
+export { MCP_COMMAND_GROUPS, type McpCommandGroup };
 /** Commands deliberately excluded from the MCP surface. */
-export declare const MCP_COMMAND_EXCLUSIONS: readonly ["auth.*", "config.*", "daemon.*", "gateway.*", "doctor", "skills.*", "update", "sync", "info", "schema", "meta.schema"];
+export declare const MCP_COMMAND_EXCLUSIONS: readonly ["auth.*", "config.*", "daemon.*", "gateway.*", "doctor", "skills.*", "update", "sync", "info", "schema", "meta.schema", "batch", "mcp"];
+export type CommandToolOptions = {
+    /** Only commands whose risk is `read`; groups left without any are dropped. */
+    readOnly?: boolean;
+    /** Subset of MCP_COMMAND_GROUPS to expose; default all. */
+    groups?: readonly McpCommandGroup[];
+    /** The curated search_notes/read_note/... tools are registered alongside. */
+    knowledgeTools?: boolean;
+};
+/** The tool name a command group is published under. */
+export declare function commandToolName(group: McpCommandGroup): string;
 /** Runs a CLI invocation and captures its output. */
 export type CommandRunner = (argv: string[]) => Promise<{
     stdout: string;
     stderr: string;
 }>;
 /** Runs the current CLI entry point without a shell. */
+export declare function createCliCommandRunner(overrides?: {
+    forward?: typeof tryForwardToDaemon;
+    execute?: (file: string, args: string[], options: ExecFileOptionsWithStringEncoding) => Promise<{
+        stdout: string;
+        stderr: string;
+    }>;
+}): CommandRunner;
 export declare const runCliCommand: CommandRunner;
 /** Validates tool inputs and builds CLI arguments in schema order. */
 export declare function commandArgv(schema: CommandSchema, input: Record<string, unknown>): string[];
 /** Builds grouped MCP tool definitions from the command schemas. */
-export declare function commandToolDefinitions(): {
+export declare function commandToolDefinitions(options?: CommandToolOptions): {
     name: string;
     commands: CommandSchema[];
     config: {
@@ -40,4 +59,4 @@ export declare function commandToolDefinitions(): {
     };
 }[];
 /** Registers command tools using the real CLI or an injected runner. */
-export declare function registerCommandTools(server: McpServer, runner?: CommandRunner): void;
+export declare function registerCommandTools(server: McpServer, runner?: CommandRunner, options?: CommandToolOptions): void;

package/dist/gateway/mcpCommandTools.js

@@ -2,32 +2,68 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { z } from 'zod';
 import { listCommandSchemas } from '../commands/schema/spec.js';
+import { tryForwardToDaemon } from '../daemon/forward.js';
+import { MCP_COMMAND_GROUPS } from './mcpGroups.js';
+import { requestContext } from '../utils/requestContext.js';
 /**
  * One MCP tool per command group, generated from the command schemas. Each runs
  * the real CLI as a child process without a shell, preserving the CLI's own
  * validation, dry-run and confirmation guards. Approval belongs to the agent's
  * permission flow, guided by the tool annotations.
  */
-/** Command groups exposed as MCP tools. */
-export const MCP_COMMAND_GROUPS = [
-    'note', 'tag', 'box', 'todo', 'view', 'prop', 'template', 'prompt', 'graph', 'storage', 'meta.stats',
-];
+export { MCP_COMMAND_GROUPS };
 /** Commands deliberately excluded from the MCP surface. */
 export const MCP_COMMAND_EXCLUSIONS = [
     'auth.*', 'config.*', 'daemon.*', 'gateway.*', 'doctor', 'skills.*', 'update', 'sync', 'info', 'schema', 'meta.schema',
+    // MCP clients issue several tool calls themselves; batch is the shell's equivalent.
+    'batch',
+    // The MCP server itself.
+    'mcp',
 ];
+/** The tool name a command group is published under. */
+export function commandToolName(group) {
+    return group === 'meta.stats' ? 'dinox_stats' : `dinox_${group}`;
+}
 const execute = promisify(execFile);
 /** Runs the current CLI entry point without a shell. */
-export const runCliCommand = (argv) => {
-    const entryPoint = process.argv[1];
-    if (entryPoint === undefined)
-        throw new Error('Cannot run CLI command: process.argv[1] is undefined');
-    return execute(process.execPath, [...process.execArgv, entryPoint, ...argv], {
-        env: process.env,
-        timeout: 120_000,
-        maxBuffer: 32 * 1024 * 1024,
-    });
-};
+export function createCliCommandRunner(overrides = {}) {
+    return (argv) => {
+        const entryPoint = process.argv[1];
+        if (entryPoint === undefined)
+            throw new Error('Cannot run CLI command: process.argv[1] is undefined');
+        return (async () => {
+            let result;
+            try {
+                result = await (overrides.forward ?? tryForwardToDaemon)(argv);
+            }
+            catch (error) {
+                const context = {
+                    stdout: [], stderr: [], format: null, noticeProvider: null, cwd: process.cwd(),
+                };
+                const { printCliError } = await import('../runCli.js');
+                const code = requestContext.run(context, () => printCliError(error, argv));
+                throw Object.assign(new Error(`Command failed with exit code ${code}`), {
+                    code, stdout: context.stdout.join(''), stderr: context.stderr.join(''),
+                });
+            }
+            if (result) {
+                if (result.exitCode !== 0) {
+                    throw Object.assign(new Error(`Command failed with exit code ${result.exitCode}`), {
+                        code: result.exitCode, stdout: result.stdout, stderr: result.stderr,
+                    });
+                }
+                return result;
+            }
+            return (overrides.execute ?? execute)(process.execPath, [...process.execArgv, entryPoint, ...argv], {
+                encoding: 'utf8',
+                env: process.env,
+                timeout: 120_000,
+                maxBuffer: 32 * 1024 * 1024,
+            });
+        })();
+    };
+}
+export const runCliCommand = createCliCommandRunner();
 function key(name) {
     return name
         .replace(/^[<[.]+|[>\].]+$/g, '')
@@ -139,28 +175,33 @@ export function commandArgv(schema, input) {
     return [...schema.path.split('.'), ...flags, '--format', 'json', '--', ...positionals];
 }
 /** Builds grouped MCP tool definitions from the command schemas. */
-export function commandToolDefinitions() {
-    return MCP_COMMAND_GROUPS.map((group) => {
-        const commands = listCommandSchemas().filter((schema) => group === 'meta.stats' ? schema.path === group : schema.path.startsWith(`${group}.`));
+export function commandToolDefinitions(options = {}) {
+    const { readOnly = false, groups = MCP_COMMAND_GROUPS, knowledgeTools = true } = options;
+    return MCP_COMMAND_GROUPS.filter((group) => groups.includes(group)).flatMap((group) => {
+        const commands = listCommandSchemas().filter((schema) => (group === 'meta.stats' ? schema.path === group : schema.path.startsWith(`${group}.`))
+            && (!readOnly || schema.risk === 'read'));
+        if (commands.length === 0)
+            return [];
         const actions = commands.map(actionName);
-        const description = 'Dinox CLI commands. search_notes/read_note/search_todos/related_notes are the fast daemon-backed path for plain search/read. ' +
+        const description = 'Dinox CLI commands. ' +
+            (knowledgeTools ? 'search_notes/read_note/search_todos/related_notes are the fast daemon-backed path for plain search/read. ' : '') +
             'High-risk writes need dryRun: true first, then the CLI confirmation options listed below (e.g. confirm/expectedCount); ' +
             'CLI guards enforce them. Input keys are camelCase.\n' +
             commands.map(describeAction).join('\n');
-        return {
-            name: group === 'meta.stats' ? 'dinox_stats' : `dinox_${group}`,
-            commands,
-            config: {
-                description,
-                annotations: { ...toolAnnotations(commands), openWorldHint: group === 'storage' },
-                inputSchema: { action: z.enum(actions), input: z.record(z.string(), z.unknown()).optional() },
-            },
-        };
+        return [{
+                name: commandToolName(group),
+                commands,
+                config: {
+                    description,
+                    annotations: { ...toolAnnotations(commands), openWorldHint: group === 'storage' },
+                    inputSchema: { action: z.enum(actions), input: z.record(z.string(), z.unknown()).optional() },
+                },
+            }];
     });
 }
 /** Registers command tools using the real CLI or an injected runner. */
-export function registerCommandTools(server, runner = runCliCommand) {
-    for (const tool of commandToolDefinitions()) {
+export function registerCommandTools(server, runner = runCliCommand, options = {}) {
+    for (const tool of commandToolDefinitions(options)) {
         server.registerTool(tool.name, tool.config, async ({ action, input }) => {
             try {
                 const schema = tool.commands.find((command) => actionName(command) === action);

package/dist/gateway/mcpEnv.d.ts

@@ -5,3 +5,5 @@ export declare const GATEWAY_SESSION_TOKEN_ENV = "DINOX_GATEWAY_SESSION_TOKEN";
 export declare const GATEWAY_KNOWLEDGE_TOOLS_ENV = "DINOX_GATEWAY_KNOWLEDGE_TOOLS";
 /** Must not collide with MCP servers the user already registered with the agent. */
 export declare const DINOX_MCP_SERVER_NAME = "dinox-gateway";
+/** `dino mcp`, the server users register with their own MCP clients. */
+export declare const DINOX_STANDALONE_MCP_SERVER_NAME = "dinox";

package/dist/gateway/mcpEnv.js

@@ -5,3 +5,5 @@ export const GATEWAY_SESSION_TOKEN_ENV = 'DINOX_GATEWAY_SESSION_TOKEN';
 export const GATEWAY_KNOWLEDGE_TOOLS_ENV = 'DINOX_GATEWAY_KNOWLEDGE_TOOLS';
 /** Must not collide with MCP servers the user already registered with the agent. */
 export const DINOX_MCP_SERVER_NAME = 'dinox-gateway';
+/** `dino mcp`, the server users register with their own MCP clients. */
+export const DINOX_STANDALONE_MCP_SERVER_NAME = 'dinox';

package/dist/gateway/mcpGroups.d.ts

@@ -0,0 +1,3 @@
+/** Command groups exposed as MCP tools. Kept free of imports: command descriptors read it at load time. */
+export declare const MCP_COMMAND_GROUPS: readonly ["note", "tag", "box", "todo", "view", "prop", "template", "prompt", "graph", "storage", "meta.stats"];
+export type McpCommandGroup = (typeof MCP_COMMAND_GROUPS)[number];

package/dist/gateway/mcpGroups.js

@@ -0,0 +1,4 @@
+/** Command groups exposed as MCP tools. Kept free of imports: command descriptors read it at load time. */
+export const MCP_COMMAND_GROUPS = [
+    'note', 'tag', 'box', 'todo', 'view', 'prop', 'template', 'prompt', 'graph', 'storage', 'meta.stats',
+];

package/dist/gateway/mcpServer.d.ts

@@ -1,4 +1,4 @@
-import { type CommandRunner } from './mcpCommandTools.js';
+import { type CommandRunner, type CommandToolOptions } from './mcpCommandTools.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 export type DaemonCall = (method: string, params?: unknown, options?: {
     timeoutMs?: number;
@@ -13,4 +13,13 @@ export type DinoxMcpOptions = {
     cwd?: string;
 };
 export declare function createDinoxMcpServer(call?: DaemonCall, options?: DinoxMcpOptions): McpServer;
+/**
+ * The Dinox MCP server for any MCP client (`dino mcp`). Only the generated
+ * command tools: they reach the daemon when it is available and otherwise run
+ * the CLI in a child process, so no daemon is required.
+ */
+export declare function createStandaloneMcpServer(options?: Omit<CommandToolOptions, 'knowledgeTools'> & {
+    commandRunner?: CommandRunner;
+}): McpServer;
 export declare function serveDinoxMcpOverStdio(): Promise<void>;
+export declare function serveStandaloneMcpOverStdio(options: Omit<CommandToolOptions, 'knowledgeTools'>): Promise<void>;