@dinoxx/dinox-cli 2.14.0 → 2.16.0

package/dist/commands/tags/index.js

@@ -1,3 +1,5 @@
+import { WRITE_DURABILITY_OPTION } from '../writeDurability.js';
+import { completeWrite, WRITE_RECEIPT_FIELDS } from '../writeReceipt.js';
 import { resolveAuthIdentity } from '../../auth/userInfo.js';
 import { registerCommandGroup } from '../descriptor/register.js';
 import { FORMAT_OPTIONS, OFFLINE_OPTIONS, REQUIRE_SYNC_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
@@ -5,7 +7,7 @@ import { buildTagAddDryRunPreview, buildTagMutationDryRunPreview } from '../writ
 import { printDryRunPreview } from '../../utils/dryRun.js';
 import { DinoxError } from '../../utils/errors.js';
 import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../../utils/output.js';
-import { commandStale, printStaleCacheWarning, syncBeforeCommand, waitForMutationUpload, withCommandRuntime, } from '../runtime.js';
+import { commandStale, printStaleCacheWarning, syncBeforeCommand, resolveWriteDurabilityForRuntime, withCommandRuntime, } from '../runtime.js';
 import { assertWriteConfirmationProvided, parseExpectedCount } from '../writeConfirmation.js';
 import { addTag, inspectAddTag, listTags } from './repo.js';
 import { getTagStats, getTagTree, inspectTagCleanup, mergeTag, moveTag, renameTag, suggestTagMerges, } from './operations.js';
@@ -56,6 +58,7 @@ async function runTagAdd(context) {
     }
     const structuredOutput = getRequestedStructuredOutputFormat() !== null;
     await withCommandRuntime(context, async (runtime) => {
+        const durability = resolveWriteDurabilityForRuntime(runtime, context.options.durability);
         const identity = await resolveAuthIdentity(runtime.config);
         await syncBeforeCommand(runtime, { syncTokenIndex: true });
         const emoji = typeof context.options.emoji === 'string' ? context.options.emoji : undefined;
@@ -76,8 +79,7 @@ async function runTagAdd(context) {
             userId: identity.userId,
             emoji,
         });
-        await waitForMutationUpload(runtime);
-        const payload = { ok: true, stale: commandStale(runtime), ...result };
+        const payload = { ok: true, ...(await completeWrite(runtime, durability)), ...result };
         if (structuredOutput) {
             printSuccess(payload);
             return;
@@ -88,9 +90,10 @@ async function runTagAdd(context) {
 }
 async function withTagWriteRuntime(context, run) {
     return withCommandRuntime(context, async (runtime) => {
+        const durability = resolveWriteDurabilityForRuntime(runtime, context.options.durability);
         const identity = await resolveAuthIdentity(runtime.config);
         await syncBeforeCommand(runtime, { syncTokenIndex: true });
-        return run({ runtime, userId: identity.userId });
+        return run({ runtime, userId: identity.userId, durability });
     });
 }
 function requireArg(value, message) {
@@ -103,7 +106,7 @@ function requireArg(value, message) {
 async function runTagRename(context) {
     const path = requireArg(context.args.path, 'Tag path is required');
     const newName = requireArg(context.args.newName, 'New tag name is required');
-    await withTagWriteRuntime(context, async ({ runtime, userId }) => {
+    await withTagWriteRuntime(context, async ({ runtime, userId, durability }) => {
         const result = await renameTag(runtime.db, { path, newName, userId }, { dryRun: Boolean(context.options.dryRun) });
         if (Boolean(context.options.dryRun)) {
             printDryRunPreview(buildTagMutationDryRunPreview({
@@ -118,8 +121,7 @@ async function runTagRename(context) {
             }), runtime);
             return;
         }
-        await waitForMutationUpload(runtime);
-        printSuccess({ ok: true, stale: commandStale(runtime), ...result });
+        printSuccess({ ok: true, ...(await completeWrite(runtime, durability)), ...result });
     });
 }
 async function runTagMove(context) {
@@ -128,7 +130,7 @@ async function runTagMove(context) {
     if (!to) {
         throw new DinoxError('--to is required');
     }
-    await withTagWriteRuntime(context, async ({ runtime, userId }) => {
+    await withTagWriteRuntime(context, async ({ runtime, userId, durability }) => {
         const result = await moveTag(runtime.db, { path, to, userId }, { dryRun: Boolean(context.options.dryRun) });
         if (Boolean(context.options.dryRun)) {
             printDryRunPreview(buildTagMutationDryRunPreview({
@@ -143,8 +145,7 @@ async function runTagMove(context) {
             }), runtime);
             return;
         }
-        await waitForMutationUpload(runtime);
-        printSuccess({ ok: true, stale: commandStale(runtime), ...result });
+        printSuccess({ ok: true, ...(await completeWrite(runtime, durability)), ...result });
     });
 }
 async function runTagMerge(context) {
@@ -158,7 +159,7 @@ async function runTagMerge(context) {
         expectedCount,
     };
     assertWriteConfirmationProvided('Tag merge', writeOptions);
-    await withTagWriteRuntime(context, async ({ runtime, userId }) => {
+    await withTagWriteRuntime(context, async ({ runtime, userId, durability }) => {
         const result = await mergeTag(runtime.db, { from, to, userId }, writeOptions);
         if (dryRun) {
             printDryRunPreview(buildTagMutationDryRunPreview({
@@ -179,8 +180,7 @@ async function runTagMerge(context) {
             }), runtime);
             return;
         }
-        await waitForMutationUpload(runtime);
-        printSuccess({ ok: true, stale: commandStale(runtime), ...result });
+        printSuccess({ ok: true, ...(await completeWrite(runtime, durability)), ...result });
     });
 }
 async function runTagSuggest(context) {
@@ -273,7 +273,7 @@ export const tagCommandGroup = {
             options: [
                 { flags: '--name <string>', description: 'Tag name/path (alternative to positional name)' },
                 { flags: '--emoji <string>', description: 'Tag emoji' },
-                { flags: '--dry-run', description: 'Preview the write without executing it' },
+                WRITE_DURABILITY_OPTION, { flags: '--dry-run', description: 'Preview the write without executing it' },
             ],
             schema: {
                 path: 'tag.add',
@@ -283,7 +283,7 @@ export const tagCommandGroup = {
                 output: {
                     type: 'structured',
                     summary: 'Tag creation acknowledgement',
-                    fields: ['id', 'tag', 'createdNodes', 'restoredNodes', 'stale'],
+                    fields: ['id', 'tag', 'createdNodes', 'restoredNodes', ...WRITE_RECEIPT_FIELDS],
                 },
                 examples: ['dino tag add "work/projects" --format json --dry-run', 'dino tag add "work/projects" --emoji "🏷️" --format json'],
             },
@@ -296,7 +296,7 @@ export const tagCommandGroup = {
                 { syntax: '<path>', description: 'Existing tag path' },
                 { syntax: '<new-name>', description: 'New leaf name' },
             ],
-            options: [{ flags: '--dry-run', description: 'Preview the write without executing it' }],
+            options: [WRITE_DURABILITY_OPTION, { flags: '--dry-run', description: 'Preview the write without executing it' }],
             schema: {
                 path: 'tag.rename',
                 risk: 'write',
@@ -305,7 +305,7 @@ export const tagCommandGroup = {
                 output: {
                     type: 'structured',
                     summary: 'Tag rename result',
-                    fields: ['id', 'fromPath', 'toPath', 'updatedTags', 'updatedNotes', 'stale'],
+                    fields: ['id', 'fromPath', 'toPath', 'updatedTags', 'updatedNotes', ...WRITE_RECEIPT_FIELDS],
                 },
                 examples: ['dino tag rename "AI/old" "new" --format json --dry-run'],
             },
@@ -317,7 +317,7 @@ export const tagCommandGroup = {
             arguments: [{ syntax: '<path>', description: 'Existing tag path' }],
             options: [
                 { flags: '--to <parent-path>', description: 'Target parent tag path', required: true, type: 'string' },
-                { flags: '--dry-run', description: 'Preview the write without executing it' },
+                WRITE_DURABILITY_OPTION, { flags: '--dry-run', description: 'Preview the write without executing it' },
             ],
             schema: {
                 path: 'tag.move',
@@ -327,7 +327,7 @@ export const tagCommandGroup = {
                 output: {
                     type: 'structured',
                     summary: 'Tag move result',
-                    fields: ['id', 'fromPath', 'toPath', 'updatedTags', 'updatedNotes', 'stale'],
+                    fields: ['id', 'fromPath', 'toPath', 'updatedTags', 'updatedNotes', ...WRITE_RECEIPT_FIELDS],
                 },
                 examples: ['dino tag move "AI" --to "Technology" --format json --dry-run'],
             },
@@ -343,7 +343,7 @@ export const tagCommandGroup = {
             options: [
                 { flags: '--expected-count <n>', description: 'Required for real writes; must equal source tags plus notes affected', type: 'number' },
                 { flags: '--confirm', description: 'Required for real writes after reviewing a dry run', type: 'boolean' },
-                { flags: '--dry-run', description: 'Preview the write without executing it', type: 'boolean' },
+                WRITE_DURABILITY_OPTION, { flags: '--dry-run', description: 'Preview the write without executing it', type: 'boolean' },
             ],
             schema: {
                 path: 'tag.merge',
@@ -353,7 +353,7 @@ export const tagCommandGroup = {
                 output: {
                     type: 'structured',
                     summary: 'Tag merge result',
-                    fields: ['fromId', 'toId', 'fromPath', 'toPath', 'softDeletedTagIds', 'updatedNotes', 'affectedCount', 'stale'],
+                    fields: ['fromId', 'toId', 'fromPath', 'toPath', 'softDeletedTagIds', 'updatedNotes', 'affectedCount', ...WRITE_RECEIPT_FIELDS],
                 },
                 examples: [
                     'dino tag merge "ai" "AI" --format json --dry-run',

package/dist/commands/todo/index.js

@@ -1,4 +1,5 @@
 import { resolveAuthIdentity } from '../../auth/userInfo.js';
+import { nextCursor, resolveCursorOffset } from '../../utils/cursor.js';
 import { registerCommandGroup } from '../descriptor/register.js';
 import { FORMAT_OPTIONS, OFFLINE_OPTIONS, REQUIRE_SYNC_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
 import { WRITE_DURABILITY_OPTION } from '../writeDurability.js';
@@ -147,12 +148,25 @@ async function runTodoSearch({ args, globals, options }) {
     });
     const limit = parsePositiveIntegerOption(searchOptions.limit, '--limit', DEFAULT_TASK_LIMIT, MAX_TASK_LIMIT);
     const scanLimit = parsePositiveIntegerOption(searchOptions.scanLimit, '--scan-limit', DEFAULT_NOTE_SCAN_LIMIT, MAX_NOTE_SCAN_LIMIT);
+    // Raw option values, not the resolved range: `--days` must not change the hash between pages.
+    const cursorQuery = {
+        keyword,
+        includeDeleted: Boolean(searchOptions.includeDeleted),
+        taskStatus,
+        taskTagFilter,
+        from: searchOptions.from,
+        to: searchOptions.to,
+        days: searchOptions.days,
+        scanLimit,
+    };
+    const offset = resolveCursorOffset(searchOptions.cursor, 0, 'todo.search', cursorQuery);
     const wire = toTodoSearchWire(keyword, {
         includeDeleted: Boolean(searchOptions.includeDeleted),
         taskStatus,
         taskTagFilter,
         taskDateRange,
         limit,
+        offset,
         scanLimit,
     });
     const result = await routeRead(globals, 'todo.search', wire, () => withTodoDatabase(globals, async (runtime) => {
@@ -161,7 +175,12 @@ async function runTodoSearch({ args, globals, options }) {
         return { ...local, stale: commandStale(runtime) };
     }));
     const { stale, ...response } = result;
-    printSuccess({ stale: stale ?? false, ...response });
+    const nextOffset = response.meta.offset + response.meta.returned_count;
+    printSuccess({
+        stale: stale ?? false,
+        ...response,
+        meta: { ...response.meta, next_cursor: nextCursor('todo.search', cursorQuery, nextOffset, response.meta.has_more) },
+    });
 }
 async function runTodoAppend({ args, globals, options }) {
     const appendOptions = options;
@@ -290,6 +309,7 @@ const todoSearchCommand = {
         { flags: '--days <n>', description: 'Recent N days; mutually exclusive with --from/--to' },
         { flags: '--limit <n>', description: 'Maximum returned tasks' },
         { flags: '--scan-limit <n>', description: 'Maximum scanned note rows' },
+        { flags: '--cursor <token>', description: 'Continue from meta.next_cursor of the previous page (same query)' },
         { flags: '--include-deleted', description: 'Include soft-deleted notes' },
     ],
     schema: {
@@ -301,7 +321,7 @@ const todoSearchCommand = {
             type: 'structured',
             summary: 'Todo search payload with metadata and task list',
             fields: ['tasks.task_id', 'tasks.task_key', 'tasks.note_id', 'tasks.note_title', 'tasks.status', 'tasks.depth', 'tasks.parent_id', 'tasks.tags'],
-            metaFields: ['stale', 'meta.query', 'meta.returned_count', 'meta.total_count', 'meta.total_count_is_lower_bound', 'meta.matched_note_count', 'meta.limit', 'meta.scan_limit', 'meta.scanned_note_count', 'meta.scan_truncated', 'meta.truncated', 'meta.applied_filters.status', 'meta.applied_filters.tags', 'meta.applied_filters.include_deleted', 'meta.applied_filters.date_range'],
+            metaFields: ['stale', 'meta.query', 'meta.returned_count', 'meta.total_count', 'meta.total_count_is_lower_bound', 'meta.matched_note_count', 'meta.limit', 'meta.offset', 'meta.has_more', 'meta.next_cursor', 'meta.scan_limit', 'meta.scanned_note_count', 'meta.scan_truncated', 'meta.truncated', 'meta.applied_filters.status', 'meta.applied_filters.tags', 'meta.applied_filters.include_deleted', 'meta.applied_filters.date_range'],
         },
         examples: ['dino todo search "报销" --status uncompleted --format json', 'dino todo search --days 7 --format json'],
     },

package/dist/commands/todo/repo.d.ts

@@ -7,6 +7,7 @@ export type SearchTodoOptions = {
     taskTagFilter: string[];
     taskDateRange?: TaskDateRangeFilter;
     limit: number;
+    offset?: number;
     scanLimit: number;
 };
 export type AppendTodoTasksOptions = {
@@ -65,6 +66,8 @@ export type SearchedTodoResponse = {
         total_count: number;
         matched_note_count: number;
         limit: number;
+        offset: number;
+        has_more: boolean;
         scan_limit: number;
         scanned_note_count: number;
         scan_truncated: boolean;
@@ -109,6 +112,8 @@ export type TodoSearchWire = {
     taskStatus: TaskStatusFilter;
     taskTagFilter: string[];
     limit: number;
+    /** Index of the first returned task among the matches (from `--cursor`). */
+    offset?: number;
     scanLimit: number;
     startDate?: string;
     endDate?: string;

package/dist/commands/todo/repo.js

@@ -40,6 +40,7 @@ export function toTodoSearchWire(query, options) {
         taskStatus: options.taskStatus,
         taskTagFilter: options.taskTagFilter,
         limit: options.limit,
+        ...(options.offset ? { offset: options.offset } : {}),
         scanLimit: options.scanLimit,
         startDate: options.taskDateRange?.startDate?.toISOString(),
         endDate: options.taskDateRange?.endDate?.toISOString(),
@@ -62,6 +63,7 @@ export async function executeTodoSearch(db, wire) {
         taskTagFilter: wire.taskTagFilter,
         taskDateRange,
         limit: wire.limit,
+        offset: wire.offset,
         scanLimit: wire.scanLimit,
     });
 }
@@ -71,7 +73,8 @@ export async function searchTodoTasks(db, query, options) {
     const noteRows = scannedRows.slice(0, options.scanLimit);
     const allTasks = extractFlattenedTasks(noteRows);
     const filteredTasks = filterTasksForTodoList(allTasks, query, options.taskStatus, options.taskTagFilter, options.taskDateRange);
-    const visibleTasks = filteredTasks.slice(0, options.limit);
+    const offset = options.offset ?? 0;
+    const visibleTasks = filteredTasks.slice(offset, offset + options.limit);
     const tasks = visibleTasks.map((task) => ({
         task_key: buildTaskKey(task.noteId, task.taskId),
         note_id: task.noteId,
@@ -96,11 +99,13 @@ export async function searchTodoTasks(db, query, options) {
             total_count: filteredTasks.length,
             matched_note_count: new Set(filteredTasks.map((task) => task.noteId)).size,
             limit: options.limit,
+            offset,
+            has_more: filteredTasks.length > offset + tasks.length,
             scan_limit: options.scanLimit,
             scanned_note_count: noteRows.length,
             scan_truncated: scanTruncated,
             total_count_is_lower_bound: scanTruncated,
-            truncated: scanTruncated || filteredTasks.length > tasks.length,
+            truncated: scanTruncated || filteredTasks.length > offset + tasks.length,
             applied_filters: {
                 status: options.taskStatus,
                 tags: [...options.taskTagFilter],

package/dist/commands/writeReceipt.d.ts

@@ -0,0 +1,13 @@
+import type { WriteDurability } from './writeDurability.js';
+import { type CommandRuntime, type MutationUploadReceipt } from './runtime.js';
+/** Output fields every local-database write reports, as note and todo writes do. */
+export declare const WRITE_RECEIPT_FIELDS: readonly ["durability", "upload_queue_remaining", "stale"];
+export type WriteReceipt = MutationUploadReceipt & {
+    stale: boolean;
+};
+/**
+ * Waits for the upload `--durability` asks for and describes where the write
+ * stands: `durability` local or uploaded, the remaining upload queue, any
+ * upload error, and whether the pre-write sync was stale.
+ */
+export declare function completeWrite(runtime: CommandRuntime, durability: WriteDurability): Promise<WriteReceipt>;

package/dist/commands/writeReceipt.js

@@ -0,0 +1,12 @@
+import { commandStale, waitForMutationUpload } from './runtime.js';
+/** Output fields every local-database write reports, as note and todo writes do. */
+export const WRITE_RECEIPT_FIELDS = ['durability', 'upload_queue_remaining', 'stale'];
+/**
+ * Waits for the upload `--durability` asks for and describes where the write
+ * stands: `durability` local or uploaded, the remaining upload queue, any
+ * upload error, and whether the pre-write sync was stale.
+ */
+export async function completeWrite(runtime, durability) {
+    const upload = await waitForMutationUpload(runtime, { durability });
+    return { ...upload, stale: commandStale(runtime) };
+}

package/dist/config/serviceEndpoints.d.ts

@@ -1,3 +1,5 @@
 export declare const POWERSYNC_DEFAULT_ENDPOINT = "https://powersync.dinoai.fun";
 export declare const POWERSYNC_DEFAULT_TOKEN_ENDPOINT = "https://dinoai.chatgo.pro/auth/v2/token";
 export declare const POWERSYNC_DEFAULT_UPLOAD_BASE_URL = "https://dinoai.chatgo.pro";
+/** dinox-tool business API (semantic search, gateway credentials). */
+export declare const AI_SERVICE_URL = "https://aisdk.chatgo.pro";

package/dist/config/serviceEndpoints.js

@@ -1,3 +1,5 @@
 export const POWERSYNC_DEFAULT_ENDPOINT = 'https://powersync.dinoai.fun';
 export const POWERSYNC_DEFAULT_TOKEN_ENDPOINT = 'https://dinoai.chatgo.pro/auth/v2/token';
 export const POWERSYNC_DEFAULT_UPLOAD_BASE_URL = 'https://dinoai.chatgo.pro';
+/** dinox-tool business API (semantic search, gateway credentials). */
+export const AI_SERVICE_URL = 'https://aisdk.chatgo.pro';

package/dist/daemon/client.d.ts

@@ -1,6 +1,8 @@
 import type { DaemonPingResult, DaemonShutdownResult } from './types.js';
 export declare function sendDaemonRequest(method: string, params?: unknown, requestOptions?: {
     timeoutMs?: number;
+    /** Streamed responses: called with each NDJSON frame ahead of the final response line. */
+    onFrame?: (frame: unknown) => void;
 }): Promise<unknown>;
 export declare function isDaemonRunning(timeoutMs?: number): Promise<boolean>;
 /**

package/dist/daemon/client.js

@@ -66,8 +66,9 @@ export async function sendDaemonRequest(method, params, requestOptions = {}) {
         };
         const req = httpRequest(options, (res) => {
             const statusCode = res.statusCode ?? 0;
-            const chunks = [];
+            let chunks = [];
             let totalBytes = 0;
+            const { onFrame } = requestOptions;
             res.on('data', (chunk) => {
                 totalBytes += chunk.length;
                 if (method !== 'command.execute' && totalBytes > MAX_DAEMON_RESPONSE_BYTES) {
@@ -75,6 +76,21 @@ export async function sendDaemonRequest(method, params, requestOptions = {}) {
                     return;
                 }
                 chunks.push(chunk);
+                if (!onFrame || !chunk.includes(0x0a))
+                    return;
+                // Every complete line is a frame; the response itself is the unterminated last line.
+                let pending = Buffer.concat(chunks);
+                for (let newline = pending.indexOf(0x0a); newline !== -1; newline = pending.indexOf(0x0a)) {
+                    const line = pending.subarray(0, newline).toString('utf-8');
+                    pending = pending.subarray(newline + 1);
+                    try {
+                        onFrame(JSON.parse(line));
+                    }
+                    catch {
+                        // A malformed frame only loses that progress line.
+                    }
+                }
+                chunks = [pending];
             });
             res.on('end', () => {
                 try {
@@ -97,8 +113,12 @@ export async function sendDaemonRequest(method, params, requestOptions = {}) {
             });
         });
         req.on('socket', socket => {
-            if (!socket.connecting)
+            // A reused keep-alive socket is already connected and never emits
+            // 'connect' again; listening anyway leaks one listener per request.
+            if (!socket.connecting) {
                 connected = true;
+                return;
+            }
             socket.once('connect', () => { connected = true; });
         });
         req.on('timeout', () => {

package/dist/daemon/forward.d.ts

@@ -30,5 +30,8 @@ export type ForwardDependencies = typeof forwardDependencies;
  * the daemon could have received the request. A failure after that point
  * throws DAEMON_UNAVAILABLE, never falls back, so a write is not applied twice.
  */
-export declare function tryForwardToDaemon(argv: string[], overrides?: Partial<ForwardDependencies>): Promise<CommandExecuteResult | null>;
+export declare function tryForwardToDaemon(argv: string[], overrides?: Partial<ForwardDependencies> & {
+    /** Receives `--progress` events live while the daemon runs the command. */
+    onProgress?: (text: string) => void;
+}): Promise<CommandExecuteResult | null>;
 export {};

package/dist/daemon/forward.js

@@ -1,6 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import { loadConfig } from '../config/store.js';
 import { resolveConfig } from '../config/resolve.js';
+import { GLOBAL_VALUE_OPTIONS } from '../commands/schema/globalOptions.js';
 import { DinoxError } from '../utils/errors.js';
 import { printHumanReadableWarning } from '../utils/output.js';
 import { parseSyncTimeoutMs } from '../utils/syncTimeout.js';
@@ -29,7 +30,7 @@ export function commandExecutionTarget(input) {
             words.push(...argv.slice(i + 1));
             break;
         }
-        if (arg === '--format' || arg === '--sync-timeout' || arg === '--request-id') {
+        if (GLOBAL_VALUE_OPTIONS.includes(arg)) {
             i++;
             continue;
         }
@@ -66,7 +67,8 @@ const forwardDependencies = {
  * throws DAEMON_UNAVAILABLE, never falls back, so a write is not applied twice.
  */
 export async function tryForwardToDaemon(argv, overrides = {}) {
-    const deps = { ...forwardDependencies, ...overrides };
+    const { onProgress, ...dependencyOverrides } = overrides;
+    const deps = { ...forwardDependencies, ...dependencyOverrides };
     if (commandExecutionTarget(argv) !== 'daemon' || /^(0|false|off|no)$/i.test(deps.env.DINOX_DAEMON ?? ''))
         return null;
     const fallback = (error) => {
@@ -106,8 +108,15 @@ export async function tryForwardToDaemon(argv, overrides = {}) {
     }
     const execute = async () => {
         const result = await deps.sendDaemonRequest('command.execute', {
-            argv, cwd: deps.cwd(), clientVersion: deps.version(), requestId,
-        }, { timeoutMs });
+            argv, cwd: deps.cwd(), clientVersion: deps.version(), requestId, ...(onProgress ? { stream: true } : {}),
+        }, {
+            timeoutMs,
+            ...(onProgress ? { onFrame: (frame) => {
+                    const text = frame?.progress;
+                    if (typeof text === 'string')
+                        onProgress(text);
+                } } : {}),
+        });
         if (!result || typeof result.stdout !== 'string' || typeof result.stderr !== 'string' || !Number.isInteger(result.exitCode)) {
             throw new Error('Invalid command.execute response');
         }

package/dist/daemon/server.d.ts

@@ -37,7 +37,7 @@ export declare class DaemonServer {
         onStopRequested?: (reason: string, details?: Record<string, unknown>) => void | Promise<void>;
     });
     initialize(): Promise<void>;
-    handleRequest(req: DaemonRequest): Promise<DaemonResponse>;
+    handleRequest(req: DaemonRequest, onProgress?: (text: string) => void): Promise<DaemonResponse>;
     private isCacheStale;
     start(port: number): Promise<void>;
     stop(): Promise<void>;

package/dist/daemon/server.js

@@ -74,6 +74,9 @@ function validateLocalRequest(req) {
     }
     return { ok: true };
 }
+function isStreamedCommand(request) {
+    return request?.method === 'command.execute' && request.params?.stream === true;
+}
 export class DaemonServer {
     options;
     config = null;
@@ -144,7 +147,7 @@ export class DaemonServer {
         // PowerSync keeps the local cache in sync continuously while connected,
         // so no background polling loop is needed here.
     }
-    async handleRequest(req) {
+    async handleRequest(req, onProgress) {
         try {
             if (!this.db) {
                 throw new Error('Database not initialized');
@@ -171,6 +174,7 @@ export class DaemonServer {
                         format: null,
                         noticeProvider: null,
                         cwd: input.cwd,
+                        ...(onProgress ? { onProgress } : {}),
                         daemon: {
                             db: this.db,
                             config: this.config,
@@ -316,12 +320,24 @@ export class DaemonServer {
                 }
                 try {
                     const daemonReq = await readJsonBody(req);
+                    if (isStreamedCommand(daemonReq)) {
+                        res.writeHead(200, { 'Content-Type': 'application/x-ndjson' });
+                        const daemonRes = await this.handleRequest(daemonReq, (progress) => {
+                            res.write(`${JSON.stringify({ progress })}\n`);
+                        });
+                        res.end(JSON.stringify(daemonRes));
+                        return;
+                    }
                     const daemonRes = await this.handleRequest(daemonReq);
                     res.writeHead(200, { 'Content-Type': 'application/json' });
                     res.end(JSON.stringify(daemonRes));
                 }
                 catch (error) {
                     const message = error instanceof Error ? error.message : String(error);
+                    if (res.headersSent) {
+                        res.end(JSON.stringify({ ok: false, error: message }));
+                        return;
+                    }
                     const statusCode = message.includes('too large') ? 413 : 400;
                     res.writeHead(statusCode, { 'Content-Type': 'application/json' });
                     res.end(JSON.stringify({ ok: false, error: message }));

package/dist/daemon/types.d.ts

@@ -57,6 +57,12 @@ export type CommandExecuteParams = {
     cwd: string;
     clientVersion: string;
     requestId?: string;
+    /** Answer as NDJSON: `{"progress": text}` frames while the command runs, then the response. */
+    stream?: boolean;
+};
+/** A frame the daemon streams ahead of a `stream: true` response. */
+export type CommandExecuteFrame = {
+    progress: string;
 };
 export type CommandExecuteResult = {
     stdout: string;

package/dist/dinox.js

@@ -1,17 +1,24 @@
 #!/usr/bin/env node
 import { commandExecutionTarget, tryForwardToDaemon } from './daemon/forward.js';
+import { applyDefaultFormat } from './utils/defaultFormat.js';
 import { getPackageVersion } from './utils/version.js';
 import { requestIdFromArgv, runWithRequestId } from './requests/store.js';
 import { isDinoxError } from './utils/errors.js';
 import { exitProcessAfterFlushing } from './utils/processExit.js';
-import { localCommandExecution, requestContext } from './utils/requestContext.js';
-const argv = process.argv.slice(2);
+import { localCommandExecution } from './utils/requestContext.js';
+/** `--progress` before `--`: the daemon streams events back while it runs the command. */
+function wantsProgress(args) {
+    const end = args.indexOf('--');
+    return (end === -1 ? args : args.slice(0, end)).includes('--progress');
+}
+let argv = process.argv.slice(2);
 let fatalError;
 try {
+    argv = applyDefaultFormat(argv);
     const versionOnly = argv.length === 1 && ['--version', '-V'].includes(argv[0]);
     const forwarded = versionOnly
         ? { stdout: `${getPackageVersion()}\n`, stderr: '', exitCode: 0 }
-        : await tryForwardToDaemon(argv);
+        : await tryForwardToDaemon(argv, wantsProgress(argv) ? { onProgress: (text) => process.stderr.write(text) } : {});
     if (forwarded) {
         process.stdout.write(forwarded.stdout);
         process.stderr.write(forwarded.stderr);
@@ -21,13 +28,8 @@ try {
         const { runCli } = await import('./runCli.js');
         const key = requestIdFromArgv(argv);
         if (key && commandExecutionTarget(argv) === 'daemon') {
-            const result = await runWithRequestId(key, argv, async () => {
-                const context = {
-                    stdout: [], stderr: [], format: null, noticeProvider: null, cwd: process.cwd(),
-                };
-                const exitCode = await requestContext.run(context, () => localCommandExecution.run(true, () => runCli(argv, error => { fatalError = error; })));
-                return { stdout: context.stdout.join(''), stderr: context.stderr.join(''), exitCode };
-            });
+            const { runCapturedInProcess } = await import('./requests/execute.js');
+            const result = await runWithRequestId(key, argv, () => runCapturedInProcess(argv, error => { fatalError = error; }));
             process.stdout.write(result.stdout);
             process.stderr.write(result.stderr);
             process.exitCode = result.exitCode;

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

@@ -37,11 +37,15 @@ export declare class AcpGatewayAdapter implements GatewayAdapter {
      * 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[]);
+    mcpServers?: (sessionToken: string, cwd: string) => McpServer[]);
     info(): GatewayAdapterInfo;
     runTurn(input: GatewayTurnInput): Promise<GatewayTurnResult>;
     sendFile(token: string, file: GatewayFileSource): Promise<GatewaySentFile> | null;
+    private catalogExpiresAt;
+    private catalogRevision;
+    private probing;
     describeConfig(): Promise<GatewayConfigOption[]>;
+    private probeConfig;
     dispose(): Promise<void>;
     /** Codex leaves generated images on disk; send the ones this turn made when it sent nothing itself. */
     private sendGeneratedImages;