@treeseed/sdk 0.5.2 → 0.6.0

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

@@ -0,0 +1,882 @@
+const DEFAULT_RAILWAY_API_URL = "https://backboard.railway.com/graphql/v2";
+const DEFAULT_RAILWAY_WORKSPACE = "knowledge-coop";
+function normalizeRailwayEnvironmentName(value) {
+  const normalized = typeof value === "string" ? value.trim() : "";
+  if (!normalized) {
+    return "";
+  }
+  return normalized === "prod" ? "production" : normalized;
+}
+function configuredEnvValue(env, name) {
+  const value = env?.[name];
+  return typeof value === "string" && value.trim() ? value.trim() : "";
+}
+function isUsableRailwayToken(value) {
+  return typeof value === "string" && value.trim().length >= 8;
+}
+function resolveRailwayApiToken(env = process.env) {
+  const token = configuredEnvValue(env, "RAILWAY_API_TOKEN");
+  return isUsableRailwayToken(token) ? token : "";
+}
+function resolveRailwayApiUrl(env = process.env) {
+  return configuredEnvValue(env, "TREESEED_RAILWAY_API_URL") || DEFAULT_RAILWAY_API_URL;
+}
+function resolveRailwayWorkspace(env = process.env) {
+  return configuredEnvValue(env, "TREESEED_RAILWAY_WORKSPACE") || DEFAULT_RAILWAY_WORKSPACE;
+}
+function normalizeRailwayErrorMessage(payload, fallbackStatus) {
+  if (payload && typeof payload === "object" && Array.isArray(payload.errors) && payload.errors.length > 0) {
+    const first = payload.errors[0];
+    if (first && typeof first === "object" && typeof first.message === "string") {
+      return first.message;
+    }
+  }
+  return typeof fallbackStatus === "number" ? `Railway API request failed with ${fallbackStatus}.` : "Railway API request failed.";
+}
+function isRetryableRailwayStatus(status) {
+  return status === 408 || status === 429 || status >= 500;
+}
+function parseRetryAfterMs(value) {
+  if (!value) {
+    return null;
+  }
+  const seconds = Number(value);
+  if (Number.isFinite(seconds) && seconds >= 0) {
+    return Math.round(seconds * 1e3);
+  }
+  const absoluteTime = Date.parse(value);
+  if (Number.isFinite(absoluteTime)) {
+    return Math.max(0, absoluteTime - Date.now());
+  }
+  return null;
+}
+function markRailwayTransientError(error, options = {}) {
+  const tagged = error;
+  tagged.treeseedTransient = true;
+  if (typeof options.retryAfterMs === "number" && Number.isFinite(options.retryAfterMs) && options.retryAfterMs >= 0) {
+    tagged.treeseedRetryAfterMs = options.retryAfterMs;
+  }
+  return tagged;
+}
+function isTransientRailwayRequestError(error) {
+  if (error && typeof error === "object" && error.treeseedTransient === true) {
+    return true;
+  }
+  const message = error instanceof Error ? error.message : String(error ?? "");
+  return /fetch failed|timed out|etimedout|econnreset|enetunreach|temporarily unavailable|aborted|rate limit|too many requests|429/iu.test(message);
+}
+function railwayConnectionLabel(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : "";
+}
+function normalizeConnectionNodes(connection, mapper) {
+  if (!connection || typeof connection !== "object" || !Array.isArray(connection.edges)) {
+    return [];
+  }
+  return connection.edges.map((edge) => {
+    if (!edge || typeof edge !== "object") {
+      return null;
+    }
+    const node = edge.node;
+    return node && typeof node === "object" ? mapper(node) : null;
+  }).filter(Boolean);
+}
+function normalizeWorkspace(node) {
+  const id = railwayConnectionLabel(node.id);
+  const name = railwayConnectionLabel(node.name);
+  if (!id || !name) {
+    return null;
+  }
+  return { id, name };
+}
+function normalizeEnvironment(node) {
+  const id = railwayConnectionLabel(node.id);
+  const name = railwayConnectionLabel(node.name);
+  if (!id || !name) {
+    return null;
+  }
+  return { id, name };
+}
+function normalizeService(node) {
+  const id = railwayConnectionLabel(node.id);
+  const name = railwayConnectionLabel(node.name);
+  if (!id || !name) {
+    return null;
+  }
+  return { id, name };
+}
+function normalizeProject(node) {
+  const id = railwayConnectionLabel(node.id);
+  const name = railwayConnectionLabel(node.name);
+  if (!id || !name) {
+    return null;
+  }
+  return {
+    id,
+    name,
+    workspaceId: railwayConnectionLabel(node.workspaceId) || null,
+    environments: normalizeConnectionNodes(node.environments, normalizeEnvironment),
+    services: normalizeConnectionNodes(node.services, normalizeService)
+  };
+}
+function normalizeVariableMap(value) {
+  if (!value) {
+    return {};
+  }
+  if (typeof value === "string") {
+    try {
+      return normalizeVariableMap(JSON.parse(value));
+    } catch {
+      return {};
+    }
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, entryValue]) => {
+      if (typeof entryValue === "string") {
+        return [key, entryValue];
+      }
+      if (entryValue && typeof entryValue === "object" && typeof entryValue.value === "string") {
+        return [key, entryValue.value];
+      }
+      return [key, null];
+    })
+  );
+}
+function normalizeRailwayNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function normalizeRailwayCustomDomainDnsRecord(node) {
+  const fqdn = railwayConnectionLabel(node.fqdn);
+  if (!fqdn) {
+    return null;
+  }
+  return {
+    fqdn,
+    hostlabel: railwayConnectionLabel(node.hostlabel),
+    recordType: railwayConnectionLabel(node.recordType),
+    requiredValue: railwayConnectionLabel(node.requiredValue),
+    currentValue: railwayConnectionLabel(node.currentValue),
+    status: railwayConnectionLabel(node.status),
+    zone: railwayConnectionLabel(node.zone),
+    purpose: railwayConnectionLabel(node.purpose)
+  };
+}
+function normalizeRailwayCustomDomain(node) {
+  const id = railwayConnectionLabel(node.id);
+  const domain = railwayConnectionLabel(node.domain);
+  if (!id || !domain) {
+    return null;
+  }
+  const status = node.status && typeof node.status === "object" ? node.status : {};
+  const dnsRecords = Array.isArray(status.dnsRecords) ? status.dnsRecords.map((entry) => entry && typeof entry === "object" ? normalizeRailwayCustomDomainDnsRecord(entry) : null).filter(Boolean) : [];
+  return {
+    id,
+    domain,
+    environmentId: railwayConnectionLabel(node.environmentId),
+    serviceId: railwayConnectionLabel(node.serviceId),
+    targetPort: typeof node.targetPort === "number" && Number.isFinite(node.targetPort) ? node.targetPort : null,
+    verified: status.verified === true,
+    certificateStatus: railwayConnectionLabel(status.certificateStatus) || null,
+    verificationDnsHost: railwayConnectionLabel(status.verificationDnsHost) || null,
+    verificationToken: railwayConnectionLabel(status.verificationToken) || null,
+    dnsRecords
+  };
+}
+async function railwayGraphqlRequest({
+  query,
+  variables,
+  env = process.env,
+  apiToken,
+  apiUrl,
+  fetchImpl = fetch,
+  timeoutMs = 15e3,
+  retries = 5
+}) {
+  const token = apiToken || resolveRailwayApiToken(env);
+  if (!token) {
+    throw new Error("Configure RAILWAY_API_TOKEN before invoking Railway APIs.");
+  }
+  let attempt = 0;
+  for (; ; ) {
+    const controller = new AbortController();
+    let timer = null;
+    try {
+      const response = await Promise.race([
+        fetchImpl(apiUrl || resolveRailwayApiUrl(env), {
+          method: "POST",
+          headers: {
+            authorization: `Bearer ${token}`,
+            "content-type": "application/json"
+          },
+          body: JSON.stringify({ query, variables }),
+          signal: controller.signal
+        }),
+        new Promise((_, reject) => {
+          timer = setTimeout(() => {
+            controller.abort();
+            reject(markRailwayTransientError(new Error(`Railway API request timed out after ${timeoutMs}ms.`)));
+          }, timeoutMs);
+        })
+      ]);
+      const payload = await response.json().catch(() => ({}));
+      if (!response.ok || Array.isArray(payload.errors) && payload.errors.length > 0) {
+        const message = normalizeRailwayErrorMessage(payload, response.status);
+        const hasGraphqlErrors = Array.isArray(payload.errors) && payload.errors.length > 0;
+        const retryAfterMs = parseRetryAfterMs(response.headers.get("retry-after"));
+        const shouldRetry = isRetryableRailwayStatus(response.status) || /rate limit|too many requests/iu.test(message);
+        const error = new Error(message);
+        if (shouldRetry || hasGraphqlErrors && /rate limit|too many requests/iu.test(message)) {
+          throw markRailwayTransientError(error, { retryAfterMs });
+        }
+        throw error;
+      }
+      return payload;
+    } catch (error) {
+      if (attempt >= retries || !isTransientRailwayRequestError(error)) {
+        throw error;
+      }
+      attempt += 1;
+      const retryAfterMs = error && typeof error === "object" && typeof error.treeseedRetryAfterMs === "number" ? Math.max(0, Number(error.treeseedRetryAfterMs)) : null;
+      const backoffMs = retryAfterMs ?? Math.min(500 * 2 ** (attempt - 1), 4e3);
+      await new Promise((resolve) => setTimeout(resolve, backoffMs));
+    } finally {
+      if (timer) {
+        clearTimeout(timer);
+      }
+    }
+  }
+}
+async function getRailwayAuthProfile({
+  env = process.env,
+  fetchImpl = fetch
+}) {
+  const payload = await railwayGraphqlRequest({
+    query: `
+query TreeseedRailwayAuthProfile {
+	me {
+		id
+		name
+		email
+		workspaces {
+			id
+			name
+		}
+	}
+}
+`.trim(),
+    env,
+    fetchImpl
+  });
+  const me = payload.data?.me;
+  return {
+    id: railwayConnectionLabel(me?.id) || null,
+    name: railwayConnectionLabel(me?.name) || null,
+    email: railwayConnectionLabel(me?.email) || null,
+    workspaces: Array.isArray(me?.workspaces) ? me.workspaces.map((workspace) => workspace && typeof workspace === "object" ? normalizeWorkspace(workspace) : null).filter(Boolean) : []
+  };
+}
+async function resolveRailwayWorkspaceContext({
+  env = process.env,
+  workspace,
+  fetchImpl = fetch
+}) {
+  const desired = (workspace || resolveRailwayWorkspace(env)).trim();
+  const profile = await getRailwayAuthProfile({ env, fetchImpl });
+  const match = profile.workspaces.find((candidate) => candidate.id === desired || candidate.name === desired) ?? null;
+  if (!match) {
+    const available = profile.workspaces.map((candidate) => candidate.name).join(", ") || "(none)";
+    throw new Error(`Railway workspace ${desired} is not visible to the current token. Available workspaces: ${available}.`);
+  }
+  return match;
+}
+async function listRailwayProjects({
+  env = process.env,
+  workspaceId,
+  fetchImpl = fetch
+}) {
+  const payload = await railwayGraphqlRequest({
+    query: `
+query TreeseedRailwayProjects($workspaceId: String!, $first: Int!) {
+	projects(workspaceId: $workspaceId, first: $first) {
+		edges {
+			node {
+				id
+				name
+				workspaceId
+				environments(first: 50) {
+					edges {
+						node {
+							id
+							name
+						}
+					}
+				}
+				services(first: 50) {
+					edges {
+						node {
+							id
+							name
+						}
+					}
+				}
+			}
+		}
+	}
+}
+`.trim(),
+    variables: { workspaceId, first: 100 },
+    env,
+    fetchImpl
+  });
+  return normalizeConnectionNodes(payload.data?.projects, normalizeProject);
+}
+async function getRailwayProject({
+  projectId,
+  env = process.env,
+  fetchImpl = fetch
+}) {
+  const payload = await railwayGraphqlRequest({
+    query: `
+query TreeseedRailwayProject($projectId: String!) {
+	project(id: $projectId) {
+		id
+		name
+		workspaceId
+		environments(first: 50) {
+			edges {
+				node {
+					id
+					name
+				}
+			}
+		}
+		services(first: 50) {
+			edges {
+				node {
+					id
+					name
+				}
+			}
+		}
+	}
+}
+`.trim(),
+    variables: { projectId },
+    env,
+    fetchImpl
+  });
+  return payload.data?.project ? normalizeProject(payload.data.project) : null;
+}
+async function ensureRailwayProject({
+  projectName,
+  projectId,
+  defaultEnvironmentName = "staging",
+  env = process.env,
+  workspace,
+  fetchImpl = fetch
+}) {
+  const workspaceContext = await resolveRailwayWorkspaceContext({ env, workspace, fetchImpl });
+  const projects = await listRailwayProjects({ env, workspaceId: workspaceContext.id, fetchImpl });
+  const desiredProjectName = railwayConnectionLabel(projectName);
+  const desiredProjectId = railwayConnectionLabel(projectId);
+  const existing = projects.find(
+    (project2) => desiredProjectId && project2.id === desiredProjectId || desiredProjectName && project2.name === desiredProjectName
+  ) ?? null;
+  if (existing) {
+    return { workspace: workspaceContext, project: existing, created: false };
+  }
+  if (!desiredProjectName) {
+    throw new Error("Railway project creation requires a project name.");
+  }
+  const created = await railwayGraphqlRequest({
+    query: `
+mutation TreeseedRailwayProjectCreate($input: ProjectCreateInput!) {
+	projectCreate(input: $input) {
+		id
+		name
+		workspaceId
+		environments(first: 50) {
+			edges {
+				node {
+					id
+					name
+				}
+			}
+		}
+		services(first: 50) {
+			edges {
+				node {
+					id
+					name
+				}
+			}
+		}
+	}
+}
+`.trim(),
+    variables: {
+      input: {
+        name: desiredProjectName,
+        workspaceId: workspaceContext.id,
+        defaultEnvironmentName
+      }
+    },
+    env,
+    fetchImpl
+  });
+  const project = created.data?.projectCreate ? normalizeProject(created.data.projectCreate) : null;
+  if (!project) {
+    throw new Error(`Railway project create did not return a usable project for ${desiredProjectName}.`);
+  }
+  return { workspace: workspaceContext, project, created: true };
+}
+async function ensureRailwayEnvironment({
+  projectId,
+  environmentName,
+  env = process.env,
+  fetchImpl = fetch
+}) {
+  const environments = await listRailwayEnvironments({ projectId, env, fetchImpl });
+  const existing = environments.find((environment2) => environment2.name === environmentName || environment2.id === environmentName) ?? null;
+  if (existing) {
+    return { environment: existing, created: false };
+  }
+  const created = await railwayGraphqlRequest({
+    query: `
+mutation TreeseedRailwayEnvironmentCreate($input: EnvironmentCreateInput!) {
+	environmentCreate(input: $input) {
+		id
+		name
+	}
+}
+`.trim(),
+    variables: {
+      input: {
+        projectId,
+        name: environmentName,
+        skipInitialDeploys: true
+      }
+    },
+    env,
+    fetchImpl
+  });
+  const environment = created.data?.environmentCreate ? normalizeEnvironment(created.data.environmentCreate) : null;
+  if (!environment) {
+    throw new Error(`Railway environment create did not return a usable environment for ${environmentName}.`);
+  }
+  return { environment, created: true };
+}
+async function listRailwayEnvironments({
+  projectId,
+  env = process.env,
+  fetchImpl = fetch
+}) {
+  const payload = await railwayGraphqlRequest({
+    query: `
+query TreeseedRailwayProjectEnvironments($projectId: String!) {
+	project(id: $projectId) {
+		id
+		environments(first: 50) {
+			edges {
+				node {
+					id
+					name
+				}
+			}
+		}
+	}
+}
+`.trim(),
+    variables: { projectId },
+    env,
+    fetchImpl
+  });
+  return normalizeConnectionNodes(payload.data?.project ? payload.data.project.environments : null, normalizeEnvironment);
+}
+async function ensureRailwayService({
+  projectId,
+  serviceName,
+  serviceId,
+  env = process.env,
+  fetchImpl = fetch
+}) {
+  const services = await listRailwayServices({ projectId, env, fetchImpl });
+  const desiredServiceName = railwayConnectionLabel(serviceName);
+  const desiredServiceId = railwayConnectionLabel(serviceId);
+  const existing = services.find(
+    (service2) => desiredServiceId && service2.id === desiredServiceId || desiredServiceName && service2.name === desiredServiceName
+  ) ?? null;
+  if (existing) {
+    return { service: existing, created: false };
+  }
+  if (!desiredServiceName) {
+    throw new Error("Railway service creation requires a service name.");
+  }
+  const created = await railwayGraphqlRequest({
+    query: `
+mutation TreeseedRailwayServiceCreate($input: ServiceCreateInput!) {
+	serviceCreate(input: $input) {
+		id
+		name
+	}
+}
+`.trim(),
+    variables: {
+      input: {
+        projectId,
+        name: desiredServiceName
+      }
+    },
+    env,
+    fetchImpl
+  });
+  const service = created.data?.serviceCreate ? normalizeService(created.data.serviceCreate) : null;
+  if (!service) {
+    throw new Error(`Railway service create did not return a usable service for ${desiredServiceName}.`);
+  }
+  return { service, created: true };
+}
+async function listRailwayServices({
+  projectId,
+  env = process.env,
+  fetchImpl = fetch
+}) {
+  const payload = await railwayGraphqlRequest({
+    query: `
+query TreeseedRailwayProjectServices($projectId: String!) {
+	project(id: $projectId) {
+		id
+		services(first: 50) {
+			edges {
+				node {
+					id
+					name
+				}
+			}
+		}
+	}
+}
+`.trim(),
+    variables: { projectId },
+    env,
+    fetchImpl
+  });
+  return normalizeConnectionNodes(payload.data?.project ? payload.data.project.services : null, normalizeService);
+}
+async function getRailwayServiceInstance({
+  serviceId,
+  environmentId,
+  env = process.env,
+  fetchImpl = fetch
+}) {
+  const legacySummary = {
+    id: null,
+    buildCommand: null,
+    startCommand: null,
+    rootDirectory: null,
+    healthcheckPath: null,
+    healthcheckTimeoutSeconds: null,
+    healthcheckIntervalSeconds: null,
+    restartPolicy: null,
+    runtimeMode: null,
+    sleepApplication: null,
+    runtimeConfigSupported: false
+  };
+  try {
+    const payload = await railwayGraphqlRequest({
+      query: `
+query TreeseedRailwayServiceInstance($serviceId: String!, $environmentId: String!) {
+	serviceInstance(serviceId: $serviceId, environmentId: $environmentId) {
+		id
+		buildCommand
+		startCommand
+		rootDirectory
+		healthcheckPath
+		healthcheckTimeout
+		sleepApplication
+	}
+}
+`.trim(),
+      variables: { serviceId, environmentId },
+      env,
+      fetchImpl
+    });
+    const instance = payload.data?.serviceInstance;
+    return {
+      id: railwayConnectionLabel(instance?.id) || null,
+      buildCommand: railwayConnectionLabel(instance?.buildCommand) || null,
+      startCommand: railwayConnectionLabel(instance?.startCommand) || null,
+      rootDirectory: railwayConnectionLabel(instance?.rootDirectory) || null,
+      healthcheckPath: railwayConnectionLabel(instance?.healthcheckPath) || null,
+      healthcheckTimeoutSeconds: normalizeRailwayNumber(instance?.healthcheckTimeout),
+      healthcheckIntervalSeconds: null,
+      restartPolicy: null,
+      runtimeMode: instance?.sleepApplication === true ? "serverless" : "replicated",
+      sleepApplication: typeof instance?.sleepApplication === "boolean" ? instance.sleepApplication : null,
+      runtimeConfigSupported: true
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error ?? "");
+    if (/Cannot query field .*healthcheckPath|Cannot query field .*healthcheckTimeout|Cannot query field .*sleepApplication/iu.test(message)) {
+      const payload = await railwayGraphqlRequest({
+        query: `
+query TreeseedRailwayServiceInstanceLegacy($serviceId: String!, $environmentId: String!) {
+	serviceInstance(serviceId: $serviceId, environmentId: $environmentId) {
+		id
+		buildCommand
+		startCommand
+		rootDirectory
+	}
+}
+`.trim(),
+        variables: { serviceId, environmentId },
+        env,
+        fetchImpl
+      });
+      const instance = payload.data?.serviceInstance;
+      return {
+        ...legacySummary,
+        id: railwayConnectionLabel(instance?.id) || null,
+        buildCommand: railwayConnectionLabel(instance?.buildCommand) || null,
+        startCommand: railwayConnectionLabel(instance?.startCommand) || null,
+        rootDirectory: railwayConnectionLabel(instance?.rootDirectory) || null
+      };
+    }
+    if (!/ServiceInstance not found/iu.test(message)) {
+      throw error;
+    }
+    return legacySummary;
+  }
+}
+async function ensureRailwayServiceInstanceConfiguration({
+  serviceId,
+  environmentId,
+  buildCommand,
+  startCommand,
+  rootDirectory,
+  healthcheckPath,
+  healthcheckTimeoutSeconds,
+  healthcheckIntervalSeconds,
+  restartPolicy,
+  runtimeMode,
+  env = process.env,
+  fetchImpl = fetch
+}) {
+  const current = await getRailwayServiceInstance({ serviceId, environmentId, env, fetchImpl });
+  if (!current.id) {
+    return { instance: current, updated: false };
+  }
+  const desired = {
+    buildCommand: railwayConnectionLabel(buildCommand) || null,
+    startCommand: railwayConnectionLabel(startCommand) || null,
+    rootDirectory: railwayConnectionLabel(rootDirectory) || null,
+    healthcheckPath: railwayConnectionLabel(healthcheckPath) || null,
+    healthcheckTimeoutSeconds: normalizeRailwayNumber(healthcheckTimeoutSeconds),
+    healthcheckIntervalSeconds: normalizeRailwayNumber(healthcheckIntervalSeconds),
+    restartPolicy: railwayConnectionLabel(restartPolicy) || null,
+    runtimeMode: railwayConnectionLabel(runtimeMode) || null,
+    sleepApplication: railwayConnectionLabel(runtimeMode) === "serverless" ? true : railwayConnectionLabel(runtimeMode) === "replicated" ? false : null
+  };
+  const needsRuntimeConfig = desired.healthcheckPath !== null || desired.healthcheckTimeoutSeconds !== null || desired.runtimeMode !== null;
+  if (needsRuntimeConfig && current.runtimeConfigSupported !== true) {
+    throw new Error("Railway service instance runtime settings are unsupported by the current Railway API schema.");
+  }
+  if (desired.healthcheckIntervalSeconds !== null) {
+    throw new Error("Railway service instance healthcheck intervals are unsupported by the current Railway API schema.");
+  }
+  if (desired.restartPolicy !== null) {
+    throw new Error("Railway service instance restart policies are unsupported by the current Railway API schema.");
+  }
+  const drifted = desired.buildCommand !== null && desired.buildCommand !== current.buildCommand || desired.startCommand !== null && desired.startCommand !== current.startCommand || 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;
+  if (!drifted) {
+    return { instance: current, updated: false };
+  }
+  const mutationQuery = needsRuntimeConfig ? `
+mutation TreeseedRailwayServiceInstanceUpdate($serviceId: String!, $environmentId: String!, $input: ServiceInstanceUpdateInput!) {
+	serviceInstanceUpdate(serviceId: $serviceId, environmentId: $environmentId, input: $input)
+}
+`.trim() : `
+mutation TreeseedRailwayServiceInstanceUpdateLegacy($serviceId: String!, $environmentId: String!, $input: ServiceInstanceUpdateInput!) {
+	serviceInstanceUpdate(serviceId: $serviceId, environmentId: $environmentId, input: $input)
+}
+`.trim();
+  try {
+    await railwayGraphqlRequest({
+      query: mutationQuery,
+      variables: {
+        serviceId,
+        environmentId,
+        input: {
+          ...desired.buildCommand !== null ? { buildCommand: desired.buildCommand } : {},
+          ...desired.startCommand !== null ? { startCommand: desired.startCommand } : {},
+          ...desired.rootDirectory !== null ? { rootDirectory: desired.rootDirectory } : {},
+          ...desired.healthcheckPath !== null ? { healthcheckPath: desired.healthcheckPath } : {},
+          ...desired.healthcheckTimeoutSeconds !== null ? { healthcheckTimeout: desired.healthcheckTimeoutSeconds } : {},
+          ...desired.sleepApplication !== null ? { sleepApplication: desired.sleepApplication } : {}
+        }
+      },
+      env,
+      fetchImpl
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error ?? "");
+    if (needsRuntimeConfig && /Field .* is not defined by type .*ServiceInstanceUpdateInput|Unknown argument|Cannot query field/iu.test(message)) {
+      throw new Error("Railway service instance runtime settings are unsupported by the current Railway API schema.");
+    }
+    throw error;
+  }
+  const instance = await getRailwayServiceInstance({
+    serviceId,
+    environmentId,
+    env,
+    fetchImpl
+  });
+  return {
+    instance: {
+      id: instance.id || current.id,
+      buildCommand: instance.buildCommand ?? desired.buildCommand,
+      startCommand: instance.startCommand ?? desired.startCommand,
+      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,
+      runtimeConfigSupported: instance.runtimeConfigSupported
+    },
+    updated: true
+  };
+}
+async function listRailwayVariables({
+  projectId,
+  environmentId,
+  serviceId,
+  env = process.env,
+  fetchImpl = fetch
+}) {
+  const payload = await railwayGraphqlRequest({
+    query: `
+query TreeseedRailwayVariables($projectId: String!, $environmentId: String!, $serviceId: String) {
+	variables(projectId: $projectId, environmentId: $environmentId, serviceId: $serviceId, unrendered: true)
+}
+`.trim(),
+    variables: {
+      projectId,
+      environmentId,
+      serviceId: serviceId || null
+    },
+    env,
+    fetchImpl
+  });
+  return normalizeVariableMap(payload.data?.variables);
+}
+async function upsertRailwayVariables({
+  projectId,
+  environmentId,
+  serviceId,
+  variables,
+  env = process.env,
+  fetchImpl = fetch
+}) {
+  if (Object.keys(variables).length === 0) {
+    return;
+  }
+  await railwayGraphqlRequest({
+    query: `
+mutation TreeseedRailwayVariableCollectionUpsert($input: VariableCollectionUpsertInput!) {
+	variableCollectionUpsert(input: $input)
+}
+`.trim(),
+    variables: {
+      input: {
+        projectId,
+        environmentId,
+        serviceId: serviceId || null,
+        variables,
+        replace: false,
+        skipDeploys: true
+      }
+    },
+    env,
+    fetchImpl
+  });
+}
+async function listRailwayCustomDomains({
+  projectId,
+  environmentId,
+  serviceId,
+  env = process.env,
+  fetchImpl = fetch
+}) {
+  const payload = await railwayGraphqlRequest({
+    query: `
+query TreeseedRailwayCustomDomains($projectId: String!, $environmentId: String!, $serviceId: String!) {
+	domains(projectId: $projectId, environmentId: $environmentId, serviceId: $serviceId) {
+		customDomains {
+			id
+			domain
+			environmentId
+			serviceId
+			targetPort
+			status {
+				verified
+				certificateStatus
+				verificationDnsHost
+				verificationToken
+				dnsRecords {
+					fqdn
+					hostlabel
+					recordType
+					requiredValue
+					currentValue
+					status
+					zone
+					purpose
+				}
+			}
+		}
+	}
+}
+`.trim(),
+    variables: {
+      projectId,
+      environmentId,
+      serviceId
+    },
+    env,
+    fetchImpl
+  });
+  return Array.isArray(payload.data?.domains?.customDomains) ? payload.data.domains.customDomains.map((entry) => entry && typeof entry === "object" ? normalizeRailwayCustomDomain(entry) : null).filter(Boolean) : [];
+}
+export {
+  ensureRailwayEnvironment,
+  ensureRailwayProject,
+  ensureRailwayService,
+  ensureRailwayServiceInstanceConfiguration,
+  getRailwayAuthProfile,
+  getRailwayProject,
+  getRailwayServiceInstance,
+  isUsableRailwayToken,
+  listRailwayCustomDomains,
+  listRailwayEnvironments,
+  listRailwayProjects,
+  listRailwayServices,
+  listRailwayVariables,
+  normalizeRailwayEnvironmentName,
+  railwayGraphqlRequest,
+  resolveRailwayApiToken,
+  resolveRailwayApiUrl,
+  resolveRailwayWorkspace,
+  resolveRailwayWorkspaceContext,
+  upsertRailwayVariables
+};