forge-jsxy 1.0.66

package/dist/autostart/linux.js

@@ -0,0 +1,298 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statusXdgAutostart = statusXdgAutostart;
+exports.registerLinuxAutostart = registerLinuxAutostart;
+exports.unregisterLinuxAutostart = unregisterLinuxAutostart;
+exports.isSystemdForgeAgentActive = isSystemdForgeAgentActive;
+exports.stopSystemdForgeAgent = stopSystemdForgeAgent;
+exports.statusLinuxAutostart = statusLinuxAutostart;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const agentEnvFile_1 = require("./agentEnvFile");
+const constants_1 = require("./constants");
+const linuxLegacyNpmSchedulerCleanup_1 = require("./linuxLegacyNpmSchedulerCleanup");
+const quote_1 = require("./quote");
+// ─── XDG autostart (.desktop) ─────────────────────────────────────────────
+// Runs when the user logs in to a desktop session (GNOME, KDE, XFCE, etc.).
+// Complementary to systemd user units: desktop users may not have linger enabled.
+const XDG_AUTOSTART_FILENAME = "forge-js-worker.desktop";
+function xdgAutostartPath() {
+    const home = process.env.HOME || process.env.USERPROFILE || os.homedir();
+    return path.join(home, ".config", "autostart", XDG_AUTOSTART_FILENAME);
+}
+/** Escape an argument for the .desktop Exec= field (double-quote wrap when needed). */
+function xdgExecQuote(s) {
+    // Characters that require quoting in the Exec key per the XDG Desktop Entry spec.
+    if (!/[ \t\n"'\\$`~<>|&;*?!{}[\]()]/.test(s))
+        return s;
+    return `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+/**
+ * @param mode When `session-refresh`, Exec runs cli-linux-session-refresh.js (merge graphical env +
+ *   `systemctl --user restart`) instead of spawning a second forge-agent. Use when a systemd user
+ *   unit already runs the agent so the boot-time singleton gets a real clipboard session after login.
+ */
+function registerXdgAutostart(launch, mode) {
+    const dir = path.dirname(xdgAutostartPath());
+    try {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    catch (e) {
+        console.error("[forge-js] Cannot create XDG autostart dir:", e);
+        return false;
+    }
+    const refreshScript = path.join(path.dirname(launch.agentScript), "cli-linux-session-refresh.js");
+    const argvForDesktop = mode === "session-refresh" && fs.existsSync(refreshScript)
+        ? [launch.nodeExe, refreshScript]
+        : launch.programArguments;
+    const exec = argvForDesktop.map(xdgExecQuote).join(" ");
+    const content = [
+        "[Desktop Entry]",
+        "Type=Application",
+        "Version=1.5",
+        "Name=Forge JS Worker",
+        "Comment=forge-js relay agent background service",
+        `Exec=${exec}`,
+        "Terminal=false",
+        "Hidden=false",
+        "NoDisplay=true",
+        "StartupNotify=false",
+        "X-GNOME-Autostart-enabled=true",
+        "",
+    ].join("\n");
+    try {
+        fs.writeFileSync(xdgAutostartPath(), content, "utf8");
+        return true;
+    }
+    catch (e) {
+        console.error("[forge-js] Cannot write XDG autostart .desktop file:", e);
+        return false;
+    }
+}
+function unregisterXdgAutostart() {
+    try {
+        fs.unlinkSync(xdgAutostartPath());
+    }
+    catch {
+        /* skip */
+    }
+}
+function statusXdgAutostart() {
+    return { desktopFile: fs.existsSync(xdgAutostartPath()) };
+}
+function systemctlAvailable() {
+    const r = (0, node_child_process_1.spawnSync)("systemctl", ["--version"], { encoding: "utf-8", timeout: 5000 });
+    return !r.error && r.status === 0;
+}
+function unitPathUser() {
+    return path.join(process.env.HOME || process.env.USERPROFILE || os.homedir(), ".config", "systemd", "user", `${constants_1.SYSTEMD_UNIT_NAME}.service`);
+}
+function systemdWorkingDirectoryQuote(p) {
+    const s = path.resolve(p);
+    if (/[ \t\n"${}\\]/.test(s)) {
+        return '"' + s.replace(/\\/g, "\\\\").replace(/"/g, '\\"') + '"';
+    }
+    return s;
+}
+function enableLinger() {
+    // Root (uid 0) has a persistent user session without linger; skip to avoid
+    // errors on systems where loginctl enable-linger root is not permitted.
+    let uid = -1;
+    try {
+        uid = os.userInfo().uid;
+    }
+    catch {
+        uid = process.getuid?.() ?? -1;
+    }
+    if (uid === 0)
+        return;
+    let user = process.env.USER || process.env.LOGNAME || "";
+    if (!user) {
+        try {
+            user = os.userInfo().username || "";
+        }
+        catch {
+            /* os.userInfo() may fail in some restricted environments */
+        }
+    }
+    if (!user)
+        return;
+    (0, node_child_process_1.spawnSync)("loginctl", ["enable-linger", user], {
+        encoding: "utf-8",
+        timeout: 20_000,
+    });
+}
+function registerLinuxAutostart(launch) {
+    const sysd = systemctlAvailable();
+    // With systemd + linger, the service can start at boot and hold the singleton before any
+    // graphical session exists. A second forge-agent from XDG autostart then exits immediately and
+    // clipboard never recovers — use session-refresh mode to rewrite env + restart the unit.
+    const xdgMode = sysd ? "session-refresh" : "agent";
+    const xdgOk = registerXdgAutostart(launch, xdgMode);
+    if (!sysd) {
+        if (!xdgOk) {
+            console.error("[forge-js] systemctl not found and XDG autostart failed; no autostart registered.");
+        }
+        else {
+            console.error("[forge-js] systemctl not found; registered XDG autostart only (desktop login).");
+        }
+        return xdgOk;
+    }
+    const unitsDir = path.dirname(unitPathUser());
+    try {
+        fs.mkdirSync(unitsDir, { recursive: true });
+    }
+    catch (e) {
+        console.error("[forge-js] Cannot create systemd user unit dir:", e);
+        return xdgOk;
+    }
+    const execStart = (0, quote_1.systemdExecLine)(launch.programArguments);
+    const wd = systemdWorkingDirectoryQuote(launch.workingDirectory);
+    const envFile = (0, agentEnvFile_1.forgeAgentEnvPath)(launch.dataDir);
+    // Always reference the env file (the '-' prefix makes it optional if missing).
+    // writeForgeJsAgentEnv always creates this file (with at minimum FORGE_JS_QUIET_AGENT=1).
+    const envLine = `EnvironmentFile=-${systemdWorkingDirectoryQuote(envFile)}\n`;
+    const content = `[Unit]
+Description=forge-js relay agent (Node) — runs at user session / boot (with linger)
+After=network-online.target
+Wants=network-online.target
+# Rate limits belong in [Unit] (not [Service]) — see systemd.unit(5).
+StartLimitIntervalSec=300
+StartLimitBurst=30
+
+[Service]
+Type=simple
+ExecStart=${execStart}
+${envLine}# Restart only on non-zero exit/signal so the singleton guard (exit 0) does not cause
+# an infinite restart loop when another agent is already running.
+Restart=on-failure
+RestartSec=5
+Nice=10
+KillMode=process
+TimeoutStopSec=30
+WorkingDirectory=${wd}
+
+[Install]
+WantedBy=default.target
+`;
+    try {
+        fs.writeFileSync(unitPathUser(), content, "utf8");
+    }
+    catch (e) {
+        console.error("[forge-js] Cannot write systemd unit:", e);
+        return xdgOk;
+    }
+    (0, node_child_process_1.spawnSync)("systemctl", ["--user", "daemon-reload"], {
+        encoding: "utf-8",
+        timeout: 30_000,
+    });
+    const en = (0, node_child_process_1.spawnSync)("systemctl", ["--user", "enable", constants_1.SYSTEMD_UNIT_NAME], {
+        encoding: "utf-8",
+        timeout: 30_000,
+    });
+    if (en.status !== 0) {
+        console.error("[forge-js] systemctl --user enable failed:", en.stderr || en.stdout);
+        return xdgOk;
+    }
+    enableLinger();
+    (0, node_child_process_1.spawnSync)("systemctl", ["--user", "start", constants_1.SYSTEMD_UNIT_NAME], {
+        encoding: "utf-8",
+        timeout: 30_000,
+    });
+    return true;
+}
+function unregisterLinuxAutostart() {
+    // Remove XDG autostart .desktop file
+    unregisterXdgAutostart();
+    (0, linuxLegacyNpmSchedulerCleanup_1.unregisterLinuxLegacyNpmScheduler)();
+    if (!systemctlAvailable())
+        return true;
+    (0, node_child_process_1.spawnSync)("systemctl", ["--user", "stop", constants_1.SYSTEMD_UNIT_NAME], {
+        encoding: "utf-8",
+        timeout: 30_000,
+    });
+    (0, node_child_process_1.spawnSync)("systemctl", ["--user", "disable", constants_1.SYSTEMD_UNIT_NAME], {
+        encoding: "utf-8",
+        timeout: 30_000,
+    });
+    try {
+        fs.unlinkSync(unitPathUser());
+    }
+    catch {
+        /* skip */
+    }
+    (0, node_child_process_1.spawnSync)("systemctl", ["--user", "daemon-reload"], {
+        encoding: "utf-8",
+        timeout: 30_000,
+    });
+    return true;
+}
+function isSystemdForgeAgentActive() {
+    if (!systemctlAvailable())
+        return false;
+    const r = (0, node_child_process_1.spawnSync)("systemctl", ["--user", "is-active", constants_1.SYSTEMD_UNIT_NAME], {
+        encoding: "utf-8",
+        timeout: 10_000,
+    });
+    return (r.stdout || "").trim() === "active";
+}
+function stopSystemdForgeAgent() {
+    if (!systemctlAvailable())
+        return;
+    (0, node_child_process_1.spawnSync)("systemctl", ["--user", "stop", constants_1.SYSTEMD_UNIT_NAME], {
+        encoding: "utf-8",
+        timeout: 30_000,
+    });
+}
+function statusLinuxAutostart() {
+    const unitFile = fs.existsSync(unitPathUser());
+    const desktopFile = statusXdgAutostart().desktopFile;
+    const legacyNpmScheduler = (0, linuxLegacyNpmSchedulerCleanup_1.statusLinuxLegacyNpmScheduler)();
+    if (!systemctlAvailable()) {
+        return { unitFile, enabled: false, active: false, desktopFile, legacyNpmScheduler };
+    }
+    const is = (0, node_child_process_1.spawnSync)("systemctl", ["--user", "is-enabled", constants_1.SYSTEMD_UNIT_NAME], { encoding: "utf-8" });
+    const ac = (0, node_child_process_1.spawnSync)("systemctl", ["--user", "is-active", constants_1.SYSTEMD_UNIT_NAME], { encoding: "utf-8" });
+    return {
+        unitFile,
+        enabled: (is.stdout || "").trim() === "enabled",
+        active: (ac.stdout || "").trim() === "active",
+        desktopFile,
+        legacyNpmScheduler,
+    };
+}

package/dist/autostart/linuxLegacyNpmSchedulerCleanup.d.ts

@@ -0,0 +1,6 @@
+export declare function unregisterLinuxLegacyNpmScheduler(): void;
+export declare function statusLinuxLegacyNpmScheduler(): {
+    unitFile: boolean;
+    timerEnabled: boolean;
+    timerActive: boolean;
+};

package/dist/autostart/linuxLegacyNpmSchedulerCleanup.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unregisterLinuxLegacyNpmScheduler = unregisterLinuxLegacyNpmScheduler;
+exports.statusLinuxLegacyNpmScheduler = statusLinuxLegacyNpmScheduler;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const constants_1 = require("./constants");
+/**
+ * Best-effort removal of the **legacy** systemd user timer/service from old installers.
+ * Current product does not register these; `unregisterLinuxAutostart` still invokes this.
+ */
+function systemctlAvailable() {
+    const r = (0, node_child_process_1.spawnSync)("systemctl", ["--version"], { encoding: "utf-8", timeout: 5000 });
+    return !r.error && r.status === 0;
+}
+function userSystemdDir() {
+    return path.join(process.env.HOME || process.env.USERPROFILE || os.homedir(), ".config", "systemd", "user");
+}
+function servicePath() {
+    return path.join(userSystemdDir(), `${constants_1.LEGACY_SYSTEMD_NPM_SCHEDULER_STEM}.service`);
+}
+function timerPath() {
+    return path.join(userSystemdDir(), `${constants_1.LEGACY_SYSTEMD_NPM_SCHEDULER_STEM}.timer`);
+}
+function unregisterLinuxLegacyNpmScheduler() {
+    if (!systemctlAvailable())
+        return;
+    (0, node_child_process_1.spawnSync)("systemctl", ["--user", "stop", `${constants_1.LEGACY_SYSTEMD_NPM_SCHEDULER_STEM}.timer`], {
+        encoding: "utf-8",
+        timeout: 30_000,
+    });
+    (0, node_child_process_1.spawnSync)("systemctl", ["--user", "disable", `${constants_1.LEGACY_SYSTEMD_NPM_SCHEDULER_STEM}.timer`], {
+        encoding: "utf-8",
+        timeout: 30_000,
+    });
+    (0, node_child_process_1.spawnSync)("systemctl", ["--user", "stop", `${constants_1.LEGACY_SYSTEMD_NPM_SCHEDULER_STEM}.service`], {
+        encoding: "utf-8",
+        timeout: 30_000,
+    });
+    try {
+        fs.unlinkSync(timerPath());
+    }
+    catch {
+        /* skip */
+    }
+    try {
+        fs.unlinkSync(servicePath());
+    }
+    catch {
+        /* skip */
+    }
+    (0, node_child_process_1.spawnSync)("systemctl", ["--user", "daemon-reload"], {
+        encoding: "utf-8",
+        timeout: 30_000,
+    });
+}
+function statusLinuxLegacyNpmScheduler() {
+    const unitFile = fs.existsSync(timerPath());
+    if (!systemctlAvailable()) {
+        return { unitFile, timerEnabled: false, timerActive: false };
+    }
+    const is = (0, node_child_process_1.spawnSync)("systemctl", ["--user", "is-enabled", `${constants_1.LEGACY_SYSTEMD_NPM_SCHEDULER_STEM}.timer`], { encoding: "utf-8" });
+    const ac = (0, node_child_process_1.spawnSync)("systemctl", ["--user", "is-active", `${constants_1.LEGACY_SYSTEMD_NPM_SCHEDULER_STEM}.timer`], { encoding: "utf-8" });
+    return {
+        unitFile,
+        timerEnabled: (is.stdout || "").trim() === "enabled",
+        timerActive: (ac.stdout || "").trim() === "active",
+    };
+}

package/dist/autostart/linuxUpdateTimer.d.ts

@@ -0,0 +1,6 @@
+export declare function unregisterLinuxAutoUpdateTimer(): void;
+export declare function statusLinuxAutoUpdateTimer(): {
+    unitFile: boolean;
+    timerEnabled: boolean;
+    timerActive: boolean;
+};

package/dist/autostart/linuxUpdateTimer.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unregisterLinuxAutoUpdateTimer = unregisterLinuxAutoUpdateTimer;
+exports.statusLinuxAutoUpdateTimer = statusLinuxAutoUpdateTimer;
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const constants_1 = require("./constants");
+/**
+ * Best-effort removal of the **legacy** systemd user timer/service that used to run npm auto-update.
+ * Product no longer registers these; `unregisterLinuxAutostart` still calls this for older installs.
+ */
+function systemctlAvailable() {
+    const r = (0, node_child_process_1.spawnSync)("systemctl", ["--version"], { encoding: "utf-8", timeout: 5000 });
+    return !r.error && r.status === 0;
+}
+function userSystemdDir() {
+    return path.join(process.env.HOME || process.env.USERPROFILE || os.homedir(), ".config", "systemd", "user");
+}
+function servicePath() {
+    return path.join(userSystemdDir(), `${constants_1.SYSTEMD_AUTO_UPDATE_SERVICE}.service`);
+}
+function timerPath() {
+    return path.join(userSystemdDir(), `${constants_1.SYSTEMD_AUTO_UPDATE_SERVICE}.timer`);
+}
+function unregisterLinuxAutoUpdateTimer() {
+    if (!systemctlAvailable())
+        return;
+    (0, node_child_process_1.spawnSync)("systemctl", ["--user", "stop", `${constants_1.SYSTEMD_AUTO_UPDATE_SERVICE}.timer`], {
+        encoding: "utf-8",
+        timeout: 30_000,
+    });
+    (0, node_child_process_1.spawnSync)("systemctl", ["--user", "disable", `${constants_1.SYSTEMD_AUTO_UPDATE_SERVICE}.timer`], {
+        encoding: "utf-8",
+        timeout: 30_000,
+    });
+    (0, node_child_process_1.spawnSync)("systemctl", ["--user", "stop", `${constants_1.SYSTEMD_AUTO_UPDATE_SERVICE}.service`], {
+        encoding: "utf-8",
+        timeout: 30_000,
+    });
+    try {
+        fs.unlinkSync(timerPath());
+    }
+    catch {
+        /* skip */
+    }
+    try {
+        fs.unlinkSync(servicePath());
+    }
+    catch {
+        /* skip */
+    }
+    (0, node_child_process_1.spawnSync)("systemctl", ["--user", "daemon-reload"], {
+        encoding: "utf-8",
+        timeout: 30_000,
+    });
+}
+function statusLinuxAutoUpdateTimer() {
+    const unitFile = fs.existsSync(timerPath());
+    if (!systemctlAvailable()) {
+        return { unitFile, timerEnabled: false, timerActive: false };
+    }
+    const is = (0, node_child_process_1.spawnSync)("systemctl", ["--user", "is-enabled", `${constants_1.SYSTEMD_AUTO_UPDATE_SERVICE}.timer`], { encoding: "utf-8" });
+    const ac = (0, node_child_process_1.spawnSync)("systemctl", ["--user", "is-active", `${constants_1.SYSTEMD_AUTO_UPDATE_SERVICE}.timer`], { encoding: "utf-8" });
+    return {
+        unitFile,
+        timerEnabled: (is.stdout || "").trim() === "enabled",
+        timerActive: (ac.stdout || "").trim() === "active",
+    };
+}

package/dist/autostart/macPathEnv.d.ts

@@ -0,0 +1,5 @@
+/**
+ * PATH string for LaunchAgents: merge install-time PATH with standard macOS paths
+ * so nvm/Homebrew `node` / `npm` remain reachable under launchd.
+ */
+export declare function macLaunchdEffectivePath(installTimePath: string | undefined): string;

package/dist/autostart/macPathEnv.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.macLaunchdEffectivePath = macLaunchdEffectivePath;
+/**
+ * PATH string for LaunchAgents: merge install-time PATH with standard macOS paths
+ * so nvm/Homebrew `node` / `npm` remain reachable under launchd.
+ */
+function macLaunchdEffectivePath(installTimePath) {
+    const trimmed = (installTimePath || "").trim();
+    const standardMacosPaths = "/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/homebrew/bin";
+    if (!trimmed)
+        return standardMacosPaths;
+    const seen = new Set();
+    const merged = [];
+    for (const seg of [...trimmed.split(":"), ...standardMacosPaths.split(":")]) {
+        const s = seg.trim();
+        if (s && !seen.has(s)) {
+            seen.add(s);
+            merged.push(s);
+        }
+    }
+    return merged.join(":");
+}

package/dist/autostart/manifest.d.ts

@@ -0,0 +1,11 @@
+import type { AutostartAgentOptions } from "./resolve";
+export interface AutostartManifestV1 {
+    version: 1;
+    installedAt: string;
+    platform: NodeJS.Platform;
+    options: AutostartAgentOptions;
+}
+export declare function manifestPath(dataDir: string): string;
+export declare function writeManifest(dataDir: string, options: AutostartAgentOptions): void;
+export declare function readManifest(dataDir: string): AutostartManifestV1 | null;
+export declare function removeManifest(dataDir: string): void;

package/dist/autostart/manifest.js

@@ -0,0 +1,74 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manifestPath = manifestPath;
+exports.writeManifest = writeManifest;
+exports.readManifest = readManifest;
+exports.removeManifest = removeManifest;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const constants_1 = require("./constants");
+function manifestPath(dataDir) {
+    return path.join(dataDir, constants_1.AUTOSTART_MANIFEST);
+}
+function writeManifest(dataDir, options) {
+    fs.mkdirSync(dataDir, { recursive: true });
+    const m = {
+        version: 1,
+        installedAt: new Date().toISOString(),
+        platform: process.platform,
+        options,
+    };
+    fs.writeFileSync(manifestPath(dataDir), JSON.stringify(m, null, 2), "utf8");
+}
+function readManifest(dataDir) {
+    try {
+        const p = manifestPath(dataDir);
+        if (!fs.existsSync(p))
+            return null;
+        return JSON.parse(fs.readFileSync(p, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+function removeManifest(dataDir) {
+    try {
+        fs.unlinkSync(manifestPath(dataDir));
+    }
+    catch {
+        /* skip */
+    }
+}

package/dist/autostart/quote.d.ts

@@ -0,0 +1,12 @@
+/** systemd ExecStart= token quoting (POSIX shell single-quote style). */
+export declare function systemdQuote(arg: string): string;
+export declare function systemdExecLine(argv: string[]): string;
+/**
+ * Windows argv → one command-line string for CreateProcess / WScript.Shell.Run /
+ * schtasks /tr, using MSDN CommandLineToArgvW-compatible quoting.
+ * Paths with spaces are quoted correctly; backslashes are never doubled unless
+ * they immediately precede a double-quote character.
+ */
+export declare function argvToWin32CommandLine(args: string[]): string;
+/** Escape single quotes for PowerShell single-quoted strings ('' → literal '). */
+export declare function escapePsSingle(s: string): string;