@treeseed/sdk 0.6.0 → 0.6.2

package/dist/operations/services/project-platform.js

@@ -16,12 +16,14 @@ import { collectTreeseedReconcileStatus, reconcileTreeseedTarget } from "../../r
 import { loadTreeseedManifest } from "../../platform/tenant-config.js";
 import { applyTreeseedEnvironmentToProcess } from "./config-runtime.js";
 import {
+  assertDeploymentInitialized,
   createPersistentDeployTarget,
   deployTargetLabel,
   ensureGeneratedWranglerConfig,
   finalizeDeploymentState,
   loadDeployState,
   purgePublishedContentCaches,
+  resolveConfiguredCloudflareAccountId,
   resolveConfiguredSurfaceBaseUrl,
   writeDeployState
 } from "./deploy.js";
@@ -36,6 +38,8 @@ import {
 } from "./railway-deploy.js";
 import { loadCliDeployConfig, packageScriptPath, resolveWranglerBin } from "./runtime-tools.js";
 import { CloudflareQueuePullClient, CloudflareQueuePushClient } from "../../remote.js";
+import { runPrefixedCommand, runTreeseedBootstrapDag, sleep, writeTreeseedBootstrapLine } from "./bootstrap-runner.js";
+import { runTenantDeployPreflight } from "./save-deploy-preflight.js";
 function stableHash(value) {
   return createHash("sha256").update(value).digest("hex");
 }
@@ -98,6 +102,165 @@ function runWrangler(tenantRoot, args, extraEnv = {}, options = {}) {
   }
   return result;
 }
+function isTransientWranglerOutput(output) {
+  return /fetch failed|timed out|etimedout|econnreset|enetunreach|temporarily unavailable|connectivity issue|internal error|aborted/i.test(output);
+}
+async function runPrefixedWranglerWithRetry(tenantRoot, args, {
+  env = {},
+  write,
+  prefix
+}) {
+  let lastOutput = "";
+  for (let attempt = 1; attempt <= 3; attempt += 1) {
+    const result = await runPrefixedCommand(process.execPath, [resolveWranglerBin(), ...args], {
+      cwd: tenantRoot,
+      env,
+      write,
+      prefix
+    });
+    if (result.status === 0) {
+      return result;
+    }
+    lastOutput = [result.stderr?.trim(), result.stdout?.trim()].filter(Boolean).join("\n");
+    if (attempt === 3 || !isTransientWranglerOutput(lastOutput)) {
+      throw new Error(lastOutput || `wrangler ${args.join(" ")} failed`);
+    }
+    writeTreeseedBootstrapLine(
+      write,
+      { ...prefix, stage: "retry" },
+      `Wrangler command hit a transient failure; retrying in ${2 * attempt}s...`,
+      "stderr"
+    );
+    await sleep(2e3 * attempt);
+  }
+  throw new Error(lastOutput || `wrangler ${args.join(" ")} failed`);
+}
+function prepareTenantCloudflareDeploy({
+  tenantRoot,
+  scope,
+  target: explicitTarget,
+  dryRun,
+  write,
+  env = process.env
+}) {
+  const target = explicitTarget ?? createPersistentDeployTarget(scope === "local" ? "staging" : scope);
+  if (scope !== "local") {
+    assertDeploymentInitialized(tenantRoot, { target });
+    runTenantDeployPreflight({ cwd: tenantRoot, scope });
+  }
+  const { wranglerPath, deployConfig, state } = ensureGeneratedWranglerConfig(tenantRoot, { target });
+  const deployState = loadDeployState(tenantRoot, deployConfig, { target });
+  const pagesProjectName = target.kind === "persistent" ? deployState.pages?.projectName ?? null : null;
+  const pagesBranchName = target.kind === "persistent" ? target.scope === "prod" ? deployState.pages?.productionBranch ?? "main" : deployState.pages?.stagingBranch ?? "staging" : null;
+  return {
+    tenantRoot,
+    scope,
+    target,
+    dryRun,
+    wranglerPath,
+    databaseName: state.d1Databases.SITE_DATA_DB.databaseName,
+    pagesProjectName,
+    pagesBranchName,
+    env: {
+      ...process.env,
+      ...env,
+      CLOUDFLARE_ACCOUNT_ID: resolveConfiguredCloudflareAccountId(deployConfig)
+    },
+    write
+  };
+}
+async function runTenantDataMigration(context) {
+  if (context.dryRun) {
+    writeTreeseedBootstrapLine(context.write, {
+      scope: context.scope,
+      system: "data",
+      task: "d1-migrate",
+      stage: "deploy"
+    }, `Dry run: would apply remote migrations for ${context.databaseName}.`);
+    return { databaseName: context.databaseName, dryRun: true };
+  }
+  await runPrefixedWranglerWithRetry(context.tenantRoot, [
+    "d1",
+    "migrations",
+    "apply",
+    context.databaseName,
+    "--remote",
+    "--config",
+    context.wranglerPath
+  ], {
+    env: context.env,
+    write: context.write,
+    prefix: {
+      scope: context.scope,
+      system: "data",
+      task: "d1-migrate",
+      stage: "deploy"
+    }
+  });
+  return { databaseName: context.databaseName, dryRun: false };
+}
+async function runTenantWebBuild(context) {
+  const prefix = {
+    scope: context.scope,
+    system: "web",
+    task: "build",
+    stage: "deploy"
+  };
+  if (context.dryRun) {
+    writeTreeseedBootstrapLine(context.write, prefix, "Dry run: skipped tenant build.");
+    return { dryRun: true };
+  }
+  const result = await runPrefixedCommand(process.execPath, [packageScriptPath("tenant-build")], {
+    cwd: context.tenantRoot,
+    env: context.env,
+    write: context.write,
+    prefix
+  });
+  if (result.status !== 0) {
+    throw new Error("tenant-build failed.");
+  }
+  return { dryRun: false };
+}
+async function runTenantWebPublish(context) {
+  const prefix = {
+    scope: context.scope,
+    system: "web",
+    task: "publish",
+    stage: "deploy"
+  };
+  if (context.dryRun) {
+    if (context.pagesProjectName) {
+      writeTreeseedBootstrapLine(context.write, prefix, `Dry run: would deploy ${deployTargetLabel(context.target)} to Pages project ${context.pagesProjectName} from ${resolve(context.tenantRoot, "dist")}.`);
+    } else {
+      writeTreeseedBootstrapLine(context.write, prefix, `Dry run: would deploy ${deployTargetLabel(context.target)} with generated Wrangler config at ${resolve(context.wranglerPath)}.`);
+    }
+    return { dryRun: true };
+  }
+  if (context.pagesProjectName) {
+    const args = [
+      "pages",
+      "deploy",
+      resolve(context.tenantRoot, "dist"),
+      "--project-name",
+      context.pagesProjectName
+    ];
+    if (context.pagesBranchName) {
+      args.push("--branch", context.pagesBranchName);
+    }
+    await runPrefixedWranglerWithRetry(context.tenantRoot, args, {
+      env: context.env,
+      write: context.write,
+      prefix
+    });
+  } else {
+    await runPrefixedWranglerWithRetry(context.tenantRoot, ["deploy", "--config", context.wranglerPath], {
+      env: context.env,
+      write: context.write,
+      prefix
+    });
+  }
+  return { dryRun: false };
+}
 function inferContentType(filePath) {
   const extension = extname(filePath).toLowerCase();
   if (extension === ".json") return "application/json";
@@ -806,6 +969,10 @@ async function deployProjectPlatform(options) {
   const reporter = resolveReporter(options.tenantRoot, options.reporter);
   const commitSha = currentCommit(options.tenantRoot);
   const branchName = currentRef(options.tenantRoot);
+  const selectedSystems = new Set(options.bootstrapSystems ?? ["data", "web", "api", "agents"]);
+  const execution = options.bootstrapExecution ?? "parallel";
+  const write = options.write;
+  const env = { ...process.env, ...options.env ?? {} };
   await reportDeployment(reporter, {
     environment: options.scope,
     deploymentKind: "code",
@@ -818,19 +985,120 @@ async function deployProjectPlatform(options) {
   if (!options.skipProvision) {
     await provisionProjectPlatform({ ...options, reporter });
   }
-  runNodeScript(options.tenantRoot, "tenant-deploy", ["--environment", options.scope, ...options.dryRun ? ["--dry-run"] : []]);
-  const serviceResults = [];
-  if (options.scope !== "local") {
-    const validation = validateRailwayDeployPrerequisites(options.tenantRoot, options.scope);
-    for (const service of validation.services) {
-      serviceResults.push(await deployRailwayService(options.tenantRoot, service, { dryRun: options.dryRun }));
+  const nodes = [];
+  let cloudflareContext = null;
+  if (options.scope === "local" && selectedSystems.has("web")) {
+    nodes.push({
+      id: "web:build",
+      run: () => runTenantWebBuild({
+        tenantRoot: options.tenantRoot,
+        scope: "local",
+        dryRun: options.dryRun,
+        env,
+        write
+      })
+    });
+  } else if (selectedSystems.has("data") || selectedSystems.has("web")) {
+    cloudflareContext = prepareTenantCloudflareDeploy({
+      tenantRoot: options.tenantRoot,
+      scope: options.scope,
+      dryRun: options.dryRun,
+      write,
+      env
+    });
+  }
+  if (cloudflareContext && selectedSystems.has("data")) {
+    const context = cloudflareContext;
+    nodes.push({
+      id: "data:d1-migrate",
+      run: () => runTenantDataMigration(context)
+    });
+  }
+  if (cloudflareContext && selectedSystems.has("web")) {
+    const context = cloudflareContext;
+    nodes.push({
+      id: "web:build",
+      run: () => runTenantWebBuild(context)
+    });
+    nodes.push({
+      id: "web:publish",
+      dependencies: ["web:build", ...selectedSystems.has("data") ? ["data:d1-migrate"] : []],
+      run: () => runTenantWebPublish(context)
+    });
+  }
+  const serviceResultsByKey = /* @__PURE__ */ new Map();
+  let selectedRailwayServiceKeys = [];
+  if (options.scope !== "local" && (selectedSystems.has("api") || selectedSystems.has("agents"))) {
+    const validation = validateRailwayDeployPrerequisites(options.tenantRoot, options.scope, { env });
+    const selectedServices = validation.services.filter(
+      (service) => service.key === "api" ? selectedSystems.has("api") : selectedSystems.has("agents")
+    );
+    for (const service of selectedServices) {
+      const system = service.key === "api" ? "api" : "agents";
+      const nodeId = `${system}:${service.key}-railway-deploy`;
+      selectedRailwayServiceKeys.push(service.key);
+      nodes.push({
+        id: nodeId,
+        dependencies: selectedSystems.has("data") ? ["data:d1-migrate"] : [],
+        run: async () => {
+          const result = await deployRailwayService(options.tenantRoot, service, {
+            dryRun: options.dryRun,
+            write,
+            env,
+            prefix: {
+              scope: options.scope,
+              system,
+              task: `${service.key}-railway-deploy`,
+              stage: "deploy"
+            }
+          });
+          serviceResultsByKey.set(service.key, result);
+          return result;
+        }
+      });
     }
-    const railwaySchedules = options.scope === "prod" ? await ensureRailwayScheduledJobs(options.tenantRoot, options.scope, { dryRun: options.dryRun }) : [];
-    const railwayScheduleVerification = options.scope === "prod" && !options.dryRun ? await verifyRailwayScheduledJobs(options.tenantRoot, options.scope) : { ok: true, checks: railwaySchedules, skipped: options.scope !== "prod" ? true : options.dryRun, reason: options.scope !== "prod" ? "prod_only" : "dry_run" };
+  }
+  let railwaySchedules = [];
+  let railwayScheduleVerification = { ok: true, checks: [], skipped: true, reason: !selectedSystems.has("agents") ? "agents_not_selected" : options.scope !== "prod" ? "prod_only" : "dry_run" };
+  if (options.scope === "prod" && selectedSystems.has("agents")) {
+    const agentDeployNodeIds = nodes.filter((node) => node.id.startsWith("agents:") && node.id.endsWith("-railway-deploy")).map((node) => node.id);
+    nodes.push({
+      id: "agents:schedules",
+      dependencies: agentDeployNodeIds,
+      run: async () => {
+        writeTreeseedBootstrapLine(write, {
+          scope: options.scope,
+          system: "agents",
+          task: "schedules",
+          stage: "deploy"
+        }, "Reconciling Railway schedules...");
+        railwaySchedules = await ensureRailwayScheduledJobs(options.tenantRoot, options.scope, { dryRun: options.dryRun, env });
+        railwayScheduleVerification = !options.dryRun ? await verifyRailwayScheduledJobs(options.tenantRoot, options.scope) : { ok: true, checks: railwaySchedules, skipped: true, reason: "dry_run" };
+        return {
+          service: "railway-schedules",
+          status: railwayScheduleVerification.ok ? "verified" : "failed",
+          command: "railway schedules reconcile",
+          cwd: options.tenantRoot,
+          publicBaseUrl: null,
+          schedules: railwaySchedules,
+          scheduleVerification: railwayScheduleVerification
+        };
+      }
+    });
+  }
+  await runTreeseedBootstrapDag({ nodes, execution });
+  const serviceResults = selectedRailwayServiceKeys.map((serviceKey) => serviceResultsByKey.get(serviceKey)).filter(Boolean);
+  if (options.scope !== "local" && !options.dryRun && (selectedSystems.has("web") || serviceResults.length > 0)) {
     finalizeDeploymentState(options.tenantRoot, {
       target: createPersistentDeployTarget(options.scope),
       serviceResults
     });
+  }
+  if (options.scope !== "prod" || !selectedSystems.has("agents")) {
+    railwaySchedules = [];
+    railwayScheduleVerification = { ok: true, checks: railwaySchedules, skipped: true, reason: !selectedSystems.has("agents") ? "agents_not_selected" : options.scope !== "prod" ? "prod_only" : "dry_run" };
+  }
+  if (selectedSystems.has("agents")) {
     serviceResults.push({
       service: "railway-schedules",
       status: railwayScheduleVerification.ok ? "verified" : "failed",
@@ -851,7 +1119,7 @@ async function deployProjectPlatform(options) {
     triggeredByType: "project_runner",
     metadata: {
       scope: options.scope,
-      railway: options.scope === "local" ? [] : configuredRailwayServices(options.tenantRoot, options.scope).map((service) => service.key),
+      railway: options.scope === "local" ? [] : configuredRailwayServices(options.tenantRoot, options.scope).map((service) => service.key).filter((serviceKey) => serviceKey === "api" ? selectedSystems.has("api") : selectedSystems.has("agents")),
       monitor
     },
     finishedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -980,9 +1248,13 @@ export {
   deployProjectPlatform,
   inferEnvironmentFromBranch,
   monitorProjectPlatform,
+  prepareTenantCloudflareDeploy,
   provisionProjectPlatform,
   publishProjectContent,
   resolveScope,
   runProjectPlatformAction,
+  runTenantDataMigration,
+  runTenantWebBuild,
+  runTenantWebPublish,
   syncControlPlaneState
 };

package/dist/operations/services/railway-deploy.d.ts

@@ -1,3 +1,4 @@
+import { type TreeseedBootstrapTaskPrefix, type TreeseedBootstrapWriter } from './bootstrap-runner.ts';
 export declare function isUsableRailwayToken(value: any): boolean;
 export declare function resolveRailwayAuthToken(env?: NodeJS.ProcessEnv): string;
 export declare function buildRailwayCommandEnv(env?: NodeJS.ProcessEnv): {
@@ -269,8 +270,11 @@ export declare function planRailwayServiceDeploy(service: any): {
     args: any[];
     cwd: any;
 };
-export declare function deployRailwayService(tenantRoot: any, service: any, { dryRun }?: {
-    dryRun?: boolean | undefined;
+export declare function deployRailwayService(tenantRoot: any, service: any, { dryRun, write, prefix, env, }?: {
+    dryRun?: boolean;
+    write?: TreeseedBootstrapWriter;
+    prefix?: TreeseedBootstrapTaskPrefix;
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
 }): Promise<{
     service: any;
     status: string;

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

@@ -3,6 +3,7 @@ import { relative, resolve } from "node:path";
 import { spawnSync } from "node:child_process";
 import { loadCliDeployConfig } from "./runtime-tools.js";
 import { createPersistentDeployTarget, resolveTreeseedResourceIdentity } from "./deploy.js";
+import { runPrefixedCommand, sleep } from "./bootstrap-runner.js";
 import {
   ensureRailwayEnvironment,
   ensureRailwayProject,
@@ -900,7 +901,12 @@ async function syncRailwayServiceRuntimeConfigurationAfterDeploy(tenantRoot, ser
     env
   });
 }
-async function deployRailwayService(tenantRoot, service, { dryRun = false } = {}) {
+async function deployRailwayService(tenantRoot, service, {
+  dryRun = false,
+  write,
+  prefix,
+  env = process.env
+} = {}) {
   const plan = planRailwayServiceDeploy(service);
   if (dryRun) {
     return {
@@ -911,11 +917,19 @@ async function deployRailwayService(tenantRoot, service, { dryRun = false } = {}
       publicBaseUrl: service.publicBaseUrl
     };
   }
+  const taskPrefix = prefix ?? {
+    scope: normalizeScope(service.scope ?? service.railwayEnvironment ?? "railway"),
+    system: service.key === "api" ? "api" : "agents",
+    task: `${service.key}-railway-deploy`,
+    stage: "deploy"
+  };
+  const commandEnv = buildRailwayCommandEnv({ ...process.env, ...env });
   if (service.buildCommand) {
-    const buildResult = spawnSync("bash", ["-lc", service.buildCommand], {
+    const buildResult = await runPrefixedCommand("bash", ["-lc", service.buildCommand], {
       cwd: service.rootDir,
-      stdio: "inherit",
-      env: { ...process.env }
+      env: commandEnv,
+      write,
+      prefix: { ...taskPrefix, stage: "build" }
     });
     if (buildResult.status !== 0) {
       throw new Error(`Railway ${service.key} build command failed.`);
@@ -923,17 +937,12 @@ async function deployRailwayService(tenantRoot, service, { dryRun = false } = {}
   }
   let lastFailure = null;
   for (let attempt = 1; attempt <= 5; attempt += 1) {
-    const result = runRailway(plan.args, {
+    const result = await runPrefixedCommand(plan.command, plan.args, {
       cwd: service.rootDir,
-      capture: true,
-      allowFailure: true
+      env: commandEnv,
+      write,
+      prefix: taskPrefix
     });
-    if (result.stdout) {
-      process.stdout.write(result.stdout);
-    }
-    if (result.stderr) {
-      process.stderr.write(result.stderr);
-    }
     if (result.status === 0) {
       lastFailure = null;
       break;
@@ -943,16 +952,15 @@ async function deployRailwayService(tenantRoot, service, { dryRun = false } = {}
       throw new Error(result.stderr?.trim() || result.stdout?.trim() || `railway ${plan.args.join(" ")} failed`);
     }
     const backoffMs = 5e3 * attempt;
-    console.warn(
-      `Railway deploy for ${service.serviceName ?? service.serviceId ?? service.key} hit a transient failure; retrying in ${Math.round(backoffMs / 1e3)}s...`
-    );
-    sleepSync(backoffMs);
+    const warning = `Railway deploy for ${service.serviceName ?? service.serviceId ?? service.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`);
   }
   const runtimeConfiguration = await syncRailwayServiceRuntimeConfigurationAfterDeploy(tenantRoot, service, {
-    env: buildRailwayCommandEnv(process.env)
+    env: commandEnv
   });
   return {
     service: service.key,

package/dist/operations/services/runtime-tools.d.ts

@@ -23,8 +23,6 @@ export declare function loadPackageJson(root?: string): any;
 export declare function isWorkspaceRoot(root?: string): boolean;
 export declare function createProductionBuildEnv(extraEnv?: {}): {
     TREESEED_LOCAL_DEV_MODE: string;
-    TREESEED_PUBLIC_FORMS_LOCAL_BYPASS_TURNSTILE: string;
-    TREESEED_FORMS_LOCAL_BYPASS_TURNSTILE: string;
     TREESEED_FORMS_LOCAL_BYPASS_CLOUDFLARE_GUARDS: string;
     TREESEED_PUBLIC_DEV_WATCH_RELOAD: string;
 };

package/dist/operations/services/runtime-tools.js

@@ -331,8 +331,6 @@ function isWorkspaceRoot(root = process.cwd()) {
 function createProductionBuildEnv(extraEnv = {}) {
   return {
     TREESEED_LOCAL_DEV_MODE: "cloudflare",
-    TREESEED_PUBLIC_FORMS_LOCAL_BYPASS_TURNSTILE: "",
-    TREESEED_FORMS_LOCAL_BYPASS_TURNSTILE: "",
     TREESEED_FORMS_LOCAL_BYPASS_CLOUDFLARE_GUARDS: "",
     TREESEED_PUBLIC_DEV_WATCH_RELOAD: "",
     ...extraEnv