@dinoxx/dinox-cli 2.14.0 → 2.16.0

package/dist/gateway/runExecutor.js

@@ -1,8 +1,8 @@
-import os from 'node:os';
 import { AssistantProjection, projectPendingApprovals, toTranscriptMessage } from './assistantProjection.js';
 import { CONTEXT_MESSAGE_LIMIT, withConversationContext } from './conversationContext.js';
 import { commitRunTerminal, enqueueRun, finishMergedRun, startQueuedRuns, TERMINAL_RUN_STATUSES, withdrawQueuedRun, readAgentInstructions, readCurrentTopic, readSessionBinding, readTranscriptPage, resolveTrustedResource, updateRunSnapshot, waitForMessage, withGatewaySession, writeSessionBinding, } from './threadStore.js';
-import { readAgentConfig } from './protocol.js';
+import { AGENT_CWD_CONFIG_KEY, readAgentConfig } from './protocol.js';
+import { resolveTurnWorkspace, queuedTurnPrompt } from './workspace.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;
@@ -313,24 +313,35 @@ export class GatewayRunExecutor {
                 readSessionBinding(db, active.threadId, gateway.id),
             ]);
             const topicId = topic?.id ?? null;
-            const continued = binding?.topicId === topicId ? binding : null;
+            let continued = binding?.topicId === topicId ? binding : null;
             const turns = [...merged, request];
-            const [resources, context, instructions] = await Promise.all([
+            const tailSynced = this.clientTailSynced(turns[0], active.controller.signal);
+            const [resources, initialContext, 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)),
+                tailSynced.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.
+            let context = initialContext;
             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 agentConfig = requestedConfig && requestedConfig !== 'invalid' ? { ...requestedConfig } : undefined;
+            const cwd = await resolveTurnWorkspace(gateway, binding, !!continued, agentConfig);
+            if (agentConfig)
+                delete agentConfig[AGENT_CWD_CONFIG_KEY];
+            const prompt = queuedTurnPrompt(turns.map((turn) => turn.prompt));
             const result = await adapter.runTurn({
                 sessionId: continued?.sessionId ?? null,
                 cwd,
-                sessionPreamble: sessionPreamble(instructions, { delivery: !!this.deps.uploadFile, knowledge: gateway.dinoxTools !== false }),
-                prompt: withConversationContext(prompt, context, { canReadConversation: gateway.dinoxTools !== false }),
+                prompt: async ({ created }) => {
+                    if (created && continued) {
+                        continued = null;
+                        // A failed load has no retained history, including this gateway's own replies.
+                        const synced = await tailSynced;
+                        context = await this.unseenContext(active.threadId, turns[0].userMessage.id, topic?.createdAt ?? null, null, synced);
+                    }
+                    const text = withConversationContext(prompt, context, { canReadConversation: gateway.dinoxTools !== false });
+                    const preamble = created && sessionPreamble(instructions, { delivery: !!this.deps.uploadFile, knowledge: gateway.dinoxTools !== false });
+                    return preamble ? `${preamble}\n\n${text}` : text;
+                },
                 resources,
                 signal: active.controller.signal,
                 config: agentConfig,

package/dist/gateway/service.d.ts

@@ -15,11 +15,13 @@ export type GatewayServiceDeps = {
  */
 export declare class GatewayService {
     private readonly deps;
+    private readonly definitions;
     private hosts;
     private readonly log;
     private readonly keepAwake;
     constructor(deps: GatewayServiceDeps);
     start(): Promise<void>;
+    private reconcile;
     stop(): Promise<void>;
     /** Re-reads the account's gateways (after add/remove) without restarting the daemon. */
     reload(): Promise<DeviceHostStatus[]>;

package/dist/gateway/service.js

@@ -23,6 +23,7 @@ const defaultLog = (message, details) => writeDaemonLogLine('dinox-gateway', mes
  */
 export class GatewayService {
     deps;
+    definitions = new Map();
     hosts = [];
     log;
     keepAwake;
@@ -32,7 +33,9 @@ export class GatewayService {
         this.keepAwake = new KeepAwake(this.log);
     }
     async start() {
-        const configured = await loadGateways(this.deps.userId);
+        await this.reconcile(await loadGateways(this.deps.userId), true);
+    }
+    async reconcile(configured, recoverOrphans) {
         const machineId = await getMachineId();
         // Reconcile before anything else, also when the last gateway was removed.
         const retired = await retireRemovedRobots(this.deps.db, {
@@ -48,10 +51,17 @@ export class GatewayService {
         const gateways = configured.filter((gateway) => gateway.enabled);
         if (gateways.length === 0)
             return;
-        const interrupted = await interruptOrphanedRuns(this.deps.db, this.deps.userId);
+        const interrupted = recoverOrphans && this.hosts.length === 0 ? await interruptOrphanedRuns(this.deps.db, this.deps.userId) : 0;
         if (interrupted > 0)
             this.log('marked runs from a previous host as interrupted', { count: interrupted });
         for (const gateway of gateways) {
+            const existing = this.hosts.find((host) => this.definitions.get(host)?.id === gateway.id);
+            if (existing) {
+                const definition = this.definitions.get(existing);
+                applyLiveSettings(definition, gateway);
+                await upsertRobot(this.deps.db, this.robotRegistration(definition, machineId)).catch((error) => this.log('register robot failed', { gateway: gateway.name, error: String(error) }));
+                continue;
+            }
             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,
@@ -67,18 +77,33 @@ export class GatewayService {
             });
             host.start();
             this.hosts.push(host);
+            this.definitions.set(host, gateway);
         }
     }
     async stop() {
         const hosts = this.hosts;
         this.hosts = [];
+        this.definitions.clear();
         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() {
-        await this.stop();
-        await this.start();
+        const configured = await loadGateways(this.deps.userId);
+        const identity = (gateway) => JSON.stringify([
+            gateway.id, gateway.deviceId, gateway.name, gateway.kind, gateway.command, gateway.args ?? [],
+            Object.entries(gateway.env ?? {}).sort(([a], [b]) => a.localeCompare(b)), gateway.enabled,
+        ]);
+        for (const host of [...this.hosts]) {
+            const previous = this.definitions.get(host);
+            const next = configured.find((gateway) => gateway.id === previous.id);
+            if (next && identity(previous) === identity(next))
+                continue;
+            await host.stop();
+            this.hosts = this.hosts.filter((candidate) => candidate !== host);
+            this.definitions.delete(host);
+        }
+        await this.reconcile(configured, false);
         return this.status();
     }
     /** Saves a change made in the app, applies it to the running gateway and syncs the robot row. */

package/dist/gateway/threadStore.d.ts

@@ -219,4 +219,6 @@ export declare function retireRemovedRobots(db: Tx, input: {
     keepIds: string[];
 }): Promise<string[]>;
 export declare function softDeleteRobot(db: Tx, robotId: string): Promise<void>;
+/** Only the settings for this robot may choose its agent's workspace. */
+export declare function readAgentWorkspace(db: Tx, threadId: string, gatewayId: string): Promise<string | null>;
 export {};

package/dist/gateway/threadStore.js

@@ -595,3 +595,16 @@ function robotMachineId(metaData) {
 export async function softDeleteRobot(db, robotId) {
     await db.execute('UPDATE c_robot SET is_del = 1, updated_at = ? WHERE id = ?', [new Date().toISOString(), robotId]);
 }
+/** Only the settings for this robot may choose its agent's workspace. */
+export async function readAgentWorkspace(db, threadId, gatewayId) {
+    const row = await db.getOptional(`SELECT p.meta_data FROM c_thread t JOIN c_project p ON p.id = t.project_id
+     WHERE t.id = ? AND (p.is_del IS NULL OR p.is_del = 0) LIMIT 1`, [threadId]);
+    try {
+        const settings = JSON.parse(row?.meta_data ?? '{}').runSettings;
+        const value = settings?.robotId === gatewayId ? settings.values?.['dinox.cwd'] : null;
+        return typeof value === 'string' && value.length > 0 && value.length <= 4096 ? value : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/gateway/types.d.ts

@@ -26,7 +26,7 @@ export type GatewayDefinition = {
     /** ACP: executable started over stdio, e.g. `hermes` with args `["acp"]`. */
     command?: string;
     args?: string[];
-    /** Working directory for new agent sessions (each session keeps the one it started in). */
+    /** Last configured fallback after the conversation's and agent's working folders. */
     cwd?: string;
     /**
      * Directory of sessions bound before sessions recorded their own: the
@@ -118,9 +118,10 @@ export type GatewayTurnInput = {
     sessionId: string | null;
     /** Working directory of the session (a new one starts here; a continued one is loaded with it). */
     cwd: string;
-    prompt: string;
-    /** Prepended to the prompt when the turn starts a new session, e.g. the agent's instructions. */
-    sessionPreamble?: string;
+    /** Build context only after the adapter knows whether history survived. */
+    prompt: (session: {
+        created: boolean;
+    }) => Promise<string>;
     /** Attachments the user sent with this turn (trusted, https). */
     resources: Array<{
         uri: string;

package/dist/gateway/workspace.d.ts

@@ -0,0 +1,5 @@
+import type { GatewayDefinition } from './types.js';
+import type { GatewaySessionBinding } from './threadStore.js';
+/** A topic reset changes context, while the conversation keeps its folder. */
+export declare function resolveTurnWorkspace(gateway: GatewayDefinition, binding: GatewaySessionBinding | null, continued: boolean, config?: Record<string, string>): Promise<string>;
+export declare function queuedTurnPrompt(prompts: string[]): string;

package/dist/gateway/workspace.js

@@ -0,0 +1,30 @@
+import os from 'node:os';
+import { AGENT_CWD_CONFIG_KEY } from './protocol.js';
+import { resolveWorkspaceFolder } from './workspaceFolders.js';
+/** A topic reset changes context, while the conversation keeps its folder. */
+export async function resolveTurnWorkspace(gateway, binding, continued, config) {
+    if (continued)
+        return binding?.cwd ?? gateway.previousCwd ?? gateway.cwd ?? os.homedir();
+    if (binding?.cwd)
+        return binding.cwd;
+    const requested = config?.[AGENT_CWD_CONFIG_KEY];
+    if (requested) {
+        try {
+            return await resolveWorkspaceFolder(requested);
+        }
+        catch (error) {
+            throw new Error(`Working folder is unavailable: ${requested} (${error instanceof Error ? error.message : String(error)})`);
+        }
+    }
+    return gateway.cwd ?? os.homedir();
+}
+export function queuedTurnPrompt(prompts) {
+    if (prompts.length === 1)
+        return prompts[0].trim();
+    return [
+        '<dinox_queued_messages>',
+        'The user sent these messages one after another while you were busy. Answer them together.',
+        ...prompts.map((text, index) => `[Message ${index + 1}] ${text.trim().replaceAll('</dinox_queued_messages>', '<\\/dinox_queued_messages>')}`),
+        '</dinox_queued_messages>',
+    ].join('\n');
+}

package/dist/gateway/workspaceFolders.d.ts

@@ -18,10 +18,12 @@ export type WorkspaceFolder = {
 };
 /** The folder an agent may work in, resolved to its real path. */
 export declare function resolveWorkspaceFolder(input: string, home?: string): Promise<string>;
-/** `~/Dinox Agents/<agent name>`: a folder of the agent's own, offered as the default choice. */
-export declare function agentHomeFolder(agentName: string, home?: string): string;
+/** A portable folder name, optionally distinguished by the agent ID's last six characters. */
+export declare function agentFolderName(name: string, agentId?: string | null): string;
+/** `~/dinox-agents/<name>`: a folder of the agent's own, offered as the default choice. */
+export declare function agentHomeFolder(agentName: string, home?: string, agentId?: string | null): string;
 /** Creates the agent's own folder when missing; the only folder the app can create. */
-export declare function ensureAgentHomeFolder(agentName: string, home?: string): Promise<string>;
+export declare function ensureAgentHomeFolder(agentName: string, home?: string, agentId?: string | null): Promise<string>;
 /** The visible subfolders of a folder (the home folder included), for browsing. */
 export declare function listWorkspaceFolders(input: string | null | undefined, home?: string): Promise<{
     path: string;

package/dist/gateway/workspaceFolders.js

@@ -13,7 +13,7 @@ const MAX_FOLDERS = 200;
 /** Home-level folders that hold system data rather than the user's work. */
 const SYSTEM_FOLDERS = new Set(['Library', 'Applications']);
 const SKIPPED_FOLDERS = new Set(['node_modules']);
-const AGENT_HOME_PARENT = 'Dinox Agents';
+const AGENT_HOME_PARENT = 'dinox-agents';
 async function realHome(home) {
     return fs.realpath(home).catch(() => path.resolve(home));
 }
@@ -73,14 +73,27 @@ export async function resolveWorkspaceFolder(input, home = os.homedir()) {
     }
     return real;
 }
-/** `~/Dinox Agents/<agent name>`: a folder of the agent's own, offered as the default choice. */
-export function agentHomeFolder(agentName, home = os.homedir()) {
-    const safeName = agentName.replace(/[\u0000-\u001f\u007f/\\:*?"<>|]/g, '').trim() || 'Agent';
-    return path.join(home, AGENT_HOME_PARENT, safeName.slice(0, 64));
+/** A portable folder name, optionally distinguished by the agent ID's last six characters. */
+export function agentFolderName(name, agentId) {
+    let base = name.normalize('NFC')
+        .replace(/[\u0000-\u001f\u007f/\\:*?"<>|]/g, '')
+        .replace(/\s+/g, '-')
+        .toLowerCase()
+        .replace(/-+/g, '-')
+        .replace(/^[-.]+|[-.]+$/g, '');
+    base = Array.from(base).slice(0, 48).join('').replace(/[-.]+$/g, '') || 'agent';
+    if (/^(con|prn|aux|nul|com[0-9]|lpt[0-9])(\..*)?$/.test(base))
+        base += '-agent';
+    const suffix = agentId?.replace(/[^a-z0-9]/gi, '').toLowerCase().slice(-6);
+    return suffix ? `${base}-${suffix}` : base;
+}
+/** `~/dinox-agents/<name>`: a folder of the agent's own, offered as the default choice. */
+export function agentHomeFolder(agentName, home = os.homedir(), agentId) {
+    return path.join(home, AGENT_HOME_PARENT, agentFolderName(agentName, agentId));
 }
 /** Creates the agent's own folder when missing; the only folder the app can create. */
-export async function ensureAgentHomeFolder(agentName, home = os.homedir()) {
-    const folder = agentHomeFolder(agentName, home);
+export async function ensureAgentHomeFolder(agentName, home = os.homedir(), agentId) {
+    const folder = agentHomeFolder(agentName, home, agentId);
     await fs.mkdir(folder, { recursive: true, mode: 0o755 });
     return resolveWorkspaceFolder(folder, home);
 }

package/dist/gateway/workspaceListing.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractPowerSyncDatabase } from '@powersync/common';
+import { type RemoteDeviceWorkspaceListRequest, type RemoteDeviceWorkspaceListResponse } from '../vendor/electron/shared/remote-device-agent.js';
+import type { GatewayDefinition } from './types.js';
+/** Wire paths stay relative even when a directory on disk is a symlink. */
+export declare function listGatewayWorkspace(db: AbstractPowerSyncDatabase, userId: string, gateway: GatewayDefinition, request: RemoteDeviceWorkspaceListRequest): Promise<RemoteDeviceWorkspaceListResponse>;

package/dist/gateway/workspaceListing.js

@@ -0,0 +1,78 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { REMOTE_DEVICE_PROTOCOL_VERSION, } from '../vendor/electron/shared/remote-device-agent.js';
+import { readAgentWorkspace, readSessionBinding, threadExists } from './threadStore.js';
+import { resolveWorkspaceFolder } from './workspaceFolders.js';
+const SUBJECT_ID = /^[a-z0-9][a-z0-9_-]{0,127}$/;
+const DEVICE_ID = /^[a-z0-9][a-z0-9_-]{0,63}$/;
+const IGNORED_NAMES = new Set(['node_modules', 'build', 'coverage', 'dist']);
+function withinRoot(root, target) {
+    const relative = path.relative(root, target);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+/** Wire paths stay relative even when a directory on disk is a symlink. */
+export async function listGatewayWorkspace(db, userId, gateway, request) {
+    const base = {
+        protocolVersion: REMOTE_DEVICE_PROTOCOL_VERSION, type: 'workspace.list.result', requestId: request.requestId,
+        threadId: request.threadId, parentPath: '', ok: false, entries: [], nextCursor: null, truncated: false, fetchedAt: new Date().toISOString(),
+    };
+    const fail = (code, message) => ({ ...base, error: { code, message } });
+    const parent = request.parentPath ?? '';
+    if (request.protocolVersion !== REMOTE_DEVICE_PROTOCOL_VERSION ||
+        typeof request.requestId !== 'string' || !SUBJECT_ID.test(request.requestId) ||
+        typeof request.threadId !== 'string' || !SUBJECT_ID.test(request.threadId) ||
+        typeof request.clientDeviceId !== 'string' || !DEVICE_ID.test(request.clientDeviceId))
+        return fail('invalid_request', 'Invalid query identity');
+    if (typeof parent !== 'string' || parent.length > 2048 || parent.includes('\\') ||
+        path.win32.isAbsolute(parent) || parent.startsWith('/') ||
+        (parent && parent.split('/').some((part) => !part || part === '.' || part === '..' || part === '.git' || part === 'node_modules')))
+        return fail('invalid_request', 'Invalid workspace path');
+    base.parentPath = parent;
+    const cursor = request.cursor;
+    const offset = cursor === undefined || cursor === null || cursor === '' ? 0 : typeof cursor === 'string' && /^\d{1,8}$/.test(cursor) ? Number(cursor) : null;
+    if (offset === null)
+        return fail('invalid_request', 'Invalid workspace cursor');
+    try {
+        if (!(await threadExists(db, request.threadId, userId)))
+            return fail('thread_not_found', 'Conversation not found');
+        const binding = await readSessionBinding(db, request.threadId, gateway.id);
+        const agentFolder = binding?.cwd ? null : await readAgentWorkspace(db, request.threadId, gateway.id);
+        const root = binding?.cwd ?? (agentFolder ? await resolveWorkspaceFolder(agentFolder) : gateway.cwd);
+        if (!root)
+            return { ...base, ok: true };
+        const rootReal = await fs.realpath(root);
+        const target = await fs.realpath(path.resolve(rootReal, ...parent.split('/')));
+        if (path.relative(rootReal, target).split(path.sep).some((part) => part === '.git' || part === 'node_modules'))
+            return fail('invalid_request', 'Directory contents are unavailable');
+        if (!withinRoot(rootReal, target))
+            return fail('invalid_request', 'Workspace path escapes its root');
+        if (!(await fs.stat(target)).isDirectory())
+            return fail('invalid_request', 'Workspace path is not a directory');
+        const rank = (entry) => entry.isDirectory() ? 0 : entry.isSymbolicLink() ? 2 : 1;
+        const all = (await fs.readdir(target, { withFileTypes: true }))
+            .filter((entry) => !!entry.name && !entry.name.startsWith('.') && !entry.name.includes('\\') && !IGNORED_NAMES.has(entry.name))
+            .sort((a, b) => rank(a) - rank(b) || a.name.localeCompare(b.name, undefined, { numeric: true }));
+        const bounded = all.slice(0, 5000);
+        if (offset > bounded.length)
+            return fail('invalid_request', 'Invalid workspace cursor');
+        const limit = typeof request.limit === 'number' && Number.isFinite(request.limit) ? Math.min(200, Math.max(1, Math.trunc(request.limit))) : 100;
+        const page = bounded.slice(offset, offset + limit);
+        const entries = await Promise.all(page.map(async (entry) => {
+            const kind = entry.isSymbolicLink() ? 'symlink' : entry.isDirectory() ? 'directory' : 'file';
+            const stat = await fs.lstat(path.join(target, entry.name)).catch(() => null);
+            return {
+                path: parent ? `${parent}/${entry.name}` : entry.name,
+                name: entry.name,
+                kind,
+                hasChildren: kind === 'directory',
+                ...(stat?.isFile() ? { size: stat.size } : {}),
+                ...(stat ? { modifiedAt: stat.mtime.toISOString() } : {}),
+            };
+        }));
+        const next = offset + page.length;
+        return { ...base, ok: true, entries, nextCursor: next < bounded.length ? String(next) : null, truncated: all.length > bounded.length };
+    }
+    catch (error) {
+        return fail('query_failed', error instanceof Error ? error.message : String(error));
+    }
+}

package/dist/powersync/syncPass.js

@@ -1,14 +1,26 @@
 import { createTimeoutSignal } from '../utils/abort.js';
+import { reportProgress } from '../utils/progress.js';
 import { getStatusSnapshot, waitForDownloadIdle } from './runtime.js';
 import { syncNoteTokenIndex } from './tokenIndex.js';
 export async function runSingleSyncPass(db, timeoutMs) {
     const deadline = Date.now() + Math.max(1, timeoutMs);
     const remainingMs = () => Math.max(0, deadline - Date.now());
-    const downloadIdle = await waitForDownloadIdle(db, Math.max(1, Math.min(remainingMs(), 60_000)));
+    // PowerSync reports operation counts while a checkpoint downloads.
+    const stopDownloadProgress = db.registerListener({
+        statusChanged: (status) => {
+            const progress = status.downloadProgress;
+            if (progress)
+                reportProgress({ phase: 'download', current: progress.downloadedOperations, total: progress.totalOperations });
+        },
+    });
+    reportProgress({ phase: 'download' });
+    const downloadIdle = await waitForDownloadIdle(db, Math.max(1, Math.min(remainingMs(), 60_000)))
+        .finally(stopDownloadProgress);
     const indexTimeoutMs = remainingMs();
     const timeout = indexTimeoutMs > 0 ? createTimeoutSignal(indexTimeoutMs) : null;
     const tokenIndex = await syncNoteTokenIndex(db, {
         signal: timeout?.signal ?? AbortSignal.abort(),
+        onBatch: (progress) => reportProgress({ phase: 'index', current: progress.scanned }),
     }).finally(() => timeout?.cancel());
     const status = getStatusSnapshot(db);
     const uploadIdle = !status.dataFlowStatus.uploading;

package/dist/powersync/tokenIndex.d.ts

@@ -25,6 +25,8 @@ export declare function syncNoteTokenIndex(db: AbstractPowerSyncDatabase, option
     nowIso?: () => string;
     tokenize?: (text: string, limit?: number) => string[];
     signal?: AbortSignal;
+    /** Called after each batch with the running counters. */
+    onBatch?: (result: NoteTokenIndexResult) => void;
 }): Promise<NoteTokenIndexResult>;
 export declare function inspectNoteTokenIndex(db: AbstractPowerSyncDatabase): Promise<NoteTokenIndexInspection>;
 export declare function rebuildNoteTokenIndex(db: AbstractPowerSyncDatabase, options?: Parameters<typeof syncNoteTokenIndex>[1]): Promise<NoteTokenIndexResult>;

package/dist/powersync/tokenIndex.js

@@ -67,6 +67,7 @@ export async function syncNoteTokenIndex(db, options) {
         }
         await updateIndexCursor(db, cursorUpdatedAt, cursorId, nowIso);
         result.cursor = { updatedAt: cursorUpdatedAt, id: cursorId };
+        options?.onBatch?.(result);
     }
     result.complete = await reconcileSkippedRows(db, result, batchSize, nowIso, tokenize, signal);
     result.cursor = {

package/dist/requests/execute.d.ts

@@ -0,0 +1,11 @@
+import type { CommandExecuteResult } from '../daemon/types.js';
+/**
+ * Runs a command line in this process with its stdout/stderr captured instead
+ * of written, the same way the daemon runs a forwarded command.
+ */
+export declare function runCapturedInProcess(argv: string[], onFatalError?: (error: unknown) => void): Promise<CommandExecuteResult>;
+/**
+ * Runs one data command and returns its captured output: inside the daemon
+ * when it is available, otherwise in this process (honoring `--request-id`).
+ */
+export declare function executeCommandLine(argv: string[]): Promise<CommandExecuteResult>;

package/dist/requests/execute.js

@@ -0,0 +1,26 @@
+import { tryForwardToDaemon } from '../daemon/forward.js';
+import { localCommandExecution, requestContext } from '../utils/requestContext.js';
+import { requestIdFromArgv, runWithRequestId } from './store.js';
+/**
+ * Runs a command line in this process with its stdout/stderr captured instead
+ * of written, the same way the daemon runs a forwarded command.
+ */
+export async function runCapturedInProcess(argv, onFatalError) {
+    const { runCli } = await import('../runCli.js');
+    const context = {
+        stdout: [], stderr: [], format: null, noticeProvider: null, cwd: process.cwd(),
+    };
+    const exitCode = await requestContext.run(context, () => localCommandExecution.run(true, () => runCli(argv, onFatalError)));
+    return { stdout: context.stdout.join(''), stderr: context.stderr.join(''), exitCode };
+}
+/**
+ * Runs one data command and returns its captured output: inside the daemon
+ * when it is available, otherwise in this process (honoring `--request-id`).
+ */
+export async function executeCommandLine(argv) {
+    const forwarded = await tryForwardToDaemon(argv);
+    if (forwarded)
+        return forwarded;
+    const key = requestIdFromArgv(argv);
+    return key ? runWithRequestId(key, argv, () => runCapturedInProcess(argv)) : runCapturedInProcess(argv);
+}

package/dist/skills/commandRefs.js

@@ -1,17 +1,9 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { GLOBAL_OPTION_NAMES } from '../commands/schema/globalOptions.js';
 import { listCommandSchemas } from '../commands/schema/spec.js';
 // Global flags accepted by every command (see src/cli.ts) plus Commander builtins.
-const GLOBAL_FLAGS = new Set([
-    '--json',
-    '--format',
-    '--offline',
-    '--require-sync',
-    '--sync-timeout',
-    '--verbose',
-    '--help',
-    '--version',
-]);
+const GLOBAL_FLAGS = new Set([...GLOBAL_OPTION_NAMES, '--help', '--version']);
 const SHELL_BOUNDARY = /\s(?:\||&&|\|\||;|>|2>|#)\s/;
 function buildCommandIndex() {
     const byCommand = new Map();

package/dist/utils/cursor.d.ts

@@ -0,0 +1,9 @@
+export declare function encodeCursor(command: string, offset: number, query: unknown): string;
+/** Returns the offset a cursor points at; throws when it is malformed or belongs to another query. */
+export declare function decodeCursor(token: string, command: string, query: unknown): number;
+/**
+ * Resolves the start offset from `--cursor` or `--offset`; the two are
+ * mutually exclusive (an offset of 0, the default, does not count).
+ */
+export declare function resolveCursorOffset(cursor: unknown, offset: number, command: string, query: unknown): number;
+export declare function nextCursor(command: string, query: unknown, nextOffset: number, hasMore: boolean): string | null;

package/dist/utils/cursor.js

@@ -0,0 +1,61 @@
+import { createHash } from 'node:crypto';
+import { DinoxError } from './errors.js';
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(',')}]`;
+    if (value && typeof value === 'object') {
+        const entries = Object.entries(value)
+            .filter(([, item]) => item !== undefined)
+            .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+        return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${stableJson(item)}`).join(',')}}`;
+    }
+    return JSON.stringify(value ?? null);
+}
+function queryHash(command, query) {
+    return createHash('sha256').update(`${command}\n${stableJson(query)}`).digest('base64url').slice(0, 16);
+}
+export function encodeCursor(command, offset, query) {
+    const payload = { v: 1, c: command, o: offset, q: queryHash(command, query) };
+    return Buffer.from(JSON.stringify(payload)).toString('base64url');
+}
+function invalidCursor(message) {
+    return new DinoxError(message, {
+        code: 'INVALID_ARGUMENT',
+        recoverable: true,
+        suggestion: 'Pass the nextCursor from the previous page of the same command and query, or drop --cursor to start over.',
+    });
+}
+/** Returns the offset a cursor points at; throws when it is malformed or belongs to another query. */
+export function decodeCursor(token, command, query) {
+    let payload;
+    try {
+        payload = JSON.parse(Buffer.from(token.trim(), 'base64url').toString('utf8'));
+    }
+    catch {
+        throw invalidCursor('--cursor is not a valid pagination cursor');
+    }
+    if (!payload || payload.v !== 1 || typeof payload.o !== 'number' || !Number.isInteger(payload.o) || payload.o < 0) {
+        throw invalidCursor('--cursor is not a valid pagination cursor');
+    }
+    if (payload.c !== command || payload.q !== queryHash(command, query)) {
+        throw invalidCursor(`--cursor belongs to a different ${payload.c === command ? 'query' : 'command'}`);
+    }
+    return payload.o;
+}
+/**
+ * Resolves the start offset from `--cursor` or `--offset`; the two are
+ * mutually exclusive (an offset of 0, the default, does not count).
+ */
+export function resolveCursorOffset(cursor, offset, command, query) {
+    if (cursor === undefined || cursor === null || cursor === '')
+        return offset;
+    if (typeof cursor !== 'string')
+        throw invalidCursor('--cursor must be a string');
+    if (offset > 0) {
+        throw new DinoxError('--cursor and --offset cannot be used together', { code: 'INVALID_ARGUMENT', recoverable: true });
+    }
+    return decodeCursor(cursor, command, query);
+}
+export function nextCursor(command, query, nextOffset, hasMore) {
+    return hasMore ? encodeCursor(command, nextOffset, query) : null;
+}

package/dist/utils/defaultFormat.d.ts

@@ -0,0 +1,8 @@
+export declare const DEFAULT_FORMAT_ENV = "DINOX_FORMAT";
+/**
+ * Applies DINOX_FORMAT (json, yaml, or auto: json when stdout is not a
+ * terminal) by adding `--format` when the command line has none. Agents set
+ * it once instead of passing `--format json` on every call. Help, version and
+ * protocol commands are left alone.
+ */
+export declare function applyDefaultFormat(argv: string[], env?: NodeJS.ProcessEnv, stdoutIsTTY?: boolean): string[];

package/dist/utils/defaultFormat.js

@@ -0,0 +1,38 @@
+import { DinoxError } from './errors.js';
+export const DEFAULT_FORMAT_ENV = 'DINOX_FORMAT';
+/** Commands whose stdout is a protocol, never a command result. */
+const PROTOCOL_COMMANDS = [['gateway', 'mcp'], ['mcp'], ['daemon', 'supervise']];
+function commandWords(argv) {
+    return argv.filter((arg) => !arg.startsWith('-')).slice(0, 2);
+}
+/**
+ * Applies DINOX_FORMAT (json, yaml, or auto: json when stdout is not a
+ * terminal) by adding `--format` when the command line has none. Agents set
+ * it once instead of passing `--format json` on every call. Help, version and
+ * protocol commands are left alone.
+ */
+export function applyDefaultFormat(argv, env = process.env, stdoutIsTTY = Boolean(process.stdout.isTTY)) {
+    const raw = env[DEFAULT_FORMAT_ENV]?.trim().toLowerCase();
+    if (!raw)
+        return argv;
+    if (raw !== 'json' && raw !== 'yaml' && raw !== 'auto') {
+        throw new DinoxError(`${DEFAULT_FORMAT_ENV} must be one of: json, yaml, auto`, {
+            code: 'INVALID_ARGUMENT',
+            recoverable: true,
+        });
+    }
+    const format = raw === 'auto' ? (stdoutIsTTY ? null : 'json') : raw;
+    if (!format || argv.length === 0)
+        return argv;
+    const terminator = argv.indexOf('--');
+    const options = terminator === -1 ? argv : argv.slice(0, terminator);
+    const explicit = options.some((arg) => arg === '--format' || arg.startsWith('--format=') || arg === '--json');
+    const informational = options.some((arg) => ['--help', '-h', '--version', '-V'].includes(arg)) || options[0] === 'help';
+    const words = commandWords(options);
+    const protocol = PROTOCOL_COMMANDS.some((command) => command.every((word, index) => words[index] === word));
+    if (explicit || informational || protocol)
+        return argv;
+    return terminator === -1
+        ? [...argv, '--format', format]
+        : [...argv.slice(0, terminator), '--format', format, ...argv.slice(terminator)];
+}

package/dist/utils/errorCodes.d.ts

@@ -471,6 +471,10 @@ export declare const ERROR_CODES: {
         readonly exitCode: 5;
         readonly description: "No command schema exists for the requested path.";
     };
+    readonly SEMANTIC_SEARCH_UNAVAILABLE: {
+        readonly exitCode: 1;
+        readonly description: "The semantic search service could not be reached or failed; keyword search (note search) still works.";
+    };
     readonly SKILLS_LOCK_INVALID: {
         readonly exitCode: 1;
         readonly description: "The skills installer lock file is malformed.";

package/dist/utils/errorCodes.js

@@ -123,6 +123,7 @@ export const ERROR_CODES = {
     SAVED_VIEW_UNSUPPORTED_LAYOUT: { exitCode: 1, description: 'The saved view layout is unsupported.' },
     SAVED_VIEW_VALUE_TYPE_MISMATCH: { exitCode: 1, description: 'A filter value does not match the field type.' },
     SCHEMA_PATH_NOT_FOUND: { exitCode: 5, description: 'No command schema exists for the requested path.' },
+    SEMANTIC_SEARCH_UNAVAILABLE: { exitCode: 1, description: 'The semantic search service could not be reached or failed; keyword search (note search) still works.' },
     SKILLS_LOCK_INVALID: { exitCode: 1, description: 'The skills installer lock file is malformed.' },
     SKILLS_LOCK_READ_FAILED: { exitCode: 1, description: 'The skills installer lock file could not be read.' },
     SKILLS_MIGRATION_FAILED: { exitCode: 1, description: 'The skills installer failed during migration.' },