@bridge_gpt/mcp-server 0.2.49 → 0.2.51

package/build/scheduler-backends/launchd.js

@@ -1,225 +0,0 @@
-/**
- * macOS launchd backend (BAPI-327).
- *
- * Generates and installs a one-shot LaunchAgent plist that fires the baked
- * Claude invocation at a single calendar minute via `StartCalendarInterval`.
- *
- * Drift policy: the plist omits `RunAtLoad` as defense-in-depth (it avoids an
- * immediate run when the agent is reloaded at login), but this is NOT a true
- * no-late-fire guarantee — launchd still fires a missed `StartCalendarInterval`
- * event on the next wake. Unlike systemd `Persistent=false` / Task Scheduler,
- * launchd has no OS-level "skip if missed" knob, so the authoritative staleness
- * guard is the baked `--scheduled-at <T>` value in the prompt, which
- * `/full-automation` (Phase C) checks before running. The working directory is
- * set by the `WorkingDirectory` key, not a Claude flag. `ProgramArguments` is a
- * string array (no shell concatenation).
- */
-import { promises as fs } from "node:fs";
-import { pathApiForPlatform } from "./types.js";
-import { bakedEnvFromCreateInput, bakedEnvEntries, xmlEscape } from "./escaping.js";
-/** launchd label for a NEW schedule id (neutral, generic schedule-run naming). */
-export function launchdLabelForId(id) {
-    return `com.bridge-gpt.schedule-run.${id}`;
-}
-/**
- * Resolve the launchd label for an existing schedule, preferring the label baked
- * into the recorded plist path so legacy `com.bridge-gpt.full-automation.<id>`
- * schedules remain list/cancel compatible after the neutral-naming change.
- */
-export function launchdLabelForMetadata(metadata) {
-    const unitPath = metadata.unit_path;
-    if (unitPath && unitPath.endsWith(".plist")) {
-        const base = unitPath.split(/[\\/]/).pop();
-        if (base)
-            return base.slice(0, -".plist".length);
-    }
-    return launchdLabelForId(metadata.id);
-}
-/** `~/Library/LaunchAgents/<label>.plist` for a schedule id. */
-export function launchdPlistPathForId(id, homeDir) {
-    const pathApi = pathApiForPlatform("darwin");
-    return pathApi.join(homeDir, "Library", "LaunchAgents", `${launchdLabelForId(id)}.plist`);
-}
-/** Convert an ISO timestamp to local launchd calendar fields (minute precision). */
-export function startCalendarIntervalFromIso(runAtIso) {
-    const date = new Date(runAtIso);
-    return {
-        Year: date.getFullYear(),
-        Month: date.getMonth() + 1, // launchd months are 1-12
-        Day: date.getDate(),
-        Hour: date.getHours(),
-        Minute: date.getMinutes(),
-    };
-}
-/** UID used by `launchctl` domain targets; falls back to the process UID. */
-function resolveUid(deps) {
-    const fromEnv = deps.env.UID;
-    if (fromEnv && /^\d+$/.test(fromEnv))
-        return fromEnv;
-    const procUid = typeof process.getuid === "function" ? process.getuid() : undefined;
-    return procUid !== undefined ? String(procUid) : "501";
-}
-/** Render a valid one-shot launchd plist. */
-export function renderLaunchdPlist(input) {
-    const label = launchdLabelForId(input.id);
-    const cal = startCalendarIntervalFromIso(input.runAtIso);
-    const env = bakedEnvEntries(bakedEnvFromCreateInput(input));
-    // The OS unit runs the Node execution shim (trigger invocation), which then
-    // spawns the stored agent invocation and records run-history events.
-    const programArgs = [input.triggerInvocation.exe, ...input.triggerInvocation.args]
-        .map((arg) => `    <string>${xmlEscape(arg)}</string>`)
-        .join("\n");
-    const envEntries = env
-        .map(([key, value]) => `    <key>${xmlEscape(key)}</key>\n    <string>${xmlEscape(value)}</string>`)
-        .join("\n");
-    // No run-at-load key (defense-in-depth: avoids an immediate run on agent
-    // reload). This does NOT stop a missed StartCalendarInterval from firing on
-    // wake — staleness is enforced by `/full-automation --scheduled-at` (Phase C).
-    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>${xmlEscape(label)}</string>`,
-        "  <key>StartCalendarInterval</key>",
-        "  <dict>",
-        `    <key>Year</key><integer>${cal.Year}</integer>`,
-        `    <key>Month</key><integer>${cal.Month}</integer>`,
-        `    <key>Day</key><integer>${cal.Day}</integer>`,
-        `    <key>Hour</key><integer>${cal.Hour}</integer>`,
-        `    <key>Minute</key><integer>${cal.Minute}</integer>`,
-        "  </dict>",
-        "  <key>EnvironmentVariables</key>",
-        "  <dict>",
-        envEntries,
-        "  </dict>",
-        "  <key>ProgramArguments</key>",
-        "  <array>",
-        programArgs,
-        "  </array>",
-        "  <key>WorkingDirectory</key>",
-        `  <string>${xmlEscape(input.repoPath)}</string>`,
-        "  <key>StandardOutPath</key>",
-        `  <string>${xmlEscape(input.paths.stdoutPath)}</string>`,
-        "  <key>StandardErrorPath</key>",
-        `  <string>${xmlEscape(input.paths.stderrPath)}</string>`,
-        "</dict>",
-        "</plist>",
-        "",
-    ].join("\n");
-}
-/** Create the macOS launchd scheduler backend. */
-export function createLaunchdBackend() {
-    return {
-        name: "launchd",
-        async isAvailable(deps) {
-            return deps.platform === "darwin";
-        },
-        async create(input) {
-            const plistPath = launchdPlistPathForId(input.id, input.deps.homeDir);
-            const content = renderLaunchdPlist(input);
-            const artifact = { path: plistPath, content, kind: "launchd-plist" };
-            if (input.dryRun) {
-                return {
-                    ok: true,
-                    backend: "launchd",
-                    unitPath: plistPath,
-                    unitPaths: [plistPath],
-                    backendJobId: null,
-                    artifacts: [artifact],
-                };
-            }
-            // ~/Library/LaunchAgents may not exist yet for a fresh user account.
-            await fs.mkdir(pathApiForPlatform("darwin").dirname(plistPath), { recursive: true });
-            await fs.writeFile(plistPath, content, "utf-8");
-            const uid = resolveUid(input.deps);
-            const result = await input.deps.runCommand("launchctl", [
-                "bootstrap",
-                `gui/${uid}`,
-                plistPath,
-            ]);
-            if (result.exitCode !== 0) {
-                // Don't leave an orphaned plist behind when bootstrap fails.
-                await fs.unlink(plistPath).catch(() => undefined);
-                return {
-                    ok: false,
-                    backend: "launchd",
-                    unitPath: plistPath,
-                    unitPaths: [plistPath],
-                    backendJobId: null,
-                    artifacts: [artifact],
-                    error: `launchctl bootstrap failed: ${(result.stderr || result.stdout).trim()}`,
-                };
-            }
-            return {
-                ok: true,
-                backend: "launchd",
-                unitPath: plistPath,
-                unitPaths: [plistPath],
-                backendJobId: null,
-                artifacts: [artifact],
-            };
-        },
-        async list(input) {
-            const uid = resolveUid(input.deps);
-            const entries = [];
-            for (const metadata of input.recorded) {
-                const plistPath = metadata.unit_path ?? launchdPlistPathForId(metadata.id, input.deps.homeDir);
-                let exists = true;
-                try {
-                    await fs.access(plistPath);
-                }
-                catch {
-                    exists = false;
-                }
-                if (!exists) {
-                    entries.push({ metadata, status: "stale", detail: "plist missing" });
-                    continue;
-                }
-                const label = launchdLabelForMetadata(metadata);
-                const printed = await input.deps.runCommand("launchctl", ["print", `gui/${uid}/${label}`]);
-                entries.push({
-                    metadata,
-                    status: printed.exitCode === 0 ? "active" : "stale",
-                    detail: printed.exitCode === 0 ? "loaded" : "plist present but not loaded",
-                });
-            }
-            return entries;
-        },
-        async cancel(input) {
-            const uid = resolveUid(input.deps);
-            const label = launchdLabelForMetadata(input.metadata);
-            const plistPath = input.metadata.unit_path ?? launchdPlistPathForId(input.metadata.id, input.deps.homeDir);
-            let plistExisted = true;
-            try {
-                await fs.access(plistPath);
-            }
-            catch {
-                plistExisted = false;
-            }
-            // bootout is best-effort: an already-unloaded label returns non-zero, which
-            // is treated as stale-but-cancelable rather than a hard failure.
-            const bootout = await input.deps.runCommand("launchctl", [
-                "bootout",
-                `gui/${uid}/${label}`,
-            ]);
-            if (plistExisted) {
-                try {
-                    await fs.unlink(plistPath);
-                }
-                catch (error) {
-                    if (error.code !== "ENOENT") {
-                        return { ok: false, nativeRemoved: false, stale: false, error: String(error) };
-                    }
-                }
-            }
-            const nativeRemoved = bootout.exitCode === 0;
-            return {
-                ok: true,
-                nativeRemoved,
-                stale: !plistExisted || !nativeRemoved,
-            };
-        },
-    };
-}

package/build/scheduler-backends/systemd-user.js

@@ -1,250 +0,0 @@
-/**
- * Linux systemd-user backend (BAPI-327, primary Linux scheduler).
- *
- * Generates a `.service` + `.timer` pair under `~/.config/systemd/user/` and
- * installs them with `systemctl --user`. The timer fires once via
- * `OnCalendar=<run_at_iso>`.
- *
- * Drift policy: `Persistent=false` gives a real OS-level no-catch-up guarantee —
- * a run missed during downtime is dropped, not fired late on next boot/login.
- * (launchd and `at` cannot guarantee this; the cross-backend staleness guard is
- * the baked `--scheduled-at <T>` value checked by `/full-automation` in Phase C.)
- * Working directory is set by the service's `WorkingDirectory=` directive, never
- * via a shell `cd` in ExecStart and never a Claude `--cwd` flag.
- */
-import { promises as fs } from "node:fs";
-import { pathApiForPlatform } from "./types.js";
-import { bakedEnvFromCreateInput, bakedEnvEntries, systemdQuote } from "./escaping.js";
-/** Return the unit names for a NEW schedule id (neutral schedule-run naming). */
-export function systemdUnitNamesForId(id) {
-    return {
-        service: `bridge-gpt-schedule-run-${id}.service`,
-        timer: `bridge-gpt-schedule-run-${id}.timer`,
-    };
-}
-/** Return the unit file paths for a schedule id. */
-export function systemdUnitPathsForId(id, homeDir) {
-    const pathApi = pathApiForPlatform("linux");
-    const dir = pathApi.join(homeDir, ".config", "systemd", "user");
-    const names = systemdUnitNamesForId(id);
-    return {
-        service: pathApi.join(dir, names.service),
-        timer: pathApi.join(dir, names.timer),
-    };
-}
-/**
- * Resolve unit names + paths for an EXISTING schedule, preferring the names baked
- * into the recorded unit paths so legacy `bridge-gpt-full-automation-<id>` units
- * remain list/cancel compatible after the neutral-naming change.
- */
-export function systemdUnitsForMetadata(metadata, homeDir) {
-    const timerPath = metadata.unit_path && metadata.unit_path.endsWith(".timer") ? metadata.unit_path : undefined;
-    const servicePath = (metadata.unit_paths ?? []).find((p) => p.endsWith(".service"));
-    if (timerPath && servicePath) {
-        const basename = (p) => p.split(/[\\/]/).pop();
-        return {
-            names: { service: basename(servicePath), timer: basename(timerPath) },
-            paths: { service: servicePath, timer: timerPath },
-        };
-    }
-    return {
-        names: systemdUnitNamesForId(metadata.id),
-        paths: systemdUnitPathsForId(metadata.id, homeDir),
-    };
-}
-/** Render the systemd service unit. */
-export function renderSystemdService(input) {
-    const env = bakedEnvEntries(bakedEnvFromCreateInput(input));
-    const envLines = env
-        .map(([key, value]) => `Environment=${key}=${systemdQuote(value)}`)
-        .join("\n");
-    // ExecStart runs the Node execution shim (trigger invocation); the shim spawns
-    // the stored agent invocation and records run-history events.
-    const execStart = [input.triggerInvocation.exe, ...input.triggerInvocation.args]
-        .map((part) => systemdQuote(part))
-        .join(" ");
-    return [
-        "[Unit]",
-        `Description=Bridge GPT schedule-run one-shot (${input.id}: ${input.command})`,
-        "",
-        "[Service]",
-        "Type=oneshot",
-        envLines,
-        `WorkingDirectory=${systemdQuote(input.repoPath)}`,
-        `ExecStart=${execStart}`,
-        `StandardOutput=append:${input.paths.stdoutPath}`,
-        `StandardError=append:${input.paths.stderrPath}`,
-        "",
-    ].join("\n");
-}
-/**
- * Render an `OnCalendar` value systemd actually accepts. systemd's calendar
- * grammar is `YYYY-MM-DD HH:MM:SS` with an optional timezone token — it does NOT
- * accept the ISO `T` separator, fractional seconds, or a bare `Z`, so emitting
- * `run_at_iso` verbatim makes `systemd-analyze calendar` reject the unit and the
- * timer silently never fires. Render from the UTC fields (host-timezone
- * independent) and append the `UTC` token.
- */
-export function formatSystemdOnCalendar(runAtIso) {
-    const d = new Date(runAtIso);
-    const pad = (n) => String(n).padStart(2, "0");
-    const date = `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())}`;
-    const time = `${pad(d.getUTCHours())}:${pad(d.getUTCMinutes())}:${pad(d.getUTCSeconds())}`;
-    return `${date} ${time} UTC`;
-}
-/** Render the systemd timer unit. */
-export function renderSystemdTimer(input) {
-    const names = systemdUnitNamesForId(input.id);
-    return [
-        "[Unit]",
-        `Description=Bridge GPT schedule-run one-shot timer (${input.id}: ${input.command})`,
-        "",
-        "[Timer]",
-        `OnCalendar=${formatSystemdOnCalendar(input.runAtIso)}`,
-        // Drift policy: a missed run must NOT fire late on next boot.
-        "Persistent=false",
-        `Unit=${names.service}`,
-        "",
-        "[Install]",
-        "WantedBy=timers.target",
-        "",
-    ].join("\n");
-}
-/** Whether `systemctl --user` is usable (used by isAvailable). */
-async function systemctlUserUsable(deps) {
-    const probe = await deps.runCommand("systemctl", ["--user", "--version"]);
-    return probe.exitCode === 0;
-}
-/** Create the Linux systemd-user backend. */
-export function createSystemdUserBackend() {
-    return {
-        name: "systemd-user",
-        async isAvailable(deps) {
-            if (deps.platform !== "linux")
-                return false;
-            return systemctlUserUsable(deps);
-        },
-        async create(input) {
-            const paths = systemdUnitPathsForId(input.id, input.deps.homeDir);
-            const names = systemdUnitNamesForId(input.id);
-            const serviceContent = renderSystemdService(input);
-            const timerContent = renderSystemdTimer(input);
-            const artifacts = [
-                { path: paths.service, content: serviceContent, kind: "systemd-service" },
-                { path: paths.timer, content: timerContent, kind: "systemd-timer" },
-            ];
-            const unitPaths = [paths.service, paths.timer];
-            if (input.dryRun) {
-                return {
-                    ok: true,
-                    backend: "systemd-user",
-                    unitPath: paths.timer,
-                    unitPaths,
-                    backendJobId: names.timer,
-                    artifacts,
-                };
-            }
-            const pathApi = pathApiForPlatform("linux");
-            await fs.mkdir(pathApi.dirname(paths.service), { recursive: true });
-            await fs.writeFile(paths.service, serviceContent, "utf-8");
-            await fs.writeFile(paths.timer, timerContent, "utf-8");
-            // Remove the orphaned unit files if a systemctl step fails.
-            const cleanupUnitFiles = async () => {
-                await fs.unlink(paths.timer).catch(() => undefined);
-                await fs.unlink(paths.service).catch(() => undefined);
-            };
-            const reload = await input.deps.runCommand("systemctl", ["--user", "daemon-reload"]);
-            if (reload.exitCode !== 0) {
-                await cleanupUnitFiles();
-                return {
-                    ok: false,
-                    backend: "systemd-user",
-                    unitPath: paths.timer,
-                    unitPaths,
-                    backendJobId: names.timer,
-                    artifacts,
-                    error: `systemctl --user daemon-reload failed: ${(reload.stderr || reload.stdout).trim()}`,
-                };
-            }
-            const enable = await input.deps.runCommand("systemctl", [
-                "--user",
-                "enable",
-                "--now",
-                names.timer,
-            ]);
-            if (enable.exitCode !== 0) {
-                await cleanupUnitFiles();
-                return {
-                    ok: false,
-                    backend: "systemd-user",
-                    unitPath: paths.timer,
-                    unitPaths,
-                    backendJobId: names.timer,
-                    artifacts,
-                    error: `systemctl --user enable --now failed: ${(enable.stderr || enable.stdout).trim()}`,
-                };
-            }
-            return {
-                ok: true,
-                backend: "systemd-user",
-                unitPath: paths.timer,
-                unitPaths,
-                backendJobId: names.timer,
-                artifacts,
-            };
-        },
-        async list(input) {
-            const entries = [];
-            for (const metadata of input.recorded) {
-                const { paths, names } = systemdUnitsForMetadata(metadata, input.deps.homeDir);
-                let timerExists = true;
-                try {
-                    await fs.access(paths.timer);
-                }
-                catch {
-                    timerExists = false;
-                }
-                if (!timerExists) {
-                    entries.push({ metadata, status: "stale", detail: "timer unit file missing" });
-                    continue;
-                }
-                const status = await input.deps.runCommand("systemctl", ["--user", "status", names.timer]);
-                if (status.exitCode === 0) {
-                    entries.push({ metadata, status: "active", detail: "timer active" });
-                }
-                else if (status.exitCode === 3) {
-                    // exit 3 = unit known but inactive; still registered, treat as stale.
-                    entries.push({ metadata, status: "stale", detail: "timer inactive" });
-                }
-                else {
-                    entries.push({ metadata, status: "backend-unavailable", detail: "systemctl unavailable" });
-                }
-            }
-            return entries;
-        },
-        async cancel(input) {
-            const { paths, names } = systemdUnitsForMetadata(input.metadata, input.deps.homeDir);
-            const disable = await input.deps.runCommand("systemctl", [
-                "--user",
-                "disable",
-                "--now",
-                names.timer,
-            ]);
-            let removedAny = false;
-            for (const unitPath of [paths.timer, paths.service]) {
-                try {
-                    await fs.unlink(unitPath);
-                    removedAny = true;
-                }
-                catch (error) {
-                    if (error.code !== "ENOENT") {
-                        return { ok: false, nativeRemoved: false, stale: false, error: String(error) };
-                    }
-                }
-            }
-            await input.deps.runCommand("systemctl", ["--user", "daemon-reload"]);
-            const nativeRemoved = disable.exitCode === 0 || removedAny;
-            return { ok: true, nativeRemoved, stale: disable.exitCode !== 0 };
-        },
-    };
-}