@treeseed/sdk 0.6.38 → 0.6.40

package/dist/operations/services/package-reference-policy.js

@@ -20,6 +20,19 @@ function isPrereleaseVersion(version) {
 function isStableVersion(version) {
   return /^\d+\.\d+\.\d+$/u.test(String(version).trim());
 }
+function stableVersionBase(version) {
+  const match = String(version).trim().match(/^(\d+\.\d+\.\d+)(?:-|$)/u);
+  return match?.[1] ?? null;
+}
+function compareStableVersions(left, right) {
+  const leftParts = left.split(".").map((part) => Number(part));
+  const rightParts = right.split(".").map((part) => Number(part));
+  for (let index = 0; index < 3; index += 1) {
+    const difference = (leftParts[index] ?? 0) - (rightParts[index] ?? 0);
+    if (difference !== 0) return difference;
+  }
+  return 0;
+}
 function isGitDependencySpec(spec) {
   return /^(?:git\+|github:|gitlab:|bitbucket:|ssh:\/\/|https:\/\/|file:)/u.test(String(spec).trim()) && String(spec).includes("#");
 }
@@ -279,9 +292,68 @@ function gitTagMessage(repoDir, tagName) {
     return "";
   }
 }
+function gitRemoteTagMessage(repoDir, tagName) {
+  try {
+    run("git", ["fetch", "--no-tags", "origin", `refs/tags/${tagName}`], { cwd: repoDir, capture: true });
+    return run("git", ["cat-file", "-p", "FETCH_HEAD"], { cwd: repoDir, capture: true });
+  } catch {
+    return "";
+  }
+}
+function gitDevTagMessage(repoDir, tagName) {
+  const local = gitTagMessage(repoDir, tagName);
+  if (local.trim()) return local;
+  return gitRemoteTagMessage(repoDir, tagName);
+}
 function tagHasTreeseedDevMetadata(repoDir, tagName) {
   return gitTagMessage(repoDir, tagName).includes("treeseed-dev-tag: true");
 }
+function parseTreeseedDevTag(tagName, message) {
+  const match = String(tagName).match(/^(\d+\.\d+\.\d+)-dev\.([0-9A-Za-z.-]+)\.(\d{8}T\d{6}Z)$/u);
+  if (!match) return null;
+  const metadata = Object.fromEntries(
+    String(message).split(/\r?\n/u).map((line) => line.match(/^([^:]+):\s*(.*)$/u)).filter((lineMatch) => Boolean(lineMatch)).map((lineMatch) => [String(lineMatch[1]).trim(), String(lineMatch[2] ?? "").trim()])
+  );
+  if (metadata["treeseed-dev-tag"] !== "true") return null;
+  return {
+    tagName,
+    stableVersion: match[1],
+    branchSlug: match[2],
+    timestamp: match[3],
+    metadata,
+    branch: metadata.branch || null,
+    packageName: metadata.package || null,
+    version: metadata.version || null
+  };
+}
+function devTagScope(info) {
+  const branch = info.branch ?? info.branchSlug;
+  if (branch === "staging" || info.branchSlug === "staging") return "staging";
+  if (branch === "main" || branch === "prod" || branch === "production" || info.branchSlug === "main" || info.branchSlug === "prod" || info.branchSlug === "production") return "main";
+  return "preview";
+}
+function classifyStaleTreeseedDevTag(input) {
+  const tagName = String(input.tagName).trim();
+  if (!tagName.includes("-dev.")) return { tagName, action: "skip", reason: "not-dev-tag", info: null };
+  if (tagName.startsWith("deprecated/")) return { tagName, action: "skip", reason: "deprecated-tag", info: null };
+  const info = parseTreeseedDevTag(tagName, input.message);
+  if (!info) return { tagName, action: "skip", reason: input.message.includes("treeseed-dev-tag: true") ? "malformed-dev-tag" : "missing-treeseed-metadata", info: null };
+  if (input.expectedPackageName && info.packageName && info.packageName !== input.expectedPackageName) {
+    return { tagName, action: "skip", reason: "package-mismatch", info };
+  }
+  if ((input.activeReferences ?? []).includes(tagName)) return { tagName, action: "skip", reason: "still-referenced", info };
+  const scope = devTagScope(info);
+  if (scope === "main") return { tagName, action: "skip", reason: "main-or-production-tag", info };
+  const branchScope = input.branchScope ?? "all";
+  if (branchScope !== "all" && branchScope !== scope) return { tagName, action: "skip", reason: `scope-${scope}`, info };
+  const currentStableVersion = stableVersionBase(input.currentVersion);
+  if (!currentStableVersion) return { tagName, action: "skip", reason: "invalid-current-version", info };
+  const comparison = compareStableVersions(info.stableVersion, currentStableVersion);
+  if (comparison >= 0) {
+    return { tagName, action: "skip", reason: comparison === 0 ? "current-version" : "newer-version", info };
+  }
+  return { tagName, action: "delete", reason: "stale-before-current-version", info };
+}
 function cleanupDevTags(repoDir, tagNames, activeReferences = []) {
   const active = new Set(activeReferences.filter(Boolean));
   const cleaned = [];
@@ -309,10 +381,72 @@ function cleanupDevTags(repoDir, tagNames, activeReferences = []) {
   }
   return { cleaned, skipped };
 }
+function localDevTags(repoDir) {
+  return run("git", ["tag", "-l", "*-dev.*"], { cwd: repoDir, capture: true }).split(/\r?\n/u).map((line) => line.trim()).filter(Boolean);
+}
+function remoteDevTags(repoDir) {
+  try {
+    return run("git", ["ls-remote", "--tags", "origin", "*-dev.*"], { cwd: repoDir, capture: true }).split(/\r?\n/u).map((line) => line.trim()).filter(Boolean).filter((line) => !line.endsWith("^{}")).map((line) => line.split(/\s+/u)[1] ?? "").filter((ref) => ref.startsWith("refs/tags/")).map((ref) => ref.slice("refs/tags/".length));
+  } catch {
+    return [];
+  }
+}
+function collectTreeseedDevTagCleanupPlan(input) {
+  const tagNames = [.../* @__PURE__ */ new Set([...localDevTags(input.repoDir), ...remoteDevTags(input.repoDir)])].sort();
+  const classifications = tagNames.map((tagName) => classifyStaleTreeseedDevTag({
+    tagName,
+    message: gitDevTagMessage(input.repoDir, tagName),
+    currentVersion: input.currentVersion,
+    activeReferences: input.activeReferences ?? [],
+    branchScope: input.branchScope ?? "all",
+    expectedPackageName: input.packageName
+  }));
+  return {
+    packageName: input.packageName,
+    currentVersion: input.currentVersion,
+    branchScope: input.branchScope ?? "all",
+    candidates: classifications.filter((classification) => classification.action === "delete"),
+    skipped: classifications.filter((classification) => classification.action === "skip"),
+    tags: classifications
+  };
+}
+function cleanupStaleTreeseedDevTags(input) {
+  const plan = collectTreeseedDevTagCleanupPlan(input);
+  const cleaned = [];
+  const skipped = [...plan.skipped.map((entry) => ({ tagName: entry.tagName, reason: entry.reason }))];
+  for (const candidate of plan.candidates) {
+    if (input.dryRun) continue;
+    try {
+      run("git", ["tag", "-d", candidate.tagName], { cwd: input.repoDir });
+    } catch {
+    }
+    try {
+      run("git", ["push", "origin", `:refs/tags/${candidate.tagName}`], { cwd: input.repoDir });
+      cleaned.push(candidate.tagName);
+    } catch (error) {
+      skipped.push({ tagName: candidate.tagName, reason: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  return {
+    status: input.dryRun ? "planned" : "completed",
+    packageName: input.packageName,
+    currentVersion: input.currentVersion,
+    branchScope: input.branchScope ?? "all",
+    candidates: plan.candidates.map((entry) => ({ tagName: entry.tagName, reason: entry.reason, branch: entry.info?.branch, branchSlug: entry.info?.branchSlug, version: entry.info?.version })),
+    candidateCount: plan.candidates.length,
+    cleaned,
+    cleanedCount: cleaned.length,
+    skipped,
+    skippedCount: skipped.length
+  };
+}
 export {
   assertNoInternalDevReferences,
+  classifyStaleTreeseedDevTag,
   cleanupDevTags,
+  cleanupStaleTreeseedDevTags,
   collectInternalDevReferenceIssues,
+  collectTreeseedDevTagCleanupPlan,
   createDevTagMessage,
   createPackageDependencyReference,
   devTagFromDependencySpec,
@@ -323,6 +457,7 @@ export {
   isStableVersion,
   normalizeGitRemoteForDependency,
   normalizeGitRemoteForManifest,
+  parseTreeseedDevTag,
   rewriteInternalDependenciesToStableVersions,
   rewriteProjectInternalDependenciesToStableVersions,
   tagHasTreeseedDevMetadata,

package/dist/operations/services/project-platform.d.ts

@@ -244,6 +244,13 @@ export declare function deployProjectPlatform(options: ProjectPlatformActionOpti
             healthcheckPath: string | null;
             healthcheckTimeoutSeconds: number | null;
             runtimeMode: string | null;
+            volume: {
+                id: string;
+                name: string;
+                mountPath: any;
+                created: boolean;
+                updated: boolean;
+            } | null;
         } | null;
     } | undefined)[];
 }>;
@@ -737,6 +744,13 @@ export declare function runProjectPlatformAction(action: ProjectPlatformAction,
             healthcheckPath: string | null;
             healthcheckTimeoutSeconds: number | null;
             runtimeMode: string | null;
+            volume: {
+                id: string;
+                name: string;
+                mountPath: any;
+                created: boolean;
+                updated: boolean;
+            } | null;
         } | null;
     } | undefined)[];
 }>;

package/dist/operations/services/project-platform.js

@@ -631,9 +631,10 @@ function probeR2(tenantRoot, siteConfig, state, target) {
   }
 }
 function probeScaleConfiguration(siteConfig, state) {
-  const worker = state.services?.worker ?? {};
+  const worker = state.services?.workerRunner ?? state.services?.worker ?? {};
+  const workerConfig = siteConfig.services?.workerRunner ?? siteConfig.services?.worker ?? {};
   const scalerKind = String(process.env.TREESEED_WORKER_POOL_SCALER ?? "").trim();
-  if (scalerKind !== "railway" && siteConfig.services?.worker?.provider !== "railway") {
+  if (scalerKind !== "railway" && workerConfig.provider !== "railway") {
     return {
       ok: true,
       skipped: true,

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

@@ -53,6 +53,20 @@ export type RailwayCustomDomainSummary = {
     verificationToken: string | null;
     dnsRecords: RailwayCustomDomainDnsRecord[];
 };
+export type RailwayVolumeInstanceSummary = {
+    id: string;
+    serviceId: string | null;
+    environmentId: string | null;
+    mountPath: string | null;
+    sizeGb: number | null;
+    usedGb: number | null;
+};
+export type RailwayVolumeSummary = {
+    id: string;
+    name: string;
+    projectId: string | null;
+    instances: RailwayVolumeInstanceSummary[];
+};
 export declare function isUsableRailwayToken(value: string | undefined | null): boolean;
 export declare function resolveRailwayApiToken(env?: NodeJS.ProcessEnv | Record<string, string | undefined>): string;
 export declare function resolveRailwayApiUrl(env?: NodeJS.ProcessEnv | Record<string, string | undefined>): string;
@@ -235,6 +249,25 @@ export declare function upsertRailwayVariables({ projectId, environmentId, servi
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
     fetchImpl?: typeof fetch;
 }): Promise<void>;
+export declare function listRailwayVolumes({ projectId, env, fetchImpl, }: {
+    projectId: string;
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+    fetchImpl?: typeof fetch;
+}): Promise<RailwayVolumeSummary[]>;
+export declare function ensureRailwayServiceVolume({ projectId, environmentId, serviceId, name, mountPath, env, fetchImpl, }: {
+    projectId: string;
+    environmentId: string;
+    serviceId: string;
+    name: string;
+    mountPath: string;
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+    fetchImpl?: typeof fetch;
+}): Promise<{
+    volume: RailwayVolumeSummary;
+    instance: RailwayVolumeInstanceSummary | null;
+    created: boolean;
+    updated: boolean;
+}>;
 export declare function listRailwayCustomDomains({ projectId, environmentId, serviceId, env, fetchImpl, }: {
     projectId: string;
     environmentId: string;

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

@@ -191,6 +191,83 @@ function normalizeRailwayCustomDomain(node) {
     dnsRecords
   };
 }
+function normalizeRailwayVolumeInstance(node) {
+  const id = railwayConnectionLabel(node.id);
+  if (!id) {
+    return null;
+  }
+  const sizeGb = normalizeRailwayNumber(node.sizeGb ?? node.sizeGB ?? node.size_gb ?? node.capacityGb ?? node.capacityGB);
+  const usedGb = normalizeRailwayNumber(node.usedGb ?? node.usedGB ?? node.used_gb ?? node.currentUsageGb ?? node.currentUsageGB);
+  return {
+    id,
+    serviceId: railwayConnectionLabel(node.serviceId) || railwayConnectionLabel(node.service?.id) || null,
+    environmentId: railwayConnectionLabel(node.environmentId) || railwayConnectionLabel(node.environment?.id) || null,
+    mountPath: railwayConnectionLabel(node.mountPath) || railwayConnectionLabel(node.mount_path) || null,
+    sizeGb,
+    usedGb
+  };
+}
+function normalizeVolumeInstances(value) {
+  const direct = Array.isArray(value) ? value : null;
+  if (direct) {
+    return direct.map((entry) => entry && typeof entry === "object" ? normalizeRailwayVolumeInstance(entry) : null).filter(Boolean);
+  }
+  return normalizeConnectionNodes(value, normalizeRailwayVolumeInstance);
+}
+function normalizeRailwayVolume(node) {
+  const id = railwayConnectionLabel(node.id);
+  if (!id) {
+    return null;
+  }
+  return {
+    id,
+    name: railwayConnectionLabel(node.name),
+    projectId: railwayConnectionLabel(node.projectId) || null,
+    instances: [
+      ...normalizeVolumeInstances(node.instances),
+      ...normalizeVolumeInstances(node.volumeInstances),
+      ...normalizeVolumeInstances(node.volume_instances)
+    ]
+  };
+}
+function collectRailwayVolumes(value, seen = /* @__PURE__ */ new Set()) {
+  const volumes = [];
+  const visit = (entry) => {
+    if (!entry || typeof entry !== "object") {
+      return;
+    }
+    if (seen.has(entry)) {
+      return;
+    }
+    seen.add(entry);
+    if (Array.isArray(entry)) {
+      for (const item of entry) {
+        visit(item);
+      }
+      return;
+    }
+    const record = entry;
+    const volume = normalizeRailwayVolume(record);
+    if (volume && (record.volumeInstances !== void 0 || record.instances !== void 0 || record.projectId !== void 0 || record.name !== void 0)) {
+      volumes.push(volume);
+    }
+    for (const child of Object.values(record)) {
+      visit(child);
+    }
+  };
+  visit(value);
+  const byId = /* @__PURE__ */ new Map();
+  for (const volume of volumes) {
+    const existing = byId.get(volume.id);
+    byId.set(volume.id, existing ? {
+      ...existing,
+      name: existing.name || volume.name,
+      projectId: existing.projectId || volume.projectId,
+      instances: [...existing.instances, ...volume.instances]
+    } : volume);
+  }
+  return [...byId.values()];
+}
 async function railwayGraphqlRequest({
   query,
   variables,
@@ -811,6 +888,200 @@ mutation TreeseedRailwayVariableCollectionUpsert($input: VariableCollectionUpser
     fetchImpl
   });
 }
+async function listRailwayVolumes({
+  projectId,
+  env = process.env,
+  fetchImpl = fetch
+}) {
+  const query = configuredEnvValue(env, "TREESEED_RAILWAY_VOLUME_LIST_QUERY") || `
+query TreeseedRailwayVolumeList($projectId: String!) {
+	project(id: $projectId) {
+		id
+		volumes {
+			edges {
+				node {
+					id
+					name
+					projectId
+					volumeInstances {
+						edges {
+							node {
+								id
+								serviceId
+								environmentId
+								mountPath
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+`.trim();
+  const payload = await railwayGraphqlRequest({
+    query,
+    variables: { projectId },
+    env,
+    fetchImpl
+  });
+  return collectRailwayVolumes(payload.data);
+}
+async function createRailwayVolume({
+  projectId,
+  environmentId,
+  serviceId,
+  name,
+  mountPath,
+  env = process.env,
+  fetchImpl = fetch
+}) {
+  const mutation = configuredEnvValue(env, "TREESEED_RAILWAY_VOLUME_CREATE_MUTATION") || `
+mutation TreeseedRailwayVolumeCreate($input: VolumeCreateInput!) {
+	volumeCreate(input: $input) {
+		id
+		name
+		projectId
+		volumeInstances {
+			edges {
+				node {
+					id
+					serviceId
+					environmentId
+					mountPath
+				}
+			}
+		}
+	}
+}
+`.trim();
+  const payload = await railwayGraphqlRequest({
+    query: mutation,
+    variables: {
+      input: {
+        projectId,
+        environmentId,
+        serviceId,
+        name,
+        mountPath
+      }
+    },
+    env,
+    fetchImpl
+  });
+  const volume = collectRailwayVolumes(payload.data)[0] ?? null;
+  if (!volume) {
+    throw new Error(`Railway volume create did not return a usable volume for ${name}.`);
+  }
+  return volume;
+}
+async function updateRailwayVolumeName({
+  volumeId,
+  name,
+  env = process.env,
+  fetchImpl = fetch
+}) {
+  const mutation = configuredEnvValue(env, "TREESEED_RAILWAY_VOLUME_UPDATE_MUTATION") || `
+mutation TreeseedRailwayVolumeUpdate($id: String!, $input: VolumeUpdateInput!) {
+	volumeUpdate(id: $id, input: $input) {
+		id
+		name
+		projectId
+		volumeInstances {
+			edges {
+				node {
+					id
+					serviceId
+					environmentId
+					mountPath
+				}
+			}
+		}
+	}
+}
+`.trim();
+  const payload = await railwayGraphqlRequest({
+    query: mutation,
+    variables: {
+      id: volumeId,
+      input: { name }
+    },
+    env,
+    fetchImpl
+  });
+  return collectRailwayVolumes(payload.data)[0] ?? null;
+}
+async function updateRailwayVolumeInstanceMountPath({
+  instanceId,
+  mountPath,
+  env = process.env,
+  fetchImpl = fetch
+}) {
+  const mutation = configuredEnvValue(env, "TREESEED_RAILWAY_VOLUME_INSTANCE_UPDATE_MUTATION") || `
+mutation TreeseedRailwayVolumeInstanceUpdate($id: String!, $input: VolumeInstanceUpdateInput!) {
+	volumeInstanceUpdate(id: $id, input: $input) {
+		id
+		serviceId
+		environmentId
+		mountPath
+	}
+}
+`.trim();
+  await railwayGraphqlRequest({
+    query: mutation,
+    variables: {
+      id: instanceId,
+      input: { mountPath }
+    },
+    env,
+    fetchImpl
+  });
+}
+async function ensureRailwayServiceVolume({
+  projectId,
+  environmentId,
+  serviceId,
+  name,
+  mountPath,
+  env = process.env,
+  fetchImpl = fetch
+}) {
+  if (!mountPath.startsWith("/")) {
+    throw new Error(`Railway volume mount path must be absolute: ${mountPath}`);
+  }
+  const volumes = await listRailwayVolumes({ projectId, env, fetchImpl });
+  let volume = volumes.find(
+    (candidate) => candidate.instances.some((instance2) => instance2.serviceId === serviceId && instance2.environmentId === environmentId)
+  ) ?? volumes.find((candidate) => candidate.name === name) ?? null;
+  let created = false;
+  let updated = false;
+  if (!volume) {
+    volume = await createRailwayVolume({
+      projectId,
+      environmentId,
+      serviceId,
+      name,
+      mountPath,
+      env,
+      fetchImpl
+    });
+    created = true;
+  }
+  if (volume.name && volume.name !== name) {
+    volume = await updateRailwayVolumeName({ volumeId: volume.id, name, env, fetchImpl }) ?? { ...volume, name };
+    updated = true;
+  }
+  const instance = volume.instances.find((entry) => entry.serviceId === serviceId && entry.environmentId === environmentId) ?? null;
+  if (instance && instance.mountPath !== mountPath) {
+    await updateRailwayVolumeInstanceMountPath({ instanceId: instance.id, mountPath, env, fetchImpl });
+    volume = {
+      ...volume,
+      instances: volume.instances.map((entry) => entry.id === instance.id ? { ...entry, mountPath } : entry)
+    };
+    updated = true;
+  }
+  return { volume, instance, created, updated };
+}
 async function listRailwayCustomDomains({
   projectId,
   environmentId,
@@ -863,6 +1134,7 @@ export {
   ensureRailwayProject,
   ensureRailwayService,
   ensureRailwayServiceInstanceConfiguration,
+  ensureRailwayServiceVolume,
   getRailwayAuthProfile,
   getRailwayProject,
   getRailwayServiceInstance,
@@ -872,6 +1144,7 @@ export {
   listRailwayProjects,
   listRailwayServices,
   listRailwayVariables,
+  listRailwayVolumes,
   normalizeRailwayEnvironmentName,
   railwayGraphqlRequest,
   resolveRailwayApiToken,

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

@@ -1,4 +1,7 @@
 import { type TreeseedBootstrapTaskPrefix, type TreeseedBootstrapWriter } from './bootstrap-runner.ts';
+export declare function deriveRailwayWorkerRunnerServiceName(projectSlug: any, index?: number): string;
+export declare function deriveRailwayWorkerRunnerVolumeName(serviceName: any): string;
+export declare function railwayServiceRuntimeStartCommand(service: any): any;
 export declare function isUsableRailwayToken(value: any): boolean;
 export declare function resolveRailwayAuthToken(env?: NodeJS.ProcessEnv): string;
 export declare function buildRailwayCommandEnv(env?: NodeJS.ProcessEnv): {
@@ -55,6 +58,10 @@ export declare function configuredRailwayServices(tenantRoot: any, scope: any):
     runtimeMode: any;
     schedule: string[];
     hostingKind: string;
+    runnerPool: {
+        bootstrapIndex: number;
+        volumeMountPath: string;
+    } | null;
 } | null)[];
 export declare function configuredRailwayScheduledJobs(tenantRoot: any, scope: any, { phase }?: {
     phase?: string | undefined;
@@ -95,6 +102,10 @@ export declare function validateRailwayServiceConfiguration(tenantRoot: any, sco
         runtimeMode: any;
         schedule: string[];
         hostingKind: string;
+        runnerPool: {
+            bootstrapIndex: number;
+            volumeMountPath: string;
+        } | null;
     } | null)[];
     schedules: {
         service: string;
@@ -134,6 +145,10 @@ export declare function validateRailwayDeployPrerequisites(tenantRoot: any, scop
         runtimeMode: any;
         schedule: string[];
         hostingKind: string;
+        runnerPool: {
+            bootstrapIndex: number;
+            volumeMountPath: string;
+        } | null;
     } | null)[];
     schedules: {
         service: string;
@@ -296,5 +311,12 @@ export declare function deployRailwayService(tenantRoot: any, service: any, { dr
         healthcheckPath: string | null;
         healthcheckTimeoutSeconds: number | null;
         runtimeMode: string | null;
+        volume: {
+            id: string;
+            name: string;
+            mountPath: any;
+            created: boolean;
+            updated: boolean;
+        } | null;
     } | null;
 }>;