@dinoxx/dinox-cli 2.13.1 → 2.14.0

package/dist/daemon/supervisor.d.ts

@@ -5,11 +5,11 @@
  * every gateway goes offline. Under launchd / systemd the daemon belongs to
  * the login session instead, starts at login, and is restarted after a crash.
  *
- * Restart policy is "on failure" only: a clean exit (`dino daemon stop`, a
- * version/account restart, exclusive DB access for `doctor`) leaves it
- * stopped until the CLI starts it again through the manager. launchd and
- * systemd restart the daemon themselves; on Windows, Task Scheduler only
- * starts `dino daemon supervise`, which restarts it (see supervise.ts).
+ * Restart policy is "always": launchd KeepAlive, systemd Restart=always, and
+ * on Windows `dino daemon supervise` (Task Scheduler only starts it; see
+ * supervise.ts) bring the daemon back after any exit, including a clean one
+ * for exclusive DB access or a crash. Only `dino daemon stop` / `uninstall`,
+ * which go through stop() / uninstall() here, leave it down.
  */
 export type DaemonServiceKind = 'launchd' | 'systemd' | 'schtasks';
 export type DaemonServiceSpec = {
@@ -33,25 +33,41 @@ export type DaemonService = {
     isInstalled(): boolean;
     /** True when the installed definition is exactly what this CLI would write. */
     isCurrent(spec: DaemonServiceSpec): boolean;
+    /** The program and arguments the installed definition runs, or null when there is none. */
+    installedCommand(): string[] | null;
     /** Writes the definition and (re)loads it, which starts the daemon. */
     install(spec: DaemonServiceSpec): Promise<void>;
     /** Starts the installed daemon when it is not running. */
     start(): Promise<void>;
+    /** Stops the daemon and keeps it stopped until start() (or the next login). */
+    stop(): Promise<void>;
+    /** Restarts it now, skipping restart throttling. Windows: the caller then stops it through the socket. */
+    restart(): Promise<void>;
     /** Stops the daemon and removes the definition; false when nothing was installed. */
     uninstall(): Promise<boolean>;
 };
 /** Set in the service definition so the daemon can report who supervises it. */
 export declare const DAEMON_SERVICE_ENV = "DINOX_DAEMON_SUPERVISOR";
+/** Windows: file in the daemon directory telling the supervisor not to restart. */
+export declare const SUPERVISOR_STOP_MARKER = "supervisor.stop";
 export declare const runServiceCommand: ServiceCommandRunner;
 /**
  * One daemon per data directory (it owns that directory's socket), so a
  * non-default `DINOX_DATA_DIR` gets its own service.
  */
 export declare function daemonServiceLabel(env?: NodeJS.ProcessEnv): string;
+/** ProgramArguments of a plist written by renderLaunchdPlist. */
+export declare function parseLaunchdProgramArguments(plist: string): string[] | null;
 export declare function renderLaunchdPlist(label: string, spec: DaemonServiceSpec): string;
+/** The words of an ExecStart line written by renderSystemdUnit. */
+export declare function parseSystemdExecStart(unit: string): string[] | null;
 export declare function renderSystemdUnit(spec: DaemonServiceSpec): string;
 /** Quotes one argument the way CommandLineToArgvW (and so Node) parses it back. */
 export declare function quoteWindowsArg(value: string): string;
+/** Splits a command line the way the Windows C runtime does (the inverse of quoteWindowsArg). */
+export declare function splitWindowsCommandLine(commandLine: string): string[];
+/** The command line of a launcher written by renderWindowsLauncher. */
+export declare function parseWindowsLauncherCommand(launcher: string): string[] | null;
 /**
  * Task Scheduler runs console programs in a visible window, so the task runs
  * this script with wscript, which sets the daemon environment and starts the

package/dist/daemon/supervisor.js

@@ -8,6 +8,8 @@ import { DinoxError } from '../utils/errors.js';
 /** Set in the service definition so the daemon can report who supervises it. */
 export const DAEMON_SERVICE_ENV = 'DINOX_DAEMON_SUPERVISOR';
 const DEFAULT_LABEL = 'com.dinox.cli.daemon';
+/** Windows: file in the daemon directory telling the supervisor not to restart. */
+export const SUPERVISOR_STOP_MARKER = 'supervisor.stop';
 const COMMAND_TIMEOUT_MS = 15_000;
 const LAUNCHD_BOOTSTRAP_ATTEMPTS = 5;
 const LAUNCHD_BOOTSTRAP_RETRY_MS = 300;
@@ -54,6 +56,21 @@ function xmlEscape(value) {
         .replace(/>/g, '>')
         .replace(/"/g, '"');
 }
+function xmlUnescape(value) {
+    return value
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&apos;/g, "'")
+        .replace(/&amp;/g, '&');
+}
+/** ProgramArguments of a plist written by renderLaunchdPlist. */
+export function parseLaunchdProgramArguments(plist) {
+    const array = /<key>ProgramArguments<\/key>\s*<array>([\s\S]*?)<\/array>/.exec(plist);
+    if (!array)
+        return null;
+    return [...array[1].matchAll(/<string>([\s\S]*?)<\/string>/g)].map((match) => xmlUnescape(match[1]));
+}
 export function renderLaunchdPlist(label, spec) {
     const string = (value) => `<string>${xmlEscape(value)}</string>`;
     const args = [spec.program, ...spec.args].map((arg) => `\t\t${string(arg)}`).join('\n');
@@ -80,10 +97,7 @@ ${env}
 \t<key>RunAtLoad</key>
 \t<true/>
 \t<key>KeepAlive</key>
-\t<dict>
-\t\t<key>SuccessfulExit</key>
-\t\t<false/>
-\t</dict>
+\t<true/>
 \t<key>ThrottleInterval</key>
 \t<integer>30</integer>
 \t<key>StandardOutPath</key>
@@ -117,6 +131,10 @@ class LaunchdService {
     isCurrent(spec) {
         return readDefinition(this.definitionPath) === this.render(spec);
     }
+    installedCommand() {
+        const plist = readDefinition(this.definitionPath);
+        return plist === null ? null : parseLaunchdProgramArguments(plist);
+    }
     async isLoaded() {
         return (await this.run('launchctl', ['print', this.target])).code === 0;
     }
@@ -147,6 +165,18 @@ class LaunchdService {
         if (result.code !== 0)
             throw failed(this.kind, 'kickstart', result);
     }
+    async stop() {
+        const result = await this.run('launchctl', ['bootout', this.target]);
+        if (result.code !== 0 && await this.isLoaded())
+            throw failed(this.kind, 'bootout', result);
+    }
+    async restart() {
+        if (!(await this.isLoaded()))
+            await this.bootstrap();
+        const result = await this.run('launchctl', ['kickstart', '-k', this.target]);
+        if (result.code !== 0)
+            throw failed(this.kind, 'kickstart', result);
+    }
     async uninstall() {
         const installed = this.isInstalled();
         if (await this.isLoaded()) {
@@ -170,6 +200,16 @@ function systemdQuote(value) {
         .replace(/\n/g, '\\n');
     return `"${escaped}"`;
 }
+/** The words of an ExecStart line written by renderSystemdUnit. */
+export function parseSystemdExecStart(unit) {
+    const line = /^ExecStart=(.*)$/m.exec(unit);
+    if (!line)
+        return null;
+    return [...line[1].matchAll(/"((?:[^"\\]|\\.)*)"/g)].map((match) => match[1]
+        .replace(/%%/g, '%')
+        .replace(/\$\$/g, '$')
+        .replace(/\\(.)/g, (_, char) => (char === 'n' ? '\n' : char)));
+}
 export function renderSystemdUnit(spec) {
     const execStart = [spec.program, ...spec.args].map(systemdQuote).join(' ');
     const env = Object.keys(spec.env)
@@ -185,8 +225,8 @@ Type=simple
 ExecStart=${execStart}
 WorkingDirectory=${spec.workingDirectory.replace(/%/g, '%%')}
 ${env}
-Restart=on-failure
-RestartSec=30
+Restart=always
+RestartSec=5
 StandardOutput=append:${spec.logPath}
 StandardError=append:${spec.logPath}
 
@@ -215,6 +255,10 @@ class SystemdService {
     isCurrent(spec) {
         return readDefinition(this.definitionPath) === this.render(spec);
     }
+    installedCommand() {
+        const unit = readDefinition(this.definitionPath);
+        return unit === null ? null : parseSystemdExecStart(unit);
+    }
     async systemctl(step, ...args) {
         const result = await this.run('systemctl', ['--user', ...args]);
         if (result.code !== 0)
@@ -229,6 +273,12 @@ class SystemdService {
     async start() {
         await this.systemctl('start', 'start', this.unit);
     }
+    async stop() {
+        await this.systemctl('stop', 'stop', this.unit);
+    }
+    async restart() {
+        await this.systemctl('restart', 'restart', this.unit);
+    }
     async uninstall() {
         if (!this.isInstalled())
             return false;
@@ -260,6 +310,57 @@ export function quoteWindowsArg(value) {
     }
     return `${quoted}${'\\'.repeat(backslashes * 2)}"`;
 }
+/** Splits a command line the way the Windows C runtime does (the inverse of quoteWindowsArg). */
+export function splitWindowsCommandLine(commandLine) {
+    const args = [];
+    let current = '';
+    let inArg = false;
+    let quoted = false;
+    for (let index = 0; index < commandLine.length; index += 1) {
+        const char = commandLine[index];
+        if (char === '\\') {
+            let backslashes = 0;
+            while (commandLine[index] === '\\') {
+                backslashes += 1;
+                index += 1;
+            }
+            if (commandLine[index] === '"') {
+                current += '\\'.repeat(Math.floor(backslashes / 2));
+                if (backslashes % 2 === 1)
+                    current += '"';
+                else
+                    quoted = !quoted;
+            }
+            else {
+                current += '\\'.repeat(backslashes);
+                index -= 1;
+            }
+            inArg = true;
+        }
+        else if (char === '"') {
+            quoted = !quoted;
+            inArg = true;
+        }
+        else if (/\s/.test(char) && !quoted) {
+            if (inArg)
+                args.push(current);
+            current = '';
+            inArg = false;
+        }
+        else {
+            current += char;
+            inArg = true;
+        }
+    }
+    if (inArg)
+        args.push(current);
+    return args;
+}
+/** The command line of a launcher written by renderWindowsLauncher. */
+export function parseWindowsLauncherCommand(launcher) {
+    const line = /^shell\.Run "((?:[^"]|"")*)", 0, False\r?$/m.exec(launcher);
+    return line ? splitWindowsCommandLine(line[1].replace(/""/g, '"')) : null;
+}
 function vbsString(value) {
     return `"${value.replace(/"/g, '""').replace(/\r?\n/g, '" & vbLf & "')}"`;
 }
@@ -366,6 +467,10 @@ class WindowsTaskService {
     isCurrent(spec) {
         return readUtf16(this.definitionPath) === this.render(spec);
     }
+    installedCommand() {
+        const launcher = readUtf16(this.definitionPath);
+        return launcher === null ? null : parseWindowsLauncherCommand(launcher);
+    }
     async isRegistered() {
         return (await this.run('schtasks', ['/Query', '/TN', this.taskName])).code === 0;
     }
@@ -398,15 +503,29 @@ class WindowsTaskService {
             throw failed(this.kind, 'run', result);
     }
     async install(spec) {
+        this.clearStopMarker();
         writeUtf16(this.definitionPath, this.render(spec));
         await this.register();
         await this.runTask();
     }
     async start() {
+        this.clearStopMarker();
         if (!(await this.isRegistered()))
             await this.register();
         await this.runTask();
     }
+    async stop() {
+        mkdirSync(this.launcherDir, { recursive: true });
+        writeFileSync(path.join(this.launcherDir, SUPERVISOR_STOP_MARKER), '');
+    }
+    async restart() {
+        this.clearStopMarker();
+    }
+    clearStopMarker() {
+        const marker = path.join(this.launcherDir, SUPERVISOR_STOP_MARKER);
+        if (existsSync(marker))
+            unlinkSync(marker);
+    }
     async uninstall() {
         const installed = this.isInstalled();
         if (await this.isRegistered()) {

package/dist/daemon/types.d.ts

@@ -12,6 +12,11 @@ export type DaemonResponse = {
 };
 export type DaemonShutdownParams = {
     expectedInstanceId: string;
+    requester?: {
+        pid: number;
+        version: string;
+        command?: string;
+    };
 };
 export type DaemonShutdownResult = {
     stopping: true;
@@ -47,3 +52,14 @@ export type DaemonPingResult = {
 };
 /** Kept only for old scripts that pass --port; the daemon transport is socket-based. */
 export declare const DEFAULT_DAEMON_PORT = 45678;
+export type CommandExecuteParams = {
+    argv: string[];
+    cwd: string;
+    clientVersion: string;
+    requestId?: string;
+};
+export type CommandExecuteResult = {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+};

package/dist/dinox.js

@@ -1,70 +1,47 @@
 #!/usr/bin/env node
-import { createCli } from './cli.js';
-import { buildStructuredErrorPayload, isDinoxError } from './utils/errors.js';
-import { clearRequestedStructuredOutputFormat, parseStructuredOutputFormatFromArgv, printError, printHumanReadableError, setRequestedStructuredOutputFormat, } from './utils/output.js';
+import { commandExecutionTarget, tryForwardToDaemon } from './daemon/forward.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';
-function normalizeArgv(argv) {
-    // pnpm/npm script forwarding can prepend a standalone "--".
-    if (argv[0] === '--') {
-        return argv.slice(1);
+import { localCommandExecution, requestContext } from './utils/requestContext.js';
+const argv = process.argv.slice(2);
+let fatalError;
+try {
+    const versionOnly = argv.length === 1 && ['--version', '-V'].includes(argv[0]);
+    const forwarded = versionOnly
+        ? { stdout: `${getPackageVersion()}\n`, stderr: '', exitCode: 0 }
+        : await tryForwardToDaemon(argv);
+    if (forwarded) {
+        process.stdout.write(forwarded.stdout);
+        process.stderr.write(forwarded.stderr);
+        process.exitCode = forwarded.exitCode;
+    }
+    else {
+        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 };
+            });
+            process.stdout.write(result.stdout);
+            process.stderr.write(result.stderr);
+            process.exitCode = result.exitCode;
+        }
+        else {
+            process.exitCode = await localCommandExecution.run(true, () => runCli(argv, error => { fatalError = error; }));
+        }
     }
-    return argv;
 }
-async function main() {
-    const program = createCli();
-    const argv = normalizeArgv(process.argv.slice(2));
-    const executable = process.argv[1] ?? 'dino';
-    await program.parseAsync(['node', executable, ...argv]);
+catch (error) {
+    // Routing failures use the same printer as command failures.
+    const { printCliError } = await import('./runCli.js');
+    process.exitCode = printCliError(error, argv);
 }
-function isVerbose(argv) {
-    return argv.includes('--verbose');
+if (isDinoxError(fatalError) && fatalError.requiresProcessExit) {
+    await exitProcessAfterFlushing(Number(process.exitCode));
 }
-function isCommanderError(error) {
-    return Boolean(error)
-        && typeof error === 'object'
-        && typeof error.code === 'string'
-        && error.code.startsWith('commander.')
-        && typeof error.exitCode === 'number';
-}
-async function exitAfterFatalCleanup(error, exitCode) {
-    if (isDinoxError(error) && error.requiresProcessExit) {
-        await exitProcessAfterFlushing(exitCode);
-    }
-}
-main().catch(async (error) => {
-    if (isCommanderError(error)) {
-        process.exitCode = error.exitCode === 0 ? 0 : 2;
-        return;
-    }
-    const argv = normalizeArgv(process.argv.slice(2));
-    let format = null;
-    try {
-        format = parseStructuredOutputFormatFromArgv(argv);
-    }
-    catch {
-        format = null;
-    }
-    const verbose = isVerbose(argv);
-    const payload = buildStructuredErrorPayload(error, verbose);
-    const exitCode = isDinoxError(error) ? error.exitCode : 1;
-    process.exitCode = exitCode;
-    if (format) {
-        setRequestedStructuredOutputFormat(format);
-        printError(payload, format);
-        clearRequestedStructuredOutputFormat();
-        await exitAfterFatalCleanup(error, exitCode);
-        return;
-    }
-    printHumanReadableError(payload.message);
-    if (payload.suggested_action) {
-        printHumanReadableError(`suggested action: ${payload.suggested_action.command}`);
-        printHumanReadableError(`reason: ${payload.suggested_action.reason}`);
-    }
-    else if (payload.suggestion) {
-        printHumanReadableError(`suggestion: ${payload.suggestion}`);
-    }
-    if (verbose && payload.stack) {
-        printHumanReadableError(payload.stack);
-    }
-    await exitAfterFatalCleanup(error, exitCode);
-});

package/dist/gateway/mcpCommandTools.d.ts

@@ -1,6 +1,8 @@
+import { type ExecFileOptionsWithStringEncoding } from 'node:child_process';
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 import type { CommandSchema } from '../commands/schema/types.js';
+import { tryForwardToDaemon } from '../daemon/forward.js';
 /**
  * One MCP tool per command group, generated from the command schemas. Each runs
  * the real CLI as a child process without a shell, preserving the CLI's own
@@ -17,6 +19,13 @@ export type CommandRunner = (argv: string[]) => Promise<{
     stderr: string;
 }>;
 /** Runs the current CLI entry point without a shell. */
+export declare function createCliCommandRunner(overrides?: {
+    forward?: typeof tryForwardToDaemon;
+    execute?: (file: string, args: string[], options: ExecFileOptionsWithStringEncoding) => Promise<{
+        stdout: string;
+        stderr: string;
+    }>;
+}): CommandRunner;
 export declare const runCliCommand: CommandRunner;
 /** Validates tool inputs and builds CLI arguments in schema order. */
 export declare function commandArgv(schema: CommandSchema, input: Record<string, unknown>): string[];

package/dist/gateway/mcpCommandTools.js

@@ -2,6 +2,8 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { z } from 'zod';
 import { listCommandSchemas } from '../commands/schema/spec.js';
+import { tryForwardToDaemon } from '../daemon/forward.js';
+import { requestContext } from '../utils/requestContext.js';
 /**
  * One MCP tool per command group, generated from the command schemas. Each runs
  * the real CLI as a child process without a shell, preserving the CLI's own
@@ -18,16 +20,44 @@ export const MCP_COMMAND_EXCLUSIONS = [
 ];
 const execute = promisify(execFile);
 /** Runs the current CLI entry point without a shell. */
-export const runCliCommand = (argv) => {
-    const entryPoint = process.argv[1];
-    if (entryPoint === undefined)
-        throw new Error('Cannot run CLI command: process.argv[1] is undefined');
-    return execute(process.execPath, [...process.execArgv, entryPoint, ...argv], {
-        env: process.env,
-        timeout: 120_000,
-        maxBuffer: 32 * 1024 * 1024,
-    });
-};
+export function createCliCommandRunner(overrides = {}) {
+    return (argv) => {
+        const entryPoint = process.argv[1];
+        if (entryPoint === undefined)
+            throw new Error('Cannot run CLI command: process.argv[1] is undefined');
+        return (async () => {
+            let result;
+            try {
+                result = await (overrides.forward ?? tryForwardToDaemon)(argv);
+            }
+            catch (error) {
+                const context = {
+                    stdout: [], stderr: [], format: null, noticeProvider: null, cwd: process.cwd(),
+                };
+                const { printCliError } = await import('../runCli.js');
+                const code = requestContext.run(context, () => printCliError(error, argv));
+                throw Object.assign(new Error(`Command failed with exit code ${code}`), {
+                    code, stdout: context.stdout.join(''), stderr: context.stderr.join(''),
+                });
+            }
+            if (result) {
+                if (result.exitCode !== 0) {
+                    throw Object.assign(new Error(`Command failed with exit code ${result.exitCode}`), {
+                        code: result.exitCode, stdout: result.stdout, stderr: result.stderr,
+                    });
+                }
+                return result;
+            }
+            return (overrides.execute ?? execute)(process.execPath, [...process.execArgv, entryPoint, ...argv], {
+                encoding: 'utf8',
+                env: process.env,
+                timeout: 120_000,
+                maxBuffer: 32 * 1024 * 1024,
+            });
+        })();
+    };
+}
+export const runCliCommand = createCliCommandRunner();
 function key(name) {
     return name
         .replace(/^[<[.]+|[>\].]+$/g, '')

package/dist/powersync/runtime.d.ts

@@ -7,6 +7,8 @@ export type ConnectResult = {
     dbPath: string;
     stale: boolean;
     releaseOwner: () => Promise<void>;
+    /** Drops the sync stream and connects again (online connections only). */
+    reconnect?: () => Promise<void>;
 };
 type ClosablePowerSyncDatabase = {
     close: () => Promise<void>;

package/dist/powersync/runtime.js

@@ -215,9 +215,11 @@ export async function connectPowerSync(args) {
             });
         }, uploader);
         await db.connect(connector);
+        // connect() disconnects an existing stream first.
+        const reconnect = () => db.connect(connector);
         if (args.waitForInitialSync === false) {
             const status = getStatusSnapshot(db);
-            return { db, dbPath, stale: !status.connected || !status.hasSynced, releaseOwner };
+            return { db, dbPath, stale: !status.connected || !status.hasSynced, releaseOwner, reconnect };
         }
         const { signal, cancel } = createTimeoutSignal(args.timeoutMs);
         try {

package/dist/requests/store.d.ts

@@ -0,0 +1,10 @@
+import type { CommandExecuteResult } from '../daemon/types.js';
+export declare const AUTO_REQUEST_ID_PREFIX = "auto:";
+export declare function validateRequestId(key: string): string;
+/** Reads only options before the argument terminator. */
+export declare function requestIdFromArgv(argv: string[]): string | undefined;
+/** Claims once across processes and preserves the complete output for replay. */
+export declare function runWithRequestId(key: string, argv: string[], run: () => Promise<CommandExecuteResult>, opts?: {
+    waitTimeoutMs?: number;
+    pollIntervalMs?: number;
+}): Promise<CommandExecuteResult>;