@treeseed/sdk 0.10.18 → 0.10.20

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;
 }
@@ -589,9 +613,7 @@ function setRailwaySecretVariable({ cwd, service, environment, key, value, env =
 }
 function ensureRailwayProjectExists(service, { env = process.env } = {}) {
   const projectName = typeof service?.projectName === "string" ? service.projectName.trim() : "";
-  if (!projectName) {
-    throw new Error(`Railway service ${service?.key ?? service?.serviceName ?? service?.serviceId ?? "(unknown)"} is missing a projectName.`);
-  }
+  const projectId = typeof service?.projectId === "string" ? service.projectId.trim() : "";
   const listed = runRailway(["list", "--json"], {
     cwd: service.rootDir,
     capture: true,
@@ -599,11 +621,17 @@ function ensureRailwayProjectExists(service, { env = process.env } = {}) {
     env
   });
   if (listed.status === 0) {
-    const match = normalizeRailwayProjectList(listed.stdout ?? "").find((entry) => entry.name === projectName || entry.id === projectName);
+    const match = normalizeRailwayProjectList(listed.stdout ?? "").find((entry) => entry.name === projectName || entry.id === projectName || entry.id === projectId);
     if (match) {
       return match;
     }
   }
+  if (!projectName) {
+    if (projectId) {
+      return { id: projectId, name: "" };
+    }
+    throw new Error(`Railway service ${service?.key ?? service?.serviceName ?? service?.serviceId ?? "(unknown)"} is missing a projectName.`);
+  }
   const args = ["init", "--name", projectName, "--json"];
   const workspace = resolveRailwayWorkspace(env);
   if (workspace) {
@@ -1734,6 +1762,16 @@ async function ensureRailwayServiceVolumeWithCliFallback({
     capture: true,
     env
   };
+  ensureRailwayProjectContext({
+    key: serviceName,
+    projectId,
+    serviceName,
+    rootDir: tenantRoot,
+    railwayEnvironment: environmentName
+  }, {
+    env,
+    capture: true
+  });
   const volumeArgs = ["volume", "--service", serviceId, "--environment", environmentId];
   const listResult = runRailway([...volumeArgs, "list", "--json"], cliOptions);
   const existingVolumes = normalizeRailwayCliVolumeList(parseRailwayJsonOutput(listResult.stdout ?? ""), {
@@ -1758,7 +1796,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 +1848,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 +1867,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 +2041,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";
@@ -46,6 +47,7 @@ import {
   getRailwayServiceInstance,
   getRailwayProject,
   listRailwayCustomDomains,
+  listRailwayEnvironments,
   listRailwayProjects,
   listRailwayVolumes,
   listRailwayVariables,
@@ -1394,6 +1396,44 @@ function relativeRailwayRootDir(tenantRoot, serviceRoot) {
   const resolved = relative(tenantRoot, serviceRoot).replace(/\\/gu, "/");
   return !resolved || resolved === "" ? "." : resolved;
 }
+async function ensureRailwayEnvironmentForService({
+  service,
+  project,
+  environmentName,
+  env
+}) {
+  try {
+    return (await ensureRailwayEnvironment({
+      projectId: project.id,
+      environmentName,
+      env
+    })).environment;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error ?? "");
+    if (!/Problem processing request/iu.test(message)) {
+      throw error;
+    }
+  }
+  ensureRailwayProjectContext({
+    ...service,
+    projectId: project.id,
+    projectName: project.name ?? service.projectName,
+    railwayEnvironment: environmentName
+  }, {
+    env,
+    allowFailure: true,
+    capture: true
+  });
+  for (let attempt = 0; attempt < 12; attempt += 1) {
+    const environments = await listRailwayEnvironments({ projectId: project.id, env });
+    const existing = environments.find((environment) => environment.name === environmentName || environment.id === environmentName) ?? null;
+    if (existing) {
+      return existing;
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, 2500));
+  }
+  throw new Error(`Railway environment ${environmentName} was created through the CLI fallback but was not visible through the Railway API.`);
+}
 async function resolveRailwayTopologyForScope(input, scope, {
   ensure = false,
   refresh = false,
@@ -1464,11 +1504,12 @@ async function resolveRailwayTopologyForScope(input, scope, {
       }
       let environment = project?.environments.find((entry) => entry.name === service.railwayEnvironment || entry.id === service.railwayEnvironment) ?? null;
       if (project && !environment && ensure) {
-        environment = (await ensureRailwayEnvironment({
-          projectId: project.id,
+        environment = await ensureRailwayEnvironmentForService({
+          service,
+          project,
           environmentName: service.railwayEnvironment,
           env
-        })).environment;
+        });
         project = {
           ...project,
           environments: [...project.environments.filter((entry) => entry.id !== environment?.id), environment]
@@ -2216,16 +2257,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 +2305,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 +2321,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/dist/workflow/operations.js

@@ -69,6 +69,7 @@ import {
   syncBranchWithOrigin
 } from "../operations/services/git-workflow.js";
 import { resolveGitHubRepositorySlug } from "../operations/services/github-automation.js";
+import { dispatchGitHubWorkflowRun } from "../operations/services/github-api.js";
 import {
   formatGitHubActionsGateFailure,
   inspectGitHubActionsVerification,
@@ -1168,6 +1169,9 @@ function workflowSessionSnapshot(session) {
     }))
   };
 }
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
 function nextPendingJournalStep(journal) {
   return journal.steps.find((step) => step.status === "pending") ?? null;
 }
@@ -3127,9 +3131,39 @@ async function workflowSave(helpers, input) {
             lockfileValidation: repo.lockfileValidation
           }))
         };
-        const saveWorkflowGates = shouldUseHostedSaveCi(effectiveInput, branch) ? await executeJournalStep(root, workflowRun.runId, "hosted-ci", () => {
+        const saveWorkflowGates = shouldUseHostedSaveCi(effectiveInput, branch) ? await executeJournalStep(root, workflowRun.runId, "hosted-ci", async () => {
           if (branch === STAGING_BRANCH) {
-            return { workflowGates: saveResult?.workflowGates ?? [] };
+            const workflowGates = saveResult?.workflowGates ?? [];
+            if (workflowGates.length > 0 || effectiveInput.verifyDeployedResources !== true || scope === "local" || !savedRootRepo.commitSha) {
+              return { workflowGates };
+            }
+            helpers.write("[save][workflow] Dispatching hosted market deploy gate for deployed resource verification.");
+            const repository = resolveGitHubRepositorySlug(savedRootRepo.path);
+            await dispatchGitHubWorkflowRun(repository, {
+              workflow: "deploy.yml",
+              branch,
+              inputs: {
+                environment: "staging",
+                action_kind: "deploy_web"
+              }
+            });
+            await sleep(5e3);
+            helpers.write("[save][workflow] Waiting for hosted market deploy gate.");
+            const dispatchedGates = await waitForWorkflowGates("save", [
+              hostedDeployGate({
+                name: savedRootRepo.name,
+                repoPath: savedRootRepo.path,
+                repository,
+                workflow: "deploy.yml",
+                branch,
+                headSha: savedRootRepo.commitSha
+              })
+            ], "hosted", {
+              root,
+              runId: workflowRun.runId,
+              onProgress: (line, stream) => helpers.write(line, stream)
+            });
+            return { workflowGates: dispatchedGates };
           }
           helpers.write("[save][workflow] Waiting for hosted save workflow gates.");
           return waitForWorkflowGates("save", [

package/package.json

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