@microck/canonfig 2.0.0

package/dist/synchronization/synchronization.errors.js

@@ -0,0 +1,102 @@
+import { Schema } from "effect";
+export class DuplicatePlannerInputError extends Schema.TaggedError()("DuplicatePlannerInputError", {
+    collection: Schema.String,
+    id: Schema.String,
+}) {
+}
+export class MissingDesiredResourceError extends Schema.TaggedError()("MissingDesiredResourceError", { resource: Schema.String }) {
+}
+export class MissingObservedResourceError extends Schema.TaggedError()("MissingObservedResourceError", { resource: Schema.String }) {
+}
+export class PlannerResourceKindMismatchError extends Schema.TaggedError()("PlannerResourceKindMismatchError", {
+    resource: Schema.String,
+    publishedKind: Schema.String,
+    desiredKind: Schema.String,
+}) {
+}
+export class PlannerPolicyKindMismatchError extends Schema.TaggedError()("PlannerPolicyKindMismatchError", {
+    resource: Schema.String,
+    kind: Schema.String,
+    policy: Schema.String,
+}) {
+}
+export class PlannerVerificationKindMismatchError extends Schema.TaggedError()("PlannerVerificationKindMismatchError", {
+    resource: Schema.String,
+    kind: Schema.String,
+    method: Schema.String,
+}) {
+}
+export class PlannerVerificationContentMismatchError extends Schema.TaggedError()("PlannerVerificationContentMismatchError", {
+    resource: Schema.String,
+    kind: Schema.String,
+    method: Schema.String,
+    reason: Schema.String,
+}) {
+}
+export class PlannerInvalidRecipeError extends Schema.TaggedError()("PlannerInvalidRecipeError", {
+    resource: Schema.String,
+    method: Schema.String,
+    package: Schema.String,
+    reason: Schema.String,
+}) {
+}
+export class PlannerInvalidResourcePathError extends Schema.TaggedError()("PlannerInvalidResourcePathError", {
+    resource: Schema.String,
+    path: Schema.String,
+    reason: Schema.String,
+}) {
+}
+export class PlannerConflictingResourcePathError extends Schema.TaggedError()("PlannerConflictingResourcePathError", {
+    resource: Schema.String,
+    path: Schema.String,
+    conflictsWith: Schema.String,
+    reason: Schema.String,
+}) {
+}
+export class PlannerMissingDependencyError extends Schema.TaggedError()("PlannerMissingDependencyError", {
+    resource: Schema.String,
+    dependency: Schema.String,
+}) {
+}
+export class PlannerDependencyCycleError extends Schema.TaggedError()("PlannerDependencyCycleError", { cycle: Schema.Array(Schema.String) }) {
+}
+export class MissingBlobMetadataError extends Schema.TaggedError()("MissingBlobMetadataError", {
+    resource: Schema.String,
+    blob: Schema.String,
+}) {
+}
+export class InvalidObservedStateError extends Schema.TaggedError()("InvalidObservedStateError", {
+    resource: Schema.String,
+    kind: Schema.String,
+    observedState: Schema.String,
+}) {
+}
+export class InvalidExecutionPlanError extends Schema.TaggedError()("InvalidExecutionPlanError", { message: Schema.String }) {
+}
+export class MissingExecutionResourceError extends Schema.TaggedError()("MissingExecutionResourceError", { resource: Schema.String }) {
+}
+export class MissingArtifactError extends Schema.TaggedError()("MissingArtifactError", { digest: Schema.String }) {
+}
+export class InvalidArtifactError extends Schema.TaggedError()("InvalidArtifactError", {
+    digest: Schema.String,
+    message: Schema.String,
+}) {
+}
+export class ActionExecutionError extends Schema.TaggedError()("ActionExecutionError", {
+    action: Schema.String,
+    message: Schema.String,
+}) {
+}
+export class RecoveryRunNotFoundError extends Schema.TaggedError()("RecoveryRunNotFoundError", { follower: Schema.String }) {
+}
+export class RecoveryIntegrityError extends Schema.TaggedError()("RecoveryIntegrityError", {
+    run: Schema.String,
+    message: Schema.String,
+}) {
+}
+export class RollbackCleanupError extends Schema.TaggedError()("RollbackCleanupError", {
+    run: Schema.String,
+    outcome: Schema.String,
+    message: Schema.String,
+}) {
+}

package/dist/synchronization/synchronization.layer.js

@@ -0,0 +1,97 @@
+import { Clock, Effect, Layer, Option } from "effect";
+import { AgentResolution } from "../agent/agent-resolution.service.js";
+import { MachineState } from "../machine/machine-state.service.js";
+import { StateRepository } from "../state/state-repository.service.js";
+import { cleanupRollbackSnapshots, executeSynchronizationPlan, executionFollower, executionRevision, } from "./executor.js";
+import { recoverSynchronizationPlan } from "./recovery.js";
+import { RollbackCleanupError } from "./synchronization.errors.js";
+import { Synchronization } from "./synchronization.service.js";
+const makeSynchronization = Effect.gen(function* () {
+    const repository = yield* StateRepository;
+    const machine = yield* MachineState;
+    const agentResolution = Option.getOrUndefined(yield* Effect.serviceOption(AgentResolution));
+    return Synchronization.of({
+        run: (input) => Effect.gen(function* () {
+            const follower = yield* executionFollower(input);
+            const revision = yield* executionRevision(input);
+            const startedAt = new Date(yield* Clock.currentTimeMillis).toISOString();
+            // startRun atomically persists the full plan and all pending actions.
+            // No MachineState operation is reachable before this succeeds.
+            yield* repository.startRun({
+                id: input.id,
+                follower,
+                revision,
+                plan: input.plan,
+                startedAt,
+            });
+            const result = yield* executeSynchronizationPlan({
+                ...input,
+                agentResolution: input.agentResolution ?? agentResolution,
+            }).pipe(Effect.provideService(StateRepository, repository), Effect.provideService(MachineState, machine), Effect.catch((error) => Effect.succeed({
+                outcome: {
+                    outcome: "Failed",
+                    run: input.id,
+                    reason: String(error).slice(0, 2048),
+                },
+                appliedResources: [],
+                removedResources: [],
+            })));
+            const completedAt = new Date(yield* Clock.currentTimeMillis).toISOString();
+            yield* repository.completeRun({
+                run: input.id,
+                completedAt,
+                outcome: result.outcome,
+                appliedResources: result.appliedResources,
+                removedResources: result.removedResources,
+            });
+            if (result.outcome.outcome !== "Interrupted") {
+                yield* cleanupRollbackSnapshots(input.id, input.plan.actions.map((action) => action.id)).pipe(Effect.provideService(MachineState, machine), Effect.mapError((error) => new RollbackCleanupError({
+                    run: input.id,
+                    outcome: result.outcome.outcome,
+                    message: String(error),
+                })));
+            }
+            return result.outcome;
+        }).pipe(Effect.onInterrupt(() => Effect.void)),
+        recover: (input) => Effect.gen(function* () {
+            const recovery = yield* repository.loadRecovery(input.follower);
+            const result = yield* recoverSynchronizationPlan({
+                ...input,
+                agentResolution: input.agentResolution ?? agentResolution,
+            }).pipe(Effect.provideService(StateRepository, repository), Effect.provideService(MachineState, machine));
+            yield* repository.completeRun({
+                run: result.outcome.run,
+                completedAt: new Date(yield* Clock.currentTimeMillis).toISOString(),
+                outcome: result.outcome,
+                appliedResources: result.appliedResources,
+                removedResources: result.removedResources,
+            });
+            if (result.outcome.outcome !== "Interrupted") {
+                yield* cleanupRollbackSnapshots(result.outcome.run, recovery?.run.plan.actions.map((action) => action.id) ?? []).pipe(Effect.provideService(MachineState, machine), Effect.mapError((error) => new RollbackCleanupError({
+                    run: result.outcome.run,
+                    outcome: result.outcome.outcome,
+                    message: String(error),
+                })));
+            }
+            return result.outcome;
+        }).pipe(Effect.onInterrupt(() => Effect.gen(function* () {
+            const recovery = yield* repository.loadRecovery(input.follower);
+            if (recovery === undefined)
+                return;
+            yield* repository.completeRun({
+                run: recovery.run.id,
+                completedAt: new Date(yield* Clock.currentTimeMillis).toISOString(),
+                outcome: {
+                    outcome: "Interrupted",
+                    run: recovery.run.id,
+                    completedActions: recovery.actions
+                        .filter((event) => event.state === "succeeded" || event.state === "skipped")
+                        .map((event) => event.action),
+                },
+                appliedResources: [],
+            });
+        }).pipe(Effect.ignore))),
+    });
+});
+export const SynchronizationLive = Layer.effect(Synchronization, makeSynchronization);
+export const synchronizationLayer = SynchronizationLive;

package/dist/synchronization/synchronization.service.js

@@ -0,0 +1,11 @@
+import { Context } from "effect";
+import { planSynchronization } from "./planner.js";
+/** Pure synchronization planning boundary. C6 owns all execution side effects. */
+export class SynchronizationPlanner extends Context.Service()("canonfig/synchronization/SynchronizationPlanner") {
+}
+export const synchronizationPlannerService = {
+    plan: planSynchronization,
+};
+/** Apply and crash-recovery boundary for recorded synchronization plans. */
+export class Synchronization extends Context.Service()("canonfig/synchronization/Synchronization") {
+}

package/dist/synchronization/synchronization.types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@microck/canonfig",
+  "version": "2.0.0",
+  "description": "one-way configuration synchronizer: publish a canonical AI agent setup from one Source Machine and converge Linux, macOS, and Windows Follower Machines",
+  "author": "Microck <contact@micr.dev>",
+  "license": "MIT",
+  "type": "module",
+  "keywords": [
+    "canonfig",
+    "cli",
+    "sync",
+    "configuration",
+    "mcp",
+    "skills",
+    "ai-agents",
+    "effect"
+  ],
+  "bin": {
+    "canonfig": "dist/runtime/main.js"
+  },
+  "workspaces": [
+    "website"
+  ],
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "build": "npm run build:cli && npm run website:build",
+    "build:cli": "tsc -p tsconfig.json",
+    "prepack": "npm run build:cli",
+    "typecheck": "tsc -p tsconfig.json --noEmit && npm run website:typecheck",
+    "lint": "oxlint oxlint.config.ts vitest.config.ts tools/release src/agent src/cli src/domain src/enrollment src/machine src/profile src/runtime src/schedule src/state src/synchronization tests/agent-resolution.test.ts tests/acceptance tests/cli.test.ts tests/doctor.test.ts tests/foundation.test.ts tests/packed-cli.test.ts tests/profile-contract.test.ts tests/discovery.test.ts tests/publication.test.ts tests/state-repository.test.ts tests/machine-state-linux.test.ts tests/machine-state-macos.test.ts tests/machine-state-windows.test.ts tests/schedule-manager.test.ts tests/skills.test.ts tests/synchronization-planner.test.ts tests/contract/machine-state.contract.ts tests/contract/schedule-manager.contract.ts tests/integration/enrollment.test.ts tests/integration/transport.test.ts tests/integration/npm-artifact.test.ts tests/integration/synchronization-run.test.ts tests/integration/recovery.test.ts tests/integration/follower-orchestration.test.ts && npm run website:lint && npm run docs:validate && npm run skills:validate",
+    "test": "vitest run",
+    "test:acceptance": "vitest run tests/acceptance",
+    "dev": "tsx src/runtime/main.ts",
+    "docs:validate": "tsx website/scripts/validate-commands.ts",
+    "release:validate": "tsx tools/release/validate-release.ts",
+    "skills:validate": "tsx website/scripts/validate-skills.ts",
+    "website:dev": "npm run dev --workspace @canonfig/website",
+    "website:typecheck": "npm run typecheck --workspace @canonfig/website",
+    "website:lint": "npm run lint --workspace @canonfig/website",
+    "website:build": "npm run build --workspace @canonfig/website"
+  },
+  "dependencies": {
+    "@effect/platform-node": "4.0.0-rc.109",
+    "@effect/sql-sqlite-node": "4.0.0-rc.109",
+    "effect": "4.0.0-rc.109",
+    "selfsigned": "^5.5.0",
+    "smol-toml": "1.6.1",
+    "yaml": "^2.9.0"
+  },
+  "devDependencies": {
+    "@effect/vitest": "4.0.0-rc.109",
+    "@oxlint/plugins": "1.78.0",
+    "@types/node": "24.10.1",
+    "oxlint": "1.78.0",
+    "tsx": "4.20.6",
+    "typescript": "5.9.3",
+    "vitest": "4.1.10"
+  }
+}