@treeseed/sdk 0.10.24 → 0.10.25

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

@@ -87,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) {
@@ -1967,6 +1991,7 @@ async function deployRailwayService(tenantRoot, service, {
   prefix,
   env = process.env
 } = {}) {
+  const timings = [];
   if (dryRun) {
     const plan2 = planRailwayServiceDeploy(service, { env });
     return {
@@ -1974,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 });
@@ -1990,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,
@@ -2002,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);
@@ -2017,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.`);
     }
@@ -2035,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,
@@ -2047,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;