@treeseed/sdk 0.12.15 → 0.12.17

package/dist/hosting/builtins.js

@@ -54,7 +54,7 @@ function defaultVerify(input) {
       issues: []
     }
   ];
-  if (input.unit.host.id === "railway" && input.environment === "prod" && unitConfig(input).sourceMode === "image") {
+  if (input.unit.host.id === "railway" && input.environment === "prod" && unitConfig(input).sourceMode === "image" && input.unit.serviceType.id !== "relational-database" && unitConfig(input).resourceType !== "postgres") {
     const imageRef = unitConfig(input).imageRef;
     const hasImageRef = typeof imageRef === "string" && imageRef.trim().length > 0;
     checks.push({

package/dist/hosting/graph.js

@@ -60,7 +60,7 @@ function resolvePublicTreeDxRoot(input) {
   ].filter((candidate) => Boolean(candidate));
   return candidates.find((candidate) => existsSync(resolve(candidate, "treeseed.package.yaml")) || existsSync(resolve(candidate, ".git"))) ?? candidates[0];
 }
-function publicTreeDxSourcePolicy(input, config) {
+function publicTreeDxSourcePolicy(input, config, launchEnv) {
   const railway = config.publicTreeDxFederation?.railway ?? {};
   const configuredSource = railway.source && typeof railway.source === "object" && !Array.isArray(railway.source) ? railway.source : {};
   const configuredMode = typeof railway.sourceMode === "string" ? railway.sourceMode : null;
@@ -68,6 +68,7 @@ function publicTreeDxSourcePolicy(input, config) {
   const repository = typeof railway.sourceRepo === "string" ? railway.sourceRepo : typeof configuredSource.repository === "string" ? configuredSource.repository : typeof configuredSource.repo === "string" ? configuredSource.repo : readPackageRepository(treeDxRoot) ?? "treeseed-ai/treedx";
   const sourceMode = configuredMode === "git" || configuredMode === "image" ? configuredMode : input.environment === "staging" ? "git" : "image";
   if (sourceMode !== "git") {
+    const imageRef = typeof launchEnv.TREESEED_PUBLIC_TREEDX_IMAGE_REF === "string" && launchEnv.TREESEED_PUBLIC_TREEDX_IMAGE_REF.trim() ? launchEnv.TREESEED_PUBLIC_TREEDX_IMAGE_REF.trim() : null;
     return {
       sourceMode: "image",
       sourceRepo: null,
@@ -75,6 +76,7 @@ function publicTreeDxSourcePolicy(input, config) {
       sourceCommit: null,
       sourceRootDirectory: null,
       image: "treeseed/treedx",
+      imageRef,
       imageTagRef: "TREESEED_PUBLIC_TREEDX_IMAGE_REF"
     };
   }
@@ -110,6 +112,7 @@ function railwayImageRefEnvForService(serviceKey) {
   if (serviceKey === "operationsRunner") return "TREESEED_OPERATIONS_RUNNER_IMAGE_REF";
   if (serviceKey === "capacityProviderManager") return "TREESEED_AGENT_MANAGER_IMAGE_REF";
   if (serviceKey === "capacityProviderRunner") return "TREESEED_AGENT_RUNNER_IMAGE_REF";
+  if (String(serviceKey).startsWith("public-treedx-node-")) return "TREESEED_PUBLIC_TREEDX_IMAGE_REF";
   return null;
 }
 function defaultRailwayImageRefForService(serviceKey, environment) {
@@ -295,14 +298,17 @@ function buildProfileFromDeployConfig(input) {
     publicTreeDxProjectGroup(environment, config),
     privateTreeDxProjectGroup()
   ];
-  const railwayImageRefEnvKeys = [...new Set(Object.keys(config.services ?? {}).map((serviceKey) => railwayImageRefEnvForService(serviceKey)).filter((value) => Boolean(value)))];
+  const railwayImageRefEnvKeys = [.../* @__PURE__ */ new Set([
+    ...Object.keys(config.services ?? {}).map((serviceKey) => railwayImageRefEnvForService(serviceKey)).filter((value) => Boolean(value)),
+    ...config.hosting?.kind === "treeseed_control_plane" ? ["TREESEED_PUBLIC_TREEDX_IMAGE_REF"] : []
+  ])];
   let railwayImageRefEnv = {};
   try {
     railwayImageRefEnv = resolveTreeseedMachineEnvironmentValues(input.configRoot ?? input.tenantRoot, environment, railwayImageRefEnvKeys);
   } catch {
     railwayImageRefEnv = {};
   }
-  const launchEnv = mergeRecord(process.env, railwayImageRefEnv, input.env);
+  const launchEnv = mergeRecord(railwayImageRefEnv, process.env, input.env);
   if (config.surfaces?.web && config.surfaces.web.enabled !== false) {
     services.push({
       id: "web",
@@ -419,7 +425,7 @@ function buildProfileFromDeployConfig(input) {
   }
   if (config.hosting?.kind === "treeseed_control_plane") {
     const treeDxNodePool = publicTreeDxNodePool(config);
-    const treeDxSourcePolicy = publicTreeDxSourcePolicy(input, config);
+    const treeDxSourcePolicy = publicTreeDxSourcePolicy(input, config, launchEnv);
     const treeDxNodeUnits = Array.from({ length: treeDxNodePool.bootstrapCount }, (_, offset) => {
       const nodeIndex = offset + 1;
       const serviceName = indexedName("public-treedx-node", nodeIndex);
@@ -431,6 +437,7 @@ function buildProfileFromDeployConfig(input) {
         projectGroupId: "public-treedx-federation",
         config: {
           ...treeDxSourcePolicy.image ? { image: treeDxSourcePolicy.image } : {},
+          ...treeDxSourcePolicy.imageRef ? { imageRef: treeDxSourcePolicy.imageRef } : {},
           ...treeDxSourcePolicy.imageTagRef ? { imageTagRef: treeDxSourcePolicy.imageTagRef } : {},
           sourceMode: treeDxSourcePolicy.sourceMode,
           ...treeDxSourcePolicy.sourceRepo ? { sourceRepo: treeDxSourcePolicy.sourceRepo } : {},

package/dist/operations/services/railway-deploy.js

@@ -629,7 +629,7 @@ function configuredRailwayServicesForConfig(tenantRoot, scope, deployConfig, app
   } catch {
     machineEnv = {};
   }
-  const imageRefEnv = { ...process.env, ...machineEnv, ...envOverlay };
+  const imageRefEnv = { ...machineEnv, ...process.env, ...envOverlay };
   let identity;
   try {
     identity = resolveTreeseedResourceIdentity(deployConfig, createPersistentDeployTarget(normalizedScope));

package/dist/reconcile/builtin-adapters.js

@@ -2134,7 +2134,7 @@ function getPersistedCustomDomainState(input, provider, domain) {
   }
   if (provider === "railway") {
     try {
-      const state = loadTreeseedReconcileState(input.context.tenantRoot, input.context.target);
+      const state = loadTreeseedReconcileState(input.context.tenantRoot, input.context.target, input.context.launchEnv);
       const unitId = createTreeseedReconcileUnitId("custom-domain:api", domain);
       const unit = state.units[unitId];
       const reconciled = unit?.lastReconciledState;

package/dist/reconcile/engine.js

@@ -204,7 +204,7 @@ async function refreshTreeseedUnits({
   const units = filterUnitsBySelector(baseUnits, selector);
   const deployConfig = derived.deployConfig;
   const registry = createTreeseedReconcileRegistry(deployConfig);
-  const reconcileState = loadTreeseedReconcileState(tenantRoot, target);
+  const reconcileState = loadTreeseedReconcileState(tenantRoot, target, env);
   const context = createRunContext(tenantRoot, target, env, write);
   const observations = /* @__PURE__ */ new Map();
   await runByDependencyLevel(topologicallySortDesiredUnits(units), async (unit) => {
@@ -294,7 +294,7 @@ async function reconcileTreeseedTarget({
   const persistVerifiedResult = async (persisted, verifiedResult) => {
     persistChain = persistChain.then(() => {
       persistResult(planned.state, persisted, verifiedResult);
-      writeTreeseedReconcileState(tenantRoot, planned.state);
+      writeTreeseedReconcileState(tenantRoot, planned.state, env);
     });
     await persistChain;
   };
@@ -458,7 +458,7 @@ async function reconcileTreeseedTarget({
     results.push(verifiedResult);
   });
   if (!dryRun) {
-    writeTreeseedReconcileState(tenantRoot, planned.state);
+    writeTreeseedReconcileState(tenantRoot, planned.state, env);
   }
   return {
     target,
@@ -477,10 +477,10 @@ async function destroyTreeseedTargetUnits({
   units: explicitUnits,
   write
 }) {
-  const { units: allUnits, deployConfig } = deriveTreeseedDesiredUnits({ tenantRoot, target });
+  const { units: allUnits, deployConfig } = deriveTreeseedDesiredUnits({ tenantRoot, target, env });
   const units = filterUnitsBySelector(explicitUnits ?? allUnits, selector);
   const registry = createTreeseedReconcileRegistry(deployConfig);
-  const reconcileState = loadTreeseedReconcileState(tenantRoot, target);
+  const reconcileState = loadTreeseedReconcileState(tenantRoot, target, env);
   const context = createRunContext(tenantRoot, target, env, write);
   const results = [];
   for (const unit of reverseTopologicallySortedUnits(units)) {

package/dist/reconcile/state.d.ts

@@ -1,7 +1,7 @@
 import type { TreeseedDesiredUnit, TreeseedReconcileStateRecord, TreeseedReconcileTarget, TreeseedUnitPersistedState } from './contracts.js';
 export declare function migrateLegacyDeployStateUnits(legacyState: Record<string, any>, target: TreeseedReconcileTarget): Record<string, TreeseedUnitPersistedState>;
-export declare function loadTreeseedReconcileState(tenantRoot: string, target: TreeseedReconcileTarget): TreeseedReconcileStateRecord;
-export declare function writeTreeseedReconcileState(tenantRoot: string, reconcileState: TreeseedReconcileStateRecord): void;
+export declare function loadTreeseedReconcileState(tenantRoot: string, target: TreeseedReconcileTarget, env?: NodeJS.ProcessEnv | Record<string, string | undefined>): TreeseedReconcileStateRecord;
+export declare function writeTreeseedReconcileState(tenantRoot: string, reconcileState: TreeseedReconcileStateRecord, env?: NodeJS.ProcessEnv | Record<string, string | undefined>): void;
 export declare function ensureTreeseedPersistedUnitState(reconcileState: TreeseedReconcileStateRecord, unit: TreeseedDesiredUnit): TreeseedUnitPersistedState;
 export declare function updateTreeseedPersistedUnitState(reconcileState: TreeseedReconcileStateRecord, state: TreeseedUnitPersistedState): void;
 export declare function desiredUnitSpecHash(unit: TreeseedDesiredUnit): string;

package/dist/reconcile/state.js

@@ -227,8 +227,8 @@ function migrateLegacyDeployStateUnits(legacyState, target) {
   }
   return units;
 }
-function loadTreeseedReconcileState(tenantRoot, target) {
-  const deployConfig = loadTreeseedPlatformConfig({ tenantRoot, environment: target.kind === "persistent" ? target.scope : "staging", env: process.env }).deployConfig;
+function loadTreeseedReconcileState(tenantRoot, target, env = process.env) {
+  const deployConfig = loadTreeseedPlatformConfig({ tenantRoot, environment: target.kind === "persistent" ? target.scope : "staging", env }).deployConfig;
   const legacyState = loadDeployState(tenantRoot, deployConfig, { target });
   const persistedUnits = legacyState.units && typeof legacyState.units === "object" ? legacyState.units : migrateLegacyDeployStateUnits(legacyState, target);
   return {
@@ -238,8 +238,8 @@ function loadTreeseedReconcileState(tenantRoot, target) {
     units: { ...persistedUnits }
   };
 }
-function writeTreeseedReconcileState(tenantRoot, reconcileState) {
-  const deployConfig = loadTreeseedPlatformConfig({ tenantRoot, environment: reconcileState.target.kind === "persistent" ? reconcileState.target.scope : "staging", env: process.env }).deployConfig;
+function writeTreeseedReconcileState(tenantRoot, reconcileState, env = process.env) {
+  const deployConfig = loadTreeseedPlatformConfig({ tenantRoot, environment: reconcileState.target.kind === "persistent" ? reconcileState.target.scope : "staging", env }).deployConfig;
   const legacyState = loadDeployState(tenantRoot, deployConfig, { target: reconcileState.target });
   writeDeployState(tenantRoot, {
     ...legacyState,

package/dist/workflow/operations.js

@@ -1708,7 +1708,7 @@ function prepareFreshReleaseRun(root, branch, rootRepo, packageReports) {
   ]);
   const archived = [];
   const blockers = [];
-  for (const journal of listInterruptedWorkflowRuns(root).filter((entry) => entry.command === "release")) {
+  for (const journal of listInterruptedWorkflowRuns(root, { recentLimit: 50 }).filter((entry) => entry.command === "release")) {
     const classification = classifyWorkflowRunJournal(journal, {
       currentBranch: branch,
       currentHeads
@@ -1741,7 +1741,7 @@ function findAutoResumableReleaseRun(root, branch, rootRepo, packageReports, opt
     [rootRepo.name, rootRepo.commitSha ?? null],
     ...packageReports.map((report) => [report.name, report.commitSha ?? null])
   ]);
-  return listInterruptedWorkflowRuns(root).find((journal) => {
+  return listInterruptedWorkflowRuns(root, { recentLimit: 50 }).find((journal) => {
     if (journal.command !== "release" || !journal.resumable || journal.session.branchName !== STAGING_BRANCH) {
       return false;
     }
@@ -5246,22 +5246,32 @@ ${blockers.join("\n")}`, {
 async function workflowRelease(helpers, input) {
   try {
     return await withContextEnv(helpers.context.env, async () => {
+      const traceReleaseStartup = (phase) => {
+        console.error(`[release][startup] ${phase}`);
+      };
+      traceReleaseStartup("resolve workspace");
       const root = workspaceRoot(resolveProjectRootOrThrow("release", helpers.cwd()));
+      traceReleaseStartup("resolve session");
       const session = resolveTreeseedWorkflowSession(root);
       const executionMode = normalizeExecutionMode(input);
+      traceReleaseStartup("inspect root repo");
       const rootRepo = createWorkspaceRootRepoReport(root);
+      traceReleaseStartup("inspect package repos");
       const packageReports = createWorkspacePackageReports(root);
       const explicitResumeRunId = helpers.context.workflow?.resumeRunId ?? null;
+      traceReleaseStartup("check auto resume");
       const autoResumeRun = executionMode === "execute" && !explicitResumeRunId && input.fresh !== true ? findAutoResumableReleaseRun(root, session.branchName, rootRepo, packageReports, { archiveStale: false }) : null;
       const planAutoResumeRun = executionMode === "plan" && input.fresh !== true ? findAutoResumableReleaseRun(root, session.branchName, rootRepo, packageReports) : null;
       const effectiveInput = autoResumeRun ? {
         ...autoResumeRun.input,
         ciMode: input.ciMode ?? autoResumeRun.input.ciMode
       } : input;
+      traceReleaseStartup("local cleanup");
       const localCleanup = maybeRunLocalWorkflowCleanup(helpers, root, "release", effectiveInput);
       const level = effectiveInput.bump ?? "patch";
       const ciMode = normalizeCiMode(effectiveInput.ciMode, "release");
       const packageSelection = session.packageSelection;
+      traceReleaseStartup("build release plan");
       const plannedRelease = buildReleasePlanSnapshot({
         root,
         mode: session.mode,
@@ -5274,10 +5284,12 @@ async function workflowRelease(helpers, input) {
         blockers: []
       });
       const selectedPackageNames = releasePlanPackageSelection(plannedRelease.packageSelection).selected;
+      traceReleaseStartup("collect blockers");
       const blockers = collectReleasePlanBlockers(session, session.mode, selectedPackageNames, {
         level,
         repairVersionLine: effectiveInput.repairVersionLine === true
       });
+      traceReleaseStartup("collect production readiness");
       const plannedReadiness = collectTreeseedDeploymentReadiness({
         tenantRoot: root,
         environment: "prod",
@@ -5314,13 +5326,16 @@ async function workflowRelease(helpers, input) {
           releaseBasePayload
         );
       }
+      traceReleaseStartup("validate blockers");
       if (blockers.length > 0) {
         workflowError("release", "validation_failed", `Treeseed release cannot continue until blockers are resolved:
 ${blockers.join("\n")}`, {
           details: { blockers, releasePlan: plannedRelease }
         });
       }
+      traceReleaseStartup("prepare fresh release");
       const freshPreparation = input.fresh === true ? prepareFreshReleaseRun(root, session.branchName, rootRepo, packageReports) : { archived: [], blockers: [] };
+      traceReleaseStartup("compute versions");
       const selectedVersions = releasePlanVersionMap(plannedRelease.plannedVersions);
       const stableVersions = new Map([
         ...releasePlanStableDependencyVersionMap(plannedRelease).entries(),
@@ -5331,6 +5346,7 @@ ${blockers.join("\n")}`, {
         ...stableVersions.entries()
       ]);
       const selectedPackageSet = new Set(selectedPackageNames);
+      traceReleaseStartup("acquire workflow run");
       const workflowRun = acquireWorkflowRun(
         "release",
         session,

package/dist/workflow/runs.d.ts

@@ -131,4 +131,7 @@ export declare function createWorkflowRunJournal(root: string, options: {
     steps: Omit<TreeseedWorkflowRunStep, 'status' | 'completedAt' | 'data'>[];
 }): TreeseedWorkflowRunJournal;
 export declare function listWorkflowRunJournals(root: string): TreeseedWorkflowRunJournal[];
-export declare function listInterruptedWorkflowRuns(root: string): TreeseedWorkflowRunJournal[];
+export declare function listRecentWorkflowRunJournals(root: string, limit?: number): TreeseedWorkflowRunJournal[];
+export declare function listInterruptedWorkflowRuns(root: string, options?: {
+    recentLimit?: number;
+}): TreeseedWorkflowRunJournal[];

package/dist/workflow/runs.js

@@ -576,8 +576,42 @@ function listWorkflowRunJournals(root) {
   }
   return [...byId.values()].sort((left, right) => right.createdAt.localeCompare(left.createdAt));
 }
-function listInterruptedWorkflowRuns(root) {
-  return listWorkflowRunJournals(root).filter((journal) => journal.status === "failed" && journal.resumable);
+function listRecentWorkflowRunJournalsForScope(root, scope, limit) {
+  const runsDir = workflowRunsRoot(root, null, scope);
+  if (!existsSync(runsDir)) {
+    return [];
+  }
+  return readdirSync(runsDir).filter((entry) => entry.endsWith(".json")).map((entry) => {
+    const path = resolve(runsDir, entry);
+    try {
+      return { path, mtimeMs: statSync(path).mtimeMs };
+    } catch {
+      return null;
+    }
+  }).filter((entry) => entry != null).sort((left, right) => right.mtimeMs - left.mtimeMs).slice(0, Math.max(1, limit)).map((entry) => {
+    try {
+      if (statSync(entry.path).size > 5 * 1024 * 1024) {
+        const archivedSummary = archivedWorkflowRunSummary(entry.path);
+        if (archivedSummary) return archivedSummary;
+      }
+    } catch {
+      return null;
+    }
+    return safeJsonParse(entry.path);
+  }).filter((entry) => entry != null);
+}
+function listRecentWorkflowRunJournals(root, limit = 50) {
+  const local = listRecentWorkflowRunJournalsForScope(root, "worktree", limit);
+  const shared = listRecentWorkflowRunJournalsForScope(root, "shared", limit);
+  const byId = /* @__PURE__ */ new Map();
+  for (const journal of [...local, ...shared]) {
+    byId.set(journal.runId, journal);
+  }
+  return [...byId.values()].sort((left, right) => right.createdAt.localeCompare(left.createdAt)).slice(0, Math.max(1, limit));
+}
+function listInterruptedWorkflowRuns(root, options = {}) {
+  const journals = options.recentLimit ? listRecentWorkflowRunJournals(root, options.recentLimit) : listWorkflowRunJournals(root);
+  return journals.filter((journal) => journal.status === "failed" && journal.resumable);
 }
 export {
   acquireWorkflowLock,
@@ -591,6 +625,7 @@ export {
   inspectWorkflowLock,
   isSharedWorkflowCommand,
   listInterruptedWorkflowRuns,
+  listRecentWorkflowRunJournals,
   listWorkflowRunJournals,
   readWorkflowRunJournal,
   refreshWorkflowLock,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/sdk",
-  "version": "0.12.15",
+  "version": "0.12.17",
   "description": "Shared Treeseed SDK for content-backed and D1-backed object models.",
   "license": "AGPL-3.0-only",
   "repository": {