@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/operations/services/live-hosted-service-checks.js

@@ -1,611 +0,0 @@
-import { resolve } from "node:path";
-import { loadTreeseedPlatformConfig } from "../../platform/config.js";
-import { resolveTreeseedLaunchEnvironment } from "./config-runtime.js";
-import {
-  getRailwayServiceInstance,
-  inspectRailwayServiceDeploymentHealth,
-  listRailwayEnvironments,
-  listRailwayProjects,
-  listRailwayServices,
-  listRailwayVariables,
-  listRailwayVolumes,
-  normalizeRailwayEnvironmentName,
-  resolveRailwayWorkspaceContext
-} from "./railway-api.js";
-import {
-  configuredRailwayServices,
-  findStaleTreeseedOperationsRunnerResources,
-  isTreeseedOperationsRunnerResourceName,
-  railwayObsoleteAliasCleanupPolicy
-} from "./railway-deploy.js";
-import { railwayTreeDxServiceName } from "./railway-source-policy.js";
-import { discoverTreeseedApplications } from "../../hosting/apps.js";
-import {
-  collectTreeseedHostedServiceChecks
-} from "./hosted-service-checks.js";
-const DEFAULT_RETRY_ATTEMPTS = 3;
-const DEFAULT_RETRY_INTERVAL_MS = 1500;
-const DEFAULT_RAILWAY_DEPLOYMENT_SETTLE_ATTEMPTS = 12;
-const DEFAULT_RAILWAY_DEPLOYMENT_SETTLE_INTERVAL_MS = 5e3;
-function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
-}
-function liveCheckErrorMessage(error, fallback) {
-  const message = error instanceof Error ? error.message : String(error ?? "");
-  return message.trim() || fallback;
-}
-function normalizeBaseUrl(value) {
-  return typeof value === "string" && value.trim() ? value.trim().replace(/\/+$/u, "") : null;
-}
-function urlForDomain(value) {
-  const normalized = normalizeBaseUrl(value);
-  if (!normalized) return null;
-  return /^https?:\/\//iu.test(normalized) ? normalized : `https://${normalized}`;
-}
-function selectedWebConfig(deployConfig, selectedApplication) {
-  return selectedApplication?.roles.includes("web") ? selectedApplication.config : deployConfig;
-}
-function pagesBranchName(config, target) {
-  const pages = config.cloudflare?.pages && typeof config.cloudflare.pages === "object" ? config.cloudflare.pages : {};
-  const key = target === "prod" ? "productionBranch" : "stagingBranch";
-  const fallback = target === "prod" ? "main" : "staging";
-  return typeof pages[key] === "string" && pages[key].trim() ? pages[key].trim() : fallback;
-}
-async function observeHttp(url, options) {
-  const attempts = Math.max(1, Math.floor(options.httpRetry?.attempts ?? options.retry?.attempts ?? DEFAULT_RETRY_ATTEMPTS));
-  const intervalMs = Math.max(0, Math.floor(options.httpRetry?.intervalMs ?? options.retry?.intervalMs ?? DEFAULT_RETRY_INTERVAL_MS));
-  const timeoutMs = Math.max(1e3, Math.floor(options.timeoutMs ?? 1e4));
-  let lastError = "";
-  let lastResponse = null;
-  for (let attempt = 0; attempt < attempts; attempt += 1) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-      const response = await (options.fetchImpl ?? fetch)(url, {
-        method: "GET",
-        headers: { accept: "application/json, text/plain, */*" },
-        signal: controller.signal
-      });
-      clearTimeout(timeout);
-      lastResponse = { status: response.status, ok: response.ok };
-      if (response.ok) return lastResponse;
-    } catch (error) {
-      clearTimeout(timeout);
-      lastError = error instanceof Error ? error.message : String(error);
-      if (attempt + 1 < attempts) await sleep(intervalMs);
-    }
-    if (attempt + 1 < attempts) await sleep(intervalMs);
-  }
-  return lastResponse ?? { ok: false, error: lastError || "HTTP request failed." };
-}
-async function inspectRailwayServiceDeploymentHealthWithRetry(input) {
-  const attempts = Math.max(1, Math.floor(input.options.retry?.attempts ?? DEFAULT_RAILWAY_DEPLOYMENT_SETTLE_ATTEMPTS));
-  const intervalMs = Math.max(0, Math.floor(input.options.retry?.intervalMs ?? DEFAULT_RAILWAY_DEPLOYMENT_SETTLE_INTERVAL_MS));
-  let lastDeployment = null;
-  let lastError = null;
-  for (let attempt = 0; attempt < attempts; attempt += 1) {
-    try {
-      const deployment = await inspectRailwayServiceDeploymentHealth({
-        serviceId: input.serviceId,
-        environmentId: input.environmentId,
-        env: input.options.env,
-        fetchImpl: input.options.fetchImpl
-      });
-      lastDeployment = deployment;
-      if (deployment.ok) return deployment;
-      if (input.acceptSleeping && deployment.status === "SLEEPING") {
-        return { ...deployment, ok: true, message: "Serverless deployment is healthy and sleeping until requested." };
-      }
-    } catch (error) {
-      lastError = error;
-    }
-    if (attempt === 0 || (attempt + 1) % 3 === 0) {
-      process.stderr.write(`[trsd][railway][live-check] service=${input.serviceName ?? input.serviceId} attempt=${attempt + 1}/${attempts} status=${lastDeployment?.status ?? "unavailable"}
-`);
-    }
-    if (attempt + 1 < attempts) await sleep(intervalMs);
-  }
-  return lastDeployment ?? {
-    ok: false,
-    status: null,
-    message: lastError instanceof Error ? lastError.message : String(lastError ?? "Unable to inspect deployment health.")
-  };
-}
-function findByName(items, nameOrId) {
-  if (!nameOrId) return null;
-  return items.find((item) => item.name === nameOrId || item.id === nameOrId) ?? null;
-}
-function indexedName(baseName, index) {
-  return `${baseName.replace(/-\d+$/u, "")}-${String(Math.max(1, index)).padStart(2, "0")}`;
-}
-function isActiveRailwayVolumeInstance(instance) {
-  const state = String(instance.state ?? "READY").toUpperCase();
-  return instance.isPendingDeletion !== true && !(typeof instance.deletedAt === "string" && instance.deletedAt.trim()) && state !== "DELETING" && state !== "DELETED";
-}
-function activeRailwayVolumeInstances(volume) {
-  const instances = Array.isArray(volume.instances) ? volume.instances : [];
-  return instances.filter(isActiveRailwayVolumeInstance);
-}
-function railwayVolumeInstanceStates(volume) {
-  const states = (Array.isArray(volume.instances) ? volume.instances : []).map((instance) => {
-    const state = String(instance.state ?? "READY").trim().toUpperCase();
-    return `${state}${instance.isPendingDeletion === true ? ":PENDING_DELETION" : ""}${instance.deletedAt ? `:DELETED_AT=${instance.deletedAt}` : ""}`;
-  }).filter(Boolean);
-  return states.length > 0 ? [...new Set(states)].join(",") : "none";
-}
-function isRetainedDetachedRailwayVolume(value) {
-  return String(value ?? "").trim().startsWith("retained-");
-}
-function selectedServiceKeySet(options) {
-  return new Set((options.serviceKeys ?? []).map((key) => key.trim()).filter(Boolean));
-}
-function serviceIsSelected(selected, serviceKey) {
-  return selected.size === 0 || selected.has(serviceKey);
-}
-function serviceMatchesAppSelection(service, tenantRoot, appId, applications) {
-  if (!appId) return true;
-  if (service.application?.id === appId) return true;
-  if (!service.application) {
-    const rootApplication = applications.find((application) => application.root === tenantRoot);
-    return rootApplication?.id === appId || rootApplication?.relativeRoot === appId;
-  }
-  return false;
-}
-function treeseedDatabaseDescriptors(tenantRoot, options) {
-  const descriptors = [];
-  const rootConfig = loadTreeseedPlatformConfig({ tenantRoot, environment: options.target, env: process.env }).deployConfig;
-  const applications = discoverTreeseedApplications(tenantRoot);
-  const candidates = [
-    { applicationId: null, applicationRoot: tenantRoot, config: rootConfig },
-    ...applications.map((application) => ({
-      applicationId: application.id,
-      applicationRoot: application.root,
-      config: application.config
-    }))
-  ];
-  for (const candidate of candidates) {
-    if (options.appId && options.appId !== candidate.applicationId) continue;
-    const service = candidate.config.services?.treeseedDatabase;
-    if (!service || service.enabled === false || service.provider !== "railway" || service.railway?.resourceType !== "postgres") {
-      continue;
-    }
-    const serviceName = typeof service.railway?.serviceName === "string" && service.railway.serviceName.trim() ? service.railway.serviceName.trim() : `${candidate.config.slug ?? "treeseed-api"}-postgres`;
-    descriptors.push({
-      applicationId: candidate.applicationId,
-      applicationRoot: candidate.applicationRoot,
-      serviceName
-    });
-  }
-  return descriptors;
-}
-async function verifyRailwayPostgresTopology(input) {
-  const descriptorRoot = resolve(input.descriptor.applicationRoot);
-  const ownerService = input.configuredServices.find(
-    (service) => ["api", "operationsRunner"].includes(service.key) && (!input.descriptor.applicationId || service.application?.id === input.descriptor.applicationId || service.application?.root === descriptorRoot || !service.application && resolve(service.rootDir) === descriptorRoot)
-  );
-  if (!ownerService) {
-    input.issues.push(`${input.descriptor.serviceName}: no Railway API or operations runner service is configured to own the database.`);
-    return;
-  }
-  const project = ownerService.projectId ? findByName(input.projects, ownerService.projectId) : findByName(input.projects, ownerService.projectName);
-  if (!project?.id) {
-    input.issues.push(`${input.descriptor.serviceName}: Railway project ${ownerService.projectName} was not found.`);
-    return;
-  }
-  const environments = await listRailwayEnvironments({ projectId: project.id, env: input.options.env, fetchImpl: input.options.fetchImpl });
-  const environment = findByName(environments, ownerService.railwayEnvironment);
-  if (!environment?.id) {
-    input.issues.push(`${input.descriptor.serviceName}: Railway environment ${ownerService.railwayEnvironment} was not found.`);
-    return;
-  }
-  const [services, volumes] = await Promise.all([
-    listRailwayServices({ projectId: project.id, env: input.options.env, fetchImpl: input.options.fetchImpl }),
-    listRailwayVolumes({ projectId: project.id, env: input.options.env, fetchImpl: input.options.fetchImpl }).catch(() => [])
-  ]);
-  const postgresService = findByName(services, input.descriptor.serviceName);
-  if (!postgresService?.id) {
-    input.issues.push(`${input.descriptor.serviceName}: canonical Railway PostgreSQL service was not found.`);
-  }
-  const volumeName = `${input.descriptor.serviceName}-volume`;
-  const canonicalVolume = volumes.find((volume) => volume.name === volumeName) ?? null;
-  if (!canonicalVolume) {
-    input.issues.push(`${volumeName}: canonical Railway PostgreSQL volume was not found.`);
-    return;
-  }
-  const activeInstances = activeRailwayVolumeInstances(canonicalVolume);
-  const attachedToPostgres = postgresService?.id ? activeInstances.some(
-    (instance) => instance.serviceId === postgresService.id && instance.environmentId === environment.id && instance.mountPath === "/var/lib/postgresql/data"
-  ) : false;
-  if (!attachedToPostgres) {
-    input.issues.push(`${volumeName}: canonical Railway PostgreSQL volume is not attached to ${input.descriptor.serviceName} at /var/lib/postgresql/data (states=${railwayVolumeInstanceStates(canonicalVolume)}).`);
-  }
-}
-function resolveLiveProviderEnv(options) {
-  let launchValues = {};
-  try {
-    launchValues = resolveTreeseedLaunchEnvironment({
-      tenantRoot: options.tenantRoot,
-      scope: options.target,
-      baseEnv: { ...process.env, ...options.env ?? {} }
-    });
-  } catch {
-    launchValues = {};
-  }
-  return {
-    ...process.env,
-    ...launchValues,
-    ...options.env ?? {}
-  };
-}
-async function collectRailwayObservations(options) {
-  const observed = {};
-  const issues = [];
-  const inspectedVolumeScopes = /* @__PURE__ */ new Set();
-  const inspectedRunnerScopes = /* @__PURE__ */ new Set();
-  const selectedServiceKeys = selectedServiceKeySet(options);
-  const applications = discoverTreeseedApplications(options.tenantRoot);
-  const environmentCache = /* @__PURE__ */ new Map();
-  const serviceCache = /* @__PURE__ */ new Map();
-  const volumeCache = /* @__PURE__ */ new Map();
-  const environmentsFor = (projectId) => {
-    const existing = environmentCache.get(projectId);
-    if (existing) return existing;
-    const loaded = listRailwayEnvironments({ projectId, env: options.env, fetchImpl: options.fetchImpl });
-    environmentCache.set(projectId, loaded);
-    return loaded;
-  };
-  const servicesFor = (projectId) => {
-    const existing = serviceCache.get(projectId);
-    if (existing) return existing;
-    const loaded = listRailwayServices({ projectId, env: options.env, fetchImpl: options.fetchImpl });
-    serviceCache.set(projectId, loaded);
-    return loaded;
-  };
-  const volumesFor = (projectId) => {
-    const existing = volumeCache.get(projectId);
-    if (existing) return existing;
-    const loaded = listRailwayVolumes({ projectId, env: options.env, fetchImpl: options.fetchImpl }).catch(() => []);
-    volumeCache.set(projectId, loaded);
-    return loaded;
-  };
-  try {
-    const workspace = await resolveRailwayWorkspaceContext({ env: options.env, fetchImpl: options.fetchImpl });
-    const projects = await listRailwayProjects({ workspaceId: workspace.id, env: options.env, fetchImpl: options.fetchImpl });
-    const configuredServices = configuredRailwayServices(options.tenantRoot, options.target, options.env).filter((entry) => serviceMatchesAppSelection(entry, options.tenantRoot, options.appId, applications)).filter((entry) => serviceIsSelected(selectedServiceKeys, entry.key));
-    const siblingTarget = options.target === "staging" ? "prod" : options.target === "prod" ? "staging" : null;
-    const configuredSiblingServices = siblingTarget ? configuredRailwayServices(options.tenantRoot, siblingTarget, options.env, { identityOnly: true }).filter((entry) => entry.enabled !== false).filter((entry) => entry.key === "operationsRunner") : [];
-    const retainedObsoleteAliases = options.target === "staging" ? railwayObsoleteAliasCleanupPolicy("staging", configuredServices).retainedResourceNames : [];
-    if (selectedServiceKeys.size === 0 || selectedServiceKeys.has("api") || selectedServiceKeys.has("operationsRunner")) {
-      for (const descriptor of treeseedDatabaseDescriptors(options.tenantRoot, options)) {
-        await verifyRailwayPostgresTopology({ descriptor, configuredServices, projects, options, issues });
-      }
-    }
-    for (const service of configuredServices) {
-      if (options.target === "prod" && service.sourceMode === "image" && !service.imageRef) {
-        issues.push(`${service.serviceName}: production Railway service is configured for image deployment but no immutable image ref is resolved.`);
-      }
-      const project = service.projectId ? findByName(projects, service.projectId) : findByName(projects, service.projectName);
-      if (!project?.id) {
-        issues.push(`${service.serviceName}: Railway project ${service.projectName} was not found.`);
-        continue;
-      }
-      const environments = await environmentsFor(project.id);
-      const environment = findByName(environments, service.railwayEnvironment);
-      if (!environment?.id) {
-        issues.push(`${service.serviceName}: Railway environment ${service.railwayEnvironment} was not found.`);
-        continue;
-      }
-      const volumeScope = `${project.id}:${environment.id}`;
-      if (!inspectedVolumeScopes.has(volumeScope)) {
-        inspectedVolumeScopes.add(volumeScope);
-        const volumes2 = await volumesFor(project.id);
-        for (const volume of volumes2) {
-          if (isRetainedDetachedRailwayVolume(volume.name)) {
-            continue;
-          }
-          if (String(volume.name ?? "").endsWith("-postgres-volume") && activeRailwayVolumeInstances(volume).length === 0) {
-            issues.push(`${volume.name ?? volume.id}: detached PostgreSQL volume remains in Railway project ${project.name} (states=${railwayVolumeInstanceStates(volume)}).`);
-          }
-          const detachedPostgresInstances = activeRailwayVolumeInstances(volume).filter(
-            (instance2) => instance2.environmentId === environment.id && instance2.mountPath === "/var/lib/postgresql/data" && !instance2.serviceId
-          );
-          if (detachedPostgresInstances.length > 0) {
-            issues.push(`${volume.name ?? volume.id}: detached PostgreSQL volume remains in Railway project ${project.name} (states=${railwayVolumeInstanceStates(volume)}).`);
-          }
-        }
-      }
-      const services = await servicesFor(project.id);
-      const runnerScope = `${project.id}:${environment.id}`;
-      if (service.key === "operationsRunner" && !inspectedRunnerScopes.has(runnerScope)) {
-        inspectedRunnerScopes.add(runnerScope);
-        const desiredRunnerNames = /* @__PURE__ */ new Set([
-          ...configuredServices.filter((entry) => entry.key === "operationsRunner").filter((entry) => entry.projectId ? entry.projectId === project.id : entry.projectName === project.name).filter((entry) => normalizeRailwayEnvironmentName(entry.railwayEnvironment) === normalizeRailwayEnvironmentName(environment.name)).map((entry) => entry.serviceName).filter(Boolean),
-          ...configuredSiblingServices.filter((entry) => entry.projectId ? entry.projectId === project.id : entry.projectName === project.name).map((entry) => entry.serviceName).filter((name) => Boolean(name) && isTreeseedOperationsRunnerResourceName(name)),
-          ...retainedObsoleteAliases.filter((name) => isTreeseedOperationsRunnerResourceName(name) && !name.endsWith("-volume"))
-        ]);
-        const desiredRunnerServiceIds = new Set(services.filter((entry) => desiredRunnerNames.has(entry.name)).map((entry) => entry.id));
-        for (const staleService of findStaleTreeseedOperationsRunnerResources(services, desiredRunnerNames)) {
-          issues.push(`${staleService.name}: stale operations runner Railway service remains in project ${project.name}.`);
-        }
-        const volumes2 = await volumesFor(project.id);
-        const desiredRunnerVolumeNames = /* @__PURE__ */ new Set([
-          ...[...desiredRunnerNames].map((name) => `${name}-volume`),
-          ...retainedObsoleteAliases.filter((name) => name.endsWith("-volume"))
-        ]);
-        for (const staleVolume of findStaleTreeseedOperationsRunnerResources(volumes2, desiredRunnerVolumeNames)) {
-          const activeInstances = activeRailwayVolumeInstances(staleVolume);
-          const relevant = staleVolume.instances.length === 0 || activeInstances.length > 0;
-          const attachedToDesiredRunner = activeInstances.some((instance2) => desiredRunnerServiceIds.has(instance2.serviceId ?? ""));
-          if (relevant && !attachedToDesiredRunner) {
-            issues.push(`${staleVolume.name ?? staleVolume.id}: stale operations runner Railway volume remains in project ${project.name} (states=${railwayVolumeInstanceStates(staleVolume)}).`);
-          }
-        }
-      }
-      const railwayService = service.serviceId ? findByName(services, service.serviceId) : findByName(services, service.serviceName);
-      if (!railwayService?.id) {
-        issues.push(`${service.serviceName}: Railway service was not found.`);
-        continue;
-      }
-      const [instance, variables, volumes] = await Promise.all([
-        getRailwayServiceInstance({ serviceId: railwayService.id, environmentId: environment.id, env: options.env, fetchImpl: options.fetchImpl }),
-        listRailwayVariables({ projectId: project.id, environmentId: environment.id, serviceId: railwayService.id, env: options.env, fetchImpl: options.fetchImpl }).catch(() => ({})),
-        volumesFor(project.id)
-      ]);
-      const mountedVolume = Array.isArray(volumes) ? volumes.find((entry) => {
-        const instances = Array.isArray(entry.instances) ? entry.instances : Array.isArray(entry.volumeInstances) ? entry.volumeInstances : [];
-        return instances.some(
-          (instance2) => instance2?.serviceId === railwayService.id && instance2?.environmentId === environment.id && (!service.volumeMountPath || instance2?.mountPath === service.volumeMountPath) && isActiveRailwayVolumeInstance(instance2)
-        );
-      }) ?? null : null;
-      const volumeInstance = mountedVolume ? (Array.isArray(mountedVolume.instances) ? mountedVolume.instances : Array.isArray(mountedVolume.volumeInstances) ? mountedVolume.volumeInstances : []).find(
-        (instance2) => instance2?.serviceId === railwayService.id && instance2?.environmentId === environment.id && (!service.volumeMountPath || instance2?.mountPath === service.volumeMountPath) && isActiveRailwayVolumeInstance(instance2)
-      ) ?? null : null;
-      const variableKeys = Object.keys(variables ?? {});
-      const deployment = await inspectRailwayServiceDeploymentHealthWithRetry({
-        serviceId: railwayService.id,
-        environmentId: environment.id,
-        serviceName: service.serviceName,
-        acceptSleeping: service.runtimeMode === "serverless",
-        options
-      }).catch((error) => ({
-        ok: false,
-        status: null,
-        message: error instanceof Error ? error.message : String(error ?? "Unable to inspect Railway deployment health.")
-      }));
-      if (!deployment.ok) {
-        issues.push(`${service.serviceName}: latest Railway deployment is not healthy. ${deployment.message}`);
-      }
-      if (service.volumeMountPath && !volumeInstance) {
-        issues.push(`${service.serviceName}: Railway volume is not mounted at ${service.volumeMountPath}.`);
-      }
-      observed[service.serviceName] = {
-        projectName: project.name,
-        environmentName: environment.name,
-        serviceName: railwayService.name,
-        serviceId: railwayService.id,
-        rootDirectory: instance.rootDirectory,
-        buildCommand: instance.buildCommand,
-        dockerfilePath: instance.dockerfilePath,
-        startCommand: instance.startCommand,
-        healthcheckPath: instance.healthcheckPath,
-        healthcheckTimeoutSeconds: instance.healthcheckTimeoutSeconds,
-        runtimeMode: service.runtimeMode ?? instance.runtimeMode,
-        deploymentStatus: deployment.status,
-        deploymentHealthy: deployment.ok,
-        deploymentBranch: deployment.branch ?? null,
-        deploymentRepo: deployment.repo ?? null,
-        deploymentRootDirectory: deployment.rootDirectory ?? null,
-        deploymentCommitHash: deployment.commitHash ?? null,
-        deploymentRequiredMountPath: deployment.requiredMountPath ?? null,
-        deploymentVolumeMounts: deployment.volumeMounts ?? [],
-        volumeName: mountedVolume?.name ?? null,
-        volumeId: mountedVolume?.id ?? null,
-        volumeMountPath: volumeInstance?.mountPath ?? null,
-        volumeServiceId: volumeInstance?.serviceId ?? null,
-        volumeEnvironmentId: volumeInstance?.environmentId ?? null,
-        volumeState: volumeInstance?.state ?? null,
-        volumePendingDeletion: volumeInstance?.isPendingDeletion ?? null,
-        volumeDeletedAt: volumeInstance?.deletedAt ?? null,
-        variables: variableKeys,
-        secrets: variableKeys,
-        health: "unknown"
-      };
-    }
-    if (selectedServiceKeys.size === 0) {
-      const deployConfig = loadTreeseedPlatformConfig({ tenantRoot: options.tenantRoot, environment: options.target, env: options.env }).deployConfig;
-      const appConfigs = [
-        ...!options.appId || options.appId === "web" ? [deployConfig] : [],
-        ...discoverTreeseedApplications(options.tenantRoot).filter((application) => application.id === "api" && (!options.appId || options.appId === "api")).map((application) => application.config)
-      ];
-      for (const config of appConfigs) {
-        const nodePool = config.publicTreeDxFederation?.railway?.nodePool;
-        if (!nodePool && config.hosting?.kind !== "treeseed_control_plane") continue;
-        const bootstrapCount = Math.max(1, Number.parseInt(String(nodePool?.bootstrapCount ?? 1), 10) || 1);
-        const projectName = config.slug ?? "treeseed-api";
-        const environmentName = normalizeRailwayEnvironmentName(options.target) || options.target;
-        const project = findByName(projects, projectName);
-        if (!project?.id) {
-          issues.push(`public-treedx: Railway project ${projectName} was not found.`);
-          continue;
-        }
-        const environments = await environmentsFor(project.id);
-        const environment = findByName(environments, environmentName);
-        if (!environment?.id) {
-          issues.push(`public-treedx: Railway environment ${environmentName} was not found.`);
-          continue;
-        }
-        const [services, volumes] = await Promise.all([
-          servicesFor(project.id),
-          volumesFor(project.id)
-        ]);
-        for (let index = 1; index <= bootstrapCount; index += 1) {
-          const logicalServiceName = indexedName("public-treedx-node", index);
-          const serviceName = railwayTreeDxServiceName(index, options.target);
-          const volumeName = `${serviceName}-volume`;
-          const configuredNode = Array.isArray(config.services) ? config.services.find((service2) => service2?.id === logicalServiceName || service2?.name === logicalServiceName) : null;
-          const volumeMountPath = typeof configuredNode?.volumeMountPath === "string" && configuredNode.volumeMountPath.trim() ? configuredNode.volumeMountPath.trim() : "/data";
-          const service = findByName(services, serviceName);
-          if (!service?.id) {
-            issues.push(`${serviceName}: public TreeDX Railway service was not found.`);
-            continue;
-          }
-          const deployment = await inspectRailwayServiceDeploymentHealthWithRetry({
-            serviceId: service.id,
-            environmentId: environment.id,
-            serviceName,
-            options
-          }).catch((error) => ({
-            ok: false,
-            status: null,
-            message: error instanceof Error ? error.message : String(error ?? "Unable to inspect TreeDX deployment health.")
-          }));
-          if (!deployment.ok) {
-            issues.push(`${serviceName}: public TreeDX latest deployment is not healthy. ${deployment.message}`);
-          }
-          const variables = await listRailwayVariables({ projectId: project.id, environmentId: environment.id, serviceId: service.id, env: options.env, fetchImpl: options.fetchImpl }).catch(() => ({}));
-          if (variables.TREEDX_FEDERATION_MODE !== "connected_library") {
-            issues.push(`${serviceName}: TREEDX_FEDERATION_MODE is not connected_library.`);
-          }
-          const mountedVolume = volumes.find((volume) => volume.name === volumeName && volume.instances.some(
-            (instance) => instance.serviceId === service.id && instance.environmentId === environment.id && instance.mountPath === volumeMountPath && isActiveRailwayVolumeInstance(instance)
-          ));
-          if (!mountedVolume) {
-            issues.push(`${serviceName}: public TreeDX volume ${volumeName} is not mounted at ${volumeMountPath}.`);
-          }
-        }
-      }
-    }
-    return { observed, status: "observed", issues };
-  } catch (error) {
-    return {
-      observed,
-      status: "failed",
-      issues: [...issues, liveCheckErrorMessage(error, "Railway live observation failed without provider details.")].filter((issue) => issue.trim())
-    };
-  }
-}
-async function collectHttpObservations(options) {
-  const deployConfig = loadTreeseedPlatformConfig({ tenantRoot: options.tenantRoot, environment: options.target, env: options.env }).deployConfig;
-  const urls = /* @__PURE__ */ new Set();
-  const fallbacks = /* @__PURE__ */ new Map();
-  const selectedServiceKeys = selectedServiceKeySet(options);
-  const applications = discoverTreeseedApplications(options.tenantRoot);
-  const selectedApplication = options.appId ? applications.find((application) => application.id === options.appId || application.relativeRoot === options.appId) : null;
-  const webHttpSelected = selectedServiceKeys.size === 0 || selectedServiceKeys.has("web");
-  if (webHttpSelected && (!options.appId || options.appId === "web" || selectedApplication?.roles.includes("web"))) {
-    const webConfig = selectedWebConfig(deployConfig, selectedApplication);
-    const webDomain = webConfig.surfaces?.web?.environments?.[options.target]?.domain ?? webConfig.surfaces?.web?.publicBaseUrl ?? webConfig.siteUrl;
-    const webUrl = urlForDomain(webDomain);
-    if (webUrl) {
-      urls.add(webUrl);
-      if (selectedServiceKeys.size === 0 && (!options.appId || options.appId === "web" || selectedApplication?.roles.includes("api"))) {
-        urls.add(`${webUrl}/v1/healthz`);
-      }
-      const pagesProjectName = webConfig.cloudflare?.pages?.projectName;
-      if (pagesProjectName) {
-        const branchName = pagesBranchName(webConfig, options.target);
-        const pagesUrl = options.target === "prod" ? `https://${pagesProjectName}.pages.dev` : `https://${branchName}.${pagesProjectName}.pages.dev`;
-        fallbacks.set(webUrl, pagesUrl);
-      }
-    }
-  }
-  for (const service of configuredRailwayServices(options.tenantRoot, options.target, options.env).filter((entry) => serviceMatchesAppSelection(entry, options.tenantRoot, options.appId, applications)).filter((entry) => serviceIsSelected(selectedServiceKeys, entry.key))) {
-    const serviceConfig = deployConfig.services?.[service.key];
-    const domain = service.publicBaseUrl ?? serviceConfig?.environments?.[options.target]?.baseUrl ?? serviceConfig?.environments?.[options.target]?.domain ?? (service.key === "api" ? deployConfig.surfaces?.api?.environments?.[options.target]?.domain : null);
-    const baseUrl = urlForDomain(domain);
-    if (!baseUrl) continue;
-    urls.add(`${baseUrl}${service.healthcheckPath ?? "/healthz"}`);
-    if (service.key === "api") urls.add(`${baseUrl}/healthz/deep`);
-  }
-  const entries = await Promise.all([...urls].map(async (url) => {
-    const observed = await observeHttp(url, options);
-    const fallbackUrl = fallbacks.get(url);
-    if (observed.ok !== true && !observed.status && fallbackUrl) {
-      const fallback = await observeHttp(fallbackUrl, options);
-      return [url, {
-        ...observed,
-        fallbackUrl,
-        fallbackStatus: fallback.status,
-        fallbackOk: fallback.ok,
-        fallbackError: fallback.error
-      }];
-    }
-    return [url, observed];
-  }));
-  return Object.fromEntries(entries);
-}
-function strictenReport(report, options) {
-  if (!options.strict) return report;
-  const checks = report.checks.map((check) => {
-    if (check.status !== "skipped") return check;
-    const providerRequired = options.requireLiveRailway && check.provider === "railway" || options.requireLiveHttp && check.provider === "http";
-    if (!providerRequired) return check;
-    return {
-      ...check,
-      status: "failed",
-      issues: check.issues.length > 0 ? check.issues : ["Required live observation was not available."],
-      remediation: check.remediation ?? "Run provider configuration bootstrap or verify provider credentials, then rerun with --live."
-    };
-  });
-  const summary = {
-    passed: checks.filter((entry) => entry.status === "passed").length,
-    failed: checks.filter((entry) => entry.status === "failed").length,
-    skipped: checks.filter((entry) => entry.status === "skipped").length,
-    warning: checks.filter((entry) => entry.status === "warning").length
-  };
-  return { ...report, checks, summary };
-}
-async function collectTreeseedLiveHostedServiceChecks(options) {
-  const effectiveOptions = {
-    ...options,
-    env: resolveLiveProviderEnv(options)
-  };
-  const requireLiveRailway = options.requireLiveRailway ?? options.strict === true;
-  const requireLiveHttp = options.requireLiveHttp ?? options.strict === true;
-  const railway = requireLiveRailway ? await collectRailwayObservations(effectiveOptions) : { observed: {}, status: "skipped", issues: [] };
-  const httpChecks = requireLiveHttp ? await collectHttpObservations(effectiveOptions) : {};
-  const report = collectTreeseedHostedServiceChecks({
-    tenantRoot: effectiveOptions.tenantRoot,
-    target: effectiveOptions.target,
-    appId: effectiveOptions.appId,
-    serviceKeys: effectiveOptions.serviceKeys,
-    env: effectiveOptions.env,
-    observedRailwayServices: railway.observed,
-    httpChecks
-  });
-  const railwayIssues = railway.issues.map((issue) => issue.trim()).filter(Boolean);
-  const providerIssueChecks = railwayIssues.map((issue, index) => ({
-    id: `railway:live-issue:${index + 1}`,
-    provider: "railway",
-    serviceType: "unknown",
-    target: options.target,
-    description: "Railway live provider verification issue.",
-    expected: { ok: true },
-    observed: { issue },
-    status: "failed",
-    issues: [issue]
-  }));
-  const reportWithLiveIssues = providerIssueChecks.length > 0 ? {
-    ...report,
-    checks: [...report.checks, ...providerIssueChecks],
-    summary: {
-      passed: report.checks.filter((entry) => entry.status === "passed").length,
-      failed: report.checks.filter((entry) => entry.status === "failed").length + providerIssueChecks.length,
-      skipped: report.checks.filter((entry) => entry.status === "skipped").length,
-      warning: report.checks.filter((entry) => entry.status === "warning").length
-    }
-  } : report;
-  const httpStatus = requireLiveHttp ? Object.values(httpChecks).some((entry) => entry.ok === true || entry.status) ? "observed" : "failed" : "skipped";
-  return strictenReport({
-    ...reportWithLiveIssues,
-    live: true,
-    liveObservation: {
-      railway: railway.status,
-      http: httpStatus,
-      issues: railwayIssues
-    }
-  }, options);
-}
-export {
-  collectTreeseedLiveHostedServiceChecks
-};

package/dist/operations/services/local-cleanup.d.ts

@@ -1,30 +0,0 @@
-export type TreeseedLocalCleanupMode = 'standard' | 'aggressive';
-export type TreeseedLocalCleanupAction = {
-    id: string;
-    kind: 'directory' | 'docker' | 'npm-cache';
-    path?: string;
-    command?: string[];
-    status: 'removed' | 'skipped' | 'failed';
-    beforeBytes?: number;
-    afterBytes?: number;
-    exitCode?: number | null;
-    error?: string;
-};
-export type TreeseedLocalCleanupReport = {
-    ok: boolean;
-    mode: TreeseedLocalCleanupMode;
-    root: string;
-    startedAt: string;
-    completedAt: string;
-    beforeBytes: number;
-    afterBytes: number;
-    reclaimedBytes: number;
-    actions: TreeseedLocalCleanupAction[];
-};
-export declare function runTreeseedLocalCleanup(input: {
-    root: string;
-    mode?: TreeseedLocalCleanupMode;
-    docker?: boolean;
-    npmCache?: boolean;
-    npmCacheRoot?: string;
-}): TreeseedLocalCleanupReport;