@bridge_gpt/mcp-server 0.2.49 → 0.2.51

package/build/schedule-store.js

@@ -1,172 +0,0 @@
-/**
- * Local-only schedule metadata storage (BAPI-327).
- *
- * Schedules live entirely under `~/.bridge-gpt/schedules/` on the user's machine
- * and are NEVER mirrored to the Bridge server. One pretty-printed JSON file per
- * schedule id holds the metadata; stdout/stderr land in `logs/<id>.{out,err}`.
- *
- * All paths are rooted at the injected `homeDir` (never `os.homedir()` directly)
- * and built with the platform path API, so the store is fully unit-testable for
- * any OS from any host and never touches the real home directory in tests.
- */
-import { promises as fs } from "node:fs";
-import { pathApiForPlatform } from "./scheduler-backends/types.js";
-/** Upper bound on retained run-history events per schedule (oldest dropped). */
-export const MAX_RUN_HISTORY_EVENTS = 50;
-/** Monotonic suffix source for atomic temp files (avoids same-tick collisions). */
-let atomicWriteCounter = 0;
-/**
- * Build the schedule root from the injected home directory and platform path
- * API: `~/.bridge-gpt/schedules` on POSIX, `%USERPROFILE%\.bridge-gpt\schedules`
- * on Windows.
- */
-export function getScheduleRoot(homeDir, platform) {
-    const pathApi = pathApiForPlatform(platform);
-    return pathApi.join(homeDir, ".bridge-gpt", "schedules");
-}
-/** Return the metadata + log paths for a schedule id under the schedule root. */
-export function getSchedulePaths(id, homeDir, platform) {
-    const pathApi = pathApiForPlatform(platform);
-    const schedulesDir = getScheduleRoot(homeDir, platform);
-    const logsDir = pathApi.join(schedulesDir, "logs");
-    return {
-        schedulesDir,
-        logsDir,
-        metadataPath: pathApi.join(schedulesDir, `${id}.json`),
-        stdoutPath: pathApi.join(logsDir, `${id}.out`),
-        stderrPath: pathApi.join(logsDir, `${id}.err`),
-    };
-}
-/**
- * Create only the schedules directory and the logs directory. Must NOT be called
- * by dry-run code paths — dry-run never touches the filesystem.
- */
-export async function ensureScheduleDirectories(homeDir, platform) {
-    const pathApi = pathApiForPlatform(platform);
-    const schedulesDir = getScheduleRoot(homeDir, platform);
-    const logsDir = pathApi.join(schedulesDir, "logs");
-    await fs.mkdir(schedulesDir, { recursive: true });
-    await fs.mkdir(logsDir, { recursive: true });
-}
-/**
- * Persist one pretty-printed JSON file per schedule id with a trailing newline.
- * Called only AFTER the scheduler backend successfully creates the unit/job.
- *
- * The write is atomic (BAPI-351): the content is written to a temp file in the
- * same directory and renamed into place, so a concurrent `_execute` run-history
- * append never observes a partially-written metadata file, and a crash mid-write
- * leaves the prior valid file intact rather than a truncated one.
- */
-export async function writeScheduleMetadata(metadata, homeDir, platform) {
-    const { metadataPath } = getSchedulePaths(metadata.id, homeDir, platform);
-    const content = `${JSON.stringify(metadata, null, 2)}\n`;
-    const tmpPath = `${metadataPath}.tmp-${process.pid}-${atomicWriteCounter++}`;
-    try {
-        await fs.writeFile(tmpPath, content, "utf-8");
-        await fs.rename(tmpPath, metadataPath);
-    }
-    catch (error) {
-        // Best-effort cleanup of the temp file; never leave it orphaned, and never
-        // partially overwrite the real metadata file.
-        await fs.unlink(tmpPath).catch(() => undefined);
-        throw error;
-    }
-}
-/**
- * Append a bounded run-history event to a schedule's metadata and rewrite it
- * atomically (BAPI-351). Tolerant of legacy records that have no `run_history`
- * (initializes it). Returns the updated metadata, or `null` if the schedule
- * metadata no longer exists.
- */
-export async function appendScheduleRunEvent(id, event, homeDir, platform) {
-    const metadata = await readScheduleMetadata(id, homeDir, platform);
-    if (!metadata)
-        return null;
-    const history = Array.isArray(metadata.run_history) ? [...metadata.run_history] : [];
-    history.push(event);
-    // Keep the newest events when bounding (drop from the front).
-    metadata.run_history =
-        history.length > MAX_RUN_HISTORY_EVENTS
-            ? history.slice(history.length - MAX_RUN_HISTORY_EVENTS)
-            : history;
-    await writeScheduleMetadata(metadata, homeDir, platform);
-    return metadata;
-}
-/** Read and parse a single schedule metadata JSON file; `null` when missing. */
-export async function readScheduleMetadata(id, homeDir, platform) {
-    const { metadataPath } = getSchedulePaths(id, homeDir, platform);
-    let raw;
-    try {
-        raw = await fs.readFile(metadataPath, "utf-8");
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return null;
-        throw error;
-    }
-    return JSON.parse(raw);
-}
-/**
- * Read every `*.json` metadata file from the schedule root. Malformed JSON is
- * surfaced as a controlled parse-error row (never silently swallowed); a missing
- * schedule directory yields an empty list, but any other filesystem error
- * (e.g. EACCES) propagates rather than masquerading as "no schedules".
- */
-export async function listScheduleMetadata(homeDir, platform) {
-    const pathApi = pathApiForPlatform(platform);
-    const schedulesDir = getScheduleRoot(homeDir, platform);
-    let entries;
-    try {
-        entries = await fs.readdir(schedulesDir);
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return [];
-        throw error;
-    }
-    const rows = [];
-    for (const entry of entries.sort()) {
-        if (!entry.endsWith(".json"))
-            continue;
-        const id = entry.slice(0, -".json".length);
-        const fullPath = pathApi.join(schedulesDir, entry);
-        let raw;
-        try {
-            raw = await fs.readFile(fullPath, "utf-8");
-        }
-        catch (error) {
-            if (error.code === "ENOENT")
-                continue; // raced delete
-            throw error;
-        }
-        try {
-            const metadata = JSON.parse(raw);
-            rows.push({ ok: true, id, metadata, path: fullPath });
-        }
-        catch (error) {
-            rows.push({
-                ok: false,
-                id,
-                path: fullPath,
-                error: error instanceof Error ? error.message : String(error),
-            });
-        }
-    }
-    return rows;
-}
-/**
- * Delete the schedule metadata JSON file after a successful or stale cancel. The
- * local log files (`logs/<id>.out|.err`) are deliberately left in place for
- * post-run inspection.
- */
-export async function deleteScheduleMetadata(id, homeDir, platform) {
-    const { metadataPath } = getSchedulePaths(id, homeDir, platform);
-    try {
-        await fs.unlink(metadataPath);
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return;
-        throw error;
-    }
-}

package/build/scheduled-prompt.js

@@ -1,115 +0,0 @@
-import { schemaSupportsAutoFlag } from "./command-catalog.js";
-/** The fixed late-fire threshold, in seconds, shared by every scheduled run. */
-export const LATE_FIRE_THRESHOLD_SECONDS = 60;
-/**
- * Quote a single argument token for safe inclusion in the rendered prompt while
- * preserving its boundary. Simple tokens (alphanumerics plus a small set of
- * path/flag-safe punctuation) are left bare; anything containing whitespace or
- * prompt/markup-sensitive characters is wrapped in double quotes with embedded
- * double quotes escaped. This is prompt-token quoting, NOT shell quoting — no
- * shell ever sees these strings.
- */
-export function quotePromptToken(token) {
-    if (token === "")
-        return '""';
-    // Safe: letters, digits, and characters that never need quoting in a prompt
-    // (path separators, ISO-timestamp punctuation, flag dashes, etc.).
-    if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(token))
-        return token;
-    return `"${token.replace(/"/g, '\\"')}"`;
-}
-/**
- * Compute the augmented argv tokens the scheduled run delegates to the command:
- * the normalized `input.args`, plus (only where the command can parse them)
- * `--scheduled-at <ISO>` and `--auto`.
- *
- * `--scheduled-at` is appended for `full-automation` (legacy) and `epic-tick`
- * (BAPI-418), both of whose parsers accept it as a first-class argument. Every
- * other command rejects unrecognized flags and halts (e.g. `start-tickets` stops
- * on any unsupported flag), and the shared late-fire gate already embeds the
- * scheduled time — so injecting `--scheduled-at` into their argv would break an
- * otherwise `schedulable: true` command for no benefit.
- *
- * `--auto` is appended when auto-approve is set AND the command supports it (its
- * schema declares a boolean `--auto` flag, or it is `full-automation` / `epic-tick`).
- * It is never duplicated if already present in `input.args`.
- *
- * This is the SINGLE source of the delegated argv: both the rendered target
- * command line and the `$ARGUMENTS` body substitution derive from it, so the body
- * parse and the command line never disagree (e.g. `review-ticket`, which reads
- * `--auto` out of `$ARGUMENTS`, sees the same `--auto` the command line shows).
- */
-export function buildAugmentedArgs(input) {
-    const args = [...input.args];
-    // Commands whose parsers accept --scheduled-at as a first-class argument.
-    // epic-tick already accepts --scheduled-at (parseEpicTickArgs, cli.ts) so it
-    // receives the scheduled time as a structured arg for the late-fire decision,
-    // not just via the embedded gate text.
-    if (input.commandName === "full-automation" || input.commandName === "epic-tick") {
-        args.push("--scheduled-at", input.scheduledAt);
-    }
-    const supportsAuto = schemaSupportsAutoFlag(input.schema) ||
-        input.commandName === "full-automation" ||
-        input.commandName === "epic-tick";
-    const alreadyHasAuto = input.args.includes("--auto");
-    if (input.autoApprove && supportsAuto && !alreadyHasAuto) {
-        args.push("--auto");
-    }
-    return args;
-}
-/**
- * Render the delegated target command line as
- * `/<commandName> <augmented args...>` (see {@link buildAugmentedArgs}).
- */
-export function buildTargetCommandLine(input) {
-    const parts = [`/${input.commandName}`];
-    for (const arg of buildAugmentedArgs(input))
-        parts.push(quotePromptToken(arg));
-    return parts.join(" ");
-}
-/** Render only the fixed late-fire gate text (exposed for focused testing). */
-export function renderLateFireGate(scheduleId, scheduledAt, autoApprove) {
-    const lateAction = autoApprove
-        ? "explain that the run is firing late and then PROCEED with the command below (this schedule was created with auto-approve)."
-        : "explain that the run is firing late and then HALT WITHOUT EXECUTING the command below (this schedule was created without auto-approve, and a headless run must not proceed unconfirmed).";
-    return [
-        "## Scheduled-run drift gate",
-        "",
-        `This is an automated, headless scheduled run (schedule id: ${scheduleId}).`,
-        `It was scheduled to fire at ${scheduledAt}.`,
-        "",
-        `Before doing anything else, check how late this run is firing. If it is more than ${LATE_FIRE_THRESHOLD_SECONDS} seconds later than the scheduled time above, ${lateAction}`,
-        `If it is within ${LATE_FIRE_THRESHOLD_SECONDS} seconds of the scheduled time, proceed silently.`,
-        "",
-        "Then run the following command exactly as written:",
-    ].join("\n");
-}
-/**
- * Replace `$ARGUMENTS` in a command body with the safely-quoted, normalized
- * argument string. Every occurrence is replaced (commands often repeat the
- * placeholder in a title and a body line).
- */
-function replaceArgumentsPlaceholder(body, argString) {
-    return body.split("$ARGUMENTS").join(argString);
-}
-/**
- * Render the full scheduled-run prompt: gate + delegated command line + command
- * body (with `$ARGUMENTS` substituted). Deterministic for identical inputs.
- */
-export function renderScheduledPrompt(input) {
-    const gate = renderLateFireGate(input.scheduleId, input.scheduledAt, input.autoApprove);
-    const targetInput = {
-        commandName: input.commandName,
-        args: input.args,
-        scheduledAt: input.scheduledAt,
-        autoApprove: input.autoApprove,
-        schema: input.schema,
-    };
-    const targetCommandLine = buildTargetCommandLine(targetInput);
-    // `$ARGUMENTS` must match what the command line shows — including the appended
-    // `--scheduled-at` / `--auto` — so a body that re-parses `$ARGUMENTS` (e.g.
-    // review-ticket reading `--auto`) agrees with the rendered command line.
-    const argString = buildAugmentedArgs(targetInput).map(quotePromptToken).join(" ");
-    const body = replaceArgumentsPlaceholder(input.commandBody, argString);
-    return [gate, "", targetCommandLine, "", body].join("\n");
-}

package/build/scheduler-backends/at-fallback.js

@@ -1,139 +0,0 @@
-import { bakedEnvFromCreateInput, formatEnvExportsForGeneratedUnit, posixShellQuote, } from "./escaping.js";
-/** Virtual artifact path for the script piped to `at` (never written to disk). */
-export const AT_STDIN_ARTIFACT_PATH = "<at-stdin>";
-/** Convert an ISO timestamp to the `YYYYMMDDHHMM` form required by `at -t`. */
-export function formatAtTimestamp(runAtIso) {
-    const d = new Date(runAtIso);
-    const pad = (n) => String(n).padStart(2, "0");
-    return (`${d.getFullYear()}${pad(d.getMonth() + 1)}${pad(d.getDate())}` +
-        `${pad(d.getHours())}${pad(d.getMinutes())}`);
-}
-/** Render the script piped into `at`. */
-export function renderAtScript(input) {
-    const exports = formatEnvExportsForGeneratedUnit(bakedEnvFromCreateInput(input));
-    // The script runs the Node execution shim (trigger invocation); the shim spawns
-    // the stored agent invocation and records run-history events.
-    const command = [input.triggerInvocation.exe, ...input.triggerInvocation.args]
-        .map((part) => posixShellQuote(part))
-        .join(" ");
-    return [
-        "#!/bin/sh",
-        exports,
-        `cd ${posixShellQuote(input.repoPath)}`,
-        `${command} >>${posixShellQuote(input.paths.stdoutPath)} 2>>${posixShellQuote(input.paths.stderrPath)}`,
-        "",
-    ].join("\n");
-}
-/**
- * Parse an `at` job id from common stdout/stderr forms; `null` when absent.
- * Anchored to the start of a line so a stray earlier "job" word can't be
- * mistaken for the job line, and (defensively, should `at` ever print more than
- * one) the LAST `job <id> at …` line wins.
- */
-export function parseAtJobId(stdout, stderr) {
-    const combined = `${stdout}\n${stderr}`;
-    const matches = [...combined.matchAll(/^job\s+(\d+)\s+at\b/gim)];
-    return matches.length > 0 ? matches[matches.length - 1][1] : null;
-}
-/** Whether both `at` and `atq` resolve (used by isAvailable). */
-async function atToolsResolvable(deps) {
-    const at = await deps.runCommand("which", ["at"]);
-    if (at.exitCode !== 0)
-        return false;
-    const atq = await deps.runCommand("which", ["atq"]);
-    return atq.exitCode === 0;
-}
-/** Create the Linux `at` fallback backend. */
-export function createAtFallbackBackend() {
-    return {
-        name: "at-fallback",
-        async isAvailable(deps) {
-            if (deps.platform !== "linux")
-                return false;
-            return atToolsResolvable(deps);
-        },
-        async create(input) {
-            const script = renderAtScript(input);
-            const artifact = {
-                path: AT_STDIN_ARTIFACT_PATH,
-                content: script,
-                kind: "at-script",
-            };
-            if (input.dryRun) {
-                return {
-                    ok: true,
-                    backend: "at-fallback",
-                    unitPath: null,
-                    unitPaths: [],
-                    backendJobId: null,
-                    artifacts: [artifact],
-                };
-            }
-            const timestamp = formatAtTimestamp(input.runAtIso);
-            const result = await input.deps.runCommand("at", ["-t", timestamp], { input: script });
-            if (result.exitCode !== 0) {
-                return {
-                    ok: false,
-                    backend: "at-fallback",
-                    unitPath: null,
-                    unitPaths: [],
-                    backendJobId: null,
-                    artifacts: [artifact],
-                    error: `at scheduling failed: ${(result.stderr || result.stdout).trim()}`,
-                };
-            }
-            const jobId = parseAtJobId(result.stdout, result.stderr);
-            if (!jobId) {
-                return {
-                    ok: false,
-                    backend: "at-fallback",
-                    unitPath: null,
-                    unitPaths: [],
-                    backendJobId: null,
-                    artifacts: [artifact],
-                    error: "Could not parse an at job id from the scheduler output.",
-                };
-            }
-            return {
-                ok: true,
-                backend: "at-fallback",
-                unitPath: null,
-                unitPaths: [],
-                backendJobId: jobId,
-                artifacts: [artifact],
-            };
-        },
-        async list(input) {
-            const atq = await input.deps.runCommand("atq", []);
-            if (atq.exitCode !== 0) {
-                return input.recorded.map((metadata) => ({
-                    metadata,
-                    status: "backend-unavailable",
-                    detail: "atq unavailable",
-                }));
-            }
-            const liveJobIds = new Set(atq.stdout
-                .split(/\r?\n/)
-                .map((line) => line.trim().match(/^(\d+)\b/)?.[1])
-                .filter((id) => Boolean(id)));
-            return input.recorded.map((metadata) => {
-                const jobId = metadata.backend_job_id;
-                const active = jobId !== null && liveJobIds.has(jobId);
-                return {
-                    metadata,
-                    status: active ? "active" : "stale",
-                    detail: active ? `at job ${jobId}` : "at job not queued",
-                };
-            });
-        },
-        async cancel(input) {
-            const jobId = input.metadata.backend_job_id;
-            if (!jobId) {
-                return { ok: true, nativeRemoved: false, stale: true };
-            }
-            const result = await input.deps.runCommand("atrm", [jobId]);
-            const nativeRemoved = result.exitCode === 0;
-            return { ok: true, nativeRemoved, stale: !nativeRemoved };
-        },
-    };
-}

package/build/scheduler-backends/escaping.js

@@ -1,143 +0,0 @@
-/**
- * Escaping / quoting helpers shared by every scheduler backend (BAPI-327).
- *
- * Generated unit content is attacker-adjacent: idea-file paths, repo paths, and
- * prompts flow into plist XML, Windows `.cmd` wrappers, systemd unit directives,
- * and `at` heredoc scripts. Each target has a different quoting grammar, so each
- * gets a dedicated helper. Every helper first rejects NUL bytes — a NUL can
- * truncate a generated file mid-write and silently drop a security-relevant
- * suffix — via {@link assertNoNul}.
- */
-/**
- * All baked PATH-trap / schedule-context environment variable names, in a stable
- * order. Generalized in BAPI-351: the full-automation-specific `BRIDGE_GPT_CLAUDE`
- * became the agent-neutral `BRIDGE_GPT_AGENT_PATH`, and schedule-context vars
- * (`BRIDGE_GPT_SCHEDULE_ID`, `BRIDGE_GPT_COMMAND`, `BRIDGE_GPT_COMMAND_ARGS_JSON`)
- * were added. `BRIDGE_GPT_IDEA_FILE` is now legacy-only (baked only when present).
- */
-export const BAKED_ENV_VAR_NAMES = [
-    "PATH",
-    "BRIDGE_GPT_NODE",
-    "BRIDGE_GPT_NPX",
-    "BRIDGE_GPT_AGENT",
-    "BRIDGE_GPT_AGENT_PATH",
-    "BRIDGE_GPT_REPO_PATH",
-    "BRIDGE_GPT_SCHEDULE_ID",
-    "BRIDGE_GPT_COMMAND",
-    "BRIDGE_GPT_COMMAND_ARGS_JSON",
-];
-/**
- * Reject any generated value containing a NUL byte. NUL can prematurely
- * terminate a C-string when a unit file is parsed by the OS scheduler, silently
- * dropping the rest of the value. The `label` names the offending field so the
- * error is actionable.
- */
-export function assertNoNul(value, label) {
-    if (value.includes("\0")) {
-        throw new Error(`Refusing to generate scheduler content: ${label} contains a NUL byte, which is not allowed.`);
-    }
-}
-/** Escape a string for use inside a launchd plist `<string>` value. */
-export function xmlEscape(value) {
-    assertNoNul(value, "xml value");
-    return value
-        .replace(/&/g, "&amp;")
-        .replace(/</g, "&lt;")
-        .replace(/>/g, "&gt;")
-        .replace(/"/g, "&quot;")
-        .replace(/'/g, "&apos;");
-}
-/**
- * Quote a value as a single POSIX shell argument (single-quote form). Empty
- * strings and strings with spaces become a quoted token; embedded single quotes
- * use the canonical close/escape/reopen `'\''` form. Used by the `at` heredoc.
- */
-export function posixShellQuote(value) {
-    assertNoNul(value, "posix shell value");
-    if (value === "")
-        return "''";
-    return `'${value.replace(/'/g, "'\\''")}'`;
-}
-/**
- * Quote a value for a Windows command line (a single argument inside a `.cmd`
- * wrapper). Wraps in double quotes and escapes embedded double quotes the
- * cmd-compatible way. Always quoting keeps paths/prompts with spaces intact.
- */
-export function windowsCmdQuote(value) {
-    assertNoNul(value, "windows cmd value");
-    // Within double quotes, cmd treats "" as a literal quote.
-    return `"${value.replace(/"/g, '""')}"`;
-}
-/**
- * Escape a value to be assigned via `set "KEY=value"` in a `.cmd` wrapper. The
- * `set "KEY=..."` quoted form already neutralises `& | < > ^`, but a literal `%`
- * still triggers variable expansion, so it is doubled to `%%`. A double quote
- * would close the `set` quoting, so it is dropped/escaped to keep the line safe.
- */
-export function escapeWindowsCmdSetValue(value) {
-    assertNoNul(value, "windows cmd set value");
-    return value.replace(/%/g, "%%").replace(/"/g, "");
-}
-/**
- * Quote a value for a systemd unit directive (e.g. `ExecStart=`, `Environment=`,
- * `WorkingDirectory=`). systemd accepts double-quoted tokens with C-style
- * backslash escaping for embedded backslashes and quotes. Empty strings render
- * as an explicit empty quoted token.
- */
-export function systemdQuote(value) {
-    assertNoNul(value, "systemd value");
-    const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-    return `"${escaped}"`;
-}
-/**
- * Build the ordered baked PATH-trap + schedule-context env entries from explicit,
- * schedule-time values — never `process.env`. Each value is NUL-checked. This is
- * the single source every backend uses so the baked environment is consistent
- * across launchd / Task Scheduler / systemd / at. `BRIDGE_GPT_IDEA_FILE` is
- * appended only for the legacy full-automation path (when `ideaFile` is set).
- */
-export function bakedEnvEntries(env) {
-    const entries = [
-        ["PATH", env.envPath],
-        ["BRIDGE_GPT_NODE", env.nodePath],
-        ["BRIDGE_GPT_NPX", env.npxPath],
-        ["BRIDGE_GPT_AGENT", env.agent],
-        ["BRIDGE_GPT_AGENT_PATH", env.agentPath],
-        ["BRIDGE_GPT_REPO_PATH", env.repoPath],
-        ["BRIDGE_GPT_SCHEDULE_ID", env.scheduleId],
-        ["BRIDGE_GPT_COMMAND", env.command],
-        ["BRIDGE_GPT_COMMAND_ARGS_JSON", env.commandArgsJson],
-    ];
-    if (env.ideaFile !== undefined) {
-        entries.push(["BRIDGE_GPT_IDEA_FILE", env.ideaFile]);
-    }
-    for (const [key, value] of entries) {
-        assertNoNul(value, key);
-    }
-    return entries;
-}
-/** Build a {@link BakedEnv} from a generalized scheduler create input. */
-export function bakedEnvFromCreateInput(input) {
-    return {
-        envPath: input.envPath,
-        nodePath: input.nodePath,
-        npxPath: input.npxPath,
-        agent: input.agent,
-        agentPath: input.agentPath,
-        repoPath: input.repoPath,
-        scheduleId: input.id,
-        command: input.command,
-        commandArgsJson: JSON.stringify(input.args),
-        ideaFile: input.legacyIdeaFile,
-    };
-}
-/**
- * Render the baked env as POSIX `export KEY='value'` lines (used by the `at`
- * heredoc script). Values come only from {@link bakedEnvEntries}; no value is
- * ever read from the ambient process environment.
- */
-export function formatEnvExportsForGeneratedUnit(env) {
-    return bakedEnvEntries(env)
-        .map(([key, value]) => `export ${key}=${posixShellQuote(value)}`)
-        .join("\n");
-}

package/build/scheduler-backends/index.js

@@ -1,72 +0,0 @@
-import { createLaunchdBackend } from "./launchd.js";
-import { createTaskSchedulerBackend } from "./task-scheduler.js";
-import { createSystemdUserBackend } from "./systemd-user.js";
-import { createAtFallbackBackend } from "./at-fallback.js";
-export * from "./types.js";
-const LAUNCHD = createLaunchdBackend();
-const TASK_SCHEDULER = createTaskSchedulerBackend();
-const SYSTEMD_USER = createSystemdUserBackend();
-const AT_FALLBACK = createAtFallbackBackend();
-const SUPPORTED_PLATFORMS = ["darwin", "win32", "linux"];
-/** Controlled message for an unsupported `process.platform`. */
-export function unsupportedSchedulerPlatformMessage(platform) {
-    return (`Unsupported platform '${platform}'. schedule-run supports ` +
-        `${SUPPORTED_PLATFORMS.join(", ")}.`);
-}
-/** Return the backend instance for a specific name, or `null` when unknown. */
-export function getSchedulerBackendByName(name) {
-    switch (name) {
-        case "launchd":
-            return LAUNCHD;
-        case "task-scheduler":
-            return TASK_SCHEDULER;
-        case "systemd-user":
-            return SYSTEMD_USER;
-        case "at-fallback":
-            return AT_FALLBACK;
-        default:
-            return null;
-    }
-}
-/** Return the ordered candidate backends for a platform (or unsupported). */
-export function getSchedulerBackendsForPlatform(platform) {
-    switch (platform) {
-        case "darwin":
-            return { ok: true, backends: [LAUNCHD] };
-        case "win32":
-            return { ok: true, backends: [TASK_SCHEDULER] };
-        case "linux":
-            return { ok: true, backends: [SYSTEMD_USER, AT_FALLBACK] };
-        default:
-            return { ok: false, error: unsupportedSchedulerPlatformMessage(platform) };
-    }
-}
-/**
- * Select the scheduler backend for a create.
- *
- * For dry-run, return the platform's PRIMARY backend without probing tool
- * availability — previewing a unit must not depend on installed schedulers. For
- * real creates, return the first backend whose `isAvailable` resolves true
- * (Linux prefers systemd-user, then at-fallback). Returns a controlled error
- * (never throws) for unsupported platforms or when nothing is available.
- */
-export async function selectSchedulerBackend(deps, dryRun) {
-    const platformResult = getSchedulerBackendsForPlatform(deps.platform);
-    if (!platformResult.ok) {
-        return { ok: false, error: platformResult.error };
-    }
-    const candidates = platformResult.backends;
-    if (dryRun) {
-        return { ok: true, backend: candidates[0] };
-    }
-    for (const backend of candidates) {
-        if (await backend.isAvailable(deps)) {
-            return { ok: true, backend };
-        }
-    }
-    return {
-        ok: false,
-        error: `No available scheduler backend for platform '${deps.platform}'. ` +
-            `Tried: ${candidates.map((b) => b.name).join(", ")}.`,
-    };
-}