@adecore/service 0.29.1 → 0.29.2

package/README.md

@@ -1,6 +1,6 @@
 # @adecore/service
 
-Definitions and managers for macOS launchd GUI jobs and Linux systemd user services, with everything they touch injected. The host supplies the identity, paths, environment, commands and files. Deciding who may install a service and which executable it runs stays with the host.
+Definitions and managers for macOS launchd GUI jobs, Linux systemd user services and Windows scheduled tasks at logon, with everything they touch injected. The host supplies the identity, paths, environment, commands and files. Deciding who may install a service and which executable it runs stays with the host.
 
 ```sh
 bun add @adecore/service

package/dist/cmd-line.d.ts

@@ -0,0 +1,2 @@
+export declare function cmdEscaped(text: string): string;
+export declare function scheduledTaskMarker(label: string): string;

package/dist/cmd-line.js

@@ -0,0 +1,12 @@
+// What cmd.exe reads as syntax outside quotes, and so escapes with a caret.
+const CMD_SPECIAL = /([()\][%!^"`<>&|;, *?])/g;
+export function cmdEscaped(text) {
+    return text.replace(CMD_SPECIAL, '^$1');
+}
+/*
+ * What a manager finds the cmd.exe of a task by: `schtasks /End` ends that process alone, so a stop
+ * has to end the tree under it first. Its title is the label, which is the name of the task.
+ */
+export function scheduledTaskMarker(label) {
+    return `title ${cmdEscaped(label)} && `;
+}

package/dist/definitions.d.ts

@@ -6,7 +6,9 @@ export interface ServiceSpec {
     environment: Record<string, string>;
     workingDirectory: string;
     logFile: string;
+    user?: string;
 }
 export declare function launchAgentPlist(spec: ServiceSpec): string;
 export declare function systemdUnit(spec: ServiceSpec): string;
+export declare function scheduledTask(spec: ServiceSpec): string;
 export declare function definitionRunsProgram(definition: string, program: string): boolean;

package/dist/definitions.js

@@ -1,6 +1,10 @@
+import { cmdEscaped, scheduledTaskMarker } from './cmd-line.js';
 function xmlText(value) {
     return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
+function xmlValue(text) {
+    return text.replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&');
+}
 function plistString(value, indent) {
     return `${indent}<string>${xmlText(value)}</string>`;
 }
@@ -59,6 +63,96 @@ export function systemdUnit(spec) {
     ];
     return lines.join('\n');
 }
+/* One argument as the C runtime splits a command line, escaped so cmd.exe passes it on as it is. */
+function cmdArgument(arg) {
+    if (/[\r\n]/.test(arg)) {
+        throw new Error('A scheduled task cannot pass on a line break');
+    }
+    return cmdEscaped(`"${arg.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\*)$/, '$1$1')}"`);
+}
+/* The line cmd.exe runs: its title, the environment, the program and the log it appends to. */
+function taskCommandLine(spec) {
+    const variables = Object.entries(spec.environment).map(([name, value]) => `set ${cmdEscaped(`"${name}=${value}"`)}`);
+    const program = [cmdEscaped(spec.program), ...spec.args.map(cmdArgument)].join(' ');
+    return `${scheduledTaskMarker(spec.label)}${[...variables, `${program} >>${cmdEscaped(spec.logFile)} 2>&1`].join(' && ')}`;
+}
+/*
+ * A scheduled task for one person, started at their logon in their own session without a stored
+ * password, and run again every minute so it comes back after a crash: a second instance is ignored
+ * while one runs. RestartOnFailure is left out, since it also starts a task a stop ended. A task carries no environment
+ * of its own, so cmd.exe sets it and appends the output to the log.
+ */
+export function scheduledTask(spec) {
+    if (spec.user === undefined || spec.user === '') {
+        throw new Error('A scheduled task needs the user it starts for.');
+    }
+    const user = xmlText(spec.user);
+    // No XML declaration: schtasks decodes the file itself and refuses one that names an encoding.
+    const lines = [
+        '<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">',
+        '  <RegistrationInfo>',
+        `    <Description>${xmlText(spec.description)}</Description>`,
+        `    <URI>\\${xmlText(spec.label)}</URI>`,
+        '  </RegistrationInfo>',
+        '  <Triggers>',
+        '    <LogonTrigger>',
+        '      <Enabled>true</Enabled>',
+        `      <UserId>${user}</UserId>`,
+        '      <Repetition>',
+        '        <Interval>PT1M</Interval>',
+        '        <StopAtDurationEnd>false</StopAtDurationEnd>',
+        '      </Repetition>',
+        '    </LogonTrigger>',
+        '  </Triggers>',
+        '  <Principals>',
+        '    <Principal id="Author">',
+        `      <UserId>${user}</UserId>`,
+        '      <LogonType>InteractiveToken</LogonType>',
+        '      <RunLevel>LeastPrivilege</RunLevel>',
+        '    </Principal>',
+        '  </Principals>',
+        '  <Settings>',
+        '    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>',
+        '    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>',
+        '    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>',
+        '    <AllowHardTerminate>true</AllowHardTerminate>',
+        '    <StartWhenAvailable>true</StartWhenAvailable>',
+        '    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>',
+        '    <IdleSettings>',
+        '      <StopOnIdleEnd>false</StopOnIdleEnd>',
+        '      <RestartOnIdle>false</RestartOnIdle>',
+        '    </IdleSettings>',
+        '    <AllowStartOnDemand>true</AllowStartOnDemand>',
+        '    <Enabled>true</Enabled>',
+        '    <Hidden>false</Hidden>',
+        '    <RunOnlyIfIdle>false</RunOnlyIfIdle>',
+        '    <WakeToRun>false</WakeToRun>',
+        // The default ends a task after three days.
+        '    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>',
+        // The default, 7, runs a task below normal priority.
+        '    <Priority>5</Priority>',
+        '  </Settings>',
+        '  <Actions Context="Author">',
+        '    <Exec>',
+        '      <Command>%SystemRoot%\\System32\\cmd.exe</Command>',
+        `      <Arguments>${xmlText(`/d /s /c "${taskCommandLine(spec)}"`)}</Arguments>`,
+        `      <WorkingDirectory>${xmlText(spec.workingDirectory)}</WorkingDirectory>`,
+        '    </Exec>',
+        '  </Actions>',
+        '</Task>',
+        ''
+    ];
+    return lines.join('\r\n');
+}
+function scheduledTaskRunsProgram(definition, program) {
+    const exec = definition.match(/<Exec>[\s\S]*?<\/Exec>/g);
+    if (exec?.length !== 1) {
+        return false;
+    }
+    const args = /<Arguments>([^<]*)<\/Arguments>/.exec(exec[0])?.[1];
+    const line = args === undefined ? undefined : /\/c "([\s\S]*)"$/.exec(xmlValue(args))?.[1];
+    return line !== undefined && (line.split(' && ').at(-1) ?? '').startsWith(`${cmdEscaped(program)} `);
+}
 /* Only keys of the outer plist dictionary identify the executable; nested environment keys are data. */
 function launchAgentProgram(definition) {
     const xml = definition.replace(/<!--[\s\S]*?-->/g, '');
@@ -130,5 +224,8 @@ function systemdRunsProgram(definition, program) {
  * Callers sharing a service identity can check executable ownership before replacing its definition.
  */
 export function definitionRunsProgram(definition, program) {
+    if (/<Task[\s>]/.test(definition)) {
+        return scheduledTaskRunsProgram(definition, program);
+    }
     return definition.trimStart().startsWith('<') ? launchAgentProgram(definition) === xmlText(program) : systemdRunsProgram(definition, program);
 }

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { definitionRunsProgram, launchAgentPlist, systemdUnit, type ServiceSpec } from './definitions.js';
-export { launchdManager, systemdManager, type CommandResult, type CommandRunner, type LaunchdOptions, type ServiceFiles, type ServiceManager, type SystemdOptions } from './manager.js';
+export { definitionRunsProgram, launchAgentPlist, scheduledTask, systemdUnit, type ServiceSpec } from './definitions.js';
+export { launchdManager, systemdManager, taskSchedulerManager, type CommandResult, type CommandRunner, type LaunchdOptions, type ServiceFiles, type ServiceManager, type SystemdOptions, type TaskSchedulerOptions } from './manager.js';
 export { platformServiceManager, serviceDefinition, type PlatformServiceOptions } from './platform.js';
 export { diskFiles, runCommand } from './system.js';

package/dist/index.js

@@ -1,4 +1,4 @@
-export { definitionRunsProgram, launchAgentPlist, systemdUnit } from './definitions.js';
-export { launchdManager, systemdManager } from './manager.js';
+export { definitionRunsProgram, launchAgentPlist, scheduledTask, systemdUnit } from './definitions.js';
+export { launchdManager, systemdManager, taskSchedulerManager } from './manager.js';
 export { platformServiceManager, serviceDefinition } from './platform.js';
 export { diskFiles, runCommand } from './system.js';

package/dist/manager.d.ts

@@ -11,7 +11,7 @@ export interface ServiceFiles {
     makeDirectory(path: string): void;
 }
 export interface ServiceManager {
-    readonly kind: 'launchd' | 'systemd';
+    readonly kind: 'launchd' | 'systemd' | 'task-scheduler';
     readonly path: string;
     isInstalled(): boolean;
     read(): string | null;
@@ -43,3 +43,12 @@ export interface SystemdOptions {
     unitName: string;
 }
 export declare function systemdManager(options: SystemdOptions): ServiceManager;
+export interface TaskSchedulerOptions {
+    taskName: string;
+    definitionFile: string;
+    logFile: string;
+    run: CommandRunner;
+    files: ServiceFiles;
+    sleep(ms: number): Promise<void>;
+}
+export declare function taskSchedulerManager(options: TaskSchedulerOptions): ServiceManager;

package/dist/manager.js

@@ -1,4 +1,5 @@
-import { dirname, join } from 'node:path';
+import { posix, win32 } from 'node:path';
+import { scheduledTaskMarker } from './cmd-line.js';
 function expectSuccess(result, what) {
     if (result.code !== 0) {
         throw new Error(`${what} failed (${result.code}): ${(result.stderr || result.stdout).trim() || 'no output'}`);
@@ -10,7 +11,7 @@ function expectSuccess(result, what) {
  * the bundle, where the login shell's PATH and a log path in the home cannot be written.
  */
 export function launchdManager(options) {
-    const path = join(options.home, 'Library', 'LaunchAgents', `${options.label}.plist`);
+    const path = posix.join(options.home, 'Library', 'LaunchAgents', `${options.label}.plist`);
     const domain = `gui/${options.uid}`;
     const target = `${domain}/${options.label}`;
     const launchctl = (...args) => options.run('/bin/launchctl', args);
@@ -25,7 +26,7 @@ export function launchdManager(options) {
         read: () => options.files.read(path),
         install(definition) {
             // launchd opens the log but makes no folder for it, and a job whose log cannot open never starts.
-            options.files.makeDirectory(dirname(options.logFile));
+            options.files.makeDirectory(posix.dirname(options.logFile));
             const previous = options.files.read(path);
             if (previous !== definition) {
                 options.files.write(path, definition);
@@ -62,7 +63,7 @@ export function launchdManager(options) {
 /* A user unit under ~/.config/systemd/user, enabled for `default.target`. */
 export function systemdManager(options) {
     const unit = options.unitName;
-    const path = join(options.configHome, 'systemd', 'user', unit);
+    const path = posix.join(options.configHome, 'systemd', 'user', unit);
     const systemctl = (...args) => options.run('systemctl', ['--user', ...args]);
     const reload = () => {
         expectSuccess(systemctl('daemon-reload'), 'systemctl daemon-reload');
@@ -105,3 +106,79 @@ export function systemdManager(options) {
         }
     };
 }
+/*
+ * A task in the person's own Task Scheduler library, registered with `schtasks` from a copy of the
+ * definition on disk. Creating one for oneself takes no admin. The task runs again every minute, so
+ * a stop also disables it, and a start enables it again.
+ */
+export function taskSchedulerManager(options) {
+    const path = options.definitionFile;
+    const name = options.taskName;
+    const schtasks = (...args) => options.run('schtasks.exe', args);
+    const exists = () => schtasks('/Query', '/TN', name).code === 0;
+    // schtasks writes the state in the language of the system; PowerShell names it the same everywhere.
+    const isRunning = () => options
+        .run('powershell.exe', [
+        '-NoProfile',
+        '-NonInteractive',
+        '-Command',
+        `(Get-ScheduledTask -TaskPath '\\' -TaskName '${name.replace(/'/g, "''")}' -ErrorAction Stop).State`
+    ])
+        .stdout.trim() === 'Running';
+    // Before `/End`, which leaves what the task's cmd.exe started running without a parent to find it by.
+    const endTree = () => {
+        const marker = scheduledTaskMarker(name).replace(/'/g, "''");
+        const script = [
+            'Get-CimInstance Win32_Process -Filter "Name=\'cmd.exe\'"',
+            `Where-Object { $_.CommandLine -and $_.CommandLine.Contains('${marker}') }`,
+            'ForEach-Object { taskkill.exe /PID $_.ProcessId /T /F | Out-Null }'
+        ].join(' | ');
+        options.run('powershell.exe', ['-NoProfile', '-NonInteractive', '-EncodedCommand', Buffer.from(script, 'utf16le').toString('base64')]);
+    };
+    const run = () => {
+        expectSuccess(schtasks('/Change', '/TN', name, '/ENABLE'), 'schtasks /Change /ENABLE');
+        expectSuccess(schtasks('/Run', '/TN', name), 'schtasks /Run');
+    };
+    return {
+        kind: 'task-scheduler',
+        path,
+        isInstalled: () => options.files.read(path) !== null && exists(),
+        read: () => options.files.read(path),
+        install(definition) {
+            // cmd.exe appends to the log but makes no folder for it, and the task ends at once without one.
+            options.files.makeDirectory(win32.dirname(options.logFile));
+            const previous = options.files.read(path);
+            if (previous !== definition) {
+                options.files.write(path, definition);
+            }
+            if (previous !== definition || !exists()) {
+                expectSuccess(schtasks('/Create', '/TN', name, '/XML', path, '/F'), 'schtasks /Create');
+            }
+            return previous !== null && previous !== definition;
+        },
+        start() {
+            run();
+        },
+        async restart() {
+            if (isRunning()) {
+                endTree();
+                schtasks('/End', '/TN', name);
+                // A task that still counts as running ignores the next start.
+                for (let attempt = 0; attempt < 25 && isRunning(); attempt++) {
+                    await options.sleep(200);
+                }
+            }
+            run();
+        },
+        stop() {
+            endTree();
+            // schtasks ends no instance of a task that is disabled already.
+            schtasks('/End', '/TN', name);
+            schtasks('/Change', '/TN', name, '/DISABLE');
+        },
+        uninstall() {
+            schtasks('/Delete', '/TN', name, '/F');
+            options.files.remove(path);
+        }
+    };
+}

package/dist/platform.d.ts

@@ -1,8 +1,9 @@
 import { type ServiceSpec } from './definitions.js';
-import { type LaunchdOptions, type ServiceManager, type SystemdOptions } from './manager.js';
+import { type LaunchdOptions, type ServiceManager, type SystemdOptions, type TaskSchedulerOptions } from './manager.js';
 export interface PlatformServiceOptions {
     launchd: LaunchdOptions;
     systemd: SystemdOptions;
+    taskScheduler?: TaskSchedulerOptions;
 }
 export declare function platformServiceManager(platform: NodeJS.Platform, options: PlatformServiceOptions): ServiceManager | null;
 export declare function serviceDefinition(platform: NodeJS.Platform, spec: ServiceSpec): string;

package/dist/platform.js

@@ -1,5 +1,5 @@
-import { launchAgentPlist, systemdUnit } from './definitions.js';
-import { launchdManager, systemdManager } from './manager.js';
+import { launchAgentPlist, scheduledTask, systemdUnit } from './definitions.js';
+import { launchdManager, systemdManager, taskSchedulerManager } from './manager.js';
 export function platformServiceManager(platform, options) {
     if (platform === 'darwin') {
         return launchdManager(options.launchd);
@@ -7,6 +7,9 @@ export function platformServiceManager(platform, options) {
     if (platform === 'linux') {
         return systemdManager(options.systemd);
     }
+    if (platform === 'win32' && options.taskScheduler !== undefined) {
+        return taskSchedulerManager(options.taskScheduler);
+    }
     return null;
 }
 export function serviceDefinition(platform, spec) {
@@ -16,5 +19,8 @@ export function serviceDefinition(platform, spec) {
     if (platform === 'linux') {
         return systemdUnit(spec);
     }
+    if (platform === 'win32') {
+        return scheduledTask(spec);
+    }
     throw new Error(`Background services are unsupported on ${platform}.`);
 }

package/dist/system.js

@@ -1,9 +1,9 @@
 import { spawnSync } from 'node:child_process';
 import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
-/* The real launchctl, systemctl and loginctl under a service manager, bounded so a hung one cannot hold up a quit. */
+/* The real launchctl, systemctl, loginctl and schtasks under a service manager, bounded so a hung one cannot hold up a quit. */
 export function runCommand(command, args) {
-    const result = spawnSync(command, args, { encoding: 'utf8', timeout: 15_000, stdio: ['ignore', 'pipe', 'pipe'] });
+    const result = spawnSync(command, args, { encoding: 'utf8', timeout: 15_000, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
     return { code: result.status ?? 1, stdout: result.stdout ?? '', stderr: result.stderr || result.error?.message || '' };
 }
 export const diskFiles = {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@adecore/service",
-  "version": "0.29.1",
-  "description": "User service definitions and injectable launchd and systemd managers.",
+  "version": "0.29.2",
+  "description": "User service definitions and injectable launchd, systemd and Task Scheduler managers.",
   "license": "FSL-1.1-MIT",
   "author": "Bas Milius",
   "repository": {

package/src/cmd-line.ts

@@ -0,0 +1,14 @@
+// What cmd.exe reads as syntax outside quotes, and so escapes with a caret.
+const CMD_SPECIAL = /([()\][%!^"`<>&|;, *?])/g;
+
+export function cmdEscaped(text: string): string {
+    return text.replace(CMD_SPECIAL, '^$1');
+}
+
+/*
+ * What a manager finds the cmd.exe of a task by: `schtasks /End` ends that process alone, so a stop
+ * has to end the tree under it first. Its title is the label, which is the name of the task.
+ */
+export function scheduledTaskMarker(label: string): string {
+    return `title ${cmdEscaped(label)} && `;
+}

package/src/definitions.ts

@@ -1,3 +1,5 @@
+import { cmdEscaped, scheduledTaskMarker } from './cmd-line.js';
+
 export interface ServiceSpec {
     label: string;
     description: string;
@@ -5,14 +7,20 @@ export interface ServiceSpec {
     args: string[];
     environment: Record<string, string>;
     workingDirectory: string;
-    /* launchd only: where stdout and stderr go. systemd has the journal. */
+    /* launchd and the scheduled task: where stdout and stderr go. systemd has the journal. */
     logFile: string;
+    /* The scheduled task only, which needs it: the account it starts for at logon, as `DOMAIN\\name`. */
+    user?: string;
 }
 
 function xmlText(value: string): string {
     return value.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
 
+function xmlValue(text: string): string {
+    return text.replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&amp;/g, '&');
+}
+
 function plistString(value: string, indent: string): string {
     return `${indent}<string>${xmlText(value)}</string>`;
 }
@@ -92,6 +100,100 @@ export function systemdUnit(spec: ServiceSpec): string {
     return lines.join('\n');
 }
 
+/* One argument as the C runtime splits a command line, escaped so cmd.exe passes it on as it is. */
+function cmdArgument(arg: string): string {
+    if (/[\r\n]/.test(arg)) {
+        throw new Error('A scheduled task cannot pass on a line break');
+    }
+    return cmdEscaped(`"${arg.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\*)$/, '$1$1')}"`);
+}
+
+/* The line cmd.exe runs: its title, the environment, the program and the log it appends to. */
+function taskCommandLine(spec: ServiceSpec): string {
+    const variables = Object.entries(spec.environment).map(([name, value]) => `set ${cmdEscaped(`"${name}=${value}"`)}`);
+    const program = [cmdEscaped(spec.program), ...spec.args.map(cmdArgument)].join(' ');
+    return `${scheduledTaskMarker(spec.label)}${[...variables, `${program} >>${cmdEscaped(spec.logFile)} 2>&1`].join(' && ')}`;
+}
+
+/*
+ * A scheduled task for one person, started at their logon in their own session without a stored
+ * password, and run again every minute so it comes back after a crash: a second instance is ignored
+ * while one runs. RestartOnFailure is left out, since it also starts a task a stop ended. A task carries no environment
+ * of its own, so cmd.exe sets it and appends the output to the log.
+ */
+export function scheduledTask(spec: ServiceSpec): string {
+    if (spec.user === undefined || spec.user === '') {
+        throw new Error('A scheduled task needs the user it starts for.');
+    }
+    const user = xmlText(spec.user);
+    // No XML declaration: schtasks decodes the file itself and refuses one that names an encoding.
+    const lines = [
+        '<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">',
+        '  <RegistrationInfo>',
+        `    <Description>${xmlText(spec.description)}</Description>`,
+        `    <URI>\\${xmlText(spec.label)}</URI>`,
+        '  </RegistrationInfo>',
+        '  <Triggers>',
+        '    <LogonTrigger>',
+        '      <Enabled>true</Enabled>',
+        `      <UserId>${user}</UserId>`,
+        '      <Repetition>',
+        '        <Interval>PT1M</Interval>',
+        '        <StopAtDurationEnd>false</StopAtDurationEnd>',
+        '      </Repetition>',
+        '    </LogonTrigger>',
+        '  </Triggers>',
+        '  <Principals>',
+        '    <Principal id="Author">',
+        `      <UserId>${user}</UserId>`,
+        '      <LogonType>InteractiveToken</LogonType>',
+        '      <RunLevel>LeastPrivilege</RunLevel>',
+        '    </Principal>',
+        '  </Principals>',
+        '  <Settings>',
+        '    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>',
+        '    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>',
+        '    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>',
+        '    <AllowHardTerminate>true</AllowHardTerminate>',
+        '    <StartWhenAvailable>true</StartWhenAvailable>',
+        '    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>',
+        '    <IdleSettings>',
+        '      <StopOnIdleEnd>false</StopOnIdleEnd>',
+        '      <RestartOnIdle>false</RestartOnIdle>',
+        '    </IdleSettings>',
+        '    <AllowStartOnDemand>true</AllowStartOnDemand>',
+        '    <Enabled>true</Enabled>',
+        '    <Hidden>false</Hidden>',
+        '    <RunOnlyIfIdle>false</RunOnlyIfIdle>',
+        '    <WakeToRun>false</WakeToRun>',
+        // The default ends a task after three days.
+        '    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>',
+        // The default, 7, runs a task below normal priority.
+        '    <Priority>5</Priority>',
+        '  </Settings>',
+        '  <Actions Context="Author">',
+        '    <Exec>',
+        '      <Command>%SystemRoot%\\System32\\cmd.exe</Command>',
+        `      <Arguments>${xmlText(`/d /s /c "${taskCommandLine(spec)}"`)}</Arguments>`,
+        `      <WorkingDirectory>${xmlText(spec.workingDirectory)}</WorkingDirectory>`,
+        '    </Exec>',
+        '  </Actions>',
+        '</Task>',
+        ''
+    ];
+    return lines.join('\r\n');
+}
+
+function scheduledTaskRunsProgram(definition: string, program: string): boolean {
+    const exec = definition.match(/<Exec>[\s\S]*?<\/Exec>/g);
+    if (exec?.length !== 1) {
+        return false;
+    }
+    const args = /<Arguments>([^<]*)<\/Arguments>/.exec(exec[0])?.[1];
+    const line = args === undefined ? undefined : /\/c "([\s\S]*)"$/.exec(xmlValue(args))?.[1];
+    return line !== undefined && (line.split(' && ').at(-1) ?? '').startsWith(`${cmdEscaped(program)} `);
+}
+
 /* Only keys of the outer plist dictionary identify the executable; nested environment keys are data. */
 function launchAgentProgram(definition: string): string | null {
     const xml = definition.replace(/<!--[\s\S]*?-->/g, '');
@@ -162,5 +264,8 @@ function systemdRunsProgram(definition: string, program: string): boolean {
  * Callers sharing a service identity can check executable ownership before replacing its definition.
  */
 export function definitionRunsProgram(definition: string, program: string): boolean {
+    if (/<Task[\s>]/.test(definition)) {
+        return scheduledTaskRunsProgram(definition, program);
+    }
     return definition.trimStart().startsWith('<') ? launchAgentProgram(definition) === xmlText(program) : systemdRunsProgram(definition, program);
 }

package/src/index.ts

@@ -1,13 +1,15 @@
-export { definitionRunsProgram, launchAgentPlist, systemdUnit, type ServiceSpec } from './definitions.js';
+export { definitionRunsProgram, launchAgentPlist, scheduledTask, systemdUnit, type ServiceSpec } from './definitions.js';
 export {
     launchdManager,
     systemdManager,
+    taskSchedulerManager,
     type CommandResult,
     type CommandRunner,
     type LaunchdOptions,
     type ServiceFiles,
     type ServiceManager,
-    type SystemdOptions
+    type SystemdOptions,
+    type TaskSchedulerOptions
 } from './manager.js';
 export { platformServiceManager, serviceDefinition, type PlatformServiceOptions } from './platform.js';
 export { diskFiles, runCommand } from './system.js';

package/src/manager.ts

@@ -1,4 +1,5 @@
-import { dirname, join } from 'node:path';
+import { posix, win32 } from 'node:path';
+import { scheduledTaskMarker } from './cmd-line.js';
 
 export interface CommandResult {
     code: number;
@@ -18,7 +19,7 @@ export interface ServiceFiles {
 }
 
 export interface ServiceManager {
-    readonly kind: 'launchd' | 'systemd';
+    readonly kind: 'launchd' | 'systemd' | 'task-scheduler';
     /* The definition's file. */
     readonly path: string;
     isInstalled(): boolean;
@@ -63,7 +64,7 @@ export interface LaunchdOptions {
  * the bundle, where the login shell's PATH and a log path in the home cannot be written.
  */
 export function launchdManager(options: LaunchdOptions): ServiceManager {
-    const path = join(options.home, 'Library', 'LaunchAgents', `${options.label}.plist`);
+    const path = posix.join(options.home, 'Library', 'LaunchAgents', `${options.label}.plist`);
     const domain = `gui/${options.uid}`;
     const target = `${domain}/${options.label}`;
     const launchctl = (...args: string[]): CommandResult => options.run('/bin/launchctl', args);
@@ -80,7 +81,7 @@ export function launchdManager(options: LaunchdOptions): ServiceManager {
         read: () => options.files.read(path),
         install(definition) {
             // launchd opens the log but makes no folder for it, and a job whose log cannot open never starts.
-            options.files.makeDirectory(dirname(options.logFile));
+            options.files.makeDirectory(posix.dirname(options.logFile));
             const previous = options.files.read(path);
             if (previous !== definition) {
                 options.files.write(path, definition);
@@ -126,7 +127,7 @@ export interface SystemdOptions {
 /* A user unit under ~/.config/systemd/user, enabled for `default.target`. */
 export function systemdManager(options: SystemdOptions): ServiceManager {
     const unit = options.unitName;
-    const path = join(options.configHome, 'systemd', 'user', unit);
+    const path = posix.join(options.configHome, 'systemd', 'user', unit);
     const systemctl = (...args: string[]): CommandResult => options.run('systemctl', ['--user', ...args]);
 
     const reload = (): void => {
@@ -171,3 +172,95 @@ export function systemdManager(options: SystemdOptions): ServiceManager {
         }
     };
 }
+
+export interface TaskSchedulerOptions {
+    /* The name of the task, which has to be the label of the spec: a stop finds the task's processes by it. */
+    taskName: string;
+    /* Where the definition is kept and registered from. */
+    definitionFile: string;
+    logFile: string;
+    run: CommandRunner;
+    files: ServiceFiles;
+    sleep(ms: number): Promise<void>;
+}
+
+/*
+ * A task in the person's own Task Scheduler library, registered with `schtasks` from a copy of the
+ * definition on disk. Creating one for oneself takes no admin. The task runs again every minute, so
+ * a stop also disables it, and a start enables it again.
+ */
+export function taskSchedulerManager(options: TaskSchedulerOptions): ServiceManager {
+    const path = options.definitionFile;
+    const name = options.taskName;
+    const schtasks = (...args: string[]): CommandResult => options.run('schtasks.exe', args);
+    const exists = (): boolean => schtasks('/Query', '/TN', name).code === 0;
+    // schtasks writes the state in the language of the system; PowerShell names it the same everywhere.
+    const isRunning = (): boolean =>
+        options
+            .run('powershell.exe', [
+                '-NoProfile',
+                '-NonInteractive',
+                '-Command',
+                `(Get-ScheduledTask -TaskPath '\\' -TaskName '${name.replace(/'/g, "''")}' -ErrorAction Stop).State`
+            ])
+            .stdout.trim() === 'Running';
+
+    // Before `/End`, which leaves what the task's cmd.exe started running without a parent to find it by.
+    const endTree = (): void => {
+        const marker = scheduledTaskMarker(name).replace(/'/g, "''");
+        const script = [
+            'Get-CimInstance Win32_Process -Filter "Name=\'cmd.exe\'"',
+            `Where-Object { $_.CommandLine -and $_.CommandLine.Contains('${marker}') }`,
+            'ForEach-Object { taskkill.exe /PID $_.ProcessId /T /F | Out-Null }'
+        ].join(' | ');
+        options.run('powershell.exe', ['-NoProfile', '-NonInteractive', '-EncodedCommand', Buffer.from(script, 'utf16le').toString('base64')]);
+    };
+
+    const run = (): void => {
+        expectSuccess(schtasks('/Change', '/TN', name, '/ENABLE'), 'schtasks /Change /ENABLE');
+        expectSuccess(schtasks('/Run', '/TN', name), 'schtasks /Run');
+    };
+
+    return {
+        kind: 'task-scheduler',
+        path,
+        isInstalled: () => options.files.read(path) !== null && exists(),
+        read: () => options.files.read(path),
+        install(definition) {
+            // cmd.exe appends to the log but makes no folder for it, and the task ends at once without one.
+            options.files.makeDirectory(win32.dirname(options.logFile));
+            const previous = options.files.read(path);
+            if (previous !== definition) {
+                options.files.write(path, definition);
+            }
+            if (previous !== definition || !exists()) {
+                expectSuccess(schtasks('/Create', '/TN', name, '/XML', path, '/F'), 'schtasks /Create');
+            }
+            return previous !== null && previous !== definition;
+        },
+        start() {
+            run();
+        },
+        async restart() {
+            if (isRunning()) {
+                endTree();
+                schtasks('/End', '/TN', name);
+                // A task that still counts as running ignores the next start.
+                for (let attempt = 0; attempt < 25 && isRunning(); attempt++) {
+                    await options.sleep(200);
+                }
+            }
+            run();
+        },
+        stop() {
+            endTree();
+            // schtasks ends no instance of a task that is disabled already.
+            schtasks('/End', '/TN', name);
+            schtasks('/Change', '/TN', name, '/DISABLE');
+        },
+        uninstall() {
+            schtasks('/Delete', '/TN', name, '/F');
+            options.files.remove(path);
+        }
+    };
+}

package/src/platform.ts

@@ -1,9 +1,19 @@
-import { launchAgentPlist, systemdUnit, type ServiceSpec } from './definitions.js';
-import { launchdManager, systemdManager, type LaunchdOptions, type ServiceManager, type SystemdOptions } from './manager.js';
+import { launchAgentPlist, scheduledTask, systemdUnit, type ServiceSpec } from './definitions.js';
+import {
+    launchdManager,
+    systemdManager,
+    taskSchedulerManager,
+    type LaunchdOptions,
+    type ServiceManager,
+    type SystemdOptions,
+    type TaskSchedulerOptions
+} from './manager.js';
 
 export interface PlatformServiceOptions {
     launchd: LaunchdOptions;
     systemd: SystemdOptions;
+    /* Without it there is no manager on Windows. */
+    taskScheduler?: TaskSchedulerOptions;
 }
 
 export function platformServiceManager(platform: NodeJS.Platform, options: PlatformServiceOptions): ServiceManager | null {
@@ -13,6 +23,9 @@ export function platformServiceManager(platform: NodeJS.Platform, options: Platf
     if (platform === 'linux') {
         return systemdManager(options.systemd);
     }
+    if (platform === 'win32' && options.taskScheduler !== undefined) {
+        return taskSchedulerManager(options.taskScheduler);
+    }
     return null;
 }
 
@@ -23,5 +36,8 @@ export function serviceDefinition(platform: NodeJS.Platform, spec: ServiceSpec):
     if (platform === 'linux') {
         return systemdUnit(spec);
     }
+    if (platform === 'win32') {
+        return scheduledTask(spec);
+    }
     throw new Error(`Background services are unsupported on ${platform}.`);
 }

package/src/system.ts

@@ -3,9 +3,9 @@ import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
 import type { CommandResult, ServiceFiles } from './manager.js';
 
-/* The real launchctl, systemctl and loginctl under a service manager, bounded so a hung one cannot hold up a quit. */
+/* The real launchctl, systemctl, loginctl and schtasks under a service manager, bounded so a hung one cannot hold up a quit. */
 export function runCommand(command: string, args: string[]): CommandResult {
-    const result = spawnSync(command, args, { encoding: 'utf8', timeout: 15_000, stdio: ['ignore', 'pipe', 'pipe'] });
+    const result = spawnSync(command, args, { encoding: 'utf8', timeout: 15_000, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
     return { code: result.status ?? 1, stdout: result.stdout ?? '', stderr: result.stderr || result.error?.message || '' };
 }