@otto-code/server 0.5.0

package/dist/server/server/session/checkout/checkout-session.js

@@ -0,0 +1,1000 @@
+import { getErrorMessage } from "@otto-code/protocol/error-utils";
+import { validateBranchSlug } from "@otto-code/protocol/branch-slug";
+import { toCheckoutError } from "../../checkout-git-utils.js";
+import { buildCheckoutPrStatusPayloadFromSnapshot, buildCheckoutStatusPayloadFromSnapshot, } from "../../checkout/status-projection.js";
+import { assertSafeGitRef } from "../../worktree-session.js";
+import { isGitHostingFeatureDisabledError } from "../../../services/git-hosting/types.js";
+import { assertPullRequestAutoMergeDisableReady, assertPullRequestAutoMergeEnableReady, } from "../../../services/github-service.js";
+import { commitChanges, createPullRequest, mergeFromBase, mergeToBase, pullCurrentBranch, pushCurrentBranch, } from "../../../utils/checkout-git.js";
+import { execCommand } from "../../../utils/spawn.js";
+import { expandTilde } from "../../../utils/path.js";
+/**
+ * A client's checkout view, both sides: the read & live-stream side (status
+ * queries, branch validation/suggestions, manual refresh, live git-diff and
+ * checkout-status subscriptions) and the command side (switch/rename/commit/
+ * merge/pull/push/stash and the GitHub-PR operations).
+ *
+ * Command operations keep the live diff in sync by calling scheduleDiffRefresh()
+ * and refresh the workspace git snapshot through gitMutation.notifyGitMutation(); the
+ * workspace git observer streams branch changes through emitStatusUpdate().
+ */
+export class CheckoutSession {
+    constructor(options) {
+        this.diffSubscriptions = new Map();
+        this.host = options.host;
+        this.gitMutation = options.gitMutation;
+        this.workspaceGitService = options.workspaceGitService;
+        this.github = options.github;
+        this.gitHostingResolver = options.gitHostingResolver ?? null;
+        this.checkoutDiffManager = options.checkoutDiffManager;
+        this.gitMetadataGenerator = options.gitMetadataGenerator;
+        this.ottoHome = options.ottoHome;
+        this.worktreesRoot = options.worktreesRoot;
+        this.logger = options.logger;
+    }
+    async handleStatusRequest(msg) {
+        const { cwd, requestId } = msg;
+        const resolvedCwd = expandTilde(cwd);
+        try {
+            const snapshot = await this.workspaceGitService.getSnapshot(resolvedCwd);
+            this.host.emit({
+                type: "checkout_status_response",
+                payload: buildCheckoutStatusPayloadFromSnapshot({
+                    cwd,
+                    requestId,
+                    snapshot,
+                }),
+            });
+        }
+        catch (error) {
+            this.host.emit({
+                type: "checkout_status_response",
+                payload: {
+                    cwd,
+                    isGit: false,
+                    repoRoot: null,
+                    currentBranch: null,
+                    isDirty: null,
+                    baseRef: null,
+                    aheadBehind: null,
+                    aheadOfOrigin: null,
+                    behindOfOrigin: null,
+                    hasRemote: false,
+                    remoteUrl: null,
+                    isOttoOwnedWorktree: false,
+                    error: toCheckoutError(error),
+                    requestId,
+                },
+            });
+        }
+    }
+    async handleValidateBranchRequest(msg) {
+        const { cwd, branchName, requestId } = msg;
+        try {
+            const resolvedCwd = expandTilde(cwd);
+            assertSafeGitRef(branchName, "branch");
+            const resolution = await this.workspaceGitService.validateBranchRef(resolvedCwd, branchName);
+            switch (resolution.kind) {
+                case "local":
+                    this.host.emit({
+                        type: "validate_branch_response",
+                        payload: {
+                            exists: true,
+                            resolvedRef: resolution.name,
+                            isRemote: false,
+                            error: null,
+                            requestId,
+                        },
+                    });
+                    return;
+                case "remote-only":
+                    this.host.emit({
+                        type: "validate_branch_response",
+                        payload: {
+                            exists: true,
+                            resolvedRef: resolution.remoteRef,
+                            isRemote: true,
+                            error: null,
+                            requestId,
+                        },
+                    });
+                    return;
+                case "not-found":
+                    this.host.emit({
+                        type: "validate_branch_response",
+                        payload: {
+                            exists: false,
+                            resolvedRef: null,
+                            isRemote: false,
+                            error: null,
+                            requestId,
+                        },
+                    });
+                    return;
+                default: {
+                    const exhaustiveCheck = resolution;
+                    throw new Error(`Unhandled branch resolution: ${getErrorMessage(exhaustiveCheck)}`);
+                }
+            }
+        }
+        catch (error) {
+            this.host.emit({
+                type: "validate_branch_response",
+                payload: {
+                    exists: false,
+                    resolvedRef: null,
+                    isRemote: false,
+                    error: error instanceof Error ? error.message : String(error),
+                    requestId,
+                },
+            });
+        }
+    }
+    async handleBranchSuggestionsRequest(msg) {
+        const { cwd, query, limit, requestId } = msg;
+        try {
+            const resolvedCwd = expandTilde(cwd);
+            const branchDetails = await this.workspaceGitService.suggestBranchesForCwd(resolvedCwd, {
+                query,
+                limit,
+            });
+            this.host.emit({
+                type: "branch_suggestions_response",
+                payload: {
+                    branches: branchDetails.map((branch) => branch.name),
+                    branchDetails,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.host.emit({
+                type: "branch_suggestions_response",
+                payload: {
+                    branches: [],
+                    branchDetails: [],
+                    error: error instanceof Error ? error.message : String(error),
+                    requestId,
+                },
+            });
+        }
+    }
+    async handleSubscribeDiffRequest(msg) {
+        const cwd = expandTilde(msg.cwd);
+        this.diffSubscriptions.get(msg.subscriptionId)?.();
+        this.diffSubscriptions.delete(msg.subscriptionId);
+        const subscription = await this.checkoutDiffManager.subscribe({ cwd, compare: msg.compare }, (snapshot) => {
+            this.host.emit({
+                type: "checkout_diff_update",
+                payload: {
+                    subscriptionId: msg.subscriptionId,
+                    ...snapshot,
+                },
+            });
+        });
+        this.diffSubscriptions.set(msg.subscriptionId, subscription.unsubscribe);
+        this.host.emit({
+            type: "subscribe_checkout_diff_response",
+            payload: {
+                subscriptionId: msg.subscriptionId,
+                ...subscription.initial,
+                requestId: msg.requestId,
+            },
+        });
+    }
+    handleUnsubscribeDiffRequest(msg) {
+        this.diffSubscriptions.get(msg.subscriptionId)?.();
+        this.diffSubscriptions.delete(msg.subscriptionId);
+    }
+    async handleRefreshRequest(msg) {
+        const { cwd, requestId } = msg;
+        const resolvedCwd = expandTilde(cwd);
+        try {
+            this.github.invalidate({ cwd: resolvedCwd });
+            await this.workspaceGitService.getSnapshot(resolvedCwd, {
+                force: true,
+                includeGitHub: true,
+                reason: "manual-refresh",
+            });
+            this.checkoutDiffManager.scheduleRefreshForCwd(resolvedCwd);
+            this.host.emit({
+                type: "checkout.refresh.response",
+                payload: {
+                    cwd,
+                    success: true,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.host.emit({
+                type: "checkout.refresh.response",
+                payload: {
+                    cwd,
+                    success: false,
+                    error: toCheckoutError(error),
+                    requestId,
+                },
+            });
+        }
+    }
+    emitStatusUpdate(cwd, snapshot) {
+        try {
+            const requestId = `subscription:${cwd}`;
+            this.host.emit({
+                type: "checkout_status_update",
+                payload: {
+                    ...buildCheckoutStatusPayloadFromSnapshot({
+                        cwd,
+                        requestId,
+                        snapshot,
+                    }),
+                    prStatus: buildCheckoutPrStatusPayloadFromSnapshot({
+                        cwd,
+                        requestId,
+                        snapshot,
+                    }),
+                },
+            });
+        }
+        catch (error) {
+            this.logger.warn({ err: error, cwd }, "Failed to emit workspace checkout status update");
+        }
+    }
+    /**
+     * Notify the live diff subscriptions that the working tree at `cwd` changed.
+     * Called by the command handlers below after they mutate the repository.
+     */
+    scheduleDiffRefresh(cwd) {
+        this.checkoutDiffManager.scheduleRefreshForCwd(cwd);
+    }
+    // ---------------------------------------------------------------------------
+    // Command operations (writes) and GitHub-PR operations
+    // ---------------------------------------------------------------------------
+    async handleCheckoutSwitchBranchRequest(msg) {
+        const { cwd, branch, requestId } = msg;
+        try {
+            const checkoutResult = await this.gitMutation.checkoutExistingBranch(cwd, branch);
+            this.scheduleDiffRefresh(cwd);
+            // Push a workspace_update immediately so the sidebar/header reflect
+            // the new branch name without waiting for the background git watcher.
+            await this.host.emitWorkspaceUpdateForCwd(cwd);
+            this.host.emit({
+                type: "checkout_switch_branch_response",
+                payload: {
+                    cwd,
+                    success: true,
+                    branch,
+                    source: checkoutResult.source,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.host.emit({
+                type: "checkout_switch_branch_response",
+                payload: {
+                    cwd,
+                    success: false,
+                    branch,
+                    error: toCheckoutError(error),
+                    requestId,
+                },
+            });
+        }
+    }
+    async handleCheckoutRenameBranchRequest(msg) {
+        const { cwd, branch, requestId } = msg;
+        const validation = validateBranchSlug(branch);
+        if (!validation.valid) {
+            this.host.emit({
+                type: "checkout.rename_branch.response",
+                payload: {
+                    cwd,
+                    success: false,
+                    currentBranch: null,
+                    error: toCheckoutError(new Error(validation.error ?? "Invalid branch name")),
+                    requestId,
+                },
+            });
+            return;
+        }
+        try {
+            const result = await this.host.renameCurrentBranch(cwd, branch);
+            await this.gitMutation.notifyGitMutation(cwd, "rename-branch", { invalidateGithub: true });
+            this.scheduleDiffRefresh(cwd);
+            this.host.handleWorkspaceGitBranchSnapshot(cwd, result.currentBranch);
+            // Branch is a git fact derived per-descriptor from each workspace's own
+            // live git snapshot (id → cwd); the reconciliation pass re-persists the
+            // `branch` field per workspace from its own cwd. No cwd → ids fan-out here.
+            // TODO(K10): PR-binding on branch rename is deferred — see plan K10.
+            // Push a workspace_update immediately so the sidebar/header reflect
+            // the new branch name without waiting for the background git watcher.
+            await this.host.emitWorkspaceUpdateForCwd(cwd);
+            this.host.emit({
+                type: "checkout.rename_branch.response",
+                payload: {
+                    cwd,
+                    success: true,
+                    currentBranch: result.currentBranch,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.host.emit({
+                type: "checkout.rename_branch.response",
+                payload: {
+                    cwd,
+                    success: false,
+                    currentBranch: null,
+                    error: toCheckoutError(error),
+                    requestId,
+                },
+            });
+        }
+    }
+    async handleStashSaveRequest(msg) {
+        const { cwd, requestId } = msg;
+        try {
+            const branchLabel = msg.branch?.trim() ?? "";
+            const message = branchLabel
+                ? `${CheckoutSession.OTTO_STASH_PREFIX} ${branchLabel}`
+                : `${CheckoutSession.OTTO_STASH_PREFIX} unnamed`;
+            await execCommand("git", ["stash", "push", "--include-untracked", "-m", message], {
+                cwd,
+            });
+            await this.gitMutation.notifyGitMutation(cwd, "stash-push");
+            this.scheduleDiffRefresh(cwd);
+            this.host.emit({
+                type: "stash_save_response",
+                payload: { cwd, success: true, error: null, requestId },
+            });
+        }
+        catch (error) {
+            this.host.emit({
+                type: "stash_save_response",
+                payload: { cwd, success: false, error: toCheckoutError(error), requestId },
+            });
+        }
+    }
+    async handleStashPopRequest(msg) {
+        const { cwd, stashIndex, requestId } = msg;
+        try {
+            await execCommand("git", ["stash", "pop", `stash@{${stashIndex}}`], {
+                cwd,
+            });
+            await this.gitMutation.notifyGitMutation(cwd, "stash-pop");
+            this.scheduleDiffRefresh(cwd);
+            this.host.emit({
+                type: "stash_pop_response",
+                payload: { cwd, success: true, error: null, requestId },
+            });
+        }
+        catch (error) {
+            this.host.emit({
+                type: "stash_pop_response",
+                payload: { cwd, success: false, error: toCheckoutError(error), requestId },
+            });
+        }
+    }
+    async handleStashListRequest(msg) {
+        const { cwd, requestId } = msg;
+        const ottoOnly = msg.ottoOnly !== false;
+        try {
+            const entries = await this.workspaceGitService.listStashes(cwd, { ottoOnly });
+            this.host.emit({
+                type: "stash_list_response",
+                payload: { cwd, entries, error: null, requestId },
+            });
+        }
+        catch (error) {
+            this.host.emit({
+                type: "stash_list_response",
+                payload: { cwd, entries: [], error: toCheckoutError(error), requestId },
+            });
+        }
+    }
+    async handleCheckoutCommitRequest(msg) {
+        const { cwd, requestId } = msg;
+        try {
+            let message = msg.message?.trim() ?? "";
+            if (!message) {
+                message = await this.gitMetadataGenerator.generateCommitMessage(cwd);
+            }
+            if (!message) {
+                throw new Error("Commit message is required");
+            }
+            await commitChanges(cwd, {
+                message,
+                addAll: msg.addAll ?? true,
+            });
+            await this.gitMutation.notifyGitMutation(cwd, "commit-changes");
+            this.scheduleDiffRefresh(cwd);
+            this.host.emit({
+                type: "checkout_commit_response",
+                payload: {
+                    cwd,
+                    success: true,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.host.emit({
+                type: "checkout_commit_response",
+                payload: {
+                    cwd,
+                    success: false,
+                    error: toCheckoutError(error),
+                    requestId,
+                },
+            });
+        }
+    }
+    async handleCheckoutMergeRequest(msg) {
+        const { cwd, requestId } = msg;
+        try {
+            const snapshot = await this.workspaceGitService.getSnapshot(cwd);
+            if (!snapshot.git.isGit) {
+                throw new Error(`Not a git repository: ${cwd}`);
+            }
+            if (msg.requireCleanTarget) {
+                if (snapshot.git.isDirty) {
+                    throw new Error("Working directory has uncommitted changes.");
+                }
+            }
+            let baseRef = msg.baseRef ?? snapshot.git.baseRef;
+            if (!baseRef) {
+                throw new Error("Base branch is required for merge");
+            }
+            if (baseRef.startsWith("origin/")) {
+                baseRef = baseRef.slice("origin/".length);
+            }
+            const mutatedCwd = await mergeToBase(cwd, {
+                baseRef,
+                mode: msg.strategy === "squash" ? "squash" : "merge",
+            }, { ottoHome: this.ottoHome, worktreesRoot: this.worktreesRoot });
+            await Promise.all([
+                this.gitMutation.notifyGitMutation(mutatedCwd, "merge-to-base", { invalidateGithub: true }),
+                ...(mutatedCwd !== cwd ? [this.gitMutation.notifyGitMutation(cwd, "merge-to-base")] : []),
+            ]);
+            this.scheduleDiffRefresh(cwd);
+            this.host.emit({
+                type: "checkout_merge_response",
+                payload: {
+                    cwd,
+                    success: true,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.host.emit({
+                type: "checkout_merge_response",
+                payload: {
+                    cwd,
+                    success: false,
+                    error: toCheckoutError(error),
+                    requestId,
+                },
+            });
+        }
+    }
+    async handleCheckoutMergeFromBaseRequest(msg) {
+        const { cwd, requestId } = msg;
+        try {
+            if (msg.requireCleanTarget ?? true) {
+                const snapshot = await this.workspaceGitService.getSnapshot(cwd);
+                if (snapshot.git.isDirty) {
+                    throw new Error("Working directory has uncommitted changes.");
+                }
+            }
+            await mergeFromBase(cwd, {
+                baseRef: msg.baseRef,
+                requireCleanTarget: msg.requireCleanTarget ?? true,
+            });
+            await this.gitMutation.notifyGitMutation(cwd, "merge-from-base", { invalidateGithub: true });
+            this.scheduleDiffRefresh(cwd);
+            this.host.emit({
+                type: "checkout_merge_from_base_response",
+                payload: {
+                    cwd,
+                    success: true,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.host.emit({
+                type: "checkout_merge_from_base_response",
+                payload: {
+                    cwd,
+                    success: false,
+                    error: toCheckoutError(error),
+                    requestId,
+                },
+            });
+        }
+    }
+    async handleCheckoutPullRequest(msg) {
+        const { cwd, requestId } = msg;
+        try {
+            await pullCurrentBranch(cwd);
+            await this.gitMutation.notifyGitMutation(cwd, "pull", { invalidateGithub: true });
+            this.scheduleDiffRefresh(cwd);
+            this.host.emit({
+                type: "checkout_pull_response",
+                payload: {
+                    cwd,
+                    success: true,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.host.emit({
+                type: "checkout_pull_response",
+                payload: {
+                    cwd,
+                    success: false,
+                    error: toCheckoutError(error),
+                    requestId,
+                },
+            });
+        }
+    }
+    async handleCheckoutPushRequest(msg) {
+        const { cwd, requestId } = msg;
+        try {
+            await pushCurrentBranch(cwd);
+            await this.gitMutation.notifyGitMutation(cwd, "push", { invalidateGithub: true });
+            this.host.emit({
+                type: "checkout_push_response",
+                payload: {
+                    cwd,
+                    success: true,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.host.emit({
+                type: "checkout_push_response",
+                payload: {
+                    cwd,
+                    success: false,
+                    error: toCheckoutError(error),
+                    requestId,
+                },
+            });
+        }
+    }
+    async handleCheckoutPrCreateRequest(msg) {
+        const { cwd, requestId } = msg;
+        try {
+            let title = msg.title?.trim() ?? "";
+            let body = msg.body?.trim() ?? "";
+            if (!title || !body) {
+                const generated = await this.gitMetadataGenerator.generatePullRequestText(cwd, msg.baseRef);
+                if (!title)
+                    title = generated.title;
+                if (!body)
+                    body = generated.body;
+            }
+            const result = await createPullRequest(cwd, {
+                title,
+                body,
+                base: msg.baseRef,
+            }, this.github);
+            await this.gitMutation.notifyGitMutation(cwd, "create-pr", { invalidateGithub: true });
+            this.host.emit({
+                type: "checkout_pr_create_response",
+                payload: {
+                    cwd,
+                    url: result.url ?? null,
+                    number: result.number ?? null,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.host.emit({
+                type: "checkout_pr_create_response",
+                payload: {
+                    cwd,
+                    url: null,
+                    number: null,
+                    error: toCheckoutError(error),
+                    requestId,
+                },
+            });
+        }
+    }
+    async handleCheckoutPrMergeRequest(msg) {
+        const { cwd, requestId } = msg;
+        try {
+            const pullRequest = await this.resolveCurrentPullRequest(cwd, "merge", {
+                force: true,
+                includeGitHub: true,
+                reason: "merge-pr-validation",
+            });
+            this.assertCurrentPullRequestHasGithubMergeFacts(pullRequest);
+            await this.github.mergePullRequest({
+                cwd,
+                prNumber: pullRequest.number,
+                mergeMethod: msg.mergeMethod,
+                status: pullRequest,
+            });
+            await this.gitMutation.notifyGitMutation(cwd, "merge-pr", { invalidateGithub: true });
+            this.host.emit({
+                type: "checkout_pr_merge_response",
+                payload: {
+                    cwd,
+                    success: true,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.host.emit({
+                type: "checkout_pr_merge_response",
+                payload: {
+                    cwd,
+                    success: false,
+                    error: toCheckoutError(error),
+                    requestId,
+                },
+            });
+        }
+    }
+    assertCurrentPullRequestHasGithubMergeFacts(pullRequest) {
+        if (!pullRequest.github) {
+            throw new Error("GitHub merge facts are unavailable for this pull request");
+        }
+    }
+    async handleCheckoutGithubSetAutoMergeRequest(msg) {
+        const { cwd, requestId } = msg;
+        try {
+            const pullRequest = await this.resolveCurrentPullRequest(cwd, "auto-merge", {
+                force: true,
+                includeGitHub: true,
+                reason: "auto-merge-validation",
+            });
+            if (msg.enabled) {
+                const mergeMethod = msg.mergeMethod;
+                if (!mergeMethod) {
+                    throw new Error("mergeMethod is required when enabling auto-merge");
+                }
+                assertPullRequestAutoMergeEnableReady({
+                    mergeMethod,
+                    status: pullRequest,
+                });
+                await this.github.enablePullRequestAutoMerge({
+                    cwd,
+                    prNumber: pullRequest.number,
+                    mergeMethod,
+                    status: pullRequest,
+                });
+            }
+            else {
+                if (msg.mergeMethod) {
+                    throw new Error("mergeMethod is not allowed when disabling auto-merge");
+                }
+                assertPullRequestAutoMergeDisableReady({ status: pullRequest });
+                await this.github.disablePullRequestAutoMerge({
+                    cwd,
+                    prNumber: pullRequest.number,
+                    status: pullRequest,
+                });
+            }
+            await this.gitMutation.notifyGitMutation(cwd, msg.enabled ? "enable-pr-auto-merge" : "disable-pr-auto-merge", {
+                invalidateGithub: true,
+            });
+            this.host.emit({
+                type: "checkout.github.set_auto_merge.response",
+                payload: {
+                    cwd,
+                    enabled: msg.enabled,
+                    success: true,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.host.emit({
+                type: "checkout.github.set_auto_merge.response",
+                payload: {
+                    cwd,
+                    enabled: msg.enabled,
+                    success: false,
+                    error: toCheckoutError(error),
+                    requestId,
+                },
+            });
+        }
+    }
+    async resolveCurrentPullRequest(cwd, operation, options) {
+        const snapshot = await this.workspaceGitService.getSnapshot(cwd, options);
+        const pullRequest = snapshot.github.pullRequest;
+        if (!pullRequest || typeof pullRequest.number !== "number") {
+            throw new Error(`Unable to determine GitHub pull request number for ${operation}`);
+        }
+        return { ...pullRequest, number: pullRequest.number };
+    }
+    async handleCheckoutPrStatusRequest(msg) {
+        const { cwd, requestId } = msg;
+        try {
+            const snapshot = await this.workspaceGitService.getSnapshot(cwd);
+            this.host.emit({
+                type: "checkout_pr_status_response",
+                payload: buildCheckoutPrStatusPayloadFromSnapshot({
+                    cwd,
+                    requestId,
+                    snapshot,
+                }),
+            });
+        }
+        catch (error) {
+            this.host.emit({
+                type: "checkout_pr_status_response",
+                payload: {
+                    cwd,
+                    status: null,
+                    githubFeaturesEnabled: true,
+                    error: toCheckoutError(error),
+                    requestId,
+                },
+            });
+        }
+    }
+    async handlePullRequestTimelineRequest(msg) {
+        const { cwd, prNumber, repoOwner, repoName, requestId } = msg;
+        if (!isValidPullRequestTimelineIdentity({ prNumber, repoOwner, repoName })) {
+            this.host.emit({
+                type: "pull_request_timeline_response",
+                payload: {
+                    cwd,
+                    prNumber,
+                    items: [],
+                    truncated: false,
+                    error: {
+                        kind: "unknown",
+                        message: "Pull request timeline request has invalid PR identity",
+                    },
+                    requestId,
+                    githubFeaturesEnabled: true,
+                },
+            });
+            return;
+        }
+        // Treat missing CLI/credentials as features-off, not a thrown failure —
+        // the router surfaces GitHostingCredentialsMissingError for providers
+        // whose project has no token configured yet.
+        const githubFeaturesEnabled = await this.github.isAuthenticated({ cwd }).catch(() => false);
+        if (!githubFeaturesEnabled) {
+            this.host.emit({
+                type: "pull_request_timeline_response",
+                payload: {
+                    cwd,
+                    prNumber,
+                    items: [],
+                    truncated: false,
+                    error: {
+                        kind: "unknown",
+                        message: "GitHub CLI is unavailable or not authenticated",
+                    },
+                    requestId,
+                    githubFeaturesEnabled: false,
+                },
+            });
+            return;
+        }
+        try {
+            const timeline = await this.github.getPullRequestTimeline({
+                cwd,
+                prNumber,
+                repoOwner,
+                repoName,
+            });
+            this.host.emit({
+                type: "pull_request_timeline_response",
+                payload: {
+                    cwd,
+                    prNumber: timeline.prNumber,
+                    items: timeline.items.map(toPullRequestTimelinePayloadItem),
+                    truncated: timeline.truncated,
+                    error: timeline.error,
+                    requestId,
+                    githubFeaturesEnabled: true,
+                },
+            });
+        }
+        catch (error) {
+            this.host.emit({
+                type: "pull_request_timeline_response",
+                payload: {
+                    cwd,
+                    prNumber,
+                    items: [],
+                    truncated: false,
+                    error: {
+                        kind: "unknown",
+                        message: error instanceof Error ? error.message : String(error),
+                    },
+                    requestId,
+                    githubFeaturesEnabled: true,
+                },
+            });
+        }
+    }
+    async handleCheckoutGithubGetCheckDetailsRequest(msg) {
+        const { cwd, repoOwner, repoName, checkRunId, workflowRunId, requestId } = msg;
+        try {
+            const details = await this.github.getGitHubCheckDetails({
+                cwd,
+                repoOwner,
+                repoName,
+                checkRunId,
+                workflowRunId,
+            });
+            this.host.emit({
+                type: "checkout.github.get_check_details.response",
+                payload: {
+                    cwd,
+                    success: true,
+                    details,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.host.emit({
+                type: "checkout.github.get_check_details.response",
+                payload: {
+                    cwd,
+                    success: false,
+                    details: null,
+                    error: {
+                        code: "UNKNOWN",
+                        message: error instanceof Error ? error.message : String(error),
+                    },
+                    requestId,
+                },
+            });
+        }
+    }
+    async handleGitHubSearchRequest(msg) {
+        const { cwd, query, limit, kinds, requestId } = msg;
+        try {
+            const resolvedCwd = expandTilde(cwd);
+            const result = await this.github.searchIssuesAndPrs({
+                cwd: resolvedCwd,
+                query,
+                limit,
+                kinds,
+            });
+            this.host.emit({
+                type: "github_search_response",
+                payload: {
+                    items: result.items,
+                    githubFeaturesEnabled: result.githubFeaturesEnabled,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.host.emit({
+                type: "github_search_response",
+                payload: {
+                    items: [],
+                    githubFeaturesEnabled: true,
+                    error: error instanceof Error ? error.message : String(error),
+                    requestId,
+                },
+            });
+        }
+    }
+    // Provider-neutral successor to handleGitHubSearchRequest: resolves the
+    // project's hosting provider from cwd, so a Bitbucket project searches
+    // Bitbucket PRs and a GitHub project searches GitHub issues + PRs.
+    async handleHostingSearchRequest(msg) {
+        const { cwd, query, limit, kinds, requestId } = msg;
+        const resolvedCwd = expandTilde(cwd);
+        const resolved = this.gitHostingResolver
+            ? await this.gitHostingResolver.resolveForCwd(resolvedCwd).catch(() => null)
+            : null;
+        const provider = resolved?.providerId ?? "github";
+        if (resolved && !resolved.service) {
+            this.host.emit({
+                type: "hosting.search.response",
+                payload: {
+                    items: [],
+                    provider,
+                    featuresEnabled: false,
+                    error: null,
+                    requestId,
+                },
+            });
+            return;
+        }
+        try {
+            const requestedKinds = kinds ?? ["issue", "pr"];
+            const result = await this.github.searchIssuesAndPrs({
+                cwd: resolvedCwd,
+                query,
+                limit,
+                kinds: requestedKinds.map((kind) => (kind === "issue" ? "github-issue" : "github-pr")),
+            });
+            this.host.emit({
+                type: "hosting.search.response",
+                payload: {
+                    items: result.items,
+                    provider,
+                    featuresEnabled: result.githubFeaturesEnabled,
+                    error: null,
+                    requestId,
+                },
+            });
+        }
+        catch (error) {
+            if (isGitHostingFeatureDisabledError(error)) {
+                this.host.emit({
+                    type: "hosting.search.response",
+                    payload: {
+                        items: [],
+                        provider,
+                        featuresEnabled: false,
+                        error: null,
+                        requestId,
+                    },
+                });
+                return;
+            }
+            this.host.emit({
+                type: "hosting.search.response",
+                payload: {
+                    items: [],
+                    provider,
+                    featuresEnabled: true,
+                    error: error instanceof Error ? error.message : String(error),
+                    requestId,
+                },
+            });
+        }
+    }
+    cleanup() {
+        for (const unsubscribe of this.diffSubscriptions.values()) {
+            unsubscribe();
+        }
+        this.diffSubscriptions.clear();
+    }
+}
+CheckoutSession.OTTO_STASH_PREFIX = "otto-auto-stash:";
+function isValidPullRequestTimelineIdentity(options) {
+    if (!Number.isInteger(options.prNumber) || options.prNumber <= 0) {
+        return false;
+    }
+    return isValidGitHubRepoSegment(options.repoOwner) && isValidGitHubRepoSegment(options.repoName);
+}
+function isValidGitHubRepoSegment(value) {
+    return /^[A-Za-z0-9._-]+$/.test(value);
+}
+function toPullRequestTimelinePayloadItem(item) {
+    return item;
+}
+//# sourceMappingURL=checkout-session.js.map