@otto-code/server 0.5.0

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

@@ -0,0 +1,4 @@
+import { createGitHubService } from "../github-service.js";
+import { type GitHostingService } from "./types.js";
+export declare function createGitHubHostingService(options?: Parameters<typeof createGitHubService>[0]): GitHostingService;
+//# sourceMappingURL=github-hosting-service.d.ts.map

package/dist/server/services/git-hosting/github-hosting-service.js

@@ -0,0 +1,11 @@
+import { createGitHubService } from "../github-service.js";
+import { GITHUB_CAPABILITIES } from "./types.js";
+// GitHub adapter: the existing gh-CLI service tagged with its provider
+// identity and capabilities. Behavior is unchanged.
+export function createGitHubHostingService(options = {}) {
+    return Object.assign(createGitHubService(options), {
+        providerId: "github",
+        capabilities: GITHUB_CAPABILITIES,
+    });
+}
+//# sourceMappingURL=github-hosting-service.js.map

package/dist/server/services/git-hosting/hosting-http-client.d.ts

@@ -0,0 +1,20 @@
+import type { GitHostingProviderId } from "@otto-code/protocol/messages";
+export interface HostingHttpClientOptions {
+    providerId: GitHostingProviderId;
+    baseUrl: string;
+    buildAuthorizationHeader: () => string;
+    fetchImpl?: typeof fetch;
+    now?: () => number;
+    setTimeoutMs?: number;
+}
+export interface HostingHttpRequest {
+    method: "GET" | "POST";
+    path: string;
+    query?: Record<string, string | number | undefined>;
+    body?: unknown;
+}
+export interface HostingHttpClient {
+    request(input: HostingHttpRequest): Promise<unknown>;
+}
+export declare function createHostingHttpClient(options: HostingHttpClientOptions): HostingHttpClient;
+//# sourceMappingURL=hosting-http-client.d.ts.map

package/dist/server/services/git-hosting/hosting-http-client.js

@@ -0,0 +1,131 @@
+import { GitHostingAuthenticationError, GitHostingRateLimitError, GitHostingRequestError, } from "./types.js";
+const DEFAULT_REQUEST_TIMEOUT_MS = 30000;
+const MAX_RETRY_AFTER_MS = 30000;
+const RATE_LIMIT_COOLDOWN_MS = 60000;
+// HTTPS JSON client with the abuse guardrails all hosting providers share:
+// - hard request timeout;
+// - at most ONE retry, only for GET, only on 429/5xx, honoring Retry-After
+//   with a cap — mutations are never retried;
+// - a cooldown window after a rate-limit response during which requests fail
+//   fast instead of hammering the API;
+// - credentials appear only in the outgoing header; errors carry method,
+//   path, and status, never headers or bodies.
+export function createHostingHttpClient(options) {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const now = options.now ?? Date.now;
+    const timeoutMs = options.setTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    let cooldownUntil = 0;
+    if (!options.baseUrl.startsWith("https://")) {
+        throw new Error("Git hosting API base URL must use https");
+    }
+    function buildUrl(input) {
+        const url = new URL(options.baseUrl.replace(/\/+$/u, "") + input.path);
+        for (const [key, value] of Object.entries(input.query ?? {})) {
+            if (value !== undefined) {
+                url.searchParams.set(key, String(value));
+            }
+        }
+        return url;
+    }
+    function parseRetryAfterMs(response) {
+        const header = response.headers.get("retry-after");
+        if (!header) {
+            return null;
+        }
+        const seconds = Number(header);
+        if (!Number.isFinite(seconds) || seconds < 0) {
+            return null;
+        }
+        return Math.min(seconds * 1000, MAX_RETRY_AFTER_MS);
+    }
+    async function performOnce(input) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            return await fetchImpl(buildUrl(input), {
+                method: input.method,
+                headers: {
+                    Authorization: options.buildAuthorizationHeader(),
+                    Accept: "application/json",
+                    ...(input.body !== undefined ? { "Content-Type": "application/json" } : {}),
+                },
+                body: input.body !== undefined ? JSON.stringify(input.body) : undefined,
+                signal: controller.signal,
+            });
+        }
+        catch (error) {
+            if (controller.signal.aborted) {
+                throw new GitHostingRequestError({
+                    method: input.method,
+                    path: input.path,
+                    status: null,
+                    detail: `timed out after ${timeoutMs}ms`,
+                });
+            }
+            throw new GitHostingRequestError({
+                method: input.method,
+                path: input.path,
+                status: null,
+                detail: error instanceof Error ? error.message : "network error",
+            });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async function readJson(response, input) {
+        if (response.status === 204) {
+            return null;
+        }
+        try {
+            return await response.json();
+        }
+        catch {
+            throw new GitHostingRequestError({
+                method: input.method,
+                path: input.path,
+                status: response.status,
+                detail: "invalid JSON response",
+            });
+        }
+    }
+    return {
+        async request(input) {
+            const currentTime = now();
+            if (currentTime < cooldownUntil) {
+                throw new GitHostingRateLimitError({
+                    providerId: options.providerId,
+                    retryAfterMs: cooldownUntil - currentTime,
+                });
+            }
+            let response = await performOnce(input);
+            const isRetryable = input.method === "GET" && (response.status === 429 || response.status >= 500);
+            if (isRetryable) {
+                const retryAfterMs = parseRetryAfterMs(response) ?? 2000;
+                await new Promise((resolve) => setTimeout(resolve, retryAfterMs));
+                response = await performOnce(input);
+            }
+            if (response.status === 429) {
+                // Floor the cooldown: a zero or missing Retry-After must not let
+                // callers keep hammering a rate-limited API.
+                cooldownUntil = now() + Math.max(parseRetryAfterMs(response) ?? 0, RATE_LIMIT_COOLDOWN_MS);
+                throw new GitHostingRateLimitError({
+                    providerId: options.providerId,
+                    retryAfterMs: cooldownUntil - now(),
+                });
+            }
+            if (response.status === 401 || response.status === 403) {
+                throw new GitHostingAuthenticationError(options.providerId);
+            }
+            if (!response.ok) {
+                throw new GitHostingRequestError({
+                    method: input.method,
+                    path: input.path,
+                    status: response.status,
+                });
+            }
+            return readJson(response, input);
+        },
+    };
+}
+//# sourceMappingURL=hosting-http-client.js.map

package/dist/server/services/git-hosting/request-cache.d.ts

@@ -0,0 +1,20 @@
+export interface HostingReadOptions {
+    force?: boolean;
+    reason?: string;
+}
+export interface HostingRequestCache {
+    cached<T>(params: {
+        cwd: string;
+        method: string;
+        args: unknown;
+        readOptions?: HostingReadOptions;
+        load: () => Promise<T>;
+    }): Promise<T>;
+    invalidate(cwd: string): void;
+    clear(): void;
+}
+export declare function createHostingRequestCache(options: {
+    ttlMs: number;
+    now?: () => number;
+}): HostingRequestCache;
+//# sourceMappingURL=request-cache.d.ts.map

package/dist/server/services/git-hosting/request-cache.js

@@ -0,0 +1,68 @@
+// TTL + single-flight read cache shared by hosting service implementations.
+// Mirrors the discipline of github-service.ts's internal `cached()`: one
+// in-flight request per key, results cached for a short TTL, forced reads
+// require a reason (audit trail against accidental hot loops).
+export function createHostingRequestCache(options) {
+    const now = options.now ?? Date.now;
+    const cache = new Map();
+    const inFlight = new Map();
+    function buildKey(params) {
+        return JSON.stringify({ cwd: params.cwd, method: params.method, args: params.args });
+    }
+    return {
+        cached(params) {
+            if (params.readOptions?.force && !params.readOptions.reason) {
+                throw new Error("Forced git hosting read requires a reason");
+            }
+            const key = buildKey(params);
+            const entry = cache.get(key);
+            if (!params.readOptions?.force && entry && entry.expiresAt > now()) {
+                return Promise.resolve(entry.value);
+            }
+            const existing = inFlight.get(key);
+            if (existing && (!params.readOptions?.force || existing.force)) {
+                return existing.promise;
+            }
+            const request = params
+                .load()
+                .then((value) => {
+                if (inFlight.get(key)?.promise === request) {
+                    cache.set(key, {
+                        value,
+                        cwd: params.cwd,
+                        expiresAt: now() + options.ttlMs,
+                    });
+                }
+                return value;
+            })
+                .finally(() => {
+                if (inFlight.get(key)?.promise === request) {
+                    inFlight.delete(key);
+                }
+            });
+            inFlight.set(key, {
+                cwd: params.cwd,
+                promise: request,
+                force: params.readOptions?.force === true,
+            });
+            return request;
+        },
+        invalidate(cwd) {
+            for (const [key, entry] of cache.entries()) {
+                if (entry.cwd === cwd) {
+                    cache.delete(key);
+                }
+            }
+            for (const [key, entry] of inFlight.entries()) {
+                if (entry.cwd === cwd) {
+                    inFlight.delete(key);
+                }
+            }
+        },
+        clear() {
+            cache.clear();
+            inFlight.clear();
+        },
+    };
+}
+//# sourceMappingURL=request-cache.js.map

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

@@ -0,0 +1,32 @@
+import type { GitHostingCapabilities, GitHostingProviderId, MutableDaemonConfig } from "@otto-code/protocol/messages";
+import { type GitHostingService } from "./types.js";
+export type ResolvedGitHosting = {
+    providerId: GitHostingProviderId;
+    capabilities: GitHostingCapabilities;
+    service: GitHostingService;
+    credentialsMissing: false;
+} | {
+    providerId: GitHostingProviderId;
+    capabilities: GitHostingCapabilities;
+    service: null;
+    credentialsMissing: true;
+};
+export interface GitHostingResolver {
+    resolveForCwd(cwd: string): Promise<ResolvedGitHosting>;
+    resolveForProvider(providerId: GitHostingProviderId): ResolvedGitHosting;
+    invalidate(cwd: string): void;
+    invalidateAll(): void;
+    dispose(): void;
+}
+export interface GitHostingResolverOptions {
+    github: GitHostingService;
+    getDaemonConfig: () => MutableDaemonConfig;
+    ottoHome: string;
+    readOttoConfigJson: (repoRoot: string) => unknown;
+    resolveRepoRoot?: (cwd: string) => Promise<string | null>;
+    resolveRemoteUrl?: (cwd: string) => Promise<string | null>;
+    now?: () => number;
+}
+export declare function deriveProviderFromRemote(remoteUrl: string | null): GitHostingProviderId | null;
+export declare function createGitHostingResolver(options: GitHostingResolverOptions): GitHostingResolver;
+//# sourceMappingURL=resolver.d.ts.map

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

@@ -0,0 +1,152 @@
+import { createHash } from "node:crypto";
+import { parseBitbucketCloudRemoteUrl, parseGitHubRemoteUrl } from "@otto-code/protocol/git-remote";
+import { OttoConfigSchema } from "@otto-code/protocol/otto-config-schema";
+import { runGitCommand } from "../../utils/run-git-command.js";
+import { parseGitRevParsePath } from "../../utils/git-rev-parse-path.js";
+import { createBitbucketCloudService, } from "./bitbucket-cloud-service.js";
+import { BITBUCKET_CLOUD_CAPABILITIES, GITHUB_CAPABILITIES, } from "./types.js";
+const RESOLUTION_TTL_MS = 30000;
+const READ_ONLY_GIT_ENV = { GIT_TERMINAL_PROMPT: "0" };
+async function defaultResolveRepoRoot(cwd) {
+    try {
+        const { stdout } = await runGitCommand(["rev-parse", "--show-toplevel"], {
+            cwd,
+            envOverlay: READ_ONLY_GIT_ENV,
+        });
+        return parseGitRevParsePath(stdout);
+    }
+    catch {
+        return null;
+    }
+}
+async function defaultResolveRemoteUrl(cwd) {
+    try {
+        const { stdout } = await runGitCommand(["remote", "get-url", "origin"], {
+            cwd,
+            envOverlay: READ_ONLY_GIT_ENV,
+        });
+        return stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+// A workspace's provider is the host its git remote points at. github.com and
+// bitbucket.org are unambiguous; standard SSH (scp-style) remotes parse too.
+// Aliased SSH hosts fall through to the otto.json override.
+export function deriveProviderFromRemote(remoteUrl) {
+    if (!remoteUrl) {
+        return null;
+    }
+    if (parseGitHubRemoteUrl(remoteUrl)) {
+        return "github";
+    }
+    if (parseBitbucketCloudRemoteUrl(remoteUrl)) {
+        return "bitbucket-cloud";
+    }
+    return null;
+}
+function credentialsFingerprint(credentials) {
+    // In-memory instance cache key; hashed so the token itself never sits in a
+    // Map key that could end up in a heap dump grep or debug log.
+    return createHash("sha256").update(`${credentials.email}\n${credentials.apiToken}`).digest("hex");
+}
+export function createGitHostingResolver(options) {
+    const now = options.now ?? Date.now;
+    const resolveRepoRoot = options.resolveRepoRoot ?? defaultResolveRepoRoot;
+    const resolveRemoteUrl = options.resolveRemoteUrl ?? defaultResolveRemoteUrl;
+    const resolutionCache = new Map();
+    // The single host-level Bitbucket service, rebuilt when credentials rotate.
+    let bitbucketInstance = null;
+    function capabilitiesFor(providerId) {
+        return providerId === "github" ? GITHUB_CAPABILITIES : BITBUCKET_CLOUD_CAPABILITIES;
+    }
+    function readProviderOverride(repoRoot) {
+        if (!repoRoot) {
+            return null;
+        }
+        const parsed = OttoConfigSchema.safeParse(options.readOttoConfigJson(repoRoot) ?? {});
+        if (!parsed.success) {
+            return null;
+        }
+        return parsed.data.gitHosting?.provider ?? null;
+    }
+    function bitbucketCredentials() {
+        const config = options.getDaemonConfig();
+        const email = config.gitHosting?.providers?.bitbucketCloud?.email?.trim() ?? "";
+        const apiToken = config.gitHosting?.providers?.bitbucketCloud?.apiToken?.trim() ?? "";
+        if (!email || !apiToken) {
+            return null;
+        }
+        return { email, apiToken };
+    }
+    function getBitbucketService(credentials) {
+        const fingerprint = credentialsFingerprint(credentials);
+        if (bitbucketInstance && bitbucketInstance.fingerprint === fingerprint) {
+            return bitbucketInstance.service;
+        }
+        bitbucketInstance?.service.dispose?.();
+        const service = createBitbucketCloudService({
+            credentials,
+            resolveRemoteUrl,
+            now,
+        });
+        bitbucketInstance = { fingerprint, service };
+        return service;
+    }
+    function resolveForProvider(providerId) {
+        const capabilities = capabilitiesFor(providerId);
+        if (providerId === "github") {
+            // GitHub auth is owned by the gh CLI; we always have a path to try, and
+            // isAuthenticated reports the real state.
+            return { providerId, capabilities, service: options.github, credentialsMissing: false };
+        }
+        const credentials = bitbucketCredentials();
+        if (!credentials) {
+            return { providerId, capabilities, service: null, credentialsMissing: true };
+        }
+        return {
+            providerId,
+            capabilities,
+            service: getBitbucketService(credentials),
+            credentialsMissing: false,
+        };
+    }
+    async function resolveUncached(cwd) {
+        const repoRoot = await resolveRepoRoot(cwd);
+        const override = readProviderOverride(repoRoot);
+        const remoteUrl = await resolveRemoteUrl(cwd);
+        const providerId = override ?? deriveProviderFromRemote(remoteUrl) ?? "github";
+        return resolveForProvider(providerId);
+    }
+    return {
+        resolveForCwd(cwd) {
+            const cached = resolutionCache.get(cwd);
+            if (cached && cached.expiresAt > now()) {
+                return cached.value;
+            }
+            const value = resolveUncached(cwd).catch((error) => {
+                resolutionCache.delete(cwd);
+                throw error;
+            });
+            resolutionCache.set(cwd, { value, expiresAt: now() + RESOLUTION_TTL_MS });
+            return value;
+        },
+        resolveForProvider,
+        invalidate(cwd) {
+            resolutionCache.delete(cwd);
+            options.github.invalidate({ cwd });
+            bitbucketInstance?.service.invalidate({ cwd });
+        },
+        invalidateAll() {
+            resolutionCache.clear();
+        },
+        dispose() {
+            resolutionCache.clear();
+            bitbucketInstance?.service.dispose?.();
+            bitbucketInstance = null;
+            options.github.dispose?.();
+        },
+    };
+}
+//# sourceMappingURL=resolver.js.map

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

@@ -0,0 +1,4 @@
+import type { GitHubService } from "../github-service.js";
+import type { GitHostingResolver } from "./resolver.js";
+export declare function createGitHostingRouter(resolver: GitHostingResolver): GitHubService;
+//# sourceMappingURL=router.d.ts.map

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

@@ -0,0 +1,105 @@
+import { GitHostingCredentialsMissingError } from "./types.js";
+// A GitHubService-shaped facade that routes every call to the provider the
+// target directory's project selects. Every method on the service interface
+// already carries a cwd, so existing consumers (session, checkout,
+// auto-archive, agent tools) become multi-provider by swapping the singleton
+// injection for this router — no per-call-site changes.
+export function createGitHostingRouter(resolver) {
+    async function serviceFor(cwd) {
+        const resolved = await resolver.resolveForCwd(cwd);
+        if (!resolved.service) {
+            throw new GitHostingCredentialsMissingError(resolved.providerId);
+        }
+        return resolved.service;
+    }
+    return {
+        async listPullRequests(input) {
+            return (await serviceFor(input.cwd)).listPullRequests(input);
+        },
+        async listIssues(input) {
+            return (await serviceFor(input.cwd)).listIssues(input);
+        },
+        async getPullRequest(input) {
+            return (await serviceFor(input.cwd)).getPullRequest(input);
+        },
+        async getPullRequestHeadRef(input) {
+            return (await serviceFor(input.cwd)).getPullRequestHeadRef(input);
+        },
+        async getPullRequestCheckoutTarget(input) {
+            const service = await serviceFor(input.cwd);
+            if (!service.getPullRequestCheckoutTarget) {
+                throw new Error("Pull request checkout targets are not supported by this provider");
+            }
+            return service.getPullRequestCheckoutTarget(input);
+        },
+        async getCurrentPullRequestStatus(input) {
+            return (await serviceFor(input.cwd)).getCurrentPullRequestStatus(input);
+        },
+        async getPullRequestTimeline(input) {
+            return (await serviceFor(input.cwd)).getPullRequestTimeline(input);
+        },
+        async getGitHubCheckDetails(input) {
+            return (await serviceFor(input.cwd)).getGitHubCheckDetails(input);
+        },
+        async searchIssuesAndPrs(input) {
+            return (await serviceFor(input.cwd)).searchIssuesAndPrs(input);
+        },
+        async createPullRequest(input) {
+            return (await serviceFor(input.cwd)).createPullRequest(input);
+        },
+        async mergePullRequest(input) {
+            return (await serviceFor(input.cwd)).mergePullRequest(input);
+        },
+        async enablePullRequestAutoMerge(input) {
+            return (await serviceFor(input.cwd)).enablePullRequestAutoMerge(input);
+        },
+        async disablePullRequestAutoMerge(input) {
+            return (await serviceFor(input.cwd)).disablePullRequestAutoMerge(input);
+        },
+        async isAuthenticated(input) {
+            return (await serviceFor(input.cwd)).isAuthenticated(input);
+        },
+        retainCurrentPullRequestStatusPoll(input) {
+            // Resolution is async while retain is sync: subscribe once the provider
+            // resolves, and make unsubscribe idempotent across that boundary.
+            let inner = null;
+            let cancelled = false;
+            const subscribe = async () => {
+                const resolved = await resolver.resolveForCwd(input.cwd);
+                if (cancelled) {
+                    return;
+                }
+                if (!resolved.service) {
+                    input.onError?.(new GitHostingCredentialsMissingError(resolved.providerId));
+                    return;
+                }
+                if (!resolved.service.retainCurrentPullRequestStatusPoll) {
+                    return;
+                }
+                inner = resolved.service.retainCurrentPullRequestStatusPoll(input);
+                if (cancelled) {
+                    inner.unsubscribe();
+                }
+            };
+            void subscribe().catch((error) => {
+                if (!cancelled) {
+                    input.onError?.(error);
+                }
+            });
+            return {
+                unsubscribe: () => {
+                    cancelled = true;
+                    inner?.unsubscribe();
+                    inner = null;
+                },
+            };
+        },
+        invalidate(input) {
+            resolver.invalidate(input.cwd);
+        },
+        dispose() {
+            resolver.dispose();
+        },
+    };
+}
+//# sourceMappingURL=router.js.map

package/dist/server/services/git-hosting/status-poller.d.ts

@@ -0,0 +1,39 @@
+import type { HostingCurrentPullRequestStatus } from "../github-service.js";
+export interface PullRequestStatusPollerIntervals {
+    fastIntervalMs: number;
+    slowIntervalMs: number;
+    errorBackoffCapMs: number;
+}
+export interface PullRequestStatusPollTargetKey {
+    cwd: string;
+    headRef: string;
+    headRepositoryOwner?: string;
+}
+export interface PullRequestStatusPoller {
+    retain(options: {
+        cwd: string;
+        headRef: string;
+        headRepositoryOwner?: string;
+        onStatus?: (status: HostingCurrentPullRequestStatus | null) => void;
+        onError?: (error: unknown) => void;
+    }): {
+        unsubscribe: () => void;
+    };
+    reportSuccess(options: {
+        target: PullRequestStatusPollTargetKey;
+        status: HostingCurrentPullRequestStatus | null;
+        notify: boolean;
+    }): void;
+    dispose(): void;
+}
+export declare function isPullRequestStatusPending(status: HostingCurrentPullRequestStatus | null): boolean;
+export declare function computeNextPollInterval(params: {
+    status: HostingCurrentPullRequestStatus | null;
+    consecutiveErrors: number;
+    intervals: PullRequestStatusPollerIntervals;
+}): number;
+export declare function createPullRequestStatusPoller(options: {
+    intervals: PullRequestStatusPollerIntervals;
+    poll: (target: PullRequestStatusPollTargetKey) => Promise<void>;
+}): PullRequestStatusPoller;
+//# sourceMappingURL=status-poller.d.ts.map