@hyperdrive.bot/fleet-server 0.3.99

package/dist/server/server/fleet/fleet-reader.js

@@ -0,0 +1,470 @@
+/**
+ * Fleet reader — wraps the super-repo autonomous "loop" fleet as read-only data.
+ *
+ * The loops keep running exactly as before: bash runners under
+ * `super-repo/tooling/loops/<name>/`, scheduled by the user crontab, writing state
+ * into `super-repo/_bmad-output/loops/`. This module ONLY reads that state so the
+ * daemon can surface each loop as a first-class "Loops" entity in Hyperpaseo.
+ *
+ * Internally the entity is namespaced `fleet` (paseo already has a "loop" entity —
+ * the Ralph worker/verifier — so the token `loop` is taken across protocol/server/cli).
+ * The UI still presents these as "Loops".
+ *
+ * Zero external deps (node builtins only) so it can run standalone for verification
+ * AND be imported by the daemon FleetService without pulling anything in.
+ */
+import { readdirSync, readFileSync, statSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { defaultSystemdUnitDir, PAUSE_MARKER, SystemdUserScheduler, } from "./fleet-scheduler.js";
+import { LoopParamsSchemaSchema, } from "@hyperdrive.bot/fleet-protocol/fleet/params";
+// PAUSE_MARKER lives in fleet-scheduler (the single owner of scheduler mechanics) and
+// is re-exported here for the existing cron callers.
+export { PAUSE_MARKER } from "./fleet-scheduler.js";
+const DATE_RE = /(\d{4}-\d{2}-\d{2})/;
+const TWO_DAYS_MS = 2 * 24 * 60 * 60 * 1000;
+// Hard-failure signatures only. Deliberately does NOT match the bare word
+// "error": the sentry loops' own gate summaries say "N error+fatal issues",
+// which is their normal domain output, not a loop failure.
+const ERROR_LINE_RE = /cmd failed|ETIMEDOUT|ECONNREFUSED|EAI_AGAIN|\bunauthorized\b|traceback|\bHALT\b|cannot find module|ENOENT|permission denied|throttlingexception/i;
+export function defaultFleetReaderConfig() {
+    const repo = process.env.PASEO_SUPERREPO ?? join(homedir(), "super-repo");
+    return {
+        loopsDir: process.env.PASEO_FLEET_LOOPS_DIR ?? join(repo, "tooling", "loops"),
+        stateDir: process.env.PASEO_FLEET_STATE_DIR ?? join(repo, "_bmad-output", "loops"),
+    };
+}
+// ---- fs helpers -------------------------------------------------------------
+function safeReaddir(dir) {
+    try {
+        return readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+}
+function safeRead(path) {
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+function safeStatMtime(path) {
+    try {
+        return statSync(path).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+}
+function safeJson(raw) {
+    if (!raw)
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+// ---- discovery + crontab ----------------------------------------------------
+/**
+ * Every filename that counts as a loop's entrypoint. Keep this list exhaustive: a loop
+ * whose runner is not listed here is scheduled and running but INVISIBLE in the Loops
+ * view, which reads identically to "no such loop". `ci-pipeline-fixer` is a node loop
+ * (`run.mjs`) and was invisible until it was added here.
+ */
+export const LOOP_RUNNER_FILENAMES = ["run.sh", "run-poll.sh", "run.mjs"];
+/** Directories that are scaffolding or shared code, never loops. */
+const NON_LOOP_DIRS = new Set(["template", "lib", "scripts"]);
+/** The loop's entrypoint file, or null when the directory has none. */
+export function findRunnerFile(dir) {
+    for (const filename of LOOP_RUNNER_FILENAMES) {
+        if (existsSync(join(dir, filename))) {
+            return filename;
+        }
+    }
+    return null;
+}
+/** Loop directories = subdirs of loopsDir holding a known runner, minus scaffolding. */
+export function discoverLoopDirs(loopsDir) {
+    const out = [];
+    for (const name of safeReaddir(loopsDir)) {
+        if (NON_LOOP_DIRS.has(name))
+            continue;
+        const dir = join(loopsDir, name);
+        try {
+            if (!statSync(dir).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        if (findRunnerFile(dir) !== null) {
+            out.push({ name, dir });
+        }
+    }
+    return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+function parseMode(line) {
+    if (/--live\b/.test(line))
+        return "live";
+    if (/--dry-run\b/.test(line))
+        return "dry-run";
+    return "unknown";
+}
+/** Parse `crontab -l` into name → {cadence, mode} by matching run(-poll).sh paths. */
+export function parseCrontab(crontab) {
+    const map = new Map();
+    for (const raw of crontab.split("\n")) {
+        const line = raw.trim();
+        if (!line)
+            continue;
+        const paused = line.startsWith(PAUSE_MARKER);
+        // A paused loop is a real cron line hidden behind the pause marker; any other
+        // comment is not a loop schedule and is skipped.
+        if (!paused && line.startsWith("#"))
+            continue;
+        const effective = paused ? line.slice(PAUSE_MARKER.length).trim() : line;
+        const m = effective.match(/tooling\/(?:loops\/)?([a-z0-9._-]+)\/run(?:-poll)?\.sh/i);
+        if (!m)
+            continue;
+        map.set(m[1], {
+            cadence: effective.split(/\s+/).slice(0, 5).join(" "),
+            mode: parseMode(effective),
+            paused,
+        });
+    }
+    return map;
+}
+function readCrontab() {
+    try {
+        return execFileSync("crontab", ["-l"], { encoding: "utf8" });
+    }
+    catch {
+        return "";
+    }
+}
+/** File names a loop uses to declare and store its parameters. */
+export const LOOP_PARAMS_SCHEMA_FILE = "params.schema.json";
+export const LOOP_PARAMS_VALUES_FILE = "params.json";
+/**
+ * A loop's declared parameters, when it ships one. A malformed declaration is treated
+ * as "no schema" rather than throwing: one bad file must not take the whole Loops list
+ * down, and the loop still renders with its schedule and health.
+ */
+export function readParamsSchema(dir) {
+    const raw = safeRead(join(dir, LOOP_PARAMS_SCHEMA_FILE));
+    if (raw === null)
+        return undefined;
+    try {
+        const parsed = LoopParamsSchemaSchema.safeParse(JSON.parse(raw));
+        return parsed.success ? parsed.data : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Current parameter values, if the loop has been configured. */
+export function readParams(dir) {
+    const raw = safeRead(join(dir, LOOP_PARAMS_VALUES_FILE));
+    if (raw === null)
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return parsed;
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+// ---- state readers ----------------------------------------------------------
+/** Pick the newest `<prefix>-<kind>-<date>.<ext>` file. */
+function latestDated(files, prefix, kind, ext) {
+    const want = `${prefix}-${kind}-`;
+    let best = null;
+    for (const f of files) {
+        if (!f.startsWith(want) || !f.endsWith(`.${ext}`))
+            continue;
+        const d = f.match(DATE_RE);
+        if (!d)
+            continue;
+        if (!best || d[1] > best.date)
+            best = { file: f, date: d[1] };
+    }
+    return best;
+}
+function countTsvRows(text) {
+    if (!text)
+        return 0;
+    return text.split("\n").filter((l) => l.trim().length > 0).length;
+}
+function toIso(v) {
+    if (v == null)
+        return undefined;
+    if (typeof v === "number")
+        return new Date(v).toISOString();
+    const n = Number(v);
+    if (!Number.isNaN(n) && v.length >= 10)
+        return new Date(n).toISOString();
+    return v;
+}
+function readSeenLedger(stateDir, statePrefix) {
+    return (safeJson(safeRead(join(stateDir, `${statePrefix}-seen.json`))) ?? {});
+}
+function readOpenFindings(stateDir, statePrefix, files, seen) {
+    const gate = latestDated(files, statePrefix, "gate", "json");
+    if (!gate)
+        return [];
+    const parsed = safeJson(safeRead(join(stateDir, gate.file)));
+    const findings = [];
+    for (const r of parsed?.rows ?? []) {
+        const key = String(r.key ?? "");
+        if (!key)
+            continue;
+        const s = seen[key];
+        findings.push({
+            key,
+            title: typeof r.title === "string" ? r.title : undefined,
+            evidence: typeof r.evidence === "string" ? r.evidence : undefined,
+            actionable: Boolean(r.actionable),
+            outcome: s?.outcome,
+            handledAt: toIso(s?.handledAt),
+        });
+    }
+    return findings;
+}
+function datedDaysFor(files, statePrefix) {
+    const dates = new Set();
+    for (const f of files) {
+        if (!f.startsWith(`${statePrefix}-`))
+            continue;
+        const d = f.match(DATE_RE);
+        if (d)
+            dates.add(d[1]);
+    }
+    return [...dates].sort();
+}
+function countGateRows(stateDir, statePrefix, date) {
+    const parsed = safeJson(safeRead(join(stateDir, `${statePrefix}-gate-${date}.json`)));
+    return (parsed?.rows ?? []).length;
+}
+function readRecentRuns(stateDir, statePrefix, files) {
+    return datedDaysFor(files, statePrefix)
+        .slice(-5)
+        .toReversed()
+        .map((date) => ({
+        date,
+        gateCount: countGateRows(stateDir, statePrefix, date),
+        freshCount: countTsvRows(safeRead(join(stateDir, `${statePrefix}-fresh-${date}.tsv`))),
+        doneCount: countTsvRows(safeRead(join(stateDir, `${statePrefix}-done-${date}.tsv`))),
+    }));
+}
+function readErrorTail(stateDir, statePrefix) {
+    const raw = safeRead(join(stateDir, `${statePrefix}-gate.err`));
+    if (!raw)
+        return undefined;
+    const errLines = raw.split("\n").filter((l) => ERROR_LINE_RE.test(l));
+    return errLines.length > 0 ? errLines.slice(-5).join("\n") : undefined;
+}
+function computeLastRunAt(stateDir, statePrefix, files) {
+    let newest = 0;
+    for (const f of files) {
+        if (!f.startsWith(`${statePrefix}-`))
+            continue;
+        const mt = safeStatMtime(join(stateDir, f));
+        if (mt > newest)
+            newest = mt;
+    }
+    return newest > 0 ? new Date(newest).toISOString() : undefined;
+}
+export function readLoopState(stateDir, statePrefix, files) {
+    const seen = readSeenLedger(stateDir, statePrefix);
+    return {
+        lastRunAt: computeLastRunAt(stateDir, statePrefix, files),
+        openFindings: readOpenFindings(stateDir, statePrefix, files, seen),
+        errorTail: readErrorTail(stateDir, statePrefix),
+        recentRuns: readRecentRuns(stateDir, statePrefix, files),
+    };
+}
+// ---- derivation -------------------------------------------------------------
+function readDescription(dir) {
+    const md = safeRead(join(dir, "LOOP.md"));
+    if (!md)
+        return undefined;
+    for (const line of md.split("\n")) {
+        const t = line.trim();
+        if (!t)
+            continue;
+        if (t.startsWith("#")) {
+            const h = t.replace(/^#+\s*/, "").trim();
+            if (h)
+                return h;
+            continue;
+        }
+        return t;
+    }
+    return undefined;
+}
+function deriveStatus(args) {
+    if (args.paused)
+        return "paused";
+    if (!args.scheduled && !args.lastRunAt)
+        return "unscheduled";
+    if (args.errorTail)
+        return "error";
+    const blocked = args.openFindings.some((f) => (f.outcome ?? "").toLowerCase().includes("block"));
+    if (blocked)
+        return "blocked";
+    if (args.lastRunAt) {
+        const ageMs = args.now.getTime() - new Date(args.lastRunAt).getTime();
+        return ageMs <= TWO_DAYS_MS ? "healthy" : "idle";
+    }
+    return args.scheduled ? "idle" : "unknown";
+}
+/** A few loops write state under a prefix different from their dir name. */
+function statePrefixFor(name) {
+    const overrides = { "review-loop": "review" };
+    return overrides[name] ?? name;
+}
+function titleCase(name) {
+    return name
+        .split(/[-_]/)
+        .map((w) => (w ? w.charAt(0).toUpperCase() + w.slice(1) : w))
+        .join(" ");
+}
+// ---- top-level --------------------------------------------------------------
+/**
+ * Resolve every loop's schedule through the backend this host actually uses.
+ *
+ * Order matters. crontab wins when the caller injected one (tests, and macOS hosts
+ * where cron is the scheduler). Otherwise systemd --user is tried first, because on
+ * Linux/WSL2 `crontab -l` can exist yet fail with "Permission denied", which the cron
+ * reader cannot distinguish from an empty crontab. Trusting cron there reports every
+ * loop as `unscheduled` with `mode: unknown`, which is exactly the silent-wrong-answer
+ * the Loops view exists to prevent.
+ */
+export function resolveSchedules(config, names) {
+    if (config.schedules) {
+        return config.schedules;
+    }
+    if (config.crontab !== undefined) {
+        return cronEntriesToSchedules(parseCrontab(config.crontab));
+    }
+    const unitDir = config.unitDir ?? defaultSystemdUnitDir();
+    if (SystemdUserScheduler.isAvailable(unitDir)) {
+        const scheduler = new SystemdUserScheduler({ unitDir, backupDir: unitDir });
+        const resolved = new Map();
+        let anyScheduled = false;
+        for (const name of names) {
+            const entry = scheduler.read(name);
+            resolved.set(name, entry);
+            anyScheduled || (anyScheduled = entry.scheduled);
+        }
+        if (anyScheduled) {
+            return resolved;
+        }
+    }
+    return cronEntriesToSchedules(parseCrontab(readCrontab()));
+}
+function cronEntriesToSchedules(cron) {
+    const out = new Map();
+    for (const [name, entry] of cron) {
+        out.set(name, {
+            scheduled: true,
+            paused: entry.paused,
+            cadence: entry.cadence,
+            mode: entry.mode,
+        });
+    }
+    return out;
+}
+export function readFleet(config = defaultFleetReaderConfig()) {
+    const now = config.now ? config.now() : new Date();
+    const discovered = discoverLoopDirs(config.loopsDir);
+    const cron = resolveSchedules(config, discovered.map((entry) => entry.name));
+    const stateFiles = safeReaddir(config.stateDir);
+    const loops = [];
+    for (const { name, dir } of discovered) {
+        const statePrefix = statePrefixFor(name);
+        const raw = cron.get(name);
+        // A backend entry for an unscheduled loop is still "no schedule".
+        const c = raw?.scheduled ? raw : undefined;
+        const state = readLoopState(config.stateDir, statePrefix, stateFiles);
+        loops.push({
+            name,
+            displayName: titleCase(name),
+            description: readDescription(dir),
+            dir,
+            statePrefix,
+            scheduled: Boolean(c),
+            paused: c?.paused ?? false,
+            cadence: c?.cadence,
+            mode: c?.mode ?? "unknown",
+            status: deriveStatus({
+                scheduled: Boolean(c),
+                paused: c?.paused ?? false,
+                lastRunAt: state.lastRunAt,
+                errorTail: state.errorTail,
+                openFindings: state.openFindings,
+                now,
+            }),
+            lastRunAt: state.lastRunAt,
+            openFindings: state.openFindings,
+            errorTail: state.errorTail,
+            recentRuns: state.recentRuns,
+            paramsSchema: readParamsSchema(dir),
+            params: readParams(dir),
+        });
+    }
+    return loops;
+}
+// ---- standalone verification ------------------------------------------------
+function printFleet(fleet) {
+    for (const l of fleet) {
+        const sched = l.scheduled ? `${l.cadence} [${l.mode}]` : "not scheduled";
+        const findings = l.openFindings.length > 0
+            ? " → " +
+                l.openFindings
+                    .slice(0, 5)
+                    .map((f) => `${f.key}${f.outcome ? `(${f.outcome})` : ""}`)
+                    .join(", ")
+            : "";
+        console.log(`● ${l.displayName}  (${l.name})  —  ${l.status}`);
+        console.log(`    schedule: ${sched}`);
+        console.log(`    lastRun:  ${l.lastRunAt ?? "—"}`);
+        if (l.description)
+            console.log(`    about:    ${l.description}`);
+        console.log(`    findings: ${l.openFindings.length}${findings}`);
+        if (l.recentRuns.length > 0) {
+            console.log(`    runs:     ` +
+                l.recentRuns
+                    .map((r) => `${r.date}:g${r.gateCount}/f${r.freshCount}/d${r.doneCount}`)
+                    .join("  "));
+        }
+        if (l.errorTail) {
+            console.log(`    ! errors: ${l.errorTail.split("\n").at(-1)}`);
+        }
+        console.log("");
+    }
+}
+function main() {
+    const cfg = defaultFleetReaderConfig();
+    const fleet = readFleet(cfg);
+    console.log(`\nFleet reader\n  loopsDir = ${cfg.loopsDir}\n  stateDir = ${cfg.stateDir}\n`);
+    console.log(`Discovered ${fleet.length} loop(s):\n`);
+    printFleet(fleet);
+}
+const invokedDirectly = process.argv[1] !== undefined &&
+    (fileURLToPath(import.meta.url) === process.argv[1] || process.argv.includes("--print"));
+if (invokedDirectly) {
+    main();
+}
+//# sourceMappingURL=fleet-reader.js.map

package/dist/server/server/fleet/fleet-scaffold.d.ts

@@ -0,0 +1,26 @@
+/**
+ * In-app equivalent of the `/new-loop` skill: scaffold a new loop under
+ * `tooling/loops/<name>/` from the template and return the cron line to install.
+ * Deliberately does NOT install cron itself (matching the skill) — the loop starts
+ * unscheduled until the user adds the returned line to their crontab, and its gate.mjs
+ * still needs the real discovery query filled in.
+ */
+export interface CreateLoopSpec {
+    name: string;
+    description: string;
+    cron: string;
+    action: string;
+    mode: "live" | "dry-run";
+    rails?: string;
+    allowed?: string;
+}
+export interface CreateLoopResult {
+    dir: string;
+    cronLine: string;
+}
+export declare function createLoopScaffold(args: {
+    loopsDir: string;
+    superRepoRoot: string;
+    spec: CreateLoopSpec;
+}): CreateLoopResult;
+//# sourceMappingURL=fleet-scaffold.d.ts.map

package/dist/server/server/fleet/fleet-scaffold.js

@@ -0,0 +1,48 @@
+import { cpSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+const NAME_RE = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+const TOKEN_FILES = ["run.sh", "gate.mjs", "LOOP.md"];
+export function createLoopScaffold(args) {
+    const { loopsDir, superRepoRoot, spec } = args;
+    const name = spec.name.trim();
+    if (!NAME_RE.test(name)) {
+        throw new Error(`Invalid loop name "${name}": use kebab-case (lowercase letters, digits, dashes)`);
+    }
+    if (name === "template" || name === "lib") {
+        throw new Error(`"${name}" is reserved`);
+    }
+    const dir = join(loopsDir, name);
+    if (existsSync(dir)) {
+        throw new Error(`Loop "${name}" already exists at ${dir}`);
+    }
+    const templateDir = join(loopsDir, "template");
+    if (!existsSync(templateDir)) {
+        throw new Error(`Loop template not found at ${templateDir}`);
+    }
+    cpSync(templateDir, dir, { recursive: true });
+    const modeFlag = spec.mode === "live" ? "--live" : "--dry-run";
+    const replacements = {
+        __NAME__: name,
+        __DESCRIPTION__: spec.description.trim() || name,
+        __CRON__: spec.cron.trim(),
+        __MODE__: modeFlag,
+        __ACTION__: spec.action.trim(),
+        __RAILS__: spec.rails?.trim() ?? "(none beyond baseline)",
+        __ALLOWED__: spec.allowed?.trim() ?? "Read,Grep,Glob,Bash(git:*)",
+    };
+    for (const file of TOKEN_FILES) {
+        const path = join(dir, file);
+        if (!existsSync(path))
+            continue;
+        let content = readFileSync(path, "utf8");
+        for (const [token, value] of Object.entries(replacements)) {
+            content = content.split(token).join(value);
+        }
+        writeFileSync(path, content, "utf8");
+    }
+    const cronLine = `${spec.cron.trim()} /bin/bash -lc ` +
+        `'${superRepoRoot}/tooling/loops/${name}/run.sh ${modeFlag} ` +
+        `>> ~/.local/state/${name}/$(date +\\%F).log 2>&1'`;
+    return { dir, cronLine };
+}
+//# sourceMappingURL=fleet-scaffold.js.map

package/dist/server/server/fleet/fleet-scheduler.d.ts

@@ -0,0 +1,75 @@
+export type FleetLoopMode = "live" | "dry-run" | "unknown";
+export type FleetSchedulerKind = "systemd-user" | "crontab" | "none";
+export interface FleetScheduleEntry {
+    /** A scheduler unit/line exists for this loop. */
+    scheduled: boolean;
+    /** Scheduled but switched off (disabled timer, or commented cron line). */
+    paused: boolean;
+    /** Human-readable cadence, backend-specific (`OnCalendar` value or cron expression). */
+    cadence?: string;
+    mode: FleetLoopMode;
+}
+export interface SetModeResult {
+    changed: boolean;
+    previousMode: FleetLoopMode;
+    mode: FleetLoopMode;
+    backupPath?: string;
+}
+export interface SetPausedResult {
+    changed: boolean;
+    backupPath?: string;
+}
+/** Prefix written in front of a cron line to pause it without deleting it. */
+export declare const PAUSE_MARKER = "#PASEO-PAUSED#";
+/** Mode of a command string, from its `--live` / `--dry-run` flag. */
+export declare function parseModeFromCommand(command: string): FleetLoopMode;
+/**
+ * Rewrite a command's mode flag, inserting one right after the runner path when the
+ * command carries none. Appending at the end would land after the shell redirect
+ * (`>> log 2>&1`), where the runner would never see it.
+ */
+export declare function applyModeToCommand(command: string, mode: "live" | "dry-run", runnerRe: RegExp): string;
+/** Matches the loop's runner path so we only ever touch that loop's own command. */
+export declare function loopRunnerRegExp(name: string): RegExp;
+export interface SystemdUnits {
+    serviceText: string | null;
+    timerText: string | null;
+    enabled: boolean;
+}
+/** All `ExecStart=` values in a service unit (a unit may declare several). */
+export declare function readExecStart(serviceText: string): string | null;
+/** Cadence of a timer unit: `OnCalendar`, falling back to the monotonic variants. */
+export declare function readTimerCadence(timerText: string): string | undefined;
+/** Derive a loop's schedule from its systemd unit texts. Pure, so it is testable. */
+export declare function scheduleFromSystemdUnits(units: SystemdUnits): FleetScheduleEntry;
+export interface SystemdBackendConfig {
+    /** Usually `~/.config/systemd/user`. */
+    unitDir: string;
+    /** Where crontab/unit backups are written before a mutation. */
+    backupDir: string;
+    /** Injectable so tests never shell out. Runs `systemctl --user <args>`. */
+    systemctl?: (args: string[]) => void;
+    now?: () => number;
+}
+export declare class SystemdUserScheduler {
+    readonly kind: FleetSchedulerKind;
+    private readonly config;
+    constructor(config: SystemdBackendConfig);
+    /** True when this host actually schedules anything through systemd --user. */
+    static isAvailable(unitDir: string): boolean;
+    private servicePath;
+    private timerPath;
+    private wantsPath;
+    readUnits(name: string): SystemdUnits;
+    read(name: string): FleetScheduleEntry;
+    private backup;
+    /**
+     * Flip a loop between dry-run and live by rewriting the flag in its service unit,
+     * then reloading systemd so the next timer firing uses it. The unit is backed up
+     * first and only the `ExecStart` flag changes.
+     */
+    setMode(name: string, mode: "live" | "dry-run"): SetModeResult;
+    setPaused(name: string, paused: boolean): SetPausedResult;
+}
+export declare function defaultSystemdUnitDir(): string;
+//# sourceMappingURL=fleet-scheduler.d.ts.map