@treeseed/sdk 0.10.28 → 0.12.4

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

@@ -0,0 +1,463 @@
+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 } from "./railway-deploy.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 = 60;
+const DEFAULT_RAILWAY_DEPLOYMENT_SETTLE_INTERVAL_MS = 5e3;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, 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.retry?.attempts ?? DEFAULT_RETRY_ATTEMPTS));
+  const intervalMs = Math.max(0, Math.floor(options.retry?.intervalMs ?? DEFAULT_RETRY_INTERVAL_MS));
+  const timeoutMs = Math.max(1e3, Math.floor(options.timeoutMs ?? 1e4));
+  let lastError = "";
+  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);
+      return { status: response.status, ok: response.ok };
+    } catch (error) {
+      clearTimeout(timeout);
+      lastError = error instanceof Error ? error.message : String(error);
+      if (attempt + 1 < attempts) await sleep(intervalMs);
+    }
+  }
+  return { 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;
+    } catch (error) {
+      lastError = error;
+    }
+    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 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);
+  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).filter((entry) => !options.appId || entry.application?.id === options.appId).filter((entry) => serviceIsSelected(selectedServiceKeys, entry.key));
+    for (const service of configuredServices) {
+      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 listRailwayEnvironments({ projectId: project.id, env: options.env, fetchImpl: options.fetchImpl });
+      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 listRailwayVolumes({ projectId: project.id, env: options.env, fetchImpl: options.fetchImpl }).catch(() => []);
+        for (const volume of volumes2) {
+          if (isRetainedDetachedRailwayVolume(volume.name)) {
+            continue;
+          }
+          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 listRailwayServices({ projectId: project.id, env: options.env, fetchImpl: options.fetchImpl });
+      const runnerScope = `${project.id}:${environment.id}`;
+      if (service.key === "operationsRunner" && !inspectedRunnerScopes.has(runnerScope)) {
+        inspectedRunnerScopes.add(runnerScope);
+        const desiredRunnerNames = 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));
+        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 listRailwayVolumes({ projectId: project.id, env: options.env, fetchImpl: options.fetchImpl }).catch(() => []);
+        const desiredRunnerVolumeNames = new Set([...desiredRunnerNames].map((name) => `${name}-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(() => ({})),
+        listRailwayVolumes({ projectId: project.id, env: options.env, fetchImpl: options.fetchImpl }).catch(() => [])
+      ]);
+      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,
+        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: process.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 listRailwayEnvironments({ projectId: project.id, env: options.env, fetchImpl: options.fetchImpl });
+        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([
+          listRailwayServices({ projectId: project.id, env: options.env, fetchImpl: options.fetchImpl }),
+          listRailwayVolumes({ projectId: project.id, env: options.env, fetchImpl: options.fetchImpl }).catch(() => [])
+        ]);
+        for (let index = 1; index <= bootstrapCount; index += 1) {
+          const serviceName = indexedName("public-treedx-node", index);
+          const volumeName = `${serviceName}-volume`;
+          const configuredNode = Array.isArray(config.services) ? config.services.find((service2) => service2?.id === serviceName || service2?.name === serviceName) : 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,
+            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: process.env }).deployConfig;
+  const urls = /* @__PURE__ */ new Set();
+  const fallbacks = /* @__PURE__ */ new Map();
+  const selectedServiceKeys = selectedServiceKeySet(options);
+  const selectedApplication = options.appId ? discoverTreeseedApplications(options.tenantRoot).find((application) => application.id === options.appId || application.relativeRoot === options.appId) : null;
+  if (!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 (!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).filter((entry) => !options.appId || entry.application?.id === options.appId).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,
+    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-dev.js

@@ -53,7 +53,6 @@ function prepareCloudflareLocalRuntime({ envOverrides = {}, persistTo, outDir }
   };
   runNodeScript("./scripts/patch-starlight-content-path.js");
   runNodeScript("./scripts/aggregate-book.js");
-  runNodeScript("./scripts/ensure-mailpit.js");
   runLocalD1Migration(persistTo);
   const astroArgs = ["astro", "build", "--root", fixtureRoot];
   if (outDir) {

package/dist/operations/services/managed-host-security.d.ts

@@ -1,4 +1,4 @@
-import type { TreeseedDeployConfig } from '../../platform/contracts.ts';
+import type { TreeseedDeployConfig } from '../../platform/contracts.js';
 export declare const MANAGED_HOST_DIRECT_CI_OPT_IN_ENV = "TREESEED_ALLOW_MANAGED_HOST_DIRECT_CI_SECRETS";
 export declare function allowsManagedHostDirectCiSecrets(env?: Record<string, string | undefined>): boolean;
 export declare function isTreeseedManagedHostedProject(deployConfig: Pick<TreeseedDeployConfig, 'hosting' | 'hub' | 'runtime'> | null | undefined): boolean;

package/dist/operations/services/managed-host-security.js

@@ -5,7 +5,7 @@ const SAFE_MANAGED_HOST_CI_VARIABLES = /* @__PURE__ */ new Set([
   "TREESEED_HOSTING_KIND",
   "TREESEED_HOSTING_REGISTRATION",
   "TREESEED_HOSTING_TEAM_ID",
-  "TREESEED_MARKET_API_BASE_URL",
+  "TREESEED_API_BASE_URL",
   "TREESEED_PROJECT_ID"
 ]);
 const SAFE_MANAGED_HOST_CI_SECRETS = /* @__PURE__ */ new Set([

package/dist/operations/services/managed-repositories.d.ts

@@ -0,0 +1,37 @@
+export type TreeseedManagedRepositoryKind = 'root' | 'package' | 'template' | 'fixture' | 'project';
+export type TreeseedTemplateRepositoryManifest = {
+    id: string;
+    name: string;
+    category: string;
+    repository: string | null;
+    version: string | null;
+    versionSource: string;
+    manifestPath: string | null;
+    verify: {
+        fast: string | null;
+        local: string | null;
+        release: string | null;
+    };
+    release: {
+        tagPrefix: string;
+        recordPath: string;
+    };
+};
+export type TreeseedManagedRepository = {
+    id: string;
+    name: string;
+    kind: TreeseedManagedRepositoryKind;
+    dir: string;
+    relativeDir: string;
+    branchName: string | null;
+    dirty: boolean;
+    detached: boolean;
+    hasOriginRemote: boolean;
+    remoteUrl: string | null;
+    templateManifest: TreeseedTemplateRepositoryManifest | null;
+};
+export declare function parseGitmodulesPaths(root: string): string[];
+export declare function readTreeseedTemplateRepositoryManifest(repoDir: string): TreeseedTemplateRepositoryManifest | null;
+export declare function discoverTreeseedManagedRepositories(root: string): TreeseedManagedRepository[];
+export declare function checkedOutManagedWorkflowRepos(root: string): TreeseedManagedRepository[];
+export declare function checkedOutTemplateRepositories(root: string): TreeseedManagedRepository[];