@treeseed/sdk 0.12.62 → 0.13.0-rc.10

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

@@ -1,936 +0,0 @@
-import { Buffer } from "node:buffer";
-import { spawnSync } from "node:child_process";
-import { createRequire } from "node:module";
-import { Octokit } from "octokit";
-import { createTreeseedManagedToolEnv, resolveTreeseedToolBinary } from "../../managed-dependencies.js";
-import { resolveTreeseedGitHubToken } from "../../service-credentials.js";
-const require2 = createRequire(import.meta.url);
-const sodium = require2("libsodium-wrappers");
-const DEFAULT_GITHUB_API_TIMEOUT_MS = 6e4;
-function normalizeGitHubVisibility(value, fallback = "private") {
-  const normalized = typeof value === "string" ? value.trim().toLowerCase() : "";
-  return normalized === "public" || normalized === "internal" || normalized === "private" ? normalized : fallback;
-}
-function configuredEnvValue(env, key) {
-  const value = env?.[key];
-  return typeof value === "string" && value.trim() ? value.trim() : "";
-}
-function resolveGitHubApiToken(env = process.env) {
-  return resolveTreeseedGitHubToken(env);
-}
-function parseGitHubRepositorySlug(value) {
-  const normalized = String(value ?? "").trim().replace(/\.git$/u, "");
-  const [owner, ...rest] = normalized.split("/").filter(Boolean);
-  if (!owner || rest.length === 0) {
-    throw new Error(`Invalid GitHub repository slug "${value}". Expected owner/name.`);
-  }
-  return {
-    owner,
-    name: rest.join("/")
-  };
-}
-function createGitHubRequestSignal(timeoutMs = DEFAULT_GITHUB_API_TIMEOUT_MS, upstreamSignal) {
-  if (typeof AbortSignal !== "undefined" && typeof AbortSignal.timeout === "function") {
-    const timeoutSignal = AbortSignal.timeout(timeoutMs);
-    if (upstreamSignal) {
-      const abortSignalAny = AbortSignal.any;
-      return typeof abortSignalAny === "function" ? abortSignalAny([upstreamSignal, timeoutSignal]) : timeoutSignal;
-    }
-    return timeoutSignal;
-  }
-  return upstreamSignal ?? void 0;
-}
-function createGitHubTimeoutFetch(timeoutMs = DEFAULT_GITHUB_API_TIMEOUT_MS) {
-  const baseFetch = globalThis.fetch.bind(globalThis);
-  return ((input, init) => {
-    const signal = createGitHubRequestSignal(timeoutMs, init?.signal ?? null);
-    return baseFetch(input, signal ? { ...init, signal } : init);
-  });
-}
-function normalizeGitHubApiError(error, context) {
-  if (error && typeof error === "object") {
-    const status = typeof error.status === "number" ? error.status : null;
-    const message = typeof error.message === "string" ? error.message.trim() : "";
-    if (status === 401 || status === 403) {
-      return new Error(`${context}: GitHub authentication failed.`);
-    }
-    if (status === 404) {
-      return new Error(`${context}: GitHub resource was not found.`);
-    }
-    if (status === 422) {
-      return new Error(`${context}: ${message || "GitHub rejected the request."}`);
-    }
-    if (status && message) {
-      return new Error(`${context}: ${message}`);
-    }
-  }
-  if (error instanceof Error && error.message.trim()) {
-    return new Error(`${context}: ${error.message.trim()}`);
-  }
-  return new Error(`${context}: GitHub API request failed.`);
-}
-function isRetriableGitHubApiError(error) {
-  const message = error instanceof Error ? error.message : String(error ?? "");
-  return /timed out|timeout|aborted|ECONNRESET|ECONNREFUSED|fetch failed|socket hang up/iu.test(message);
-}
-async function withGitHubApiRetries(operation, retries = 2) {
-  let attempt = 0;
-  let lastError;
-  while (attempt <= retries) {
-    try {
-      return await operation();
-    } catch (error) {
-      lastError = error;
-      if (attempt >= retries || !isRetriableGitHubApiError(error)) {
-        throw error;
-      }
-      await sleep(1e3 * (attempt + 1));
-      attempt += 1;
-    }
-  }
-  throw lastError instanceof Error ? lastError : new Error(String(lastError ?? "GitHub API request failed."));
-}
-function normalizeRepositorySummary(repository) {
-  return {
-    id: Number(repository.id ?? 0),
-    owner: String(repository.owner?.login ?? repository.owner?.name ?? ""),
-    name: String(repository.name ?? ""),
-    slug: `${String(repository.owner?.login ?? repository.owner?.name ?? "")}/${String(repository.name ?? "")}`,
-    url: String(repository.html_url ?? repository.url ?? ""),
-    sshUrl: String(repository.ssh_url ?? ""),
-    httpsUrl: String(repository.clone_url ?? ""),
-    defaultBranch: String(repository.default_branch ?? "main"),
-    visibility: normalizeGitHubVisibility(repository.visibility, repository.private ? "private" : "public")
-  };
-}
-function createGitHubApiClient({
-  env = process.env,
-  timeoutMs = DEFAULT_GITHUB_API_TIMEOUT_MS
-} = {}) {
-  const token = resolveGitHubApiToken(env);
-  if (!token) {
-    throw new Error("Configure TREESEED_GITHUB_TOKEN before using Treeseed GitHub automation.");
-  }
-  return new Octokit({
-    auth: token,
-    request: {
-      fetch: createGitHubTimeoutFetch(timeoutMs)
-    }
-  });
-}
-async function getGitHubRepository(repository, { client = createGitHubApiClient() } = {}) {
-  const { owner, name } = typeof repository === "string" ? parseGitHubRepositorySlug(repository) : repository;
-  try {
-    const response = await client.rest.repos.get({ owner, repo: name });
-    return normalizeRepositorySummary(response.data);
-  } catch (error) {
-    throw normalizeGitHubApiError(error, `Unable to load GitHub repository ${owner}/${name}`);
-  }
-}
-async function maybeGetGitHubRepository(repository, { client = createGitHubApiClient() } = {}) {
-  try {
-    return await getGitHubRepository(repository, { client });
-  } catch (error) {
-    if (/not found/iu.test(error instanceof Error ? error.message : String(error ?? ""))) {
-      return null;
-    }
-    throw error;
-  }
-}
-async function ensureGitHubRepository(input, { client = createGitHubApiClient() } = {}) {
-  const existing = await maybeGetGitHubRepository({ owner: input.owner, name: input.name }, { client });
-  let repository = existing;
-  if (!repository) {
-    try {
-      const viewer = await client.rest.users.getAuthenticated();
-      if (viewer.data.login === input.owner) {
-        const created = await client.rest.repos.createForAuthenticatedUser({
-          name: input.name,
-          description: input.description ?? void 0,
-          homepage: input.homepageUrl ?? void 0,
-          private: (input.visibility ?? "private") !== "public"
-        });
-        repository = normalizeRepositorySummary(created.data);
-      } else {
-        const created = await client.rest.repos.createInOrg({
-          org: input.owner,
-          name: input.name,
-          description: input.description ?? void 0,
-          homepage: input.homepageUrl ?? void 0,
-          visibility: input.visibility ?? "private"
-        });
-        repository = normalizeRepositorySummary(created.data);
-      }
-    } catch (error) {
-      throw normalizeGitHubApiError(error, `Unable to create GitHub repository ${input.owner}/${input.name}`);
-    }
-  }
-  try {
-    const updated = await client.rest.repos.update({
-      owner: input.owner,
-      repo: input.name,
-      name: input.name,
-      description: input.description ?? void 0,
-      homepage: input.homepageUrl ?? void 0,
-      private: (input.visibility ?? repository.visibility ?? "private") === "private",
-      visibility: input.visibility ?? repository.visibility
-    });
-    repository = normalizeRepositorySummary(updated.data);
-    if (Array.isArray(input.topics)) {
-      await client.rest.repos.replaceAllTopics({
-        owner: input.owner,
-        repo: input.name,
-        names: input.topics
-      });
-    }
-    return repository;
-  } catch (error) {
-    throw normalizeGitHubApiError(error, `Unable to update GitHub repository ${input.owner}/${input.name}`);
-  }
-}
-async function paginateNames(request) {
-  const items = await request();
-  return new Set(
-    items.map((entry) => typeof entry?.name === "string" ? entry.name.trim() : "").filter(Boolean)
-  );
-}
-async function listGitHubRepositorySecretNames(repository, { client = createGitHubApiClient() } = {}) {
-  const { owner, name } = typeof repository === "string" ? parseGitHubRepositorySlug(repository) : repository;
-  try {
-    return await withGitHubApiRetries(() => paginateNames(
-      () => client.paginate(client.rest.actions.listRepoSecrets, {
-        owner,
-        repo: name,
-        per_page: 100
-      })
-    ));
-  } catch (error) {
-    throw normalizeGitHubApiError(error, `Unable to list GitHub secrets for ${owner}/${name}`);
-  }
-}
-async function listGitHubRepositoryVariableNames(repository, { client = createGitHubApiClient() } = {}) {
-  const { owner, name } = typeof repository === "string" ? parseGitHubRepositorySlug(repository) : repository;
-  try {
-    return await withGitHubApiRetries(() => paginateNames(
-      () => client.paginate(client.rest.actions.listRepoVariables, {
-        owner,
-        repo: name,
-        per_page: 100
-      })
-    ));
-  } catch (error) {
-    throw normalizeGitHubApiError(error, `Unable to list GitHub variables for ${owner}/${name}`);
-  }
-}
-async function ensureGitHubActionsEnvironment(repository, environmentName, {
-  client = createGitHubApiClient(),
-  branchName,
-  tagName
-} = {}) {
-  const { owner, name: repo } = typeof repository === "string" ? parseGitHubRepositorySlug(repository) : repository;
-  const desiredPolicies = [
-    ...branchName ? [{ name: branchName, type: "branch" }] : [],
-    ...tagName ? [{ name: tagName, type: "tag" }] : []
-  ];
-  try {
-    await withGitHubApiRetries(() => client.request("PUT /repos/{owner}/{repo}/environments/{environment_name}", {
-      owner,
-      repo,
-      environment_name: environmentName,
-      ...desiredPolicies.length > 0 ? {
-        deployment_branch_policy: {
-          protected_branches: false,
-          custom_branch_policies: true
-        }
-      } : {}
-    }));
-    if (desiredPolicies.length > 0) {
-      await ensureGitHubEnvironmentDeploymentPolicies(client, {
-        owner,
-        repo,
-        environmentName,
-        policies: desiredPolicies
-      });
-    }
-    return { repository: `${owner}/${repo}`, environment: environmentName };
-  } catch (error) {
-    throw normalizeGitHubApiError(error, `Unable to ensure GitHub environment ${environmentName} for ${owner}/${repo}`);
-  }
-}
-async function ensureGitHubEnvironmentDeploymentPolicies(client, {
-  owner,
-  repo,
-  environmentName,
-  policies: desiredPolicies
-}) {
-  const response = await withGitHubApiRetries(() => client.request(
-    "GET /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies",
-    {
-      owner,
-      repo,
-      environment_name: environmentName,
-      per_page: 100
-    }
-  ));
-  const policies = Array.isArray(response.data?.branch_policies) ? response.data.branch_policies : [];
-  const desiredKey = (policy) => `${policy.type ?? "branch"}:${policy.name ?? ""}`;
-  const desiredKeys = new Set(desiredPolicies.map((policy) => desiredKey(policy)));
-  for (const policy of policies) {
-    if (!policy.id || desiredKeys.has(desiredKey(policy))) {
-      continue;
-    }
-    await withGitHubApiRetries(() => client.request(
-      "DELETE /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies/{branch_policy_id}",
-      {
-        owner,
-        repo,
-        environment_name: environmentName,
-        branch_policy_id: policy.id
-      }
-    ));
-  }
-  const existingKeys = new Set(policies.map((policy) => desiredKey(policy)));
-  for (const policy of desiredPolicies) {
-    if (existingKeys.has(desiredKey(policy))) {
-      continue;
-    }
-    try {
-      await withGitHubApiRetries(() => client.request(
-        "POST /repos/{owner}/{repo}/environments/{environment_name}/deployment-branch-policies",
-        {
-          owner,
-          repo,
-          environment_name: environmentName,
-          name: policy.name,
-          type: policy.type
-        }
-      ));
-    } catch (error) {
-      if (error && typeof error === "object" && error.status === 303) {
-        continue;
-      }
-      throw error;
-    }
-  }
-}
-async function paginateGitHubEnvironmentNames(client, route, params) {
-  const paginate = client.paginate;
-  return await paginateNames(() => paginate(route, {
-    ...params,
-    per_page: 100
-  }));
-}
-async function listGitHubEnvironmentSecretNames(repository, environmentName, { client = createGitHubApiClient() } = {}) {
-  const { owner, name } = typeof repository === "string" ? parseGitHubRepositorySlug(repository) : repository;
-  try {
-    return await withGitHubApiRetries(() => paginateGitHubEnvironmentNames(
-      client,
-      "GET /repos/{owner}/{repo}/environments/{environment_name}/secrets",
-      { owner, repo: name, environment_name: environmentName }
-    ));
-  } catch (error) {
-    throw normalizeGitHubApiError(error, `Unable to list GitHub environment secrets for ${owner}/${name}:${environmentName}`);
-  }
-}
-async function listGitHubEnvironmentVariableNames(repository, environmentName, { client = createGitHubApiClient() } = {}) {
-  const { owner, name } = typeof repository === "string" ? parseGitHubRepositorySlug(repository) : repository;
-  try {
-    return await withGitHubApiRetries(() => paginateGitHubEnvironmentNames(
-      client,
-      "GET /repos/{owner}/{repo}/environments/{environment_name}/variables",
-      { owner, repo: name, environment_name: environmentName }
-    ));
-  } catch (error) {
-    throw normalizeGitHubApiError(error, `Unable to list GitHub environment variables for ${owner}/${name}:${environmentName}`);
-  }
-}
-async function listGitHubEnvironmentVariables(repository, environmentName, { client = createGitHubApiClient() } = {}) {
-  const { owner, name } = typeof repository === "string" ? parseGitHubRepositorySlug(repository) : repository;
-  try {
-    const paginate = client.paginate;
-    const variables = await withGitHubApiRetries(() => paginate(
-      "GET /repos/{owner}/{repo}/environments/{environment_name}/variables",
-      { owner, repo: name, environment_name: environmentName, per_page: 100 }
-    ));
-    return new Map(variables.map((entry) => [String(entry.name ?? "").trim(), String(entry.value ?? "")]).filter(([variableName]) => variableName.length > 0));
-  } catch (error) {
-    throw normalizeGitHubApiError(error, `Unable to list GitHub environment variables for ${owner}/${name}:${environmentName}`);
-  }
-}
-async function encryptGitHubSecret(secret, key) {
-  await sodium.ready;
-  const messageBytes = Buffer.from(secret);
-  const keyBytes = Buffer.from(key, "base64");
-  return Buffer.from(sodium.crypto_box_seal(messageBytes, keyBytes)).toString("base64");
-}
-async function upsertGitHubRepositorySecret(repository, name, value, { client = createGitHubApiClient() } = {}) {
-  const { owner, name: repo } = typeof repository === "string" ? parseGitHubRepositorySlug(repository) : repository;
-  try {
-    const key = await client.rest.actions.getRepoPublicKey({
-      owner,
-      repo
-    });
-    const encryptedValue = await encryptGitHubSecret(value, key.data.key);
-    await withGitHubApiRetries(() => client.rest.actions.createOrUpdateRepoSecret({
-      owner,
-      repo,
-      secret_name: name,
-      encrypted_value: encryptedValue,
-      key_id: key.data.key_id
-    }));
-  } catch (error) {
-    throw normalizeGitHubApiError(error, `Unable to upsert GitHub secret ${name} for ${owner}/${repo}`);
-  }
-}
-async function upsertGitHubEnvironmentSecret(repository, environmentName, name, value, { client = createGitHubApiClient() } = {}) {
-  const { owner, name: repo } = typeof repository === "string" ? parseGitHubRepositorySlug(repository) : repository;
-  try {
-    const key = await client.request("GET /repos/{owner}/{repo}/environments/{environment_name}/secrets/public-key", {
-      owner,
-      repo,
-      environment_name: environmentName
-    });
-    const encryptedValue = await encryptGitHubSecret(value, String(key.data.key ?? ""));
-    await withGitHubApiRetries(() => client.request("PUT /repos/{owner}/{repo}/environments/{environment_name}/secrets/{secret_name}", {
-      owner,
-      repo,
-      environment_name: environmentName,
-      secret_name: name,
-      encrypted_value: encryptedValue,
-      key_id: String(key.data.key_id ?? "")
-    }));
-  } catch (error) {
-    throw normalizeGitHubApiError(error, `Unable to upsert GitHub environment secret ${name} for ${owner}/${repo}:${environmentName}`);
-  }
-}
-async function upsertGitHubRepositoryVariable(repository, name, value, { client = createGitHubApiClient() } = {}) {
-  const { owner, name: repo } = typeof repository === "string" ? parseGitHubRepositorySlug(repository) : repository;
-  try {
-    const createOrUpdateRepoVariable = client.rest.actions.createOrUpdateRepoVariable;
-    if (typeof createOrUpdateRepoVariable === "function") {
-      await withGitHubApiRetries(() => createOrUpdateRepoVariable({
-        owner,
-        repo,
-        name,
-        value
-      }));
-      return;
-    }
-    await withGitHubApiRetries(async () => {
-      try {
-        await client.request("POST /repos/{owner}/{repo}/actions/variables", {
-          owner,
-          repo,
-          name,
-          value
-        });
-        return;
-      } catch (error) {
-        const status = typeof error?.status === "number" ? Number(error.status) : null;
-        const message = error instanceof Error ? error.message : String(error ?? "");
-        if (status !== 409 && status !== 422 && !/already exists/iu.test(message)) {
-          throw error;
-        }
-      }
-      await client.request("PATCH /repos/{owner}/{repo}/actions/variables/{name}", {
-        owner,
-        repo,
-        name,
-        value
-      });
-    });
-  } catch (error) {
-    throw normalizeGitHubApiError(error, `Unable to upsert GitHub variable ${name} for ${owner}/${repo}`);
-  }
-}
-async function upsertGitHubEnvironmentVariable(repository, environmentName, name, value, { client = createGitHubApiClient() } = {}) {
-  const { owner, name: repo } = typeof repository === "string" ? parseGitHubRepositorySlug(repository) : repository;
-  try {
-    await withGitHubApiRetries(async () => {
-      try {
-        await client.request("POST /repos/{owner}/{repo}/environments/{environment_name}/variables", {
-          owner,
-          repo,
-          environment_name: environmentName,
-          name,
-          value
-        });
-        return;
-      } catch (error) {
-        const status = typeof error?.status === "number" ? Number(error.status) : null;
-        const message = error instanceof Error ? error.message : String(error ?? "");
-        if (status !== 409 && status !== 422 && !/already exists/iu.test(message)) {
-          throw error;
-        }
-      }
-      await client.request("PATCH /repos/{owner}/{repo}/environments/{environment_name}/variables/{name}", {
-        owner,
-        repo,
-        environment_name: environmentName,
-        name,
-        value
-      });
-    });
-  } catch (error) {
-    throw normalizeGitHubApiError(error, `Unable to upsert GitHub environment variable ${name} for ${owner}/${repo}:${environmentName}`);
-  }
-}
-function upsertGitHubRepositoryVariableWithGhCli(repository, name, value, {
-  env = process.env
-} = {}) {
-  const token = resolveGitHubApiToken(env);
-  if (!token) {
-    throw new Error("Configure TREESEED_GITHUB_TOKEN before using Treeseed GitHub automation.");
-  }
-  const { owner, name: repo } = typeof repository === "string" ? parseGitHubRepositorySlug(repository) : repository;
-  const ghEnv = {
-    ...process.env,
-    ...env,
-    GH_TOKEN: token,
-    GITHUB_TOKEN: token
-  };
-  const gh = resolveTreeseedToolBinary("gh", { env: ghEnv });
-  if (!gh) {
-    throw new Error("GitHub CLI `gh` is unavailable.");
-  }
-  const create = spawnSync(
-    gh,
-    [
-      "api",
-      `repos/${owner}/${repo}/actions/variables`,
-      "--method",
-      "POST",
-      "-f",
-      `name=${name}`,
-      "-f",
-      `value=${value}`
-    ],
-    { encoding: "utf8", env: createTreeseedManagedToolEnv(ghEnv) }
-  );
-  if (create.status === 0) {
-    return;
-  }
-  const combinedCreateOutput = `${create.stdout ?? ""}
-${create.stderr ?? ""}`.trim();
-  if (!/already exists|HTTP 409|HTTP 422/iu.test(combinedCreateOutput)) {
-    throw new Error(combinedCreateOutput || `gh api exited with status ${create.status ?? 1}`);
-  }
-  const update = spawnSync(
-    gh,
-    [
-      "api",
-      `repos/${owner}/${repo}/actions/variables/${name}`,
-      "--method",
-      "PATCH",
-      "-f",
-      `name=${name}`,
-      "-f",
-      `value=${value}`
-    ],
-    { encoding: "utf8", env: createTreeseedManagedToolEnv(ghEnv) }
-  );
-  if (update.status === 0) {
-    return;
-  }
-  const combinedUpdateOutput = `${update.stdout ?? ""}
-${update.stderr ?? ""}`.trim();
-  throw new Error(combinedUpdateOutput || `gh api exited with status ${update.status ?? 1}`);
-}
-function normalizeWorkflowRun(run) {
-  return {
-    id: Number(run.id ?? 0),
-    status: typeof run.status === "string" ? run.status : null,
-    conclusion: typeof run.conclusion === "string" ? run.conclusion : null,
-    url: typeof run.html_url === "string" ? run.html_url : null,
-    headSha: typeof run.head_sha === "string" ? run.head_sha : null,
-    headBranch: typeof run.head_branch === "string" ? run.head_branch : null,
-    createdAt: typeof run.created_at === "string" ? run.created_at : null,
-    updatedAt: typeof run.updated_at === "string" ? run.updated_at : null
-  };
-}
-function normalizeWorkflowJob(job) {
-  return {
-    id: Number(job.id ?? 0),
-    name: String(job.name ?? ""),
-    status: typeof job.status === "string" ? job.status : null,
-    conclusion: typeof job.conclusion === "string" ? job.conclusion : null,
-    url: typeof job.html_url === "string" ? job.html_url : null,
-    steps: Array.isArray(job.steps) ? job.steps.map((step) => ({
-      name: String(step.name ?? ""),
-      status: typeof step.status === "string" ? step.status : null,
-      conclusion: typeof step.conclusion === "string" ? step.conclusion : null
-    })) : []
-  };
-}
-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({
-      owner,
-      repo,
-      run_id: runId,
-      per_page: 100
-    });
-    return jobs.data.jobs.map((job) => normalizeWorkflowJob(job));
-  } catch {
-    return [];
-  }
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function waitForGitHubWorkflowRunCompletion(repository, {
-  client = createGitHubApiClient(),
-  workflow = "publish.yml",
-  headSha,
-  branch,
-  timeoutSeconds = 600,
-  pollSeconds = 5,
-  dispatchIfMissing = false,
-  dispatchAfterSeconds = 60,
-  dispatchInputs,
-  onProgress
-} = {}) {
-  const { owner, name } = typeof repository === "string" ? parseGitHubRepositorySlug(repository) : repository;
-  const startedAt = Date.now();
-  let dispatchedMissingRun = false;
-  let lastProgress = null;
-  let monitorErrorStartedAt = null;
-  let lastMonitorError = null;
-  const emitProgress = (type, run = null, jobs = []) => {
-    const completedJobs = jobs.filter((job) => job.status === "completed");
-    const failedJobs = jobs.filter((job) => job.conclusion && job.conclusion !== "success" && job.conclusion !== "skipped");
-    const activeJobs = jobs.filter((job) => job.status && job.status !== "completed");
-    const event = {
-      type,
-      repository: `${owner}/${name}`,
-      workflow,
-      branch: run?.headBranch ?? branch ?? null,
-      headSha: run?.headSha ?? headSha ?? null,
-      elapsedSeconds: Math.max(0, Math.round((Date.now() - startedAt) / 1e3)),
-      runId: run?.id ?? null,
-      url: run?.url ?? null,
-      status: run?.status ?? null,
-      conclusion: run?.conclusion ?? null,
-      jobs,
-      activeJobs,
-      completedJobs,
-      failedJobs
-    };
-    lastProgress = event;
-    onProgress?.(event);
-  };
-  while (Date.now() - startedAt < timeoutSeconds * 1e3) {
-    try {
-      const listed = await client.rest.actions.listWorkflowRuns({
-        owner,
-        repo: name,
-        workflow_id: workflow,
-        per_page: 20
-      });
-      monitorErrorStartedAt = null;
-      lastMonitorError = null;
-      const matchingRuns = listed.data.workflow_runs.map((run) => normalizeWorkflowRun(run)).filter((run) => (!headSha || run.headSha === headSha) && (!branch || run.headBranch === branch));
-      const match = matchingRuns[0];
-      if (!match?.id) {
-        emitProgress("waiting");
-        if (dispatchIfMissing && branch && !dispatchedMissingRun && Date.now() - startedAt >= dispatchAfterSeconds * 1e3) {
-          try {
-            await client.rest.actions.createWorkflowDispatch({
-              owner,
-              repo: name,
-              workflow_id: workflow,
-              ref: branch,
-              inputs: dispatchInputs
-            });
-            dispatchedMissingRun = true;
-          } catch (error) {
-            throw normalizeGitHubApiError(error, `Unable to dispatch GitHub workflow ${workflow} in ${owner}/${name}`);
-          }
-        }
-        await sleep(pollSeconds * 1e3);
-        continue;
-      }
-      for (; ; ) {
-        if (Date.now() - startedAt >= timeoutSeconds * 1e3 && lastProgress?.runId === match.id) {
-          break;
-        }
-        const current = await client.rest.actions.getWorkflowRun({
-          owner,
-          repo: name,
-          run_id: match.id
-        });
-        monitorErrorStartedAt = null;
-        lastMonitorError = null;
-        const normalized = normalizeWorkflowRun(current.data);
-        const progressJobs = await listWorkflowJobsForProgress(client, owner, name, match.id);
-        if (normalized.status === "completed") {
-          const normalizedJobs = progressJobs;
-          emitProgress("completed", normalized, normalizedJobs);
-          return {
-            status: "completed",
-            repository: `${owner}/${name}`,
-            workflow,
-            runId: normalized.id,
-            headSha: normalized.headSha,
-            branch: normalized.headBranch,
-            createdAt: normalized.createdAt,
-            updatedAt: normalized.updatedAt,
-            conclusion: normalized.conclusion,
-            url: normalized.url,
-            jobs: normalizedJobs,
-            failedJobs: normalizedJobs.filter((job) => job.conclusion && job.conclusion !== "success" && job.conclusion !== "skipped")
-          };
-        }
-        emitProgress("running", normalized, progressJobs);
-        await sleep(pollSeconds * 1e3);
-      }
-    } catch (error) {
-      const normalizedError = normalizeGitHubApiError(error, `Unable to monitor GitHub workflow ${workflow} in ${owner}/${name}`);
-      lastMonitorError = normalizedError;
-      monitorErrorStartedAt ??= Date.now();
-      const toleratedMonitorErrorSeconds = Math.max(pollSeconds * 2, 120);
-      if (Date.now() - monitorErrorStartedAt < toleratedMonitorErrorSeconds * 1e3) {
-        await sleep(pollSeconds * 1e3);
-        continue;
-      }
-      throw normalizedError;
-    }
-  }
-  const lastState = lastProgress ? ` Last known state: run ${lastProgress.runId ?? "(not created)"} ${lastProgress.status ?? "waiting"}${lastProgress.conclusion ? `/${lastProgress.conclusion}` : ""}${lastProgress.url ? ` ${lastProgress.url}` : ""}.` : "";
-  const monitorErrorState = lastMonitorError ? ` Last monitor error: ${lastMonitorError.message}` : "";
-  throw new Error(`Timed out waiting for GitHub workflow ${workflow} in ${owner}/${name}.${lastState}${monitorErrorState}`);
-}
-async function ensureGitHubBranchFromBase(repository, branch, {
-  baseBranch = "main",
-  client = createGitHubApiClient()
-} = {}) {
-  const { owner, name } = typeof repository === "string" ? parseGitHubRepositorySlug(repository) : repository;
-  try {
-    const existing = await client.rest.repos.getBranch({
-      owner,
-      repo: name,
-      branch
-    });
-    return {
-      branch,
-      baseBranch,
-      existed: true,
-      created: false,
-      sha: existing.data.commit.sha
-    };
-  } catch (error) {
-    if (!/not found/iu.test(error instanceof Error ? error.message : String(error ?? ""))) {
-      throw normalizeGitHubApiError(error, `Unable to resolve GitHub branch ${branch} in ${owner}/${name}`);
-    }
-  }
-  try {
-    const base = await client.rest.repos.getBranch({
-      owner,
-      repo: name,
-      branch: baseBranch
-    });
-    await client.rest.git.createRef({
-      owner,
-      repo: name,
-      ref: `refs/heads/${branch}`,
-      sha: base.data.commit.sha
-    });
-    return {
-      branch,
-      baseBranch,
-      existed: false,
-      created: true,
-      sha: base.data.commit.sha
-    };
-  } catch (error) {
-    throw normalizeGitHubApiError(error, `Unable to create GitHub branch ${branch} from ${baseBranch} in ${owner}/${name}`);
-  }
-}
-export {
-  cancelGitHubWorkflowRun,
-  createGitHubApiClient,
-  dispatchGitHubWorkflowRun,
-  ensureGitHubActionsEnvironment,
-  ensureGitHubBranchFromBase,
-  ensureGitHubRepository,
-  formatGitHubWorkflowFailure,
-  getGitHubRepository,
-  getGitHubWorkflowFileStatus,
-  getLatestGitHubWorkflowRun,
-  listGitHubEnvironmentSecretNames,
-  listGitHubEnvironmentVariableNames,
-  listGitHubEnvironmentVariables,
-  listGitHubRepositorySecretNames,
-  listGitHubRepositoryVariableNames,
-  maybeGetGitHubRepository,
-  parseGitHubRepositorySlug,
-  resolveGitHubApiToken,
-  upsertGitHubEnvironmentSecret,
-  upsertGitHubEnvironmentVariable,
-  upsertGitHubRepositorySecret,
-  upsertGitHubRepositoryVariable,
-  upsertGitHubRepositoryVariableWithGhCli,
-  waitForGitHubWorkflowRunCompletion
-};