@treeseed/sdk 0.5.2 → 0.6.0

package/dist/reconcile/state.js

@@ -0,0 +1,303 @@
+import { createHash } from "node:crypto";
+import { loadCliDeployConfig } from "../operations/services/runtime-tools.js";
+import { loadDeployState, resolveTreeseedResourceIdentity, writeDeployState } from "../operations/services/deploy.js";
+import { targetKey } from "./units.js";
+function stableHash(value) {
+  return createHash("sha256").update(JSON.stringify(value)).digest("hex");
+}
+function railwayUnitTypeForServiceKey(serviceKey) {
+  if (serviceKey === "workdayStart") {
+    return "railway-service:workday-start";
+  }
+  if (serviceKey === "workdayReport") {
+    return "railway-service:workday-report";
+  }
+  return `railway-service:${serviceKey}`;
+}
+function emptyPersistedUnitState(unit) {
+  return {
+    unitId: unit.unitId,
+    unitType: unit.unitType,
+    provider: unit.provider,
+    identity: unit.identity,
+    target: unit.target,
+    logicalName: unit.logicalName,
+    desiredSpecHash: stableHash(unit.spec),
+    lastObservedAt: null,
+    lastReconciledAt: null,
+    lastVerifiedAt: null,
+    lastStatus: "pending",
+    lastObservedState: {},
+    lastReconciledState: {},
+    lastDiff: null,
+    lastVerification: null,
+    lastAction: null,
+    resourceLocators: {},
+    warnings: [],
+    error: null
+  };
+}
+function migrateLegacyDeployStateUnits(legacyState, target) {
+  const identity = legacyState.identity ?? resolveTreeseedResourceIdentity({
+    slug: legacyState.hosting?.projectId ?? legacyState.runtime?.projectId ?? "project",
+    hosting: legacyState.hosting ?? {},
+    runtime: legacyState.runtime ?? {},
+    cloudflare: {}
+  }, target);
+  const units = {};
+  const queue = legacyState.queues?.agentWork;
+  if (queue?.name) {
+    units[`queue:${queue.name}`] = {
+      unitId: `queue:${queue.name}`,
+      unitType: "queue",
+      provider: "cloudflare",
+      identity,
+      target,
+      logicalName: queue.name,
+      desiredSpecHash: "",
+      lastObservedAt: legacyState.readiness?.lastValidatedAt ?? null,
+      lastReconciledAt: legacyState.lastDeploymentTimestamp ?? null,
+      lastVerifiedAt: legacyState.readiness?.lastValidatedAt ?? null,
+      lastStatus: queue.queueId ? "ready" : "pending",
+      lastObservedState: {
+        name: queue.name,
+        dlqName: queue.dlqName ?? null,
+        queueId: queue.queueId ?? null,
+        dlqId: queue.dlqId ?? null
+      },
+      lastReconciledState: {
+        name: queue.name,
+        dlqName: queue.dlqName ?? null,
+        queueId: queue.queueId ?? null,
+        dlqId: queue.dlqId ?? null
+      },
+      lastDiff: null,
+      lastVerification: null,
+      lastAction: null,
+      resourceLocators: {
+        queueId: queue.queueId ?? null,
+        dlqId: queue.dlqId ?? null
+      },
+      warnings: [],
+      error: null
+    };
+  }
+  const db = legacyState.d1Databases?.SITE_DATA_DB;
+  if (db?.databaseName) {
+    units[`database:${db.databaseName}`] = {
+      unitId: `database:${db.databaseName}`,
+      unitType: "database",
+      provider: "cloudflare",
+      identity,
+      target,
+      logicalName: db.databaseName,
+      desiredSpecHash: "",
+      lastObservedAt: legacyState.readiness?.lastValidatedAt ?? null,
+      lastReconciledAt: legacyState.lastDeploymentTimestamp ?? null,
+      lastVerifiedAt: legacyState.readiness?.lastValidatedAt ?? null,
+      lastStatus: db.databaseId ? "ready" : "pending",
+      lastObservedState: {
+        databaseName: db.databaseName,
+        databaseId: db.databaseId ?? null,
+        previewDatabaseId: db.previewDatabaseId ?? null
+      },
+      lastReconciledState: {
+        databaseName: db.databaseName,
+        databaseId: db.databaseId ?? null,
+        previewDatabaseId: db.previewDatabaseId ?? null
+      },
+      lastDiff: null,
+      lastVerification: null,
+      lastAction: null,
+      resourceLocators: {
+        databaseId: db.databaseId ?? null,
+        previewDatabaseId: db.previewDatabaseId ?? null
+      },
+      warnings: [],
+      error: null
+    };
+  }
+  for (const [binding, namespace] of Object.entries(legacyState.kvNamespaces ?? {})) {
+    const record = namespace;
+    if (!record?.name) continue;
+    const unitType = binding === "FORM_GUARD_KV" ? "kv-form-guard" : "kv-session";
+    units[`${unitType}:${record.name}`] = {
+      unitId: `${unitType}:${record.name}`,
+      unitType,
+      provider: "cloudflare",
+      identity,
+      target,
+      logicalName: record.name,
+      desiredSpecHash: "",
+      lastObservedAt: legacyState.readiness?.lastValidatedAt ?? null,
+      lastReconciledAt: legacyState.lastDeploymentTimestamp ?? null,
+      lastVerifiedAt: legacyState.readiness?.lastValidatedAt ?? null,
+      lastStatus: record.id ? "ready" : "pending",
+      lastObservedState: { ...record },
+      lastReconciledState: { ...record },
+      lastDiff: null,
+      lastVerification: null,
+      lastAction: null,
+      resourceLocators: {
+        id: record.id ?? null,
+        previewId: record.previewId ?? null
+      },
+      warnings: [],
+      error: null
+    };
+  }
+  if (legacyState.content?.bucketName) {
+    units[`content-store:${legacyState.content.bucketName}`] = {
+      unitId: `content-store:${legacyState.content.bucketName}`,
+      unitType: "content-store",
+      provider: "cloudflare",
+      identity,
+      target,
+      logicalName: legacyState.content.bucketName,
+      desiredSpecHash: "",
+      lastObservedAt: legacyState.readiness?.lastValidatedAt ?? null,
+      lastReconciledAt: legacyState.lastDeploymentTimestamp ?? null,
+      lastVerifiedAt: legacyState.readiness?.lastValidatedAt ?? null,
+      lastStatus: "ready",
+      lastObservedState: { ...legacyState.content },
+      lastReconciledState: { ...legacyState.content },
+      lastDiff: null,
+      lastVerification: null,
+      lastAction: null,
+      resourceLocators: {
+        bucketName: legacyState.content.bucketName,
+        r2Binding: legacyState.content.r2Binding ?? null
+      },
+      warnings: [],
+      error: null
+    };
+  }
+  if (legacyState.pages?.projectName) {
+    units[`pages-project:${legacyState.pages.projectName}`] = {
+      unitId: `pages-project:${legacyState.pages.projectName}`,
+      unitType: "pages-project",
+      provider: "cloudflare",
+      identity,
+      target,
+      logicalName: legacyState.pages.projectName,
+      desiredSpecHash: "",
+      lastObservedAt: legacyState.readiness?.lastValidatedAt ?? null,
+      lastReconciledAt: legacyState.lastDeploymentTimestamp ?? null,
+      lastVerifiedAt: legacyState.readiness?.lastValidatedAt ?? null,
+      lastStatus: "ready",
+      lastObservedState: { ...legacyState.pages },
+      lastReconciledState: { ...legacyState.pages },
+      lastDiff: null,
+      lastVerification: null,
+      lastAction: null,
+      resourceLocators: {
+        projectName: legacyState.pages.projectName,
+        url: legacyState.pages.url ?? null
+      },
+      warnings: [],
+      error: null
+    };
+  }
+  if (legacyState.workerName) {
+    units[`edge-worker:${legacyState.workerName}`] = {
+      unitId: `edge-worker:${legacyState.workerName}`,
+      unitType: "edge-worker",
+      provider: "cloudflare",
+      identity,
+      target,
+      logicalName: legacyState.workerName,
+      desiredSpecHash: "",
+      lastObservedAt: legacyState.readiness?.lastValidatedAt ?? null,
+      lastReconciledAt: legacyState.lastDeploymentTimestamp ?? null,
+      lastVerifiedAt: legacyState.readiness?.lastValidatedAt ?? null,
+      lastStatus: legacyState.workerName ? "ready" : "pending",
+      lastObservedState: { workerName: legacyState.workerName, lastDeployedUrl: legacyState.lastDeployedUrl ?? null },
+      lastReconciledState: { workerName: legacyState.workerName, lastDeployedUrl: legacyState.lastDeployedUrl ?? null },
+      lastDiff: null,
+      lastVerification: null,
+      lastAction: null,
+      resourceLocators: {
+        workerName: legacyState.workerName,
+        url: legacyState.lastDeployedUrl ?? null
+      },
+      warnings: [],
+      error: null
+    };
+  }
+  for (const [serviceKey, service] of Object.entries(legacyState.services ?? {})) {
+    const record = service;
+    if (!record?.enabled || record.provider !== "railway") {
+      continue;
+    }
+    const unitType = railwayUnitTypeForServiceKey(serviceKey);
+    const logicalName = record.serviceName ?? record.serviceId ?? serviceKey;
+    units[`${unitType}:${logicalName}`] = {
+      unitId: `${unitType}:${logicalName}`,
+      unitType,
+      provider: "railway",
+      identity,
+      target,
+      logicalName,
+      desiredSpecHash: "",
+      lastObservedAt: legacyState.readiness?.lastValidatedAt ?? null,
+      lastReconciledAt: record.lastDeploymentTimestamp ?? null,
+      lastVerifiedAt: legacyState.readiness?.lastValidatedAt ?? null,
+      lastStatus: record.initialized ? "ready" : "pending",
+      lastObservedState: { ...record },
+      lastReconciledState: { ...record },
+      lastDiff: null,
+      lastVerification: null,
+      lastAction: null,
+      resourceLocators: {
+        projectId: record.projectId ?? null,
+        serviceId: record.serviceId ?? null,
+        serviceName: record.serviceName ?? null,
+        publicBaseUrl: record.publicBaseUrl ?? null
+      },
+      warnings: [],
+      error: null
+    };
+  }
+  return units;
+}
+function loadTreeseedReconcileState(tenantRoot, target) {
+  const deployConfig = loadCliDeployConfig(tenantRoot);
+  const legacyState = loadDeployState(tenantRoot, deployConfig, { target });
+  const persistedUnits = legacyState.units && typeof legacyState.units === "object" ? legacyState.units : migrateLegacyDeployStateUnits(legacyState, target);
+  return {
+    version: 1,
+    target,
+    dependencyGraphVersion: legacyState.reconcile?.dependencyGraphVersion ?? 1,
+    units: { ...persistedUnits }
+  };
+}
+function writeTreeseedReconcileState(tenantRoot, reconcileState) {
+  const deployConfig = loadCliDeployConfig(tenantRoot);
+  const legacyState = loadDeployState(tenantRoot, deployConfig, { target: reconcileState.target });
+  writeDeployState(tenantRoot, {
+    ...legacyState,
+    reconcile: {
+      version: reconcileState.version,
+      dependencyGraphVersion: reconcileState.dependencyGraphVersion,
+      targetKey: targetKey(reconcileState.target)
+    },
+    units: reconcileState.units
+  }, { target: reconcileState.target });
+}
+function ensureTreeseedPersistedUnitState(reconcileState, unit) {
+  return reconcileState.units[unit.unitId] ?? emptyPersistedUnitState(unit);
+}
+function updateTreeseedPersistedUnitState(reconcileState, state) {
+  reconcileState.units[state.unitId] = state;
+}
+function desiredUnitSpecHash(unit) {
+  return stableHash(unit.spec);
+}
+export {
+  desiredUnitSpecHash,
+  ensureTreeseedPersistedUnitState,
+  loadTreeseedReconcileState,
+  migrateLegacyDeployStateUnits,
+  updateTreeseedPersistedUnitState,
+  writeTreeseedReconcileState
+};

package/dist/reconcile/units.d.ts

@@ -0,0 +1,6 @@
+import type { TreeseedDesiredUnit, TreeseedReconcileTarget, TreeseedReconcileUnitType } from './contracts.ts';
+export declare const TRESEED_RECONCILE_UNIT_TYPES: TreeseedReconcileUnitType[];
+export declare function targetKey(target: TreeseedReconcileTarget): string;
+export declare function createTreeseedReconcileUnitId(unitType: TreeseedReconcileUnitType, logicalName: string): string;
+export declare function topologicallySortDesiredUnits(units: TreeseedDesiredUnit[]): TreeseedDesiredUnit[];
+export declare function reverseTopologicallySortedUnits(units: TreeseedDesiredUnit[]): TreeseedDesiredUnit[];

package/dist/reconcile/units.js

@@ -0,0 +1,68 @@
+const TRESEED_RECONCILE_UNIT_TYPES = [
+  "web-ui",
+  "api-runtime",
+  "manager-runtime",
+  "worker-runtime",
+  "workday-start-runtime",
+  "workday-report-runtime",
+  "edge-worker",
+  "content-store",
+  "queue",
+  "database",
+  "kv-form-guard",
+  "kv-session",
+  "pages-project",
+  "custom-domain:web",
+  "custom-domain:api",
+  "dns-record",
+  "railway-service:api",
+  "railway-service:manager",
+  "railway-service:worker",
+  "railway-service:workday-start",
+  "railway-service:workday-report"
+];
+function targetKey(target) {
+  return target.kind === "persistent" ? target.scope : `branch:${target.branchName}`;
+}
+function createTreeseedReconcileUnitId(unitType, logicalName) {
+  return `${unitType}:${logicalName}`;
+}
+function topologicallySortDesiredUnits(units) {
+  const byId = new Map(units.map((unit) => [unit.unitId, unit]));
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const output = [];
+  const visit = (unit) => {
+    if (visited.has(unit.unitId)) {
+      return;
+    }
+    if (visiting.has(unit.unitId)) {
+      throw new Error(`Treeseed reconcile dependency cycle detected at ${unit.unitId}.`);
+    }
+    visiting.add(unit.unitId);
+    for (const dependencyId of unit.dependencies) {
+      const dependency = byId.get(dependencyId);
+      if (!dependency) {
+        throw new Error(`Treeseed reconcile dependency ${dependencyId} referenced by ${unit.unitId} is missing.`);
+      }
+      visit(dependency);
+    }
+    visiting.delete(unit.unitId);
+    visited.add(unit.unitId);
+    output.push(unit);
+  };
+  for (const unit of units) {
+    visit(unit);
+  }
+  return output;
+}
+function reverseTopologicallySortedUnits(units) {
+  return [...topologicallySortDesiredUnits(units)].reverse();
+}
+export {
+  TRESEED_RECONCILE_UNIT_TYPES,
+  createTreeseedReconcileUnitId,
+  reverseTopologicallySortedUnits,
+  targetKey,
+  topologicallySortDesiredUnits
+};

package/dist/scripts/config-treeseed.js

@@ -5,6 +5,7 @@ function parseArgs(argv) {
     const parsed = {
         scopes: [],
         sync: 'all',
+        bootstrap: false,
         rotateMachineKey: false,
     };
     const rest = [...argv];
@@ -29,6 +30,10 @@ function parseArgs(argv) {
             parsed.sync = current.split('=', 2)[1] ?? 'all';
             continue;
         }
+        if (current === '--bootstrap') {
+            parsed.bootstrap = true;
+            continue;
+        }
         if (current === '--rotate-machine-key') {
             parsed.rotateMachineKey = true;
             continue;
@@ -50,30 +55,34 @@ try {
     }
     else {
         applyTreeseedSafeRepairs(tenantRoot);
-        const context = collectTreeseedConfigContext({
-            tenantRoot,
-            scopes,
-            env: process.env,
-        });
-        const updates = scopes.flatMap((scope) => context.entriesByScope[scope].map((entry) => ({
-            scope,
-            entryId: entry.id,
-            value: entry.effectiveValue,
-            reused: entry.currentValue.length > 0 || entry.suggestedValue.length > 0,
-        })));
-        const applyResult = applyTreeseedConfigValues({ tenantRoot, updates });
-        const result = finalizeTreeseedConfig({
+        const applyResult = options.bootstrap
+            ? { updated: [], sharedStorageMigrations: [] }
+            : (() => {
+                const context = collectTreeseedConfigContext({
+                    tenantRoot,
+                    scopes,
+                    env: process.env,
+                });
+                const updates = scopes.flatMap((scope) => context.entriesByScope[scope].map((entry) => ({
+                    scope,
+                    entryId: entry.id,
+                    value: entry.effectiveValue,
+                    reused: entry.currentValue.length > 0 || entry.suggestedValue.length > 0,
+                })));
+                return applyTreeseedConfigValues({ tenantRoot, updates });
+            })();
+        const result = await finalizeTreeseedConfig({
             tenantRoot,
             scopes,
             sync: options.sync,
             env: process.env,
         });
         const { configPath, keyPath } = getTreeseedMachineConfigPaths(tenantRoot);
-        console.log('Treeseed config completed.');
+        console.log(options.bootstrap ? 'Treeseed bootstrap completed.' : 'Treeseed config completed.');
         console.log(`Machine config: ${configPath}`);
         console.log(`Machine key: ${keyPath}`);
         console.log(`Updated values: ${applyResult.updated.length}`);
-        console.log(`Initialized environments: ${result.initialized.length}`);
+        console.log(`Reconciled environments: ${result.reconciled.length}`);
         for (const scope of scopes) {
             const readiness = result.readinessByScope?.[scope];
             if (!readiness)
@@ -84,10 +93,9 @@ try {
         if (result.synced.github) {
             console.log(`GitHub sync: ${result.synced.github.secrets.length} secrets, ${result.synced.github.variables.length} variables (${result.synced.github.repository})`);
         }
-        if (result.synced.cloudflare) {
-            console.log(`Cloudflare sync: ${result.synced.cloudflare.secrets.length} secrets, ${result.synced.cloudflare.varsManagedByWranglerConfig.length} vars via Wrangler config`);
-        }
     }
 }
-finally {
+catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
 }

package/dist/scripts/tenant-deploy.js

@@ -99,14 +99,29 @@ function runNodeScript(scriptPath, scriptArgs = [], env = {}) {
         process.exit(result.status ?? 1);
     }
 }
+function isTransientWranglerFailure(result) {
+    const output = [result.stderr, result.stdout]
+        .filter((value) => typeof value === 'string' && value.trim().length > 0)
+        .join('\n');
+    return /fetch failed|timed out|etimedout|econnreset|enetunreach|temporarily unavailable|connectivity issue|internal error/i.test(output);
+}
+function sleepSync(milliseconds) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, milliseconds);
+}
 function runWranglerDeploy(configPath) {
-    const result = spawnSync(process.execPath, [resolveWranglerBin(), 'deploy', '--config', configPath], {
-        stdio: 'inherit',
-        cwd: tenantRoot,
-        env: { ...process.env },
-    });
-    if (result.status !== 0) {
-        process.exit(result.status ?? 1);
+    for (let attempt = 1; attempt <= 3; attempt += 1) {
+        const result = spawnSync(process.execPath, [resolveWranglerBin(), 'deploy', '--config', configPath], {
+            stdio: 'inherit',
+            cwd: tenantRoot,
+            env: { ...process.env },
+        });
+        if (result.status === 0) {
+            return;
+        }
+        if (attempt === 3 || !isTransientWranglerFailure(result)) {
+            process.exit(result.status ?? 1);
+        }
+        sleepSync(2000 * attempt);
     }
 }
 function runWranglerPagesDeploy(projectName, branchName, outputDir = 'dist') {
@@ -121,13 +136,19 @@ function runWranglerPagesDeploy(projectName, branchName, outputDir = 'dist') {
     if (branchName) {
         args.push('--branch', branchName);
     }
-    const result = spawnSync(process.execPath, args, {
-        stdio: 'inherit',
-        cwd: tenantRoot,
-        env: { ...process.env },
-    });
-    if (result.status !== 0) {
-        process.exit(result.status ?? 1);
+    for (let attempt = 1; attempt <= 3; attempt += 1) {
+        const result = spawnSync(process.execPath, args, {
+            stdio: 'inherit',
+            cwd: tenantRoot,
+            env: { ...process.env },
+        });
+        if (result.status === 0) {
+            return;
+        }
+        if (attempt === 3 || !isTransientWranglerFailure(result)) {
+            process.exit(result.status ?? 1);
+        }
+        sleepSync(2000 * attempt);
     }
 }
 async function main() {