@treeseed/sdk 0.10.17 → 0.10.19

package/dist/operations/services/railway-api.d.ts

@@ -199,7 +199,7 @@ export declare function getRailwayServiceInstance({ serviceId, environmentId, en
     sleepApplication: null;
     runtimeConfigSupported: false;
 }>;
-export declare function ensureRailwayServiceInstanceConfiguration({ serviceId, environmentId, buildCommand, startCommand, cronSchedule, rootDirectory, healthcheckPath, healthcheckTimeoutSeconds, healthcheckIntervalSeconds, restartPolicy, runtimeMode, env, fetchImpl, }: {
+export declare function ensureRailwayServiceInstanceConfiguration({ serviceId, environmentId, buildCommand, startCommand, cronSchedule, rootDirectory, healthcheckPath, healthcheckTimeoutSeconds, healthcheckIntervalSeconds, restartPolicy, runtimeMode, env, fetchImpl, settleAttempts, settleDelayMs, }: {
     serviceId: string;
     environmentId: string;
     buildCommand?: string | null;
@@ -213,6 +213,8 @@ export declare function ensureRailwayServiceInstanceConfiguration({ serviceId, e
     runtimeMode?: string | null;
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
     fetchImpl?: typeof fetch;
+    settleAttempts?: number;
+    settleDelayMs?: number;
 }): Promise<{
     instance: {
         id: string | null;
@@ -288,12 +290,7 @@ export declare function ensureRailwayServiceVolume({ projectId, environmentId, s
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
     fetchImpl?: typeof fetch;
 }): Promise<{
-    volume: {
-        instances: RailwayVolumeInstanceSummary[];
-        id: string;
-        name: string;
-        projectId: string | null;
-    } | null;
+    volume: RailwayVolumeSummary | null;
     instance: RailwayVolumeInstanceSummary | null;
     created: boolean;
     updated: boolean;

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

@@ -838,9 +838,17 @@ async function ensureRailwayServiceInstanceConfiguration({
   restartPolicy,
   runtimeMode,
   env = process.env,
-  fetchImpl = fetch
+  fetchImpl = fetch,
+  settleAttempts = 24,
+  settleDelayMs = 5e3
 }) {
-  const current = await getRailwayServiceInstance({ serviceId, environmentId, env, fetchImpl });
+  let current = await getRailwayServiceInstance({ serviceId, environmentId, env, fetchImpl });
+  if (!current.id) {
+    for (let attempt = 0; attempt < 8 && !current.id; attempt += 1) {
+      await new Promise((resolve) => setTimeout(resolve, 1500));
+      current = await getRailwayServiceInstance({ serviceId, environmentId, env, fetchImpl });
+    }
+  }
   if (!current.id) {
     return { instance: current, updated: false };
   }
@@ -905,30 +913,40 @@ mutation TreeseedRailwayServiceInstanceUpdateLegacy($serviceId: String!, $enviro
     }
     throw error;
   }
-  const instance = await getRailwayServiceInstance({
-    serviceId,
-    environmentId,
-    env,
-    fetchImpl
-  });
+  let instance = current;
+  for (let attempt = 0; attempt <= settleAttempts; attempt += 1) {
+    instance = await getRailwayServiceInstance({
+      serviceId,
+      environmentId,
+      env,
+      fetchImpl
+    });
+    if (!serviceInstanceDrifted(instance, desired) || attempt >= settleAttempts) {
+      break;
+    }
+    await new Promise((resolve) => setTimeout(resolve, settleDelayMs));
+  }
   return {
     instance: {
       id: instance.id || current.id,
-      buildCommand: instance.buildCommand ?? desired.buildCommand,
-      startCommand: instance.startCommand ?? desired.startCommand,
-      cronSchedule: instance.cronSchedule ?? desired.cronSchedule,
-      rootDirectory: instance.rootDirectory ?? desired.rootDirectory,
-      healthcheckPath: instance.healthcheckPath ?? desired.healthcheckPath,
-      healthcheckTimeoutSeconds: instance.healthcheckTimeoutSeconds ?? desired.healthcheckTimeoutSeconds,
-      healthcheckIntervalSeconds: instance.healthcheckIntervalSeconds ?? desired.healthcheckIntervalSeconds,
-      restartPolicy: instance.restartPolicy ?? desired.restartPolicy,
-      runtimeMode: instance.runtimeMode ?? desired.runtimeMode,
-      sleepApplication: instance.sleepApplication ?? desired.sleepApplication,
+      buildCommand: instance.buildCommand,
+      startCommand: instance.startCommand,
+      cronSchedule: instance.cronSchedule,
+      rootDirectory: instance.rootDirectory,
+      healthcheckPath: instance.healthcheckPath,
+      healthcheckTimeoutSeconds: instance.healthcheckTimeoutSeconds,
+      healthcheckIntervalSeconds: instance.healthcheckIntervalSeconds,
+      restartPolicy: instance.restartPolicy,
+      runtimeMode: instance.runtimeMode,
+      sleepApplication: instance.sleepApplication,
       runtimeConfigSupported: instance.runtimeConfigSupported
     },
     updated: true
   };
 }
+function serviceInstanceDrifted(current, desired) {
+  return desired.buildCommand !== null && desired.buildCommand !== current.buildCommand || desired.startCommand !== null && desired.startCommand !== current.startCommand || desired.cronSchedule !== null && desired.cronSchedule !== current.cronSchedule || desired.rootDirectory !== null && desired.rootDirectory !== current.rootDirectory || desired.healthcheckPath !== null && desired.healthcheckPath !== current.healthcheckPath || desired.healthcheckTimeoutSeconds !== null && desired.healthcheckTimeoutSeconds !== current.healthcheckTimeoutSeconds || desired.runtimeMode !== null && desired.runtimeMode !== current.runtimeMode;
+}
 async function listRailwayVariables({
   projectId,
   environmentId,
@@ -1193,23 +1211,37 @@ async function ensureRailwayServiceVolume({
     ...candidate,
     instances: candidate.instances.filter(isActiveRailwayVolumeInstance)
   })).filter((candidate) => candidate.instances.length > 0);
-  let volume = activeVolumes.find(
-    (candidate) => candidate.instances.some((instance2) => instance2.serviceId === serviceId && instance2.environmentId === environmentId)
-  ) ?? activeVolumes.find(
+  let volume = findRailwayVolumeForService(volumes, serviceId, environmentId) ?? activeVolumes.find(
     (candidate) => candidate.name === name && candidate.instances.some((instance2) => instance2.environmentId === environmentId)
   ) ?? null;
   let created = false;
   let updated = false;
   const createReplacementVolume = async () => {
-    const replacement = await createRailwayVolume({
-      projectId,
-      environmentId,
-      serviceId,
-      name,
-      mountPath,
-      env,
-      fetchImpl
-    });
+    let replacement;
+    try {
+      replacement = await createRailwayVolume({
+        projectId,
+        environmentId,
+        serviceId,
+        name,
+        mountPath,
+        env,
+        fetchImpl
+      });
+    } catch (error) {
+      if (!looksLikeRailwayVolumeCreateRace(error)) {
+        throw error;
+      }
+      for (let attempt = 0; attempt < 8; attempt += 1) {
+        await new Promise((resolve) => setTimeout(resolve, 1500));
+        const refreshed = await listRailwayVolumes({ projectId, env, fetchImpl });
+        const existing = findRailwayVolumeForService(refreshed, serviceId, environmentId);
+        if (existing) {
+          return existing;
+        }
+      }
+      throw error;
+    }
     created = true;
     return replacement;
   };
@@ -1259,6 +1291,17 @@ async function ensureRailwayServiceVolume({
   }
   return { volume, instance, created, updated };
 }
+function findRailwayVolumeForService(volumes, serviceId, environmentId) {
+  return volumes.find(
+    (candidate) => candidate.instances.some(
+      (instance) => instance.serviceId === serviceId && instance.environmentId === environmentId && isActiveRailwayVolumeInstance(instance)
+    )
+  ) ?? null;
+}
+function looksLikeRailwayVolumeCreateRace(error) {
+  const message = error instanceof Error ? error.message : String(error ?? "");
+  return /would have \d+ volumes attached|can only have one volume|not authorized/iu.test(message);
+}
 async function listRailwayCustomDomains({
   projectId,
   environmentId,

package/dist/operations/services/railway-deploy.d.ts

@@ -4,7 +4,16 @@ export declare function deriveRailwayMarketOperationsRunnerServiceName(baseServi
 export declare function deriveRailwayWorkerRunnerVolumeName(serviceName: any, environmentName?: string): string;
 export declare function deriveRailwayMarketOperationsRunnerVolumeName(serviceName: any, environmentName?: string): string;
 export declare function railwayServiceRuntimeStartCommand(service: any): any;
+export declare function parseRailwayJsonOutput(output: any): any;
 export declare function collectRailwayDeploymentStatusChecks(statusPayload: any, scope: any, services: any): any;
+export declare function listRailwayServiceVolumesWithCli({ cwd, serviceId, environmentId, name, mountPath, env, }: {
+    cwd: any;
+    serviceId: any;
+    environmentId: any;
+    name: any;
+    mountPath: any;
+    env?: NodeJS.ProcessEnv | undefined;
+}): any;
 export declare function isUsableRailwayToken(value: any): boolean;
 export declare function resolveRailwayAuthToken(env?: NodeJS.ProcessEnv): string;
 export declare function buildRailwayCommandEnv(env?: NodeJS.ProcessEnv): {
@@ -144,6 +153,23 @@ export declare function planRailwayServiceLink(service: any, { env }?: {
     args: string[];
     cwd: any;
 };
+export declare function ensureRailwayServiceVolumeWithCliFallback({ tenantRoot, projectId, environmentId, environmentName, serviceId, serviceName, name, mountPath, preferCli, env, }: {
+    tenantRoot: any;
+    projectId: any;
+    environmentId: any;
+    environmentName: any;
+    serviceId: any;
+    serviceName: any;
+    name: any;
+    mountPath: any;
+    preferCli?: boolean | undefined;
+    env?: NodeJS.ProcessEnv | undefined;
+}): Promise<{
+    volume: any;
+    instance: any;
+    created: boolean;
+    updated: boolean;
+}>;
 export declare function deployRailwayService(tenantRoot: any, service: any, { dryRun, write, prefix, env, }?: {
     dryRun?: boolean;
     write?: TreeseedBootstrapWriter;

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

@@ -225,6 +225,30 @@ function normalizeRailwayCliVolumeList(value, options) {
   }
   return value.volumes.map((entry) => normalizeRailwayCliVolume(entry, options)).filter(Boolean);
 }
+function listRailwayServiceVolumesWithCli({
+  cwd,
+  serviceId,
+  environmentId,
+  name,
+  mountPath,
+  env = process.env
+}) {
+  const listResult = runRailway(["volume", "--service", serviceId, "--environment", environmentId, "list", "--json"], {
+    cwd,
+    capture: true,
+    allowFailure: true,
+    env
+  });
+  if ((listResult.status ?? 1) !== 0) {
+    return [];
+  }
+  return normalizeRailwayCliVolumeList(parseRailwayJsonOutput(listResult.stdout ?? ""), {
+    serviceId,
+    environmentId,
+    fallbackName: name,
+    fallbackMountPath: mountPath
+  });
+}
 function isUsableRailwayToken(value) {
   return typeof value === "string" && value.trim().length >= 8;
 }
@@ -1758,7 +1782,43 @@ async function ensureRailwayServiceVolumeWithCliFallback({
     }
     created = true;
   }
-  const instance = volume.instances.find((entry) => entry.serviceId === serviceId && entry.environmentId === environmentId) ?? volume.instances[0] ?? null;
+  let instance = volume.instances.find((entry) => entry.serviceId === serviceId && entry.environmentId === environmentId) ?? volume.instances[0] ?? null;
+  if (!instance || instance.mountPath !== mountPath) {
+    const attachResult = runRailway([...volumeArgs, "attach", "--volume", volume.id, "--yes", "--json"], {
+      ...cliOptions,
+      allowFailure: true
+    });
+    if ((attachResult.status ?? 1) !== 0) {
+      const attachMessage = attachResult.stderr?.trim() || attachResult.stdout?.trim() || "";
+      if (!/already mounted/iu.test(attachMessage)) {
+        throw new Error(attachMessage || `Railway volume attach failed for ${serviceName} in ${environmentName}.`);
+      }
+    }
+    const attachedVolume = (attachResult.status ?? 1) === 0 ? normalizeRailwayCliVolume(parseRailwayJsonOutput(attachResult.stdout ?? ""), {
+      serviceId,
+      environmentId,
+      fallbackName: name,
+      fallbackMountPath: mountPath
+    }) : null;
+    volume = attachedVolume ?? {
+      ...volume,
+      instances: [{
+        ...instance ?? {
+          id: volume.id,
+          serviceId,
+          environmentId,
+          state: "READY",
+          sizeGb: null,
+          usedGb: null
+        },
+        serviceId,
+        environmentId,
+        mountPath
+      }]
+    };
+    instance = volume.instances.find((entry) => entry.serviceId === serviceId && entry.environmentId === environmentId) ?? volume.instances[0] ?? null;
+    updated = true;
+  }
   if (volume.name !== name || instance?.mountPath !== mountPath) {
     const updateResult = runRailway([...volumeArgs, "update", "--volume", volume.id, "--name", name, "--mount-path", mountPath, "--json"], cliOptions);
     const updatedVolume = normalizeRailwayCliVolume(parseRailwayJsonOutput(updateResult.stdout ?? ""), {
@@ -1774,6 +1834,18 @@ async function ensureRailwayServiceVolumeWithCliFallback({
     };
     updated = true;
   }
+  const apiVolume = await waitForRailwayServiceVolumeMount({
+    projectId,
+    volumeId: volume.id,
+    volumeName: name,
+    serviceId,
+    environmentId,
+    mountPath,
+    env
+  });
+  if (apiVolume) {
+    volume = apiVolume;
+  }
   return {
     volume,
     instance: volume.instances.find((entry) => entry.serviceId === serviceId && entry.environmentId === environmentId) ?? volume.instances[0] ?? null,
@@ -1781,6 +1853,33 @@ async function ensureRailwayServiceVolumeWithCliFallback({
     updated
   };
 }
+async function waitForRailwayServiceVolumeMount({
+  projectId,
+  volumeId,
+  volumeName,
+  serviceId,
+  environmentId,
+  mountPath,
+  env
+}) {
+  for (let attempt = 0; attempt <= 24; attempt += 1) {
+    const volumes = await listRailwayVolumes({ projectId, env });
+    const match = volumes.find(
+      (entry) => entry.id === volumeId || entry.name === volumeName || entry.instances.some(
+        (instance) => instance.serviceId === serviceId && instance.environmentId === environmentId && instance.mountPath === mountPath
+      )
+    ) ?? null;
+    if (match?.instances.some(
+      (instance) => instance.serviceId === serviceId && instance.environmentId === environmentId && instance.mountPath === mountPath
+    )) {
+      return match;
+    }
+    if (attempt < 24) {
+      await sleep(5e3);
+    }
+  }
+  return null;
+}
 async function deployRailwayService(tenantRoot, service, {
   dryRun = false,
   write,
@@ -1925,8 +2024,11 @@ export {
   ensureRailwayProjectExists,
   ensureRailwayScheduledJobs,
   ensureRailwayServiceExists,
+  ensureRailwayServiceVolumeWithCliFallback,
   isRailwayTransientFailure,
   isUsableRailwayToken,
+  listRailwayServiceVolumesWithCli,
+  parseRailwayJsonOutput,
   planRailwayServiceDeploy,
   planRailwayServiceLink,
   railwayServiceRuntimeStartCommand,

package/dist/reconcile/builtin-adapters.js

@@ -32,6 +32,8 @@ import {
   configuredRailwayServices,
   deriveRailwayMarketOperationsRunnerVolumeName,
   ensureRailwayProjectContext,
+  ensureRailwayServiceVolumeWithCliFallback,
+  listRailwayServiceVolumesWithCli,
   runRailway,
   validateRailwayDeployPrerequisites
 } from "../operations/services/railway-deploy.js";
@@ -42,7 +44,6 @@ import {
   ensureRailwayProject,
   ensureRailwayService,
   ensureRailwayServiceInstanceConfiguration,
-  ensureRailwayServiceVolume,
   getRailwayServiceInstance,
   getRailwayProject,
   listRailwayCustomDomains,
@@ -1568,12 +1569,16 @@ async function syncRailwayEnvironmentForScope(input, { dryRun = false } = {}) {
       });
       if (entry.configuredService.volumeMountPath) {
         const volumeName = entry.configuredService.key === "marketOperationsRunner" ? deriveRailwayMarketOperationsRunnerVolumeName(entry.service.name, entry.environment.name) : `${entry.service.name}-volume`;
-        const volume = await ensureRailwayServiceVolume({
+        const volume = await ensureRailwayServiceVolumeWithCliFallback({
+          tenantRoot: input.context.tenantRoot,
           projectId: entry.project.id,
           environmentId: entry.environment.id,
+          environmentName: entry.environment.name,
           serviceId: entry.service.id,
+          serviceName: entry.service.name,
           name: volumeName,
           mountPath: entry.configuredService.volumeMountPath,
+          preferCli: entry.configuredService.key === "marketOperationsRunner",
           env: topology.env
         });
         if (!volume.instance?.serviceId) {
@@ -1660,7 +1665,7 @@ async function ensureRailwayMarketDatabaseForScope(input, topology) {
       env: topology.env
     });
   }
-  for (let attempt = 0; attempt < 8; attempt += 1) {
+  for (let attempt = 0; attempt < 20; attempt += 1) {
     const existingVolumes = await listRailwayVolumes({
       projectId: firstService.project.id,
       env: topology.env
@@ -1669,18 +1674,10 @@ async function ensureRailwayMarketDatabaseForScope(input, topology) {
       (instance) => instance.serviceId === postgresService.id && instance.environmentId === firstService.environment?.id && instance.mountPath === "/var/lib/postgresql/data"
     ));
     if (attached) {
-      break;
+      return;
     }
-    await new Promise((resolve2) => setTimeout(resolve2, 1500));
+    await new Promise((resolve2) => setTimeout(resolve2, 3e3));
   }
-  await ensureRailwayServiceVolume({
-    projectId: firstService.project.id,
-    environmentId: firstService.environment.id,
-    serviceId: postgresService.id,
-    name: `postgres-${topology.scope === "prod" ? "prod" : topology.scope}-data`,
-    mountPath: "/var/lib/postgresql/data",
-    env: topology.env
-  });
 }
 async function observeRailwayUnit(input, { refresh = false } = {}) {
   let attempt = 0;
@@ -2220,16 +2217,33 @@ async function verifyRailwayUnit(input) {
         const volumes = entry.project?.id ? await listRailwayVolumes({ projectId: entry.project.id, env: topology.env }) : [];
         const expectedServiceId = entry.service?.id ?? null;
         const expectedEnvironmentId = entry.environment?.id ?? null;
-        const mountedVolume = volumes.find((volume) => volume.instances.some(
+        let mountedVolume = volumes.find((volume) => volume.instances.some(
           (instance) => instance.serviceId === expectedServiceId && instance.environmentId === expectedEnvironmentId && instance.mountPath === service.volumeMountPath
         )) ?? null;
+        let mountedVolumeSource = "api";
+        if (!mountedVolume && serviceKey === "marketOperationsRunner" && expectedServiceId && expectedEnvironmentId) {
+          ensureRailwayProjectContext(service, { env: topology.env, capture: true });
+          const cliVolumes = listRailwayServiceVolumesWithCli({
+            cwd: service.rootDir,
+            serviceId: expectedServiceId,
+            environmentId: expectedEnvironmentId,
+            name: deriveRailwayMarketOperationsRunnerVolumeName(entry.service?.name ?? service.serviceName ?? service.key, entry.environment?.name ?? service.railwayEnvironment),
+            mountPath: service.volumeMountPath,
+            env: topology.env
+          });
+          mountedVolume = cliVolumes.find((volume) => volume.instances.some(
+            (instance) => instance.serviceId === expectedServiceId && instance.environmentId === expectedEnvironmentId && instance.mountPath === service.volumeMountPath
+          )) ?? null;
+          mountedVolumeSource = mountedVolume ? "cli" : "api";
+        }
         checks.push(verificationCheck("railway.volume:data", "Railway service has persistent data volume mounted", "api", {
           exists: Boolean(mountedVolume),
           configured: Boolean(mountedVolume),
           expected: service.volumeMountPath,
           observed: mountedVolume ? {
             name: mountedVolume.name,
-            mountPath: service.volumeMountPath
+            mountPath: service.volumeMountPath,
+            source: mountedVolumeSource
           } : null,
           issues: mountedVolume ? [] : [`Railway service ${service.serviceName ?? service.key} is missing a persistent volume mounted at ${service.volumeMountPath}.`]
         }));
@@ -2251,7 +2265,13 @@ async function verifyRailwayUnit(input) {
           issues: Object.hasOwn(entry.currentVariables, key) ? [] : [`Railway secret ${key} is missing.`]
         }));
       }
-      return summarizeVerification(input.unit.unitId, checks);
+      const verification = summarizeVerification(input.unit.unitId, checks);
+      if (!verification.verified && attempt < 12 && railwayVerificationMaySettle(verification)) {
+        attempt += 1;
+        sleepMs(5e3);
+        continue;
+      }
+      return verification;
     } catch (error) {
       if (attempt >= 2 || !isTransientRailwayReconcileError(error)) {
         throw error;
@@ -2261,6 +2281,11 @@ async function verifyRailwayUnit(input) {
     }
   }
 }
+function railwayVerificationMaySettle(verification) {
+  return verification.checks.some(
+    (check) => !check.verified && (check.key === "railway.instance" || check.key.startsWith("railway.instance.") || check.key === "railway.volume:data")
+  );
+}
 function railwayStartCommandMatches(serviceKey, observed, expected) {
   if (observed === expected) {
     return true;

package/package.json

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