external-subagent 0.5.2 → 0.5.4

package/cli/install/init.mjs

@@ -1,6 +1,5 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { spawnSync } from 'node:child_process';
 import { LAUNCH_AGENT_LABEL, NATIVE_DIR_NAME } from '../constants.mjs';
 import { CliError } from '../errors.mjs';
 import { platform } from '../paths.mjs';
@@ -13,7 +12,7 @@ import { updateInstallation } from './update.mjs';
 import { loadInstallState, markInstallStep, removeCreatedDirectories, rollbackFiles, snapshotFile } from './recovery.mjs';
 import { SYSTEMD_UNIT_NAME, bootstrapService, bootoutService, installServiceDefinition, runtimeObservations } from './service-macos.mjs';
 
-// Standalone-install coordination (S05, AUD-005 decision D1).  A plain npm
+// Standalone-install coordination (AUD-005 decision D1).  A plain npm
 // install only stages the package and payload; an explicit `init` installs
 // the STANDALONE SERVICE ONLY — every state-changing step below is
 // host-neutral:
@@ -47,12 +46,6 @@ import { SYSTEMD_UNIT_NAME, bootstrapService, bootoutService, installServiceDefi
 // lets `init --resume` continue after environmental failures.  Journals from
 // pre-D1 inits may still list the retired codex steps; unknown completed ids
 // are simply never consulted again.
-const HOOK_INSTALLER = ['plugins', 'codex', 'external-subagent', 'scripts', 'install-agent-hooks.mjs'];
-
-function hookInstallerPath() {
-  return path.join(packageRoot(), ...HOOK_INSTALLER);
-}
-
 export function installPlan(paths, options = {}) {
   // The plan reports the payload the verifier will read.  When the running
   // tuple has a supported payload this is the resolved manifest path; on an
@@ -70,22 +63,9 @@ export function installPlan(paths, options = {}) {
     { id: 'start-service', action: darwin ? 'bootstrap the daemon service' : 'enable and start the daemon service', path: paths.launchAgent, ...(darwin ? { label: LAUNCH_AGENT_LABEL } : { unit: SYSTEMD_UNIT_NAME }) },
     { id: 'publish-active-payload', action: 'publish the verified active payload and retained-byte baseline', path: paths.state },
   ];
-  if (options.installHooks) plan.splice(plan.findIndex((step) => step.id === 'publish-active-payload'), 0, { id: 'install-hooks', action: 'install ZCode policy hooks', path: paths.zcodeConfig, provenance: paths.hookProvenance });
   return plan;
 }
 
-export function installHooks(paths, options = {}) {
-  if (options.dryRun) return { dry_run: true, plan: [{ id: 'install-hooks', action: 'install ZCode policy hooks', path: paths.zcodeConfig, provenance: paths.hookProvenance }] };
-  const result = spawnSync(process.execPath, [hookInstallerPath(), '--config', paths.zcodeConfig, '--provenance', paths.hookProvenance], { encoding: 'utf8' });
-  if (result.error) throw result.error;
-  if (result.status !== 0) {
-    let failure;
-    try { failure = JSON.parse((result.stderr || '').trim()); } catch { /* plain-text failure */ }
-    throw new CliError(failure?.code || 'HOOK_INSTALL_FAILED', failure?.error || (result.stderr || 'hook installation failed').trim());
-  }
-  try { return JSON.parse(result.stdout); } catch { throw new CliError('HOOK_INSTALL_FAILED', 'hook installer returned invalid JSON'); }
-}
-
 export function runInit(options = {}) {
   const paths = options.paths;
   if (!paths) throw new CliError('INTERNAL_ERROR', 'runInit requires product paths');
@@ -104,12 +84,13 @@ export function runInit(options = {}) {
   const payload = skipPayload ? { status: 'skipped', platform: null, version: null, files: [] } : verifyPayload();
   const pathFindings = pathReport();
 
+  // Windows has no file-based service definition (paths.launchAgent is null),
+  // so there is nothing to snapshot or roll back there; the SCM registration
+  // is created by the start-service step instead.
   const tracked = {
-    zcodeConfig: { file: paths.zcodeConfig, snapshot: snapshotFile(paths.zcodeConfig) },
-    hookProvenance: { file: paths.hookProvenance, snapshot: snapshotFile(paths.hookProvenance) },
     state: { file: paths.state, snapshot: snapshotFile(paths.state) },
     config: { file: paths.config, snapshot: snapshotFile(paths.config) },
-    launchAgent: { file: paths.launchAgent, snapshot: snapshotFile(paths.launchAgent) },
+    ...(paths.launchAgent ? { launchAgent: { file: paths.launchAgent, snapshot: snapshotFile(paths.launchAgent) } } : {}),
   };
   const directories = {
     data: { path: paths.data, existed: fs.existsSync(paths.data) },
@@ -130,6 +111,19 @@ export function runInit(options = {}) {
   // A service that was already loaded before this init is never touched.
   let serviceLoadedByThisRun = false;
   let baseline = null;
+  // The service backends are selected by process platform.  Windows has no
+  // process.getuid(), and every backend treats an undefined uid as "not
+  // applicable", so resolve it lazily instead of crashing before dispatch.
+  const currentUid = () => (typeof process.getuid === 'function' ? process.getuid() : undefined);
+  // Forward the injectable control seams (launchctl/systemctl/sc) and the
+  // explicit daemon artifact so a test or a controlled activation can own the
+  // service definition without touching the real service manager.
+  const serviceOptions = () => ({
+    launchctl: options.launchctl,
+    systemctl: options.systemctl,
+    sc: options.sc,
+    daemonPath: options.daemonPath,
+  });
   try {
     if (!completed.has('verify-payload')) mark('verify-payload');
     if (!completed.has('check-path')) mark('check-path');
@@ -142,8 +136,8 @@ export function runInit(options = {}) {
       // The daemon takes its database/socket/runtime from service arguments,
       // never from this file; drop the retired top-level path fields so an
       // install over an older local config republishes the current schema.
-      // S05-F01: `subagents.zcode.runtime_path` was a first-class config key
-      // before D1 rejected it, so a pre-S05 install can carry it in either
+      // The runtime_path remediation: `subagents.zcode.runtime_path` was a first-class config key
+      // before D1 rejected it, so an install predating that rejection can carry it in either
       // the schema-2 or the legacy schema-1 shape.  Retire it here — before
       // parseConfig migrates/validates — so `npm new -> init` self-heals such
       // configs instead of failing closed at the read gate (which stays
@@ -158,19 +152,15 @@ export function runInit(options = {}) {
       mark('write-product-config');
     }
     if (!completed.has('install-launch-agent')) {
-      installServiceDefinition(paths);
+      installServiceDefinition(paths, serviceOptions());
       failAt('install-launch-agent');
       mark('install-launch-agent');
     }
     if (!completed.has('start-service') && !options.skipServiceStart) {
-      service = bootstrapService(paths, process.getuid(), { launchctl: options.launchctl, systemctl: options.systemctl });
+      service = bootstrapService(paths, currentUid(), serviceOptions());
       serviceLoadedByThisRun = !service.skipped && !service.already_loaded;
       mark('start-service');
     }
-    if (options.installHooks && !completed.has('install-hooks')) {
-      installHooks(paths);
-      mark('install-hooks');
-    }
     // The baseline publication runs LAST and only for an init that verified
     // the payload it installed (a skipped probe — test harnesses only —
     // leaves the resume journal as the sole state).  It reuses the locked
@@ -202,7 +192,7 @@ export function runInit(options = {}) {
       ...removeCreatedDirectories(directories),
     ];
     if (serviceLoadedByThisRun) {
-      try { bootoutService(paths, process.getuid(), { launchctl: options.launchctl, systemctl: options.systemctl }); } catch (bootoutError) {
+      try { bootoutService(paths, currentUid(), serviceOptions()); } catch (bootoutError) {
         rollbackErrors.push(`service rollback (bootout) failed: ${bootoutError.message}`);
       }
     }

package/cli/install/layout.mjs

@@ -16,10 +16,18 @@ export const PLUGIN_NAME = PRODUCT_NAME;
 // payload.mjs all key off the same value.  A tuple outside this table has no
 // payload and is rejected by the installer, never silently downgraded.
 // NATIVE_PLATFORM stays the reference platform (the released macOS identity).
-export const NATIVE_PLATFORMS = Object.freeze(['darwin-arm64', 'linux-x64']);
+export const NATIVE_PLATFORMS = Object.freeze(['darwin-arm64', 'linux-x64', 'win32-x64']);
 export const NATIVE_PLATFORM = NATIVE_PLATFORMS[0];
 export const NATIVE_BINARIES = Object.freeze([DAEMON_BIN_NAME, MCP_BIN_NAME]);
 
+// Payload artifacts are named with their host executable suffix. The staged
+// Windows payload is the same product binaries with `.exe`; every consumer
+// (verification, retention, service definition, MCP facade) resolves names
+// through this one helper so a tuple never mixes stem and extension.
+export function nativeExecutableName(name, platform = nativePlatform()) {
+  return typeof platform === 'string' && platform.startsWith('win32-') ? `${name}.exe` : name;
+}
+
 export function packageRoot() {
   return path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
 }
@@ -37,7 +45,7 @@ export function nativePayloadDir(platform = nativePlatform()) {
 export function nativeBinary(name, platform = nativePlatform()) {
   const dir = nativePayloadDir(platform);
   if (!dir || !NATIVE_BINARIES.includes(name)) return null;
-  return path.join(dir, name);
+  return path.join(dir, nativeExecutableName(name, platform));
 }
 
 export function payloadManifestPath(platform = nativePlatform()) {

package/cli/install/payload.mjs

@@ -4,7 +4,7 @@ import { CliError } from '../errors.mjs';
 import { sha256 } from '../fs-atomic.mjs';
 import { NATIVE_DIR_NAME, PRODUCT_NAME } from '../constants.mjs';
 import {
-  NATIVE_PLATFORMS, cliVersion, nativePayloadDir, nativePlatform, packageVersion, payloadManifestPath,
+  NATIVE_PLATFORMS, cliVersion, nativePayloadDir, nativePlatform, packageRoot, packageVersion,
 } from './layout.mjs';
 
 const MH_MAGIC_64 = 0xfeedfacf;
@@ -24,12 +24,37 @@ const EM_X86_64 = 0x3e;
 const ELF_E_MACHINE_OFFSET = 18;
 const ELF_HEADER_MIN_BYTES = ELF_E_MACHINE_OFFSET + 2;
 
+// PE/COFF identity for the Windows payload:
+//   DOS header       "MZ"
+//   e_lfanew         uint32 LE at offset 0x3c (offset of the PE signature)
+//   PE signature     "PE\0\0"
+//   Machine          uint16 LE at peOffset + 4 (0x8664 = IMAGE_FILE_MACHINE_AMD64)
+//   Optional magic   uint16 LE at peOffset + 24 (0x20b = PE32+)
+// The image is a supported win32-x64 payload only when all four agree; any
+// truncated header or other machine/format returns null.
+const DOS_MAGIC = 0x5a4d; // "MZ"
+const PE_SIGNATURE = 0x00004550; // "PE\0\0" as a LE uint32
+const IMAGE_FILE_MACHINE_AMD64 = 0x8664;
+const PE32_PLUS_MAGIC = 0x20b;
+const PE_SIGNATURE_OFFSET = 0x3c;
+const PE_HEADER_MIN_BYTES = PE_SIGNATURE_OFFSET + 4 + 20 + 2;
+
 export function machoArch(bytes) {
   if (bytes.length < 8) return null;
   if (bytes.readUInt32LE(0) !== MH_MAGIC_64) return null;
   return bytes.readUInt32LE(4) === CPU_TYPE_ARM64 ? 'arm64' : null;
 }
 
+export function peArch(bytes) {
+  if (bytes.length < PE_HEADER_MIN_BYTES) return null;
+  if (bytes.readUInt16LE(0) !== DOS_MAGIC) return null;
+  const peOffset = bytes.readUInt32LE(PE_SIGNATURE_OFFSET);
+  if (peOffset + 4 + 20 + 2 > bytes.length) return null;
+  if (bytes.readUInt32LE(peOffset) !== PE_SIGNATURE) return null;
+  if (bytes.readUInt16LE(peOffset + 4) !== IMAGE_FILE_MACHINE_AMD64) return null;
+  return bytes.readUInt16LE(peOffset + 24) === PE32_PLUS_MAGIC ? 'x64' : null;
+}
+
 // The Linux image check mirrors machoArch: only a 64-bit little-endian x86-64
 // ELF is a supported payload.  A truncated header (shorter than e_machine), a
 // 32-bit or big-endian image, or any other machine returns null and is
@@ -47,12 +72,24 @@ export function elfArch(bytes) {
 const IMAGE_CHECKS = Object.freeze({
   'darwin-arm64': { arch: 'arm64', image: 'Mach-O arm64 image', probe: machoArch },
   'linux-x64': { arch: 'x64', image: 'ELF x86-64 image', probe: elfArch },
+  'win32-x64': { arch: 'x64', image: 'PE32+ x86-64 image', probe: peArch },
 });
 
+// Every released tuple carries a prebuilt payload, including win32-x64; the
+// table is the verification identity set, not a distribution gate.
+const PAYLOAD_PLATFORMS = Object.freeze([...NATIVE_PLATFORMS]);
+
+function payloadDirectory(platform, root) {
+  if (root) return path.join(root, 'npm', NATIVE_DIR_NAME, platform);
+  return nativePayloadDir(platform)
+    ?? (PAYLOAD_PLATFORMS.includes(platform) ? path.join(packageRoot(), 'npm', NATIVE_DIR_NAME, platform) : null);
+}
+
 export function readPayloadManifest(options = {}) {
   const platform = options.platform || nativePlatform();
   const root = options.root || undefined;
-  const file = root ? path.join(root, 'npm', NATIVE_DIR_NAME, platform || '', 'payload.json') : payloadManifestPath(platform);
+  const dir = payloadDirectory(platform, root);
+  const file = dir === null ? null : path.join(dir, 'payload.json');
   if (file === null || !fs.existsSync(file)) {
     throw new CliError('PAYLOAD_MANIFEST_MISSING', `the ${platform || 'current'} platform payload manifest is missing from this package`);
   }
@@ -73,9 +110,15 @@ export function readPayloadManifest(options = {}) {
 // little-endian Mach-O arm64 image.  A failed verification is an installation
 // defect, never a silent downgrade path.
 export function verifyPayload(options = {}) {
-  const platform = options.platform || nativePlatform();
-  if (!NATIVE_PLATFORMS.includes(platform)) {
-    throw new CliError('UNSUPPORTED_PAYLOAD_PLATFORM', `no native payload exists for ${platform ?? `${process.platform}-${process.arch}`}; supported platforms: ${NATIVE_PLATFORMS.join(', ')}`);
+  const explicitPlatform = options.platform !== undefined;
+  const platform = explicitPlatform ? options.platform : nativePlatform();
+  if (!PAYLOAD_PLATFORMS.includes(platform)) {
+    // The default resolver (nativePlatform) only produces the release tuples;
+    // win32-x64 is a controlled artifact reachable through an explicit option
+    // until the NATIVE_PLATFORMS gate opens.  The message must not claim the
+    // rejected host tuple is available by default.
+    const supported = explicitPlatform ? PAYLOAD_PLATFORMS : NATIVE_PLATFORMS;
+    throw new CliError('UNSUPPORTED_PAYLOAD_PLATFORM', `no native payload exists for ${platform ?? `${process.platform}-${process.arch}`}; supported platforms: ${supported.join(', ')}`);
   }
   const image = IMAGE_CHECKS[platform];
   const manifest = readPayloadManifest({ platform, root: options.root });
@@ -91,7 +134,8 @@ export function verifyPayload(options = {}) {
   if (versions.package !== versions.cli || versions.payload !== versions.cli) {
     throw new CliError('PAYLOAD_VERSION_MISMATCH', `payload ${versions.payload}, package ${versions.package}, and CLI ${versions.cli} versions disagree`);
   }
-  const dir = options.root ? path.join(options.root, 'npm', NATIVE_DIR_NAME, platform) : nativePayloadDir(platform);
+  const dir = payloadDirectory(platform, options.root);
+  const posixMode = platform !== 'win32-x64' && process.platform !== 'win32';
   const files = manifest.files.map((record) => {
     if (!record || typeof record.name !== 'string' || path.basename(record.name) !== record.name || record.name.includes('..')) {
       throw new CliError('PAYLOAD_MANIFEST_INVALID', 'payload file name must be a direct child');
@@ -101,7 +145,10 @@ export function verifyPayload(options = {}) {
     try { stat = fs.statSync(target); } catch (error) {
       throw new CliError('PAYLOAD_FILE_MISSING', `native payload file is missing: ${record.name} (${error.code})`);
     }
-    if (!stat.isFile() || fs.lstatSync(target).isSymbolicLink() || (stat.mode & 0o777) !== 0o755) {
+    // Windows has no POSIX execute bit: npm extraction cannot produce mode 755
+    // and the PE loader does not consult one, so the mode gate applies only to
+    // the POSIX payload identities (and only on a POSIX host).
+    if (!stat.isFile() || fs.lstatSync(target).isSymbolicLink() || (posixMode && (stat.mode & 0o777) !== 0o755)) {
       throw new CliError('PAYLOAD_PERMISSIONS_INVALID', `native payload file ${record.name} must be a regular file with mode 755`);
     }
     const bytes = fs.readFileSync(target);
@@ -112,7 +159,7 @@ export function verifyPayload(options = {}) {
     if (arch !== image.arch) {
       throw new CliError('PAYLOAD_ARCH_UNSUPPORTED', `native payload file ${record.name} is not a ${image.image}`);
     }
-    return { name: record.name, bytes: bytes.length, mode: '755', sha256: record.sha256, arch };
+    return { name: record.name, bytes: bytes.length, mode: posixMode ? '755' : null, sha256: record.sha256, arch };
   });
   return { status: 'verified', platform, version: manifest.version, files };
 }
@@ -144,12 +191,12 @@ export function normalizePayloadMode(target) {
 // mode so the install step can report what it changed.
 export function normalizePayloadFiles(options = {}) {
   const platform = options.platform || nativePlatform();
-  if (!NATIVE_PLATFORMS.includes(platform)) return [];
+  // Windows has no POSIX mode to repair; the extraction/permission repair is a
+  // POSIX-payload concern only.
+  if (!PAYLOAD_PLATFORMS.includes(platform) || platform === 'win32-x64') return [];
   let manifest;
   try { manifest = readPayloadManifest({ platform, root: options.root }); } catch { return []; }
-  const dir = options.root
-    ? path.join(options.root, 'npm', NATIVE_DIR_NAME, platform)
-    : nativePayloadDir(platform);
+  const dir = payloadDirectory(platform, options.root);
   const normalized = [];
   for (const record of manifest.files) {
     if (!record || typeof record.name !== 'string' || path.basename(record.name) !== record.name || record.name.includes('..')) continue;

package/cli/install/service-activation.mjs

@@ -7,6 +7,7 @@ import { LAUNCH_AGENT_LABEL } from '../constants.mjs';
 import { platform } from '../paths.mjs';
 import { launchAgentPlist, launchctl } from './service-macos.mjs';
 import { SYSTEMD_UNIT_NAME, execStartProgram, replaceExecStartProgram, systemctl, systemdUnit, unitServiceStatus } from './service-linux.mjs';
+import { activateServiceWindows } from './service-windows.mjs';
 
 const xml = (s) => s.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;');
 const unxml = (s) => s.replaceAll('&lt;', '<').replaceAll('&gt;', '>').replaceAll('&amp;', '&');
@@ -17,10 +18,17 @@ export function hasInstalledService(paths) {
   return Boolean(paths.launchAgent && fs.existsSync(paths.launchAgent));
 }
 
-// Platform dispatch (S03): the same activation health/rollback contract runs
+// Platform dispatch: the same activation health/rollback contract runs
 // over launchd on macOS (verbatim) and the systemd user manager on Linux.
 export async function activateService(paths, candidate, options = {}) {
-  return platform() === 'darwin' ? activateLaunchdService(paths, candidate, options) : activateSystemdService(paths, candidate, options);
+  const currentPlatform = platform();
+  if (currentPlatform === 'darwin') {
+    return activateLaunchdService(paths, candidate, options);
+  }
+  if (currentPlatform === 'win32') {
+    return activateServiceWindows(paths, candidate, options);
+  }
+  return activateSystemdService(paths, candidate, options);
 }
 
 // The service definition is derived from the CURRENT config: activation

package/cli/install/service-linux.mjs

@@ -23,7 +23,7 @@ import { readConfig } from '../config/read.mjs';
 export const SYSTEMD_UNIT_NAME = `${PRODUCT_NAME}.service`;
 export const SYSTEMCTL_PATH = '/usr/bin/systemctl';
 
-// D-S04: a host without a reachable user manager gets an actionable
+// A host without a reachable user manager gets an actionable
 // explanation, never an automatic `loginctl enable-linger` and never a detour
 // through the system manager.
 const NO_SESSION_HINT = 'log in through a real session (which provides $XDG_RUNTIME_DIR), or run \'loginctl enable-linger <user>\' so the user manager stays available without one; this product never enables linger, never modifies unrelated units, and never contacts the system (PID 1) manager';

package/cli/install/service-macos.mjs

@@ -12,6 +12,10 @@ import {
   SYSTEMD_UNIT_NAME, bootstrapServiceSystemd, bootoutServiceSystemd, installServiceUnit,
   systemdServiceRegistrationStatus,
 } from './service-linux.mjs';
+import {
+  bootstrapServiceWindows, bootoutServiceWindows, installServiceDefinitionWindows,
+  windowsServiceRegistrationStatus,
+} from './service-windows.mjs';
 
 // The macOS service backend for the product daemon, plus the platform
 // dispatch into the systemd user backend (service-linux.mjs).  The plist pins
@@ -169,36 +173,58 @@ export function bootoutLaunchdService(paths, uid = process.getuid(), options = {
   }
 }
 
-// Platform dispatch (S03): the service backend is selected by the process
+// Platform dispatch: the service backend is selected by the process
 // platform — launchd on macOS, the systemd user manager on Linux — behind the
 // same call surface every caller (init, start/stop, uninstall, status) already
 // uses.  The macOS arms below are the verbatim launchd implementations; the
 // Linux arms carry the same idempotence/removal-confirmation contract through
 // `systemctl --user` (options.systemctl is the injectable seam, the twin of
 // options.launchctl).
-export function serviceRegistrationStatus(uid = process.getuid(), options = {}) {
-  return platform() === 'darwin'
-    ? launchdServiceRegistrationStatus(uid, options)
-    : systemdServiceRegistrationStatus(options);
+export function serviceRegistrationStatus(uid, options = {}) {
+  const currentPlatform = platform();
+  if (currentPlatform === 'darwin') {
+    return launchdServiceRegistrationStatus(uid ?? process.getuid(), options);
+  }
+  if (currentPlatform === 'win32') {
+    return windowsServiceRegistrationStatus(options);
+  }
+  return systemdServiceRegistrationStatus(options);
 }
 
-export function bootstrapService(paths, uid = process.getuid(), options = {}) {
-  return platform() === 'darwin'
-    ? bootstrapLaunchdService(paths, uid, options)
-    : bootstrapServiceSystemd(paths, uid, options);
+export function bootstrapService(paths, uid, options = {}) {
+  const currentPlatform = platform();
+  if (currentPlatform === 'darwin') {
+    return bootstrapLaunchdService(paths, uid ?? process.getuid(), options);
+  }
+  if (currentPlatform === 'win32') {
+    return bootstrapServiceWindows(paths, options);
+  }
+  return bootstrapServiceSystemd(paths, uid, options);
 }
 
-export function bootoutService(paths, uid = process.getuid(), options = {}) {
-  return platform() === 'darwin'
-    ? bootoutLaunchdService(paths, uid, options)
-    : bootoutServiceSystemd(paths, uid, options);
+export function bootoutService(paths, uid, options = {}) {
+  const currentPlatform = platform();
+  if (currentPlatform === 'darwin') {
+    return bootoutLaunchdService(paths, uid ?? process.getuid(), options);
+  }
+  if (currentPlatform === 'win32') {
+    return bootoutServiceWindows(paths, options);
+  }
+  return bootoutServiceSystemd(paths, uid, options);
 }
 
 // The service-definition installer behind init's install-launch-agent step:
 // the launchd plist on macOS, the systemd user unit (0600, absolute verified
 // payload, Restart=always) on Linux, both at paths.launchAgent.
 export function installServiceDefinition(paths, options = {}) {
-  return platform() === 'darwin' ? installLaunchAgent(paths, options) : installServiceUnit(paths, options);
+  const currentPlatform = platform();
+  if (currentPlatform === 'darwin') {
+    return installLaunchAgent(paths, options);
+  }
+  if (currentPlatform === 'win32') {
+    return installServiceDefinitionWindows(paths, options);
+  }
+  return installServiceUnit(paths, options);
 }
 
 export { SYSTEMD_UNIT_NAME };