@dinoxx/dinox-cli 2.4.0 → 2.5.2

package/dist/gateway/keepAwake.js

@@ -0,0 +1,64 @@
+import { spawn } from 'node:child_process';
+/**
+ * Keeps the computer from idle-sleeping while any agent turn runs, so a task
+ * started from the phone is not cut off when the screen locks. macOS only
+ * (`caffeinate -i`, released as soon as the last turn ends); elsewhere a no-op.
+ * It cannot stop sleep from closing a laptop lid on battery.
+ */
+export class KeepAwake {
+    log;
+    platform;
+    spawnProcess;
+    holders = 0;
+    child = null;
+    constructor(log = () => { }, platform = process.platform, spawnProcess = (command, args) => spawn(command, args, { stdio: 'ignore' })) {
+        this.log = log;
+        this.platform = platform;
+        this.spawnProcess = spawnProcess;
+    }
+    /** Holds the computer awake until the returned release is called (idempotent). */
+    acquire() {
+        this.holders += 1;
+        if (this.holders === 1)
+            this.start();
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            this.holders -= 1;
+            if (this.holders === 0)
+                this.stop();
+        };
+    }
+    /** Releases everything, e.g. when the daemon stops. */
+    dispose() {
+        this.holders = 0;
+        this.stop();
+    }
+    start() {
+        if (this.platform !== 'darwin' || this.child)
+            return;
+        try {
+            const child = this.spawnProcess('caffeinate', ['-i']);
+            child.once('error', (error) => {
+                this.log('keep awake unavailable', { error: String(error) });
+                if (this.child === child)
+                    this.child = null;
+            });
+            child.once('exit', () => {
+                if (this.child === child)
+                    this.child = null;
+            });
+            this.child = child;
+        }
+        catch (error) {
+            this.log('keep awake unavailable', { error: String(error) });
+        }
+    }
+    stop() {
+        const child = this.child;
+        this.child = null;
+        child?.kill('SIGTERM');
+    }
+}

package/dist/gateway/mcpServer.js

@@ -2,6 +2,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 { READ_CONVERSATION_MAX_LIMIT } from './conversationContext.js';
 import { getPackageVersion } from '../utils/version.js';
 /**
  * Dinox knowledge tools for gateway agents, served over stdio MCP. The agent
@@ -109,6 +110,25 @@ export function createDinoxMcpServer(call = (method, params) => sendDaemonReques
             return failure(error);
         }
     });
+    server.registerTool('read_conversation', {
+        description: 'Read messages of a Dinox conversation, oldest first: who said what (the user, or which agent answered). ' +
+            'Use it when the conversation context you were given says earlier messages are not shown. Returns the newest ' +
+            'messages before `before`; pass the first returned id as `before` to page further back.',
+        inputSchema: {
+            conversationId: z.string().describe('Conversation id from the context block'),
+            before: z.string().optional().describe('Message id; only messages before it are returned'),
+            limit: z.number().int().min(1).max(READ_CONVERSATION_MAX_LIMIT).optional(),
+        },
+    }, async ({ conversationId, before, limit }) => {
+        try {
+            const result = (await call('thread.messages', { threadId: conversationId, beforeMessageId: before, limit }));
+            // `stale`: this machine is not fully synced, so the newest messages may be missing.
+            return text({ messages: result.messages, hasMore: result.hasMore, stale: result.stale === true });
+        }
+        catch (error) {
+            return failure(error);
+        }
+    });
     return server;
 }
 export async function serveDinoxMcpOverStdio() {

package/dist/gateway/protocol.d.ts

@@ -1,5 +1,5 @@
 import { REMOTE_DEVICE_PROTOCOL_VERSION, type RemoteDeviceCancelRequest, type RemoteDeviceRunRequest, type RemoteDeviceRunStatusRequest } from '../vendor/electron/shared/remote-device-agent.js';
-import type { GatewayConfigOption } from './types.js';
+import type { GatewayApprovalMode, GatewayConfigOption } from './types.js';
 export declare function validateRunRequest(value: unknown, byteLength: number): string | null;
 export type AgentConfigQuery = {
     protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
@@ -20,6 +20,93 @@ export type AgentConfigResult = {
     };
 };
 export declare function isAgentConfigQuery(value: unknown): value is AgentConfigQuery;
+export type AgentHostSettings = {
+    /** Folder new conversations start in; null until chosen (the home folder is used). */
+    cwd: string | null;
+    approval: GatewayApprovalMode;
+    /** Online but refusing new turns. */
+    paused: boolean;
+    /** The agent may search and read the user's notes. */
+    dinoxTools: boolean;
+};
+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>`). */
+    useAgentFolder?: true;
+    approval?: GatewayApprovalMode;
+    paused?: boolean;
+    dinoxTools?: boolean;
+};
+export type AgentSettingsQuery = {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: 'agent.settings.get';
+    requestId: string;
+    clientDeviceId: string;
+};
+export type AgentSettingsUpdate = {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: 'agent.settings.set';
+    requestId: string;
+    clientDeviceId: string;
+    settings: AgentSettingsChange;
+};
+export type AgentSettingsErrorCode = 'invalid_request' | 'not_found' | 'not_allowed' | 'failed';
+export type AgentSettingsResult = {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: 'agent.settings.result';
+    requestId: string;
+    ok: boolean;
+    settings: AgentHostSettings;
+    /** For showing paths as `~/...`. */
+    home: string;
+    /** Where `useAgentFolder` puts the agent's own folder. */
+    agentFolder: string;
+    fetchedAt: string;
+    error?: {
+        code: AgentSettingsErrorCode;
+        message: string;
+    };
+};
+export type AgentFoldersQuery = {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: 'agent.folders.list';
+    requestId: string;
+    clientDeviceId: string;
+    /** Folder to list; absent lists the home folder with suggestions. */
+    path?: string | null;
+};
+export type AgentFolder = {
+    name: string;
+    path: string;
+    isProject: boolean;
+};
+export type AgentFoldersResult = {
+    protocolVersion: typeof REMOTE_DEVICE_PROTOCOL_VERSION;
+    type: 'agent.folders.result';
+    requestId: string;
+    ok: boolean;
+    path: string;
+    parent: string | null;
+    folders: AgentFolder[];
+    truncated: boolean;
+    /** Only for the home listing: the current folder and recently used ones. */
+    suggestions: AgentFolder[];
+    home: string;
+    fetchedAt: string;
+    error?: {
+        code: AgentSettingsErrorCode;
+        message: string;
+    };
+};
+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. */
+export declare function readAgentSettingsUpdate(value: unknown, byteLength: number): {
+    update: AgentSettingsUpdate;
+} | {
+    error: string;
+} | null;
 /** The run's chosen agent settings, `null` when none, `'invalid'` when malformed. */
 export declare function readAgentConfig(request: RemoteDeviceRunRequest): Record<string, string> | null | 'invalid';
 export declare function validateApprovalRequest(value: unknown, byteLength: number): string | null;

package/dist/gateway/protocol.js

@@ -70,6 +70,61 @@ export function validateRunRequest(value, byteLength) {
 export function isAgentConfigQuery(value) {
     return isMessageOfType(value, 'agent.config.get') && isDeviceId(value.clientDeviceId);
 }
+/*
+ * Gateway extension (`capabilities.executor.settings`): the owner reads and
+ * changes how this computer runs the agent with `agent.settings.get` /
+ * `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 function isAgentSettingsQuery(value) {
+    return isMessageOfType(value, 'agent.settings.get') && isDeviceId(value.clientDeviceId);
+}
+export function isAgentFoldersQuery(value) {
+    if (!isMessageOfType(value, 'agent.folders.list') || !isDeviceId(value.clientDeviceId))
+        return false;
+    const folder = value.path;
+    return folder === undefined || folder === null || (typeof folder === 'string' && folder.length <= MAX_PATH_LENGTH);
+}
+/** The change an `agent.settings.set` asks for, or why it is malformed. */
+export function readAgentSettingsUpdate(value, byteLength) {
+    if (!isMessageOfType(value, 'agent.settings.set'))
+        return null;
+    if (byteLength > MAX_SETTINGS_REQUEST_BYTES)
+        return { error: 'request too large' };
+    if (!isDeviceId(value.clientDeviceId))
+        return { error: 'invalid clientDeviceId' };
+    const raw = value.settings;
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return { error: 'invalid settings' };
+    const input = raw;
+    const change = {};
+    if (input.cwd !== undefined) {
+        if (typeof input.cwd !== 'string' || !input.cwd.trim() || input.cwd.length > MAX_PATH_LENGTH)
+            return { error: 'invalid cwd' };
+        change.cwd = input.cwd;
+    }
+    if (input.useAgentFolder !== undefined) {
+        if (input.useAgentFolder !== true || change.cwd !== undefined)
+            return { error: 'invalid useAgentFolder' };
+        change.useAgentFolder = true;
+    }
+    if (input.approval !== undefined) {
+        if (input.approval !== 'ask' && input.approval !== 'auto_read')
+            return { error: 'invalid approval' };
+        change.approval = input.approval;
+    }
+    for (const key of ['paused', 'dinoxTools']) {
+        if (input[key] === undefined)
+            continue;
+        if (typeof input[key] !== 'boolean')
+            return { error: `invalid ${key}` };
+        change[key] = input[key];
+    }
+    if (Object.keys(change).length === 0)
+        return { error: 'nothing to change' };
+    return { update: { ...value, settings: change } };
+}
 /** The run's chosen agent settings, `null` when none, `'invalid'` when malformed. */
 export function readAgentConfig(request) {
     const raw = request.agentConfig;

package/dist/gateway/runExecutor.d.ts

@@ -4,6 +4,8 @@ import type { RunSnapshot } from './streamPublisher.js';
 import type { GatewayAdapter, GatewayDefinition } from './types.js';
 /** Turns waiting behind a thread's active one; more are refused as `busy`. */
 export declare const MAX_QUEUED_TURNS = 10;
+/** How long a turn waits for the client's latest messages to sync to this machine. */
+export declare const CLIENT_TAIL_SYNC_TIMEOUT_MS = 5000;
 type Logger = (message: string, details?: Record<string, unknown>) => void;
 type Emit = (snapshot: RunSnapshot) => void;
 export declare class QueueFullError extends Error {
@@ -15,13 +17,21 @@ export type RunExecutorDeps = {
     gateway: GatewayDefinition;
     adapter: GatewayAdapter;
     log: Logger;
+    /** Overrides CLIENT_TAIL_SYNC_TIMEOUT_MS (tests). */
+    clientTailSyncTimeoutMs?: number;
+    /** Keeps the computer awake while a turn runs; returns the release. */
+    keepAwake?: () => () => void;
 };
+/** The user's instructions for the agent, as the start of a new session. */
+export declare function agentInstructionsPreamble(instructions: string): string | undefined;
 /**
  * Runs accepted turns on one gateway. A thread has at most one active run;
  * turns sent meanwhile wait in a per-thread FIFO and, when it ends, run
  * together as one turn (each keeps its own message; the reply follows the
  * last). The agent session is scoped to the thread's current topic: a "new
  * topic" marker in Dinox starts a fresh agent session, everything else continues it.
+ * The thread may have been answered by other agents meanwhile, so each turn
+ * also carries the messages this gateway's session has not seen.
  */
 export declare class GatewayRunExecutor {
     private readonly deps;
@@ -32,6 +42,7 @@ export declare class GatewayRunExecutor {
     private queueIndex;
     /** Accepts of one thread run one at a time, so two can never both start a turn. */
     private readonly acceptChains;
+    private readonly missingTails;
     constructor(deps: RunExecutorDeps);
     /** Threads with an active or waiting turn. */
     busyThreadIds(): string[];
@@ -62,6 +73,19 @@ export declare class GatewayRunExecutor {
         approved: boolean;
     }): RemoteDeviceToolApprovalAckCode;
     private execute;
+    /**
+     * The client sends the last message it saw; a turn reads the transcript only
+     * once that message has synced here (its upload may still be in flight), or
+     * gives up after a short wait. A tail that never arrived is not waited for again.
+     */
+    private clientTailSynced;
+    /**
+     * Messages before this turn that the session has not seen: the whole topic
+     * for a new session, those after the session's mark for a continued one,
+     * leaving out the turns the session answered itself. A session bound before
+     * seen messages were tracked is assumed to be up to date.
+     */
+    private unseenContext;
     private resolveResources;
 }
 export {};

package/dist/gateway/runExecutor.js

@@ -1,10 +1,18 @@
+import os from 'node:os';
 import { AssistantProjection, projectPendingApprovals, toTranscriptMessage } from './assistantProjection.js';
-import { commitRunTerminal, enqueueRun, finishMergedRun, startQueuedRuns, withdrawQueuedRun, readCurrentTopicId, readSessionBinding, resolveTrustedResource, updateRunSnapshot, writeSessionBinding, } from './threadStore.js';
+import { CONTEXT_MESSAGE_LIMIT, withConversationContext } from './conversationContext.js';
+import { commitRunTerminal, enqueueRun, finishMergedRun, startQueuedRuns, withdrawQueuedRun, readAgentInstructions, readCurrentTopic, readSessionBinding, readTranscriptPage, resolveTrustedResource, updateRunSnapshot, waitForMessage, withGatewaySession, writeSessionBinding, } from './threadStore.js';
 import { readAgentConfig } from './protocol.js';
 const SNAPSHOT_PERSIST_INTERVAL_MS = 1_000;
 /** Turns waiting behind a thread's active one; more are refused as `busy`. */
 export const MAX_QUEUED_TURNS = 10;
 const APPROVAL_TIMEOUT_MS = 30 * 60 * 1000;
+/** The agent's instructions travel with a new session's first prompt; longer ones are cut. */
+const MAX_INSTRUCTIONS_CHARS = 8_000;
+/** How long a turn waits for the client's latest messages to sync to this machine. */
+export const CLIENT_TAIL_SYNC_TIMEOUT_MS = 5_000;
+/** Client tails that never synced, so later turns of their thread do not wait for them again. */
+const MAX_REMEMBERED_MISSING_TAILS = 200;
 export class QueueFullError extends Error {
     constructor() {
         super(`At most ${MAX_QUEUED_TURNS} messages can wait in one conversation`);
@@ -18,6 +26,20 @@ function statusForStop(stopReason) {
         return 'failed';
     return 'succeeded';
 }
+/** The user's instructions for the agent, as the start of a new session. */
+export function agentInstructionsPreamble(instructions) {
+    const text = instructions.trim();
+    if (!text)
+        return undefined;
+    const clipped = text.length > MAX_INSTRUCTIONS_CHARS ? `${text.slice(0, MAX_INSTRUCTIONS_CHARS)}…` : text;
+    return [
+        '<dinox_agent_instructions>',
+        'Instructions the user set for you in Dinox. Follow them throughout this conversation.',
+        '',
+        clipped.replaceAll('</dinox_agent_instructions>', '<\\/dinox_agent_instructions>'),
+        '</dinox_agent_instructions>',
+    ].join('\n');
+}
 function withErrorText(message, error) {
     return { ...message, metadata: { ...(message.metadata ?? {}), error } };
 }
@@ -27,6 +49,8 @@ function withErrorText(message, error) {
  * together as one turn (each keeps its own message; the reply follows the
  * last). The agent session is scoped to the thread's current topic: a "new
  * topic" marker in Dinox starts a fresh agent session, everything else continues it.
+ * The thread may have been answered by other agents meanwhile, so each turn
+ * also carries the messages this gateway's session has not seen.
  */
 export class GatewayRunExecutor {
     deps;
@@ -37,6 +61,7 @@ export class GatewayRunExecutor {
     queueIndex = 0;
     /** Accepts of one thread run one at a time, so two can never both start a turn. */
     acceptChains = new Map();
+    missingTails = new Set();
     constructor(deps) {
         this.deps = deps;
     }
@@ -144,7 +169,9 @@ export class GatewayRunExecutor {
         };
         this.activeByThread.set(request.threadId, active);
         this.activeRequests.set(request.threadId, request);
+        const releaseAwake = this.deps.keepAwake?.();
         void this.execute(request, active, emit, merged).finally(() => {
+            releaseAwake?.();
             if (this.activeByThread.get(request.threadId) === active) {
                 this.activeByThread.delete(request.threadId);
                 this.activeRequests.delete(request.threadId);
@@ -235,21 +262,32 @@ export class GatewayRunExecutor {
         };
         const awaitApproval = registerApproval;
         let errorText = null;
+        let nextBinding = null;
         try {
             publish(true);
-            const [topicId, binding] = await Promise.all([
-                readCurrentTopicId(db, active.threadId),
-                readSessionBinding(db, active.threadId),
+            const [topic, binding] = await Promise.all([
+                readCurrentTopic(db, active.threadId),
+                readSessionBinding(db, active.threadId, gateway.id),
             ]);
-            const sessionId = binding && binding.gatewayId === gateway.id && binding.topicId === topicId ? binding.sessionId : null;
+            const topicId = topic?.id ?? null;
+            const continued = binding?.topicId === topicId ? binding : null;
             const turns = [...merged, request];
-            const resources = (await Promise.all(turns.map((turn) => this.resolveResources(turn.userMessage)))).flat();
+            const [resources, context, instructions] = await Promise.all([
+                Promise.all(turns.map((turn) => this.resolveResources(turn.userMessage))).then((lists) => lists.flat()),
+                this.clientTailSynced(turns[0], active.controller.signal).then((synced) => this.unseenContext(active.threadId, turns[0].userMessage.id, topic?.createdAt ?? null, continued, synced)),
+                readAgentInstructions(db, active.threadId).catch(() => ''),
+            ]);
+            // A session keeps the directory it started in; changing the default only affects new ones.
+            const cwd = continued ? (continued.cwd ?? gateway.previousCwd ?? gateway.cwd ?? os.homedir()) : (gateway.cwd ?? os.homedir());
             // Validated on receipt; a malformed value never reaches here.
             const requestedConfig = readAgentConfig(request);
             const agentConfig = requestedConfig && requestedConfig !== 'invalid' ? requestedConfig : undefined;
+            const prompt = turns.map((turn) => turn.prompt.trim()).filter(Boolean).join('\n\n');
             const result = await adapter.runTurn({
-                sessionId,
-                prompt: turns.map((turn) => turn.prompt.trim()).filter(Boolean).join('\n\n'),
+                sessionId: continued?.sessionId ?? null,
+                cwd,
+                sessionPreamble: agentInstructionsPreamble(instructions),
+                prompt: withConversationContext(prompt, context, { canReadConversation: gateway.dinoxTools !== false }),
                 resources,
                 signal: active.controller.signal,
                 config: agentConfig,
@@ -263,9 +301,19 @@ export class GatewayRunExecutor {
                     publish(event.type === 'approval-request' || event.type === 'approval-resolved');
                 },
             });
-            if (result.sessionId !== sessionId) {
-                await writeSessionBinding(db, active.threadId, { sessionId: result.sessionId, topicId, gatewayId: gateway.id });
-            }
+            nextBinding = {
+                sessionId: result.sessionId,
+                topicId,
+                cwd,
+                lastSeenMessageId: context?.incomplete
+                    ? // Messages that had not synced yet sort before this turn: keep the mark so the
+                        // next turn still catches up on them (its own turns are left out by session).
+                        continued && continued.sessionId === result.sessionId && !continued.legacy
+                            ? continued.lastSeenMessageId
+                            : null
+                    : // Its own reply is the newest message the session has seen.
+                        request.assistantMessage.id,
+            };
             status = statusForStop(result.stopReason);
             errorText = result.error ?? null;
         }
@@ -287,15 +335,73 @@ export class GatewayRunExecutor {
                 userId: this.deps.userId,
                 userMessageId: request.userMessage.id,
                 status,
-                assistant: toTranscriptMessage(assistant),
+                assistant: nextBinding
+                    ? withGatewaySession(toTranscriptMessage(assistant), { gatewayId: gateway.id, sessionId: nextBinding.sessionId })
+                    : toTranscriptMessage(assistant),
                 errorText,
             });
         }
         catch (error) {
             log('commit run terminal failed', { runId: active.runId, error: String(error) });
         }
+        if (nextBinding) {
+            // After the commit, so the reply it marks as seen is in the transcript.
+            await writeSessionBinding(db, active.threadId, gateway.id, nextBinding).catch((error) => log('write session binding failed', { runId: active.runId, error: String(error) }));
+        }
         emit({ revision: projection.revision, status, assistant, pendingApprovals: [] });
     }
+    /**
+     * The client sends the last message it saw; a turn reads the transcript only
+     * once that message has synced here (its upload may still be in flight), or
+     * gives up after a short wait. A tail that never arrived is not waited for again.
+     */
+    async clientTailSynced(request, signal) {
+        const tailId = request.parentMessageId;
+        if (!tailId)
+            return true;
+        const key = `${request.threadId}:${tailId}`;
+        const synced = await waitForMessage(this.deps.db, tailId, {
+            timeoutMs: this.missingTails.has(key) ? 0 : (this.deps.clientTailSyncTimeoutMs ?? CLIENT_TAIL_SYNC_TIMEOUT_MS),
+            signal,
+        });
+        if (synced) {
+            this.missingTails.delete(key);
+        }
+        else {
+            if (this.missingTails.size >= MAX_REMEMBERED_MISSING_TAILS)
+                this.missingTails.clear();
+            this.missingTails.add(key);
+            this.deps.log('client messages not synced yet', { threadId: request.threadId, tailId });
+        }
+        return synced;
+    }
+    /**
+     * Messages before this turn that the session has not seen: the whole topic
+     * for a new session, those after the session's mark for a continued one,
+     * leaving out the turns the session answered itself. A session bound before
+     * seen messages were tracked is assumed to be up to date.
+     */
+    async unseenContext(threadId, turnMessageId, topicStartedAt, continued, synced) {
+        if (continued?.legacy)
+            return synced ? null : { threadId, messages: [], earlier: 0, incomplete: true };
+        try {
+            const page = await readTranscriptPage(this.deps.db, {
+                threadId,
+                since: topicStartedAt,
+                afterMessageId: continued?.lastSeenMessageId ?? null,
+                beforeMessageId: turnMessageId,
+                excludeSessionId: continued?.sessionId ?? null,
+                limit: CONTEXT_MESSAGE_LIMIT,
+            });
+            return { threadId, ...page, ...(synced ? {} : { incomplete: true }) };
+        }
+        catch (error) {
+            // Missing context degrades the answer; it must not fail the turn. Marked
+            // incomplete so the session's mark stays and the next turn retries.
+            this.deps.log('read conversation context failed', { threadId, error: String(error) });
+            return { threadId, messages: [], earlier: 0, incomplete: true };
+        }
+    }
     async resolveResources(message) {
         const resources = [];
         for (const part of message.parts) {

package/dist/gateway/service.d.ts

@@ -16,11 +16,15 @@ export declare class GatewayService {
     private readonly deps;
     private hosts;
     private readonly log;
+    private readonly keepAwake;
     constructor(deps: GatewayServiceDeps);
     start(): Promise<void>;
     stop(): Promise<void>;
     /** Re-reads the account's gateways (after add/remove) without restarting the daemon. */
     reload(): Promise<DeviceHostStatus[]>;
+    /** Saves a change made in the app, applies it to the running gateway and syncs the robot row. */
+    private updateSettings;
+    private robotRegistration;
     status(): DeviceHostStatus[];
 }
 export {};

package/dist/gateway/service.js

@@ -1,9 +1,20 @@
 import os from 'node:os';
 import { getPackageVersion } from '../utils/version.js';
 import { createGatewayAdapter } from './adapters/index.js';
-import { getMachineId, loadGateways } from './config.js';
+import { getMachineId, loadGateways, updateGatewaySettings } from './config.js';
 import { GatewayDeviceHost } from './deviceHost.js';
+import { KeepAwake } from './keepAwake.js';
 import { interruptOrphanedRuns, retireRemovedRobots, upsertRobot } from './threadStore.js';
+/** Settings the owner changes from the app; the running gateway picks them up without a restart. */
+const LIVE_SETTINGS = ['cwd', 'previousCwd', 'approval', 'paused', 'dinoxTools'];
+function applyLiveSettings(target, source) {
+    for (const key of LIVE_SETTINGS) {
+        if (source[key] === undefined)
+            delete target[key];
+        else
+            target[key] = source[key];
+    }
+}
 const defaultLog = (message, details) => {
     process.stderr.write(`[dinox-gateway] ${message}${details ? ` ${JSON.stringify(details)}` : ''}\n`);
 };
@@ -15,9 +26,11 @@ export class GatewayService {
     deps;
     hosts = [];
     log;
+    keepAwake;
     constructor(deps) {
         this.deps = deps;
         this.log = deps.log ?? defaultLog;
+        this.keepAwake = new KeepAwake(this.log);
     }
     async start() {
         const configured = await loadGateways(this.deps.userId);
@@ -40,17 +53,7 @@ export class GatewayService {
         if (interrupted > 0)
             this.log('marked runs from a previous host as interrupted', { count: interrupted });
         for (const gateway of gateways) {
-            await upsertRobot(this.deps.db, {
-                id: gateway.id,
-                userId: this.deps.userId,
-                name: gateway.name,
-                deviceId: gateway.deviceId,
-                agentType: gateway.kind,
-                cwd: gateway.cwd ?? null,
-                deviceName: os.hostname(),
-                machineId,
-                ...(gateway.agentId ? { agentId: gateway.agentId } : {}),
-            }).catch((error) => this.log('register robot failed', { gateway: gateway.name, error: String(error) }));
+            await upsertRobot(this.deps.db, this.robotRegistration(gateway, machineId)).catch((error) => this.log('register robot failed', { gateway: gateway.name, error: String(error) }));
             const host = new GatewayDeviceHost({
                 gateway,
                 db: this.deps.db,
@@ -60,6 +63,8 @@ export class GatewayService {
                 appVersion: getPackageVersion(),
                 log: (message, details) => this.log(message, { gateway: gateway.name, ...details }),
                 credentialsUrl: this.deps.credentialsUrl,
+                updateSettings: (change) => this.updateSettings(gateway, machineId, change),
+                keepAwake: () => this.keepAwake.acquire(),
             });
             host.start();
             this.hosts.push(host);
@@ -69,6 +74,7 @@ export class GatewayService {
         const hosts = this.hosts;
         this.hosts = [];
         await Promise.allSettled(hosts.map((host) => host.stop()));
+        this.keepAwake.dispose();
     }
     /** Re-reads the account's gateways (after add/remove) without restarting the daemon. */
     async reload() {
@@ -76,6 +82,30 @@ export class GatewayService {
         await this.start();
         return this.status();
     }
+    /** Saves a change made in the app, applies it to the running gateway and syncs the robot row. */
+    async updateSettings(gateway, machineId, change) {
+        const updated = await updateGatewaySettings(this.deps.userId, gateway.id, change);
+        applyLiveSettings(gateway, updated);
+        await upsertRobot(this.deps.db, this.robotRegistration(gateway, machineId)).catch((error) => this.log('sync robot settings failed', { gateway: gateway.name, error: String(error) }));
+    }
+    robotRegistration(gateway, machineId) {
+        return {
+            id: gateway.id,
+            userId: this.deps.userId,
+            name: gateway.name,
+            deviceId: gateway.deviceId,
+            agentType: gateway.kind,
+            cwd: gateway.cwd ?? null,
+            deviceName: os.hostname(),
+            machineId,
+            ...(gateway.agentId ? { agentId: gateway.agentId } : {}),
+            settings: {
+                approval: gateway.approval ?? 'ask',
+                paused: gateway.paused === true,
+                dinoxTools: gateway.dinoxTools !== false,
+            },
+        };
+    }
     status() {
         return this.hosts.map((host) => host.status());
     }