@treeseed/sdk 0.10.28 → 0.12.4

package/dist/reconcile/state.js

@@ -1,13 +1,13 @@
 import { createHash } from "node:crypto";
-import { loadCliDeployConfig } from "../operations/services/runtime-tools.js";
+import { loadTreeseedPlatformConfig } from "../platform/config.js";
 import { loadDeployState, resolveTreeseedResourceIdentity, writeDeployState } from "../operations/services/deploy.js";
 import { targetKey } from "./units.js";
 function stableHash(value) {
   return createHash("sha256").update(JSON.stringify(value)).digest("hex");
 }
 function railwayUnitTypeForServiceKey(serviceKey) {
-  if (serviceKey === "marketOperationsRunner") {
-    return "railway-service:market-operations-runner";
+  if (serviceKey === "operationsRunner") {
+    return "railway-service:operations-runner";
   }
   if (serviceKey === "workdayManager") {
     return "railway-service:workday-manager";
@@ -48,43 +48,6 @@ function migrateLegacyDeployStateUnits(legacyState, target) {
     cloudflare: {}
   }, target);
   const units = {};
-  const queue = legacyState.queues?.agentWork;
-  if (queue?.name) {
-    units[`queue:${queue.name}`] = {
-      unitId: `queue:${queue.name}`,
-      unitType: "queue",
-      provider: "cloudflare",
-      identity,
-      target,
-      logicalName: queue.name,
-      desiredSpecHash: "",
-      lastObservedAt: legacyState.readiness?.lastValidatedAt ?? null,
-      lastReconciledAt: legacyState.lastDeploymentTimestamp ?? null,
-      lastVerifiedAt: legacyState.readiness?.lastValidatedAt ?? null,
-      lastStatus: queue.queueId ? "ready" : "pending",
-      lastObservedState: {
-        name: queue.name,
-        dlqName: queue.dlqName ?? null,
-        queueId: queue.queueId ?? null,
-        dlqId: queue.dlqId ?? null
-      },
-      lastReconciledState: {
-        name: queue.name,
-        dlqName: queue.dlqName ?? null,
-        queueId: queue.queueId ?? null,
-        dlqId: queue.dlqId ?? null
-      },
-      lastDiff: null,
-      lastVerification: null,
-      lastAction: null,
-      resourceLocators: {
-        queueId: queue.queueId ?? null,
-        dlqId: queue.dlqId ?? null
-      },
-      warnings: [],
-      error: null
-    };
-  }
   const db = legacyState.d1Databases?.SITE_DATA_DB;
   if (db?.databaseName) {
     units[`database:${db.databaseName}`] = {
@@ -265,22 +228,22 @@ function migrateLegacyDeployStateUnits(legacyState, target) {
   return units;
 }
 function loadTreeseedReconcileState(tenantRoot, target) {
-  const deployConfig = loadCliDeployConfig(tenantRoot);
+  const deployConfig = loadTreeseedPlatformConfig({ tenantRoot, environment: target.kind === "persistent" ? target.scope : "staging", env: process.env }).deployConfig;
   const legacyState = loadDeployState(tenantRoot, deployConfig, { target });
   const persistedUnits = legacyState.units && typeof legacyState.units === "object" ? legacyState.units : migrateLegacyDeployStateUnits(legacyState, target);
   return {
     version: 1,
     target,
-    dependencyGraphVersion: legacyState.reconcile?.dependencyGraphVersion ?? 1,
+    dependencyGraphVersion: legacyState.reconciliation?.dependencyGraphVersion ?? 1,
     units: { ...persistedUnits }
   };
 }
 function writeTreeseedReconcileState(tenantRoot, reconcileState) {
-  const deployConfig = loadCliDeployConfig(tenantRoot);
+  const deployConfig = loadTreeseedPlatformConfig({ tenantRoot, environment: reconcileState.target.kind === "persistent" ? reconcileState.target.scope : "staging", env: process.env }).deployConfig;
   const legacyState = loadDeployState(tenantRoot, deployConfig, { target: reconcileState.target });
   writeDeployState(tenantRoot, {
     ...legacyState,
-    reconcile: {
+    reconciliation: {
       version: reconcileState.version,
       dependencyGraphVersion: reconcileState.dependencyGraphVersion,
       targetKey: targetKey(reconcileState.target)

package/dist/reconcile/units.d.ts

@@ -1,4 +1,4 @@
-import type { TreeseedDesiredUnit, TreeseedReconcileTarget, TreeseedReconcileUnitType } from './contracts.ts';
+import type { TreeseedDesiredUnit, TreeseedReconcileTarget, TreeseedReconcileUnitType } from './contracts.js';
 export declare const TRESEED_RECONCILE_UNIT_TYPES: TreeseedReconcileUnitType[];
 export declare function targetKey(target: TreeseedReconcileTarget): string;
 export declare function createTreeseedReconcileUnitId(unitType: TreeseedReconcileUnitType, logicalName: string): string;

package/dist/reconcile/units.js

@@ -1,7 +1,7 @@
 const TRESEED_RECONCILE_UNIT_TYPES = [
   "web-ui",
   "api-runtime",
-  "market-operations-runner-runtime",
+  "operations-runner-runtime",
   "workday-manager-runtime",
   "worker-runner-runtime",
   "edge-worker",
@@ -15,9 +15,15 @@ const TRESEED_RECONCILE_UNIT_TYPES = [
   "custom-domain:api",
   "dns-record",
   "railway-service:api",
-  "railway-service:market-operations-runner",
+  "railway-service:operations-runner",
   "railway-service:workday-manager",
-  "railway-service:worker-runner"
+  "railway-service:worker-runner",
+  "branch-preview",
+  "branch-preview-cleanup",
+  "workflow-gate",
+  "save-gate:local-verify",
+  "save-gate:promotion-readiness",
+  "save-gate:hosted-verify"
 ];
 function targetKey(target) {
   return target.kind === "persistent" ? target.scope : `branch:${target.branchName}`;

package/dist/remote.d.ts

@@ -1,4 +1,4 @@
-import type { RemoteJob, RemoteJobEvent, SdkDispatchRequest, SdkDispatchResult } from './sdk-types.ts';
+import type { RemoteJob, RemoteJobEvent, SdkDispatchRequest, SdkDispatchResult } from './sdk-types.js';
 export declare const TREESEED_REMOTE_CONTRACT_VERSION = 1;
 export declare const TREESEED_REMOTE_CONTRACT_HEADER = "x-treeseed-remote-contract-version";
 export type ApiScope = string;
@@ -165,14 +165,14 @@ export declare class CloudflareQueuePullClient {
     private readonly baseUrl;
     private readonly token;
     private readonly fetchImpl;
-    constructor(config: import('./sdk-types.ts').SdkQueuePullClientConfig);
+    constructor(config: import('./sdk-types.js').SdkQueuePullClientConfig);
     private request;
-    pull(request?: import('./sdk-types.ts').SdkQueuePullRequest): Promise<{
+    pull(request?: import('./sdk-types.js').SdkQueuePullRequest): Promise<{
         messages: {
             leaseId: string;
             attempts: number;
             rawBody: string;
-            body: import("./sdk-types.ts").SdkQueueMessageEnvelope;
+            body: import("./sdk-types.js").SdkQueueMessageEnvelope;
         }[];
     }>;
     ack(acks: string[]): Promise<unknown>;
@@ -185,8 +185,8 @@ export declare class CloudflareQueuePushClient {
     private readonly baseUrl;
     private readonly token;
     private readonly fetchImpl;
-    constructor(config: import('./sdk-types.ts').SdkQueuePushClientConfig);
-    enqueue(request: import('./sdk-types.ts').SdkQueuePushRequest): Promise<void>;
+    constructor(config: import('./sdk-types.js').SdkQueuePushClientConfig);
+    enqueue(request: import('./sdk-types.js').SdkQueuePushRequest): Promise<void>;
 }
 export declare class RemoteTreeseedOperationsClient {
     private readonly client;

package/dist/scenes/artifacts.d.ts

@@ -0,0 +1,16 @@
+import type { TreeseedSceneArtifactPathPlan, TreeseedSceneManifest, TreeseedScenePlanReport, TreeseedSceneRunArtifacts, TreeseedSceneRunReport, TreeseedSceneTimelineEvent } from './types.js';
+export declare function ensureTreeseedSceneRunDirectories(paths: TreeseedSceneArtifactPathPlan): void;
+export declare function createTreeseedSceneRunArtifacts(input: {
+    paths: TreeseedSceneArtifactPathPlan;
+    playwrightTracePath?: string | null;
+    screenshotPaths?: string[];
+    viewportScreenshotPaths?: string[];
+    videoPaths?: string[];
+}): TreeseedSceneRunArtifacts;
+export declare function appendTreeseedSceneJsonl(path: string, value: unknown): void;
+export declare function writeTreeseedSceneRunArtifacts(input: {
+    scene: TreeseedSceneManifest;
+    plan: TreeseedScenePlanReport;
+    report: TreeseedSceneRunReport;
+    timeline: TreeseedSceneTimelineEvent[];
+}): void;

package/dist/scenes/artifacts.js

@@ -0,0 +1,61 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+function writeJson(path, value) {
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+function ensureTreeseedSceneRunDirectories(paths) {
+  mkdirSync(paths.runRoot, { recursive: true });
+  mkdirSync(paths.playwrightRoot, { recursive: true });
+  mkdirSync(join(paths.playwrightRoot, "screenshots"), { recursive: true });
+  mkdirSync(join(paths.playwrightRoot, "screenshots", "viewport"), { recursive: true });
+  mkdirSync(join(paths.playwrightRoot, "videos"), { recursive: true });
+  mkdirSync(paths.logsRoot, { recursive: true });
+  mkdirSync(paths.segmentsRoot, { recursive: true });
+  mkdirSync(paths.checkpointsRoot, { recursive: true });
+  mkdirSync(paths.renderRoot, { recursive: true });
+  mkdirSync(paths.evidenceRoot, { recursive: true });
+  mkdirSync(paths.publishRoot, { recursive: true });
+}
+function createTreeseedSceneRunArtifacts(input) {
+  return {
+    runRoot: input.paths.runRoot,
+    normalizedScenePath: input.paths.normalizedScenePath,
+    planPath: input.paths.planPath,
+    runPath: input.paths.runPath,
+    timelinePath: input.paths.timelinePath,
+    markdownReportPath: input.paths.markdownReportPath,
+    playwrightTracePath: input.playwrightTracePath ?? null,
+    screenshotPaths: input.screenshotPaths ?? [],
+    viewportScreenshotPaths: input.viewportScreenshotPaths ?? [],
+    videoPaths: input.videoPaths ?? [],
+    consoleLogPath: join(input.paths.playwrightRoot, "console.jsonl"),
+    networkLogPath: join(input.paths.playwrightRoot, "network.jsonl"),
+    errorsLogPath: join(input.paths.playwrightRoot, "errors.jsonl"),
+    setupPath: join(input.paths.runRoot, "setup.json"),
+    devLogPath: join(input.paths.logsRoot, "dev.jsonl"),
+    apiLogPath: join(input.paths.logsRoot, "api.jsonl"),
+    operationsRunnerLogPath: join(input.paths.logsRoot, "operations-runner.jsonl"),
+    progressPath: input.paths.progressPath,
+    checkpointsRoot: input.paths.checkpointsRoot
+  };
+}
+function appendTreeseedSceneJsonl(path, value) {
+  writeFileSync(path, `${JSON.stringify(value)}
+`, { encoding: "utf8", flag: "a" });
+}
+function writeTreeseedSceneRunArtifacts(input) {
+  const artifacts = input.report.artifacts;
+  if (!artifacts) return;
+  writeJson(artifacts.normalizedScenePath, input.scene);
+  writeJson(artifacts.planPath, input.plan);
+  if (artifacts.setupPath) writeJson(artifacts.setupPath, input.report.setup);
+  writeJson(artifacts.timelinePath, input.timeline);
+  writeJson(artifacts.runPath, input.report);
+}
+export {
+  appendTreeseedSceneJsonl,
+  createTreeseedSceneRunArtifacts,
+  ensureTreeseedSceneRunDirectories,
+  writeTreeseedSceneRunArtifacts
+};

package/dist/scenes/auth.d.ts

@@ -0,0 +1,2 @@
+import type { TreeseedSceneAuthReport, TreeseedSceneAuthResolveOptions } from './types.js';
+export declare function resolveTreeseedSceneAuth(input: TreeseedSceneAuthResolveOptions): TreeseedSceneAuthReport;

package/dist/scenes/auth.js

@@ -0,0 +1,28 @@
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+import { resolveMarketProfile, resolveMarketSession } from "../market-client.js";
+import { findNearestTreeseedRoot } from "../workflow-support.js";
+import { sceneErrorDiagnostic } from "./diagnostics.js";
+function resolveTreeseedSceneAuth(input) {
+  const required = input.scene.setup.auth?.required === true;
+  const role = input.scene.setup.auth?.role?.trim();
+  const selector = input.scene.setup.auth?.profile ?? (input.environment === "local" ? "local" : null);
+  const profile = resolveMarketProfile(selector);
+  const authRoot = findNearestTreeseedRoot(input.projectRoot) ?? resolve(process.env.HOME || homedir());
+  const session = resolveMarketSession(authRoot, profile.id);
+  const diagnostics = [];
+  if (required && !session?.accessToken && (!role || role === "anonymous")) {
+    diagnostics.push(sceneErrorDiagnostic("scene.auth_required", `Not logged in to market "${profile.id}". Run treeseed auth:login --market ${profile.id}.`, "setup.auth"));
+  }
+  return {
+    ok: diagnostics.length === 0,
+    required,
+    profileId: profile.id,
+    authRoot,
+    hasSession: Boolean(session?.accessToken),
+    diagnostics
+  };
+}
+export {
+  resolveTreeseedSceneAuth
+};

package/dist/scenes/base-url.d.ts

@@ -0,0 +1,12 @@
+import type { TreeseedSceneBaseUrlResolution, TreeseedSceneEnvironment, TreeseedSceneEnvironmentPrepareReport, TreeseedSceneManifest } from './types.js';
+export declare function resolveTreeseedSceneBaseUrl(input: {
+    projectRoot: string;
+    scene: TreeseedSceneManifest;
+    environment: TreeseedSceneEnvironment;
+    environmentReport?: TreeseedSceneEnvironmentPrepareReport | null;
+}): TreeseedSceneBaseUrlResolution;
+export declare function resolveTreeseedSceneApiBaseUrl(input: {
+    projectRoot: string;
+    environment: TreeseedSceneEnvironment | string;
+    webBaseUrl: string;
+}): string;

package/dist/scenes/base-url.js

@@ -0,0 +1,123 @@
+import { readTreeseedDevInstance } from "../local-dev/managed-dev.js";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { loadTreeseedDeployConfigFromPath } from "../platform/deploy-config.js";
+import { sceneErrorDiagnostic } from "./diagnostics.js";
+function resolveTreeseedSceneBaseUrl(input) {
+  if (input.scene.target.baseUrl !== "auto") {
+    return { ok: true, baseUrl: input.scene.target.baseUrl, diagnostics: [] };
+  }
+  if (input.environment !== "local") {
+    const configured = configuredHostedBaseUrl(input.projectRoot, input.environment);
+    if (configured) return { ok: true, baseUrl: configured, diagnostics: [] };
+    return {
+      ok: false,
+      baseUrl: null,
+      diagnostics: [
+        sceneErrorDiagnostic(
+          "scene.base_url_unresolved",
+          "Automatic staging/prod base URL resolution requires a configured Treeseed deploy base URL.",
+          "target.baseUrl"
+        )
+      ]
+    };
+  }
+  if (input.environmentReport?.dev.baseUrl) {
+    return { ok: true, baseUrl: input.environmentReport.dev.baseUrl, diagnostics: [] };
+  }
+  const instance = readTreeseedDevInstance({ cwd: input.projectRoot, surface: "web" });
+  const healthUrl = instance?.health?.find((entry) => entry.kind === "http")?.url ?? null;
+  if (!instance?.running || !healthUrl) {
+    return {
+      ok: false,
+      baseUrl: null,
+      diagnostics: [
+        sceneErrorDiagnostic(
+          "scene.local_dev_not_running",
+          "Start local dev with trsd dev start --web-runtime local --json or set target.baseUrl explicitly.",
+          "target.baseUrl"
+        )
+      ]
+    };
+  }
+  return { ok: true, baseUrl: healthUrl, diagnostics: [] };
+}
+function configuredHostedBaseUrl(projectRoot, environment) {
+  const candidates = [
+    resolve(projectRoot, "treeseed.site.yaml"),
+    resolve(projectRoot, "..", "..", "treeseed.site.yaml")
+  ];
+  for (const candidate of candidates) {
+    if (!existsSync(candidate)) continue;
+    try {
+      const config = loadTreeseedDeployConfigFromPath(candidate);
+      const serviceUrl = hostedWebUrl(config.services?.web?.environments?.[environment]) ?? hostedWebUrl(config.surfaces?.web?.environments?.[environment]) ?? (environment === "prod" ? config.surfaces?.web?.publicBaseUrl : void 0);
+      if (typeof serviceUrl === "string" && serviceUrl.trim()) return serviceUrl.trim();
+    } catch {
+    }
+  }
+  if (environment === "prod") return "https://treeseed.dev";
+  if (environment === "staging") return "https://preview.treeseed.dev";
+  return null;
+}
+function hostedWebUrl(environmentConfig) {
+  if (!environmentConfig || typeof environmentConfig !== "object") return null;
+  const record = environmentConfig;
+  const baseUrl = typeof record.baseUrl === "string" ? record.baseUrl.trim() : "";
+  if (baseUrl) return baseUrl;
+  const domain = typeof record.domain === "string" ? record.domain.trim() : "";
+  if (!domain) return null;
+  return /^https?:\/\//u.test(domain) ? domain : `https://${domain}`;
+}
+function resolveTreeseedSceneApiBaseUrl(input) {
+  if (input.environment === "local") {
+    const instance = readTreeseedDevInstance({ cwd: input.projectRoot, surface: "api" });
+    const managedApi = httpHealthBaseUrl(instance);
+    if (managedApi) return managedApi;
+    const envApi = process.env.TREESEED_API_BASE_URL?.trim() || process.env.TREESEED_MARKET_API_BASE_URL?.trim();
+    if (envApi) return envApi.replace(/\/+$/u, "");
+    return input.webBaseUrl;
+  }
+  const environment = input.environment === "prod" ? "prod" : input.environment === "staging" ? "staging" : null;
+  if (!environment) return input.webBaseUrl;
+  const configured = configuredHostedApiBaseUrl(input.projectRoot, environment);
+  return configured ?? input.webBaseUrl;
+}
+function configuredHostedApiBaseUrl(projectRoot, environment) {
+  const candidates = [
+    resolve(projectRoot, "treeseed.site.yaml"),
+    resolve(projectRoot, "packages", "api", "treeseed.site.yaml"),
+    resolve(projectRoot, "..", "..", "treeseed.site.yaml"),
+    resolve(projectRoot, "..", "..", "packages", "api", "treeseed.site.yaml")
+  ];
+  for (const candidate of candidates) {
+    if (!existsSync(candidate)) continue;
+    try {
+      const config = loadTreeseedDeployConfigFromPath(candidate);
+      const serviceUrl = hostedApiUrl(config.connections?.api?.environments?.[environment]) ?? hostedApiUrl(config.services?.api?.environments?.[environment]) ?? hostedApiUrl(config.surfaces?.api?.environments?.[environment]) ?? (environment === "prod" ? config.surfaces?.api?.publicBaseUrl : void 0);
+      if (typeof serviceUrl === "string" && serviceUrl.trim()) return serviceUrl.trim();
+    } catch {
+    }
+  }
+  if (environment === "prod") return "https://api.treeseed.dev";
+  if (environment === "staging") return "https://api.preview.treeseed.dev";
+  return null;
+}
+function hostedApiUrl(environmentConfig) {
+  return hostedWebUrl(environmentConfig);
+}
+function httpHealthBaseUrl(instance) {
+  const healthUrl = instance?.health?.find((entry) => entry.kind === "http" && typeof entry.url === "string")?.url;
+  if (!healthUrl) return null;
+  try {
+    const url = new URL(healthUrl);
+    if (url.hostname === "0.0.0.0") url.hostname = "127.0.0.1";
+    return url.origin;
+  } catch {
+    return healthUrl.replace(/\/healthz?$/u, "").replace(/\/+$/u, "");
+  }
+}
+export {
+  resolveTreeseedSceneApiBaseUrl,
+  resolveTreeseedSceneBaseUrl
+};

package/dist/scenes/builtin-plugins.d.ts

@@ -0,0 +1,2 @@
+import type { TreeseedScenePlugin } from './types.js';
+export declare function createBuiltInTreeseedScenePlugins(): TreeseedScenePlugin[];