oh-my-super-agent 0.1.0

package/dist/src/schedule/user-installation.js

@@ -0,0 +1,701 @@
+import { createHash } from "node:crypto";
+import { mkdirSync, unlinkSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+import { readImmutableFile } from "../evidence/immutable-file.js";
+import { runProcess } from "../providers/process.js";
+import { acquireDirectoryLock } from "../runtime/lock.js";
+import { assertSchema, loadJsonSchema } from "../runtime/schema.js";
+import { isRecord, lstatIfExists, readJsonFileNoFollow, validateExistingDirectory, writeFileAtomic, writeJsonAtomicNoReplace, } from "../utils/fs.js";
+import { assertGeneratedUserSchedule, USER_SCHEDULE_BLOCK_BEGIN, USER_SCHEDULE_BLOCK_END, userScheduleArtifactBaseName, userScheduleLaunchdLabel, userSchedulePackageRoot, normalizeUserScheduleEnvironmentPath, } from "./user-plan.js";
+const INSTALLATION_FILE = "oms-user-schedule.json";
+const MAX_MANAGER_OUTPUT_BYTES = 1024 * 1024;
+const MAX_CRONTAB_BYTES = 1024 * 1024;
+const SHA256_PATTERN = /^[a-f0-9]{64}$/;
+export function readInstalledUserSchedulePlanBinding(options) {
+    const installationsRoot = validateExistingDirectory(options.installationsRoot, "schedule installations directory");
+    const packageRoot = validateExistingDirectory(options.packageRoot, "package root");
+    const installationPath = join(installationsRoot, INSTALLATION_FILE);
+    const entry = lstatIfExists(installationPath);
+    if (!entry)
+        return undefined;
+    if (entry.isSymbolicLink() || !entry.isFile())
+        throw new Error("user schedule installation is not a regular file");
+    const installation = parseInstallation(readJsonFileNoFollow(installationPath, 256 * 1024), packageRoot);
+    if (installation.schema_version === 1) {
+        return Object.freeze({ schema_version: 1, manager: installation.manager });
+    }
+    return Object.freeze({
+        schema_version: 2,
+        manager: installation.manager,
+        executable_path: installation.executable_path,
+        environment_path: installation.environment_path,
+        state_root: installation.state_root,
+        workspace_root: installation.workspace_root,
+        repository: installation.repository,
+        github_poll_seconds: installation.github_poll_seconds,
+    });
+}
+export function installUserSchedule(options) {
+    const captured = captureOptions(options);
+    const context = prepareContext(captured);
+    const installedAt = canonicalTimestamp((captured.clock ?? (() => new Date().toISOString()))());
+    const lock = acquireDirectoryLock({
+        locksRoot: validateExistingDirectory(join(context.generated.plan.state_root, "locks"), "schedule locks directory"),
+        lockId: "user-schedule",
+        ownerId: "oms-scheduler",
+        note: context.generated.digest,
+    });
+    try {
+        const existing = readInstallation(context);
+        if (existing?.schema_version === 1) {
+            throw new Error("legacy OMS user schedule is recorded; remove it before installing the version 2 schedule");
+        }
+        if (existing && !recordMatchesContext(existing, context)) {
+            throw new Error("a different OMS user schedule is already recorded; remove it before replacement");
+        }
+        const record = existing ?? createInstallationRecord(context, installedAt);
+        if (context.generated.plan.manager !== "cron")
+            ensureNativeArtifactDirectory(context);
+        installArtifacts(context);
+        if (!existing) {
+            assertSchema(record, installationSchema(context.packageRoot, 2), "user schedule installation");
+            writeJsonAtomicNoReplace(context.installationPath, record);
+        }
+        activateSchedule(context);
+        return Object.freeze({ status: existing ? "replayed" : "installed", record });
+    }
+    finally {
+        lock.release();
+    }
+}
+export function statusUserSchedule(options) {
+    const context = prepareContext(captureOptions(options));
+    const record = readInstallation(context);
+    if (record?.schema_version === 1) {
+        const bindingsExact = legacyRecordMatchesContext(record, context);
+        const artifactsExact = bindingsExact && legacyArtifactsAreExact(record, context);
+        return freezeStatus(context, "drifted", true, artifactsExact, bindingsExact && artifactsExact && managerIsActive(context), record.plan_sha256);
+    }
+    const artifactsExact = artifactsAreExact(context);
+    const bindingsExact = record !== null && recordMatchesContext(record, context);
+    if (!record && !hasAnyArtifacts(context)) {
+        return freezeStatus(context, "absent", false, true, false);
+    }
+    if (!bindingsExact || !artifactsExact) {
+        return freezeStatus(context, "drifted", record !== null, artifactsExact, false);
+    }
+    return freezeStatus(context, "installed", true, true, managerIsActive(context));
+}
+export function removeUserSchedule(options) {
+    const context = prepareContext(captureOptions(options));
+    const lock = acquireDirectoryLock({
+        locksRoot: validateExistingDirectory(join(context.generated.plan.state_root, "locks"), "schedule locks directory"),
+        lockId: "user-schedule",
+        ownerId: "oms-scheduler",
+        note: context.generated.digest,
+    });
+    try {
+        const record = readInstallation(context);
+        if (!record) {
+            if (hasAnyArtifacts(context))
+                throw new Error("refusing to remove an unrecorded user schedule");
+            return Object.freeze({ removed: false });
+        }
+        if (record.schema_version === 1) {
+            removeLegacyUserSchedule(context, record);
+            unlinkInstallationRecord(context);
+            return Object.freeze({ removed: true });
+        }
+        if (!recordMatchesContext(record, context))
+            throw new Error("recorded user schedule does not match removal authority");
+        assertArtifactsSafeToRemove(context);
+        deactivateSchedule(context);
+        removeArtifacts(context);
+        unlinkInstallationRecord(context);
+        return Object.freeze({ removed: true });
+    }
+    finally {
+        lock.release();
+    }
+}
+function captureOptions(options) {
+    return {
+        generated: options.generated,
+        packageRoot: options.packageRoot,
+        homeDirectory: options.homeDirectory,
+        installationsRoot: options.installationsRoot,
+        managerExecutablePath: options.managerExecutablePath,
+        runner: options.runner,
+        env: options.env,
+        clock: options.clock,
+    };
+}
+function prepareContext(captured) {
+    assertGeneratedUserSchedule(captured.generated);
+    const packageRoot = validateExistingDirectory(captured.packageRoot, "package root");
+    if (packageRoot !== userSchedulePackageRoot(captured.generated)) {
+        throw new Error("package root does not match the generated user schedule authority");
+    }
+    const homeDirectory = validateExistingDirectory(captured.homeDirectory, "user home directory");
+    const installationsRoot = validateExistingDirectory(captured.installationsRoot, "schedule installations directory");
+    const expectedInstallationsRoot = validateExistingDirectory(join(captured.generated.plan.state_root, "schedule-installations"), "runtime schedule installations directory");
+    if (installationsRoot !== expectedInstallationsRoot) {
+        throw new Error("schedule installations directory does not match the generated state root");
+    }
+    const managerExecutablePath = safeAbsolutePath(captured.managerExecutablePath, "schedule manager executable");
+    const userId = captured.generated.plan.manager === "launchd" ? currentUserId() : null;
+    return Object.freeze({
+        generated: captured.generated,
+        packageRoot,
+        homeDirectory,
+        installationsRoot,
+        installationPath: join(installationsRoot, INSTALLATION_FILE),
+        managerExecutablePath,
+        runner: captured.runner ?? runProcess,
+        env: managerEnvironment(captured.env ?? process.env, homeDirectory),
+        userId,
+        artifacts: Object.freeze(captured.generated.artifacts.map((artifact) => Object.freeze({
+            relative_path: artifact.relative_path,
+            installed_path: installedArtifactPath(captured.generated.plan.manager, homeDirectory, artifact),
+            sha256: artifact.sha256,
+        }))),
+    });
+}
+function createInstallationRecord(context, installedAt) {
+    return deepFreeze({
+        schema_version: 2,
+        manager: context.generated.plan.manager,
+        plan_sha256: context.generated.digest,
+        executable_path: context.generated.plan.executable_path,
+        environment_path: context.generated.plan.environment_path,
+        state_root: context.generated.plan.state_root,
+        workspace_root: context.generated.plan.workspace_root,
+        repository: context.generated.plan.repository,
+        github_poll_seconds: context.generated.plan.github_poll_seconds,
+        manager_executable_path: context.managerExecutablePath,
+        home_directory: context.homeDirectory,
+        user_id: context.userId,
+        installed_at: installedAt,
+        artifacts: context.artifacts,
+    });
+}
+function readInstallation(context) {
+    if (!lstatIfExists(context.installationPath))
+        return null;
+    const value = readJsonFileNoFollow(context.installationPath, 256 * 1024);
+    return parseInstallation(value, context.packageRoot);
+}
+function parseInstallation(value, packageRoot) {
+    if (!isRecord(value) || !Array.isArray(value.artifacts))
+        throw new Error("invalid user schedule installation");
+    const schemaVersion = value.schema_version;
+    if (schemaVersion !== 1 && schemaVersion !== 2)
+        throw new Error("unsupported user schedule installation version");
+    assertSchema(value, installationSchema(packageRoot, schemaVersion), "user schedule installation");
+    const artifacts = value.artifacts.map((entry, index) => {
+        if (!isRecord(entry))
+            throw new Error(`invalid user schedule installation artifact ${index}`);
+        return Object.freeze({
+            relative_path: readString(entry.relative_path, `installation artifact ${index} name`),
+            installed_path: entry.installed_path === null
+                ? null
+                : safeAbsolutePath(readString(entry.installed_path, `installation artifact ${index} path`), "installed artifact"),
+            sha256: readSha256(entry.sha256, `installation artifact ${index} sha256`),
+        });
+    });
+    const shared = {
+        manager: readManager(value.manager),
+        plan_sha256: readSha256(value.plan_sha256, "installation plan sha256"),
+        manager_executable_path: safeAbsolutePath(readString(value.manager_executable_path, "installation manager executable"), "installation manager executable"),
+        home_directory: safeAbsolutePath(readString(value.home_directory, "installation home"), "installation home"),
+        user_id: value.user_id === null ? null : readNonNegativeInteger(value.user_id, "installation user id"),
+        installed_at: canonicalTimestamp(value.installed_at),
+        artifacts: Object.freeze(artifacts),
+    };
+    if (schemaVersion === 1)
+        return deepFreeze({ schema_version: 1, ...shared });
+    return deepFreeze({
+        schema_version: 2,
+        ...shared,
+        executable_path: safeAbsolutePath(readString(value.executable_path, "installation OMS executable"), "installation OMS executable"),
+        environment_path: normalizeUserScheduleEnvironmentPath(readString(value.environment_path, "installation environment PATH", 16 * 1024)),
+        state_root: safeAbsolutePath(readString(value.state_root, "installation state root"), "installation state root"),
+        workspace_root: safeAbsolutePath(readString(value.workspace_root, "installation workspace root"), "installation workspace root"),
+        repository: readString(value.repository, "installation repository", 140),
+        github_poll_seconds: readPollSeconds(value.github_poll_seconds),
+    });
+}
+function recordMatchesContext(record, context) {
+    return record.manager === context.generated.plan.manager
+        && record.plan_sha256 === context.generated.digest
+        && record.executable_path === context.generated.plan.executable_path
+        && record.environment_path === context.generated.plan.environment_path
+        && record.state_root === context.generated.plan.state_root
+        && record.workspace_root === context.generated.plan.workspace_root
+        && record.repository === context.generated.plan.repository
+        && record.github_poll_seconds === context.generated.plan.github_poll_seconds
+        && record.manager_executable_path === context.managerExecutablePath
+        && record.home_directory === context.homeDirectory
+        && record.user_id === context.userId
+        && JSON.stringify(record.artifacts) === JSON.stringify(context.artifacts);
+}
+function legacyRecordMatchesContext(record, context) {
+    if (record.manager !== context.generated.plan.manager
+        || record.manager_executable_path !== context.managerExecutablePath
+        || record.home_directory !== context.homeDirectory
+        || record.user_id !== context.userId
+        || record.artifacts.length !== context.artifacts.length)
+        return false;
+    return record.artifacts.every((artifact, index) => {
+        const expected = context.artifacts[index];
+        return expected !== undefined
+            && artifact.relative_path === expected.relative_path
+            && artifact.installed_path === expected.installed_path;
+    });
+}
+function legacyArtifactsAreExact(record, context) {
+    if (record.manager === "cron") {
+        const managed = extractManagedBlock(readCrontab(context));
+        const expectedSha256 = record.artifacts[0]?.sha256;
+        return managed !== null && expectedSha256 !== undefined && sha256(`${managed}\n`) === expectedSha256;
+    }
+    return record.artifacts.every((artifact) => {
+        if (!artifact.installed_path)
+            return false;
+        const entry = lstatIfExists(artifact.installed_path);
+        if (!entry || entry.isSymbolicLink() || !entry.isFile())
+            return false;
+        try {
+            return sha256(readImmutableFile(artifact.installed_path, 1024 * 1024)) === artifact.sha256;
+        }
+        catch {
+            return false;
+        }
+    });
+}
+function removeLegacyUserSchedule(context, record) {
+    if (!legacyRecordMatchesContext(record, context)) {
+        throw new Error("legacy OMS user schedule does not match removal authority");
+    }
+    if (!legacyArtifactsAreSafeToRemove(record, context)) {
+        throw new Error("refusing to remove a changed legacy OMS user schedule");
+    }
+    deactivateSchedule(context);
+    if (record.manager === "cron") {
+        const existing = readCrontab(context);
+        writeCrontab(context, replaceManagedBlock(existing, null));
+        return;
+    }
+    for (const artifact of record.artifacts) {
+        if (artifact.installed_path && lstatIfExists(artifact.installed_path))
+            unlinkSync(artifact.installed_path);
+    }
+    if (record.manager === "systemd")
+        runRequired(context, ["--user", "daemon-reload"]);
+}
+function legacyArtifactsAreSafeToRemove(record, context) {
+    if (record.manager === "cron") {
+        const managed = extractManagedBlock(readCrontab(context));
+        const expectedSha256 = record.artifacts[0]?.sha256;
+        return managed === null || (expectedSha256 !== undefined && sha256(`${managed}\n`) === expectedSha256);
+    }
+    return record.artifacts.every((artifact) => {
+        if (!artifact.installed_path)
+            return false;
+        const entry = lstatIfExists(artifact.installed_path);
+        if (!entry)
+            return true;
+        if (entry.isSymbolicLink() || !entry.isFile())
+            return false;
+        try {
+            return sha256(readImmutableFile(artifact.installed_path, 1024 * 1024)) === artifact.sha256;
+        }
+        catch {
+            return false;
+        }
+    });
+}
+function unlinkInstallationRecord(context) {
+    const entry = lstatIfExists(context.installationPath);
+    if (!entry || entry.isSymbolicLink() || !entry.isFile()) {
+        throw new Error("schedule installation record changed before removal");
+    }
+    unlinkSync(context.installationPath);
+}
+function installArtifacts(context) {
+    if (context.generated.plan.manager === "cron") {
+        const existing = readCrontab(context);
+        const expected = context.generated.artifacts[0]?.bytes.trimEnd();
+        if (!expected)
+            throw new Error("generated cron schedule is missing");
+        const managed = extractManagedBlock(existing);
+        if (managed !== null && managed !== expected)
+            throw new Error("existing OMS crontab block differs from generated schedule");
+        if (managed === null)
+            writeCrontab(context, replaceManagedBlock(existing, expected));
+        return;
+    }
+    for (const [index, artifact] of context.generated.artifacts.entries()) {
+        const installedPath = context.artifacts[index]?.installed_path;
+        if (!installedPath)
+            throw new Error("native schedule artifact path is missing");
+        const bytes = Buffer.from(artifact.bytes, "utf8");
+        const entry = lstatIfExists(installedPath);
+        if (entry) {
+            if (entry.isSymbolicLink() || !entry.isFile())
+                throw new Error(`schedule artifact is not a regular file: ${installedPath}`);
+            if (!readImmutableFile(installedPath, 1024 * 1024).equals(bytes)) {
+                throw new Error(`existing schedule artifact differs: ${artifact.relative_path}`);
+            }
+            continue;
+        }
+        writeFileAtomic(installedPath, artifact.bytes, 0o600);
+    }
+}
+function activateSchedule(context) {
+    if (context.generated.plan.manager === "cron")
+        return;
+    if (context.generated.plan.manager === "systemd") {
+        runRequired(context, ["--user", "daemon-reload"]);
+        runRequired(context, ["--user", "enable", "--now", ...timerUnitNames(context.generated)]);
+        return;
+    }
+    const domain = launchdDomain(context);
+    for (const item of context.generated.plan.jobs) {
+        const label = userScheduleLaunchdLabel(item.id);
+        runTolerant(context, ["bootout", `${domain}/${label}`]);
+        const artifact = context.artifacts.find((candidate) => candidate.relative_path === `${label}.plist`);
+        if (!artifact?.installed_path)
+            throw new Error(`launchd artifact is missing: ${label}`);
+        runRequired(context, ["bootstrap", domain, artifact.installed_path]);
+    }
+}
+function deactivateSchedule(context) {
+    if (context.generated.plan.manager === "cron")
+        return;
+    if (context.generated.plan.manager === "systemd") {
+        for (const timer of timerUnitNames(context.generated)) {
+            runDeactivation(context, ["--user", "disable", "--now", timer]);
+        }
+        return;
+    }
+    const domain = launchdDomain(context);
+    for (const item of context.generated.plan.jobs) {
+        runDeactivation(context, ["bootout", `${domain}/${userScheduleLaunchdLabel(item.id)}`]);
+    }
+}
+function managerIsActive(context) {
+    if (context.generated.plan.manager === "cron")
+        return extractManagedBlock(readCrontab(context)) !== null;
+    if (context.generated.plan.manager === "systemd") {
+        return runForStatus(context, ["--user", "is-active", ...timerUnitNames(context.generated)]);
+    }
+    const domain = launchdDomain(context);
+    return context.generated.plan.jobs.every((item) => (runForStatus(context, ["print", `${domain}/${userScheduleLaunchdLabel(item.id)}`])));
+}
+function artifactsAreExact(context) {
+    if (context.generated.plan.manager === "cron") {
+        const expected = context.generated.artifacts[0]?.bytes.trimEnd();
+        return expected !== undefined && extractManagedBlock(readCrontab(context)) === expected;
+    }
+    return context.generated.artifacts.every((artifact, index) => {
+        const path = context.artifacts[index]?.installed_path;
+        if (!path)
+            return false;
+        const entry = lstatIfExists(path);
+        if (!entry || entry.isSymbolicLink() || !entry.isFile())
+            return false;
+        try {
+            return readImmutableFile(path, 1024 * 1024).equals(Buffer.from(artifact.bytes, "utf8"));
+        }
+        catch {
+            return false;
+        }
+    });
+}
+function hasAnyArtifacts(context) {
+    if (context.generated.plan.manager === "cron")
+        return extractManagedBlock(readCrontab(context)) !== null;
+    return context.artifacts.some((artifact) => artifact.installed_path !== null && lstatIfExists(artifact.installed_path));
+}
+function assertArtifactsSafeToRemove(context) {
+    if (context.generated.plan.manager === "cron") {
+        const managed = extractManagedBlock(readCrontab(context));
+        const expected = context.generated.artifacts[0]?.bytes.trimEnd();
+        if (managed !== null && managed !== expected)
+            throw new Error("refusing to remove a changed OMS crontab block");
+        return;
+    }
+    for (const [index, artifact] of context.generated.artifacts.entries()) {
+        const path = context.artifacts[index]?.installed_path;
+        if (!path)
+            throw new Error("native schedule artifact path is missing");
+        const entry = lstatIfExists(path);
+        if (!entry)
+            continue;
+        if (entry.isSymbolicLink() || !entry.isFile())
+            throw new Error(`refusing to remove changed schedule artifact: ${path}`);
+        if (!readImmutableFile(path, 1024 * 1024).equals(Buffer.from(artifact.bytes, "utf8"))) {
+            throw new Error(`refusing to remove changed schedule artifact: ${artifact.relative_path}`);
+        }
+    }
+}
+function removeArtifacts(context) {
+    if (context.generated.plan.manager === "cron") {
+        const existing = readCrontab(context);
+        const managed = extractManagedBlock(existing);
+        const expected = context.generated.artifacts[0]?.bytes.trimEnd();
+        if (managed !== null && managed !== expected)
+            throw new Error("refusing to remove a changed OMS crontab block");
+        if (managed !== null)
+            writeCrontab(context, replaceManagedBlock(existing, null));
+        return;
+    }
+    for (const [index, artifact] of context.artifacts.entries()) {
+        if (!artifact.installed_path || !lstatIfExists(artifact.installed_path))
+            continue;
+        const expected = context.generated.artifacts[index];
+        if (!expected || !readImmutableFile(artifact.installed_path, 1024 * 1024).equals(Buffer.from(expected.bytes, "utf8"))) {
+            throw new Error(`refusing to remove changed schedule artifact: ${artifact.relative_path}`);
+        }
+        unlinkSync(artifact.installed_path);
+    }
+    if (context.generated.plan.manager === "systemd")
+        runRequired(context, ["--user", "daemon-reload"]);
+}
+function ensureNativeArtifactDirectory(context) {
+    const segments = context.generated.plan.manager === "systemd"
+        ? [".config", "systemd", "user"]
+        : ["Library", "LaunchAgents"];
+    let current = context.homeDirectory;
+    for (const segment of segments) {
+        current = join(current, segment);
+        const entry = lstatIfExists(current);
+        if (!entry)
+            mkdirSync(current, { mode: 0o700 });
+        const created = lstatIfExists(current);
+        if (!created || created.isSymbolicLink() || !created.isDirectory()) {
+            throw new Error(`user schedule directory is unsafe: ${current}`);
+        }
+    }
+    const canonical = validateExistingDirectory(current, "user schedule artifact directory");
+    if (canonical !== resolve(current))
+        throw new Error("user schedule artifact directory must not use symbolic links");
+    return canonical;
+}
+function installedArtifactPath(manager, homeDirectory, artifact) {
+    if (manager === "cron")
+        return null;
+    const root = manager === "systemd"
+        ? join(homeDirectory, ".config", "systemd", "user")
+        : join(homeDirectory, "Library", "LaunchAgents");
+    if (!/^[A-Za-z0-9][A-Za-z0-9.-]{0,127}$/.test(artifact.relative_path)) {
+        throw new Error("unsafe user schedule artifact name");
+    }
+    return join(root, artifact.relative_path);
+}
+function readCrontab(context) {
+    const result = runManager(context, ["-l"]);
+    if (result.error)
+        throw new Error("unable to start user crontab command");
+    if (result.status === 1 && result.signal === null && /no crontab/iu.test(result.stderr))
+        return "";
+    if (result.status !== 0 || result.signal !== null)
+        throw new Error("unable to read user crontab");
+    if (Buffer.byteLength(result.stdout, "utf8") > MAX_CRONTAB_BYTES)
+        throw new Error("user crontab exceeds size limit");
+    return result.stdout;
+}
+function writeCrontab(context, content) {
+    if (Buffer.byteLength(content, "utf8") > MAX_CRONTAB_BYTES)
+        throw new Error("user crontab exceeds size limit");
+    runRequired(context, ["-"], content);
+}
+function extractManagedBlock(existing) {
+    const begin = markerMatches(existing, USER_SCHEDULE_BLOCK_BEGIN);
+    const end = markerMatches(existing, USER_SCHEDULE_BLOCK_END);
+    if (begin.length === 0 && end.length === 0)
+        return null;
+    if (begin.length !== 1 || end.length !== 1 || begin[0] === undefined || end[0] === undefined || begin[0] >= end[0]) {
+        throw new Error("user crontab has malformed OMS schedule markers");
+    }
+    const endOffset = end[0] + USER_SCHEDULE_BLOCK_END.length;
+    return existing.slice(begin[0], endOffset);
+}
+function replaceManagedBlock(existing, block) {
+    const begin = markerMatches(existing, USER_SCHEDULE_BLOCK_BEGIN);
+    const end = markerMatches(existing, USER_SCHEDULE_BLOCK_END);
+    if (begin.length === 0 && end.length === 0) {
+        if (block === null)
+            return existing;
+        const prefix = existing.length === 0 ? "" : existing.endsWith("\n") ? existing : `${existing}\n`;
+        return `${prefix}${block}\n`;
+    }
+    if (begin.length !== 1 || end.length !== 1 || begin[0] === undefined || end[0] === undefined || begin[0] >= end[0]) {
+        throw new Error("user crontab has malformed OMS schedule markers");
+    }
+    let afterOffset = end[0] + USER_SCHEDULE_BLOCK_END.length;
+    if (existing[afterOffset] === "\n")
+        afterOffset += 1;
+    return `${existing.slice(0, begin[0])}${block === null ? "" : `${block}\n`}${existing.slice(afterOffset)}`;
+}
+function markerMatches(existing, marker) {
+    const indexes = [];
+    let offset = 0;
+    for (const line of existing.split("\n")) {
+        if (line === marker)
+            indexes.push(offset);
+        offset += line.length + 1;
+    }
+    return indexes;
+}
+function runManager(context, args, input) {
+    const request = Object.freeze({
+        command: context.managerExecutablePath,
+        args: Object.freeze([...args]),
+        cwd: context.homeDirectory,
+        env: context.env,
+        input,
+        timeoutMs: 30_000,
+        maxBufferBytes: MAX_MANAGER_OUTPUT_BYTES,
+    });
+    const result = context.runner(request);
+    if (Buffer.byteLength(result.stdout, "utf8") > MAX_MANAGER_OUTPUT_BYTES
+        || Buffer.byteLength(result.stderr, "utf8") > MAX_MANAGER_OUTPUT_BYTES)
+        throw new Error("schedule manager output exceeds size limit");
+    return result;
+}
+function runRequired(context, args, input) {
+    const result = runManager(context, args, input);
+    if (result.error || result.status !== 0 || result.signal !== null)
+        throw new Error("user schedule manager command failed");
+}
+function runTolerant(context, args) {
+    const result = runManager(context, args);
+    if (result.error)
+        throw new Error("unable to start user schedule manager command");
+}
+function runDeactivation(context, args) {
+    const result = runManager(context, args);
+    if (result.error)
+        throw new Error("unable to start user schedule manager command");
+    if (result.status === 0 && result.signal === null)
+        return;
+    if (result.signal === null && result.status !== null && explicitlyAlreadyAbsent(context, result))
+        return;
+    throw new Error("user schedule manager deactivation failed");
+}
+function explicitlyAlreadyAbsent(context, result) {
+    const lines = `${result.stdout}\n${result.stderr}`
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    if (lines.length === 0)
+        return false;
+    if (context.generated.plan.manager === "systemd") {
+        return lines.every((line) => /^(?:Failed to disable unit:\s*)?Unit (?:file )?[^\s]+ (?:does not exist|not found|not loaded)\.?$/iu.test(line));
+    }
+    if (context.generated.plan.manager === "launchd") {
+        return lines.every((line) => /^(?:Boot-out failed:\s*[0-9]+:\s*)?(?:Could not find specified service|No such process|Service is not loaded)\.?$/iu.test(line));
+    }
+    return false;
+}
+function runForStatus(context, args) {
+    const result = runManager(context, args);
+    return !result.error && result.status === 0 && result.signal === null;
+}
+function timerUnitNames(generated) {
+    return generated.plan.jobs.map((item) => `${userScheduleArtifactBaseName(item.id)}.timer`);
+}
+function launchdDomain(context) {
+    if (context.userId === null)
+        throw new Error("launchd user id is unavailable");
+    return `gui/${context.userId}`;
+}
+function currentUserId() {
+    const value = process.getuid?.();
+    if (!Number.isSafeInteger(value) || value === undefined || value < 0)
+        throw new Error("launchd requires a current user id");
+    return value;
+}
+function managerEnvironment(input, homeDirectory) {
+    const env = { HOME: homeDirectory };
+    for (const key of ["PATH", "USER", "LOGNAME", "LANG", "LC_ALL", "XDG_RUNTIME_DIR", "DBUS_SESSION_BUS_ADDRESS"]) {
+        if (input[key] !== undefined)
+            env[key] = input[key];
+    }
+    return Object.freeze(env);
+}
+function installationSchema(packageRoot, version) {
+    const fileName = version === 1
+        ? "user-schedule-installation-v1.schema.json"
+        : "user-schedule-installation.schema.json";
+    return loadJsonSchema(join(packageRoot, "schemas", fileName));
+}
+function freezeStatus(context, state, recorded, artifactsExact, active, planSha256 = context.generated.digest) {
+    return Object.freeze({
+        state,
+        manager: context.generated.plan.manager,
+        plan_sha256: planSha256,
+        recorded,
+        artifacts_exact: artifactsExact,
+        active,
+    });
+}
+function safeAbsolutePath(value, label) {
+    if (typeof value !== "string" || !isAbsolute(value) || /[\0\r\n]/u.test(value)) {
+        throw new Error(`${label} must be an absolute path without control characters`);
+    }
+    if (/(?:token|secret|password|api[_-]?key)=/iu.test(value))
+        throw new Error(`${label} appears to contain a secret`);
+    return value;
+}
+function readString(value, label, maxLength = 4096) {
+    if (typeof value !== "string" || value.length < 1 || value.length > maxLength) {
+        throw new Error(`${label} must be a string`);
+    }
+    return value;
+}
+function readPollSeconds(value) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 60 || value > 3_600) {
+        throw new Error("installation GitHub poll interval must be an integer from 60 to 3600 seconds");
+    }
+    return value;
+}
+function readManager(value) {
+    if (value !== "cron" && value !== "systemd" && value !== "launchd")
+        throw new Error("invalid installation manager");
+    return value;
+}
+function readSha256(value, label) {
+    if (typeof value !== "string" || !SHA256_PATTERN.test(value))
+        throw new Error(`${label} must be sha256`);
+    return value;
+}
+function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function readNonNegativeInteger(value, label) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        throw new Error(`${label} must be a non-negative integer`);
+    }
+    return value;
+}
+function canonicalTimestamp(value) {
+    if (typeof value !== "string")
+        throw new Error("schedule timestamp must be a string");
+    const epoch = Date.parse(value);
+    if (!Number.isFinite(epoch) || new Date(epoch).toISOString() !== value) {
+        throw new Error("schedule timestamp must be canonical UTC");
+    }
+    return value;
+}
+function deepFreeze(value, seen = new Set()) {
+    if (typeof value !== "object" || value === null || seen.has(value))
+        return value;
+    seen.add(value);
+    for (const child of Object.values(value))
+        deepFreeze(child, seen);
+    return Object.freeze(value);
+}
+//# sourceMappingURL=user-installation.js.map