@treeseed/sdk 0.10.18 → 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;

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

@@ -838,7 +838,9 @@ async function ensureRailwayServiceInstanceConfiguration({
   restartPolicy,
   runtimeMode,
   env = process.env,
-  fetchImpl = fetch
+  fetchImpl = fetch,
+  settleAttempts = 24,
+  settleDelayMs = 5e3
 }) {
   let current = await getRailwayServiceInstance({ serviceId, environmentId, env, fetchImpl });
   if (!current.id) {
@@ -911,34 +913,32 @@ mutation TreeseedRailwayServiceInstanceUpdateLegacy($serviceId: String!, $enviro
     }
     throw error;
   }
-  let instance = await getRailwayServiceInstance({
-    serviceId,
-    environmentId,
-    env,
-    fetchImpl
-  });
-  for (let attempt = 0; attempt < 5 && serviceInstanceDrifted(instance, desired); attempt += 1) {
-    await new Promise((resolve) => setTimeout(resolve, 1e3));
+  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

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): {

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,
@@ -1928,6 +2027,8 @@ export {
   ensureRailwayServiceVolumeWithCliFallback,
   isRailwayTransientFailure,
   isUsableRailwayToken,
+  listRailwayServiceVolumesWithCli,
+  parseRailwayJsonOutput,
   planRailwayServiceDeploy,
   planRailwayServiceLink,
   railwayServiceRuntimeStartCommand,

package/dist/reconcile/builtin-adapters.js

@@ -33,6 +33,7 @@ import {
   deriveRailwayMarketOperationsRunnerVolumeName,
   ensureRailwayProjectContext,
   ensureRailwayServiceVolumeWithCliFallback,
+  listRailwayServiceVolumesWithCli,
   runRailway,
   validateRailwayDeployPrerequisites
 } from "../operations/services/railway-deploy.js";
@@ -2216,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}.`]
         }));
@@ -2247,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;
@@ -2257,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.18",
+  "version": "0.10.19",
   "description": "Shared Treeseed SDK for content-backed and D1-backed object models.",
   "license": "AGPL-3.0-only",
   "repository": {