@dinoxx/dinox-cli 2.14.0 → 2.16.0

package/dist/gateway/adapters/acp.js

@@ -140,7 +140,7 @@ export class AcpGatewayAdapter {
         };
         input.signal.addEventListener('abort', onAbort, { once: true });
         try {
-            const text = created && input.sessionPreamble ? `${input.sessionPreamble}\n\n${input.prompt}` : input.prompt;
+            const text = await input.prompt({ created });
             const prompt = [{ type: 'text', text }];
             for (const resource of input.resources) {
                 prompt.push({ type: 'resource_link', uri: resource.uri, name: resource.name, mimeType: resource.mediaType ?? null });
@@ -170,16 +170,23 @@ export class AcpGatewayAdapter {
         turn.sent += 1;
         return turn.sendFile(file);
     }
+    catalogExpiresAt = 0;
+    catalogRevision = 0;
+    probing = null;
     async describeConfig() {
-        if (this.catalog)
+        if (this.catalog && Date.now() < this.catalogExpiresAt)
             return this.catalog;
+        if (!this.probing)
+            this.probing = this.probeConfig().finally(() => { this.probing = null; });
+        return this.probing;
+    }
+    async probeConfig() {
         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,
         // so close it where the agent allows, or it shows up in the user's session list.
+        const revision = this.catalogRevision;
         const created = await agent.connection.newSession({ cwd: this.gateway.cwd ?? os.homedir(), mcpServers: [] });
-        this.rememberConfig(agent, created.sessionId, created.configOptions);
+        this.rememberConfig(agent, created.sessionId, created.configOptions, revision === this.catalogRevision);
         if (agent.init.agentCapabilities?.sessionCapabilities?.close) {
             await agent.connection.closeSession({ sessionId: created.sessionId }).catch((error) => this.log('closing the settings session failed', { error: String(error) }));
         }
@@ -221,7 +228,7 @@ export class AcpGatewayAdapter {
             try {
                 // No turn is registered yet, so the history the agent replays is ignored.
                 const token = crypto.randomBytes(18).toString('base64url');
-                const loaded = await agent.connection.loadSession({ sessionId, cwd, mcpServers: this.mcpServers(token) });
+                const loaded = await agent.connection.loadSession({ sessionId, cwd, mcpServers: this.mcpServers(token, cwd) });
                 this.sessionTokens.set(token, sessionId);
                 agent.liveSessions.add(sessionId);
                 this.rememberConfig(agent, sessionId, loaded.configOptions);
@@ -232,7 +239,7 @@ export class AcpGatewayAdapter {
             }
         }
         const token = crypto.randomBytes(18).toString('base64url');
-        const created = await agent.connection.newSession({ cwd, mcpServers: this.mcpServers(token) });
+        const created = await agent.connection.newSession({ cwd, mcpServers: this.mcpServers(token, cwd) });
         this.sessionTokens.set(token, created.sessionId);
         agent.liveSessions.add(created.sessionId);
         this.rememberConfig(agent, created.sessionId, created.configOptions);
@@ -260,12 +267,17 @@ export class AcpGatewayAdapter {
             }
         }
     }
-    rememberConfig(agent, sessionId, options) {
+    rememberConfig(agent, sessionId, options, updateCatalog = true) {
         if (!options)
             return;
         const normalized = normalizeConfigOptions(options);
         agent.sessionConfig.set(sessionId, normalized);
-        this.catalog = normalized;
+        // A slow probe must not overwrite a newer live session update.
+        if (updateCatalog) {
+            this.catalog = normalized;
+            this.catalogExpiresAt = Date.now() + 5 * 60_000;
+            this.catalogRevision += 1;
+        }
     }
     ensureProcess() {
         if (this.process)

package/dist/gateway/adapters/echo.js

@@ -24,18 +24,21 @@ export class EchoGatewayAdapter {
     async runTurn(input) {
         const sessionId = input.sessionId ?? `echo-${generateId()}`;
         try {
-            if (input.prompt.includes('/approve')) {
+            const text = await input.prompt({ created: input.sessionId === null });
+            // Echo the user text while exercising the full prompt factory.
+            const prompt = text.replace(/<dinox_(delivery|knowledge|agent_instructions)>[\s\S]*?<\/dinox_\1>\n\n/g, '');
+            if (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 } });
+                input.onEvent({ type: 'tool', toolCallId, title: 'echo.write', status: 'pending', input: { text: prompt } });
+                input.onEvent({ type: 'approval-request', approvalId, toolCallId, toolName: 'echo.write', input: { text: 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+)/)) {
+            for (const word of `Echo: ${prompt}`.split(/(\s+)/)) {
                 await delay(CHUNK_DELAY_MS, input.signal);
                 input.onEvent({ type: 'text-delta', text: word });
             }

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

@@ -8,5 +8,6 @@ import type { GatewayAdapter, GatewayDefinition } from '../types.js';
 export declare function dinoxMcpServerConfig(options: {
     sessionToken: string;
     knowledgeTools: boolean;
+    cwd?: string;
 }): McpServer | null;
 export declare function createGatewayAdapter(gateway: GatewayDefinition, log: (message: string, details?: Record<string, unknown>) => void): GatewayAdapter;

package/dist/gateway/adapters/index.js

@@ -1,4 +1,4 @@
-import { DINOX_MCP_SERVER_NAME, GATEWAY_KNOWLEDGE_TOOLS_ENV, GATEWAY_SESSION_TOKEN_ENV } from '../mcpEnv.js';
+import { DINOX_MCP_SERVER_NAME, GATEWAY_SESSION_CWD_ENV, GATEWAY_KNOWLEDGE_TOOLS_ENV, GATEWAY_SESSION_TOKEN_ENV } from '../mcpEnv.js';
 import { AcpGatewayAdapter } from './acp.js';
 import { EchoGatewayAdapter } from './echo.js';
 /**
@@ -12,6 +12,7 @@ export function dinoxMcpServerConfig(options) {
         return null;
     const inherited = Object.entries(process.env).filter((entry) => entry[0].startsWith('DINOX_') &&
         entry[0] !== GATEWAY_SESSION_TOKEN_ENV &&
+        entry[0] !== GATEWAY_SESSION_CWD_ENV &&
         entry[0] !== GATEWAY_KNOWLEDGE_TOOLS_ENV &&
         typeof entry[1] === 'string');
     return {
@@ -20,6 +21,7 @@ export function dinoxMcpServerConfig(options) {
         args: [...process.execArgv, entrypoint, 'gateway', 'mcp'],
         env: [
             ...inherited,
+            [GATEWAY_SESSION_CWD_ENV, options.cwd ?? process.cwd()],
             [GATEWAY_SESSION_TOKEN_ENV, options.sessionToken],
             [GATEWAY_KNOWLEDGE_TOOLS_ENV, options.knowledgeTools ? '1' : '0'],
         ].map(([name, value]) => ({ name, value })),
@@ -30,8 +32,8 @@ export function createGatewayAdapter(gateway, log) {
         case 'acp':
             // Read per session, so turning the knowledge tools off applies to the next new conversation.
             // `send_file` stays offered either way: it is how the agent hands the user a file.
-            return new AcpGatewayAdapter(gateway, log, (sessionToken) => {
-                const tools = dinoxMcpServerConfig({ sessionToken, knowledgeTools: gateway.dinoxTools !== false });
+            return new AcpGatewayAdapter(gateway, log, (sessionToken, cwd) => {
+                const tools = dinoxMcpServerConfig({ sessionToken, cwd, knowledgeTools: gateway.dinoxTools !== false });
                 return tools ? [tools] : [];
             });
         case 'echo':

package/dist/gateway/deviceHost.d.ts

@@ -77,8 +77,10 @@ export declare class GatewayDeviceHost {
     private publishRunEvent;
     private flushPendingEvents;
     private handleDiscover;
-    /** Only the gateway's own queries are served; desktop queries (skills, workspace) are not advertised. */
+    /** Every reply-bearing query gets a result, including unsupported extensions. */
     private handleQuery;
+    private dispatchQuery;
+    private prepareFolder;
     private settingsResult;
     private changeSettings;
     private listFolders;

package/dist/gateway/deviceHost.js

@@ -1,15 +1,17 @@
 import os from 'node:os';
+import { listGatewayWorkspace } from './workspaceListing.js';
 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';
-import { isAgentConfigQuery, isAgentFoldersQuery, isAgentSettingsQuery, isCancelRequest, isRunStatusRequest, readAgentSettingsUpdate, reconnectDelayMs, validateApprovalRequest, validateRunRequest, } from './protocol.js';
+import { isAgentConfigQuery, isAgentFolderPrepareQuery, isAgentFoldersQuery, isAgentSettingsQuery, isCancelRequest, isRunStatusRequest, readAgentSettingsUpdate, reconnectDelayMs, validateApprovalRequest, validateRunRequest, } from './protocol.js';
 import { GatewayRunExecutor, MAX_QUEUED_TURNS, QueueFullError } from './runExecutor.js';
 import { RunStreamPublisher } from './streamPublisher.js';
-import { findRun, readRecentSessionFolders, resolveTrustedResource, TERMINAL_RUN_STATUSES, threadExists, } from './threadStore.js';
+import { findRun, readRecentSessionFolders, readSessionBinding, 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;
@@ -239,6 +241,7 @@ export class GatewayDeviceHost {
             connectedAt: this.connectedAt ?? new Date().toISOString(),
             busyThreadIds: this.executor.busyThreadIds(),
             capabilities: {
+                workspace: { list: true, scope: 'thread', filePreview: false },
                 threadRun: true,
                 cancel: true,
                 stream: 'assistant-snapshot',
@@ -249,6 +252,7 @@ export class GatewayDeviceHost {
         // 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 = {
+            agentWorkspace: true,
             kind: 'gateway',
             gatewayId: this.deps.gateway.id,
             runtime: this.deps.gateway.kind,
@@ -333,17 +337,55 @@ export class GatewayDeviceHost {
             return;
         msg.respond(encode({ protocolVersion: REMOTE_DEVICE_PROTOCOL_VERSION, type: 'device.discovered', requestId, device: this.deviceInfo() }));
     }
-    /** Only the gateway's own queries are served; desktop queries (skills, workspace) are not advertised. */
+    /** Every reply-bearing query gets a result, including unsupported extensions. */
     async handleQuery(msg) {
         const { value, byteLength } = decode(msg);
         if (!msg.reply)
             return;
+        try {
+            await this.dispatchQuery(msg, value, byteLength);
+        }
+        catch (error) {
+            const requestId = value?.requestId;
+            if (typeof requestId !== 'string')
+                return;
+            msg.respond(encode({
+                protocolVersion: REMOTE_DEVICE_PROTOCOL_VERSION,
+                type: 'query.error', requestId, ok: false,
+                error: { code: 'query_failed', message: error instanceof Error ? error.message : String(error) },
+            }));
+        }
+    }
+    async dispatchQuery(msg, value, byteLength) {
+        const raw = value;
+        if (raw?.type === 'query.cancel')
+            return;
+        if (raw?.type === 'agent.folder.prepare' && typeof raw.requestId === 'string') {
+            msg.respond(encode(await this.prepareFolder(value, raw.requestId, byteLength)));
+            return;
+        }
+        if (raw?.type === 'workspace.list' && typeof raw.requestId === 'string') {
+            msg.respond(encode(await listGatewayWorkspace(this.deps.db, this.deps.userId, this.deps.gateway, value)));
+            return;
+        }
+        if ((raw?.type === 'workspace.file.read' || raw?.type === 'skills.list') && typeof raw.requestId === 'string') {
+            const base = { protocolVersion: REMOTE_DEVICE_PROTOCOL_VERSION, requestId: raw.requestId, threadId: String(raw.threadId ?? ''), ok: false, fetchedAt: new Date().toISOString(), error: { code: 'unsupported', message: 'This gateway does not support this query' } };
+            const result = raw.type === 'skills.list'
+                ? { ...base, type: 'skills.list.result', skills: [] }
+                : { ...base, type: 'workspace.file.read.result', path: String(raw.path ?? ''), preview: null, size: null };
+            msg.respond(encode(result));
+            return;
+        }
         if (isAgentConfigQuery(value)) {
             msg.respond(encode(await this.agentConfig(value)));
             return;
         }
         if (isAgentSettingsQuery(value)) {
-            msg.respond(encode(this.settingsResult(value.requestId)));
+            const result = this.settingsResult(value.requestId);
+            if (value.threadId && await threadExists(this.deps.db, value.threadId, this.deps.userId)) {
+                result.threadCwd = (await readSessionBinding(this.deps.db, value.threadId, this.deps.gateway.id))?.cwd ?? null;
+            }
+            msg.respond(encode(result));
             return;
         }
         if (isAgentFoldersQuery(value)) {
@@ -356,7 +398,34 @@ export class GatewayDeviceHost {
             msg.respond(encode('error' in update
                 ? this.settingsResult(requestId, { code: 'invalid_request', message: update.error })
                 : await this.changeSettings(update.update)));
+            return;
+        }
+        if (typeof raw?.requestId === 'string')
+            msg.respond(encode({ protocolVersion: REMOTE_DEVICE_PROTOCOL_VERSION, type: 'query.error', requestId: raw.requestId, ok: false, error: { code: 'unsupported', message: 'Unsupported gateway query' } }));
+    }
+    async prepareFolder(value, requestId, byteLength) {
+        const result = {
+            protocolVersion: REMOTE_DEVICE_PROTOCOL_VERSION,
+            type: 'agent.folder.result',
+            requestId,
+            ok: false,
+            path: null,
+            home: os.homedir(),
+            fetchedAt: new Date().toISOString(),
+        };
+        if (!isAgentFolderPrepareQuery(value, byteLength)) {
+            return { ...result, error: { code: 'invalid_request', message: 'Choose exactly one path or agent name' } };
+        }
+        try {
+            result.path = value.path !== undefined
+                ? await resolveWorkspaceFolder(value.path)
+                : await ensureAgentHomeFolder(value.agentName, undefined, value.agentId);
+            result.ok = true;
+        }
+        catch (error) {
+            result.error = settingsError(error);
         }
+        return result;
     }
     settingsResult(requestId, error) {
         const gateway = this.deps.gateway;
@@ -365,6 +434,7 @@ export class GatewayDeviceHost {
             type: 'agent.settings.result',
             requestId,
             ok: !error,
+            threadCwd: null,
             settings: {
                 cwd: gateway.cwd ?? null,
                 approval: gateway.approval ?? 'ask',

package/dist/gateway/mcpCommandTools.d.ts

@@ -3,16 +3,26 @@ 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;
@@ -30,7 +40,7 @@ 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: {
@@ -49,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

@@ -3,6 +3,7 @@ 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
@@ -10,14 +11,19 @@ import { requestContext } from '../utils/requestContext.js';
  * 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 function createCliCommandRunner(overrides = {}) {
@@ -169,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,7 @@ 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";
+/** Session folder for resolving relative send_file paths. */
+export declare const GATEWAY_SESSION_CWD_ENV = "DINOX_GATEWAY_SESSION_CWD";

package/dist/gateway/mcpEnv.js

@@ -5,3 +5,7 @@ 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';
+/** Session folder for resolving relative send_file paths. */
+export const GATEWAY_SESSION_CWD_ENV = 'DINOX_GATEWAY_SESSION_CWD';

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

package/dist/gateway/mcpServer.js

@@ -4,7 +4,7 @@ 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 { DINOX_MCP_SERVER_NAME, GATEWAY_KNOWLEDGE_TOOLS_ENV, GATEWAY_SESSION_TOKEN_ENV } from './mcpEnv.js';
+import { DINOX_MCP_SERVER_NAME, DINOX_STANDALONE_MCP_SERVER_NAME, GATEWAY_SESSION_CWD_ENV, GATEWAY_KNOWLEDGE_TOOLS_ENV, GATEWAY_SESSION_TOKEN_ENV } from './mcpEnv.js';
 import { READ_CONVERSATION_MAX_LIMIT } from './conversationContext.js';
 import { getPackageVersion } from '../utils/version.js';
 /**
@@ -183,11 +183,32 @@ function registerKnowledgeTools(server, call) {
         }
     });
 }
+const STANDALONE_INSTRUCTIONS = "Tools for the user's Dinox knowledge base (notes, todos, tags, card boxes, views, properties, templates, prompts, " +
+    'the link graph and storage). Each dinox_* tool groups the CLI commands of one area: pick an `action` and pass its ' +
+    'camelCase `input`. Prefer note search for keywords and note semantic/context for meaning-based questions. Results ' +
+    'carry `_notice` (stale cache, pending upload) worth relaying. High-risk writes need dryRun: true first, then the ' +
+    'confirmation options the action lists.';
+/**
+ * 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 function createStandaloneMcpServer(options = {}) {
+    const server = new McpServer({ name: DINOX_STANDALONE_MCP_SERVER_NAME, version: getPackageVersion() }, { instructions: STANDALONE_INSTRUCTIONS + (options.readOnly ? ' This server is read-only.' : '') });
+    registerCommandTools(server, options.commandRunner, { ...options, knowledgeTools: false });
+    return server;
+}
+async function serveOverStdio(server) {
+    await server.connect(new StdioServerTransport());
+    await new Promise((resolve) => process.stdin.once('close', resolve));
+}
 export async function serveDinoxMcpOverStdio() {
-    const server = createDinoxMcpServer(undefined, {
+    await serveOverStdio(createDinoxMcpServer(undefined, {
+        cwd: process.env[GATEWAY_SESSION_CWD_ENV] || process.cwd(),
         knowledgeTools: process.env[GATEWAY_KNOWLEDGE_TOOLS_ENV] !== '0',
         sessionToken: process.env[GATEWAY_SESSION_TOKEN_ENV]?.trim() || undefined,
-    });
-    await server.connect(new StdioServerTransport());
-    await new Promise((resolve) => process.stdin.once('close', resolve));
+    }));
+}
+export async function serveStandaloneMcpOverStdio(options) {
+    await serveOverStdio(createStandaloneMcpServer(options));
 }

package/dist/gateway/protocol.d.ts

@@ -20,8 +20,11 @@ export type AgentConfigResult = {
     };
 };
 export declare function isAgentConfigQuery(value: unknown): value is AgentConfigQuery;
+export declare const MAX_PATH_LENGTH = 4096;
+/** Host-side workspace choice, never forwarded as an ACP session option. */
+export declare const AGENT_CWD_CONFIG_KEY = "dinox.cwd";
 export type AgentHostSettings = {
-    /** Folder new conversations start in; null until chosen (the home folder is used). */
+    /** Fallback when neither the conversation nor its agent has chosen a folder. */
     cwd: string | null;
     approval: GatewayApprovalMode;
     /** Online but refusing new turns. */
@@ -32,7 +35,7 @@ export type AgentHostSettings = {
 export type AgentSettingsChange = {
     /** An existing folder (absolute or `~/...`), checked on this computer. */
     cwd?: string;
-    /** Creates and uses the agent's own folder (`~/Dinox Agents/<name>`). */
+    /** Creates and uses the agent's own folder (`~/dinox-agents/<name>`). */
     useAgentFolder?: true;
     approval?: GatewayApprovalMode;
     paused?: boolean;
@@ -41,6 +44,7 @@ export type AgentSettingsChange = {
 export type AgentSettingsQuery = {
     protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
     type: 'agent.settings.get';
+    threadId?: string;
     requestId: string;
     clientDeviceId: string;
 };
@@ -58,6 +62,8 @@ export type AgentSettingsResult = {
     requestId: string;
     ok: boolean;
     settings: AgentHostSettings;
+    /** The conversation's folder, even after its topic has changed. */
+    threadCwd: string | null;
     /** For showing paths as `~/...`. */
     home: string;
     /** Where `useAgentFolder` puts the agent's own folder. */
@@ -99,6 +105,29 @@ export type AgentFoldersResult = {
         message: string;
     };
 };
+export type AgentFolderPrepareQuery = {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: 'agent.folder.prepare';
+    requestId: string;
+    clientDeviceId: string;
+    path?: string;
+    agentName?: string;
+    agentId?: string;
+};
+export type AgentFolderPrepareResult = {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: 'agent.folder.result';
+    requestId: string;
+    ok: boolean;
+    path: string | null;
+    home: string;
+    fetchedAt: string;
+    error?: {
+        code: AgentSettingsErrorCode;
+        message: string;
+    };
+};
+export declare function isAgentFolderPrepareQuery(value: unknown, byteLength: number): value is AgentFolderPrepareQuery;
 export declare function isAgentSettingsQuery(value: unknown): value is AgentSettingsQuery;
 export declare function isAgentFoldersQuery(value: unknown): value is AgentFoldersQuery;
 /** The change an `agent.settings.set` asks for, or why it is malformed. */

package/dist/gateway/protocol.js

@@ -76,9 +76,21 @@ export function isAgentConfigQuery(value) {
  * `agent.settings.set`, and picks a working folder with `agent.folders.list`.
  */
 const MAX_SETTINGS_REQUEST_BYTES = 16 * 1024;
-const MAX_PATH_LENGTH = 4096;
+export const MAX_PATH_LENGTH = 4096;
+/** Host-side workspace choice, never forwarded as an ACP session option. */
+export const AGENT_CWD_CONFIG_KEY = 'dinox.cwd';
+export function isAgentFolderPrepareQuery(value, byteLength) {
+    if (!isMessageOfType(value, 'agent.folder.prepare') || !isDeviceId(value.clientDeviceId) || byteLength > MAX_SETTINGS_REQUEST_BYTES)
+        return false;
+    if ((value.path === undefined) === (value.agentName === undefined))
+        return false;
+    if (value.agentId !== undefined && (value.agentName === undefined || typeof value.agentId !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(value.agentId)))
+        return false;
+    const text = value.path ?? value.agentName;
+    return typeof text === 'string' && !!text.trim() && text.length <= (value.path === undefined ? MAX_AGENT_CONFIG_TEXT : MAX_PATH_LENGTH);
+}
 export function isAgentSettingsQuery(value) {
-    return isMessageOfType(value, 'agent.settings.get') && isDeviceId(value.clientDeviceId);
+    return isMessageOfType(value, 'agent.settings.get') && isDeviceId(value.clientDeviceId) && (value.threadId === undefined || isSubjectId(value.threadId));
 }
 export function isAgentFoldersQuery(value) {
     if (!isMessageOfType(value, 'agent.folders.list') || !isDeviceId(value.clientDeviceId))
@@ -139,7 +151,7 @@ export function readAgentConfig(request) {
     for (const [id, value] of entries) {
         if (!id || id.length > MAX_AGENT_CONFIG_TEXT)
             return 'invalid';
-        if (typeof value !== 'string' || !value || value.length > MAX_AGENT_CONFIG_TEXT)
+        if (typeof value !== 'string' || !value || value.length > (id === AGENT_CWD_CONFIG_KEY ? MAX_PATH_LENGTH : MAX_AGENT_CONFIG_TEXT))
             return 'invalid';
         config[id] = value;
     }