@postman-cse/onboarding-bootstrap 0.10.0 → 0.12.0

package/src/lib/postman/workspace-selection.ts

@@ -1,121 +0,0 @@
-import { normalizeGitRepoUrl } from './postman-assets-client.js';
-
-type WorkspaceCandidate = {
-  id: string;
-  linkedRepoUrl?: string | null;
-};
-
-type ChooseCanonicalWorkspaceArgs = {
-  repoWorkspaceId?: string;
-  repoUrl: string;
-  matchingWorkspaces: WorkspaceCandidate[];
-};
-
-type WorkspaceLookupClient = {
-  findWorkspacesByName(name: string): Promise<Array<{ id: string; name: string }>>;
-  getWorkspaceGitRepoUrl(workspaceId: string, teamId: string, accessToken: string): Promise<string | null>;
-};
-
-type RepoVariableClient = {
-  setRepositoryVariable(name: string, value: string): Promise<unknown>;
-};
-
-export type CanonicalWorkspaceSelection =
-  | { type: 'existing'; workspaceId: string; source: 'linked_match' | 'repo_var' | 'name_match'; warning?: string }
-  | { type: 'create' }
-  | { type: 'manual_review'; reason: string };
-
-export function chooseCanonicalWorkspace(args: ChooseCanonicalWorkspaceArgs): CanonicalWorkspaceSelection {
-  const repoWorkspaceId = String(args.repoWorkspaceId || '').trim();
-  const normalizedRepoUrl = normalizeGitRepoUrl(args.repoUrl);
-  const matchingWorkspaces = [...args.matchingWorkspaces].sort((a, b) => a.id.localeCompare(b.id));
-
-  const linkedMatches = matchingWorkspaces.filter((workspace) =>
-    normalizeGitRepoUrl(workspace.linkedRepoUrl) === normalizedRepoUrl,
-  );
-
-  if (linkedMatches.length === 1) {
-    const linked = linkedMatches[0];
-    return {
-      type: 'existing',
-      workspaceId: linked.id,
-      source: 'linked_match',
-      warning: repoWorkspaceId && repoWorkspaceId !== linked.id
-        ? `Replacing repo workspace ${repoWorkspaceId} with canonical GitHub-linked workspace ${linked.id}`
-        : undefined,
-    };
-  }
-
-  if (linkedMatches.length > 1) {
-    if (repoWorkspaceId && linkedMatches.some((workspace) => workspace.id === repoWorkspaceId)) {
-      return {
-        type: 'existing',
-        workspaceId: repoWorkspaceId,
-        source: 'linked_match',
-        warning: `Multiple GitHub-linked workspaces matched ${normalizedRepoUrl}; keeping existing linked repo workspace ${repoWorkspaceId} until manual cleanup.`,
-      };
-    }
-    return {
-      type: 'manual_review',
-      reason: `Multiple GitHub-linked workspaces matched ${normalizedRepoUrl}: ${linkedMatches.map((workspace) => workspace.id).join(', ')}`,
-    };
-  }
-
-  if (repoWorkspaceId) {
-    const candidate = matchingWorkspaces.find((w) => w.id === repoWorkspaceId);
-    if (candidate && candidate.linkedRepoUrl && normalizeGitRepoUrl(candidate.linkedRepoUrl) !== normalizedRepoUrl) {
-      return { type: 'create' };
-    }
-    return {
-      type: 'existing',
-      workspaceId: repoWorkspaceId,
-      source: 'repo_var',
-    };
-  }
-
-  if (matchingWorkspaces.length > 0) {
-    const candidate = matchingWorkspaces[0];
-    if (candidate.linkedRepoUrl && normalizeGitRepoUrl(candidate.linkedRepoUrl) !== normalizedRepoUrl) {
-      return { type: 'create' };
-    }
-    return {
-      type: 'existing',
-      workspaceId: candidate.id,
-      source: 'name_match',
-    };
-  }
-
-  return { type: 'create' };
-}
-
-export async function resolveCanonicalWorkspaceSelection(args: {
-  postman: WorkspaceLookupClient;
-  workspaceName: string;
-  repoWorkspaceId?: string;
-  repoUrl: string;
-  teamId: string;
-  accessToken: string;
-  warn?: (message: string) => void;
-}): Promise<CanonicalWorkspaceSelection> {
-  let matchingWorkspaces: Array<{ id: string; name: string; linkedRepoUrl?: string | null }> = [];
-
-  try {
-    matchingWorkspaces = await args.postman.findWorkspacesByName(args.workspaceName);
-  } catch (error) {
-    if (!args.repoWorkspaceId) throw error;
-    args.warn?.(`Workspace duplicate check failed; falling back to repo workspace ${args.repoWorkspaceId}: ${error}`);
-  }
-
-  if (matchingWorkspaces.length > 0) {
-    matchingWorkspaces = await Promise.all(matchingWorkspaces.map(async (workspace) => ({
-      ...workspace,
-      linkedRepoUrl: await args.postman.getWorkspaceGitRepoUrl(workspace.id, args.teamId, args.accessToken),
-    })));
-  }
-
-  return chooseCanonicalWorkspace({
-    repoWorkspaceId: args.repoWorkspaceId,
-    repoUrl: args.repoUrl,
-    matchingWorkspaces,
-  });
-}

package/src/lib/repo/context.ts

@@ -1,119 +0,0 @@
-export type GitProvider = 'github' | 'gitlab' | 'bitbucket' | 'azure-devops' | 'unknown';
-
-export interface RepoContextInput {
-  repoUrl?: string;
-  repoSlug?: string;
-  gitProvider?: string;
-  ref?: string;
-  sha?: string;
-}
-
-export interface RepoContext {
-  provider: GitProvider;
-  repoUrl?: string;
-  repoSlug?: string;
-  ref?: string;
-  sha?: string;
-}
-
-function normalize(value?: string): string | undefined {
-  const trimmed = (value ?? '').trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-
-function normalizeRepoUrl(url?: string): string | undefined {
-  const raw = normalize(url);
-  if (!raw) {
-    return undefined;
-  }
-
-  const sshMatch = raw.match(/^git@([^:]+):(.+?)(?:\.git)?$/);
-  if (sshMatch) {
-    const host = sshMatch[1];
-    const path = sshMatch[2];
-    return `https://${host}/${path}`;
-  }
-
-  return raw.replace(/\.git$/, '');
-}
-
-function parseProvider(
-  explicitProvider: string | undefined,
-  repoUrl: string | undefined,
-  env: NodeJS.ProcessEnv
-): GitProvider {
-  const explicit = normalize(explicitProvider)?.toLowerCase();
-  if (explicit === 'github' || explicit === 'gitlab' || explicit === 'bitbucket' || explicit === 'azure-devops') {
-    return explicit;
-  }
-
-  const url = (repoUrl ?? '').toLowerCase();
-  if (url.includes('github')) {
-    return 'github';
-  }
-  if (url.includes('gitlab')) {
-    return 'gitlab';
-  }
-  if (url.includes('bitbucket')) {
-    return 'bitbucket';
-  }
-  if (url.includes('dev.azure.com') || url.includes('visualstudio.com')) {
-    return 'azure-devops';
-  }
-
-  if (normalize(env.GITHUB_REPOSITORY)) {
-    return 'github';
-  }
-  if (normalize(env.CI_PROJECT_PATH) || normalize(env.GITLAB_CI)) {
-    return 'gitlab';
-  }
-  if (normalize(env.BITBUCKET_REPO_SLUG)) {
-    return 'bitbucket';
-  }
-  if (normalize(env.BUILD_REPOSITORY_URI)) {
-    return 'azure-devops';
-  }
-
-  return 'unknown';
-}
-
-export function detectRepoContext(
-  input: RepoContextInput,
-  env: NodeJS.ProcessEnv = process.env
-): RepoContext {
-  const repoUrl =
-    normalizeRepoUrl(input.repoUrl) ??
-    normalizeRepoUrl(env.GITHUB_SERVER_URL && env.GITHUB_REPOSITORY ? `${env.GITHUB_SERVER_URL}/${env.GITHUB_REPOSITORY}` : undefined) ??
-    normalizeRepoUrl(env.CI_PROJECT_URL) ??
-    normalizeRepoUrl(env.BITBUCKET_GIT_HTTP_ORIGIN) ??
-    normalizeRepoUrl(env.BUILD_REPOSITORY_URI);
-  const repoSlug =
-    normalize(input.repoSlug) ??
-    normalize(env.GITHUB_REPOSITORY) ??
-    normalize(env.CI_PROJECT_PATH) ??
-    (env.BITBUCKET_WORKSPACE && env.BITBUCKET_REPO_SLUG
-      ? normalize(`${env.BITBUCKET_WORKSPACE}/${env.BITBUCKET_REPO_SLUG}`)
-      : undefined) ??
-    normalize(env.BUILD_REPOSITORY_NAME);
-  const ref =
-    normalize(input.ref) ??
-    normalize(env.GITHUB_REF_NAME) ??
-    normalize(env.CI_COMMIT_REF_NAME) ??
-    normalize(env.BITBUCKET_BRANCH) ??
-    normalize(env.BUILD_SOURCEBRANCHNAME);
-  const sha =
-    normalize(input.sha) ??
-    normalize(env.GITHUB_SHA) ??
-    normalize(env.CI_COMMIT_SHA) ??
-    normalize(env.BITBUCKET_COMMIT) ??
-    normalize(env.BUILD_SOURCEVERSION);
-  const provider = parseProvider(input.gitProvider, repoUrl, env);
-
-  return {
-    provider,
-    repoUrl,
-    repoSlug,
-    ref,
-    sha
-  };
-}

package/src/lib/retry.ts

@@ -1,79 +0,0 @@
-export interface RetryDecisionContext {
-  attempt: number;
-  maxAttempts: number;
-}
-
-export interface RetryContext extends RetryDecisionContext {
-  delayMs: number;
-  error: unknown;
-}
-
-export interface RetryOptions {
-  maxAttempts?: number;
-  delayMs?: number;
-  backoffMultiplier?: number;
-  maxDelayMs?: number;
-  onRetry?: (context: RetryContext) => void | Promise<void>;
-  shouldRetry?: (error: unknown, context: RetryDecisionContext) => boolean;
-  sleep?: (delayMs: number) => Promise<void>;
-}
-
-export function sleep(delayMs: number): Promise<void> {
-  return new Promise((resolve) => {
-    setTimeout(resolve, delayMs);
-  });
-}
-
-function normalizeRetryOptions(options: RetryOptions): Required<RetryOptions> {
-  return {
-    maxAttempts: Math.max(1, options.maxAttempts ?? 3),
-    delayMs: Math.max(0, options.delayMs ?? 2000),
-    backoffMultiplier: Math.max(1, options.backoffMultiplier ?? 1),
-    maxDelayMs:
-      options.maxDelayMs === undefined
-        ? Number.POSITIVE_INFINITY
-        : Math.max(0, options.maxDelayMs),
-    onRetry: options.onRetry ?? (async () => undefined),
-    shouldRetry: options.shouldRetry ?? (() => true),
-    sleep: options.sleep ?? sleep
-  };
-}
-
-export async function retry<T>(
-  operation: () => Promise<T>,
-  options: RetryOptions = {}
-): Promise<T> {
-  const normalized = normalizeRetryOptions(options);
-  let nextDelayMs = normalized.delayMs;
-
-  for (let attempt = 1; attempt <= normalized.maxAttempts; attempt += 1) {
-    try {
-      return await operation();
-    } catch (error) {
-      const shouldRetry =
-        attempt < normalized.maxAttempts &&
-        normalized.shouldRetry(error, {
-          attempt,
-          maxAttempts: normalized.maxAttempts
-        });
-
-      if (!shouldRetry) {
-        throw error;
-      }
-
-      await normalized.onRetry({
-        attempt,
-        maxAttempts: normalized.maxAttempts,
-        delayMs: nextDelayMs,
-        error
-      });
-      await normalized.sleep(nextDelayMs);
-      nextDelayMs = Math.min(
-        normalized.maxDelayMs,
-        Math.round(nextDelayMs * normalized.backoffMultiplier)
-      );
-    }
-  }
-
-  throw new Error('Retry exhausted without returning or throwing');
-}

package/src/lib/secrets.ts

@@ -1,104 +0,0 @@
-export const REDACTED = '[REDACTED]';
-export type SecretMasker = (input: string) => string;
-export type HeaderBag =
-  | Array<[string, string]>
-  | Headers
-  | Record<string, string>;
-
-const SENSITIVE_HEADER_NAMES = new Set([
-  'authorization',
-  'cookie',
-  'proxy-authorization',
-  'set-cookie',
-  'x-access-token',
-  'x-api-key'
-]);
-
-function isIterable(value: unknown): value is Iterable<unknown> {
-  return (
-    value !== null &&
-    value !== undefined &&
-    typeof value !== 'string' &&
-    typeof (value as Iterable<unknown>)[Symbol.iterator] === 'function'
-  );
-}
-
-function appendSecretValues(value: unknown, results: string[]): void {
-  if (value === null || value === undefined) {
-    return;
-  }
-  if (typeof value === 'string') {
-    const normalized = value.trim();
-    if (normalized) {
-      results.push(normalized);
-    }
-    return;
-  }
-  if (typeof value === 'number' || typeof value === 'boolean') {
-    results.push(String(value));
-    return;
-  }
-  if (Array.isArray(value) || isIterable(value)) {
-    for (const entry of value) {
-      appendSecretValues(entry, results);
-    }
-  }
-}
-
-export function normalizeSecretValues(secretValues: unknown): string[] {
-  const values: string[] = [];
-  appendSecretValues(secretValues, values);
-  return [...new Set(values)].sort((left, right) => right.length - left.length);
-}
-
-export function redactSecrets(
-  input: string,
-  secretValues: unknown,
-  replacement = REDACTED
-): string {
-  const source = String(input ?? '');
-  const secrets = normalizeSecretValues(secretValues);
-  if (!source || secrets.length === 0) {
-    return source;
-  }
-  return secrets.reduce((sanitized, secret) => {
-    if (!secret) {
-      return sanitized;
-    }
-    return sanitized.split(secret).join(replacement);
-  }, source);
-}
-
-export function createSecretMasker(
-  secretValues: unknown,
-  replacement = REDACTED
-): SecretMasker {
-  return (input: string) => redactSecrets(input, secretValues, replacement);
-}
-
-function headerEntries(headers: HeaderBag): Array<[string, string]> {
-  if (headers instanceof Headers) {
-    return Array.from(headers.entries());
-  }
-  if (Array.isArray(headers)) {
-    return headers.map(([name, value]) => [name, String(value)]);
-  }
-  return Object.entries(headers).map(([name, value]) => [name, String(value)]);
-}
-
-export function sanitizeHeaders(
-  headers: HeaderBag | undefined,
-  secretValues: unknown
-): Record<string, string> {
-  if (!headers) {
-    return {};
-  }
-  const sanitized: Record<string, string> = {};
-  for (const [name, value] of headerEntries(headers)) {
-    const normalizedName = name.toLowerCase();
-    sanitized[normalizedName] = SENSITIVE_HEADER_NAMES.has(normalizedName)
-      ? REDACTED
-      : redactSecrets(value, secretValues);
-  }
-  return sanitized;
-}