@treeseed/sdk 0.6.43 → 0.6.45

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

@@ -137,6 +137,14 @@ export declare function deployProjectPlatform(options: ProjectPlatformActionOpti
                 skipped: boolean;
                 reason: string;
             };
+            railwayResources: {
+                ok: boolean;
+                checks: any[];
+            } | {
+                ok: boolean;
+                skipped: boolean;
+                reason: string;
+            };
             pages: {
                 ok: boolean;
                 status: number;
@@ -315,6 +323,14 @@ export declare function monitorProjectPlatform(options: ProjectPlatformActionOpt
             skipped: boolean;
             reason: string;
         };
+        railwayResources: {
+            ok: boolean;
+            checks: any[];
+        } | {
+            ok: boolean;
+            skipped: boolean;
+            reason: string;
+        };
         pages: {
             ok: boolean;
             status: number;
@@ -498,6 +514,14 @@ export declare function runProjectPlatformAction(action: ProjectPlatformAction,
             skipped: boolean;
             reason: string;
         };
+        railwayResources: {
+            ok: boolean;
+            checks: any[];
+        } | {
+            ok: boolean;
+            skipped: boolean;
+            reason: string;
+        };
         pages: {
             ok: boolean;
             status: number;
@@ -637,6 +661,14 @@ export declare function runProjectPlatformAction(action: ProjectPlatformAction,
                 skipped: boolean;
                 reason: string;
             };
+            railwayResources: {
+                ok: boolean;
+                checks: any[];
+            } | {
+                ok: boolean;
+                skipped: boolean;
+                reason: string;
+            };
             pages: {
                 ok: boolean;
                 status: number;

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

@@ -35,6 +35,7 @@ import {
   ensureRailwayScheduledJobs,
   validateRailwayDeployPrerequisites,
   validateRailwayServiceConfiguration,
+  verifyRailwayManagedResources,
   verifyRailwayScheduledJobs
 } from "./railway-deploy.js";
 import { loadCliDeployConfig, packageScriptPath } from "./runtime-tools.js";
@@ -1209,6 +1210,7 @@ async function publishProjectContent(options) {
 }
 async function monitorProjectPlatform(options) {
   const reporter = resolveReporter(options.tenantRoot, options.reporter);
+  const env = { ...process.env, ...options.env ?? {} };
   const target = createPersistentDeployTarget(options.scope === "local" ? "staging" : options.scope);
   const siteConfig = loadCliDeployConfig(options.tenantRoot);
   const selectedSystems = new Set(resolveProjectPlatformBootstrapSystems(options, siteConfig));
@@ -1228,12 +1230,14 @@ async function monitorProjectPlatform(options) {
     r2: options.dryRun ? { ok: true, skipped: true, reason: "dry_run" } : probeR2(options.tenantRoot, siteConfig, state, target),
     queue: options.dryRun ? Promise.resolve({ ok: true, skipped: true, reason: "dry_run" }) : probeQueue(siteConfig, state),
     scaleProbe: probeScaleConfiguration(siteConfig, state),
+    railwayResources: options.scope === "local" || !apiSelected && !agentsSelected ? Promise.resolve({ ok: true, skipped: true, reason: options.scope === "local" ? "local_scope" : "railway_not_selected" }) : verifyRailwayManagedResources(options.tenantRoot, options.scope, { env, settleDeployments: true }),
     readiness: state.readiness
   };
   const resolvedChecks = {
     ...checks,
     r2: await checks.r2,
-    queue: await checks.queue
+    queue: await checks.queue,
+    railwayResources: await checks.railwayResources
   };
   const ok = [
     resolvedChecks.pages,
@@ -1243,7 +1247,8 @@ async function monitorProjectPlatform(options) {
     resolvedChecks.agentHealth,
     resolvedChecks.r2,
     resolvedChecks.queue,
-    resolvedChecks.scaleProbe
+    resolvedChecks.scaleProbe,
+    resolvedChecks.railwayResources
   ].every((check) => check?.ok === true || check?.skipped === true);
   if (!ok) {
     const failedChecks = Object.entries(resolvedChecks).filter(([, check]) => check && typeof check === "object" && check.ok !== true && check.skipped !== true).map(([name, check]) => `${name}: ${JSON.stringify(check)}`);

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

@@ -2,6 +2,7 @@ import { type TreeseedBootstrapTaskPrefix, type TreeseedBootstrapWriter } from '
 export declare function deriveRailwayWorkerRunnerServiceName(projectSlug: any, index?: number): string;
 export declare function deriveRailwayWorkerRunnerVolumeName(serviceName: any, environmentName?: string): string;
 export declare function railwayServiceRuntimeStartCommand(service: any): any;
+export declare function collectRailwayDeploymentStatusChecks(statusPayload: any, scope: any, services: any): any;
 export declare function isUsableRailwayToken(value: any): boolean;
 export declare function resolveRailwayAuthToken(env?: NodeJS.ProcessEnv): string;
 export declare function buildRailwayCommandEnv(env?: NodeJS.ProcessEnv): {
@@ -12,6 +13,43 @@ export declare function runRailway(args: any, { cwd, capture, allowFailure, inpu
     capture?: boolean | undefined;
     allowFailure?: boolean | undefined;
 }): import("child_process").SpawnSyncReturns<string>;
+export declare function waitForRailwayManagedDeploymentsSettled(tenantRoot: any, scope: any, { services, env, timeoutMs, pollMs, }?: {
+    services?: ({
+        key: string;
+        scope: string;
+        projectId: string | null;
+        projectName: string;
+        serviceId: string | null;
+        serviceName: string;
+        rootDir: string;
+        publicBaseUrl: string | null;
+        railwayEnvironment: string;
+        buildCommand: string | null;
+        startCommand: string | null;
+        healthcheckPath: any;
+        healthcheckTimeoutSeconds: any;
+        healthcheckIntervalSeconds: any;
+        restartPolicy: any;
+        runtimeMode: any;
+        schedule: string[];
+        hostingKind: string;
+        runnerPool: {
+            bootstrapIndex: number;
+            volumeMountPath: string;
+        } | null;
+    } | null)[] | undefined;
+    env?: NodeJS.ProcessEnv | undefined;
+    timeoutMs?: number | undefined;
+    pollMs?: number | undefined;
+}): Promise<{
+    ok: boolean;
+    checks: any;
+    message?: undefined;
+} | {
+    ok: boolean;
+    checks: any;
+    message: string;
+}>;
 export declare function setRailwaySecretVariable({ cwd, service, environment, key, value, env, capture, allowFailure }: {
     cwd: any;
     service: any;
@@ -281,6 +319,16 @@ export declare function verifyRailwayScheduledJobs(tenantRoot: any, scope: any,
     unsupported?: undefined;
     message?: undefined;
 }>;
+export declare function verifyRailwayManagedResources(tenantRoot: any, scope: any, { fetchImpl, apiToken, apiUrl, env, settleDeployments, settleTimeoutMs, settlePollMs, }?: {
+    fetchImpl?: typeof fetch | undefined;
+    env?: NodeJS.ProcessEnv | undefined;
+    settleDeployments?: boolean | undefined;
+    settleTimeoutMs?: number | undefined;
+    settlePollMs?: number | undefined;
+}): Promise<{
+    ok: boolean;
+    checks: any[];
+}>;
 export declare function planRailwayServiceDeploy(service: any, { env }?: {
     env?: NodeJS.ProcessEnv | undefined;
 }): {

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

@@ -15,6 +15,7 @@ import {
   listRailwayEnvironments,
   listRailwayProjects,
   listRailwayServices,
+  listRailwayVolumes,
   normalizeRailwayEnvironmentName,
   resolveRailwayApiToken,
   resolveRailwayApiUrl,
@@ -94,6 +95,74 @@ function parseRailwayJsonOutput(output) {
   }
   return null;
 }
+function railwayEdgeNodes(value) {
+  return Array.isArray(value?.edges) ? value.edges.map((entry) => entry?.node).filter(Boolean) : [];
+}
+function railwayStatusEnvironmentNodes(payload) {
+  if (!payload || typeof payload !== "object") {
+    return [];
+  }
+  if (Array.isArray(payload.environments)) {
+    return payload.environments;
+  }
+  return railwayEdgeNodes(payload.environments);
+}
+function railwayStatusDeploymentSettled(status) {
+  const normalized = String(status ?? "").trim().toUpperCase();
+  return normalized === "SUCCESS" || normalized === "SLEEPING";
+}
+function collectRailwayDeploymentStatusChecks(statusPayload, scope, services) {
+  const expectedEnvironment = resolveRailwayEnvironmentForScope(scope);
+  const environments = railwayStatusEnvironmentNodes(statusPayload);
+  const environment = environments.find(
+    (candidate) => normalizeRailwayEnvironmentName(candidate?.name) === expectedEnvironment
+  ) ?? null;
+  if (!environment) {
+    return services.map((service) => ({
+      type: "deployment-status",
+      service: service.key,
+      serviceName: service.serviceName,
+      environment: expectedEnvironment,
+      ok: false,
+      status: "missing_environment",
+      message: `Railway status did not include the ${expectedEnvironment} environment.`
+    }));
+  }
+  const instances = railwayEdgeNodes(environment.serviceInstances);
+  return services.map((service) => {
+    const instance = instances.find((candidate) => candidate?.serviceName === service.serviceName) ?? null;
+    if (!instance) {
+      return {
+        type: "deployment-status",
+        service: service.key,
+        serviceName: service.serviceName,
+        environment: expectedEnvironment,
+        ok: false,
+        status: "missing_service_instance",
+        message: `Railway status did not include service ${service.serviceName} in ${expectedEnvironment}.`
+      };
+    }
+    const deployment = instance.latestDeployment ?? null;
+    const status = String(deployment?.status ?? "").trim().toUpperCase();
+    const instanceStatuses = Array.isArray(deployment?.instances) ? deployment.instances.map((entry) => String(entry?.status ?? "").trim()).filter(Boolean) : [];
+    const ok = railwayStatusDeploymentSettled(status);
+    return {
+      type: "deployment-status",
+      service: service.key,
+      serviceName: service.serviceName,
+      environment: normalizeRailwayEnvironmentName(environment.name),
+      ok,
+      status: status || "missing_deployment",
+      observed: {
+        status: status || null,
+        deploymentStopped: deployment?.deploymentStopped ?? null,
+        instanceStatuses,
+        volumeMounts: Array.isArray(deployment?.meta?.volumeMounts) ? deployment.meta.volumeMounts : []
+      },
+      message: ok ? void 0 : `Railway deployment for ${service.serviceName} is not settled yet; observed ${status || "missing deployment status"}.`
+    };
+  });
+}
 function normalizeRailwayCliVolume(value, { serviceId, environmentId, fallbackName, fallbackMountPath }) {
   if (!value || typeof value !== "object") {
     return null;
@@ -320,6 +389,50 @@ function runRailway(args, { cwd, capture = false, allowFailure = false, input, e
   }
   return result;
 }
+async function waitForRailwayManagedDeploymentsSettled(tenantRoot, scope, {
+  services = configuredRailwayServices(tenantRoot, scope),
+  env = process.env,
+  timeoutMs = 18e4,
+  pollMs = 15e3
+} = {}) {
+  const deadline = Date.now() + timeoutMs;
+  let checks = [];
+  let lastError = null;
+  for (; ; ) {
+    try {
+      const result = runRailway(["status", "--json"], {
+        cwd: tenantRoot,
+        capture: true,
+        env
+      });
+      const payload = parseRailwayJsonOutput(result.stdout);
+      checks = collectRailwayDeploymentStatusChecks(payload, scope, services);
+      lastError = null;
+      if (checks.every((entry) => entry.ok === true)) {
+        return { ok: true, checks };
+      }
+    } catch (error) {
+      lastError = error;
+      checks = services.map((service) => ({
+        type: "deployment-status",
+        service: service.key,
+        serviceName: service.serviceName,
+        environment: resolveRailwayEnvironmentForScope(scope),
+        ok: false,
+        status: "status_error",
+        message: error instanceof Error ? error.message : String(error)
+      }));
+    }
+    if (Date.now() >= deadline) {
+      return {
+        ok: false,
+        checks,
+        message: lastError instanceof Error ? lastError.message : "Railway deployments did not settle before the monitor timeout."
+      };
+    }
+    await sleep(pollMs);
+  }
+}
 function setRailwaySecretVariable({ cwd, service, environment, key, value, env = process.env, capture = false, allowFailure = false }) {
   const effectiveEnv = buildRailwayCommandEnv({
     ...process.env,
@@ -841,6 +954,131 @@ async function verifyRailwayScheduledJobs(tenantRoot, scope, { fetchImpl = fetch
     checks
   };
 }
+async function verifyRailwayManagedResources(tenantRoot, scope, {
+  fetchImpl = fetch,
+  apiToken,
+  apiUrl,
+  env = process.env,
+  settleDeployments = false,
+  settleTimeoutMs = 18e4,
+  settlePollMs = 15e3
+} = {}) {
+  const effectiveApiToken = apiToken || resolveRailwayAuthToken(env);
+  const effectiveApiUrl = apiUrl || resolveRailwayApiUrl(env);
+  const effectiveEnv = { ...env, RAILWAY_API_TOKEN: effectiveApiToken, TREESEED_RAILWAY_API_URL: effectiveApiUrl };
+  const services = configuredRailwayServices(tenantRoot, scope);
+  const checks = [];
+  for (const service of services) {
+    const target = await resolveRailwayScheduleTarget({
+      projectId: service.projectId,
+      projectName: service.projectName,
+      serviceId: service.serviceId,
+      serviceName: service.serviceName,
+      environment: normalizeRailwayEnvironmentName(service.railwayEnvironment),
+      environmentId: envValue("TREESEED_RAILWAY_ENVIRONMENT_ID") || null
+    }, {
+      env: effectiveEnv,
+      fetchImpl,
+      ensure: false
+    });
+    if (!target.project || !target.environment || !target.service) {
+      checks.push({
+        type: "service",
+        service: service.key,
+        serviceName: service.serviceName,
+        projectName: service.projectName,
+        environment: service.railwayEnvironment,
+        ok: false,
+        status: "missing",
+        message: `Railway service ${service.serviceName} is missing in ${service.railwayEnvironment}.`
+      });
+      continue;
+    }
+    const instance = await getRailwayServiceInstance({
+      serviceId: target.service.id,
+      environmentId: target.environment.id,
+      env: effectiveEnv,
+      fetchImpl
+    });
+    checks.push({
+      type: "service-instance",
+      service: service.key,
+      serviceName: target.service.name,
+      serviceId: target.service.id,
+      projectId: target.project.id,
+      environment: target.environment.name,
+      environmentId: target.environment.id,
+      instanceId: instance.id,
+      ok: Boolean(instance.id),
+      status: instance.id ? "checked" : "missing",
+      observed: instance.id ? {
+        rootDirectory: instance.rootDirectory,
+        startCommand: instance.startCommand,
+        cronSchedule: instance.cronSchedule,
+        sleepApplication: instance.sleepApplication,
+        runtimeMode: instance.runtimeMode
+      } : null,
+      message: instance.id ? void 0 : `Railway service instance for ${target.service.name} is missing in ${target.environment.name}.`
+    });
+    if (service.key === "workerRunner") {
+      const expectedVolumeName = deriveRailwayWorkerRunnerVolumeName(target.service.name, target.environment.name);
+      const volumes = await listRailwayVolumes({
+        projectId: target.project.id,
+        env: effectiveEnv,
+        fetchImpl
+      });
+      const volume = volumes.find(
+        (candidate) => candidate.name === expectedVolumeName && candidate.instances.some((entry) => entry.serviceId === target.service.id && entry.environmentId === target.environment.id && entry.mountPath === WORKER_RUNNER_VOLUME_MOUNT_PATH)
+      ) ?? null;
+      checks.push({
+        type: "worker-runner-volume",
+        service: service.key,
+        serviceName: target.service.name,
+        serviceId: target.service.id,
+        projectId: target.project.id,
+        environment: target.environment.name,
+        environmentId: target.environment.id,
+        volumeName: expectedVolumeName,
+        mountPath: WORKER_RUNNER_VOLUME_MOUNT_PATH,
+        ok: Boolean(volume),
+        status: volume ? "checked" : "missing",
+        observed: volume ? {
+          id: volume.id,
+          name: volume.name,
+          instances: volume.instances
+        } : null,
+        message: volume ? void 0 : `Railway worker-runner volume ${expectedVolumeName} is missing or is not mounted at ${WORKER_RUNNER_VOLUME_MOUNT_PATH}.`
+      });
+    }
+  }
+  const schedules = await verifyRailwayScheduledJobs(tenantRoot, scope, {
+    fetchImpl,
+    apiToken: effectiveApiToken,
+    apiUrl: effectiveApiUrl,
+    env: effectiveEnv
+  });
+  for (const check of schedules.checks ?? []) {
+    checks.push({
+      type: "schedule",
+      ...check
+    });
+  }
+  if (settleDeployments) {
+    const settled = await waitForRailwayManagedDeploymentsSettled(tenantRoot, scope, {
+      services,
+      env: effectiveEnv,
+      timeoutMs: settleTimeoutMs,
+      pollMs: settlePollMs
+    });
+    for (const check of settled.checks ?? []) {
+      checks.push(check);
+    }
+  }
+  return {
+    ok: checks.every((entry) => entry.ok === true || entry.skipped === true),
+    checks
+  };
+}
 function shouldAttachRailwayDeployLogs(env = process.env) {
   return configuredEnvValue(env, "TREESEED_RAILWAY_DEPLOY_ATTACH_LOGS") === "1";
 }
@@ -1148,6 +1386,7 @@ async function deployRailwayService(tenantRoot, service, {
 }
 export {
   buildRailwayCommandEnv,
+  collectRailwayDeploymentStatusChecks,
   configuredRailwayScheduledJobs,
   configuredRailwayServices,
   deployRailwayService,
@@ -1168,5 +1407,7 @@ export {
   setRailwaySecretVariable,
   validateRailwayDeployPrerequisites,
   validateRailwayServiceConfiguration,
-  verifyRailwayScheduledJobs
+  verifyRailwayManagedResources,
+  verifyRailwayScheduledJobs,
+  waitForRailwayManagedDeploymentsSettled
 };

package/dist/workflow/operations.js

@@ -319,7 +319,7 @@ function normalizeSaveVerifyMode(mode) {
   }
 }
 function shouldUseHostedSaveCi(input) {
-  return normalizeCiMode(input.ciMode, "save") === "hosted" || input.verifyMode === "hosted" || input.verifyMode === "both";
+  return normalizeCiMode(input.ciMode, "save") === "hosted" || input.verifyMode === "hosted" || input.verifyMode === "both" || input.verifyDeployedResources === true;
 }
 function worktreePayload(root, requestedMode) {
   const metadata = managedWorkflowWorktreeMetadata(root);
@@ -2875,7 +2875,8 @@ async function workflowSave(helpers, input) {
           ciMode: effectiveInput.ciMode ?? "auto",
           worktreeMode: effectiveInput.worktreeMode ?? "auto",
           commitMessageMode: effectiveInput.commitMessageMode ?? "auto",
-          workspaceLinks: effectiveInput.workspaceLinks ?? "auto"
+          workspaceLinks: effectiveInput.workspaceLinks ?? "auto",
+          verifyDeployedResources: effectiveInput.verifyDeployedResources === true
         },
         [
           {
@@ -2971,6 +2972,13 @@ async function workflowSave(helpers, input) {
             branch,
             headSha: savedRootRepo.commitSha
           }] : [],
+          ...effectiveInput.verifyDeployedResources === true && scope !== "local" && savedRootRepo.pushed && savedRootRepo.commitSha && branch ? [{
+            name: savedRootRepo.name,
+            repoPath: savedRootRepo.path,
+            workflow: "deploy.yml",
+            branch,
+            headSha: savedRootRepo.commitSha
+          }] : [],
           ...savedPackageReports.filter((repo) => repo.pushed && repo.commitSha && repo.branch).map((repo) => ({
             name: repo.name,
             repoPath: repo.path,
@@ -2978,7 +2986,11 @@ async function workflowSave(helpers, input) {
             branch: String(repo.branch),
             headSha: String(repo.commitSha)
           }))
-        ], "hosted", { root, runId: workflowRun.runId }).then((workflowGates) => ({ workflowGates }))) : { workflowGates: [] };
+        ], "hosted", {
+          root,
+          runId: workflowRun.runId,
+          onProgress: (line, stream) => helpers.write(line, stream)
+        }).then((workflowGates) => ({ workflowGates }))) : { workflowGates: [] };
         const releaseCandidate = branch === STAGING_BRANCH ? await executeJournalStep(root, workflowRun.runId, "release-candidate", () => {
           const releaseSession = resolveTreeseedWorkflowSession(root);
           const stagingReleasePlan = buildReleasePlanSnapshot({
@@ -3289,6 +3301,7 @@ async function workflowStage(helpers, input) {
       const effectiveInput = autoResumeRun ? autoResumeRun.input : input;
       const message = ensureMessage("stage", effectiveInput.message, "a resolution message");
       const ciMode = normalizeCiMode(effectiveInput.ciMode, "stage");
+      const waitForStaging = effectiveInput.verifyDeployedResources === true || effectiveInput.waitForStaging !== false;
       if (executionMode === "plan") {
         const blockers = [];
         if (initialSession.branchRole !== "feature") {
@@ -3371,11 +3384,12 @@ async function workflowStage(helpers, input) {
         session,
         {
           message,
-          waitForStaging: effectiveInput.waitForStaging !== false,
+          waitForStaging,
           deletePreview: effectiveInput.deletePreview !== false,
           deleteBranch: effectiveInput.deleteBranch !== false,
           ciMode,
-          worktreeMode: effectiveInput.worktreeMode ?? "auto"
+          worktreeMode: effectiveInput.worktreeMode ?? "auto",
+          verifyDeployedResources: effectiveInput.verifyDeployedResources === true
         },
         [
           { id: "workspace-unlink", description: "Remove local workspace links", repoName: rootRepo.name, repoPath: rootRepo.path, branch: featureBranch, resumable: true },
@@ -3491,7 +3505,7 @@ async function workflowStage(helpers, input) {
             exitCode: 12
           });
         }
-        const stageWorkflowGateResult = effectiveInput.waitForStaging === false ? (skipJournalStep(root, workflowRun.runId, "wait-staging", { status: "skipped", reason: "disabled" }), { status: "skipped", reason: "disabled" }) : await executeJournalStep(root, workflowRun.runId, "wait-staging", () => waitForWorkflowGates("stage", [
+        const stageWorkflowGateResult = !waitForStaging ? (skipJournalStep(root, workflowRun.runId, "wait-staging", { status: "skipped", reason: "disabled" }), { status: "skipped", reason: "disabled" }) : await executeJournalStep(root, workflowRun.runId, "wait-staging", () => waitForWorkflowGates("stage", [
           {
             name: rootRepo.name,
             repoPath: rootRepo.path,
@@ -3506,7 +3520,11 @@ async function workflowStage(helpers, input) {
             branch: STAGING_BRANCH,
             headSha: String(report.commitSha)
           }))
-        ], ciMode, { root, runId: workflowRun.runId }).then((workflowGates) => ({
+        ], ciMode, {
+          root,
+          runId: workflowRun.runId,
+          onProgress: (line, stream) => helpers.write(line, stream)
+        }).then((workflowGates) => ({
           status: "completed",
           workflowGates
         })));

package/dist/workflow.d.ts

@@ -111,6 +111,7 @@ export type TreeseedSaveInput = {
     worktreeMode?: TreeseedWorkflowWorktreeMode;
     commitMessageMode?: 'auto' | 'cloudflare' | 'generated' | 'fallback';
     workspaceLinks?: 'auto' | 'off';
+    verifyDeployedResources?: boolean;
     plan?: boolean;
     dryRun?: boolean;
 };
@@ -153,6 +154,7 @@ export type TreeseedStageInput = {
     ciMode?: TreeseedWorkflowCiMode;
     worktreeMode?: TreeseedWorkflowWorktreeMode;
     workspaceLinks?: 'auto' | 'off';
+    verifyDeployedResources?: boolean;
     plan?: boolean;
     dryRun?: boolean;
 };

package/package.json

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