@treeseed/sdk 0.11.0 → 0.12.5

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

@@ -1,4 +1,5 @@
-import { loadCliDeployConfig } from "./runtime-tools.js";
+import { loadTreeseedPlatformConfig } from "../../platform/config.js";
+import { resolveTreeseedLaunchEnvironment } from "./config-runtime.js";
 import {
   getRailwayServiceInstance,
   inspectRailwayServiceDeploymentHealth,
@@ -15,9 +16,17 @@ 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;
 }
@@ -36,8 +45,8 @@ function pagesBranchName(config, target) {
   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 ?? 3));
-  const intervalMs = Math.max(0, Math.floor(options.retry?.intervalMs ?? 1500));
+  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) {
@@ -60,8 +69,8 @@ async function observeHttp(url, options) {
   return { ok: false, error: lastError || "HTTP request failed." };
 }
 async function inspectRailwayServiceDeploymentHealthWithRetry(input) {
-  const attempts = Math.max(1, Math.floor(input.options.retry?.attempts ?? 3));
-  const intervalMs = Math.max(0, Math.floor(input.options.retry?.intervalMs ?? 1500));
+  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) {
@@ -92,26 +101,57 @@ function findByName(items, nameOrId) {
 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((instance) => {
-    const state = String(instance.state ?? "READY").toUpperCase();
-    return state !== "DELETING" && state !== "DELETED";
-  });
+  return instances.filter(isActiveRailwayVolumeInstance);
 }
 function railwayVolumeInstanceStates(volume) {
-  const states = (Array.isArray(volume.instances) ? volume.instances : []).map((instance) => String(instance.state ?? "READY").trim().toUpperCase()).filter(Boolean);
+  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);
+    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) {
@@ -128,12 +168,15 @@ async function collectRailwayObservations(options) {
       if (!inspectedVolumeScopes.has(volumeScope)) {
         inspectedVolumeScopes.add(volumeScope);
         const volumes2 = await listRailwayVolumes({ projectId: project.id, env: options.env, fetchImpl: options.fetchImpl }).catch(() => []);
-        for (const volume2 of volumes2) {
-          const detachedPostgresInstances = activeRailwayVolumeInstances(volume2).filter(
+        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(`${volume2.name ?? volume2.id}: detached PostgreSQL volume remains in Railway project ${project.name} (states=${railwayVolumeInstanceStates(volume2)}).`);
+            issues.push(`${volume.name ?? volume.id}: detached PostgreSQL volume remains in Railway project ${project.name} (states=${railwayVolumeInstanceStates(volume)}).`);
           }
         }
       }
@@ -167,81 +210,123 @@ async function collectRailwayObservations(options) {
         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 volume = Array.isArray(volumes) ? volumes.flatMap((entry) => Array.isArray(entry.instances) ? entry.instances : Array.isArray(entry.volumeInstances) ? entry.volumeInstances : []).find((entry) => entry?.serviceId === railwayService.id && entry?.environmentId === environment.id) : null;
+      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,
-        volumeMountPath: volume?.mountPath ?? null,
+        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"
       };
     }
-    const deployConfig = loadCliDeployConfig(options.tenantRoot);
-    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.`);
+    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 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 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 mountedVolume = volumes.find((volume) => volume.name === volumeName && volume.instances.some(
-          (instance) => instance.serviceId === service.id && instance.environmentId === environment.id && instance.mountPath === volumeMountPath
-        ));
-        if (!mountedVolume) {
-          issues.push(`${serviceName}: public TreeDX volume ${volumeName} is not mounted at ${volumeMountPath}.`);
+        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}.`);
+          }
         }
       }
     }
@@ -250,14 +335,15 @@ async function collectRailwayObservations(options) {
     return {
       observed,
       status: "failed",
-      issues: [...issues, error instanceof Error ? error.message : String(error)]
+      issues: [...issues, liveCheckErrorMessage(error, "Railway live observation failed without provider details.")].filter((issue) => issue.trim())
     };
   }
 }
 async function collectHttpObservations(options) {
-  const deployConfig = loadCliDeployConfig(options.tenantRoot);
+  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);
@@ -276,7 +362,7 @@ async function collectHttpObservations(options) {
       }
     }
   }
-  for (const service of configuredRailwayServices(options.tenantRoot, options.target).filter((entry) => !options.appId || entry.application?.id === options.appId)) {
+  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);
@@ -323,25 +409,52 @@ function strictenReport(report, options) {
   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(options) : { observed: {}, status: "skipped", issues: [] };
-  const httpChecks = requireLiveHttp ? await collectHttpObservations(options) : {};
+  const railway = requireLiveRailway ? await collectRailwayObservations(effectiveOptions) : { observed: {}, status: "skipped", issues: [] };
+  const httpChecks = requireLiveHttp ? await collectHttpObservations(effectiveOptions) : {};
   const report = collectTreeseedHostedServiceChecks({
-    tenantRoot: options.tenantRoot,
-    target: options.target,
-    appId: options.appId,
+    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({
-    ...report,
+    ...reportWithLiveIssues,
     live: true,
     liveObservation: {
       railway: railway.status,
       http: httpStatus,
-      issues: railway.issues
+      issues: railwayIssues
     }
   }, options);
 }

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-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[];

package/dist/operations/services/managed-repositories.js

@@ -0,0 +1,177 @@
+import { existsSync, readFileSync } from "node:fs";
+import { basename, relative, resolve } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { currentBranch, gitStatusPorcelain, originRemoteUrl, repoRoot } from "./workspace-save.js";
+import { hasCompleteTreeseedPackageCheckout, sortWorkspacePackages, workspacePackages } from "./workspace-tools.js";
+import { discoverTreeseedPackageAdapters } from "./package-adapters.js";
+function readJsonFile(filePath) {
+  try {
+    return JSON.parse(readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function readStructuredFile(filePath) {
+  try {
+    const source = readFileSync(filePath, "utf8");
+    return filePath.endsWith(".yaml") || filePath.endsWith(".yml") ? parseYaml(source) : JSON.parse(source);
+  } catch {
+    return null;
+  }
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function parseGitmodulesPaths(root) {
+  const gitmodulesPath = resolve(root, ".gitmodules");
+  if (!existsSync(gitmodulesPath)) return [];
+  const source = readFileSync(gitmodulesPath, "utf8");
+  return [...source.matchAll(/^\s*path\s*=\s*(.+?)\s*$/gmu)].map((match) => match[1].replaceAll("\\", "/").trim()).filter(Boolean);
+}
+function isIndependentGitRepo(repoDir) {
+  try {
+    return resolve(repoRoot(repoDir)) === resolve(repoDir);
+  } catch {
+    return false;
+  }
+}
+function branchName(repoDir) {
+  return currentBranch(repoDir) || null;
+}
+function hasOriginRemote(repoDir) {
+  try {
+    originRemoteUrl(repoDir);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function remoteUrl(repoDir) {
+  try {
+    return originRemoteUrl(repoDir);
+  } catch {
+    return null;
+  }
+}
+function templateManifestPath(repoDir) {
+  for (const name of ["treeseed.template.yaml", "treeseed.template.yml", "treeseed.template.json"]) {
+    const candidate = resolve(repoDir, name);
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function defaultTemplateConfigPath(repoDir) {
+  const candidate = resolve(repoDir, "template.config.json");
+  return existsSync(candidate) ? candidate : null;
+}
+function templateVersion(repoDir, manifest, config) {
+  const versionSource = stringValue(manifest?.versionSource) ?? "template.config.json";
+  const configured = stringValue(manifest?.version) ?? stringValue(config?.templateVersion);
+  if (configured) return { version: configured, versionSource };
+  const sourcePath = resolve(repoDir, versionSource);
+  const source = readJsonFile(sourcePath);
+  return {
+    version: stringValue(source?.templateVersion) ?? stringValue(source?.version),
+    versionSource
+  };
+}
+function readTreeseedTemplateRepositoryManifest(repoDir) {
+  const manifestPath = templateManifestPath(repoDir);
+  const configPath = defaultTemplateConfigPath(repoDir);
+  const manifest = manifestPath ? readStructuredFile(manifestPath) : null;
+  const config = configPath ? readStructuredFile(configPath) : null;
+  if (!manifest && !config) return null;
+  const id = stringValue(manifest?.id) ?? stringValue(config?.id) ?? basename(repoDir);
+  const release = manifest?.release && typeof manifest.release === "object" && !Array.isArray(manifest.release) ? manifest.release : {};
+  const verify = manifest?.verify && typeof manifest.verify === "object" && !Array.isArray(manifest.verify) ? manifest.verify : {};
+  const version = templateVersion(repoDir, manifest, config);
+  return {
+    id,
+    name: stringValue(manifest?.name) ?? stringValue(config?.displayName) ?? id,
+    category: stringValue(manifest?.category) ?? stringValue(config?.category) ?? "starter",
+    repository: stringValue(manifest?.repository) ?? remoteUrl(repoDir),
+    version: version.version,
+    versionSource: version.versionSource,
+    manifestPath: manifestPath ?? configPath,
+    verify: {
+      fast: stringValue(verify.fast),
+      local: stringValue(verify.local) ?? stringValue(config?.testing?.buildCommand),
+      release: stringValue(verify.release) ?? stringValue(verify.local) ?? stringValue(config?.testing?.buildCommand)
+    },
+    release: {
+      tagPrefix: stringValue(release.tagPrefix) ?? "template/",
+      recordPath: stringValue(release.recordPath) ?? `.treeseed/templates/${id}/latest-release.json`
+    }
+  };
+}
+function classifyManagedRepo(root, relativeDir, repoDir) {
+  if (relativeDir === ".") return "root";
+  if (/^starters\/[^/]+$/u.test(relativeDir) || readTreeseedTemplateRepositoryManifest(repoDir)) return "template";
+  if (/(^|\/)\.fixtures\/treeseed-fixtures$/u.test(relativeDir)) return "fixture";
+  if (/^packages\/[^/]+$/u.test(relativeDir)) return "package";
+  return "project";
+}
+function addRecursiveSubmodules(root, relativeDir, repoDir, repos) {
+  for (const submodulePath of parseGitmodulesPaths(repoDir)) {
+    const childDir = resolve(repoDir, submodulePath);
+    const childRelativeDir = relative(root, childDir).replaceAll("\\", "/") || ".";
+    if (!existsSync(childDir) || !isIndependentGitRepo(childDir)) continue;
+    if (!repos.has(childRelativeDir)) {
+      repos.set(childRelativeDir, childDir);
+    }
+    addRecursiveSubmodules(root, childRelativeDir, childDir, repos);
+  }
+}
+function discoverTreeseedManagedRepositories(root) {
+  const gitRoot = repoRoot(root);
+  const repos = /* @__PURE__ */ new Map();
+  repos.set(".", gitRoot);
+  if (hasCompleteTreeseedPackageCheckout(root)) {
+    for (const pkg of workspacePackages(root).filter((pkg2) => pkg2.name?.startsWith("@treeseed/"))) {
+      if (existsSync(resolve(pkg.dir, ".git")) && isIndependentGitRepo(pkg.dir)) {
+        repos.set(pkg.relativeDir, pkg.dir);
+      }
+    }
+  }
+  for (const adapter of discoverTreeseedPackageAdapters(root)) {
+    if (existsSync(resolve(adapter.dir, ".git")) && isIndependentGitRepo(adapter.dir)) {
+      repos.set(adapter.relativeDir, adapter.dir);
+    }
+  }
+  addRecursiveSubmodules(root, ".", gitRoot, repos);
+  return [...repos.entries()].map(([relativeDir, dir]) => {
+    const kind = classifyManagedRepo(root, relativeDir, dir);
+    const templateManifest = kind === "template" ? readTreeseedTemplateRepositoryManifest(dir) : null;
+    const name = kind === "root" ? "@treeseed/market" : kind === "template" ? `template:${templateManifest?.id ?? basename(dir)}` : kind === "fixture" ? `fixture:${relativeDir}` : readJsonFile(resolve(dir, "package.json"))?.name ?? basename(dir);
+    const branch = branchName(dir);
+    return {
+      id: relativeDir,
+      name,
+      kind,
+      dir,
+      relativeDir,
+      branchName: branch,
+      dirty: gitStatusPorcelain(dir).length > 0,
+      detached: branch == null,
+      hasOriginRemote: hasOriginRemote(dir),
+      remoteUrl: remoteUrl(dir),
+      templateManifest
+    };
+  }).sort((left, right) => sortWorkspacePackages([
+    { name: left.name, dir: left.dir, relativeDir: left.relativeDir, packageJson: {} },
+    { name: right.name, dir: right.dir, relativeDir: right.relativeDir, packageJson: {} }
+  ])[0]?.name === left.name ? -1 : 1);
+}
+function checkedOutManagedWorkflowRepos(root) {
+  return discoverTreeseedManagedRepositories(root).filter((repo) => repo.kind !== "root");
+}
+function checkedOutTemplateRepositories(root) {
+  return discoverTreeseedManagedRepositories(root).filter((repo) => repo.kind === "template" && repo.templateManifest);
+}
+export {
+  checkedOutManagedWorkflowRepos,
+  checkedOutTemplateRepositories,
+  discoverTreeseedManagedRepositories,
+  parseGitmodulesPaths,
+  readTreeseedTemplateRepositoryManifest
+};

package/dist/operations/services/operations-runner-smoke.d.ts

@@ -1,5 +1,6 @@
+export type TreeseedOperationsRunnerSmokeEnvironment = 'local' | 'staging' | 'prod';
 export interface TreeseedOperationsRunnerSmokeReport {
-    environment: 'staging' | 'prod';
+    environment: TreeseedOperationsRunnerSmokeEnvironment;
     ok: boolean;
     baseUrl: string;
     operationId?: string;
@@ -18,7 +19,7 @@ export interface TreeseedOperationsRunnerSmokeReport {
 }
 export interface TreeseedOperationsRunnerSmokeOptions {
     tenantRoot: string;
-    environment: 'staging' | 'prod';
+    environment: TreeseedOperationsRunnerSmokeEnvironment;
     baseUrl?: string | null;
     serviceId?: string | null;
     serviceSecret?: string | null;