@treeseed/sdk 0.10.12 → 0.10.14

package/dist/operations/services/github-api.d.ts

@@ -58,6 +58,59 @@ export type GitHubWorkflowProgressEvent = {
     completedJobs?: GitHubWorkflowJobSummary[];
     failedJobs?: GitHubWorkflowJobSummary[];
 };
+export interface GitHubWorkflowDispatchResult {
+    repository: string;
+    workflow: string;
+    branch: string;
+    inputs: Record<string, string> | undefined;
+    status: number | null;
+    dispatchedAt: string;
+}
+export interface GitHubWorkflowCancellationResult {
+    ok: boolean;
+    supported: boolean;
+    repository: string | null;
+    runId: number | null;
+    url?: string | null;
+    message: string;
+    cancelledAt?: string | null;
+}
+export interface GitHubWorkflowFileStatus {
+    ok: boolean;
+    exists: boolean | null;
+    repository: string;
+    workflow: string;
+    url: string | null;
+    message: string;
+}
+export interface GitHubWorkflowFailureSummaryInput {
+    repository?: string | null;
+    workflow?: string | null;
+    runId?: number | string | null;
+    runUrl?: string | null;
+    conclusion?: string | null;
+    failedJobName?: string | null;
+    lastActiveStep?: string | null;
+    message?: string | null;
+    blockerCode?: string | null;
+    retrySafe?: boolean;
+    resumeSafe?: boolean;
+}
+export interface GitHubWorkflowFailureSummary {
+    summary: string;
+    provider: 'github';
+    repository: string | null;
+    workflow: string | null;
+    runId: number | null;
+    runUrl: string | null;
+    inspectCommand: string | null;
+    failedJobName: string | null;
+    lastActiveStep: string | null;
+    conclusion: string | null;
+    retrySafe: boolean;
+    resumeSafe: boolean;
+    blockerCode: string;
+}
 export declare function resolveGitHubApiToken(env?: NodeJS.ProcessEnv | Record<string, string | undefined>): string;
 export declare function parseGitHubRepositorySlug(value: string): {
     owner: string;
@@ -147,6 +200,36 @@ export declare function upsertGitHubRepositoryVariableWithGhCli(repository: stri
 }, name: string, value: string, { env, }?: {
     env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
 }): void;
+export declare function formatGitHubWorkflowFailure(input?: GitHubWorkflowFailureSummaryInput): GitHubWorkflowFailureSummary;
+export declare function dispatchGitHubWorkflowRun(repository: string | {
+    owner: string;
+    name: string;
+}, { client, workflow, branch, inputs, }: {
+    client?: GitHubApiClient;
+    workflow?: string;
+    branch: string;
+    inputs?: Record<string, string>;
+}): Promise<GitHubWorkflowDispatchResult>;
+export declare function cancelGitHubWorkflowRun(repository: string | {
+    owner: string;
+    name: string;
+} | null | undefined, runId: number | string | null | undefined, { client }?: {
+    client?: GitHubApiClient;
+}): Promise<GitHubWorkflowCancellationResult>;
+export declare function getGitHubWorkflowFileStatus(repository: string | {
+    owner: string;
+    name: string;
+}, workflow?: string, { client }?: {
+    client?: GitHubApiClient;
+}): Promise<GitHubWorkflowFileStatus>;
+export declare function getLatestGitHubWorkflowRun(repository: string | {
+    owner: string;
+    name: string;
+}, { client, workflow, branch, }?: {
+    client?: GitHubApiClient;
+    workflow?: string;
+    branch?: string | null;
+}): Promise<GitHubWorkflowRunSummary | null>;
 export declare function waitForGitHubWorkflowRunCompletion(repository: string | {
     owner: string;
     name: string;

package/dist/operations/services/github-api.js

@@ -548,6 +548,168 @@ function normalizeWorkflowJob(job) {
     })) : []
   };
 }
+function workflowInspectCommand(repository, runId) {
+  return repository && runId ? `gh run view ${runId} --repo ${repository} --log-failed` : null;
+}
+function formatGitHubWorkflowFailure(input = {}) {
+  const repository = typeof input.repository === "string" && input.repository.trim() ? input.repository.trim() : null;
+  const workflow = typeof input.workflow === "string" && input.workflow.trim() ? input.workflow.trim() : null;
+  const numericRunId = Number(input.runId);
+  const runId = Number.isFinite(numericRunId) && numericRunId > 0 ? numericRunId : null;
+  const runUrl = typeof input.runUrl === "string" && input.runUrl.trim() ? input.runUrl.trim() : null;
+  const conclusion = typeof input.conclusion === "string" && input.conclusion.trim() ? input.conclusion.trim() : null;
+  const failedJobName = typeof input.failedJobName === "string" && input.failedJobName.trim() ? input.failedJobName.trim() : null;
+  const lastActiveStep = typeof input.lastActiveStep === "string" && input.lastActiveStep.trim() ? input.lastActiveStep.trim() : null;
+  const blockerCode = typeof input.blockerCode === "string" && input.blockerCode.trim() ? input.blockerCode.trim() : conclusion === "cancelled" ? "github_workflow_cancelled" : conclusion === "timed_out" ? "github_workflow_timed_out" : "github_workflow_failed";
+  const detail = failedJobName ? ` Failed job: ${failedJobName}.` : lastActiveStep ? ` Last active step: ${lastActiveStep}.` : "";
+  const summary = typeof input.message === "string" && input.message.trim() ? input.message.trim() : `${workflow ?? "GitHub workflow"} ${conclusion ? `completed with conclusion ${conclusion}` : "failed"}.${detail}`;
+  return {
+    summary,
+    provider: "github",
+    repository,
+    workflow,
+    runId,
+    runUrl,
+    inspectCommand: workflowInspectCommand(repository, runId),
+    failedJobName,
+    lastActiveStep,
+    conclusion,
+    retrySafe: input.retrySafe ?? true,
+    resumeSafe: input.resumeSafe ?? false,
+    blockerCode
+  };
+}
+async function dispatchGitHubWorkflowRun(repository, {
+  client = createGitHubApiClient(),
+  workflow = "deploy-web.yml",
+  branch,
+  inputs
+}) {
+  const { owner, name } = typeof repository === "string" ? parseGitHubRepositorySlug(repository) : repository;
+  try {
+    const result = await client.rest.actions.createWorkflowDispatch({
+      owner,
+      repo: name,
+      workflow_id: workflow,
+      ref: branch,
+      inputs
+    });
+    return {
+      repository: `${owner}/${name}`,
+      workflow,
+      branch,
+      inputs,
+      status: typeof result.status === "number" ? result.status : null,
+      dispatchedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch (error) {
+    throw normalizeGitHubApiError(error, `Unable to dispatch GitHub workflow ${workflow} in ${owner}/${name}`);
+  }
+}
+async function cancelGitHubWorkflowRun(repository, runId, { client = createGitHubApiClient() } = {}) {
+  if (!repository || !runId) {
+    return {
+      ok: false,
+      supported: false,
+      repository: typeof repository === "string" ? repository : null,
+      runId: null,
+      message: "GitHub workflow cancellation requires a repository and run id."
+    };
+  }
+  const { owner, name } = typeof repository === "string" ? parseGitHubRepositorySlug(repository) : repository;
+  const numericRunId = Number(runId);
+  if (!Number.isFinite(numericRunId) || numericRunId <= 0) {
+    return {
+      ok: false,
+      supported: false,
+      repository: `${owner}/${name}`,
+      runId: null,
+      message: "GitHub workflow cancellation requires a numeric run id."
+    };
+  }
+  try {
+    await client.rest.actions.cancelWorkflowRun({
+      owner,
+      repo: name,
+      run_id: numericRunId
+    });
+    return {
+      ok: true,
+      supported: true,
+      repository: `${owner}/${name}`,
+      runId: numericRunId,
+      url: `https://github.com/${owner}/${name}/actions/runs/${numericRunId}`,
+      message: "GitHub workflow cancellation requested.",
+      cancelledAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error ?? "");
+    if (/not supported|not found|404/iu.test(message)) {
+      return {
+        ok: false,
+        supported: false,
+        repository: `${owner}/${name}`,
+        runId: numericRunId,
+        message: "GitHub workflow cancellation is not supported for this run."
+      };
+    }
+    throw normalizeGitHubApiError(error, `Unable to cancel GitHub workflow run ${numericRunId} in ${owner}/${name}`);
+  }
+}
+async function getGitHubWorkflowFileStatus(repository, workflow = "deploy-web.yml", { client = createGitHubApiClient() } = {}) {
+  const { owner, name } = typeof repository === "string" ? parseGitHubRepositorySlug(repository) : repository;
+  const normalizedWorkflow = workflow.replace(/^\.github\/workflows\//u, "");
+  const path = `.github/workflows/${normalizedWorkflow}`;
+  try {
+    const result = await client.rest.repos.getContent({
+      owner,
+      repo: name,
+      path
+    });
+    const data = result.data;
+    return {
+      ok: true,
+      exists: true,
+      repository: `${owner}/${name}`,
+      workflow: normalizedWorkflow,
+      url: typeof data.html_url === "string" ? data.html_url : `https://github.com/${owner}/${name}/blob/HEAD/${path}`,
+      message: `${normalizedWorkflow} is present.`
+    };
+  } catch (error) {
+    const status = typeof error?.status === "number" ? error.status : null;
+    if (status === 404) {
+      return {
+        ok: true,
+        exists: false,
+        repository: `${owner}/${name}`,
+        workflow: normalizedWorkflow,
+        url: null,
+        message: `${normalizedWorkflow} is missing from ${owner}/${name}.`
+      };
+    }
+    throw normalizeGitHubApiError(error, `Unable to inspect GitHub workflow file ${path} in ${owner}/${name}`);
+  }
+}
+async function getLatestGitHubWorkflowRun(repository, {
+  client = createGitHubApiClient(),
+  workflow = "deploy-web.yml",
+  branch
+} = {}) {
+  const { owner, name } = typeof repository === "string" ? parseGitHubRepositorySlug(repository) : repository;
+  try {
+    const listed = await client.rest.actions.listWorkflowRuns({
+      owner,
+      repo: name,
+      workflow_id: workflow,
+      ...branch ? { branch } : {},
+      per_page: 1
+    });
+    const run = listed.data.workflow_runs[0] ?? null;
+    return run ? normalizeWorkflowRun(run) : null;
+  } catch (error) {
+    throw normalizeGitHubApiError(error, `Unable to inspect latest GitHub workflow run ${workflow} in ${owner}/${name}`);
+  }
+}
 async function listWorkflowJobsForProgress(client, owner, repo, runId) {
   try {
     const jobs = await client.rest.actions.listJobsForWorkflowRun({
@@ -717,11 +879,16 @@ async function ensureGitHubBranchFromBase(repository, branch, {
   }
 }
 export {
+  cancelGitHubWorkflowRun,
   createGitHubApiClient,
+  dispatchGitHubWorkflowRun,
   ensureGitHubActionsEnvironment,
   ensureGitHubBranchFromBase,
   ensureGitHubRepository,
+  formatGitHubWorkflowFailure,
   getGitHubRepository,
+  getGitHubWorkflowFileStatus,
+  getLatestGitHubWorkflowRun,
   listGitHubEnvironmentSecretNames,
   listGitHubEnvironmentVariableNames,
   listGitHubRepositorySecretNames,

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

@@ -3,7 +3,18 @@ export type TreeseedMailpitContainer = {
     image: string;
     ports: string;
 };
+type RunDocker = typeof runDocker;
+declare function runDocker(args: string[], options?: {}): import("child_process").SpawnSyncReturns<string>;
 export declare function dockerIsAvailable(): boolean;
-export declare function findRunningMailpitContainer(): any;
-export declare function stopKnownMailpitContainers(): boolean;
+export declare function findRunningMailpitContainer(options?: {
+    run?: RunDocker;
+}): {
+    name: string;
+    image: string;
+    ports: string;
+} | null;
+export declare function stopKnownMailpitContainers(options?: {
+    run?: RunDocker;
+}): boolean;
 export declare function streamKnownMailpitLogs(): void;
+export {};

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

@@ -1,6 +1,6 @@
 import { spawnSync } from "node:child_process";
 const EXPECTED_PORTS = ["1025->1025/tcp", "8025->8025/tcp"];
-const KNOWN_MAILPIT_NAMES = ["treeseed_mailpit", "karyon_docs_mailpit"];
+const KNOWN_MAILPIT_NAMES = ["treeseed_mailpit", "docs_mailpit"];
 function runDocker(args, options = {}) {
   return spawnSync("docker", args, {
     encoding: "utf8",
@@ -23,24 +23,29 @@ function dockerIsAvailable() {
   const result = runDocker(["ps", "--format", "{{.Names}}	{{.Image}}	{{.Ports}}"]);
   return result.status === 0;
 }
-function findRunningMailpitContainer() {
-  const result = runDocker(["ps", "--format", "{{.Names}}	{{.Image}}	{{.Ports}}"]);
+function findKnownMailpitContainers({ all = false, run = runDocker } = {}) {
+  const args = [
+    "ps",
+    ...all ? ["-a"] : [],
+    "--format",
+    "{{.Names}}	{{.Image}}	{{.Ports}}"
+  ];
+  const result = run(args);
   if (result.status !== 0) {
-    return null;
+    return [];
   }
-  return parseDockerPsOutput(result.stdout).find(isCompatibleMailpitContainer) ?? null;
+  return parseDockerPsOutput(result.stdout).filter(isCompatibleMailpitContainer);
 }
-function stopKnownMailpitContainers() {
-  const container = findRunningMailpitContainer();
-  if (!container) {
+function findRunningMailpitContainer(options = {}) {
+  return findKnownMailpitContainers(options).at(0) ?? null;
+}
+function stopKnownMailpitContainers(options = {}) {
+  const run = options.run ?? runDocker;
+  const containers = findKnownMailpitContainers({ all: true, run });
+  if (containers.length === 0) {
     return true;
   }
-  const stopResult = runDocker(["stop", container.name]);
-  if (stopResult.status !== 0) {
-    return false;
-  }
-  const removeResult = runDocker(["rm", "-f", container.name]);
-  return removeResult.status === 0;
+  return containers.every((container) => run(["rm", "-f", container.name]).status === 0);
 }
 function streamKnownMailpitLogs() {
   const container = findRunningMailpitContainer();

package/dist/operations/services/project-web-monitor.d.ts

@@ -0,0 +1,15 @@
+import { type GitHubApiClient } from './github-api.ts';
+import type { ProjectDeploymentEnvironment, ProjectWebMonitorResult } from '../../sdk-types.ts';
+export declare function buildProjectWebMonitorResult(input: {
+    environment: ProjectDeploymentEnvironment;
+    action?: string | null;
+    repository?: Record<string, unknown> | null;
+    workflowFile?: string | null;
+    target?: Record<string, unknown> | null;
+    externalWorkflow?: Record<string, unknown> | null;
+    workflowResult?: Record<string, any> | null;
+    githubClient?: GitHubApiClient | null;
+    fetchImpl?: typeof fetch | null;
+    mockExternal?: boolean;
+    dryRun?: boolean;
+}): Promise<ProjectWebMonitorResult>;

package/dist/operations/services/project-web-monitor.js

@@ -0,0 +1,260 @@
+import {
+  getGitHubWorkflowFileStatus,
+  getLatestGitHubWorkflowRun
+} from "./github-api.js";
+const FORBIDDEN_MONITOR_FIELDS = /* @__PURE__ */ new Set([
+  "capacityProviderId",
+  "laneId",
+  "grantId",
+  "workerPoolId",
+  "runtimeHostId",
+  "railwayServiceId",
+  "runnerToken"
+]);
+function text(value, fallback = "") {
+  return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+function objectValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function repositorySlug(repository) {
+  const record = objectValue(repository);
+  const owner = text(record.owner);
+  const name = text(record.name);
+  return owner && name ? `${owner}/${name}` : null;
+}
+function externalUrl(...values) {
+  for (const value of values) {
+    const raw = text(value);
+    if (!raw) continue;
+    try {
+      const url = new URL(raw);
+      if (url.protocol === "http:" || url.protocol === "https:") return url.href;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function redact(value) {
+  if (Array.isArray(value)) return value.map((entry) => redact(entry));
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(Object.entries(value).filter(([key]) => !FORBIDDEN_MONITOR_FIELDS.has(key)).filter(([key]) => !/(?:secret|token|password|apiKey|privateKey)/iu.test(key)).map(([key, entry]) => [key, redact(entry)]));
+}
+function check(input) {
+  return redact(input);
+}
+function workflowStatusFromConclusion(conclusion) {
+  if (conclusion === "success") return "passed";
+  if (conclusion === "cancelled" || conclusion === "failure" || conclusion === "timed_out") return "failed";
+  if (conclusion) return "warning";
+  return "warning";
+}
+function statusFromChecks(checks) {
+  if (checks.some((entry) => entry.status === "failed")) return "failed";
+  if (checks.some((entry) => entry.status === "warning")) return "degraded";
+  if (checks.some((entry) => entry.status === "passed")) return "healthy";
+  return "unknown";
+}
+function workflowRunCheck(input) {
+  const run = input.workflowResult?.runId ? input.workflowResult : input.latestWorkflowRun;
+  if (!run) {
+    return check({
+      key: "latest_workflow",
+      label: "Latest workflow",
+      status: "skipped",
+      source: "github",
+      summary: input.repository ? "No workflow run was recorded for this deployment yet." : "Repository is unavailable, so workflow state was skipped."
+    });
+  }
+  const conclusion = text(run.conclusion, "");
+  const runStatus = text(run.status, "");
+  const status = runStatus === "completed" ? workflowStatusFromConclusion(conclusion) : "warning";
+  const runId = Number(run.runId ?? run.id);
+  const inspectCommand = input.repository && Number.isFinite(runId) && runId > 0 ? `gh run view ${runId} --repo ${input.repository} --log-failed` : void 0;
+  return check({
+    key: "latest_workflow",
+    label: "Latest workflow",
+    status,
+    source: "github",
+    summary: status === "passed" ? `${input.workflowFile} completed successfully.` : runStatus === "completed" ? `${input.workflowFile} completed with conclusion ${conclusion || "unknown"}.` : `${input.workflowFile} is ${runStatus || "active"}.`,
+    url: externalUrl(run.url, run.runUrl),
+    ...inspectCommand ? { inspectCommand } : {}
+  });
+}
+async function workflowFileCheck(input) {
+  if (!input.repository) {
+    return check({
+      key: "workflow_file",
+      label: "Workflow file",
+      status: "failed",
+      source: "github",
+      summary: "GitHub repository is not configured."
+    });
+  }
+  if (input.mockExternal || input.dryRun) {
+    return check({
+      key: "workflow_file",
+      label: "Workflow file",
+      status: "passed",
+      source: "github",
+      summary: `${input.workflowFile} is assumed present in mock mode.`
+    });
+  }
+  if (!input.githubClient) {
+    return check({
+      key: "workflow_file",
+      label: "Workflow file",
+      status: "warning",
+      source: "github",
+      summary: "GitHub credentials are unavailable, so workflow file presence could not be verified."
+    });
+  }
+  const status = await getGitHubWorkflowFileStatus(input.repository, input.workflowFile, { client: input.githubClient }).catch((error) => ({
+    ok: false,
+    exists: null,
+    repository: input.repository,
+    workflow: input.workflowFile,
+    url: null,
+    message: error instanceof Error ? error.message : String(error)
+  }));
+  return check({
+    key: "workflow_file",
+    label: "Workflow file",
+    status: status.exists === true ? "passed" : status.exists === false ? "failed" : "warning",
+    source: "github",
+    summary: status.message,
+    ...status.url ? { url: status.url } : {}
+  });
+}
+async function fetchWithTimeout(fetchImpl, url, timeoutMs) {
+  if (typeof AbortSignal !== "undefined" && typeof AbortSignal.timeout === "function") {
+    return await fetchImpl(url, { method: "GET", signal: AbortSignal.timeout(timeoutMs) });
+  }
+  return await fetchImpl(url, { method: "GET" });
+}
+async function httpCheck(input) {
+  if (!input.url) {
+    return check({
+      key: "http_response",
+      label: "HTTP response",
+      status: "skipped",
+      source: "http",
+      summary: "No public URL is available for HTTP probing."
+    });
+  }
+  if (input.mockExternal || input.dryRun || !input.fetchImpl) {
+    return check({
+      key: "http_response",
+      label: "HTTP response",
+      status: input.mockExternal ? "passed" : "skipped",
+      source: "http",
+      url: input.url,
+      summary: input.mockExternal ? "Mock HTTP probe passed." : "HTTP probe skipped for this monitor run."
+    });
+  }
+  try {
+    const response = await fetchWithTimeout(input.fetchImpl, input.url, input.timeoutMs ?? 1e4);
+    const status = response.status >= 200 && response.status < 400 ? "passed" : response.status === 401 || response.status === 403 || response.status >= 500 ? "warning" : "failed";
+    return check({
+      key: "http_response",
+      label: "HTTP response",
+      status,
+      source: "http",
+      url: input.url,
+      summary: `HTTP probe returned ${response.status}.`
+    });
+  } catch (error) {
+    return check({
+      key: "http_response",
+      label: "HTTP response",
+      status: "failed",
+      source: "http",
+      url: input.url,
+      summary: error instanceof Error ? error.message : "HTTP probe failed."
+    });
+  }
+}
+async function buildProjectWebMonitorResult(input) {
+  const repository = repositorySlug(input.repository);
+  const workflowFile = text(input.workflowFile ?? input.repository?.workflowFile, "deploy-web.yml");
+  const target = objectValue(input.target);
+  const targetUrl = externalUrl(target.url, target.baseUrl, target.previewUrl, target.lastDeploymentUrl);
+  const latestWorkflowRun = !input.workflowResult && repository && input.githubClient ? await getLatestGitHubWorkflowRun(repository, {
+    client: input.githubClient,
+    workflow: workflowFile,
+    branch: text(input.repository?.branch, "") || null
+  }).catch(() => null) : null;
+  const checks = [
+    workflowRunCheck({
+      workflowResult: input.workflowResult ?? input.externalWorkflow ?? null,
+      latestWorkflowRun,
+      repository,
+      workflowFile
+    }),
+    await workflowFileCheck({
+      repository,
+      workflowFile,
+      githubClient: input.githubClient,
+      mockExternal: input.mockExternal,
+      dryRun: input.dryRun
+    }),
+    check({
+      key: "web_host",
+      label: "Web host",
+      status: Object.keys(target).length > 0 ? "passed" : "failed",
+      source: "market",
+      summary: Object.keys(target).length > 0 ? "Web host target is configured." : "Web host target is missing."
+    }),
+    check({
+      key: "target_url",
+      label: "Public URL",
+      status: targetUrl ? "passed" : "failed",
+      source: "market",
+      ...targetUrl ? { url: targetUrl } : {},
+      summary: targetUrl ? "Deployment target URL is recorded." : "Deployment target URL is missing."
+    }),
+    await httpCheck({
+      url: targetUrl,
+      fetchImpl: input.fetchImpl,
+      mockExternal: input.mockExternal,
+      dryRun: input.dryRun
+    }),
+    check({
+      key: "content_publish",
+      label: "Content publish",
+      status: input.action === "publish_content" ? "passed" : "skipped",
+      source: "sdk",
+      summary: input.action === "publish_content" ? "Content publish workflow completed." : "Content publish was not part of this action."
+    }),
+    check({
+      key: "d1_migration",
+      label: "D1 migration",
+      status: "skipped",
+      source: "sdk",
+      summary: "No D1 migration result was reported for this deployment."
+    }),
+    check({
+      key: "form_api_route",
+      label: "Form/API route",
+      status: "skipped",
+      source: "http",
+      summary: "No form/API route probe was configured for this project."
+    })
+  ];
+  const status = statusFromChecks(checks);
+  const warnings = checks.filter((entry) => entry.status === "warning").map((entry) => entry.summary);
+  const urls = [...new Set(checks.map((entry) => entry.url).filter((url) => Boolean(url)))];
+  const result = {
+    environment: input.environment,
+    status,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    checks,
+    urls,
+    warnings
+  };
+  return redact(result);
+}
+export {
+  buildProjectWebMonitorResult
+};

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

@@ -283,8 +283,8 @@ async function railwayGraphqlRequest({
   apiToken,
   apiUrl,
   fetchImpl = fetch,
-  timeoutMs = 15e3,
-  retries = 5
+  timeoutMs = 3e4,
+  retries = 8
 }) {
   const token = apiToken || resolveRailwayApiToken(env);
   if (!token) {

package/dist/operations.d.ts

@@ -2,6 +2,7 @@ export { TRESEED_OPERATION_SPECS, findTreeseedOperation, listTreeseedOperationNa
 export { collectTreeseedConfigSeedValues } from './operations/services/config-runtime.ts';
 export { createKnowledgeHubRepositories, defaultHubContentResolutionPolicy, executeKnowledgeHubLaunch, normalizeKnowledgeHubLaunchIntent, planKnowledgeHubLaunch, planKnowledgeHubRepositories, validateRepositoryHost, } from './operations/services/hub-launch.ts';
 export { TreeseedOperationsSdk } from './operations/runtime.ts';
+export { cancelGitHubWorkflowRun, dispatchGitHubWorkflowRun, formatGitHubWorkflowFailure, waitForGitHubWorkflowRunCompletion, type GitHubWorkflowCancellationResult, type GitHubWorkflowDispatchResult, type GitHubWorkflowFailureSummary, type GitHubWorkflowFailureSummaryInput, type GitHubWorkflowProgressEvent, } from './operations/services/github-api.ts';
 export type { HubContentResolutionPolicy, KnowledgeHubLaunchIntent, KnowledgeHubLaunchPhase, KnowledgeHubLaunchPlan, KnowledgeHubLaunchResult, KnowledgeHubRepositoryPlan, RepositoryHost, } from './operations/services/hub-launch.ts';
 export type { TreeseedOperationContext, TreeseedOperationImplementation, TreeseedOperationId, TreeseedOperationMetadata, TreeseedOperationProvider, TreeseedOperationProviderId, TreeseedOperationRequest, TreeseedOperationResult, TreeseedOperationGroup, } from './operations-types.ts';
 export { TreeseedOperationError } from './operations-types.ts';