@treeseed/sdk 0.10.23 → 0.10.25

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

@@ -24,6 +24,7 @@ import {
   resolveRailwayWorkspaceContext,
   upsertRailwayVariables
 } from "./railway-api.js";
+import { elapsedMs, formatDurationMs } from "../../timing.js";
 function normalizeScope(scope) {
   return scope === "prod" ? "prod" : scope === "staging" ? "staging" : "local";
 }
@@ -86,6 +87,30 @@ function configuredEnvValue(env, name) {
   const value = env?.[name];
   return typeof value === "string" && value.trim() ? value.trim() : "";
 }
+async function timedRailwayPhase(timings, name, run, metadata) {
+  const startMs = performance.now();
+  try {
+    const result = await Promise.resolve(run());
+    timings.push({
+      name,
+      durationMs: elapsedMs(startMs),
+      status: "success",
+      ...metadata ? { metadata } : {}
+    });
+    return result;
+  } catch (error) {
+    timings.push({
+      name,
+      durationMs: elapsedMs(startMs),
+      status: "failed",
+      metadata: {
+        ...metadata ?? {},
+        error: error instanceof Error ? error.name || "Error" : "Error"
+      }
+    });
+    throw error;
+  }
+}
 function parseRailwayJsonOutput(output) {
   const trimmed = typeof output === "string" ? output.trim() : "";
   if (!trimmed) {
@@ -171,6 +196,26 @@ function collectRailwayDeploymentStatusChecks(statusPayload, scope, services) {
       };
     }
     const deployment = instance.latestDeployment ?? null;
+    if (!deployment) {
+      return {
+        type: "deployment-status",
+        service: service.key,
+        serviceName: service.serviceName,
+        environment: normalizeRailwayEnvironmentName(environment.name),
+        ok: true,
+        skipped: true,
+        status: "no_active_deployment",
+        observed: {
+          status: null,
+          deploymentId: null,
+          deploymentCreatedAt: null,
+          deploymentStopped: null,
+          instanceStatuses: [],
+          volumeMounts: []
+        },
+        message: `Railway service ${service.serviceName} has no active deployment to wait for.`
+      };
+    }
     const status = String(deployment?.status ?? "").trim().toUpperCase();
     const instanceStatuses = Array.isArray(deployment?.instances) ? deployment.instances.map((entry) => String(entry?.status ?? "").trim()).filter(Boolean) : [];
     const ok = railwayStatusDeploymentSettled(status);
@@ -183,6 +228,8 @@ function collectRailwayDeploymentStatusChecks(statusPayload, scope, services) {
       status: status || "missing_deployment",
       observed: {
         status: status || null,
+        deploymentId: deployment?.id ?? null,
+        deploymentCreatedAt: deployment?.createdAt ?? null,
         deploymentStopped: deployment?.deploymentStopped ?? null,
         instanceStatuses,
         volumeMounts: Array.isArray(deployment?.meta?.volumeMounts) ? deployment.meta.volumeMounts : []
@@ -474,8 +521,10 @@ async function waitForRailwayManagedDeploymentsSettled(tenantRoot, scope, {
   env = process.env,
   timeoutMs = 6e5,
   pollMs = 15e3,
+  fetchImpl = fetch,
   onProgress
 } = {}) {
+  const startMs = performance.now();
   const deadline = Date.now() + timeoutMs;
   const projectId = services.find((service) => typeof service.projectId === "string" && service.projectId.trim())?.projectId ?? null;
   if (!projectId) {
@@ -488,6 +537,11 @@ async function waitForRailwayManagedDeploymentsSettled(tenantRoot, scope, {
         environment: resolveRailwayEnvironmentForScope(scope),
         ok: false,
         status: "missing_project",
+        settle: {
+          durationMs: elapsedMs(startMs),
+          pollCount: 0,
+          finalStatus: "missing_project"
+        },
         message: `Railway deployment status for ${service.serviceName} cannot be checked without a project id.`
       }))
     };
@@ -495,12 +549,15 @@ async function waitForRailwayManagedDeploymentsSettled(tenantRoot, scope, {
   let checks = [];
   let lastError = null;
   let lastSummary = "";
+  let pollCount = 0;
   for (; ; ) {
     lastError = null;
+    pollCount += 1;
     try {
       const statusPayload = await fetchRailwayProjectDeploymentStatus({
         projectId,
-        env
+        env,
+        fetchImpl
       });
       checks = collectRailwayDeploymentStatusChecks(statusPayload, scope, services);
     } catch (error) {
@@ -512,28 +569,63 @@ async function waitForRailwayManagedDeploymentsSettled(tenantRoot, scope, {
         environment: resolveRailwayEnvironmentForScope(scope),
         ok: false,
         status: "status_error",
+        settle: {
+          durationMs: elapsedMs(startMs),
+          pollCount,
+          finalStatus: "status_error"
+        },
         message: error instanceof Error ? error.message : String(error)
       }));
     }
     const summary = formatRailwayDeploymentStatusSummary(scope, checks);
-    if (summary !== lastSummary || !checks.every((entry) => entry.ok === true)) {
-      onProgress?.(summary, "stdout");
-      lastSummary = summary;
+    const progress = `${summary} poll=${pollCount} elapsed=${formatDurationMs(elapsedMs(startMs))}`;
+    if (progress !== lastSummary || !checks.every((entry) => entry.ok === true || entry.skipped === true)) {
+      onProgress?.(progress, "stdout");
+      lastSummary = progress;
     }
-    if (checks.every((entry) => entry.ok === true)) {
-      return { ok: true, checks };
+    if (checks.every((entry) => entry.ok === true || entry.skipped === true)) {
+      return {
+        ok: true,
+        checks: checks.map((check) => ({
+          ...check,
+          settle: {
+            durationMs: elapsedMs(startMs),
+            pollCount,
+            finalStatus: check.status,
+            fastSkipped: check.skipped === true
+          }
+        })),
+        settle: {
+          durationMs: elapsedMs(startMs),
+          pollCount,
+          status: checks.every((entry) => entry.skipped === true) ? "skipped" : "settled"
+        }
+      };
     }
     if (Date.now() >= deadline) {
       return {
         ok: false,
-        checks,
+        checks: checks.map((check) => ({
+          ...check,
+          settle: {
+            durationMs: elapsedMs(startMs),
+            pollCount,
+            finalStatus: check.status,
+            timeout: true
+          }
+        })),
+        settle: {
+          durationMs: elapsedMs(startMs),
+          pollCount,
+          status: "timeout"
+        },
         message: lastError instanceof Error ? lastError.message : "Railway deployments did not settle before the monitor timeout."
       };
     }
     await sleep(pollMs);
   }
 }
-async function fetchRailwayProjectDeploymentStatus({ projectId, env = process.env }) {
+async function fetchRailwayProjectDeploymentStatus({ projectId, env = process.env, fetchImpl = fetch }) {
   const payload = await railwayGraphqlRequest({
     query: `
 query TreeseedRailwayDeploymentStatus($projectId: String!) {
@@ -571,7 +663,8 @@ query TreeseedRailwayDeploymentStatus($projectId: String!) {
 }
 `.trim(),
     variables: { projectId },
-    env
+    env,
+    fetchImpl
   });
   return payload.data?.project ?? null;
 }
@@ -1300,6 +1393,7 @@ async function verifyRailwayManagedResources(tenantRoot, scope, {
     const settled = await waitForRailwayManagedDeploymentsSettled(tenantRoot, scope, {
       services: deploymentStatusServices.length > 0 ? deploymentStatusServices : services,
       env: effectiveEnv,
+      fetchImpl,
       timeoutMs: settleTimeoutMs,
       pollMs: settlePollMs,
       onProgress
@@ -1897,6 +1991,7 @@ async function deployRailwayService(tenantRoot, service, {
   prefix,
   env = process.env
 } = {}) {
+  const timings = [];
   if (dryRun) {
     const plan2 = planRailwayServiceDeploy(service, { env });
     return {
@@ -1904,10 +1999,13 @@ async function deployRailwayService(tenantRoot, service, {
       status: "planned",
       command: [plan2.command, ...plan2.args].join(" "),
       cwd: plan2.cwd,
-      publicBaseUrl: service.publicBaseUrl
+      publicBaseUrl: service.publicBaseUrl,
+      timings
     };
   }
-  const deployService = await resolveRailwayDeployProjectContext(service, { env });
+  const deployService = await timedRailwayPhase(timings, "railway:resolve-context", () => resolveRailwayDeployProjectContext(service, { env }), {
+    service: service.key
+  });
   const commandEnv = buildRailwayCommandEnv({ ...process.env, ...env });
   let railwayDeployEnv = buildRailwayDeployCommandEnv(commandEnv);
   const railway = resolveTreeseedToolCommand("railway", { env: commandEnv });
@@ -1920,9 +2018,9 @@ async function deployRailwayService(tenantRoot, service, {
     task: `${deployService.key}-railway-deploy`,
     stage: "deploy"
   };
-  const runtimeConfiguration = await syncRailwayServiceRuntimeConfigurationAfterDeploy(tenantRoot, deployService, {
+  const runtimeConfiguration = await timedRailwayPhase(timings, "railway:sync-runtime-config", () => syncRailwayServiceRuntimeConfigurationAfterDeploy(tenantRoot, deployService, {
     env: commandEnv
-  });
+  }), { service: deployService.key });
   const cliDeployService = {
     ...deployService,
     projectId: runtimeConfiguration?.projectId ?? deployService.projectId,
@@ -1932,14 +2030,19 @@ async function deployRailwayService(tenantRoot, service, {
     serviceName: runtimeConfiguration?.serviceName ?? deployService.serviceName,
     railwayEnvironment: runtimeConfiguration?.environmentName ?? runtimeConfiguration?.environmentId ?? deployService.railwayEnvironment
   };
-  await syncRailwayApiDeviceLoginVariables(cliDeployService, commandEnv, write, taskPrefix);
+  await timedRailwayPhase(timings, "railway:device-login-vars", () => syncRailwayApiDeviceLoginVariables(cliDeployService, commandEnv, write, taskPrefix), {
+    service: cliDeployService.key
+  });
   railwayDeployEnv = buildRailwayCliContextEnv(railwayDeployEnv, cliDeployService);
   const hasCommandApiToken = Boolean(configuredEnvValue(commandEnv, "RAILWAY_API_TOKEN"));
   let usesProjectToken = Boolean(configuredEnvValue(railwayDeployEnv, "RAILWAY_TOKEN"));
   if (usesProjectToken) {
     railwayDeployEnv = { ...railwayDeployEnv, RAILWAY_API_TOKEN: void 0 };
   }
-  if (!usesProjectToken && !hasCommandApiToken) {
+  await timedRailwayPhase(timings, "railway:project-token", async () => {
+    if (usesProjectToken || hasCommandApiToken) {
+      return null;
+    }
     const projectToken = await createRailwayCliProjectToken(cliDeployService, { env: commandEnv });
     if (projectToken) {
       railwayDeployEnv = buildRailwayCliContextEnv({ ...railwayDeployEnv, RAILWAY_API_TOKEN: void 0, RAILWAY_TOKEN: projectToken }, cliDeployService);
@@ -1947,16 +2050,17 @@ async function deployRailwayService(tenantRoot, service, {
     } else if (configuredEnvValue(commandEnv, "CI") === "true") {
       throw new Error(`Railway CI deploy requires a project token for ${cliDeployService.serviceName ?? cliDeployService.key}. Automatic project token creation did not return a token.`);
     }
-  }
+    return null;
+  }, { service: cliDeployService.key });
   const linkPlan = planRailwayServiceLink(cliDeployService, { env: commandEnv });
   const plan = planRailwayServiceDeploy(cliDeployService, { env, projectTokenMode: usesProjectToken });
   if (deployService.buildCommand && shouldRunRailwayPredeployBuild(commandEnv)) {
-    const buildResult = await runPrefixedCommand("bash", ["-lc", deployService.buildCommand], {
+    const buildResult = await timedRailwayPhase(timings, "railway:predeploy-build", () => runPrefixedCommand("bash", ["-lc", deployService.buildCommand], {
       cwd: deployService.rootDir,
       env: commandEnv,
       write,
       prefix: { ...taskPrefix, stage: "build" }
-    });
+    }), { service: deployService.key });
     if (buildResult.status !== 0) {
       throw new Error(`Railway ${deployService.key} build command failed.`);
     }
@@ -1965,9 +2069,11 @@ async function deployRailwayService(tenantRoot, service, {
   const cliConfig = configuredEnvValue(commandEnv, "CI") === "true" ? writeRailwayCliProjectConfig(cliDeployService, { env: railwayDeployEnv, cwd: plan.cwd }) : null;
   const effectiveLinkPlan = hasRailwayApiToken ? linkPlan : usesProjectToken ? planRailwayProjectEnvironmentLink(cliDeployService) : linkPlan;
   const railwayLinkEnv = hasRailwayApiToken ? buildRailwayLinkCommandEnv(commandEnv, cliDeployService) : railwayDeployEnv;
-  if (cliConfig) {
-    write ? write(`[${taskPrefix.scope}][${taskPrefix.system}][${taskPrefix.task}][link] Wrote Railway CLI project context for ${cliConfig.projectPath}.`, "stdout") : null;
-  } else {
+  await timedRailwayPhase(timings, "railway:link", async () => {
+    if (cliConfig) {
+      write ? write(`[${taskPrefix.scope}][${taskPrefix.system}][${taskPrefix.task}][link] Wrote Railway CLI project context for ${cliConfig.projectPath}.`, "stdout") : null;
+      return;
+    }
     const linkResult = await runPrefixedCommand(railway.command, [...railway.argsPrefix, ...effectiveLinkPlan.args], {
       cwd: effectiveLinkPlan.cwd,
       env: railwayLinkEnv,
@@ -1977,37 +2083,40 @@ async function deployRailwayService(tenantRoot, service, {
     if (linkResult.status !== 0) {
       throw new Error(linkResult.stderr?.trim() || linkResult.stdout?.trim() || `railway ${effectiveLinkPlan.args.join(" ")} failed with exit code ${linkResult.status ?? "unknown"} in ${effectiveLinkPlan.cwd}`);
     }
-  }
-  let lastFailure = null;
-  for (let attempt = 1; attempt <= 5; attempt += 1) {
-    const result = await runPrefixedCommand(railway.command, [...railway.argsPrefix, ...plan.args], {
-      cwd: plan.cwd,
-      env: railwayDeployEnv,
-      write,
-      prefix: taskPrefix
-    });
-    if (result.status === 0) {
-      lastFailure = null;
-      break;
+  }, { service: cliDeployService.key });
+  await timedRailwayPhase(timings, "railway:deploy", async () => {
+    let lastFailure = null;
+    for (let attempt = 1; attempt <= 5; attempt += 1) {
+      const result = await runPrefixedCommand(railway.command, [...railway.argsPrefix, ...plan.args], {
+        cwd: plan.cwd,
+        env: railwayDeployEnv,
+        write,
+        prefix: taskPrefix
+      });
+      if (result.status === 0) {
+        lastFailure = null;
+        break;
+      }
+      lastFailure = result;
+      if (!isRailwayTransientFailure(result) || attempt === 5) {
+        throw new Error(result.stderr?.trim() || result.stdout?.trim() || `railway ${plan.args.join(" ")} failed with exit code ${result.status ?? "unknown"} in ${plan.cwd}`);
+      }
+      const backoffMs = 5e3 * attempt;
+      const warning = `Railway deploy for ${deployService.serviceName ?? deployService.serviceId ?? deployService.key} hit a transient failure; retrying in ${Math.round(backoffMs / 1e3)}s...`;
+      write ? write(`[${taskPrefix.scope}][${taskPrefix.system}][${taskPrefix.task}][retry] ${warning}`, "stderr") : console.warn(warning);
+      await sleep(backoffMs);
     }
-    lastFailure = result;
-    if (!isRailwayTransientFailure(result) || attempt === 5) {
-      throw new Error(result.stderr?.trim() || result.stdout?.trim() || `railway ${plan.args.join(" ")} failed with exit code ${result.status ?? "unknown"} in ${plan.cwd}`);
+    if (lastFailure) {
+      throw new Error(lastFailure.stderr?.trim() || lastFailure.stdout?.trim() || `railway ${plan.args.join(" ")} failed`);
     }
-    const backoffMs = 5e3 * attempt;
-    const warning = `Railway deploy for ${deployService.serviceName ?? deployService.serviceId ?? deployService.key} hit a transient failure; retrying in ${Math.round(backoffMs / 1e3)}s...`;
-    write ? write(`[${taskPrefix.scope}][${taskPrefix.system}][${taskPrefix.task}][retry] ${warning}`, "stderr") : console.warn(warning);
-    await sleep(backoffMs);
-  }
-  if (lastFailure) {
-    throw new Error(lastFailure.stderr?.trim() || lastFailure.stdout?.trim() || `railway ${plan.args.join(" ")} failed`);
-  }
+  }, { service: cliDeployService.key });
   return {
     service: deployService.key,
     status: "deployed",
     command: [plan.command, ...plan.args].join(" "),
     cwd: plan.cwd,
     publicBaseUrl: deployService.publicBaseUrl,
+    timings,
     runtimeConfiguration: runtimeConfiguration ? {
       updated: runtimeConfiguration.updated,
       healthcheckPath: runtimeConfiguration.instance?.healthcheckPath ?? null,

package/dist/operations/services/release-candidate.js

@@ -244,7 +244,7 @@ function rehearsalVerifyScript(root) {
 function runNpmRehearsalCommand(args, options) {
   const result = spawnSync("npm", args, {
     cwd: options.cwd,
-    env: process.env,
+    env: options.env ?? process.env,
     stdio: "pipe",
     encoding: "utf8",
     timeout: options.timeoutMs
@@ -320,7 +320,13 @@ function runProductionDependencyRehearsal(root, plannedVersions, selectedPackage
     buildRehearsalWorkspacePackageArtifacts(copied.tempRoot);
     const scriptName = rehearsalVerifyScript(copied.tempRoot);
     if (scriptName) {
-      runNpmRehearsalCommand(["run", scriptName], { cwd: copied.tempRoot, timeoutMs: 9e5 });
+      const packageJson = safePackageJson(resolve(copied.tempRoot, "package.json"));
+      const parallelMarketVerify = packageJson?.name === "@treeseed/market" && (scriptName === "verify:direct" || scriptName === "verify:local" || scriptName === "verify");
+      runNpmRehearsalCommand(["run", scriptName], {
+        cwd: copied.tempRoot,
+        timeoutMs: 9e5,
+        env: parallelMarketVerify ? { ...process.env, TREESEED_VERIFY_PARALLEL: "1" } : process.env
+      });
     }
     const postInstallIssues = collectInternalDevReferenceIssues(copied.tempRoot, selectedPackageSet);
     if (postInstallIssues.length > 0) {

package/dist/operations/services/template-host-bindings.d.ts

@@ -0,0 +1,68 @@
+import { type ProjectEnvironmentName, type TemplateConfigMergeStrategy, type TemplateConfigWriteTarget, type TemplateSecretSensitivity } from '../../sdk-types.ts';
+import type { ProjectLaunchConfigWritePlanItem, ProjectLaunchResolvedHostBinding, ProjectLaunchSecretDeploymentPlanItem } from '../../template-launch-requirements.ts';
+export interface ApplyProjectLaunchHostBindingConfigOptions {
+    projectRoot: string;
+    hostBindings?: Record<string, ProjectLaunchResolvedHostBinding> | null;
+    hostBindingPlans?: {
+        configWrites?: ProjectLaunchConfigWritePlanItem[];
+        secretDeployment?: {
+            items?: ProjectLaunchSecretDeploymentPlanItem[];
+        };
+    } | null;
+    launchInput?: {
+        projectSlug?: string | null;
+        projectName?: string | null;
+        repoName?: string | null;
+        domains?: Record<string, unknown> | null;
+    } | null;
+    derived?: {
+        projectSlug?: string | null;
+        projectName?: string | null;
+        repositoryName?: string | null;
+    } | null;
+}
+export interface ProjectLaunchHostBindingConfigWriteSummary {
+    target: TemplateConfigWriteTarget;
+    path: string;
+    requirementKey: string;
+    requirementKind: string;
+    provider: string;
+    operation: TemplateConfigMergeStrategy;
+    valuePreview: string | number | boolean | null;
+}
+export interface ProjectLaunchHostBindingEnvironmentWriteSummary {
+    env: string;
+    requirementKey: string;
+    requirementKind: string;
+    sourceHostType?: string | null;
+    sourceProvider?: string | null;
+    sensitivity: TemplateSecretSensitivity | string;
+    targets: string[];
+    scopes: ProjectEnvironmentName[];
+}
+export interface ProjectLaunchHostBindingConfigApplyResult {
+    configWrites: ProjectLaunchHostBindingConfigWriteSummary[];
+    environmentWrites: ProjectLaunchHostBindingEnvironmentWriteSummary[];
+    targets: string[];
+}
+export interface ProjectLaunchHostBindingConfigAuditDiagnostic {
+    code: 'missing_config_target' | 'stale_config_target' | 'invalid_config_target';
+    status: 'ok' | 'warning' | 'blocked';
+    target: TemplateConfigWriteTarget;
+    message: string;
+}
+export interface ProjectLaunchHostBindingConfigAuditResult {
+    status: 'ok' | 'warning' | 'blocked';
+    checkedTargets: TemplateConfigWriteTarget[];
+    changedTargets: TemplateConfigWriteTarget[];
+    diagnostics: ProjectLaunchHostBindingConfigAuditDiagnostic[];
+    expected: ProjectLaunchHostBindingConfigApplyResult;
+}
+export declare function applyProjectLaunchHostBindingConfig(options: ApplyProjectLaunchHostBindingConfigOptions): ProjectLaunchHostBindingConfigApplyResult;
+export declare function auditProjectLaunchHostBindingConfig(options: ApplyProjectLaunchHostBindingConfigOptions): ProjectLaunchHostBindingConfigAuditResult;
+export declare function preserveProjectLaunchHostBindingConfigOverlay(options: {
+    target: TemplateConfigWriteTarget;
+    currentContent: string;
+    nextContent: string;
+    hostBindingPlans?: ApplyProjectLaunchHostBindingConfigOptions['hostBindingPlans'];
+}): string;