@microck/canonfig 2.0.0

package/dist/runtime/main.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { NodeRuntime } from "@effect/platform-node";
+import { Effect } from "effect";
+import { evaluateCli, runCli } from "../cli/cli.js";
+const warningListeners = process.listeners("warning");
+process.removeAllListeners("warning");
+process.on("warning", (warning) => {
+    if (warning.name === "ExperimentalWarning"
+        && warning.message === "SQLite is an experimental feature and might change at any time")
+        return;
+    for (const listener of warningListeners)
+        listener.call(process, warning);
+});
+const nodeCliIo = {
+    writeStdout: (text) => process.stdout.write(text),
+    writeStderr: (text) => process.stderr.write(text),
+    setExitCode: (exitCode) => {
+        process.exitCode = exitCode;
+    },
+};
+const arguments_ = process.argv.slice(2);
+const outcome = evaluateCli(arguments_);
+if (outcome._tag === "Command") {
+    NodeRuntime.runMain(Effect.promise(() => import("./layers.js")).pipe(Effect.flatMap(({ runtimeLayer }) => runCli(arguments_, nodeCliIo).pipe(Effect.andThen(outcome.command._tag === "SourceServe"
+        ? Effect.never
+        : Effect.void), Effect.provide(runtimeLayer())))));
+}
+else {
+    NodeRuntime.runMain(Effect.sync(() => {
+        if (outcome._tag === "Help" || outcome._tag === "Version") {
+            nodeCliIo.writeStdout(`${outcome.text}\n`);
+        }
+        else {
+            nodeCliIo.writeStderr(`${outcome.message}\n`);
+        }
+        nodeCliIo.setExitCode(outcome.exitCode);
+    }));
+}

package/dist/schedule/linux-schedule.js

@@ -0,0 +1,24 @@
+import { normalizeSyncSchedule, } from "./schedule-manager.types.js";
+export const linuxCalendar = (input) => {
+    const schedule = normalizeSyncSchedule(input);
+    if (schedule.kind === "daily") {
+        return {
+            kind: "daily",
+            localTime: schedule.localTime,
+            timezone: schedule.timezone,
+        };
+    }
+    if (schedule.kind === "weekly") {
+        return {
+            kind: "weekly",
+            weekdays: schedule.weekdays,
+            localTime: schedule.localTime,
+            timezone: schedule.timezone,
+        };
+    }
+    return {
+        kind: "systemd-on-calendar",
+        expression: schedule.expression,
+        timezone: schedule.timezone,
+    };
+};

package/dist/schedule/macos-schedule.js

@@ -0,0 +1,25 @@
+import { Effect } from "effect";
+import { ScheduleHumanActionRequiredError } from "./schedule-manager.errors.js";
+import { normalizeSyncSchedule, } from "./schedule-manager.types.js";
+export const macosCalendar = (schedule) => {
+    schedule = normalizeSyncSchedule(schedule);
+    if (schedule.kind === "custom") {
+        return Effect.fail(new ScheduleHumanActionRequiredError({
+            action: "use a daily or weekly schedule on macOS",
+            recovery: "launchd does not support the requested custom calendar expression. Choose a daily or weekly schedule, then retry.",
+        }));
+    }
+    if (schedule.timezone !== undefined) {
+        return Effect.fail(new ScheduleHumanActionRequiredError({
+            action: "use the macOS follower timezone for scheduled sync",
+            recovery: "launchd calendar intervals follow the macOS user timezone and cannot bind a named timezone. Remove the explicit timezone or change the follower timezone.",
+        }));
+    }
+    return Effect.succeed(schedule.kind === "daily"
+        ? { kind: "daily", localTime: schedule.localTime }
+        : {
+            kind: "weekly",
+            weekdays: schedule.weekdays,
+            localTime: schedule.localTime,
+        });
+};

package/dist/schedule/schedule-manager.errors.js

@@ -0,0 +1,17 @@
+import { Schema } from "effect";
+export class InvalidScheduleError extends Schema.TaggedError()("InvalidScheduleError", {
+    field: Schema.String,
+    message: Schema.String,
+}) {
+}
+export class ScheduleHumanActionRequiredError extends Schema.TaggedError()("ScheduleHumanActionRequiredError", {
+    action: Schema.String,
+    recovery: Schema.String,
+}) {
+}
+export class ScheduleVerificationError extends Schema.TaggedError()("ScheduleVerificationError", {
+    operation: Schema.String,
+    state: Schema.String,
+    message: Schema.String,
+}) {
+}

package/dist/schedule/schedule-manager.layer.js

@@ -0,0 +1,205 @@
+import { Effect, Layer } from "effect";
+import { MachineState } from "../machine/machine-state.service.js";
+import { linuxCalendar } from "./linux-schedule.js";
+import { macosCalendar } from "./macos-schedule.js";
+import { InvalidScheduleError, ScheduleVerificationError, } from "./schedule-manager.errors.js";
+import { ScheduleManager } from "./schedule-manager.service.js";
+import { defaultSyncSchedule, normalizeSyncSchedule, } from "./schedule-manager.types.js";
+import { windowsCalendar } from "./windows-schedule.js";
+const syncArguments = ["sync", "--apply", "--no-input"];
+const validLocalTime = /^([01]\d|2[0-3]):[0-5]\d$/u;
+const validateSchedule = (schedule) => {
+    schedule = normalizeSyncSchedule(schedule);
+    if (schedule.kind === "custom") {
+        if (schedule.expression.trim() !== schedule.expression
+            || schedule.expression.length === 0
+            || /[\n\r\0]/u.test(schedule.expression)) {
+            return Effect.fail(new InvalidScheduleError({
+                field: "expression",
+                message: "custom calendar expression must be non-empty and single-line",
+            }));
+        }
+        if (schedule.timezone === undefined)
+            return Effect.succeed(schedule);
+        if (schedule.timezone.trim() !== schedule.timezone
+            || schedule.timezone.length === 0
+            || /[\n\r\0]/u.test(schedule.timezone)) {
+            return Effect.fail(new InvalidScheduleError({
+                field: "timezone",
+                message: "timezone must be a non-empty IANA timezone name",
+            }));
+        }
+        try {
+            new Intl.DateTimeFormat("en-US", { timeZone: schedule.timezone }).format();
+        }
+        catch {
+            return Effect.fail(new InvalidScheduleError({
+                field: "timezone",
+                message: `unsupported IANA timezone: ${schedule.timezone}`,
+            }));
+        }
+        return Effect.succeed(schedule);
+    }
+    if (!validLocalTime.test(schedule.localTime)) {
+        return Effect.fail(new InvalidScheduleError({
+            field: "localTime",
+            message: "local time must use 24-hour HH:mm format",
+        }));
+    }
+    if (schedule.kind === "weekly" && schedule.weekdays.length === 0) {
+        return Effect.fail(new InvalidScheduleError({
+            field: "weekdays",
+            message: "weekly schedule must declare at least one weekday",
+        }));
+    }
+    if (schedule.timezone === undefined)
+        return Effect.succeed(schedule);
+    if (schedule.timezone.trim() !== schedule.timezone
+        || schedule.timezone.length === 0
+        || /[\n\r\0]/u.test(schedule.timezone)) {
+        return Effect.fail(new InvalidScheduleError({
+            field: "timezone",
+            message: "timezone must be a non-empty IANA timezone name",
+        }));
+    }
+    try {
+        new Intl.DateTimeFormat("en-US", { timeZone: schedule.timezone }).format();
+    }
+    catch {
+        return Effect.fail(new InvalidScheduleError({
+            field: "timezone",
+            message: `unsupported IANA timezone: ${schedule.timezone}`,
+        }));
+    }
+    return Effect.succeed(schedule);
+};
+const calendarFor = (platform, schedule) => {
+    switch (platform) {
+        case "linux":
+            return Effect.succeed(linuxCalendar(schedule));
+        case "macos":
+            return macosCalendar(schedule);
+        case "windows":
+            return windowsCalendar(schedule);
+    }
+};
+const stateOf = (installed, enabled, matches) => {
+    if (!installed)
+        return "not-installed";
+    if (!matches)
+        return "drifted";
+    return enabled ? "current" : "disabled";
+};
+const snapshotsEqual = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+export const scheduleManagerLayer = Layer.effect(ScheduleManager, Effect.gen(function* () {
+    const machine = yield* MachineState;
+    const definition = Effect.fn("ScheduleManager.definition")(function* (input = {}) {
+        const schedule = yield* validateSchedule(input.schedule ?? defaultSyncSchedule);
+        const executable = input.executable === undefined
+            ? (yield* machine.findExecutable({ name: "canonfig" })).path
+            : yield* machine.normalizePath({ path: input.executable });
+        const calendar = yield* calendarFor(executable.platform, schedule);
+        const rendered = yield* machine.renderSchedulerJob({
+            name: "canonfig-sync",
+            description: "Canonfig follower synchronization",
+            executable,
+            arguments: syncArguments,
+            calendar,
+        });
+        return { schedule, definition: rendered };
+    });
+    const inspect = Effect.fn("ScheduleManager.inspect")(function* (input = {}) {
+        const desired = yield* definition(input);
+        const inspection = yield* machine.inspectSchedulerJob(desired.definition);
+        return {
+            state: stateOf(inspection.installed, inspection.enabled, inspection.matches),
+            platform: desired.definition.platform,
+            schedule: desired.schedule,
+            definition: desired.definition,
+        };
+    });
+    const snapshot = Effect.fn("ScheduleManager.snapshot")(function* (input = {}) {
+        const desired = yield* definition(input);
+        return yield* machine.snapshotSchedulerJob(desired.definition);
+    });
+    const restore = Effect.fn("ScheduleManager.restore")(function* (input, prior) {
+        const desired = yield* definition(input ?? {});
+        if (prior.platform !== desired.definition.platform
+            || prior.mechanism !== desired.definition.mechanism
+            || prior.serviceName !== desired.definition.serviceName) {
+            return yield* new ScheduleVerificationError({
+                operation: "restore",
+                state: "invalid-snapshot",
+                message: "native scheduler snapshot does not belong to this schedule",
+            });
+        }
+        yield* machine.restoreSchedulerJob(desired.definition, prior);
+        const after = yield* machine.snapshotSchedulerJob(desired.definition);
+        if (!snapshotsEqual(after, prior)) {
+            return yield* new ScheduleVerificationError({
+                operation: "restore",
+                state: after.state,
+                message: "native scheduler did not restore its exact prior state",
+            });
+        }
+    });
+    const upsert = Effect.fn("ScheduleManager.upsert")(function* (input = {}) {
+        const desired = yield* definition(input);
+        const before = yield* machine.inspectSchedulerJob(desired.definition);
+        if (before.installed && before.enabled && before.matches) {
+            return {
+                change: "unchanged",
+                status: {
+                    state: "current",
+                    platform: desired.definition.platform,
+                    schedule: desired.schedule,
+                    definition: desired.definition,
+                },
+            };
+        }
+        yield* machine.installSchedulerJob(desired.definition);
+        const after = yield* machine.inspectSchedulerJob(desired.definition);
+        const afterState = stateOf(after.installed, after.enabled, after.matches);
+        if (afterState !== "current") {
+            return yield* new ScheduleVerificationError({
+                operation: before.installed ? "update" : "install",
+                state: afterState,
+                message: "native scheduler did not converge to the requested definition",
+            });
+        }
+        return {
+            change: before.installed ? "updated" : "installed",
+            status: {
+                state: afterState,
+                platform: desired.definition.platform,
+                schedule: desired.schedule,
+                definition: desired.definition,
+            },
+        };
+    });
+    const remove = Effect.fn("ScheduleManager.remove")(function* (input = {}) {
+        const desired = yield* definition(input);
+        const before = yield* machine.inspectSchedulerJob(desired.definition);
+        if (!before.installed)
+            return { change: "unchanged" };
+        yield* machine.removeSchedulerJob(desired.definition);
+        const after = yield* machine.inspectSchedulerJob(desired.definition);
+        if (after.installed) {
+            return yield* new ScheduleVerificationError({
+                operation: "remove",
+                state: stateOf(after.installed, after.enabled, after.matches),
+                message: "native scheduler still reports the schedule as installed",
+            });
+        }
+        return { change: "removed" };
+    });
+    return ScheduleManager.of({
+        install: upsert,
+        inspect,
+        snapshot,
+        restore,
+        update: upsert,
+        status: inspect,
+        remove,
+    });
+}));

package/dist/schedule/schedule-manager.service.js

@@ -0,0 +1,3 @@
+import { Context } from "effect";
+export class ScheduleManager extends Context.Service()("canonfig/schedule/ScheduleManager") {
+}

package/dist/schedule/schedule-manager.types.js

@@ -0,0 +1,114 @@
+import { Schema } from "effect";
+export const scheduleWeekdays = [
+    "Mon",
+    "Tue",
+    "Wed",
+    "Thu",
+    "Fri",
+    "Sat",
+    "Sun",
+];
+const isScheduleWeekday = (value) => scheduleWeekdays.some((candidate) => candidate === value);
+export const SyncScheduleSchema = Schema.Union([
+    Schema.Struct({
+        kind: Schema.Literal("daily"),
+        localTime: Schema.NonEmptyString,
+        timezone: Schema.optional(Schema.NonEmptyString),
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("weekly"),
+        weekdays: Schema.Array(Schema.Literals(scheduleWeekdays)),
+        localTime: Schema.NonEmptyString,
+        timezone: Schema.optional(Schema.NonEmptyString),
+    }),
+    // Accept v2 schedules written before multi-day weekly schedules were
+    // introduced. Normalization below converts this shape to `weekdays`.
+    Schema.Struct({
+        kind: Schema.Literal("weekly"),
+        weekday: Schema.Literals(scheduleWeekdays),
+        localTime: Schema.NonEmptyString,
+        timezone: Schema.optional(Schema.NonEmptyString),
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("custom"),
+        expression: Schema.NonEmptyString,
+        timezone: Schema.optional(Schema.NonEmptyString),
+    }),
+]);
+export const defaultSyncSchedule = {
+    kind: "daily",
+    localTime: "00:00",
+};
+/** Convert the signed profile-level schedule contract to native scheduler input. */
+export const syncScheduleFromDefault = (schedule) => {
+    const timezone = schedule.timezone === "local" ? undefined : schedule.timezone;
+    switch (schedule.type) {
+        case "daily":
+            return timezone === undefined
+                ? { kind: "daily", localTime: schedule.at }
+                : { kind: "daily", localTime: schedule.at, timezone };
+        case "weekly": {
+            const weekdays = schedule.days.map((value) => {
+                const weekday = `${value.slice(0, 1).toUpperCase()}${value.slice(1).toLowerCase()}`;
+                if (!isScheduleWeekday(weekday)) {
+                    throw new Error(`unsupported schedule weekday: ${value}`);
+                }
+                return weekday;
+            });
+            const normalized = {
+                kind: "weekly",
+                weekdays: [...new Set(weekdays)].sort((left, right) => weekdayIndex.get(left) - weekdayIndex.get(right)),
+                localTime: schedule.at,
+            };
+            return timezone === undefined ? normalized : { ...normalized, timezone };
+        }
+        case "custom":
+            return timezone === undefined
+                ? { kind: "custom", expression: schedule.expression }
+                : { kind: "custom", expression: schedule.expression, timezone };
+    }
+};
+const weekdayIndex = new Map(scheduleWeekdays.map((weekday, index) => [weekday, index]));
+export const scheduleWeekdaysFor = (schedule) => "weekdays" in schedule
+    ? [...new Set(schedule.weekdays)].sort((left, right) => weekdayIndex.get(left) - weekdayIndex.get(right))
+    : [schedule.weekday];
+export const normalizeSyncSchedule = (schedule) => {
+    if (schedule.kind !== "weekly")
+        return schedule;
+    const normalized = {
+        kind: "weekly",
+        weekdays: scheduleWeekdaysFor(schedule),
+        localTime: schedule.localTime,
+    };
+    return schedule.timezone === undefined
+        ? normalized
+        : { ...normalized, timezone: schedule.timezone };
+};
+export const syncScheduleFromResourceSpec = (spec) => {
+    const timezone = spec.timezone === "local" ? undefined : spec.timezone;
+    switch (spec.calendar.type) {
+        case "daily":
+            return { kind: "daily", localTime: spec.calendar.at, timezone };
+        case "weekly": {
+            const weekdays = spec.calendar.days.map((value) => {
+                const weekday = `${value.slice(0, 1).toUpperCase()}${value.slice(1).toLowerCase()}`;
+                if (!isScheduleWeekday(weekday)) {
+                    throw new Error(`unsupported schedule weekday: ${value}`);
+                }
+                return weekday;
+            });
+            const normalized = {
+                kind: "weekly",
+                weekdays: [...new Set(weekdays)].sort((left, right) => weekdayIndex.get(left) - weekdayIndex.get(right)),
+                localTime: spec.calendar.at,
+            };
+            return timezone === undefined ? normalized : { ...normalized, timezone };
+        }
+        case "custom":
+            return {
+                kind: "custom",
+                expression: spec.calendar.expression,
+                timezone,
+            };
+    }
+};

package/dist/schedule/windows-schedule.js

@@ -0,0 +1,25 @@
+import { Effect } from "effect";
+import { ScheduleHumanActionRequiredError } from "./schedule-manager.errors.js";
+import { normalizeSyncSchedule, } from "./schedule-manager.types.js";
+export const windowsCalendar = (schedule) => {
+    schedule = normalizeSyncSchedule(schedule);
+    if (schedule.kind === "custom") {
+        return Effect.fail(new ScheduleHumanActionRequiredError({
+            action: "use a daily or weekly schedule on Windows",
+            recovery: "Task Scheduler does not support the requested custom calendar expression. Choose a daily or weekly schedule, then retry.",
+        }));
+    }
+    if (schedule.timezone !== undefined) {
+        return Effect.fail(new ScheduleHumanActionRequiredError({
+            action: "use the Windows follower timezone for scheduled sync",
+            recovery: "Task Scheduler calendar triggers follow the Windows user timezone and cannot preserve a named IANA timezone across DST. Remove the explicit timezone or change the follower timezone.",
+        }));
+    }
+    return Effect.succeed(schedule.kind === "daily"
+        ? { kind: "daily", localTime: schedule.localTime }
+        : {
+            kind: "weekly",
+            weekdays: schedule.weekdays,
+            localTime: schedule.localTime,
+        });
+};

package/dist/state/state-repository.errors.js

@@ -0,0 +1,55 @@
+import { Schema } from "effect";
+export class RepositorySqlError extends Schema.TaggedError()("RepositorySqlError", {
+    operation: Schema.String,
+    message: Schema.String,
+}) {
+}
+export class RepositoryDecodeError extends Schema.TaggedError()("RepositoryDecodeError", {
+    entity: Schema.String,
+    id: Schema.String,
+    message: Schema.String,
+}) {
+}
+export class RevisionImmutableError extends Schema.TaggedError()("RevisionImmutableError", {
+    revision: Schema.String,
+    message: Schema.String,
+}) {
+}
+export class ActiveRunExistsError extends Schema.TaggedError()("ActiveRunExistsError", {
+    follower: Schema.String,
+}) {
+}
+export class FollowerNotFoundError extends Schema.TaggedError()("FollowerNotFoundError", {
+    follower: Schema.String,
+}) {
+}
+export class RevisionNotFoundError extends Schema.TaggedError()("RevisionNotFoundError", {
+    revision: Schema.String,
+}) {
+}
+export class RunNotFoundError extends Schema.TaggedError()("RunNotFoundError", {
+    run: Schema.String,
+}) {
+}
+export class ActionNotInPlanError extends Schema.TaggedError()("ActionNotInPlanError", {
+    run: Schema.String,
+    action: Schema.String,
+}) {
+}
+export class InvalidRunTransitionError extends Schema.TaggedError()("InvalidRunTransitionError", {
+    run: Schema.String,
+    message: Schema.String,
+}) {
+}
+export class EnrollmentStateConflictError extends Schema.TaggedError()("EnrollmentStateConflictError", {
+    reason: Schema.Literals([
+        "invitation-not-found",
+        "invitation-used",
+        "invitation-expired",
+        "invitation-mismatch",
+        "follower-identity-conflict",
+        "credential-conflict",
+    ]),
+    message: Schema.String,
+}) {
+}