@otto-code/server 0.5.0

package/dist/server/services/git-hosting/status-poller.js

@@ -0,0 +1,149 @@
+export function isPullRequestStatusPending(status) {
+    if (!status) {
+        return false;
+    }
+    if (status.isMerged || status.state !== "OPEN") {
+        return false;
+    }
+    return status.checksStatus === "pending";
+}
+export function computeNextPollInterval(params) {
+    const base = isPullRequestStatusPending(params.status)
+        ? params.intervals.fastIntervalMs
+        : params.intervals.slowIntervalMs;
+    if (params.consecutiveErrors <= 1) {
+        return base;
+    }
+    const backoff = base * 2 ** (params.consecutiveErrors - 1);
+    return Math.min(backoff, params.intervals.errorBackoffCapMs);
+}
+export function createPullRequestStatusPoller(options) {
+    const targets = new Map();
+    function keyOf(target) {
+        return JSON.stringify({
+            cwd: target.cwd,
+            headRef: target.headRef,
+            headRepositoryOwner: target.headRepositoryOwner,
+        });
+    }
+    function schedule(target, delayMs) {
+        if (target.retainCount <= 0) {
+            return;
+        }
+        if (target.timer) {
+            clearTimeout(target.timer);
+        }
+        target.timer = setTimeout(() => {
+            target.timer = null;
+            void runPoll(target);
+        }, delayMs);
+    }
+    function scheduleFromState(target) {
+        schedule(target, computeNextPollInterval({
+            status: target.latestStatus,
+            consecutiveErrors: target.consecutiveErrors,
+            intervals: options.intervals,
+        }));
+    }
+    async function runPoll(target) {
+        try {
+            await options.poll(target.target);
+            // Success path reschedules via reportSuccess from the implementation.
+        }
+        catch (error) {
+            target.consecutiveErrors += 1;
+            for (const callback of target.errorCallbacks) {
+                callback(error);
+            }
+            scheduleFromState(target);
+        }
+    }
+    function close(target) {
+        if (target.timer) {
+            clearTimeout(target.timer);
+            target.timer = null;
+        }
+        target.retainCount = 0;
+        target.callbacks.clear();
+        target.errorCallbacks.clear();
+    }
+    return {
+        retain(input) {
+            const targetKey = keyOf(input);
+            let target = targets.get(targetKey);
+            if (!target) {
+                target = {
+                    key: targetKey,
+                    target: {
+                        cwd: input.cwd,
+                        headRef: input.headRef,
+                        headRepositoryOwner: input.headRepositoryOwner,
+                    },
+                    retainCount: 0,
+                    timer: null,
+                    latestStatus: null,
+                    consecutiveErrors: 0,
+                    callbacks: new Set(),
+                    errorCallbacks: new Set(),
+                };
+                targets.set(targetKey, target);
+            }
+            const isNewlyRetained = target.retainCount === 0;
+            target.retainCount += 1;
+            if (input.onStatus) {
+                target.callbacks.add(input.onStatus);
+            }
+            if (input.onError) {
+                target.errorCallbacks.add(input.onError);
+            }
+            if (isNewlyRetained) {
+                schedule(target, 0);
+            }
+            else {
+                scheduleFromState(target);
+            }
+            let unsubscribed = false;
+            return {
+                unsubscribe: () => {
+                    if (unsubscribed) {
+                        return;
+                    }
+                    unsubscribed = true;
+                    if (input.onStatus) {
+                        target.callbacks.delete(input.onStatus);
+                    }
+                    if (input.onError) {
+                        target.errorCallbacks.delete(input.onError);
+                    }
+                    target.retainCount -= 1;
+                    if (target.retainCount > 0) {
+                        return;
+                    }
+                    close(target);
+                    targets.delete(targetKey);
+                },
+            };
+        },
+        reportSuccess(input) {
+            const target = targets.get(keyOf(input.target));
+            if (!target) {
+                return;
+            }
+            target.latestStatus = input.status;
+            target.consecutiveErrors = 0;
+            if (input.notify) {
+                for (const callback of target.callbacks) {
+                    callback(input.status);
+                }
+            }
+            scheduleFromState(target);
+        },
+        dispose() {
+            for (const target of targets.values()) {
+                close(target);
+            }
+            targets.clear();
+        },
+    };
+}
+//# sourceMappingURL=status-poller.js.map

package/dist/server/services/git-hosting/types.d.ts

@@ -0,0 +1,53 @@
+import type { GitHostingCapabilities, GitHostingProviderId } from "@otto-code/protocol/messages";
+import type { HostingCurrentPullRequestStatus, GitHubService } from "../github-service.js";
+export interface GitHostingService extends GitHubService {
+    readonly providerId: GitHostingProviderId;
+    readonly capabilities: GitHostingCapabilities;
+}
+export type CurrentPullRequestStatus = HostingCurrentPullRequestStatus;
+export interface BitbucketPullRequestStatusFacts {
+    mergeStrategiesAllowed: string[];
+    defaultMergeStrategy: string | null;
+    approvalCount: number;
+    changesRequestedCount: number;
+}
+export declare const GITHUB_CAPABILITIES: GitHostingCapabilities;
+export declare const BITBUCKET_CLOUD_CAPABILITIES: GitHostingCapabilities;
+export declare class GitHostingCredentialsMissingError extends Error {
+    readonly kind = "missing-credentials";
+    constructor(providerId: GitHostingProviderId);
+}
+export declare class GitHostingAuthenticationError extends Error {
+    readonly kind = "auth-failure";
+    constructor(providerId: GitHostingProviderId);
+}
+export declare class GitHostingRateLimitError extends Error {
+    readonly kind = "rate-limited";
+    readonly retryAfterMs: number | null;
+    constructor(params: {
+        providerId: GitHostingProviderId;
+        retryAfterMs: number | null;
+    });
+}
+export declare class GitHostingUnsupportedCapabilityError extends Error {
+    readonly kind = "unsupported-capability";
+    readonly capability: string;
+    constructor(params: {
+        providerId: GitHostingProviderId;
+        capability: string;
+    });
+}
+export declare class GitHostingRequestError extends Error {
+    readonly kind = "request-error";
+    readonly status: number | null;
+    readonly method: string;
+    readonly path: string;
+    constructor(params: {
+        method: string;
+        path: string;
+        status: number | null;
+        detail?: string;
+    });
+}
+export declare function isGitHostingFeatureDisabledError(error: unknown): boolean;
+//# sourceMappingURL=types.d.ts.map

package/dist/server/services/git-hosting/types.js

@@ -0,0 +1,75 @@
+export const GITHUB_CAPABILITIES = {
+    autoMerge: true,
+    mergeQueue: true,
+    checkAnnotations: true,
+    checkDetails: true,
+    draftPrs: true,
+    reviewDecisions: true,
+    issues: true,
+};
+export const BITBUCKET_CLOUD_CAPABILITIES = {
+    autoMerge: false,
+    mergeQueue: false,
+    checkAnnotations: false,
+    checkDetails: false,
+    draftPrs: true,
+    reviewDecisions: true,
+    // Most Bitbucket Cloud teams track issues in Jira; the native tracker is
+    // deprecated and off by default, so v1 exposes PR search only.
+    issues: false,
+};
+// Provider credentials are absent (not an auth failure): features off, no
+// error surfaced — mirrors GitHubCliMissingError semantics.
+export class GitHostingCredentialsMissingError extends Error {
+    constructor(providerId) {
+        super(`No credentials configured for git hosting provider ${providerId}`);
+        this.kind = "missing-credentials";
+        this.name = "GitHostingCredentialsMissingError";
+    }
+}
+// Credentials exist but the provider rejected them — mirrors
+// GitHubAuthenticationError semantics.
+export class GitHostingAuthenticationError extends Error {
+    constructor(providerId) {
+        super(`Git hosting provider ${providerId} rejected the configured credentials`);
+        this.kind = "auth-failure";
+        this.name = "GitHostingAuthenticationError";
+    }
+}
+export class GitHostingRateLimitError extends Error {
+    constructor(params) {
+        super(`Git hosting provider ${params.providerId} rate limited the request`);
+        this.kind = "rate-limited";
+        this.name = "GitHostingRateLimitError";
+        this.retryAfterMs = params.retryAfterMs;
+    }
+}
+// A capability the provider doesn't implement was invoked (e.g. auto-merge or
+// server-side rebase on Bitbucket Cloud). Typed so callers can discriminate on
+// `kind` like every other hosting error, instead of matching a bare message.
+export class GitHostingUnsupportedCapabilityError extends Error {
+    constructor(params) {
+        super(`Git hosting provider ${params.providerId} does not support ${params.capability}`);
+        this.kind = "unsupported-capability";
+        this.name = "GitHostingUnsupportedCapabilityError";
+        this.capability = params.capability;
+    }
+}
+export class GitHostingRequestError extends Error {
+    // Never include request headers or bodies: they can carry credentials.
+    constructor(params) {
+        super(`Git hosting request failed: ${params.method} ${params.path}` +
+            (params.status !== null ? ` (HTTP ${params.status})` : "") +
+            (params.detail ? `: ${params.detail}` : ""));
+        this.kind = "request-error";
+        this.name = "GitHostingRequestError";
+        this.status = params.status;
+        this.method = params.method;
+        this.path = params.path;
+    }
+}
+export function isGitHostingFeatureDisabledError(error) {
+    return (error instanceof GitHostingCredentialsMissingError ||
+        error instanceof GitHostingAuthenticationError);
+}
+//# sourceMappingURL=types.js.map

package/dist/server/services/github-service.d.ts

@@ -0,0 +1,339 @@
+import type { GitHubSearchKind } from "@otto-code/protocol/messages";
+import type { BitbucketPullRequestStatusFacts } from "./git-hosting/types.js";
+export declare const GITHUB_POLL_FAST_INTERVAL_MS = 20000;
+export declare const GITHUB_POLL_SLOW_INTERVAL_MS = 120000;
+export declare const GITHUB_POLL_ERROR_BACKOFF_CAP_MS = 300000;
+export interface GitHubCommandRunnerOptions {
+    cwd: string;
+    envOverlay?: Record<string, string>;
+}
+export interface GitHubCommandResult {
+    stdout: string;
+    stderr: string;
+}
+export type GitHubCommandRunner = (args: string[], options: GitHubCommandRunnerOptions) => Promise<GitHubCommandResult>;
+export interface HostingPullRequestSummary {
+    number: number;
+    title: string;
+    url: string;
+    state: string;
+    body: string | null;
+    baseRefName: string;
+    headRefName: string;
+    labels: string[];
+    updatedAt: string;
+}
+export interface GitHubPullRequestCheckoutTarget {
+    number: number;
+    baseRefName: string;
+    headRefName: string;
+    headOwnerLogin: string | null;
+    headRepositorySshUrl: string | null;
+    headRepositoryUrl: string | null;
+    isCrossRepository: boolean;
+}
+export interface GitHubIssueSummary {
+    number: number;
+    title: string;
+    url: string;
+    state: string;
+    body: string | null;
+    labels: string[];
+    updatedAt: string;
+}
+export type PullRequestCheckStatus = "pending" | "success" | "failure" | "cancelled" | "skipped";
+export interface PullRequestCheck {
+    name: string;
+    status: PullRequestCheckStatus;
+    url: string | null;
+    workflow?: string;
+    duration?: string;
+    checkRunId?: number;
+    workflowRunId?: number;
+}
+export type PullRequestChecksStatus = "none" | "pending" | "success" | "failure";
+export type PullRequestReviewDecision = "approved" | "changes_requested" | "pending" | null;
+export type PullRequestMergeable = "MERGEABLE" | "CONFLICTING" | "UNKNOWN";
+export interface GitHubPullRequestStatusFacts {
+    mergeStateStatus: string | null;
+    autoMergeRequest: {
+        enabledAt: string | null;
+        mergeMethod: string | null;
+        enabledBy: string | null;
+    } | null;
+    viewerCanEnableAutoMerge: boolean;
+    viewerCanDisableAutoMerge: boolean;
+    viewerCanMergeAsAdmin: boolean;
+    viewerCanUpdateBranch: boolean;
+    repository: {
+        autoMergeAllowed: boolean;
+        mergeCommitAllowed: boolean;
+        squashMergeAllowed: boolean;
+        rebaseMergeAllowed: boolean;
+        viewerDefaultMergeMethod: string | null;
+    };
+    isMergeQueueEnabled: boolean;
+    isInMergeQueue: boolean;
+}
+export interface HostingCurrentPullRequestStatus {
+    number?: number;
+    repoOwner?: string;
+    repoName?: string;
+    url: string;
+    title: string;
+    state: string;
+    baseRefName: string;
+    headRefName: string;
+    isMerged: boolean;
+    isDraft?: boolean;
+    mergeable: PullRequestMergeable;
+    checks: PullRequestCheck[];
+    checksStatus: PullRequestChecksStatus;
+    reviewDecision: PullRequestReviewDecision;
+    github?: GitHubPullRequestStatusFacts;
+    bitbucket?: BitbucketPullRequestStatusFacts;
+}
+export type PullRequestTimelineReviewState = "approved" | "changes_requested" | "commented";
+interface PullRequestTimelineItemBase {
+    id: string;
+    author: string;
+    authorUrl: string | null;
+    avatarUrl: string | null;
+    body: string;
+    createdAt: number;
+    url: string;
+}
+export type PullRequestTimelineItem = (PullRequestTimelineItemBase & {
+    kind: "review";
+    reviewState: PullRequestTimelineReviewState;
+}) | (PullRequestTimelineItemBase & {
+    kind: "comment";
+    reviewId?: string;
+    location?: PullRequestTimelineCommentLocation;
+});
+export interface PullRequestTimelineCommentLocation {
+    path: string;
+    line?: number;
+    startLine?: number;
+    threadId?: string;
+    isResolved?: boolean;
+    isOutdated?: boolean;
+}
+export type GitHubPullRequestTimelineErrorKind = "not_found" | "forbidden" | "unknown";
+export interface GitHubPullRequestTimelineError {
+    kind: GitHubPullRequestTimelineErrorKind;
+    message: string;
+}
+export interface GitHubPullRequestTimeline {
+    prNumber: number;
+    repoOwner: string;
+    repoName: string;
+    items: PullRequestTimelineItem[];
+    truncated: boolean;
+    error: GitHubPullRequestTimelineError | null;
+}
+export interface GitHubPullRequestCreateResult {
+    url: string;
+    number: number;
+}
+export type GitHubPullRequestMergeMethod = "merge" | "squash" | "rebase";
+export interface GitHubPullRequestCommandStatus {
+    mergeable?: PullRequestMergeable;
+    github?: GitHubPullRequestStatusFacts;
+}
+export interface MergeGitHubPullRequestOptions {
+    cwd: string;
+    prNumber: number;
+    mergeMethod: GitHubPullRequestMergeMethod;
+    status?: GitHubPullRequestCommandStatus | null;
+}
+export interface EnableGitHubPullRequestAutoMergeOptions {
+    cwd: string;
+    prNumber: number;
+    mergeMethod: GitHubPullRequestMergeMethod;
+    status?: GitHubPullRequestCommandStatus | null;
+}
+export interface DisableGitHubPullRequestAutoMergeOptions {
+    cwd: string;
+    prNumber: number;
+    status?: GitHubPullRequestCommandStatus | null;
+}
+export interface GitHubPullRequestMergeResult {
+    success: true;
+}
+export interface GitHubPullRequestAutoMergeResult {
+    success: true;
+}
+export type GitHubReadOptions = {
+    force?: false;
+    reason?: string;
+} | {
+    force: true;
+    reason: string;
+};
+export type ListHostingPullRequestsOptions = {
+    cwd: string;
+    query?: string;
+    limit?: number;
+} & GitHubReadOptions;
+export type ListGitHubIssuesOptions = {
+    cwd: string;
+    query?: string;
+    limit?: number;
+} & GitHubReadOptions;
+export type GetGitHubPullRequestOptions = {
+    cwd: string;
+    number: number;
+} & GitHubReadOptions;
+export type GetGitHubPullRequestTimelineOptions = {
+    cwd: string;
+    prNumber: number;
+    repoOwner: string;
+    repoName: string;
+} & GitHubReadOptions;
+export type GetGitHubCheckDetailsOptions = {
+    cwd: string;
+    repoOwner: string;
+    repoName: string;
+    checkRunId: number;
+    workflowRunId?: number;
+} & GitHubReadOptions;
+export interface GitHubCheckAnnotation {
+    path?: string;
+    startLine?: number;
+    endLine?: number;
+    annotationLevel?: string;
+    message?: string;
+    title?: string;
+    rawDetails?: string;
+}
+export interface GitHubCheckFailedJob {
+    jobId: number;
+    name: string;
+    status?: string | null;
+    conclusion?: string | null;
+    url?: string | null;
+    completedAt?: string;
+    logTail?: string;
+    logTruncated?: boolean;
+}
+export interface GitHubCheckDetails {
+    checkRunId: number;
+    workflowRunId?: number | null;
+    name: string;
+    status?: string | null;
+    conclusion?: string | null;
+    url?: string | null;
+    detailsUrl?: string | null;
+    output?: {
+        title?: string | null;
+        summary?: string | null;
+        text?: string | null;
+    } | null;
+    annotations: GitHubCheckAnnotation[];
+    failedJobs: GitHubCheckFailedJob[];
+    truncated: boolean;
+}
+export interface GitHubSearchResult {
+    items: Array<{
+        kind: "issue" | "pr";
+        number: number;
+        title: string;
+        url: string;
+        state: string;
+        body: string | null;
+        labels: string[];
+        baseRefName?: string | null;
+        headRefName?: string | null;
+        updatedAt?: string;
+    }>;
+    githubFeaturesEnabled: boolean;
+}
+export type SearchGitHubIssuesAndPrsOptions = {
+    cwd: string;
+    query: string;
+    limit?: number;
+    kinds?: GitHubSearchKind[];
+} & GitHubReadOptions;
+export interface CreateGitHubPullRequestOptions {
+    cwd: string;
+    repo: string;
+    title: string;
+    head: string;
+    base: string;
+    body?: string;
+}
+export interface GitHubService {
+    listPullRequests(options: ListHostingPullRequestsOptions): Promise<HostingPullRequestSummary[]>;
+    listIssues(options: ListGitHubIssuesOptions): Promise<GitHubIssueSummary[]>;
+    getPullRequest(options: GetGitHubPullRequestOptions): Promise<HostingPullRequestSummary>;
+    getPullRequestHeadRef(options: GetGitHubPullRequestOptions): Promise<string>;
+    getPullRequestCheckoutTarget?(options: GetGitHubPullRequestOptions): Promise<GitHubPullRequestCheckoutTarget>;
+    getCurrentPullRequestStatus(options: {
+        cwd: string;
+        headRef: string;
+        headRepositoryOwner?: string;
+    } & GitHubReadOptions): Promise<HostingCurrentPullRequestStatus | null>;
+    getPullRequestTimeline(options: GetGitHubPullRequestTimelineOptions): Promise<GitHubPullRequestTimeline>;
+    getGitHubCheckDetails(options: GetGitHubCheckDetailsOptions): Promise<GitHubCheckDetails>;
+    searchIssuesAndPrs(options: SearchGitHubIssuesAndPrsOptions): Promise<GitHubSearchResult>;
+    createPullRequest(options: CreateGitHubPullRequestOptions): Promise<GitHubPullRequestCreateResult>;
+    mergePullRequest(options: MergeGitHubPullRequestOptions): Promise<GitHubPullRequestMergeResult>;
+    enablePullRequestAutoMerge(options: EnableGitHubPullRequestAutoMergeOptions): Promise<GitHubPullRequestAutoMergeResult>;
+    disablePullRequestAutoMerge(options: DisableGitHubPullRequestAutoMergeOptions): Promise<GitHubPullRequestAutoMergeResult>;
+    isAuthenticated(options: {
+        cwd: string;
+    } & GitHubReadOptions): Promise<boolean>;
+    retainCurrentPullRequestStatusPoll?(options: {
+        cwd: string;
+        headRef: string;
+        headRepositoryOwner?: string;
+        onStatus?: (status: HostingCurrentPullRequestStatus | null) => void;
+        onError?: (error: unknown) => void;
+    }): {
+        unsubscribe: () => void;
+    };
+    invalidate(options: {
+        cwd: string;
+    }): void;
+    dispose?(): void;
+}
+export declare class GitHubCliMissingError extends Error {
+    readonly kind = "missing-cli";
+    constructor();
+}
+export declare class GitHubAuthenticationError extends Error {
+    readonly kind = "auth-failure";
+    readonly stderr: string;
+    constructor(params: {
+        stderr: string;
+    });
+}
+export declare class GitHubCommandError extends Error {
+    readonly kind = "command-error";
+    readonly args: string[];
+    readonly cwd: string;
+    readonly exitCode: number | null;
+    readonly stderr: string;
+    constructor(params: {
+        args: string[];
+        cwd: string;
+        exitCode: number | null;
+        stderr: string;
+    });
+}
+interface CreateGitHubServiceOptions {
+    ttlMs?: number;
+    runner?: GitHubCommandRunner;
+    resolveGhPath?: () => Promise<string | null>;
+    now?: () => number;
+}
+export declare function createGitHubService(options?: CreateGitHubServiceOptions): GitHubService;
+export declare function assertPullRequestAutoMergeEnableReady(input: Pick<EnableGitHubPullRequestAutoMergeOptions, "mergeMethod" | "status">): void;
+export declare function assertPullRequestAutoMergeDisableReady(input: Pick<DisableGitHubPullRequestAutoMergeOptions, "status">): void;
+export declare function isPullRequestMergeMethodAllowed(repository: GitHubPullRequestStatusFacts["repository"], method: GitHubPullRequestMergeMethod): boolean;
+export declare function computeGithubNextInterval(status: HostingCurrentPullRequestStatus | null, consecutiveErrors: number): number;
+export declare function parseStatusCheckRollup(value: unknown): PullRequestCheck[];
+export declare function resolveGitHubRepo(cwd: string): Promise<string | null>;
+export {};
+//# sourceMappingURL=github-service.d.ts.map