@tea-agent/loop-agent 0.28.11 → 0.28.12

package/dist/worker/scheduler/clock-install/linux-systemd-user.js

@@ -0,0 +1,224 @@
+import { spawn } from "node:child_process";
+import { mkdir, readFile, unlink, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { deriveClockUnitName } from "../clock.js";
+import { MANAGED_MARKER } from "./types.js";
+function userUnitDir() {
+    return path.join(os.homedir(), ".config", "systemd", "user");
+}
+function servicePath(unitName) {
+    return path.join(userUnitDir(), `${unitName}.service`);
+}
+function timerPath(unitName) {
+    return path.join(userUnitDir(), `${unitName}.timer`);
+}
+export function renderSystemdService(input) {
+    // Absolute argv — no shell.
+    const execStart = [
+        input.nodeBin,
+        input.agentWorkerEntry,
+        "scheduler",
+        "tick",
+        "--repo",
+        input.controlRepoRoot,
+        "--loop-agent-bin",
+        input.loopAgentBin,
+        "--clock-source",
+        "systemd-user",
+        "--json",
+    ]
+        .map(escapeSystemdArg)
+        .join(" ");
+    return `# ${MANAGED_MARKER} ${input.managedConfigHash}
+[Unit]
+Description=loop-agent Night Scheduler clock tick (${input.unitName})
+ConditionPathIsDirectory=${escapeSystemdArg(input.controlRepoRoot)}
+
+[Service]
+Type=oneshot
+WorkingDirectory=${escapeSystemdArg(input.controlRepoRoot)}
+ExecStart=${execStart}
+`;
+}
+export function renderSystemdTimer(input) {
+    return `# ${MANAGED_MARKER} ${input.managedConfigHash}
+[Unit]
+Description=loop-agent Night Scheduler clock timer (${input.unitName})
+
+[Timer]
+OnBootSec=30
+OnUnitActiveSec=${input.intervalSec}
+AccuracySec=10
+Unit=${input.unitName}.service
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+`;
+}
+function escapeSystemdArg(value) {
+    // Quote if needed; keep absolute paths intact.
+    if (/^[A-Za-z0-9_./:@%+=-]+$/.test(value))
+        return value;
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+async function runSystemctl(args) {
+    return new Promise((resolve) => {
+        const child = spawn("systemctl", ["--user", ...args], {
+            stdio: ["ignore", "pipe", "pipe"],
+            env: process.env,
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on("close", (code) => {
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
+        child.on("error", (error) => {
+            resolve({
+                code: 1,
+                stdout,
+                stderr: error instanceof Error ? error.message : String(error),
+            });
+        });
+    });
+}
+export const linuxSystemdUserAdapter = {
+    provider: "systemd-user",
+    async isAvailable() {
+        if (process.platform !== "linux")
+            return false;
+        const probe = await runSystemctl(["show-environment"]);
+        return probe.code === 0;
+    },
+    unitName(controlRepoRoot) {
+        // systemd unit names prefer simple chars; reuse hash-derived label.
+        return deriveClockUnitName(controlRepoRoot).replace(/^com\.tea-agent\./, "loop-agent-");
+    },
+    renderConfig(input) {
+        return [
+            renderSystemdService({
+                unitName: input.receipt.unitName,
+                nodeBin: input.entrypoints.nodeBin,
+                agentWorkerEntry: input.entrypoints.agentWorkerEntry,
+                controlRepoRoot: input.entrypoints.controlRepoRoot,
+                loopAgentBin: input.entrypoints.loopAgentBin,
+                managedConfigHash: input.receipt.managedConfigHash,
+            }),
+            renderSystemdTimer({
+                unitName: input.receipt.unitName,
+                intervalSec: input.receipt.intervalSec,
+                managedConfigHash: input.receipt.managedConfigHash,
+            }),
+        ].join("\n---\n");
+    },
+    async install(input) {
+        const svc = servicePath(input.receipt.unitName);
+        const tmr = timerPath(input.receipt.unitName);
+        await mkdir(userUnitDir(), { recursive: true });
+        for (const file of [svc, tmr]) {
+            try {
+                const existing = await readFile(file, "utf-8");
+                if (!existing.includes(MANAGED_MARKER)) {
+                    throw new Error(`Refusing to overwrite unmanaged systemd unit at ${file}`);
+                }
+            }
+            catch (error) {
+                if (error instanceof Error &&
+                    error.message.includes("Refusing to overwrite")) {
+                    throw error;
+                }
+                // ENOENT ok
+            }
+        }
+        const serviceBody = renderSystemdService({
+            unitName: input.receipt.unitName,
+            nodeBin: input.entrypoints.nodeBin,
+            agentWorkerEntry: input.entrypoints.agentWorkerEntry,
+            controlRepoRoot: input.entrypoints.controlRepoRoot,
+            loopAgentBin: input.entrypoints.loopAgentBin,
+            managedConfigHash: input.receipt.managedConfigHash,
+        });
+        const timerBody = renderSystemdTimer({
+            unitName: input.receipt.unitName,
+            intervalSec: input.receipt.intervalSec,
+            managedConfigHash: input.receipt.managedConfigHash,
+        });
+        await writeFile(svc, serviceBody, "utf-8");
+        await writeFile(tmr, timerBody, "utf-8");
+        const reload = await runSystemctl(["daemon-reload"]);
+        if (reload.code !== 0) {
+            throw new Error(`systemctl --user daemon-reload failed: ${reload.stderr || reload.stdout}`);
+        }
+        const enable = await runSystemctl([
+            "enable",
+            "--now",
+            `${input.receipt.unitName}.timer`,
+        ]);
+        if (enable.code !== 0) {
+            throw new Error(`systemctl --user enable --now failed: ${enable.stderr || enable.stdout}`);
+        }
+    },
+    async uninstall(input) {
+        const svc = servicePath(input.receipt.unitName);
+        const tmr = timerPath(input.receipt.unitName);
+        for (const file of [svc, tmr]) {
+            try {
+                const existing = await readFile(file, "utf-8");
+                if (!existing.includes(MANAGED_MARKER) &&
+                    !existing.includes(input.receipt.managedConfigHash)) {
+                    throw new Error(`Refusing to uninstall non-managed systemd unit at ${file}`);
+                }
+            }
+            catch (error) {
+                if (error &&
+                    typeof error === "object" &&
+                    "code" in error &&
+                    error.code === "ENOENT") {
+                    continue;
+                }
+                if (error instanceof Error &&
+                    error.message.includes("Refusing to uninstall")) {
+                    throw error;
+                }
+            }
+        }
+        await runSystemctl(["disable", "--now", `${input.receipt.unitName}.timer`]);
+        await unlink(svc).catch(() => { });
+        await unlink(tmr).catch(() => { });
+        await runSystemctl(["daemon-reload"]);
+    },
+    async probe(input) {
+        const unitName = input.receipt?.unitName ?? input.unitName;
+        const tmr = timerPath(unitName);
+        let present = false;
+        let body = "";
+        try {
+            body = await readFile(tmr, "utf-8");
+            present = true;
+        }
+        catch {
+            present = false;
+        }
+        const isActive = await runSystemctl(["is-active", `${unitName}.timer`]);
+        const loaded = isActive.code === 0 && isActive.stdout.trim() === "active";
+        let configMatches = null;
+        if (present && input.receipt) {
+            configMatches =
+                body.includes(MANAGED_MARKER) &&
+                    body.includes(input.receipt.managedConfigHash);
+        }
+        return {
+            present,
+            loaded,
+            configMatches,
+            detail: isActive.stdout.trim() || isActive.stderr.trim(),
+        };
+    },
+};

package/dist/worker/scheduler/clock-install/types.js

@@ -0,0 +1 @@
+export const MANAGED_MARKER = "tea-agent-loop-agent-night-clock";

package/dist/worker/scheduler/clock-install/win32-schtasks.js

@@ -0,0 +1,172 @@
+import { spawn } from "node:child_process";
+import { deriveClockUnitName } from "../clock.js";
+import { MANAGED_MARKER } from "./types.js";
+function taskName(unitName) {
+    // schtasks task path; keep under user-visible folder.
+    return `\\${unitName}`;
+}
+export function renderSchtasksCreateArgs(input) {
+    // Build a single command line with quoted paths. No PowerShell wrapper.
+    const command = [
+        quoteWin(input.nodeBin),
+        quoteWin(input.agentWorkerEntry),
+        "scheduler",
+        "tick",
+        "--repo",
+        quoteWin(input.controlRepoRoot),
+        "--loop-agent-bin",
+        quoteWin(input.loopAgentBin),
+        "--clock-source",
+        "schtasks",
+        "--json",
+    ].join(" ");
+    // /SC MINUTE /MO N → every N minutes (minimum 1). Sub-minute not supported by schtasks.
+    const minutes = Math.max(1, Math.round(input.intervalSec / 60));
+    return [
+        "/Create",
+        "/F",
+        "/TN",
+        taskName(input.unitName),
+        "/TR",
+        command,
+        "/SC",
+        "MINUTE",
+        "/MO",
+        String(minutes),
+        "/RL",
+        "LIMITED",
+    ];
+}
+function quoteWin(value) {
+    if (!/[ \t"]/.test(value))
+        return value;
+    return `"${value.replace(/"/g, '\\"')}"`;
+}
+async function runSchtasks(args) {
+    return new Promise((resolve) => {
+        const child = spawn("schtasks", args, {
+            stdio: ["ignore", "pipe", "pipe"],
+            windowsHide: true,
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on("close", (code) => {
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
+        child.on("error", (error) => {
+            resolve({
+                code: 1,
+                stdout,
+                stderr: error instanceof Error ? error.message : String(error),
+            });
+        });
+    });
+}
+export const win32SchtasksAdapter = {
+    provider: "schtasks",
+    async isAvailable() {
+        if (process.platform !== "win32")
+            return false;
+        const probe = await runSchtasks(["/Query"]);
+        // /Query without /TN lists tasks; permission errors still mean binary exists.
+        return (probe.code === 0 ||
+            probe.stderr.length > 0 ||
+            probe.stdout.length > 0 ||
+            !probe.stderr.includes("not recognized"));
+    },
+    unitName(controlRepoRoot) {
+        return deriveClockUnitName(controlRepoRoot);
+    },
+    renderConfig(input) {
+        return renderSchtasksCreateArgs({
+            unitName: input.receipt.unitName,
+            intervalSec: input.receipt.intervalSec,
+            nodeBin: input.entrypoints.nodeBin,
+            agentWorkerEntry: input.entrypoints.agentWorkerEntry,
+            controlRepoRoot: input.entrypoints.controlRepoRoot,
+            loopAgentBin: input.entrypoints.loopAgentBin,
+        }).join(" ");
+    },
+    async install(input) {
+        // Delete previous managed task if present (idempotent update).
+        await runSchtasks([
+            "/Delete",
+            "/F",
+            "/TN",
+            taskName(input.receipt.unitName),
+        ]);
+        const args = renderSchtasksCreateArgs({
+            unitName: input.receipt.unitName,
+            intervalSec: input.receipt.intervalSec,
+            nodeBin: input.entrypoints.nodeBin,
+            agentWorkerEntry: input.entrypoints.agentWorkerEntry,
+            controlRepoRoot: input.entrypoints.controlRepoRoot,
+            loopAgentBin: input.entrypoints.loopAgentBin,
+        });
+        const created = await runSchtasks(args);
+        if (created.code !== 0) {
+            throw new Error(`schtasks create failed: ${created.stderr || created.stdout || `exit ${created.code}`}`);
+        }
+        // Marker is stored only in install receipt; schtasks has limited annotation.
+        // Ownership is enforced via receipt unitName hash + TR path match on probe.
+        void MANAGED_MARKER;
+    },
+    async uninstall(input) {
+        const query = await runSchtasks([
+            "/Query",
+            "/TN",
+            taskName(input.receipt.unitName),
+            "/V",
+            "/FO",
+            "LIST",
+        ]);
+        if (query.code !== 0) {
+            return; // already gone
+        }
+        const body = `${query.stdout}\n${query.stderr}`;
+        if (!body.includes(input.receipt.controlRepoRoot) &&
+            !body.includes(input.receipt.agentWorkerEntry)) {
+            throw new Error(`Refusing to uninstall schtasks unit that does not match install receipt: ${input.receipt.unitName}`);
+        }
+        const del = await runSchtasks([
+            "/Delete",
+            "/F",
+            "/TN",
+            taskName(input.receipt.unitName),
+        ]);
+        if (del.code !== 0) {
+            throw new Error(`schtasks delete failed: ${del.stderr || del.stdout || `exit ${del.code}`}`);
+        }
+    },
+    async probe(input) {
+        const unitName = input.receipt?.unitName ?? input.unitName;
+        const query = await runSchtasks([
+            "/Query",
+            "/TN",
+            taskName(unitName),
+            "/V",
+            "/FO",
+            "LIST",
+        ]);
+        const present = query.code === 0;
+        const body = `${query.stdout}\n${query.stderr}`;
+        let configMatches = null;
+        if (present && input.receipt) {
+            configMatches =
+                body.includes(input.receipt.controlRepoRoot) &&
+                    body.includes(input.receipt.agentWorkerEntry);
+        }
+        return {
+            present,
+            loaded: present,
+            configMatches,
+            detail: present ? "schtasks query ok" : query.stderr.trim() || "missing",
+        };
+    },
+};

package/dist/worker/scheduler/clock-install.js

@@ -0,0 +1,284 @@
+import { realpathSync } from "node:fs";
+import { access } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { CLOCK_INSTALL_SCHEMA_VERSION, DEFAULT_CLOCK_INTERVAL_SEC, classifyClockHealth, countActiveExecutionLeases, deriveClockUnitName, hashManagedConfig, readClockInstallReceipt, readClockReceipt, writeClockInstallReceipt, } from "./clock.js";
+import { darwinLaunchdAdapter } from "./clock-install/darwin-launchd.js";
+import { linuxSystemdUserAdapter } from "./clock-install/linux-systemd-user.js";
+import { win32SchtasksAdapter } from "./clock-install/win32-schtasks.js";
+import { SchedulerError, SCHEDULER_ERROR_CODES } from "./types.js";
+const ADAPTERS = [
+    darwinLaunchdAdapter,
+    linuxSystemdUserAdapter,
+    win32SchtasksAdapter,
+];
+export function selectClockAdapter(platform = process.platform) {
+    if (platform === "darwin")
+        return darwinLaunchdAdapter;
+    if (platform === "linux")
+        return linuxSystemdUserAdapter;
+    if (platform === "win32")
+        return win32SchtasksAdapter;
+    return null;
+}
+export async function resolveClockEntrypoints(input) {
+    const controlRepoRoot = realpathSafe(path.resolve(input.controlRepoRoot));
+    const nodeBin = realpathSafe(input.nodeBin ?? process.execPath);
+    const agentWorkerEntry = realpathSafe(input.agentWorkerEntry ?? resolveDefaultAgentWorkerEntry());
+    const loopAgentBin = realpathSafe(input.loopAgentBin ?? resolveDefaultLoopAgentBin());
+    return {
+        nodeBin,
+        agentWorkerEntry,
+        loopAgentBin,
+        controlRepoRoot,
+    };
+}
+function resolveDefaultAgentWorkerEntry() {
+    // Prefer package bin when running from published install; fall back to
+    // dist entry relative to this module when developing from source.
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    // src/worker/scheduler → package root is ../../..
+    // dist/worker/scheduler → package root is ../../..
+    const packageRoot = path.resolve(here, "../../..");
+    const binEntry = path.join(packageRoot, "bin", "agent-worker.js");
+    const distEntry = path.join(packageRoot, "dist", "worker", "cli.js");
+    // Prefer bin wrapper (stable public entry).
+    try {
+        realpathSync(binEntry);
+        return binEntry;
+    }
+    catch {
+        return distEntry;
+    }
+}
+function resolveDefaultLoopAgentBin() {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const packageRoot = path.resolve(here, "../../..");
+    const binEntry = path.join(packageRoot, "bin", "loop-agent.js");
+    try {
+        realpathSync(binEntry);
+        return binEntry;
+    }
+    catch {
+        return "loop-agent";
+    }
+}
+function realpathSafe(candidate) {
+    try {
+        return realpathSync(path.resolve(candidate));
+    }
+    catch {
+        return path.resolve(candidate);
+    }
+}
+export async function installClockTimer(input) {
+    const now = input.now ?? new Date();
+    const adapter = input.adapter ?? selectClockAdapter();
+    if (!adapter) {
+        throw new SchedulerError(SCHEDULER_ERROR_CODES.INVALID_RECORD, `No supported clock provider on platform ${process.platform}`);
+    }
+    const available = await adapter.isAvailable();
+    if (!available) {
+        throw new SchedulerError(SCHEDULER_ERROR_CODES.INVALID_RECORD, `Clock provider ${adapter.provider} is not available in this environment (unsupported or user manager missing)`);
+    }
+    const intervalSec = normalizeInterval(input.intervalSec);
+    const entrypoints = await resolveClockEntrypoints({
+        controlRepoRoot: input.controlRepoRoot,
+        loopAgentBin: input.loopAgentBin,
+        agentWorkerEntry: input.agentWorkerEntry,
+        nodeBin: input.nodeBin,
+    });
+    // Verify entrypoints exist.
+    for (const [label, p] of [
+        ["nodeBin", entrypoints.nodeBin],
+        ["agentWorkerEntry", entrypoints.agentWorkerEntry],
+    ]) {
+        try {
+            await access(p);
+        }
+        catch {
+            throw new SchedulerError(SCHEDULER_ERROR_CODES.INVALID_RECORD, `Cannot resolve ${label} for clock install: ${p}`);
+        }
+    }
+    const unitName = adapter.unitName(entrypoints.controlRepoRoot);
+    const managedConfigHash = hashManagedConfig({
+        provider: adapter.provider,
+        unitName,
+        controlRepoRoot: entrypoints.controlRepoRoot,
+        intervalSec,
+        nodeBin: entrypoints.nodeBin,
+        agentWorkerEntry: entrypoints.agentWorkerEntry,
+        loopAgentBin: entrypoints.loopAgentBin,
+    });
+    const existing = await readClockInstallReceipt(entrypoints.controlRepoRoot);
+    if (existing &&
+        existing.managedConfigHash === managedConfigHash &&
+        existing.provider === adapter.provider &&
+        existing.unitName === unitName) {
+        // Still ensure OS unit is present (idempotent re-apply).
+        await adapter.install({
+            receipt: existing,
+            entrypoints,
+        });
+        return {
+            schemaVersion: 1,
+            action: "unchanged",
+            provider: adapter.provider,
+            receipt: existing,
+            message: "Clock timer already installed with matching config.",
+        };
+    }
+    const receipt = {
+        schemaVersion: CLOCK_INSTALL_SCHEMA_VERSION,
+        provider: adapter.provider,
+        unitName,
+        controlRepoRoot: entrypoints.controlRepoRoot,
+        intervalSec,
+        nodeBin: entrypoints.nodeBin,
+        agentWorkerEntry: entrypoints.agentWorkerEntry,
+        loopAgentBin: entrypoints.loopAgentBin,
+        managedConfigHash,
+        installedAt: existing?.installedAt ?? now.toISOString(),
+        updatedAt: now.toISOString(),
+    };
+    await adapter.install({ receipt, entrypoints });
+    await writeClockInstallReceipt(entrypoints.controlRepoRoot, receipt);
+    return {
+        schemaVersion: 1,
+        action: existing ? "updated" : "installed",
+        provider: adapter.provider,
+        receipt,
+        message: existing ? "Clock timer updated." : "Clock timer installed.",
+    };
+}
+export async function uninstallClockTimer(input) {
+    const controlRepoRoot = realpathSafe(path.resolve(input.controlRepoRoot));
+    const receipt = await readClockInstallReceipt(controlRepoRoot);
+    if (!receipt) {
+        return {
+            schemaVersion: 1,
+            action: "already-absent",
+            provider: null,
+            unitName: null,
+            message: "No managed clock install receipt found.",
+        };
+    }
+    const adapter = input.adapter ??
+        ADAPTERS.find((item) => item.provider === receipt.provider) ??
+        selectClockAdapter();
+    if (!adapter || adapter.provider !== receipt.provider) {
+        throw new SchedulerError(SCHEDULER_ERROR_CODES.INVALID_RECORD, `Cannot uninstall clock: provider ${receipt.provider} adapter unavailable on this host`);
+    }
+    await adapter.uninstall({ receipt });
+    // Keep install receipt for audit? Plan: uninstall removes managed unit but
+    // "保留 install receipt 历史" — we rewrite a tombstone by deleting active
+    // receipt content is ambiguous. Keep file but mark by rewriting unit gone:
+    // Plan says "uninstall 保留 clock.json、install receipt 历史". So do NOT delete.
+    // Status will see unit missing → drifted/missing via probe.
+    // Better: leave receipt; status uses probe.present=false → drifted with reinstall hint.
+    // For cleaner UX after intentional uninstall, write a soft marker by clearing
+    // is not specified. Follow plan: keep receipt file as audit.
+    return {
+        schemaVersion: 1,
+        action: "uninstalled",
+        provider: receipt.provider,
+        unitName: receipt.unitName,
+        message: "Managed clock timer removed. Install receipt and tick history retained.",
+    };
+}
+export async function statusClockTimer(input) {
+    const now = input.now ?? new Date();
+    const controlRepoRoot = realpathSafe(path.resolve(input.controlRepoRoot));
+    const install = await readClockInstallReceipt(controlRepoRoot);
+    const receipt = await readClockReceipt(controlRepoRoot);
+    const adapter = input.adapter ??
+        (install
+            ? (ADAPTERS.find((item) => item.provider === install.provider) ?? null)
+            : selectClockAdapter());
+    let providerSupported = true;
+    if (adapter) {
+        providerSupported = await adapter.isAvailable();
+    }
+    else {
+        providerSupported = false;
+    }
+    let probe = null;
+    if (adapter && install) {
+        const unitProbe = await adapter.probe({
+            receipt: install,
+            unitName: install.unitName,
+        });
+        probe = unitProbe;
+    }
+    else if (adapter) {
+        const unitName = deriveClockUnitName(controlRepoRoot);
+        const unitProbe = await adapter.probe({ receipt: null, unitName });
+        probe = unitProbe;
+    }
+    // Path drift: compare current entrypoints to install receipt.
+    let pathsMatch = null;
+    if (install) {
+        try {
+            const current = await resolveClockEntrypoints({
+                controlRepoRoot,
+                loopAgentBin: install.loopAgentBin,
+                agentWorkerEntry: install.agentWorkerEntry,
+                nodeBin: install.nodeBin,
+            });
+            // If operator upgraded package, default entry may differ from frozen receipt.
+            const liveDefault = await resolveClockEntrypoints({ controlRepoRoot });
+            pathsMatch =
+                install.nodeBin === current.nodeBin &&
+                    install.agentWorkerEntry === current.agentWorkerEntry &&
+                    // soft: live package entry still equals frozen entry
+                    install.agentWorkerEntry === liveDefault.agentWorkerEntry;
+        }
+        catch {
+            pathsMatch = false;
+        }
+    }
+    const activeLeaseCount = await countActiveExecutionLeases(controlRepoRoot, now);
+    const health = classifyClockHealth({
+        now,
+        receipt,
+        install,
+        unitPresent: probe?.present ?? null,
+        unitLoaded: probe?.loaded ?? null,
+        configMatches: probe?.configMatches ?? null,
+        pathsMatch,
+        providerSupported,
+        activeLeaseCount,
+        defaultMaxConcurrency: 1,
+    });
+    return {
+        schemaVersion: 1,
+        health,
+        install,
+        probe,
+    };
+}
+function normalizeInterval(raw) {
+    const value = raw ?? DEFAULT_CLOCK_INTERVAL_SEC;
+    if (!Number.isFinite(value) || value < 15 || value > 3600) {
+        throw new SchedulerError(SCHEDULER_ERROR_CODES.INVALID_RECORD, `intervalSec must be between 15 and 3600, got ${raw}`);
+    }
+    return Math.floor(value);
+}
+export function detectClockSourceFromEnv(explicit) {
+    if (explicit === "manual" ||
+        explicit === "launchd" ||
+        explicit === "systemd-user" ||
+        explicit === "schtasks" ||
+        explicit === "clock-run") {
+        return explicit;
+    }
+    // Heuristics for OS-invoked processes (best-effort).
+    if (process.env.LAUNCH_JOB_LABEL || process.env.XPC_SERVICE_NAME) {
+        return "launchd";
+    }
+    if (process.env.INVOCATION_ID || process.env.JOURNAL_STREAM) {
+        return "systemd-user";
+    }
+    return "manual";
+}
+export { darwinLaunchdAdapter, linuxSystemdUserAdapter, win32SchtasksAdapter };