@dinoxx/dinox-cli 2.6.0 → 2.8.0

package/dist/daemon/supervisor.js

@@ -38,18 +38,14 @@ function writeDefinition(definitionPath, content) {
     mkdirSync(path.dirname(definitionPath), { recursive: true });
     writeFileSync(definitionPath, content, { mode: 0o644 });
 }
-function readDefinition(definitionPath) {
+function readDefinition(definitionPath, encoding = 'utf8') {
     try {
-        return readFileSync(definitionPath, 'utf8');
+        return readFileSync(definitionPath, encoding);
     }
     catch {
         return null;
     }
 }
-/** True when the installed definition differs from what this CLI would write. */
-export function serviceDefinitionIsStale(service, spec) {
-    return readDefinition(service.definitionPath) !== service.render(spec);
-}
 // ---------------------------------------------------------------- launchd
 function xmlEscape(value) {
     return value
@@ -118,6 +114,9 @@ class LaunchdService {
     isInstalled() {
         return existsSync(this.definitionPath);
     }
+    isCurrent(spec) {
+        return readDefinition(this.definitionPath) === this.render(spec);
+    }
     async isLoaded() {
         return (await this.run('launchctl', ['print', this.target])).code === 0;
     }
@@ -213,6 +212,9 @@ class SystemdService {
     isInstalled() {
         return existsSync(this.definitionPath);
     }
+    isCurrent(spec) {
+        return readDefinition(this.definitionPath) === this.render(spec);
+    }
     async systemctl(step, ...args) {
         const result = await this.run('systemctl', ['--user', ...args]);
         if (result.code !== 0)
@@ -236,7 +238,188 @@ class SystemdService {
         return true;
     }
 }
-/** The service manager for this platform, or null where none is supported (Windows). */
+// ---------------------------------------------------------------- Windows
+/** Quotes one argument the way CommandLineToArgvW (and so Node) parses it back. */
+export function quoteWindowsArg(value) {
+    if (value !== '' && !/[\s"]/.test(value))
+        return value;
+    let quoted = '"';
+    let backslashes = 0;
+    for (const char of value) {
+        if (char === '\\') {
+            backslashes += 1;
+            continue;
+        }
+        if (char === '"') {
+            quoted += '\\'.repeat(backslashes * 2 + 1) + '"';
+        }
+        else {
+            quoted += '\\'.repeat(backslashes) + char;
+        }
+        backslashes = 0;
+    }
+    return `${quoted}${'\\'.repeat(backslashes * 2)}"`;
+}
+function vbsString(value) {
+    return `"${value.replace(/"/g, '""').replace(/\r?\n/g, '" & vbLf & "')}"`;
+}
+/**
+ * Task Scheduler runs console programs in a visible window, so the task runs
+ * this script with wscript, which sets the daemon environment and starts the
+ * supervisor with a hidden window (the launcher pattern pm2-windows-startup
+ * uses). The supervisor then outlives the script.
+ */
+export function renderWindowsLauncher(spec) {
+    const commandLine = [spec.program, ...spec.args].map(quoteWindowsArg).join(' ');
+    const env = Object.keys(spec.env)
+        .sort()
+        .map((name) => `env(${vbsString(name)}) = ${vbsString(spec.env[name])}`)
+        .join('\r\n');
+    return [
+        "' Generated by `dino daemon install`; rewritten when the CLI changes.",
+        'Set shell = CreateObject("WScript.Shell")',
+        'Set env = shell.Environment("Process")',
+        env,
+        `shell.CurrentDirectory = ${vbsString(spec.workingDirectory)}`,
+        `shell.Run ${vbsString(commandLine)}, 0, False`,
+        '',
+    ].join('\r\n');
+}
+export function renderWindowsTaskXml(userId, wscriptPath, launcherPath) {
+    return `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Description>Dinox CLI daemon (dino daemon install)</Description>
+  </RegistrationInfo>
+  <Triggers>
+    <LogonTrigger>
+      <Enabled>true</Enabled>
+      <UserId>${xmlEscape(userId)}</UserId>
+    </LogonTrigger>
+  </Triggers>
+  <Principals>
+    <Principal id="Author">
+      <UserId>${xmlEscape(userId)}</UserId>
+      <LogonType>InteractiveToken</LogonType>
+      <RunLevel>LeastPrivilege</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <StartWhenAvailable>true</StartWhenAvailable>
+    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>
+    <IdleSettings>
+      <StopOnIdleEnd>false</StopOnIdleEnd>
+      <RestartOnIdle>false</RestartOnIdle>
+    </IdleSettings>
+    <AllowStartOnDemand>true</AllowStartOnDemand>
+    <Enabled>true</Enabled>
+    <Hidden>false</Hidden>
+    <RunOnlyIfIdle>false</RunOnlyIfIdle>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <Priority>7</Priority>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>${xmlEscape(wscriptPath)}</Command>
+      <Arguments>${xmlEscape(`//B //Nologo ${quoteWindowsArg(launcherPath)}`)}</Arguments>
+    </Exec>
+  </Actions>
+</Task>
+`;
+}
+/** UTF-16LE with a BOM: what schtasks /XML expects and how wscript reads non-ASCII paths. */
+function writeUtf16(filePath, content) {
+    mkdirSync(path.dirname(filePath), { recursive: true });
+    writeFileSync(filePath, Buffer.concat([Buffer.from([0xff, 0xfe]), Buffer.from(content, 'utf16le')]));
+}
+function readUtf16(filePath) {
+    const content = readDefinition(filePath, 'utf16le');
+    return content === null ? null : content.replace(/^\uFEFF/, '');
+}
+class WindowsTaskService {
+    label;
+    run;
+    launcherDir;
+    wscriptPath;
+    userId;
+    kind = 'schtasks';
+    definitionPath;
+    taskName;
+    constructor(label, run, launcherDir, wscriptPath, userId) {
+        this.label = label;
+        this.run = run;
+        this.launcherDir = launcherDir;
+        this.wscriptPath = wscriptPath;
+        this.userId = userId;
+        this.taskName = `Dinox\\${label}`;
+        this.definitionPath = path.join(launcherDir, `${label}.vbs`);
+    }
+    render(spec) {
+        return renderWindowsLauncher(spec);
+    }
+    isInstalled() {
+        return existsSync(this.definitionPath);
+    }
+    isCurrent(spec) {
+        return readUtf16(this.definitionPath) === this.render(spec);
+    }
+    async isRegistered() {
+        return (await this.run('schtasks', ['/Query', '/TN', this.taskName])).code === 0;
+    }
+    async register() {
+        if (!existsSync(this.wscriptPath)) {
+            throw new DinoxError(`Windows Script Host (${this.wscriptPath}) is not available, so the daemon cannot start hidden at logon.`, {
+                code: 'DAEMON_SERVICE_UNSUPPORTED',
+                details: { reason: 'wscript-missing' },
+            });
+        }
+        const xmlPath = path.join(this.launcherDir, `${this.label}.task.xml`);
+        writeUtf16(xmlPath, renderWindowsTaskXml(this.userId, this.wscriptPath, this.definitionPath));
+        try {
+            const result = await this.run('schtasks', ['/Create', '/TN', this.taskName, '/XML', xmlPath, '/F']);
+            if (result.code !== 0)
+                throw failed(this.kind, 'create', result);
+        }
+        finally {
+            try {
+                unlinkSync(xmlPath);
+            }
+            catch {
+                // Already gone.
+            }
+        }
+    }
+    async runTask() {
+        const result = await this.run('schtasks', ['/Run', '/TN', this.taskName]);
+        if (result.code !== 0)
+            throw failed(this.kind, 'run', result);
+    }
+    async install(spec) {
+        writeUtf16(this.definitionPath, this.render(spec));
+        await this.register();
+        await this.runTask();
+    }
+    async start() {
+        if (!(await this.isRegistered()))
+            await this.register();
+        await this.runTask();
+    }
+    async uninstall() {
+        const installed = this.isInstalled();
+        if (await this.isRegistered()) {
+            const result = await this.run('schtasks', ['/Delete', '/TN', this.taskName, '/F']);
+            if (result.code !== 0)
+                throw failed(this.kind, 'delete', result);
+        }
+        if (installed)
+            unlinkSync(this.definitionPath);
+        return installed;
+    }
+}
+/** The service manager for this platform, or null where none is supported. */
 export function getDaemonService(options = {}) {
     const platform = options.platform ?? process.platform;
     const env = options.env ?? process.env;
@@ -249,5 +432,10 @@ export function getDaemonService(options = {}) {
     if (platform === 'linux') {
         return new SystemdService(label, run, env.XDG_CONFIG_HOME || path.join(homeDir, '.config'));
     }
+    if (platform === 'win32') {
+        const systemRoot = env.SystemRoot || env.SYSTEMROOT || 'C:\\Windows';
+        const user = env.USERNAME || os.userInfo().username;
+        return new WindowsTaskService(label, run, options.launcherDir ?? path.join(getDataDir(), 'daemon'), path.join(systemRoot, 'System32', 'wscript.exe'), options.windowsUserId ?? (env.USERDOMAIN ? `${env.USERDOMAIN}\\${user}` : user));
+    }
     return null;
 }

package/dist/daemon/types.d.ts

@@ -43,7 +43,7 @@ export type DaemonPingResult = {
     /** True only for daemons using the current authenticated local protocol. */
     authenticated: boolean;
     /** Service manager that owns the process; null or absent (older daemons) when unmanaged. */
-    supervisor?: 'launchd' | 'systemd' | null;
+    supervisor?: 'launchd' | 'systemd' | 'schtasks' | null;
 };
 /** Kept only for old scripts that pass --port; the daemon transport is socket-based. */
 export declare const DEFAULT_DAEMON_PORT = 45678;

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

@@ -1,6 +1,9 @@
-import { type McpServer, type SessionConfigOption, type ToolKind } from '@agentclientprotocol/sdk';
-import type { GatewayAdapter, GatewayAdapterInfo, GatewayConfigOption, GatewayDefinition, GatewayTurnInput, GatewayTurnResult } from '../types.js';
+import { type ContentBlock, type McpServer, type SessionConfigOption, type ToolKind } from '@agentclientprotocol/sdk';
+import type { GatewayAdapter, GatewayAdapterInfo, GatewayConfigOption, GatewayDefinition, GatewayFileSource, GatewaySentFile, GatewayTurnInput, GatewayTurnResult } from '../types.js';
 type Logger = (message: string, details?: Record<string, unknown>) => void;
+export declare function withoutTransportNotice(text: string): string;
+/** A file in an agent message (an image, or a resource it attached), as something to send the user. */
+export declare function fileFromContent(content: ContentBlock): GatewayFileSource | null;
 /** Select options only; boolean toggles have no use in the app yet. */
 export declare function normalizeConfigOptions(options: SessionConfigOption[] | null | undefined): GatewayConfigOption[];
 export declare function isReadOnlyToolKind(kind: ToolKind | null | undefined): boolean;
@@ -14,7 +17,10 @@ export declare class AcpGatewayAdapter implements GatewayAdapter {
     /** Live: settings changed from the app (approval, Dinox tools) apply to the next request. */
     private readonly gateway;
     private readonly log;
-    /** MCP servers offered to sessions as they are created or loaded, e.g. the Dinox knowledge tools. */
+    /**
+     * MCP servers offered to sessions as they are created or loaded, e.g. the
+     * Dinox tools; `sessionToken` lets their `send_file` reach this session.
+     */
     private readonly mcpServers;
     readonly kind: "acp";
     private process;
@@ -22,15 +28,25 @@ export declare class AcpGatewayAdapter implements GatewayAdapter {
     private readonly turns;
     /** The latest settings any session reported: the agent-wide choices the app lists. */
     private catalog;
+    /** Token each session's Dinox tools were started with → that session, for routing `send_file`. */
+    private readonly sessionTokens;
     constructor(
     /** Live: settings changed from the app (approval, Dinox tools) apply to the next request. */
     gateway: GatewayDefinition, log?: Logger, 
-    /** MCP servers offered to sessions as they are created or loaded, e.g. the Dinox knowledge tools. */
-    mcpServers?: () => McpServer[]);
+    /**
+     * MCP servers offered to sessions as they are created or loaded, e.g. the
+     * Dinox tools; `sessionToken` lets their `send_file` reach this session.
+     */
+    mcpServers?: (sessionToken: string) => McpServer[]);
     info(): GatewayAdapterInfo;
     runTurn(input: GatewayTurnInput): Promise<GatewayTurnResult>;
+    sendFile(token: string, file: GatewayFileSource): Promise<GatewaySentFile> | null;
     describeConfig(): Promise<GatewayConfigOption[]>;
     dispose(): Promise<void>;
+    /** Codex leaves generated images on disk; send the ones this turn made when it sent nothing itself. */
+    private sendGeneratedImages;
+    /** Reports a file the agent put in its message to the user, without failing the turn. */
+    private sendContentFile;
     /** Continues the session (loading it in `cwd` when this process has not seen it) or starts one there. */
     private resolveSession;
     /**

package/dist/gateway/adapters/acp.js

@@ -1,9 +1,12 @@
 import { spawn } from 'node:child_process';
+import crypto from 'node:crypto';
 import os from 'node:os';
+import { fileURLToPath } from 'node:url';
 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';
+import { codexGeneratedImagesDir, codexImagesSince } from './codexImages.js';
 const TOOL_STATUS = {
     pending: 'pending',
     in_progress: 'running',
@@ -17,6 +20,30 @@ const STOP_REASON = {
     refusal: 'refusal',
     cancelled: 'cancelled',
 };
+/** Codex reports its transport falling back as message text; it is not part of the answer. */
+const TRANSPORT_NOTICE = /^Warning: Falling back from WebSockets to HTTPS transport\.[^\n]*(\n+|$)/;
+export function withoutTransportNotice(text) {
+    return text.replace(TRANSPORT_NOTICE, '');
+}
+/** A file in an agent message (an image, or a resource it attached), as something to send the user. */
+export function fileFromContent(content) {
+    switch (content.type) {
+        case 'image':
+            return content.data ? { kind: 'data', data: content.data, mediaType: content.mimeType } : null;
+        case 'resource_link':
+            return content.uri.startsWith('file://')
+                ? { kind: 'path', path: fileURLToPath(content.uri), name: content.name }
+                : null;
+        case 'resource': {
+            const resource = content.resource;
+            if (!('blob' in resource))
+                return null;
+            return { kind: 'data', data: resource.blob, mediaType: resource.mimeType ?? 'application/octet-stream' };
+        }
+        default:
+            return null;
+    }
+}
 function toolContentText(content) {
     const text = (content ?? [])
         .map((item) => (item.type === 'content' && item.content.type === 'text' ? item.content.text : ''))
@@ -82,10 +109,15 @@ export class AcpGatewayAdapter {
     turns = new Map();
     /** The latest settings any session reported: the agent-wide choices the app lists. */
     catalog = null;
+    /** Token each session's Dinox tools were started with → that session, for routing `send_file`. */
+    sessionTokens = new Map();
     constructor(
     /** Live: settings changed from the app (approval, Dinox tools) apply to the next request. */
     gateway, log = () => { }, 
-    /** MCP servers offered to sessions as they are created or loaded, e.g. the Dinox knowledge tools. */
+    /**
+     * MCP servers offered to sessions as they are created or loaded, e.g. the
+     * Dinox tools; `sessionToken` lets their `send_file` reach this session.
+     */
     mcpServers = () => []) {
         this.gateway = gateway;
         this.log = log;
@@ -99,7 +131,9 @@ export class AcpGatewayAdapter {
         const agent = await this.ensureProcess();
         const { sessionId, created } = await this.resolveSession(agent, input.sessionId, input.cwd);
         await this.applyConfig(agent, sessionId, input.config);
-        this.turns.set(sessionId, { onEvent: input.onEvent, awaitApproval: input.awaitApproval });
+        const turn = { onEvent: input.onEvent, awaitApproval: input.awaitApproval, sendFile: input.sendFile, sent: 0 };
+        this.turns.set(sessionId, turn);
+        const startedAt = Date.now();
         const onAbort = () => {
             void agent.connection.cancel({ sessionId }).catch(() => undefined);
         };
@@ -111,6 +145,8 @@ export class AcpGatewayAdapter {
                 prompt.push({ type: 'resource_link', uri: resource.uri, name: resource.name, mimeType: resource.mediaType ?? null });
             }
             const response = await agent.connection.prompt({ sessionId, prompt });
+            if (turn.sent === 0)
+                await this.sendGeneratedImages(turn, sessionId, startedAt);
             return { sessionId, stopReason: STOP_REASON[response.stopReason] ?? 'end_turn' };
         }
         catch (error) {
@@ -123,6 +159,16 @@ export class AcpGatewayAdapter {
             this.turns.delete(sessionId);
         }
     }
+    sendFile(token, file) {
+        const sessionId = this.sessionTokens.get(token);
+        if (!sessionId)
+            return null;
+        const turn = this.turns.get(sessionId);
+        if (!turn)
+            return Promise.reject(new Error('Files can only be sent while answering the user'));
+        turn.sent += 1;
+        return turn.sendFile(file);
+    }
     async describeConfig() {
         if (this.catalog)
             return this.catalog;
@@ -146,6 +192,25 @@ export class AcpGatewayAdapter {
             return;
         agent.child.stdin.end();
         agent.child.kill('SIGTERM');
+        this.sessionTokens.clear();
+    }
+    /** Codex leaves generated images on disk; send the ones this turn made when it sent nothing itself. */
+    async sendGeneratedImages(turn, sessionId, startedAt) {
+        const dir = codexGeneratedImagesDir(sessionId, { ...process.env, ...(this.gateway.env ?? {}) });
+        if (!dir)
+            return;
+        for (const file of await codexImagesSince(dir, startedAt)) {
+            turn.sent += 1;
+            await turn.sendFile({ kind: 'path', path: file }).catch((error) => this.log('sending a generated image failed', { error: String(error) }));
+        }
+    }
+    /** Reports a file the agent put in its message to the user, without failing the turn. */
+    sendContentFile(turn, content) {
+        const file = fileFromContent(content);
+        if (!file)
+            return;
+        turn.sent += 1;
+        void turn.sendFile(file).catch((error) => this.log('sending a file from the agent message failed', { error: String(error) }));
     }
     /** Continues the session (loading it in `cwd` when this process has not seen it) or starts one there. */
     async resolveSession(agent, sessionId, cwd) {
@@ -154,7 +219,9 @@ export class AcpGatewayAdapter {
         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() });
+                const token = crypto.randomBytes(18).toString('base64url');
+                const loaded = await agent.connection.loadSession({ sessionId, cwd, mcpServers: this.mcpServers(token) });
+                this.sessionTokens.set(token, sessionId);
                 agent.liveSessions.add(sessionId);
                 this.rememberConfig(agent, sessionId, loaded.configOptions);
                 return { sessionId, created: false };
@@ -163,7 +230,9 @@ export class AcpGatewayAdapter {
                 this.log('session/load failed; starting a new session', { sessionId, error: String(error) });
             }
         }
-        const created = await agent.connection.newSession({ cwd, mcpServers: this.mcpServers() });
+        const token = crypto.randomBytes(18).toString('base64url');
+        const created = await agent.connection.newSession({ cwd, mcpServers: this.mcpServers(token) });
+        this.sessionTokens.set(token, created.sessionId);
         agent.liveSessions.add(created.sessionId);
         this.rememberConfig(agent, created.sessionId, created.configOptions);
         return { sessionId: created.sessionId, created: true };
@@ -213,6 +282,8 @@ export class AcpGatewayAdapter {
             cwd: this.gateway.cwd ?? os.homedir(),
             env: { ...process.env, ...(this.gateway.env ?? {}) },
             stdio: ['pipe', 'pipe', 'pipe'],
+            // The daemon runs without a visible console on Windows; keep agents that way.
+            windowsHide: true,
         });
         child.stderr.on('data', (chunk) => this.log('agent stderr', { text: chunk.toString('utf8').slice(0, 2000) }));
         const exited = new Promise((_, reject) => {
@@ -220,8 +291,10 @@ export class AcpGatewayAdapter {
             child.once('exit', (code, signal) => reject(new Error(`agent exited (code ${code}, signal ${signal})`)));
         });
         child.once('exit', () => {
-            if (this.process?.child === child)
+            if (this.process?.child === child) {
                 this.process = null;
+                this.sessionTokens.clear();
+            }
         });
         const stream = ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout));
         const connection = new ClientSideConnection(() => ({
@@ -253,8 +326,14 @@ export class AcpGatewayAdapter {
             return;
         switch (update.sessionUpdate) {
             case 'agent_message_chunk':
-                if (update.content.type === 'text')
-                    turn.onEvent({ type: 'text-delta', text: update.content.text });
+                if (update.content.type === 'text') {
+                    const text = withoutTransportNotice(update.content.text);
+                    if (text)
+                        turn.onEvent({ type: 'text-delta', text });
+                }
+                else {
+                    this.sendContentFile(turn, update.content);
+                }
                 break;
             case 'agent_thought_chunk':
                 if (update.content.type === 'text')

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

@@ -0,0 +1,4 @@
+export declare const MAX_FALLBACK_IMAGES = 4;
+export declare function codexGeneratedImagesDir(sessionId: string, env: Record<string, string | undefined>): string | null;
+/** Images written to the session's folder since `sinceMs`, oldest first. */
+export declare function codexImagesSince(dir: string, sinceMs: number): Promise<string[]>;

package/dist/gateway/adapters/codexImages.js

@@ -0,0 +1,34 @@
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+/**
+ * Codex saves the images it generates to `$CODEX_HOME/generated_images/<session>/`
+ * and only tells the model where they are, so a turn that produced images but
+ * never sent them would leave the user with nothing. The newest ones are sent instead.
+ */
+const IMAGE_EXTENSIONS = new Set(['.png', '.jpg', '.jpeg', '.webp', '.gif']);
+export const MAX_FALLBACK_IMAGES = 4;
+export function codexGeneratedImagesDir(sessionId, env) {
+    // The session id names a folder; refuse anything that could leave it.
+    if (!/^[A-Za-z0-9_-]{1,128}$/.test(sessionId))
+        return null;
+    const codexHome = env.CODEX_HOME?.trim() || path.join(os.homedir(), '.codex');
+    return path.join(codexHome, 'generated_images', sessionId);
+}
+/** Images written to the session's folder since `sinceMs`, oldest first. */
+export async function codexImagesSince(dir, sinceMs) {
+    const entries = await fsp.readdir(dir, { withFileTypes: true }).catch(() => []);
+    const images = [];
+    for (const entry of entries) {
+        if (!entry.isFile() || !IMAGE_EXTENSIONS.has(path.extname(entry.name).toLowerCase()))
+            continue;
+        const file = path.join(dir, entry.name);
+        const stats = await fsp.stat(file).catch(() => null);
+        if (stats && stats.mtimeMs >= sinceMs)
+            images.push({ file, mtimeMs: stats.mtimeMs });
+    }
+    return images
+        .sort((a, b) => a.mtimeMs - b.mtimeMs)
+        .slice(-MAX_FALLBACK_IMAGES)
+        .map((image) => image.file);
+}

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

@@ -1,9 +1,12 @@
 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
+ * The Dinox 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 dinoxMcpServerConfig(options: {
+    sessionToken: string;
+    knowledgeTools: boolean;
+}): McpServer | null;
 export declare function createGatewayAdapter(gateway: GatewayDefinition, log: (message: string, details?: Record<string, unknown>) => void): GatewayAdapter;

package/dist/gateway/adapters/index.js

@@ -1,30 +1,39 @@
+import { GATEWAY_KNOWLEDGE_TOOLS_ENV, GATEWAY_SESSION_TOKEN_ENV } from '../mcpEnv.js';
 import { AcpGatewayAdapter } from './acp.js';
 import { EchoGatewayAdapter } from './echo.js';
 /**
- * The Dinox knowledge tools as a stdio MCP server: this same CLI, run as
+ * The Dinox 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() {
+export function dinoxMcpServerConfig(options) {
     const entrypoint = process.argv[1];
     if (!entrypoint)
         return null;
+    const inherited = Object.entries(process.env).filter((entry) => entry[0].startsWith('DINOX_') &&
+        entry[0] !== GATEWAY_SESSION_TOKEN_ENV &&
+        entry[0] !== GATEWAY_KNOWLEDGE_TOOLS_ENV &&
+        typeof entry[1] === 'string');
     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 })),
+        env: [
+            ...inherited,
+            [GATEWAY_SESSION_TOKEN_ENV, options.sessionToken],
+            [GATEWAY_KNOWLEDGE_TOOLS_ENV, options.knowledgeTools ? '1' : '0'],
+        ].map(([name, value]) => ({ name, value })),
     };
 }
 export function createGatewayAdapter(gateway, log) {
     switch (gateway.kind) {
-        case 'acp': {
-            const dinoxTools = dinoxMcpServerConfig();
-            // Read per session, so turning the Dinox tools off applies to the next new conversation.
-            return new AcpGatewayAdapter(gateway, log, () => (gateway.dinoxTools !== false && dinoxTools ? [dinoxTools] : []));
-        }
+        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 tools ? [tools] : [];
+            });
         case 'echo':
             return new EchoGatewayAdapter();
     }

package/dist/gateway/assistantProjection.d.ts

@@ -1,6 +1,7 @@
 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';
+import type { GatewayEvent, GatewaySentFile } from './types.js';
+export declare function compactToolValue(value: unknown, depth?: number): unknown;
 export declare class AssistantProjection {
     private readonly base;
     private readonly parts;
@@ -10,11 +11,14 @@ export declare class AssistantProjection {
     constructor(base: ChatUIMessage);
     get revision(): number;
     apply(event: GatewayEvent): void;
+    /** A file sent to the user, shown where the agent sent it (the app renders images inline). */
+    addFile(file: GatewaySentFile): void;
     /** Closes streaming parts; called once when the turn ends. */
     finish(): void;
     snapshot(): ChatUIMessage;
     private appendText;
     private ensureTool;
+    private closeTextSegment;
     private findToolByApproval;
     private applyTool;
 }