@treeseed/sdk 0.11.0 → 0.12.4

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[];