@bridge_gpt/mcp-server 0.2.49 → 0.2.50

package/build/scheduler-backends/task-scheduler.js

@@ -1,214 +0,0 @@
-/**
- * Windows Task Scheduler backend (BAPI-327).
- *
- * Generates a `.cmd` wrapper (baked PATH + env, `cd /D <repo>`, absolute Claude
- * invocation, stdout/stderr redirection) plus a Task Scheduler `.xml` definition,
- * and registers a one-shot task via `schtasks /Create /XML`.
- *
- * Why XML instead of `/SC ONCE /SD /ST`: the CLI `/SD` date is parsed in the
- * host's short-date locale, so a hard-coded `MM/DD/YYYY` fails on UK/DE/JP/etc.
- * machines. The XML `<StartBoundary>` is ISO-8601 and locale-independent.
- *
- * Drift policy: the generated XML omits the missed-start catch-up element (its
- * schema default is already off), giving a real OS-level no-catch-up guarantee —
- * a missed start never runs late. (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 handled only by `cd /D`
- * inside the wrapper.
- */
-import { promises as fs } from "node:fs";
-import { pathApiForPlatform } from "./types.js";
-import { bakedEnvFromCreateInput, bakedEnvEntries, escapeWindowsCmdSetValue, windowsCmdQuote, xmlEscape, } from "./escaping.js";
-/** Task Scheduler task name for a NEW schedule id (neutral schedule-run naming). */
-export function taskNameForId(id) {
-    return `BridgeGPT-ScheduleRun-${id}`;
-}
-/** `%USERPROFILE%\.bridge-gpt\schedules\<id>.cmd` wrapper path for a schedule id. */
-export function cmdWrapperPathForId(id, homeDir) {
-    const pathApi = pathApiForPlatform("win32");
-    return pathApi.join(homeDir, ".bridge-gpt", "schedules", `${id}.cmd`);
-}
-/** `%USERPROFILE%\.bridge-gpt\schedules\<id>.xml` task definition path. */
-export function taskXmlPathForId(id, homeDir) {
-    const pathApi = pathApiForPlatform("win32");
-    return pathApi.join(homeDir, ".bridge-gpt", "schedules", `${id}.xml`);
-}
-/**
- * Local ISO-8601 `<StartBoundary>` value (`YYYY-MM-DDTHH:MM:SS`, no `Z`). Task
- * Scheduler interprets a bare boundary as local time, preserving the prior
- * local-time scheduling semantics while staying locale-independent.
- */
-export function formatTaskSchedulerBoundary(runAtIso) {
-    const d = new Date(runAtIso);
-    const pad = (n) => String(n).padStart(2, "0");
-    return (`${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}` +
-        `T${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`);
-}
-/** Render the `.cmd` wrapper that the Task Scheduler task invokes. */
-export function renderWindowsCmdWrapper(input) {
-    const env = bakedEnvEntries(bakedEnvFromCreateInput(input));
-    const lines = ["@echo off"];
-    for (const [key, value] of env) {
-        if (key === "PATH") {
-            // Prepend the baked PATH while preserving the runtime PATH behind it.
-            lines.push(`set "PATH=${escapeWindowsCmdSetValue(value)};%PATH%"`);
-        }
-        else {
-            lines.push(`set "${key}=${escapeWindowsCmdSetValue(value)}"`);
-        }
-    }
-    lines.push(`cd /D ${windowsCmdQuote(input.repoPath)}`);
-    // The wrapper runs the Node execution shim (trigger invocation), not the agent
-    // binary directly; the shim spawns the stored agent invocation.
-    const command = [input.triggerInvocation.exe, ...input.triggerInvocation.args]
-        .map((part) => windowsCmdQuote(part))
-        .join(" ");
-    // Append stdout/stderr to the local schedule logs.
-    lines.push(`${command} 1>>${windowsCmdQuote(input.paths.stdoutPath)} 2>>${windowsCmdQuote(input.paths.stderrPath)}`);
-    lines.push("");
-    return lines.join("\r\n");
-}
-/**
- * Render a minimal one-shot Task Scheduler XML document. The single `TimeTrigger`
- * fires once at the ISO-8601 `<StartBoundary>`; the action runs the generated
- * `.cmd` wrapper. The `<Settings>` block intentionally does not enable the
- * missed-start catch-up option, so a missed start never runs late.
- */
-export function renderTaskSchedulerXml(input) {
-    const wrapperPath = cmdWrapperPathForId(input.id, input.deps.homeDir);
-    const boundary = formatTaskSchedulerBoundary(input.runAtIso);
-    return [
-        '<?xml version="1.0" encoding="UTF-16"?>',
-        '<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">',
-        "  <RegistrationInfo>",
-        `    <Description>${xmlEscape(`Bridge GPT schedule-run one-shot (${input.id}: ${input.command})`)}</Description>`,
-        "  </RegistrationInfo>",
-        "  <Triggers>",
-        "    <TimeTrigger>",
-        `      <StartBoundary>${xmlEscape(boundary)}</StartBoundary>`,
-        "      <Enabled>true</Enabled>",
-        "    </TimeTrigger>",
-        "  </Triggers>",
-        "  <Principals>",
-        '    <Principal id="Author">',
-        "      <LogonType>InteractiveToken</LogonType>",
-        "    </Principal>",
-        "  </Principals>",
-        "  <Settings>",
-        "    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>",
-        "    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>",
-        "    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>",
-        "    <Enabled>true</Enabled>",
-        "  </Settings>",
-        '  <Actions Context="Author">',
-        "    <Exec>",
-        `      <Command>${xmlEscape(wrapperPath)}</Command>`,
-        "    </Exec>",
-        "  </Actions>",
-        "</Task>",
-        "",
-    ].join("\r\n");
-}
-/** Whether `schtasks` is resolvable (used by isAvailable). */
-async function schtasksResolvable(deps) {
-    const probe = await deps.runCommand("where.exe", ["schtasks"]);
-    return probe.exitCode === 0;
-}
-/** Create the Windows Task Scheduler backend. */
-export function createTaskSchedulerBackend() {
-    return {
-        name: "task-scheduler",
-        async isAvailable(deps) {
-            if (deps.platform !== "win32")
-                return false;
-            return schtasksResolvable(deps);
-        },
-        async create(input) {
-            const wrapperPath = cmdWrapperPathForId(input.id, input.deps.homeDir);
-            const xmlPath = taskXmlPathForId(input.id, input.deps.homeDir);
-            const wrapperContent = renderWindowsCmdWrapper(input);
-            const xmlContent = renderTaskSchedulerXml(input);
-            const artifacts = [
-                { path: wrapperPath, content: wrapperContent, kind: "windows-cmd-wrapper" },
-                { path: xmlPath, content: xmlContent, kind: "task-scheduler-xml" },
-            ];
-            const taskName = taskNameForId(input.id);
-            const unitPaths = [wrapperPath, xmlPath];
-            if (input.dryRun) {
-                return {
-                    ok: true,
-                    backend: "task-scheduler",
-                    unitPath: wrapperPath,
-                    unitPaths,
-                    backendJobId: taskName,
-                    artifacts,
-                };
-            }
-            await fs.writeFile(wrapperPath, wrapperContent, "utf-8");
-            // schtasks /XML requires the definition file to be UTF-16 with a BOM.
-            await fs.writeFile(xmlPath, `${xmlContent}`, "utf16le");
-            const result = await input.deps.runCommand("schtasks", [
-                "/Create",
-                "/TN",
-                taskName,
-                "/XML",
-                xmlPath,
-                "/F",
-            ]);
-            if (result.exitCode !== 0) {
-                // Don't leave the orphaned wrapper + XML behind when registration fails.
-                await fs.unlink(wrapperPath).catch(() => undefined);
-                await fs.unlink(xmlPath).catch(() => undefined);
-                return {
-                    ok: false,
-                    backend: "task-scheduler",
-                    unitPath: wrapperPath,
-                    unitPaths,
-                    backendJobId: taskName,
-                    artifacts,
-                    error: `schtasks /Create failed: ${(result.stderr || result.stdout).trim()}`,
-                };
-            }
-            return {
-                ok: true,
-                backend: "task-scheduler",
-                unitPath: wrapperPath,
-                unitPaths,
-                backendJobId: taskName,
-                artifacts,
-            };
-        },
-        async list(input) {
-            const entries = [];
-            for (const metadata of input.recorded) {
-                const taskName = metadata.backend_job_id ?? taskNameForId(metadata.id);
-                const query = await input.deps.runCommand("schtasks", ["/Query", "/TN", taskName]);
-                entries.push({
-                    metadata,
-                    status: query.exitCode === 0 ? "active" : "stale",
-                    detail: query.exitCode === 0 ? "task registered" : "task not found",
-                });
-            }
-            return entries;
-        },
-        async cancel(input) {
-            const taskName = input.metadata.backend_job_id ?? taskNameForId(input.metadata.id);
-            const result = await input.deps.runCommand("schtasks", ["/Delete", "/TN", taskName, "/F"]);
-            // Remove the generated wrapper + XML definition; both are ENOENT-tolerant.
-            const wrapperPath = input.metadata.unit_path ?? cmdWrapperPathForId(input.metadata.id, input.deps.homeDir);
-            const xmlPath = taskXmlPathForId(input.metadata.id, input.deps.homeDir);
-            for (const artifactPath of [wrapperPath, xmlPath]) {
-                try {
-                    await fs.unlink(artifactPath);
-                }
-                catch (error) {
-                    if (error.code !== "ENOENT") {
-                        return { ok: false, nativeRemoved: result.exitCode === 0, stale: false, error: String(error) };
-                    }
-                }
-            }
-            const nativeRemoved = result.exitCode === 0;
-            return { ok: true, nativeRemoved, stale: !nativeRemoved };
-        },
-    };
-}

package/build/scheduler-backends/types.js

@@ -1,23 +0,0 @@
-/**
- * Shared contract for the cross-platform `schedule-run` scheduler backends
- * (BAPI-327 / Phase B of the Full Automation v1 epic, BAPI-325).
- *
- * Every OS-native backend (launchd, Task Scheduler, systemd-user, at-fallback)
- * implements the {@link SchedulerBackend} interface against an injected
- * {@link SchedulerBackendDeps} so the create/list/cancel logic is fully unit
- * testable without touching real schedulers, the filesystem, or the network.
- *
- * The design mirrors `start-tickets.ts`: a list-based {@link RunCommand} boundary
- * (`execFile`, never `shell: true`), `platform`/`env`/`cwd`/`homeDir`/`execPath`
- * captured as data, and an optional injectable clock for deterministic tests.
- */
-import path from "node:path";
-/**
- * Return the platform-appropriate Node path API: `path.win32` on Windows so
- * generated unit paths use backslashes, `path.posix` everywhere else. Using a
- * data-driven platform (not the ambient `process.platform`) keeps generation
- * deterministic and unit-testable for every OS from any host.
- */
-export function pathApiForPlatform(platform) {
-    return platform === "win32" ? path.win32 : path.posix;
-}