@dinoxx/dinox-cli 2.13.0 → 2.14.0

package/dist/daemon/server.js

@@ -2,6 +2,8 @@ import crypto from 'node:crypto';
 import { createServer } from 'http';
 import { chmodSync, existsSync } from 'node:fs';
 import path from 'node:path';
+import { CONNECTIVITY_CHECK_INTERVAL_MS, createConnectivityWatcher } from './connectivity.js';
+import { commandExecutionTarget } from './forward.js';
 import { DAEMON_SERVICE_ENV } from './supervisor.js';
 import { writeDaemonLogLine } from './log.js';
 import { loadConfig } from '../config/store.js';
@@ -12,14 +14,21 @@ import { executeNoteSearch } from '../commands/notes/repo.js';
 import { getNoteDetail } from '../commands/notes/repo/read.js';
 import { getBacklinks, getGraphStats, getOutlinks, getRelatedNotes } from '../commands/graph/repo.js';
 import { executeTodoSearch } from '../commands/todo/repo.js';
-import { ensureDaemonDir, getDaemonSocketPath, isProcessRunning, readPid, removePid, savePid, } from './pid.js';
+import { acquireDaemonExclusiveIntentLock, ensureDaemonDir, getDaemonSocketPath, isProcessRunning, readPid, removePid, savePid, } from './pid.js';
 import { getPackageVersion } from '../utils/version.js';
 import { syncNoteTokenIndex } from '../powersync/tokenIndex.js';
 import { buildStructuredErrorPayload, DinoxError } from '../utils/errors.js';
+import { requestContext } from '../utils/requestContext.js';
+import { runWithRequestId } from '../requests/store.js';
 import { getDaemonInfo } from './client.js';
 import { GatewayService } from '../gateway/service.js';
 import { readConversation } from '../gateway/conversationContext.js';
 const MAX_DAEMON_REQUEST_BYTES = 1 * 1024 * 1024;
+const DAEMON_HEALTH_CHECK_INTERVAL_MS = 60_000;
+const DAEMON_STUCK_SYNC_RESTART_MS = 15 * 60_000;
+const DAEMON_INTENT_WAIT_CHUNK_MS = 30_000;
+/** EX_TEMPFAIL: the service manager restarts the daemon. */
+export const DAEMON_RESTART_EXIT_CODE = 75;
 function daemonSupervisor() {
     const value = process.env[DAEMON_SERVICE_ENV];
     return value === 'launchd' || value === 'systemd' || value === 'schtasks' ? value : null;
@@ -66,6 +75,8 @@ function validateLocalRequest(req) {
     return { ok: true };
 }
 export class DaemonServer {
+    options;
+    config = null;
     db = null;
     server = null;
     startTime = Date.now();
@@ -78,14 +89,30 @@ export class DaemonServer {
     ownsArtifacts = false;
     releaseOwner = null;
     stopPromise = null;
+    healthTimer = null;
+    connectivityTimer = null;
+    reconnect = null;
+    reconnecting = false;
+    syncUnconfirmedSince = null;
     gateways = null;
+    constructor(options = {}) {
+        this.options = options;
+        if (options.runtime) {
+            this.db = options.runtime.db;
+            this.config = options.runtime.config;
+        }
+    }
     async initialize() {
+        // Before reading config: an exclusive command (e.g. `auth login`) may be
+        // changing the saved identity while this respawned daemon waits.
+        await waitForDaemonExclusiveIntent(this.options.acquireIntentLock);
         const baseConfig = resolveConfig(await loadConfig());
         const { config } = await hydrateResolvedAuthIdentity(baseConfig, { timeoutMs: baseConfig.sync.timeoutMs });
+        this.config = config;
         this.userId = config.auth.userId ?? null;
         this.tokenFingerprint = config.auth.tokenFingerprint ?? null;
         this.runtimeConfigFingerprint = fingerprintDaemonRuntimeConfig(config);
-        const { db, releaseOwner } = await connectPowerSync({
+        const { db, releaseOwner, reconnect } = await (this.options.connect ?? connectPowerSync)({
             config,
             offline: false,
             timeoutMs: config.sync.timeoutMs,
@@ -94,6 +121,13 @@ export class DaemonServer {
         });
         this.db = db;
         this.releaseOwner = releaseOwner;
+        this.reconnect = reconnect ?? null;
+        if (process.env[DAEMON_SERVICE_ENV]) {
+            this.startHealthCheck(db);
+        }
+        if (this.reconnect) {
+            this.startConnectivityWatch();
+        }
         if (config.auth.userId && config.auth.authorization) {
             // Agent gateways share the daemon's PowerSync connection; a gateway
             // failure must never take the daemon down.
@@ -117,6 +151,43 @@ export class DaemonServer {
             }
             const { method, params } = req;
             switch (method) {
+                case 'command.execute': {
+                    const input = params;
+                    const valid = Boolean(input)
+                        && Array.isArray(input.argv)
+                        && input.argv.every((arg) => typeof arg === 'string')
+                        && typeof input.cwd === 'string'
+                        && path.isAbsolute(input.cwd)
+                        && typeof input.clientVersion === 'string'
+                        && commandExecutionTarget(input.argv) === 'daemon';
+                    if (!valid) {
+                        throw new DinoxError('Command cannot run inside the daemon.', { code: 'DAEMON_COMMAND_NOT_FORWARDABLE' });
+                    }
+                    if (!this.config)
+                        throw new Error('Daemon config not initialized');
+                    const context = {
+                        stdout: [],
+                        stderr: [],
+                        format: null,
+                        noticeProvider: null,
+                        cwd: input.cwd,
+                        daemon: {
+                            db: this.db,
+                            config: this.config,
+                            syncUnconfirmedSince: () => this.currentSyncUnconfirmedSince(),
+                        },
+                    };
+                    const execute = async () => {
+                        // Load the command tree only when the request is not a replay.
+                        const { runCli } = await import('../runCli.js');
+                        const exitCode = await requestContext.run(context, () => runCli(input.argv));
+                        return { stdout: context.stdout.join(''), stderr: context.stderr.join(''), exitCode };
+                    };
+                    const result = input.requestId === undefined
+                        ? await execute()
+                        : await runWithRequestId(input.requestId, input.argv, execute);
+                    return { id: req.id, ok: true, result };
+                }
                 case 'ping':
                     return {
                         id: req.id,
@@ -149,7 +220,9 @@ export class DaemonServer {
                         });
                     }
                     const timer = setTimeout(() => {
-                        void this.stop().catch(() => undefined);
+                        void Promise.resolve().then(() => this.options.onStopRequested
+                            ? this.options.onStopRequested('shutdown-request', { requester: shutdownParams.requester })
+                            : this.stop()).catch(() => undefined);
                     }, 10);
                     timer.unref?.();
                     return { id: req.id, ok: true, result: { stopping: true, instanceId: this.instanceId } };
@@ -318,7 +391,83 @@ export class DaemonServer {
             }
         }
     }
+    /**
+     * PowerSync reconnects on its own; a connection that stays failed for this
+     * long usually needs a fresh process (for example a rotated credential), so
+     * exit for the service manager to restart it.
+     */
+    startHealthCheck(db) {
+        let stuckSince = null;
+        this.healthTimer = setInterval(() => {
+            const status = getStatusSnapshot(db);
+            const failing = !status.connected
+                && Boolean(status.dataFlowStatus.downloadError || status.dataFlowStatus.uploadError);
+            if (!failing) {
+                stuckSince = null;
+                return;
+            }
+            stuckSince ??= Date.now();
+            if (Date.now() - stuckSince < DAEMON_STUCK_SYNC_RESTART_MS)
+                return;
+            if (this.healthTimer)
+                clearInterval(this.healthTimer);
+            this.healthTimer = null;
+            void Promise.resolve(this.options.onStopRequested?.('powersync-stuck', { exitCode: DAEMON_RESTART_EXIT_CODE }))
+                .catch(() => undefined);
+        }, DAEMON_HEALTH_CHECK_INTERVAL_MS);
+        this.healthTimer.unref();
+    }
+    startConnectivityWatch() {
+        const watcher = createConnectivityWatcher({
+            onChange: (change) => void this.handleConnectivityChange(change),
+        });
+        this.connectivityTimer = setInterval(() => watcher.tick(), CONNECTIVITY_CHECK_INTERVAL_MS);
+        this.connectivityTimer.unref();
+    }
+    /**
+     * After a wake from sleep or a network change the stream may be a dead
+     * connection that still reports "connected". Reconnect, and treat the cache
+     * as unconfirmed until a checkpoint completes on the new stream.
+     */
+    async handleConnectivityChange(change) {
+        if (!this.reconnect || this.reconnecting)
+            return;
+        this.reconnecting = true;
+        this.syncUnconfirmedSince = new Date().toISOString();
+        writeDaemonLogLine('dinox-daemon', 'reconnecting sync stream', { reason: change });
+        try {
+            await this.reconnect();
+        }
+        catch (error) {
+            writeDaemonLogLine('dinox-daemon', 'reconnect failed', {
+                reason: change,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        finally {
+            this.reconnecting = false;
+        }
+    }
+    /** The reconnect time while no checkpoint has completed since; null once confirmed. */
+    currentSyncUnconfirmedSince() {
+        const since = this.syncUnconfirmedSince;
+        if (!since || !this.db)
+            return since;
+        const status = getStatusSnapshot(this.db);
+        // PowerSync reports checkpoint times with whole-second precision.
+        const sinceMs = Math.floor(Date.parse(since) / 1_000) * 1_000;
+        if (!this.reconnecting && status.connected && status.lastSyncedAt && Date.parse(status.lastSyncedAt) >= sinceMs) {
+            this.syncUnconfirmedSince = null;
+        }
+        return this.syncUnconfirmedSince;
+    }
     async stopInternal() {
+        if (this.healthTimer)
+            clearInterval(this.healthTimer);
+        this.healthTimer = null;
+        if (this.connectivityTimer)
+            clearInterval(this.connectivityTimer);
+        this.connectivityTimer = null;
         const gateways = this.gateways;
         this.gateways = null;
         await gateways?.stop().catch(() => undefined);
@@ -353,3 +502,26 @@ export class DaemonServer {
         }
     }
 }
+/**
+ * Blocks until no exclusive command holds the intent lock. A respawned
+ * daemon must not take the database from the command that just stopped it;
+ * the lease is released by the OS if that command dies.
+ */
+export async function waitForDaemonExclusiveIntent(acquire = acquireDaemonExclusiveIntentLock) {
+    let logged = false;
+    for (;;) {
+        try {
+            const release = await acquire(DAEMON_INTENT_WAIT_CHUNK_MS);
+            await release();
+            return;
+        }
+        catch (error) {
+            if (error.code !== 'DAEMON_EXCLUSIVE_BUSY')
+                throw error;
+            if (!logged) {
+                writeDaemonLogLine('dinox-daemon', 'waiting for exclusive Dinox command to finish');
+                logged = true;
+            }
+        }
+    }
+}

package/dist/daemon/supervise.d.ts

@@ -10,6 +10,7 @@ export type SupervisedExit = {
 };
 export type SuperviseDependencies = {
     startChild: () => ChildProcess;
+    isStopRequested: () => boolean;
     sleep: (ms: number) => Promise<void>;
     now: () => number;
     log: (message: string, details?: Record<string, unknown>) => void;
@@ -17,12 +18,11 @@ export type SuperviseDependencies = {
     onStopRequest: (handler: () => void) => void;
 };
 /**
- * Keeps one daemon running, the way launchd's KeepAlive.SuccessfulExit=false
- * and systemd's Restart=on-failure do: restarts it after a crash with an
- * exponential backoff, and returns once it exits cleanly (exit code 0 from
- * `dino daemon stop`, an identity restart, or a stop for exclusive DB access)
- * or when asked to stop. Used where the service manager cannot restart the
- * daemon itself (Windows Task Scheduler).
+ * Keeps one daemon running the way launchd's KeepAlive and systemd's
+ * Restart=always do: restarts it after every exit, with an exponential
+ * backoff for repeated crashes, until `dino daemon stop` leaves the stop
+ * marker or the supervisor is signalled. Used where the service manager
+ * cannot restart the daemon itself (Windows Task Scheduler).
  */
 export declare function superviseDaemon(deps: SuperviseDependencies): Promise<number>;
 /** Runs the supervisor for this CLI's daemon until it exits cleanly or is signalled. */

package/dist/daemon/supervise.js

@@ -1,5 +1,7 @@
 import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
 import { appendDaemonLogLine, closeDaemonLogFd, openDaemonLogForChild } from './log.js';
+import { getSupervisorStopMarkerPath } from './pid.js';
 /** First restart delay after a crash; doubles per consecutive crash. */
 export const SUPERVISE_INITIAL_BACKOFF_MS = 1_000;
 export const SUPERVISE_MAX_BACKOFF_MS = 60_000;
@@ -20,12 +22,11 @@ function waitForExit(child) {
     });
 }
 /**
- * Keeps one daemon running, the way launchd's KeepAlive.SuccessfulExit=false
- * and systemd's Restart=on-failure do: restarts it after a crash with an
- * exponential backoff, and returns once it exits cleanly (exit code 0 from
- * `dino daemon stop`, an identity restart, or a stop for exclusive DB access)
- * or when asked to stop. Used where the service manager cannot restart the
- * daemon itself (Windows Task Scheduler).
+ * Keeps one daemon running the way launchd's KeepAlive and systemd's
+ * Restart=always do: restarts it after every exit, with an exponential
+ * backoff for repeated crashes, until `dino daemon stop` leaves the stop
+ * marker or the supervisor is signalled. Used where the service manager
+ * cannot restart the daemon itself (Windows Task Scheduler).
  */
 export async function superviseDaemon(deps) {
     let stopping = false;
@@ -37,7 +38,7 @@ export async function superviseDaemon(deps) {
         wakeSleep?.();
     });
     let backoffMs = SUPERVISE_INITIAL_BACKOFF_MS;
-    while (!stopping) {
+    while (!stopping && !deps.isStopRequested()) {
         const startedAt = deps.now();
         const child = deps.startChild();
         current = child;
@@ -46,13 +47,13 @@ export async function superviseDaemon(deps) {
         current = null;
         if (stopping)
             break;
-        if (exit.code === 0) {
-            deps.log('daemon exited cleanly; supervisor stopping');
+        if (deps.isStopRequested()) {
+            deps.log('stop marker found; supervisor stopping');
             return 0;
         }
         if (deps.now() - startedAt >= SUPERVISE_HEALTHY_RUN_MS)
             backoffMs = SUPERVISE_INITIAL_BACKOFF_MS;
-        deps.log('daemon crashed; restarting', { code: exit.code, signal: exit.signal, delayMs: backoffMs });
+        deps.log('daemon exited; restarting', { code: exit.code, signal: exit.signal, delayMs: backoffMs });
         await Promise.race([
             deps.sleep(backoffMs),
             new Promise((resolve) => {
@@ -73,6 +74,7 @@ export async function superviseCurrentDaemon(port) {
     // Launched hidden at logon there is no console, so write to the log file directly.
     const log = (message, details) => appendDaemonLogLine('dinox-supervisor', message, details);
     return superviseDaemon({
+        isStopRequested: () => existsSync(getSupervisorStopMarkerPath()),
         startChild: () => {
             const logFd = openDaemonLogForChild();
             try {

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;
+};