@treeseed/sdk 0.10.27 → 0.11.0

package/dist/operations/services/live-hosted-service-checks.js

@@ -0,0 +1,350 @@
+import { loadCliDeployConfig } from "./runtime-tools.js";
+import {
+  getRailwayServiceInstance,
+  inspectRailwayServiceDeploymentHealth,
+  listRailwayEnvironments,
+  listRailwayProjects,
+  listRailwayServices,
+  listRailwayVariables,
+  listRailwayVolumes,
+  normalizeRailwayEnvironmentName,
+  resolveRailwayWorkspaceContext
+} from "./railway-api.js";
+import { configuredRailwayServices, findStaleTreeseedOperationsRunnerResources } from "./railway-deploy.js";
+import { discoverTreeseedApplications } from "../../hosting/apps.js";
+import {
+  collectTreeseedHostedServiceChecks
+} from "./hosted-service-checks.js";
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function normalizeBaseUrl(value) {
+  return typeof value === "string" && value.trim() ? value.trim().replace(/\/+$/u, "") : null;
+}
+function urlForDomain(value) {
+  const normalized = normalizeBaseUrl(value);
+  if (!normalized) return null;
+  return /^https?:\/\//iu.test(normalized) ? normalized : `https://${normalized}`;
+}
+function selectedWebConfig(deployConfig, selectedApplication) {
+  return selectedApplication?.roles.includes("web") ? selectedApplication.config : deployConfig;
+}
+function pagesBranchName(config, target) {
+  const pages = config.cloudflare?.pages && typeof config.cloudflare.pages === "object" ? config.cloudflare.pages : {};
+  const key = target === "prod" ? "productionBranch" : "stagingBranch";
+  const fallback = target === "prod" ? "main" : "staging";
+  return typeof pages[key] === "string" && pages[key].trim() ? pages[key].trim() : fallback;
+}
+async function observeHttp(url, options) {
+  const attempts = Math.max(1, Math.floor(options.retry?.attempts ?? 3));
+  const intervalMs = Math.max(0, Math.floor(options.retry?.intervalMs ?? 1500));
+  const timeoutMs = Math.max(1e3, Math.floor(options.timeoutMs ?? 1e4));
+  let lastError = "";
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await (options.fetchImpl ?? fetch)(url, {
+        method: "GET",
+        headers: { accept: "application/json, text/plain, */*" },
+        signal: controller.signal
+      });
+      clearTimeout(timeout);
+      return { status: response.status, ok: response.ok };
+    } catch (error) {
+      clearTimeout(timeout);
+      lastError = error instanceof Error ? error.message : String(error);
+      if (attempt + 1 < attempts) await sleep(intervalMs);
+    }
+  }
+  return { ok: false, error: lastError || "HTTP request failed." };
+}
+async function inspectRailwayServiceDeploymentHealthWithRetry(input) {
+  const attempts = Math.max(1, Math.floor(input.options.retry?.attempts ?? 3));
+  const intervalMs = Math.max(0, Math.floor(input.options.retry?.intervalMs ?? 1500));
+  let lastDeployment = null;
+  let lastError = null;
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    try {
+      const deployment = await inspectRailwayServiceDeploymentHealth({
+        serviceId: input.serviceId,
+        environmentId: input.environmentId,
+        env: input.options.env,
+        fetchImpl: input.options.fetchImpl
+      });
+      lastDeployment = deployment;
+      if (deployment.ok) return deployment;
+    } catch (error) {
+      lastError = error;
+    }
+    if (attempt + 1 < attempts) await sleep(intervalMs);
+  }
+  return lastDeployment ?? {
+    ok: false,
+    status: null,
+    message: lastError instanceof Error ? lastError.message : String(lastError ?? "Unable to inspect deployment health.")
+  };
+}
+function findByName(items, nameOrId) {
+  if (!nameOrId) return null;
+  return items.find((item) => item.name === nameOrId || item.id === nameOrId) ?? null;
+}
+function indexedName(baseName, index) {
+  return `${baseName.replace(/-\d+$/u, "")}-${String(Math.max(1, index)).padStart(2, "0")}`;
+}
+function activeRailwayVolumeInstances(volume) {
+  const instances = Array.isArray(volume.instances) ? volume.instances : [];
+  return instances.filter((instance) => {
+    const state = String(instance.state ?? "READY").toUpperCase();
+    return state !== "DELETING" && state !== "DELETED";
+  });
+}
+function railwayVolumeInstanceStates(volume) {
+  const states = (Array.isArray(volume.instances) ? volume.instances : []).map((instance) => String(instance.state ?? "READY").trim().toUpperCase()).filter(Boolean);
+  return states.length > 0 ? [...new Set(states)].join(",") : "none";
+}
+async function collectRailwayObservations(options) {
+  const observed = {};
+  const issues = [];
+  const inspectedVolumeScopes = /* @__PURE__ */ new Set();
+  const inspectedRunnerScopes = /* @__PURE__ */ new Set();
+  try {
+    const workspace = await resolveRailwayWorkspaceContext({ env: options.env, fetchImpl: options.fetchImpl });
+    const projects = await listRailwayProjects({ workspaceId: workspace.id, env: options.env, fetchImpl: options.fetchImpl });
+    const configuredServices = configuredRailwayServices(options.tenantRoot, options.target).filter((entry) => !options.appId || entry.application?.id === options.appId);
+    for (const service of configuredServices) {
+      const project = service.projectId ? findByName(projects, service.projectId) : findByName(projects, service.projectName);
+      if (!project?.id) {
+        issues.push(`${service.serviceName}: Railway project ${service.projectName} was not found.`);
+        continue;
+      }
+      const environments = await listRailwayEnvironments({ projectId: project.id, env: options.env, fetchImpl: options.fetchImpl });
+      const environment = findByName(environments, service.railwayEnvironment);
+      if (!environment?.id) {
+        issues.push(`${service.serviceName}: Railway environment ${service.railwayEnvironment} was not found.`);
+        continue;
+      }
+      const volumeScope = `${project.id}:${environment.id}`;
+      if (!inspectedVolumeScopes.has(volumeScope)) {
+        inspectedVolumeScopes.add(volumeScope);
+        const volumes2 = await listRailwayVolumes({ projectId: project.id, env: options.env, fetchImpl: options.fetchImpl }).catch(() => []);
+        for (const volume2 of volumes2) {
+          const detachedPostgresInstances = activeRailwayVolumeInstances(volume2).filter(
+            (instance2) => instance2.environmentId === environment.id && instance2.mountPath === "/var/lib/postgresql/data" && !instance2.serviceId
+          );
+          if (detachedPostgresInstances.length > 0) {
+            issues.push(`${volume2.name ?? volume2.id}: detached PostgreSQL volume remains in Railway project ${project.name} (states=${railwayVolumeInstanceStates(volume2)}).`);
+          }
+        }
+      }
+      const services = await listRailwayServices({ projectId: project.id, env: options.env, fetchImpl: options.fetchImpl });
+      const runnerScope = `${project.id}:${environment.id}`;
+      if (service.key === "operationsRunner" && !inspectedRunnerScopes.has(runnerScope)) {
+        inspectedRunnerScopes.add(runnerScope);
+        const desiredRunnerNames = new Set(configuredServices.filter((entry) => entry.key === "operationsRunner").filter((entry) => entry.projectId ? entry.projectId === project.id : entry.projectName === project.name).filter((entry) => normalizeRailwayEnvironmentName(entry.railwayEnvironment) === normalizeRailwayEnvironmentName(environment.name)).map((entry) => entry.serviceName).filter(Boolean));
+        const desiredRunnerServiceIds = new Set(services.filter((entry) => desiredRunnerNames.has(entry.name)).map((entry) => entry.id));
+        for (const staleService of findStaleTreeseedOperationsRunnerResources(services, desiredRunnerNames)) {
+          issues.push(`${staleService.name}: stale operations runner Railway service remains in project ${project.name}.`);
+        }
+        const volumes2 = await listRailwayVolumes({ projectId: project.id, env: options.env, fetchImpl: options.fetchImpl }).catch(() => []);
+        const desiredRunnerVolumeNames = new Set([...desiredRunnerNames].map((name) => `${name}-volume`));
+        for (const staleVolume of findStaleTreeseedOperationsRunnerResources(volumes2, desiredRunnerVolumeNames)) {
+          const activeInstances = activeRailwayVolumeInstances(staleVolume);
+          const relevant = staleVolume.instances.length === 0 || activeInstances.length > 0;
+          const attachedToDesiredRunner = activeInstances.some((instance2) => desiredRunnerServiceIds.has(instance2.serviceId ?? ""));
+          if (relevant && !attachedToDesiredRunner) {
+            issues.push(`${staleVolume.name ?? staleVolume.id}: stale operations runner Railway volume remains in project ${project.name} (states=${railwayVolumeInstanceStates(staleVolume)}).`);
+          }
+        }
+      }
+      const railwayService = service.serviceId ? findByName(services, service.serviceId) : findByName(services, service.serviceName);
+      if (!railwayService?.id) {
+        issues.push(`${service.serviceName}: Railway service was not found.`);
+        continue;
+      }
+      const [instance, variables, volumes] = await Promise.all([
+        getRailwayServiceInstance({ serviceId: railwayService.id, environmentId: environment.id, env: options.env, fetchImpl: options.fetchImpl }),
+        listRailwayVariables({ projectId: project.id, environmentId: environment.id, serviceId: railwayService.id, env: options.env, fetchImpl: options.fetchImpl }).catch(() => ({})),
+        listRailwayVolumes({ projectId: project.id, env: options.env, fetchImpl: options.fetchImpl }).catch(() => [])
+      ]);
+      const volume = Array.isArray(volumes) ? volumes.flatMap((entry) => Array.isArray(entry.instances) ? entry.instances : Array.isArray(entry.volumeInstances) ? entry.volumeInstances : []).find((entry) => entry?.serviceId === railwayService.id && entry?.environmentId === environment.id) : null;
+      const variableKeys = Object.keys(variables ?? {});
+      observed[service.serviceName] = {
+        projectName: project.name,
+        environmentName: environment.name,
+        serviceName: railwayService.name,
+        rootDirectory: instance.rootDirectory,
+        buildCommand: instance.buildCommand,
+        startCommand: instance.startCommand,
+        healthcheckPath: instance.healthcheckPath,
+        healthcheckTimeoutSeconds: instance.healthcheckTimeoutSeconds,
+        runtimeMode: service.runtimeMode ?? instance.runtimeMode,
+        volumeMountPath: volume?.mountPath ?? null,
+        variables: variableKeys,
+        secrets: variableKeys,
+        health: "unknown"
+      };
+    }
+    const deployConfig = loadCliDeployConfig(options.tenantRoot);
+    const appConfigs = [
+      ...!options.appId || options.appId === "web" ? [deployConfig] : [],
+      ...discoverTreeseedApplications(options.tenantRoot).filter((application) => application.id === "api" && (!options.appId || options.appId === "api")).map((application) => application.config)
+    ];
+    for (const config of appConfigs) {
+      const nodePool = config.publicTreeDxFederation?.railway?.nodePool;
+      if (!nodePool && config.hosting?.kind !== "treeseed_control_plane") continue;
+      const bootstrapCount = Math.max(1, Number.parseInt(String(nodePool?.bootstrapCount ?? 1), 10) || 1);
+      const projectName = config.slug ?? "treeseed-api";
+      const environmentName = normalizeRailwayEnvironmentName(options.target) || options.target;
+      const project = findByName(projects, projectName);
+      if (!project?.id) {
+        issues.push(`public-treedx: Railway project ${projectName} was not found.`);
+        continue;
+      }
+      const environments = await listRailwayEnvironments({ projectId: project.id, env: options.env, fetchImpl: options.fetchImpl });
+      const environment = findByName(environments, environmentName);
+      if (!environment?.id) {
+        issues.push(`public-treedx: Railway environment ${environmentName} was not found.`);
+        continue;
+      }
+      const [services, volumes] = await Promise.all([
+        listRailwayServices({ projectId: project.id, env: options.env, fetchImpl: options.fetchImpl }),
+        listRailwayVolumes({ projectId: project.id, env: options.env, fetchImpl: options.fetchImpl }).catch(() => [])
+      ]);
+      for (let index = 1; index <= bootstrapCount; index += 1) {
+        const serviceName = indexedName("public-treedx-node", index);
+        const volumeName = `${serviceName}-volume`;
+        const configuredNode = Array.isArray(config.services) ? config.services.find((service2) => service2?.id === serviceName || service2?.name === serviceName) : null;
+        const volumeMountPath = typeof configuredNode?.volumeMountPath === "string" && configuredNode.volumeMountPath.trim() ? configuredNode.volumeMountPath.trim() : "/data";
+        const service = findByName(services, serviceName);
+        if (!service?.id) {
+          issues.push(`${serviceName}: public TreeDX Railway service was not found.`);
+          continue;
+        }
+        const deployment = await inspectRailwayServiceDeploymentHealthWithRetry({
+          serviceId: service.id,
+          environmentId: environment.id,
+          options
+        }).catch((error) => ({
+          ok: false,
+          status: null,
+          message: error instanceof Error ? error.message : String(error ?? "Unable to inspect TreeDX deployment health.")
+        }));
+        if (!deployment.ok) {
+          issues.push(`${serviceName}: public TreeDX latest deployment is not healthy. ${deployment.message}`);
+        }
+        const variables = await listRailwayVariables({ projectId: project.id, environmentId: environment.id, serviceId: service.id, env: options.env, fetchImpl: options.fetchImpl }).catch(() => ({}));
+        if (variables.TREEDX_FEDERATION_MODE !== "connected_library") {
+          issues.push(`${serviceName}: TREEDX_FEDERATION_MODE is not connected_library.`);
+        }
+        const mountedVolume = volumes.find((volume) => volume.name === volumeName && volume.instances.some(
+          (instance) => instance.serviceId === service.id && instance.environmentId === environment.id && instance.mountPath === volumeMountPath
+        ));
+        if (!mountedVolume) {
+          issues.push(`${serviceName}: public TreeDX volume ${volumeName} is not mounted at ${volumeMountPath}.`);
+        }
+      }
+    }
+    return { observed, status: "observed", issues };
+  } catch (error) {
+    return {
+      observed,
+      status: "failed",
+      issues: [...issues, error instanceof Error ? error.message : String(error)]
+    };
+  }
+}
+async function collectHttpObservations(options) {
+  const deployConfig = loadCliDeployConfig(options.tenantRoot);
+  const urls = /* @__PURE__ */ new Set();
+  const fallbacks = /* @__PURE__ */ new Map();
+  const selectedApplication = options.appId ? discoverTreeseedApplications(options.tenantRoot).find((application) => application.id === options.appId || application.relativeRoot === options.appId) : null;
+  if (!options.appId || options.appId === "web" || selectedApplication?.roles.includes("web")) {
+    const webConfig = selectedWebConfig(deployConfig, selectedApplication);
+    const webDomain = webConfig.surfaces?.web?.environments?.[options.target]?.domain ?? webConfig.surfaces?.web?.publicBaseUrl ?? webConfig.siteUrl;
+    const webUrl = urlForDomain(webDomain);
+    if (webUrl) {
+      urls.add(webUrl);
+      if (!options.appId || options.appId === "web" || selectedApplication?.roles.includes("api")) {
+        urls.add(`${webUrl}/v1/healthz`);
+      }
+      const pagesProjectName = webConfig.cloudflare?.pages?.projectName;
+      if (pagesProjectName) {
+        const branchName = pagesBranchName(webConfig, options.target);
+        const pagesUrl = options.target === "prod" ? `https://${pagesProjectName}.pages.dev` : `https://${branchName}.${pagesProjectName}.pages.dev`;
+        fallbacks.set(webUrl, pagesUrl);
+      }
+    }
+  }
+  for (const service of configuredRailwayServices(options.tenantRoot, options.target).filter((entry) => !options.appId || entry.application?.id === options.appId)) {
+    const serviceConfig = deployConfig.services?.[service.key];
+    const domain = service.publicBaseUrl ?? serviceConfig?.environments?.[options.target]?.baseUrl ?? serviceConfig?.environments?.[options.target]?.domain ?? (service.key === "api" ? deployConfig.surfaces?.api?.environments?.[options.target]?.domain : null);
+    const baseUrl = urlForDomain(domain);
+    if (!baseUrl) continue;
+    urls.add(`${baseUrl}${service.healthcheckPath ?? "/healthz"}`);
+    if (service.key === "api") urls.add(`${baseUrl}/healthz/deep`);
+  }
+  const entries = await Promise.all([...urls].map(async (url) => {
+    const observed = await observeHttp(url, options);
+    const fallbackUrl = fallbacks.get(url);
+    if (observed.ok !== true && !observed.status && fallbackUrl) {
+      const fallback = await observeHttp(fallbackUrl, options);
+      return [url, {
+        ...observed,
+        fallbackUrl,
+        fallbackStatus: fallback.status,
+        fallbackOk: fallback.ok,
+        fallbackError: fallback.error
+      }];
+    }
+    return [url, observed];
+  }));
+  return Object.fromEntries(entries);
+}
+function strictenReport(report, options) {
+  if (!options.strict) return report;
+  const checks = report.checks.map((check) => {
+    if (check.status !== "skipped") return check;
+    const providerRequired = options.requireLiveRailway && check.provider === "railway" || options.requireLiveHttp && check.provider === "http";
+    if (!providerRequired) return check;
+    return {
+      ...check,
+      status: "failed",
+      issues: check.issues.length > 0 ? check.issues : ["Required live observation was not available."],
+      remediation: check.remediation ?? "Run provider configuration bootstrap or verify provider credentials, then rerun with --live."
+    };
+  });
+  const summary = {
+    passed: checks.filter((entry) => entry.status === "passed").length,
+    failed: checks.filter((entry) => entry.status === "failed").length,
+    skipped: checks.filter((entry) => entry.status === "skipped").length,
+    warning: checks.filter((entry) => entry.status === "warning").length
+  };
+  return { ...report, checks, summary };
+}
+async function collectTreeseedLiveHostedServiceChecks(options) {
+  const requireLiveRailway = options.requireLiveRailway ?? options.strict === true;
+  const requireLiveHttp = options.requireLiveHttp ?? options.strict === true;
+  const railway = requireLiveRailway ? await collectRailwayObservations(options) : { observed: {}, status: "skipped", issues: [] };
+  const httpChecks = requireLiveHttp ? await collectHttpObservations(options) : {};
+  const report = collectTreeseedHostedServiceChecks({
+    tenantRoot: options.tenantRoot,
+    target: options.target,
+    appId: options.appId,
+    observedRailwayServices: railway.observed,
+    httpChecks
+  });
+  const httpStatus = requireLiveHttp ? Object.values(httpChecks).some((entry) => entry.ok === true || entry.status) ? "observed" : "failed" : "skipped";
+  return strictenReport({
+    ...report,
+    live: true,
+    liveObservation: {
+      railway: railway.status,
+      http: httpStatus,
+      issues: railway.issues
+    }
+  }, options);
+}
+export {
+  collectTreeseedLiveHostedServiceChecks
+};

package/dist/operations/services/managed-host-security.js

@@ -5,7 +5,7 @@ const SAFE_MANAGED_HOST_CI_VARIABLES = /* @__PURE__ */ new Set([
   "TREESEED_HOSTING_KIND",
   "TREESEED_HOSTING_REGISTRATION",
   "TREESEED_HOSTING_TEAM_ID",
-  "TREESEED_MARKET_API_BASE_URL",
+  "TREESEED_API_BASE_URL",
   "TREESEED_PROJECT_ID"
 ]);
 const SAFE_MANAGED_HOST_CI_SECRETS = /* @__PURE__ */ new Set([

package/dist/operations/services/operations-runner-smoke.d.ts

@@ -0,0 +1,30 @@
+export interface TreeseedOperationsRunnerSmokeReport {
+    environment: 'staging' | 'prod';
+    ok: boolean;
+    baseUrl: string;
+    operationId?: string;
+    finalStatus?: string;
+    runnerId?: string | null;
+    timings: Array<{
+        phase: string;
+        durationMs: number;
+    }>;
+    events: Array<{
+        kind: string;
+        createdAt: string;
+    }>;
+    issues: string[];
+    remediation?: string;
+}
+export interface TreeseedOperationsRunnerSmokeOptions {
+    tenantRoot: string;
+    environment: 'staging' | 'prod';
+    baseUrl?: string | null;
+    serviceId?: string | null;
+    serviceSecret?: string | null;
+    timeoutMs?: number;
+    pollMs?: number;
+    fetchImpl?: typeof fetch;
+    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
+}
+export declare function runTreeseedOperationsRunnerSmoke(options: TreeseedOperationsRunnerSmokeOptions): Promise<TreeseedOperationsRunnerSmokeReport>;

package/dist/operations/services/operations-runner-smoke.js

@@ -0,0 +1,180 @@
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { loadTreeseedDeployConfigFromPath } from "../../platform/deploy-config.js";
+import { resolveTreeseedMachineEnvironmentValues } from "./config-runtime.js";
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function normalizedBaseUrl(value2) {
+  return value2.trim().replace(/\/+$/u, "");
+}
+function value(name, values, env) {
+  const candidate = env[name] ?? values[name];
+  return typeof candidate === "string" && candidate.trim() ? candidate.trim() : null;
+}
+function manifestApiBaseUrl(tenantRoot, environment) {
+  const candidates = [
+    resolve(tenantRoot, "treeseed.site.yaml"),
+    resolve(tenantRoot, "..", "..", "treeseed.site.yaml")
+  ];
+  for (const candidate of candidates) {
+    if (!existsSync(candidate)) continue;
+    try {
+      const config = loadTreeseedDeployConfigFromPath(candidate);
+      const connectionUrl = config.connections?.api?.environments?.[environment]?.baseUrl;
+      const serviceUrl = config.services?.api?.environments?.[environment]?.baseUrl;
+      const baseUrl = connectionUrl ?? serviceUrl;
+      if (typeof baseUrl === "string" && baseUrl.trim()) {
+        return baseUrl.trim();
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function timed(timings, phase, action) {
+  const started = Date.now();
+  try {
+    return await action();
+  } finally {
+    timings.push({ phase, durationMs: Date.now() - started });
+  }
+}
+async function requestJson(fetchImpl, url, options = {}) {
+  const response = await fetchImpl(url, {
+    ...options,
+    headers: {
+      accept: "application/json",
+      ...options.body ? { "content-type": "application/json" } : {},
+      ...options.headers ?? {}
+    }
+  });
+  const text = await response.text();
+  const payload = text ? JSON.parse(text) : {};
+  if (!response.ok) {
+    const message = typeof payload?.error === "string" ? payload.error : typeof payload?.error?.message === "string" ? payload.error.message : typeof payload?.message === "string" ? payload.message : `HTTP ${response.status}`;
+    throw new Error(`${options.method ?? "GET"} ${url} failed: ${message}`);
+  }
+  return payload;
+}
+function operationFrom(payload) {
+  return payload?.operation ?? payload?.payload?.operation ?? null;
+}
+function eventsFrom(payload) {
+  const events = Array.isArray(payload?.events) ? payload.events : Array.isArray(payload?.payload?.events) ? payload.payload.events : [];
+  return events.map((event) => ({
+    kind: String(event?.kind ?? "unknown"),
+    createdAt: String(event?.createdAt ?? event?.created_at ?? "")
+  }));
+}
+function isSuccessfulOperationStatus(status) {
+  return ["completed", "succeeded"].includes(String(status ?? "").toLowerCase());
+}
+function failure(baseUrl, environment, issues, timings, extra = {}) {
+  return {
+    environment,
+    ok: false,
+    baseUrl,
+    timings,
+    events: [],
+    issues,
+    remediation: "Verify the API service, Treeseed database, and operationsRunner Railway service, then run `npx trsd hosting verify --service operationsRunner --live --json`.",
+    ...extra
+  };
+}
+async function runTreeseedOperationsRunnerSmoke(options) {
+  const env = options.env ?? process.env;
+  let values = {};
+  try {
+    values = resolveTreeseedMachineEnvironmentValues(options.tenantRoot, options.environment);
+  } catch {
+    values = {};
+  }
+  const baseUrl = normalizedBaseUrl(
+    options.baseUrl ?? manifestApiBaseUrl(options.tenantRoot, options.environment) ?? value("TREESEED_API_BASE_URL", values, env) ?? value("TREESEED_CENTRAL_MARKET_API_BASE_URL", values, env) ?? (options.environment === "prod" ? "https://api.treeseed.ai" : "https://api-treeseed-staging.treeseed.ai")
+  );
+  const serviceId = options.serviceId ?? value("TREESEED_ACCEPTANCE_SERVICE_ID", values, env) ?? value("TREESEED_API_WEB_SERVICE_ID", values, env) ?? value("TREESEED_WEB_SERVICE_ID", values, env) ?? "web";
+  const serviceSecret = options.serviceSecret ?? value("TREESEED_ACCEPTANCE_SERVICE_SECRET", values, env) ?? value("TREESEED_API_WEB_SERVICE_SECRET", values, env) ?? value("TREESEED_WEB_SERVICE_SECRET", values, env);
+  const timings = [];
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const timeoutMs = Math.max(1e3, Math.floor(options.timeoutMs ?? (options.environment === "prod" ? 12e4 : 9e4)));
+  const pollMs = Math.max(1e3, Math.floor(options.pollMs ?? 3e3));
+  if (!serviceSecret) {
+    return failure(baseUrl, options.environment, ["Missing API service credential for runner smoke."], timings);
+  }
+  const headers = {
+    "x-treeseed-service-id": serviceId,
+    "x-treeseed-service-secret": serviceSecret
+  };
+  try {
+    await timed(timings, "healthz", () => requestJson(fetchImpl, `${baseUrl}/healthz`));
+    await timed(timings, "healthz-deep", () => requestJson(fetchImpl, `${baseUrl}/healthz/deep`));
+    const idempotencyKey = `smoke:${options.environment}:${Date.now()}`;
+    const created = await timed(timings, "operation-create", () => requestJson(fetchImpl, `${baseUrl}/v1/platform/operations`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        namespace: "market",
+        operation: "diagnostic",
+        target: "market_operations_runner",
+        idempotencyKey,
+        input: {
+          source: "trsd.operations.smoke",
+          environment: options.environment
+        }
+      })
+    }));
+    const operation = operationFrom(created);
+    const operationId = typeof operation?.id === "string" ? operation.id : null;
+    if (!operationId) {
+      return failure(baseUrl, options.environment, ["API did not return a diagnostic operation id."], timings);
+    }
+    const deadline = Date.now() + timeoutMs;
+    let current = operation;
+    while (Date.now() < deadline) {
+      current = operationFrom(await timed(timings, "operation-poll", () => requestJson(fetchImpl, `${baseUrl}/v1/platform/operations/${encodeURIComponent(operationId)}`, { headers }))) ?? current;
+      if (isSuccessfulOperationStatus(current?.status)) {
+        const eventPayload = await timed(timings, "operation-events", () => requestJson(fetchImpl, `${baseUrl}/v1/platform/operations/${encodeURIComponent(operationId)}/events`, { headers }));
+        const events = eventsFrom(eventPayload);
+        const sawRunnerEvent = events.some((event) => /checkpoint|complete|runner|market\.noop/iu.test(event.kind));
+        if (!sawRunnerEvent) {
+          return failure(baseUrl, options.environment, ["Diagnostic operation completed but no runner checkpoint/completion event was recorded."], timings, {
+            operationId,
+            finalStatus: String(current?.status ?? "completed"),
+            runnerId: current?.assignedRunnerId ?? null,
+            events
+          });
+        }
+        return {
+          environment: options.environment,
+          ok: true,
+          baseUrl,
+          operationId,
+          finalStatus: String(current?.status ?? "completed"),
+          runnerId: current?.assignedRunnerId ?? null,
+          timings,
+          events,
+          issues: []
+        };
+      }
+      if (["failed", "cancelled", "timed_out"].includes(String(current?.status ?? ""))) {
+        return failure(baseUrl, options.environment, [`Diagnostic operation ended with status ${current.status}.`], timings, {
+          operationId,
+          finalStatus: current.status,
+          runnerId: current?.assignedRunnerId ?? null
+        });
+      }
+      await sleep(pollMs);
+    }
+    return failure(baseUrl, options.environment, [`Diagnostic operation was not completed within ${timeoutMs}ms.`], timings, {
+      operationId,
+      finalStatus: current?.status ?? "unknown",
+      runnerId: current?.assignedRunnerId ?? null
+    });
+  } catch (error) {
+    return failure(baseUrl, options.environment, [error instanceof Error ? error.message : String(error)], timings);
+  }
+}
+export {
+  runTreeseedOperationsRunnerSmoke
+};

package/dist/operations/services/package-adapters.d.ts

@@ -0,0 +1,95 @@
+export type TreeseedPackageKind = 'node-typescript' | 'beam-elixir-rust';
+export type TreeseedPackageCommand = {
+    label: string;
+    command: string;
+    args: string[];
+    cwd: string;
+};
+export type TreeseedPackageAdapter = {
+    id: string;
+    name: string;
+    kind: TreeseedPackageKind;
+    dir: string;
+    relativeDir: string;
+    version: string | null;
+    publishTarget: string | null;
+    manifestPath: string | null;
+    versionSource: string | null;
+    verifyCommands: {
+        fast: TreeseedPackageCommand | null;
+        local: TreeseedPackageCommand | null;
+        release: TreeseedPackageCommand | null;
+    };
+    artifacts: Array<{
+        provider: 'npm' | 'docker';
+        name: string;
+        tags?: string[];
+    }>;
+    releaseChecks: Array<{
+        kind: 'npm-pack-dry-run' | 'github-workflow' | 'docker-manifest';
+        name: string;
+        detail: string;
+    }>;
+    metadata: Record<string, unknown>;
+};
+export type TreeseedPackageDevelopmentImagePlan = {
+    package: {
+        id: string;
+        name: string;
+        path: string;
+        kind: TreeseedPackageKind;
+        version: string | null;
+        publishTarget: string | null;
+        metadata: Record<string, unknown>;
+    };
+    repository: string;
+    workflow: string;
+    branch: string;
+    refs: {
+        imageName: string;
+        branch: string;
+        branchSlug: string;
+        sha: string;
+        shortSha: string;
+        immutableTag: string;
+        movingTag: string | null;
+        imageRef: string;
+        movingImageRef: string | null;
+        archImageRefs: string[];
+    };
+    hosting: {
+        app: string;
+        environment: string;
+        overrideEnvVar: string;
+        override: Record<string, string>;
+        command: string;
+    } | null;
+};
+export declare function readMixProjectVersion(filePath: string): string | null;
+export declare function planTreeseedPackageDevelopmentImage(root: any, idOrName: string, { branch }?: {
+    branch?: string | null;
+}): TreeseedPackageDevelopmentImagePlan;
+export declare function discoverTreeseedPackageAdapters(root?: any): TreeseedPackageAdapter[];
+export declare function findTreeseedPackageAdapter(root: string, idOrName: string): TreeseedPackageAdapter | null;
+export declare function packageAdapterPlanSummary(root?: any): {
+    id: string;
+    name: string;
+    kind: TreeseedPackageKind;
+    path: string;
+    version: string | null;
+    publishTarget: string | null;
+    verify: {
+        [k: string]: string | null;
+    };
+    artifacts: {
+        provider: "npm" | "docker";
+        name: string;
+        tags?: string[];
+    }[];
+    releaseChecks: {
+        kind: "npm-pack-dry-run" | "github-workflow" | "docker-manifest";
+        name: string;
+        detail: string;
+    }[];
+    metadata: Record<string, unknown>;
+}[];