@withtruing/companion 0.0.0-stage → 0.13.1

package/dist/service.js

@@ -0,0 +1,710 @@
+import { execFile, spawn } from 'node:child_process';
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync, writeSync, } from 'node:fs';
+import { homedir, uptime } from 'node:os';
+import { dirname, join, posix, resolve, win32 } from 'node:path';
+import { promisify } from 'node:util';
+import { loadConfig } from './config.js';
+const execFileAsync = promisify(execFile);
+// Kept on purpose from the old name so existing pairings still work.
+const SERVICE_DIR_NAME = '.product-console-companion';
+const SERVICE_FILE_NAME = 'service.json';
+const PID_FILE_NAME = 'service.pid';
+const STOP_FILE_NAME = 'STOP';
+const LOG_FILE_NAME = 'run.log';
+const MAX_LOG_BYTES = 5 * 1024 * 1024;
+const RESTART_DELAY_MS = 30_000;
+const EXIT_WINDOW_MS = 15 * 60_000;
+const CRASH_PAUSE_MS = 10 * 60_000;
+const STOP_GRACE_MS = 10_000;
+const BOOT_TIME_TOLERANCE_MS = 2 * 60_000;
+const ALLOWED_ENV = ['CLAUDE_CONFIG_DIR', 'CODEX_HOME', 'HOME', 'USERPROFILE'];
+const defaultIo = {
+    exists: existsSync,
+    mkdir: (path) => mkdirSync(path, { recursive: true }),
+    read: (path) => readFileSync(path, 'utf8'),
+    write: (path, contents, mode) => writeFileSync(path, contents, mode === undefined ? undefined : { mode }),
+    remove: (path) => {
+        try {
+            unlinkSync(path);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    },
+};
+const defaultCommands = {
+    async exec(command, args) {
+        const result = await execFileAsync(command, args, { encoding: 'utf8', windowsHide: true });
+        return { stdout: result.stdout, stderr: result.stderr };
+    },
+    spawnDetached(command, args, options) {
+        spawn(command, args, {
+            cwd: options.cwd,
+            env: options.env,
+            detached: true,
+            stdio: 'ignore',
+            windowsHide: true,
+        }).unref();
+    },
+};
+function xml(value) {
+    return value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;').replaceAll("'", '&apos;');
+}
+function vbs(value) {
+    return value.replaceAll('"', '""');
+}
+function systemdArgument(value) {
+    return `"${value.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
+}
+function desktopArgument(value) {
+    return `"${value.replaceAll('\\', '\\\\').replaceAll('"', '\\"').replaceAll('`', '\\`').replaceAll('$', '\\$')}"`;
+}
+export function servicePaths(overrides = {}) {
+    const homeDir = resolve(overrides.homeDir ?? homedir());
+    const serviceDir = join(homeDir, SERVICE_DIR_NAME);
+    // Windows keeps the Startup folder under %APPDATA%, which can be redirected away from the home
+    // folder; tests that inject a home folder keep everything under it.
+    const roamingAppData = overrides.homeDir === undefined && process.env.APPDATA
+        ? process.env.APPDATA
+        : join(homeDir, 'AppData', 'Roaming');
+    return {
+        homeDir,
+        serviceDir,
+        serviceFile: join(serviceDir, SERVICE_FILE_NAME),
+        pidFile: join(serviceDir, PID_FILE_NAME),
+        stopFile: join(serviceDir, STOP_FILE_NAME),
+        logFile: join(serviceDir, LOG_FILE_NAME),
+        oldLogFile: join(serviceDir, `${LOG_FILE_NAME}.1`),
+        windowsLauncher: join(serviceDir, 'start-hidden.vbs'),
+        windowsShortcutScript: join(serviceDir, 'create-startup-shortcut.vbs'),
+        windowsStartupShortcut: join(resolve(overrides.windowsStartupDir ?? join(roamingAppData, 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup')), 'Truing companion.lnk'),
+        legacyWindowsStartupShortcut: join(resolve(overrides.windowsStartupDir ?? join(roamingAppData, 'Microsoft', 'Windows', 'Start Menu', 'Programs', 'Startup')), 'Product Console companion.lnk'),
+        macLaunchAgent: join(resolve(overrides.macLaunchAgentsDir ?? join(homeDir, 'Library', 'LaunchAgents')), 'com.withtruing.companion.plist'),
+        legacyMacLaunchAgent: join(resolve(overrides.macLaunchAgentsDir ?? join(homeDir, 'Library', 'LaunchAgents')), 'com.fynch.product-console-companion.plist'),
+        linuxSystemdUnit: join(resolve(overrides.linuxSystemdUserDir ?? join(homeDir, '.config', 'systemd', 'user')), 'truing-companion.service'),
+        legacyLinuxSystemdUnit: join(resolve(overrides.linuxSystemdUserDir ?? join(homeDir, '.config', 'systemd', 'user')), 'product-console-companion.service'),
+        linuxDesktopFile: join(resolve(overrides.linuxAutostartDir ?? join(homeDir, '.config', 'autostart')), 'truing-companion.desktop'),
+        legacyLinuxDesktopFile: join(resolve(overrides.linuxAutostartDir ?? join(homeDir, '.config', 'autostart')), 'product-console-companion.desktop'),
+    };
+}
+export function serviceConfig(cliPath, cwd, env = process.env, nodePath = process.execPath, platform = process.platform) {
+    const carriedEnvironment = {};
+    for (const name of ALLOWED_ENV) {
+        const value = env[name];
+        if (value)
+            carriedEnvironment[name] = value;
+    }
+    // Paths follow the target OS's rules, so the per-OS tests produce the same files on any CI OS.
+    const resolvePath = platform === 'win32' ? win32.resolve : posix.resolve;
+    return {
+        nodePath: resolvePath(nodePath),
+        cliPath: resolvePath(cliPath),
+        cwd: resolvePath(cwd),
+        env: carriedEnvironment,
+    };
+}
+export function isNpxCachePath(cliPath) {
+    return /(?:^|[\\/])_npx(?:[\\/]|$)/i.test(resolve(cliPath));
+}
+export function windowsLauncherContents(config) {
+    const command = `"${config.nodePath}" "${config.cliPath}" daemon`;
+    return [
+        'Set shell = CreateObject("WScript.Shell")',
+        `shell.Run "${vbs(command)}", 0, False`,
+        'Set shell = Nothing',
+        '',
+    ].join('\r\n');
+}
+export function windowsShortcutContents(paths, windowsDirectory) {
+    const wscript = join(windowsDirectory, 'System32', 'wscript.exe');
+    return [
+        'Set shell = CreateObject("WScript.Shell")',
+        `Set shortcut = shell.CreateShortcut("${vbs(paths.windowsStartupShortcut)}")`,
+        `shortcut.TargetPath = "${vbs(wscript)}"`,
+        `shortcut.Arguments = "${vbs(`"${paths.windowsLauncher}"`)}"`,
+        `shortcut.WorkingDirectory = "${vbs(paths.serviceDir)}"`,
+        'shortcut.Description = "Starts Truing companion silently"',
+        'shortcut.Save',
+        '',
+    ].join('\r\n');
+}
+export function macLaunchAgentContents(config, paths) {
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.withtruing.companion</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${xml(config.nodePath)}</string>
+    <string>${xml(config.cliPath)}</string>
+    <string>daemon</string>
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${xml(config.cwd)}</string>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${xml(paths.logFile)}</string>
+  <key>StandardErrorPath</key>
+  <string>${xml(paths.logFile)}</string>
+</dict>
+</plist>
+`;
+}
+export function linuxSystemdUnitContents(config, paths) {
+    return `[Unit]
+Description=Truing companion
+After=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${systemdArgument(config.nodePath)} ${systemdArgument(config.cliPath)} daemon
+WorkingDirectory=${config.cwd}
+Restart=on-failure
+StandardOutput=append:${paths.logFile}
+StandardError=append:${paths.logFile}
+
+[Install]
+WantedBy=default.target
+`;
+}
+export function linuxDesktopContents(config) {
+    return `[Desktop Entry]
+Type=Application
+Name=Truing companion
+Comment=Starts Truing companion silently
+Exec=${desktopArgument(config.nodePath)} ${desktopArgument(config.cliPath)} daemon
+Path=${config.cwd}
+Terminal=false
+X-GNOME-Autostart-enabled=true
+`;
+}
+function writeFile(io, path, contents, mode) {
+    io.mkdir(dirname(path));
+    io.write(path, contents, mode);
+}
+async function removeLegacyStartup(platform, paths, io, commands, uid = process.getuid?.() ?? 0) {
+    const exists = (path) => {
+        try {
+            return io.exists(path);
+        }
+        catch {
+            return false;
+        }
+    };
+    const remove = (path) => {
+        try {
+            io.remove(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    if (platform === 'win32') {
+        const found = exists(paths.legacyWindowsStartupShortcut);
+        if (!found)
+            return null;
+        return remove(paths.legacyWindowsStartupShortcut) ? 'removed' : 'failed';
+    }
+    if (platform === 'darwin') {
+        const found = exists(paths.legacyMacLaunchAgent);
+        if (!found)
+            return null;
+        try {
+            await commands.exec('launchctl', ['bootout', `gui/${uid}`, paths.legacyMacLaunchAgent]);
+        }
+        catch {
+            try {
+                await commands.exec('launchctl', ['unload', '-w', paths.legacyMacLaunchAgent]);
+            }
+            catch { /* Not loaded. */ }
+        }
+        return remove(paths.legacyMacLaunchAgent) ? 'removed' : 'failed';
+    }
+    const found = exists(paths.legacyLinuxSystemdUnit) || exists(paths.legacyLinuxDesktopFile);
+    if (!found)
+        return null;
+    try {
+        await commands.exec('systemctl', ['--user', 'disable', '--now', 'product-console-companion.service']);
+    }
+    catch { /* systemd may not exist. */ }
+    const removedUnit = remove(paths.legacyLinuxSystemdUnit);
+    const removedDesktop = remove(paths.legacyLinuxDesktopFile);
+    try {
+        await commands.exec('systemctl', ['--user', 'daemon-reload']);
+    }
+    catch { /* systemd may not exist. */ }
+    return removedUnit && removedDesktop ? 'removed' : 'failed';
+}
+export async function installService(options) {
+    const platform = options.platform ?? process.platform;
+    const env = options.env ?? process.env;
+    const io = options.io ?? defaultIo;
+    const commands = options.commands ?? defaultCommands;
+    const paths = servicePaths(options.paths);
+    const config = serviceConfig(options.cliPath, options.cwd ?? process.cwd(), env, options.nodePath, platform);
+    if (isNpxCachePath(config.cliPath)) {
+        throw new Error('This copy is running from the temporary npx cache. Run `npm install -g @withtruing/companion` first, then run `truing install`.');
+    }
+    const legacyCleanup = await removeLegacyStartup(platform, paths, io, commands, options.uid ?? process.getuid?.() ?? 0);
+    // The old package shares these service files, so stop it before its saved CLI path is replaced.
+    await stopService(options);
+    const legacyOutput = legacyCleanup === 'removed'
+        ? ["Removed the old Product Console companion's automatic startup."]
+        : legacyCleanup === 'failed'
+            ? ["Could not completely remove the old Product Console companion's automatic startup; continuing with Truing companion installation."]
+            : [];
+    io.mkdir(paths.serviceDir);
+    writeFile(io, paths.serviceFile, `${JSON.stringify(config, null, 2)}\n`, 0o600);
+    io.remove(paths.stopFile);
+    if (platform === 'win32') {
+        const windowsDirectory = options.windowsDirectory ?? env.SystemRoot ?? 'C:\\Windows';
+        writeFile(io, paths.windowsLauncher, windowsLauncherContents(config));
+        writeFile(io, paths.windowsShortcutScript, windowsShortcutContents(paths, windowsDirectory));
+        io.remove(paths.windowsStartupShortcut);
+        await commands.exec('cscript.exe', ['//nologo', paths.windowsShortcutScript]);
+        await commands.exec('cscript.exe', ['//nologo', paths.windowsLauncher]);
+        return [...legacyOutput,
+            'Truing companion will now start silently when you sign in to Windows, and it has been started now.',
+            'Run `truing stop` to stop it, or `truing uninstall` to remove automatic startup.',
+        ];
+    }
+    if (platform === 'darwin') {
+        writeFile(io, paths.macLaunchAgent, macLaunchAgentContents(config, paths));
+        const domain = `gui/${options.uid ?? process.getuid?.() ?? 0}`;
+        // A reinstall replaces an agent that is already loaded; bootstrap refuses a loaded label.
+        try {
+            await commands.exec('launchctl', ['bootout', domain, paths.macLaunchAgent]);
+        }
+        catch { /* Not loaded yet. */ }
+        try {
+            await commands.exec('launchctl', ['bootstrap', domain, paths.macLaunchAgent]);
+        }
+        catch {
+            await commands.exec('launchctl', ['load', '-w', paths.macLaunchAgent]);
+        }
+        return [...legacyOutput,
+            'Truing companion will now start silently when you sign in to your Mac, and it has been started now.',
+            'Run `truing stop` to stop it, or `truing uninstall` to remove automatic startup.',
+        ];
+    }
+    writeFile(io, paths.linuxSystemdUnit, linuxSystemdUnitContents(config, paths));
+    try {
+        await commands.exec('systemctl', ['--user', 'daemon-reload']);
+        await commands.exec('systemctl', ['--user', 'enable', '--now', 'truing-companion.service']);
+        return [...legacyOutput,
+            'Truing companion was installed as a systemd user service and has been started now.',
+            'Run `truing stop` to stop it, or `truing uninstall` to remove automatic startup.',
+        ];
+    }
+    catch {
+        writeFile(io, paths.linuxDesktopFile, linuxDesktopContents(config));
+        commands.spawnDetached(config.nodePath, [config.cliPath, 'daemon'], {
+            cwd: config.cwd,
+            env: { ...process.env, ...config.env },
+            windowsHide: true,
+        });
+        return [...legacyOutput,
+            'Truing companion will now start silently through desktop autostart, and it has been started now.',
+            'Run `truing stop` to stop it, or `truing uninstall` to remove automatic startup.',
+        ];
+    }
+}
+export function readServiceConfig(paths = servicePaths(), io = defaultIo) {
+    if (!io.exists(paths.serviceFile)) {
+        throw new Error('The background companion is not installed. Run `truing install` first.');
+    }
+    return JSON.parse(io.read(paths.serviceFile));
+}
+function readPidRecord(paths, io = defaultIo) {
+    if (!io.exists(paths.pidFile))
+        return null;
+    try {
+        const record = JSON.parse(io.read(paths.pidFile));
+        return Number.isSafeInteger(record.pid) && record.pid > 0 ? record : null;
+    }
+    catch {
+        return null;
+    }
+}
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === 'EPERM';
+    }
+}
+function currentBootTime() {
+    return Date.now() - uptime() * 1000;
+}
+function recordAlive(record) {
+    if (record.bootTime !== undefined
+        && Math.abs(record.bootTime - currentBootTime()) > BOOT_TIME_TOLERANCE_MS)
+        return false;
+    return processAlive(record.pid);
+}
+function pidRecord(pid, role, childPid) {
+    return { pid, role, ...(childPid ? { childPid } : {}), bootTime: Math.round(currentBootTime()) };
+}
+export function acquireInstanceLock(role, paths = servicePaths(), pid = process.pid) {
+    mkdirSync(paths.serviceDir, { recursive: true });
+    for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+            const fd = openSync(paths.pidFile, 'wx', 0o600);
+            writeSync(fd, `${JSON.stringify(pidRecord(pid, role))}\n`);
+            closeSync(fd);
+            return true;
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            const current = readPidRecord(paths);
+            if (current && recordAlive(current))
+                return false;
+            try {
+                unlinkSync(paths.pidFile);
+            }
+            catch (removeError) {
+                if (removeError.code !== 'ENOENT')
+                    return false;
+            }
+        }
+    }
+    return false;
+}
+export function updateInstanceLock(role, childPid, paths = servicePaths()) {
+    writeFileSync(paths.pidFile, `${JSON.stringify(pidRecord(process.pid, role, childPid))}\n`, { mode: 0o600 });
+}
+export function releaseInstanceLock(paths = servicePaths(), pid = process.pid) {
+    const record = readPidRecord(paths);
+    if (record?.pid === pid)
+        defaultIo.remove(paths.pidFile);
+}
+function rotateLog(paths) {
+    try {
+        if (statSync(paths.logFile).size < MAX_LOG_BYTES)
+            return;
+        defaultIo.remove(paths.oldLogFile);
+        renameSync(paths.logFile, paths.oldLogFile);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+}
+export function appendServiceLog(paths, message) {
+    mkdirSync(paths.serviceDir, { recursive: true });
+    rotateLog(paths);
+    const timestamp = new Date().toISOString();
+    const lines = message.replace(/\r\n/g, '\n').split('\n').filter((line) => line.length > 0);
+    if (lines.length === 0)
+        return;
+    const fd = openSync(paths.logFile, 'a', 0o600);
+    try {
+        writeSync(fd, lines.map((line) => `[${timestamp}] ${line}\n`).join(''));
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function defaultSpawnChild(config) {
+    return spawn(config.nodePath, [config.cliPath, 'run'], {
+        cwd: config.cwd,
+        env: { ...process.env, ...config.env, PRODUCT_CONSOLE_COMPANION_DAEMON_CHILD: '1' },
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+    });
+}
+/** On Windows `kill()` ends only the run process and would leave its Claude / Codex / git
+ *  children behind, so the whole tree goes. */
+function defaultTerminateChild(child) {
+    if (process.platform === 'win32' && child.pid) {
+        const killer = spawn('taskkill', ['/pid', String(child.pid), '/T', '/F'], { stdio: 'ignore', windowsHide: true });
+        killer.on('error', () => child.kill());
+        return;
+    }
+    child.kill();
+}
+function childExit(child) {
+    return new Promise((resolvePromise) => {
+        child.once('close', (code, signal) => resolvePromise({ code, signal }));
+        child.once('error', () => resolvePromise({ code: 1, signal: null }));
+    });
+}
+export class DaemonRestartPolicy {
+    exits = [];
+    nextDelay(now) {
+        this.exits = this.exits.filter((time) => now - time <= EXIT_WINDOW_MS);
+        this.exits.push(now);
+        if (this.exits.length < 5)
+            return RESTART_DELAY_MS;
+        this.exits = [];
+        return CRASH_PAUSE_MS;
+    }
+}
+async function waitForDelayOrStop(delayMs, clock, stopRequested) {
+    let remaining = delayMs;
+    while (remaining > 0) {
+        if (stopRequested())
+            return true;
+        const step = Math.min(1000, remaining);
+        await clock.sleep(step);
+        remaining -= step;
+    }
+    return stopRequested();
+}
+export async function runDaemon(options = {}) {
+    const paths = options.paths ?? servicePaths();
+    const config = options.config ?? readServiceConfig(paths);
+    const clock = options.clock ?? { now: Date.now, sleep: (ms) => new Promise((done) => setTimeout(done, ms)) };
+    const spawnChild = options.spawnChild ?? defaultSpawnChild;
+    const stopRequested = options.stopRequested ?? (() => existsSync(paths.stopFile));
+    const acquireLock = options.acquireLock ?? (() => acquireInstanceLock('daemon', paths));
+    const updateLock = options.updateLock ?? ((childPid) => updateInstanceLock('daemon', childPid, paths));
+    const releaseLock = options.releaseLock ?? (() => releaseInstanceLock(paths));
+    const writeLog = options.appendLog ?? ((line) => appendServiceLog(paths, line));
+    const terminateChild = options.terminateChild ?? defaultTerminateChild;
+    const logger = options.logger ?? console;
+    // A log that can't be written (disk full, file briefly locked) must not take the supervisor down.
+    const appendLog = (line) => {
+        try {
+            writeLog(line);
+        }
+        catch { /* Best effort. */ }
+    };
+    if (!acquireLock()) {
+        logger.log('A companion daemon or foreground run is already active; this daemon will exit.');
+        return;
+    }
+    defaultIo.remove(paths.stopFile);
+    let stopping = false;
+    let child = null;
+    const requestStop = () => {
+        stopping = true;
+        if (child)
+            terminateChild(child);
+    };
+    process.on('SIGINT', requestStop);
+    process.on('SIGTERM', requestStop);
+    // The STOP file is watched on its own short timer, so a stop ends a running child promptly
+    // without the restart clock having to tick while the child runs.
+    const stopWatch = setInterval(() => {
+        if (!stopping && stopRequested())
+            requestStop();
+    }, options.stopPollMs ?? 1000);
+    const shouldStop = () => stopping || stopRequested();
+    const policy = new DaemonRestartPolicy();
+    try {
+        appendLog('Background supervisor started.');
+        while (!shouldStop()) {
+            child = spawnChild(config);
+            updateLock(child.pid);
+            child.stdout?.on('data', (chunk) => appendLog(String(chunk)));
+            child.stderr?.on('data', (chunk) => appendLog(String(chunk)));
+            const result = await childExit(child);
+            child = null;
+            updateLock(undefined);
+            if (shouldStop())
+                break;
+            const delay = policy.nextDelay(clock.now());
+            appendLog(`Run process exited (code ${result.code ?? 'none'}, signal ${result.signal ?? 'none'}); restarting in ${Math.round(delay / 1000)} seconds.`);
+            if (await waitForDelayOrStop(delay, clock, shouldStop))
+                break;
+        }
+        appendLog('Background supervisor stopped.');
+    }
+    catch (error) {
+        logger.error(`Background supervisor failed: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+    finally {
+        clearInterval(stopWatch);
+        if (child)
+            terminateChild(child);
+        releaseLock();
+        defaultIo.remove(paths.stopFile);
+        process.off('SIGINT', requestStop);
+        process.off('SIGTERM', requestStop);
+    }
+}
+export async function startService(options = {}) {
+    const paths = servicePaths(options.paths);
+    const config = readServiceConfig(paths, options.io ?? defaultIo);
+    const commands = options.commands ?? defaultCommands;
+    (options.io ?? defaultIo).remove(paths.stopFile);
+    if ((options.platform ?? process.platform) === 'win32' && (options.io ?? defaultIo).exists(paths.windowsLauncher)) {
+        await commands.exec('cscript.exe', ['//nologo', paths.windowsLauncher]);
+        return;
+    }
+    commands.spawnDetached(config.nodePath, [config.cliPath, 'daemon'], {
+        cwd: config.cwd,
+        env: { ...process.env, ...config.env },
+        windowsHide: true,
+    });
+}
+async function killPid(pid, platform, commands) {
+    if (pid === process.pid || !processAlive(pid))
+        return;
+    if (platform === 'win32') {
+        try {
+            await commands.exec('taskkill.exe', ['/pid', String(pid), '/T', '/F']);
+        }
+        catch { /* Already gone. */ }
+        return;
+    }
+    try {
+        process.kill(pid, 'SIGTERM');
+    }
+    catch { /* Already gone. */ }
+}
+const WINDOWS_PROCESS_LIST = 'Get-CimInstance Win32_Process | ForEach-Object { "$($_.ProcessId)`t$($_.CommandLine)" }';
+/** Finds this install's daemon / run processes when there is no usable pid file. Current Windows 11
+ *  no longer ships wmic, so the process list comes from a hidden, non-interactive CIM query. */
+export async function fallbackPids(config, platform, commands) {
+    const isCompanion = (commandLine) => commandLine.includes(config.cliPath)
+        && /\s"?(?:daemon|run)"?(?:\s|$)/.test(commandLine);
+    const valid = (pid) => Number.isSafeInteger(pid) && pid > 0 && pid !== process.pid;
+    try {
+        if (platform === 'win32') {
+            const { stdout } = await commands.exec('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', WINDOWS_PROCESS_LIST]);
+            return stdout.split(/\r?\n/).map((line) => {
+                const tab = line.indexOf('\t');
+                return tab > 0 && isCompanion(line.slice(tab + 1)) ? Number(line.slice(0, tab).trim()) : 0;
+            }).filter(valid);
+        }
+        const { stdout } = await commands.exec('ps', ['-eo', 'pid=,args=']);
+        return stdout.split('\n').map((line) => {
+            const match = /^\s*(\d+)\s+(.*)$/.exec(line);
+            return match && isCompanion(match[2]) ? Number(match[1]) : 0;
+        }).filter(valid);
+    }
+    catch {
+        return [];
+    }
+}
+/** Asks the daemon to stop through the STOP file (and SIGTERM where signals exist), gives it a few
+ *  seconds to end its run process and clean up, then force-ends whatever is still alive. */
+export async function stopService(options = {}) {
+    const paths = servicePaths(options.paths);
+    const io = options.io ?? defaultIo;
+    const commands = options.commands ?? defaultCommands;
+    const platform = options.platform ?? process.platform;
+    const sleep = options.sleep ?? ((ms) => new Promise((done) => setTimeout(done, ms)));
+    const isAlive = options.isAlive ?? processAlive;
+    io.mkdir(paths.serviceDir);
+    io.write(paths.stopFile, `${new Date().toISOString()}\n`, 0o600);
+    const stored = readPidRecord(paths, io);
+    const record = stored && recordAlive(stored) ? stored : null;
+    const config = io.exists(paths.serviceFile) ? readServiceConfig(paths, io) : null;
+    const pids = new Set();
+    if (record?.childPid)
+        pids.add(record.childPid);
+    if (record)
+        pids.add(record.pid);
+    if (pids.size === 0 && config) {
+        for (const pid of await fallbackPids(config, platform, commands))
+            pids.add(pid);
+    }
+    if (record?.role === 'daemon') {
+        if (platform !== 'win32') {
+            try {
+                process.kill(record.pid, 'SIGTERM');
+            }
+            catch { /* Already gone. */ }
+        }
+        for (let waited = 0; waited < STOP_GRACE_MS && isAlive(record.pid); waited += 250)
+            await sleep(250);
+    }
+    for (const pid of pids) {
+        if (isAlive(pid))
+            await killPid(pid, platform, commands);
+    }
+    // A force-ended daemon can't remove its own pid file; a stale one must not block the next start.
+    if (stored && !(record && isAlive(record.pid)))
+        io.remove(paths.pidFile);
+    return pids.size > 0;
+}
+export async function uninstallService(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const io = options.io ?? defaultIo;
+    const commands = options.commands ?? defaultCommands;
+    const paths = servicePaths(options.paths);
+    await stopService(options);
+    const legacyCleanup = await removeLegacyStartup(platform, paths, io, commands, options.uid ?? process.getuid?.() ?? 0);
+    if (platform === 'win32') {
+        io.remove(paths.windowsStartupShortcut);
+        io.remove(paths.windowsLauncher);
+        io.remove(paths.windowsShortcutScript);
+    }
+    else if (platform === 'darwin') {
+        try {
+            await commands.exec('launchctl', ['bootout', `gui/${options.uid ?? process.getuid?.() ?? 0}`, paths.macLaunchAgent]);
+        }
+        catch {
+            try {
+                await commands.exec('launchctl', ['unload', '-w', paths.macLaunchAgent]);
+            }
+            catch { /* Not loaded. */ }
+        }
+        io.remove(paths.macLaunchAgent);
+    }
+    else {
+        try {
+            await commands.exec('systemctl', ['--user', 'disable', '--now', 'truing-companion.service']);
+        }
+        catch { /* systemd may not exist. */ }
+        io.remove(paths.linuxSystemdUnit);
+        io.remove(paths.linuxDesktopFile);
+        try {
+            await commands.exec('systemctl', ['--user', 'daemon-reload']);
+        }
+        catch { /* systemd may not exist. */ }
+    }
+    io.remove(paths.serviceFile);
+    io.remove(paths.stopFile);
+    return [
+        ...(legacyCleanup === 'removed'
+            ? ["Removed the old Product Console companion's automatic startup."]
+            : legacyCleanup === 'failed'
+                ? ["Could not completely remove the old Product Console companion's automatic startup; continuing with Truing companion uninstall."]
+                : []),
+        'Truing companion automatic startup was removed and the background process was stopped.',
+        'Your pairings and logs were kept.',
+    ];
+}
+export function serviceStatus(paths = servicePaths(), io = defaultIo) {
+    const record = readPidRecord(paths, io);
+    const config = loadConfig();
+    let logLines = [];
+    if (io.exists(paths.logFile)) {
+        logLines = io.read(paths.logFile).trimEnd().split(/\r?\n/).slice(-5);
+    }
+    return {
+        installed: io.exists(paths.serviceFile) && (io.exists(paths.windowsStartupShortcut) || io.exists(paths.macLaunchAgent)
+            || io.exists(paths.linuxSystemdUnit) || io.exists(paths.linuxDesktopFile)),
+        running: record !== null && recordAlive(record),
+        role: record?.role ?? null,
+        pid: record?.pid ?? null,
+        logLines,
+        projects: (config?.pairings ?? []).flatMap((pairing) => (pairing.connections.map(({ connectionId, repoPath }) => ({ connectionId, repoPath })))),
+        pairings: (config?.pairings ?? []).map((pairing) => ({
+            url: pairing.url,
+            workspaceId: pairing.workspaceId,
+            projects: pairing.connections.map(({ connectionId, repoPath, managed }) => ({
+                connectionId,
+                repoPath,
+                ...(managed ? { managed } : {}),
+            })),
+            workspaceTasks: pairing.pollWorkspaceTasks
+                ? { backend: pairing.workspaceBackend ?? 'api-key' }
+                : undefined,
+        })),
+    };
+}