@treeseed/sdk 0.8.6 → 0.8.7

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

@@ -256,7 +256,7 @@ export declare function validateTreeseedCommandEnvironment({ tenantRoot, scope,
 }): {
     registry: import("../../platform/environment.ts").TreeseedResolvedEnvironmentRegistry;
     values: {};
-    validation: import("../../platform/environment.ts").TreeseedEnvironmentValidationResult;
+    validation: any;
 };
 export declare function assertTreeseedCommandEnvironment({ tenantRoot, scope, purpose }: {
     tenantRoot: any;
@@ -265,7 +265,7 @@ export declare function assertTreeseedCommandEnvironment({ tenantRoot, scope, pu
 }): {
     registry: import("../../platform/environment.ts").TreeseedResolvedEnvironmentRegistry;
     values: {};
-    validation: import("../../platform/environment.ts").TreeseedEnvironmentValidationResult;
+    validation: any;
 };
 export declare function ensureTreeseedActVerificationTooling({ tenantRoot, installIfMissing, env, write }?: {
     tenantRoot?: string | undefined;

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

@@ -34,7 +34,8 @@ import {
 } from "./railway-deploy.js";
 import {
   normalizeRailwayEnvironmentName,
-  resolveRailwayWorkspace
+  resolveRailwayWorkspace,
+  resolveRailwayWorkspaceContext
 } from "./railway-api.js";
 import {
   createGitHubApiClient,
@@ -1585,20 +1586,52 @@ function applyTreeseedEnvironmentToProcess({ tenantRoot, scope, override = false
 function validateTreeseedCommandEnvironment({ tenantRoot, scope, purpose }) {
   const registry = collectTreeseedEnvironmentContext(tenantRoot);
   const values = resolveTreeseedLaunchEnvironment({ tenantRoot, scope });
-  const validation = validateTreeseedEnvironmentValues({
+  const validation = filterValidationByWorkflowPlane(validateTreeseedEnvironmentValues({
     values,
     scope,
     purpose,
     deployConfig: registry.context.deployConfig,
     tenantConfig: registry.context.tenantConfig,
     plugins: registry.context.plugins
-  });
+  }));
   return {
     registry,
     values,
     validation
   };
 }
+function filterValidationByWorkflowPlane(validation) {
+  const plane = process.env.TREESEED_WORKFLOW_PLANE;
+  if (plane !== "web" && plane !== "processing") {
+    return validation;
+  }
+  const problemApplies = (problem) => doesEntryApplyToWorkflowPlane(problem.entry, plane);
+  const missing = validation.missing.filter(problemApplies);
+  const invalid = validation.invalid.filter(problemApplies);
+  const entries = validation.entries.filter((entry) => doesEntryApplyToWorkflowPlane(entry, plane));
+  const required = validation.required.filter((entry) => doesEntryApplyToWorkflowPlane(entry, plane));
+  return {
+    ...validation,
+    ok: missing.length === 0 && invalid.length === 0,
+    entries,
+    required,
+    missing,
+    invalid
+  };
+}
+function doesEntryApplyToWorkflowPlane(entry, plane) {
+  const targets = new Set(entry.targets ?? []);
+  const hasProcessingTarget = targets.has("railway-secret") || targets.has("railway-var");
+  const hasWebTarget = targets.has("cloudflare-secret") || targets.has("cloudflare-var") || targets.has("local-cloudflare");
+  const hasWorkflowTarget = targets.has("github-secret") || targets.has("github-variable");
+  if (plane === "web") {
+    return !hasProcessingTarget || hasWebTarget || hasWorkflowTarget;
+  }
+  if (plane === "processing") {
+    return !hasWebTarget || hasProcessingTarget || hasWorkflowTarget;
+  }
+  return true;
+}
 function assertTreeseedCommandEnvironment({ tenantRoot, scope, purpose }) {
   const report = validateTreeseedCommandEnvironment({ tenantRoot, scope, purpose });
   if (report.validation.ok) {
@@ -1894,23 +1927,26 @@ async function checkRailwayConnection({ tenantRoot, env }) {
   const checkPromise = (async () => {
     for (let attempt = 0; attempt < 3; attempt += 1) {
       try {
-        const railwayCommand = resolveTreeseedToolCommand("railway", { env });
-        const whoami = railwayCommand ? checkCommand(railwayCommand.command, [...railwayCommand.argsPrefix, "whoami"], { cwd: tenantRoot, env }) : { ok: false, stdout: "", detail: "Railway CLI is unavailable." };
-        if (!whoami.ok) {
-          if (/rate.?limit|too many requests|429/iu.test(whoami.detail || "")) {
-            return providerConnectionResult(
-              "railway",
-              false,
-              "Railway connectivity preflight was rate-limited; bootstrap will continue and rely on API-backed reconcile verification.",
-              { skipped: true, warning: true, rateLimited: true }
-            );
-          }
-          throw new Error(whoami.detail || "Railway CLI authentication check failed.");
-        }
-        const identity = whoami.stdout.replace(/^logged in as\s+/iu, "").replace(/\s*👋\s*$/u, "").trim() || "an account";
-        return providerConnectionResult("railway", true, `Railway authenticated as ${identity} in workspace ${workspaceName}. Project and service existence will be reconciled during bootstrap.`);
+        const workspace = await resolveRailwayWorkspaceContext({ env, workspace: workspaceName });
+        return providerConnectionResult("railway", true, `Railway API token can access workspace ${workspace.name}. Project and service existence will be reconciled during bootstrap.`);
       } catch (error) {
         const detail = error instanceof Error ? error.message : "Railway API check failed.";
+        if (/rate.?limit|too many requests|429/iu.test(detail || "")) {
+          return providerConnectionResult(
+            "railway",
+            false,
+            "Railway connectivity preflight was rate-limited; bootstrap will continue and rely on API-backed reconcile verification.",
+            { skipped: true, warning: true, rateLimited: true }
+          );
+        }
+        if (attempt >= 2 && isTransientProviderConnectionError(detail)) {
+          return providerConnectionResult(
+            "railway",
+            false,
+            "Railway connectivity preflight hit transient API failures; bootstrap will continue and rely on API-backed reconcile verification.",
+            { skipped: true, warning: true, transient: true }
+          );
+        }
         if (attempt >= 2 || !isTransientProviderConnectionError(detail)) {
           return providerConnectionResult("railway", false, detail);
         }

package/dist/operations/services/deploy.js

@@ -1044,22 +1044,44 @@ function shouldManageCloudflareWebCacheRules(deployConfig, target) {
 function cloudflareApiRequest(path, { method = "GET", body, env, allowFailure = false } = {}) {
   const requestScript = `import { readFileSync } from 'node:fs';
 const input = JSON.parse(readFileSync(0, 'utf8') || '{}');
-const response = await fetch(input.url, {
-  method: input.method,
-  headers: {
-    authorization: 'Bearer ' + input.token,
-    'content-type': 'application/json',
-  },
-  body: input.body ? JSON.stringify(input.body) : undefined,
-});
-const rawBody = await response.text();
-let payload;
-try {
-  payload = rawBody ? JSON.parse(rawBody) : {};
-} catch {
-  payload = { success: false, errors: [{ message: rawBody || 'empty response' }] };
+function errorMessage(error) {
+  const parts = [];
+  if (error && typeof error.message === 'string') parts.push(error.message);
+  const cause = error?.cause;
+  if (cause && typeof cause.message === 'string') parts.push(cause.message);
+  if (cause && typeof cause.code === 'string') parts.push(cause.code);
+  if (Array.isArray(cause?.errors)) {
+    for (const entry of cause.errors) {
+      if (entry && typeof entry.message === 'string') parts.push(entry.message);
+      if (entry && typeof entry.code === 'string') parts.push(entry.code);
+    }
+  }
+  return [...new Set(parts.filter(Boolean))].join('; ') || String(error);
 }
-process.stdout.write(JSON.stringify({ ok: response.ok, payload }));`;
+try {
+  const response = await fetch(input.url, {
+    method: input.method,
+    headers: {
+      authorization: 'Bearer ' + input.token,
+      'content-type': 'application/json',
+    },
+    body: input.body ? JSON.stringify(input.body) : undefined,
+  });
+  const rawBody = await response.text();
+  let payload;
+  try {
+    payload = rawBody ? JSON.parse(rawBody) : {};
+  } catch {
+    payload = { success: false, errors: [{ message: rawBody || 'empty response' }] };
+  }
+  process.stdout.write(JSON.stringify({ ok: response.ok, payload }));
+} catch (error) {
+  process.stdout.write(JSON.stringify({
+    ok: false,
+    transient: true,
+    payload: { success: false, errors: [{ message: errorMessage(error) }] },
+  }));
+}`;
   const requestInput = JSON.stringify({
     url: `https://api.cloudflare.com/client/v4${path}`,
     method,
@@ -1067,6 +1089,11 @@ process.stdout.write(JSON.stringify({ ok: response.ok, payload }));`;
     token: env?.CLOUDFLARE_API_TOKEN ?? process.env.CLOUDFLARE_API_TOKEN ?? ""
   });
   const isTransient = (text) => /fetch failed|timed out|etimedout|econnreset|enetunreach|temporarily unavailable|aborted/iu.test(text || "");
+  const formatPayloadErrors = (payload) => Array.isArray(payload?.errors) ? payload.errors.map((entry) => entry?.message ?? JSON.stringify(entry)).join("; ") : "";
+  const summarizeChildError = (text) => {
+    const lines = String(text || "").split("\n").map((line) => line.trim()).filter(Boolean);
+    return lines.find((line) => /fetch failed|timed out|etimedout|econnreset|enetunreach|temporarily unavailable|aborted|typeerror|error/iu.test(line)) ?? lines[0] ?? "";
+  };
   let attempt = 0;
   for (; ; ) {
     const response = spawnSync(
@@ -1085,29 +1112,48 @@ process.stdout.write(JSON.stringify({ ok: response.ok, payload }));`;
       }
     );
     if (response.error?.code === "ETIMEDOUT") {
-      if (attempt < 2) {
+      if (attempt < 4) {
         attempt += 1;
+        sleepSync(500 * attempt);
         continue;
       }
       if (!allowFailure) {
-        throw new Error(`Cloudflare API request timed out: ${method} ${path}`);
+        throw new Error(`Cloudflare API request timed out after ${attempt + 1} attempts: ${method} ${path}`);
       }
       return null;
     }
     const stderr = response.stderr?.trim() || "";
     if (response.status !== 0) {
-      if (attempt < 2 && isTransient(stderr)) {
+      if (attempt < 4 && isTransient(stderr)) {
         attempt += 1;
+        sleepSync(500 * attempt);
         continue;
       }
       if (!allowFailure) {
-        throw new Error(stderr || `Cloudflare API request failed: ${method} ${path}`);
+        const detail = summarizeChildError(stderr);
+        throw new Error(detail ? `Cloudflare API request failed after ${attempt + 1} attempts: ${method} ${path}: ${detail}` : `Cloudflare API request failed after ${attempt + 1} attempts: ${method} ${path}`);
       }
     }
-    const parsed = JSON.parse(response.stdout?.trim() || '{"ok":false,"payload":{"success":false,"errors":[{"message":"empty response"}]}}');
+    let parsed;
+    try {
+      parsed = JSON.parse(response.stdout?.trim() || '{"ok":false,"payload":{"success":false,"errors":[{"message":"empty response"}]}}');
+    } catch {
+      parsed = {
+        ok: false,
+        payload: {
+          success: false,
+          errors: [{ message: response.stdout?.trim() || stderr || "empty response" }]
+        }
+      };
+    }
+    const details = formatPayloadErrors(parsed.payload);
+    if (!parsed.ok && parsed.transient && attempt < 4 && isTransient(details)) {
+      attempt += 1;
+      sleepSync(500 * attempt);
+      continue;
+    }
     if (!parsed.ok && !allowFailure) {
-      const details = Array.isArray(parsed.payload?.errors) ? parsed.payload.errors.map((entry) => entry?.message ?? JSON.stringify(entry)).join("; ") : "unknown error";
-      throw new Error(details || `Cloudflare API request failed: ${method} ${path}`);
+      throw new Error(details ? `Cloudflare API request failed after ${attempt + 1} attempts: ${method} ${path}: ${details}` : `Cloudflare API request failed after ${attempt + 1} attempts: ${method} ${path}`);
     }
     return parsed.payload;
   }

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

@@ -506,7 +506,7 @@ function parseFallbackDeployConfig(configPath) {
     slug: expectString(record.slug, "slug"),
     siteUrl: expectString(record.siteUrl, "siteUrl"),
     contactEmail: expectString(record.contactEmail, "contactEmail"),
-    hosting: parsedHosting && record.hub === void 0 && record.runtime === void 0 ? parsedHosting : normalizeLegacyHostingFromPlanes(hub, runtime),
+    hosting: parsedHosting?.kind === "market_control_plane" ? { ...parsedHosting, registration: "none" } : parsedHosting && record.hub === void 0 && record.runtime === void 0 ? parsedHosting : normalizeLegacyHostingFromPlanes(hub, runtime),
     hub,
     runtime,
     cloudflare: {

package/dist/platform/deploy-config.js

@@ -541,7 +541,7 @@ function parseDeployConfig(raw) {
   const turnstile = optionalRecord(parsed.turnstile, "turnstile") ?? {};
   optionalBoolean(turnstile.enabled, "turnstile.enabled");
   const normalizedHosting = normalizeLegacyHostingFromPlanes(hub, runtime);
-  const compatibilityHosting = hosting && !parsed.hub && !parsed.runtime ? hosting : normalizedHosting;
+  const compatibilityHosting = hosting?.kind === "market_control_plane" ? { ...hosting, registration: "none" } : hosting && !parsed.hub && !parsed.runtime ? hosting : normalizedHosting;
   return {
     name: expectString(parsed.name, "name"),
     slug: expectString(parsed.slug, "slug"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/sdk",
-  "version": "0.8.6",
+  "version": "0.8.7",
   "description": "Shared Treeseed SDK for content-backed and D1-backed object models.",
   "license": "AGPL-3.0-only",
   "repository": {