@iaforged/context-code 1.0.63 → 1.0.65

package/dist/src/utils/teleport.js

@@ -1,1041 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import axios from 'axios';
-import chalk from 'chalk';
-import { randomUUID } from 'crypto';
-import { getOriginalCwd, getSessionId } from '../bootstrap/state.js';
-import { checkGate_CACHED_OR_BLOCKING } from '../services/analytics/growthbook.js';
-import { logEvent } from '../services/analytics/index.js';
-import { isPolicyAllowed } from '../services/policyLimits/index.js';
-import { z } from 'zod/v4';
-import { getTeleportErrors, TeleportError } from '../components/TeleportError.js';
-import { getOauthConfig } from '../constants/oauth.js';
-import { KeybindingSetup } from '../keybindings/KeybindingProviderSetup.js';
-import { queryHaiku } from '../services/api/claude.js';
-import { getSessionLogsViaOAuth, getTeleportEvents } from '../services/api/sessionIngress.js';
-import { getOrganizationUUID } from '../services/oauth/client.js';
-import { AppStateProvider } from '../state/AppState.js';
-import { checkAndRefreshOAuthTokenIfNeeded, getClaudeAIOAuthTokens } from './auth.js';
-import { checkGithubAppInstalled } from './background/remote/preconditions.js';
-import { deserializeMessages } from './conversationRecovery.js';
-import { getCwd } from './cwd.js';
-import { logForDebugging } from './debug.js';
-import { detectCurrentRepositoryWithHost, parseGitHubRepository, parseGitRemote } from './detectRepository.js';
-import { isEnvTruthy } from './envUtils.js';
-import { TeleportOperationError, toError } from './errors.js';
-import { execFileNoThrow } from './execFileNoThrow.js';
-import { truncateToWidth } from './format.js';
-import { findGitRoot, getDefaultBranch, getIsClean, gitExe } from './git.js';
-import { safeParseJSON } from './json.js';
-import { logError } from './log.js';
-import { createSystemMessage, createUserMessage } from './messages.js';
-import { getMainLoopModel } from './model/model.js';
-import { isTranscriptMessage } from './sessionStorage.js';
-import { getSettings_DEPRECATED } from './settings/settings.js';
-import { jsonStringify } from './slowOperations.js';
-import { asSystemPrompt } from './systemPromptType.js';
-import { fetchSession, getBranchFromSession, getOAuthHeaders } from './teleport/api.js';
-import { fetchEnvironments } from './teleport/environments.js';
-import { createAndUploadGitBundle } from './teleport/gitBundle.js';
-/**
- * Creates a system message to inform about teleport session resume
- * @returns SystemMessage indicating session was resumed from another machine
- */
-function createTeleportResumeSystemMessage(branchError) {
-    if (branchError === null) {
-        return createSystemMessage('Session resumed', 'suggestion');
-    }
-    const formattedError = branchError instanceof TeleportOperationError ? branchError.formattedMessage : branchError.message;
-    return createSystemMessage(`Session resumed without branch: ${formattedError}`, 'warning');
-}
-/**
- * Creates a user message to inform the model about teleport session resume
- * @returns User message indicating session was resumed from another machine
- */
-function createTeleportResumeUserMessage() {
-    return createUserMessage({
-        content: `This session is being continued from another machine. Application state may have changed. The updated working directory is ${getOriginalCwd()}`,
-        isMeta: true
-    });
-}
-const SESSION_TITLE_AND_BRANCH_PROMPT = `You are coming up with a succinct title and git branch name for a coding session based on the provided description. The title should be clear, concise, and accurately reflect the content of the coding task.
-You should keep it short and simple, ideally no more than 6 words. Avoid using jargon or overly technical terms unless absolutely necessary. The title should be easy to understand for anyone reading it.
-Use sentence case for the title (capitalize only the first word and proper nouns), not Title Case.
-
-The branch name should be clear, concise, and accurately reflect the content of the coding task.
-You should keep it short and simple, ideally no more than 4 words. The branch should always start with "context/" and should be all lower case, with words separated by dashes.
-
-Return a JSON object with "title" and "branch" fields.
-
-Example 1: {"title": "Fix login button not working on mobile", "branch": "context/fix-mobile-login-button"}
-Example 2: {"title": "Update README with installation instructions", "branch": "context/update-readme"}
-Example 3: {"title": "Improve performance of data processing script", "branch": "context/improve-data-processing"}
-
-Here is the session description:
-<description>{description}</description>
-Please generate a title and branch name for this session.`;
-/**
- * Generates a title and branch name for a coding session using Claude Haiku
- * @param description The description/prompt for the session
- * @returns Promise<TitleAndBranch> The generated title and branch name
- */
-async function generateTitleAndBranch(description, signal) {
-    const fallbackTitle = truncateToWidth(description, 75);
-    const fallbackBranch = 'context/task';
-    try {
-        const userPrompt = SESSION_TITLE_AND_BRANCH_PROMPT.replace('{description}', description);
-        const response = await queryHaiku({
-            systemPrompt: asSystemPrompt([]),
-            userPrompt,
-            outputFormat: {
-                type: 'json_schema',
-                schema: {
-                    type: 'object',
-                    properties: {
-                        title: {
-                            type: 'string'
-                        },
-                        branch: {
-                            type: 'string'
-                        }
-                    },
-                    required: ['title', 'branch'],
-                    additionalProperties: false
-                }
-            },
-            signal,
-            options: {
-                querySource: 'teleport_generate_title',
-                agents: [],
-                isNonInteractiveSession: false,
-                hasAppendSystemPrompt: false,
-                mcpTools: []
-            }
-        });
-        // Extract text from the response
-        const firstBlock = response.message.content[0];
-        if (firstBlock?.type !== 'text') {
-            return {
-                title: fallbackTitle,
-                branchName: fallbackBranch
-            };
-        }
-        const parsed = safeParseJSON(firstBlock.text.trim());
-        const parseResult = z.object({
-            title: z.string(),
-            branch: z.string()
-        }).safeParse(parsed);
-        if (parseResult.success) {
-            return {
-                title: parseResult.data.title || fallbackTitle,
-                branchName: parseResult.data.branch || fallbackBranch
-            };
-        }
-        return {
-            title: fallbackTitle,
-            branchName: fallbackBranch
-        };
-    }
-    catch (error) {
-        logError(new Error(`Error generating title and branch: ${error}`));
-        return {
-            title: fallbackTitle,
-            branchName: fallbackBranch
-        };
-    }
-}
-/**
- * Validates that the git working directory is clean (ignoring untracked files)
- * Untracked files are ignored because they won't be lost during branch switching
- */
-export async function validateGitState() {
-    const isClean = await getIsClean({
-        ignoreUntracked: true
-    });
-    if (!isClean) {
-        logEvent('tengu_teleport_error_git_not_clean', {});
-        const error = new TeleportOperationError('Git working directory is not clean. Please commit or stash your changes before using --teleport.', chalk.red('Error: Git working directory is not clean. Please commit or stash your changes before using --teleport.\n'));
-        throw error;
-    }
-}
-/**
- * Fetches a specific branch from remote origin
- * @param branch The branch to fetch. If not specified, fetches all branches.
- */
-async function fetchFromOrigin(branch) {
-    const fetchArgs = branch ? ['fetch', 'origin', `${branch}:${branch}`] : ['fetch', 'origin'];
-    const { code: fetchCode, stderr: fetchStderr } = await execFileNoThrow(gitExe(), fetchArgs);
-    if (fetchCode !== 0) {
-        // If fetching a specific branch fails, it might not exist locally yet
-        // Try fetching just the ref without mapping to local branch
-        if (branch && fetchStderr.includes('refspec')) {
-            logForDebugging(`Specific branch fetch failed, trying to fetch ref: ${branch}`);
-            const { code: refFetchCode, stderr: refFetchStderr } = await execFileNoThrow(gitExe(), ['fetch', 'origin', branch]);
-            if (refFetchCode !== 0) {
-                logError(new Error(`Failed to fetch from remote origin: ${refFetchStderr}`));
-            }
-        }
-        else {
-            logError(new Error(`Failed to fetch from remote origin: ${fetchStderr}`));
-        }
-    }
-}
-/**
- * Ensures that the current branch has an upstream set
- * If not, sets it to origin/<branchName> if that remote branch exists
- */
-async function ensureUpstreamIsSet(branchName) {
-    // Check if upstream is already set
-    const { code: upstreamCheckCode } = await execFileNoThrow(gitExe(), ['rev-parse', '--abbrev-ref', `${branchName}@{upstream}`]);
-    if (upstreamCheckCode === 0) {
-        // Upstream is already set
-        logForDebugging(`Branch '${branchName}' already has upstream set`);
-        return;
-    }
-    // Check if origin/<branchName> exists
-    const { code: remoteCheckCode } = await execFileNoThrow(gitExe(), ['rev-parse', '--verify', `origin/${branchName}`]);
-    if (remoteCheckCode === 0) {
-        // Remote branch exists, set upstream
-        logForDebugging(`Setting upstream for '${branchName}' to 'origin/${branchName}'`);
-        const { code: setUpstreamCode, stderr: setUpstreamStderr } = await execFileNoThrow(gitExe(), ['branch', '--set-upstream-to', `origin/${branchName}`, branchName]);
-        if (setUpstreamCode !== 0) {
-            logForDebugging(`Failed to set upstream for '${branchName}': ${setUpstreamStderr}`);
-            // Don't throw, just log - this is not critical
-        }
-        else {
-            logForDebugging(`Successfully set upstream for '${branchName}'`);
-        }
-    }
-    else {
-        logForDebugging(`Remote branch 'origin/${branchName}' does not exist, skipping upstream setup`);
-    }
-}
-/**
- * Checks out a specific branch
- */
-async function checkoutBranch(branchName) {
-    // First try to checkout the branch as-is (might be local)
-    let { code: checkoutCode, stderr: checkoutStderr } = await execFileNoThrow(gitExe(), ['checkout', branchName]);
-    // If that fails, try to checkout from origin
-    if (checkoutCode !== 0) {
-        logForDebugging(`Local checkout failed, trying to checkout from origin: ${checkoutStderr}`);
-        // Try to checkout the remote branch and create a local tracking branch
-        const result = await execFileNoThrow(gitExe(), ['checkout', '-b', branchName, '--track', `origin/${branchName}`]);
-        checkoutCode = result.code;
-        checkoutStderr = result.stderr;
-        // If that also fails, try without -b in case the branch exists but isn't checked out
-        if (checkoutCode !== 0) {
-            logForDebugging(`Remote checkout with -b failed, trying without -b: ${checkoutStderr}`);
-            const finalResult = await execFileNoThrow(gitExe(), ['checkout', '--track', `origin/${branchName}`]);
-            checkoutCode = finalResult.code;
-            checkoutStderr = finalResult.stderr;
-        }
-    }
-    if (checkoutCode !== 0) {
-        logEvent('tengu_teleport_error_branch_checkout_failed', {});
-        throw new TeleportOperationError(`Failed to checkout branch '${branchName}': ${checkoutStderr}`, chalk.red(`Failed to checkout branch '${branchName}'\n`));
-    }
-    // After successful checkout, ensure upstream is set
-    await ensureUpstreamIsSet(branchName);
-}
-/**
- * Gets the current branch name
- */
-async function getCurrentBranch() {
-    const { stdout: currentBranch } = await execFileNoThrow(gitExe(), ['branch', '--show-current']);
-    return currentBranch.trim();
-}
-/**
- * Processes messages for teleport resume, removing incomplete tool_use blocks
- * and adding teleport notice messages
- * @param messages The conversation messages
- * @param error Optional error from branch checkout
- * @returns Processed messages ready for resume
- */
-export function processMessagesForTeleportResume(messages, error) {
-    // Shared logic with resume for handling interruped session transcripts
-    const deserializedMessages = deserializeMessages(messages);
-    // Add user message about teleport resume (visible to model)
-    const messagesWithTeleportNotice = [...deserializedMessages, createTeleportResumeUserMessage(), createTeleportResumeSystemMessage(error)];
-    return messagesWithTeleportNotice;
-}
-/**
- * Checks out the specified branch for a teleported session
- * @param branch Optional branch to checkout
- * @returns The current branch name and any error that occurred
- */
-export async function checkOutTeleportedSessionBranch(branch) {
-    try {
-        const currentBranch = await getCurrentBranch();
-        logForDebugging(`Current branch before teleport: '${currentBranch}'`);
-        if (branch) {
-            logForDebugging(`Switching to branch '${branch}'...`);
-            await fetchFromOrigin(branch);
-            await checkoutBranch(branch);
-            const newBranch = await getCurrentBranch();
-            logForDebugging(`Branch after checkout: '${newBranch}'`);
-        }
-        else {
-            logForDebugging('No branch specified, staying on current branch');
-        }
-        const branchName = await getCurrentBranch();
-        return {
-            branchName,
-            branchError: null
-        };
-    }
-    catch (error) {
-        const branchName = await getCurrentBranch();
-        const branchError = toError(error);
-        return {
-            branchName,
-            branchError
-        };
-    }
-}
-/**
- * Validates that the current repository matches the session's repository.
- * Returns a result object instead of throwing, allowing the caller to handle mismatches.
- *
- * @param sessionData The session resource to validate against
- * @returns Validation result with status and repo information
- */
-export async function validateSessionRepository(sessionData) {
-    const currentParsed = await detectCurrentRepositoryWithHost();
-    const currentRepo = currentParsed ? `${currentParsed.owner}/${currentParsed.name}` : null;
-    const gitSource = sessionData.session_context.sources.find((source) => source.type === 'git_repository');
-    if (!gitSource?.url) {
-        // Session has no repo requirement
-        logForDebugging(currentRepo ? 'Session has no associated repository, proceeding without validation' : 'Session has no repo requirement and not in git directory, proceeding');
-        return {
-            status: 'no_repo_required'
-        };
-    }
-    const sessionParsed = parseGitRemote(gitSource.url);
-    const sessionRepo = sessionParsed ? `${sessionParsed.owner}/${sessionParsed.name}` : parseGitHubRepository(gitSource.url);
-    if (!sessionRepo) {
-        return {
-            status: 'no_repo_required'
-        };
-    }
-    logForDebugging(`Session is for repository: ${sessionRepo}, current repo: ${currentRepo ?? 'none'}`);
-    if (!currentRepo) {
-        // Not in a git repo, but session requires one
-        return {
-            status: 'not_in_repo',
-            sessionRepo,
-            sessionHost: sessionParsed?.host,
-            currentRepo: null
-        };
-    }
-    // Compare both owner/repo and host to avoid cross-instance mismatches.
-    // Strip ports before comparing hosts — SSH remotes omit the port while
-    // HTTPS remotes may include a non-standard port (e.g. ghe.corp.com:8443),
-    // which would cause a false mismatch.
-    const stripPort = (host) => host.replace(/:\d+$/, '');
-    const repoMatch = currentRepo.toLowerCase() === sessionRepo.toLowerCase();
-    const hostMatch = !currentParsed || !sessionParsed || stripPort(currentParsed.host.toLowerCase()) === stripPort(sessionParsed.host.toLowerCase());
-    if (repoMatch && hostMatch) {
-        return {
-            status: 'match',
-            sessionRepo,
-            currentRepo
-        };
-    }
-    // Repo mismatch — keep sessionRepo/currentRepo as plain "owner/repo" so
-    // downstream consumers (e.g. getKnownPathsForRepo) can use them as lookup keys.
-    // Include host information in separate fields for display purposes.
-    return {
-        status: 'mismatch',
-        sessionRepo,
-        currentRepo,
-        sessionHost: sessionParsed?.host,
-        currentHost: currentParsed?.host
-    };
-}
-/**
- * Handles teleporting from a code session ID.
- * Fetches session logs and validates repo.
- * @param sessionId The session ID to resume
- * @param onProgress Optional callback for progress updates
- * @returns The raw session log and branch name
- */
-export async function teleportResumeCodeSession(sessionId, onProgress) {
-    if (!isPolicyAllowed('allow_remote_sessions')) {
-        throw new Error("Remote sessions are disabled by your organization's policy.");
-    }
-    logForDebugging(`Resuming code session ID: ${sessionId}`);
-    try {
-        const accessToken = getClaudeAIOAuthTokens()?.accessToken;
-        if (!accessToken) {
-            logEvent('tengu_teleport_resume_error', {
-                error_type: 'no_access_token'
-            });
-            throw new Error('Context Code web sessions require authentication with a Claude.ai account. API key authentication is not sufficient. Please run /login to authenticate, or check your authentication status with /status.');
-        }
-        // Get organization UUID
-        const orgUUID = await getOrganizationUUID();
-        if (!orgUUID) {
-            logEvent('tengu_teleport_resume_error', {
-                error_type: 'no_org_uuid'
-            });
-            throw new Error('Unable to get organization UUID for constructing session URL');
-        }
-        // Fetch and validate repository matches before resuming
-        onProgress?.('validating');
-        const sessionData = await fetchSession(sessionId);
-        const repoValidation = await validateSessionRepository(sessionData);
-        switch (repoValidation.status) {
-            case 'match':
-            case 'no_repo_required':
-                // Proceed with teleport
-                break;
-            case 'not_in_repo':
-                {
-                    logEvent('tengu_teleport_error_repo_not_in_git_dir_sessions_api', {
-                        sessionId: sessionId
-                    });
-                    // Include host for GHE users so they know which instance the repo is on
-                    const notInRepoDisplay = repoValidation.sessionHost && repoValidation.sessionHost.toLowerCase() !== 'github.com' ? `${repoValidation.sessionHost}/${repoValidation.sessionRepo}` : repoValidation.sessionRepo;
-                    throw new TeleportOperationError(`You must run claude --teleport ${sessionId} from a checkout of ${notInRepoDisplay}.`, chalk.red(`You must run claude --teleport ${sessionId} from a checkout of ${chalk.bold(notInRepoDisplay)}.\n`));
-                }
-            case 'mismatch':
-                {
-                    logEvent('tengu_teleport_error_repo_mismatch_sessions_api', {
-                        sessionId: sessionId
-                    });
-                    // Only include host prefix when hosts actually differ to disambiguate
-                    // cross-instance mismatches; for same-host mismatches the host is noise.
-                    const hostsDiffer = repoValidation.sessionHost && repoValidation.currentHost && repoValidation.sessionHost.replace(/:\d+$/, '').toLowerCase() !== repoValidation.currentHost.replace(/:\d+$/, '').toLowerCase();
-                    const sessionDisplay = hostsDiffer ? `${repoValidation.sessionHost}/${repoValidation.sessionRepo}` : repoValidation.sessionRepo;
-                    const currentDisplay = hostsDiffer ? `${repoValidation.currentHost}/${repoValidation.currentRepo}` : repoValidation.currentRepo;
-                    throw new TeleportOperationError(`You must run claude --teleport ${sessionId} from a checkout of ${sessionDisplay}.\nThis repo is ${currentDisplay}.`, chalk.red(`You must run claude --teleport ${sessionId} from a checkout of ${chalk.bold(sessionDisplay)}.\nThis repo is ${chalk.bold(currentDisplay)}.\n`));
-                }
-            case 'error':
-                throw new TeleportOperationError(repoValidation.errorMessage || 'Failed to validate session repository', chalk.red(`Error: ${repoValidation.errorMessage || 'Failed to validate session repository'}\n`));
-            default:
-                {
-                    const _exhaustive = repoValidation.status;
-                    throw new Error(`Unhandled repo validation status: ${_exhaustive}`);
-                }
-        }
-        return await teleportFromSessionsAPI(sessionId, orgUUID, accessToken, onProgress, sessionData);
-    }
-    catch (error) {
-        if (error instanceof TeleportOperationError) {
-            throw error;
-        }
-        const err = toError(error);
-        logError(err);
-        logEvent('tengu_teleport_resume_error', {
-            error_type: 'resume_session_id_catch'
-        });
-        throw new TeleportOperationError(err.message, chalk.red(`Error: ${err.message}\n`));
-    }
-}
-/**
- * Helper function to handle teleport prerequisites (authentication and git state)
- * Shows TeleportError dialog rendered into the existing root if needed
- */
-async function handleTeleportPrerequisites(root, errorsToIgnore) {
-    const errors = await getTeleportErrors();
-    if (errors.size > 0) {
-        // Log teleport errors detected
-        logEvent('tengu_teleport_errors_detected', {
-            error_types: Array.from(errors).join(','),
-            errors_ignored: Array.from(errorsToIgnore || []).join(',')
-        });
-        // Show TeleportError dialog for user interaction
-        await new Promise(resolve => {
-            root.render(_jsx(AppStateProvider, { children: _jsx(KeybindingSetup, { children: _jsx(TeleportError, { errorsToIgnore: errorsToIgnore, onComplete: () => {
-                            // Log when errors are resolved
-                            logEvent('tengu_teleport_errors_resolved', {
-                                error_types: Array.from(errors).join(',')
-                            });
-                            void resolve();
-                        } }) }) }));
-        });
-    }
-}
-/**
- * Creates a remote Claude.ai session with error handling and UI feedback.
- * Shows prerequisite error dialog in the existing root if needed.
- * @param root The existing Ink root to render dialogs into
- * @param description The description/prompt for the new session (null for no initial prompt)
- * @param signal AbortSignal for cancellation
- * @param branchName Optional branch name for the remote session to use
- * @returns Promise<TeleportToRemoteResponse | null> The created session or null if creation fails
- */
-export async function teleportToRemoteWithErrorHandling(root, description, signal, branchName) {
-    const errorsToIgnore = new Set(['needsGitStash']);
-    await handleTeleportPrerequisites(root, errorsToIgnore);
-    return teleportToRemote({
-        initialMessage: description,
-        signal,
-        branchName,
-        onBundleFail: msg => process.stderr.write(`\n${msg}\n`)
-    });
-}
-/**
- * Fetches session data from the session ingress API (/v1/session_ingress/)
- * Uses session logs instead of SDK events to get the correct message structure
- * @param sessionId The session ID to fetch
- * @param orgUUID The organization UUID
- * @param accessToken The OAuth access token
- * @param onProgress Optional callback for progress updates
- * @param sessionData Optional session data (used to extract branch info)
- * @returns TeleportRemoteResponse with session logs as Message[]
- */
-export async function teleportFromSessionsAPI(sessionId, orgUUID, accessToken, onProgress, sessionData) {
-    const startTime = Date.now();
-    try {
-        // Fetch session logs via session ingress
-        logForDebugging(`[teleport] Starting fetch for session: ${sessionId}`);
-        onProgress?.('fetching_logs');
-        const logsStartTime = Date.now();
-        // Try CCR v2 first (GetTeleportEvents — server dispatches Spanner/
-        // threadstore). Fall back to session-ingress if it returns null
-        // (endpoint not yet deployed, or transient error). Once session-ingress
-        // is gone, the fallback becomes a no-op — getSessionLogsViaOAuth will
-        // return null too and we fail with "Failed to fetch session logs".
-        let logs = await getTeleportEvents(sessionId, accessToken, orgUUID);
-        if (logs === null) {
-            logForDebugging('[teleport] v2 endpoint returned null, trying session-ingress');
-            logs = await getSessionLogsViaOAuth(sessionId, accessToken, orgUUID);
-        }
-        logForDebugging(`[teleport] Session logs fetched in ${Date.now() - logsStartTime}ms`);
-        if (logs === null) {
-            throw new Error('Failed to fetch session logs');
-        }
-        // Filter to get only transcript messages, excluding sidechain messages
-        const filterStartTime = Date.now();
-        const messages = logs.filter(entry => isTranscriptMessage(entry) && !entry.isSidechain);
-        logForDebugging(`[teleport] Filtered ${logs.length} entries to ${messages.length} messages in ${Date.now() - filterStartTime}ms`);
-        // Extract branch info from session data
-        onProgress?.('fetching_branch');
-        const branch = sessionData ? getBranchFromSession(sessionData) : undefined;
-        if (branch) {
-            logForDebugging(`[teleport] Found branch: ${branch}`);
-        }
-        logForDebugging(`[teleport] Total teleportFromSessionsAPI time: ${Date.now() - startTime}ms`);
-        return {
-            log: messages,
-            branch
-        };
-    }
-    catch (error) {
-        const err = toError(error);
-        // Handle 404 specifically
-        if (axios.isAxiosError(error) && error.response?.status === 404) {
-            logEvent('tengu_teleport_error_session_not_found_404', {
-                sessionId: sessionId
-            });
-            throw new TeleportOperationError(`${sessionId} not found.`, `${sessionId} not found.\n${chalk.dim('Run /status in Context Code to check your account.')}`);
-        }
-        logError(err);
-        throw new Error(`Failed to fetch session from Sessions API: ${err.message}`);
-    }
-}
-/**
- * Polls remote session events. Pass the previous response's `lastEventId`
- * as `afterId` to fetch only the delta. Set `skipMetadata` to avoid the
- * per-call GET /v1/sessions/{id} when branch/status aren't needed.
- */
-export async function pollRemoteSessionEvents(sessionId, afterId = null, opts) {
-    const accessToken = getClaudeAIOAuthTokens()?.accessToken;
-    if (!accessToken) {
-        throw new Error('No access token for polling');
-    }
-    const orgUUID = await getOrganizationUUID();
-    if (!orgUUID) {
-        throw new Error('No org UUID for polling');
-    }
-    const headers = {
-        ...getOAuthHeaders(accessToken),
-        'anthropic-beta': 'ccr-byoc-2025-07-29',
-        'x-organization-uuid': orgUUID
-    };
-    const eventsUrl = `${getOauthConfig().BASE_API_URL}/v1/sessions/${sessionId}/events`;
-    // Cap is a safety valve against stuck cursors; steady-state is 0–1 pages.
-    const MAX_EVENT_PAGES = 50;
-    const sdkMessages = [];
-    let cursor = afterId;
-    for (let page = 0; page < MAX_EVENT_PAGES; page++) {
-        const eventsResponse = await axios.get(eventsUrl, {
-            headers,
-            params: cursor ? {
-                after_id: cursor
-            } : undefined,
-            timeout: 30000
-        });
-        if (eventsResponse.status !== 200) {
-            throw new Error(`Failed to fetch session events: ${eventsResponse.statusText}`);
-        }
-        const eventsData = eventsResponse.data;
-        if (!eventsData?.data || !Array.isArray(eventsData.data)) {
-            throw new Error('Invalid events response');
-        }
-        for (const event of eventsData.data) {
-            if (event && typeof event === 'object' && 'type' in event) {
-                if (event.type === 'env_manager_log' || event.type === 'control_response') {
-                    continue;
-                }
-                if ('session_id' in event) {
-                    sdkMessages.push(event);
-                }
-            }
-        }
-        if (!eventsData.last_id)
-            break;
-        cursor = eventsData.last_id;
-        if (!eventsData.has_more)
-            break;
-    }
-    if (opts?.skipMetadata) {
-        return {
-            newEvents: sdkMessages,
-            lastEventId: cursor
-        };
-    }
-    // Fetch session metadata (branch, status)
-    let branch;
-    let sessionStatus;
-    try {
-        const sessionData = await fetchSession(sessionId);
-        branch = getBranchFromSession(sessionData);
-        sessionStatus = sessionData.session_status;
-    }
-    catch (e) {
-        logForDebugging(`teleport: failed to fetch session ${sessionId} metadata: ${e}`, {
-            level: 'debug'
-        });
-    }
-    return {
-        newEvents: sdkMessages,
-        lastEventId: cursor,
-        branch,
-        sessionStatus
-    };
-}
-/**
- * Creates a remote Claude.ai session using the Sessions API.
- *
- * Two source modes:
- * - GitHub (default): backend clones from the repo's origin URL. Requires a
- *   GitHub remote + CCR-side GitHub connection. 43% of CLI sessions have an
- *   origin remote; far fewer pass the full precondition chain.
- * - Bundle (CCR_FORCE_BUNDLE=1): CLI creates `git bundle --all`, uploads via Files
- *   API, passes file_id as seed_bundle_file_id on the session context. CCR
- *   downloads it and clones from the bundle. No GitHub dependency — works for
- *   local-only repos. Reach: 54% of CLI sessions (anything with .git/).
- *   Backend: anthropic#303856.
- */
-export async function teleportToRemote(options) {
-    const { initialMessage, signal } = options;
-    try {
-        // Check authentication
-        await checkAndRefreshOAuthTokenIfNeeded();
-        const accessToken = getClaudeAIOAuthTokens()?.accessToken;
-        if (!accessToken) {
-            logError(new Error('No access token found for remote session creation'));
-            return null;
-        }
-        // Get organization UUID
-        const orgUUID = await getOrganizationUUID();
-        if (!orgUUID) {
-            logError(new Error('Unable to get organization UUID for remote session creation'));
-            return null;
-        }
-        // Explicit environmentId short-circuits Haiku title-gen + env selection.
-        // Still runs repo detection so the container gets a working directory —
-        // the code_review orchestrator reads --repo-dir $(pwd), it doesn't clone
-        // (bughunter.go:520 sets a git source too; env-manager does the checkout
-        // before the SessionStart hook fires).
-        if (options.environmentId) {
-            const url = `${getOauthConfig().BASE_API_URL}/v1/sessions`;
-            const headers = {
-                ...getOAuthHeaders(accessToken),
-                'anthropic-beta': 'ccr-byoc-2025-07-29',
-                'x-organization-uuid': orgUUID
-            };
-            const envVars = {
-                CLAUDE_CODE_OAUTH_TOKEN: accessToken,
-                ...(options.environmentVariables ?? {})
-            };
-            // Bundle mode: upload local working tree (uncommitted changes via
-            // refs/seed/stash), container clones from the bundle. No GitHub.
-            // Otherwise: github.com source — caller checked eligibility.
-            let gitSource = null;
-            let seedBundleFileId = null;
-            if (options.useBundle) {
-                const bundle = await createAndUploadGitBundle({
-                    oauthToken: accessToken,
-                    sessionId: getSessionId(),
-                    baseUrl: getOauthConfig().BASE_API_URL
-                }, {
-                    signal
-                });
-                if (bundle.success === false) {
-                    logError(new Error(`Bundle upload failed: ${bundle.error}`));
-                    return null;
-                }
-                seedBundleFileId = bundle.fileId;
-                logEvent('tengu_teleport_bundle_mode', {
-                    size_bytes: bundle.bundleSizeBytes,
-                    scope: bundle.scope,
-                    has_wip: bundle.hasWip,
-                    reason: 'explicit_env_bundle'
-                });
-            }
-            else {
-                const repoInfo = await detectCurrentRepositoryWithHost();
-                if (repoInfo) {
-                    gitSource = {
-                        type: 'git_repository',
-                        url: `https://${repoInfo.host}/${repoInfo.owner}/${repoInfo.name}`,
-                        revision: options.branchName
-                    };
-                }
-            }
-            const requestBody = {
-                title: options.title || options.description || 'Remote task',
-                events: [],
-                session_context: {
-                    sources: gitSource ? [gitSource] : [],
-                    ...(seedBundleFileId && {
-                        seed_bundle_file_id: seedBundleFileId
-                    }),
-                    outcomes: [],
-                    environment_variables: envVars
-                },
-                environment_id: options.environmentId
-            };
-            logForDebugging(`[teleportToRemote] explicit env ${options.environmentId}, ${Object.keys(envVars).length} env vars, ${seedBundleFileId ? `bundle=${seedBundleFileId}` : `source=${gitSource?.url ?? 'none'}@${options.branchName ?? 'default'}`}`);
-            const response = await axios.post(url, requestBody, {
-                headers,
-                signal
-            });
-            if (response.status !== 200 && response.status !== 201) {
-                logError(new Error(`CreateSession ${response.status}: ${jsonStringify(response.data)}`));
-                return null;
-            }
-            const sessionData = response.data;
-            if (!sessionData || typeof sessionData.id !== 'string') {
-                logError(new Error(`No session id in response: ${jsonStringify(response.data)}`));
-                return null;
-            }
-            return {
-                id: sessionData.id,
-                title: sessionData.title || requestBody.title
-            };
-        }
-        let gitSource = null;
-        let gitOutcome = null;
-        let seedBundleFileId = null;
-        // Source selection ladder: GitHub clone (if CCR can actually pull it) →
-        // bundle fallback (if .git exists) → empty sandbox.
-        //
-        // The preflight is the same code path the container's git-proxy clone
-        // will hit (get_github_client_with_user_auth → no_sync_user_token_found).
-        // 50% of users who reach the "install GitHub App" step never finish it;
-        // without the preflight, every one of them gets a container that 401s
-        // on clone. With it, they silently fall back to bundle.
-        //
-        // CCR_FORCE_BUNDLE=1 skips the preflight entirely — useful for testing
-        // or when you know your GitHub auth is busted. Read here (not in the
-        // caller) so it works for remote-agent too, not just --remote.
-        const repoInfo = await detectCurrentRepositoryWithHost();
-        // Generate title and branch name for the session. Skip the Haiku call
-        // when both title and outcome branch are explicitly provided.
-        let sessionTitle;
-        let sessionBranch;
-        if (options.title && options.reuseOutcomeBranch) {
-            sessionTitle = options.title;
-            sessionBranch = options.reuseOutcomeBranch;
-        }
-        else {
-            const generated = await generateTitleAndBranch(options.description || initialMessage || 'Background task', signal);
-            sessionTitle = options.title || generated.title;
-            sessionBranch = options.reuseOutcomeBranch || generated.branchName;
-        }
-        // Preflight: does CCR have a token that can clone this repo?
-        // Only checked for github.com — GHES needs ghe_configuration_id which
-        // we don't have, and GHES users are power users who probably finished
-        // setup. For them (and for non-GitHub hosts that parseGitRemote
-        // somehow accepted), fall through optimistically; if the backend
-        // rejects the host, bundle next time.
-        let ghViable = false;
-        let sourceReason = 'no_git_at_all';
-        // gitRoot gates both bundle creation and the gate check itself — no
-        // point awaiting GrowthBook when there's nothing to bundle.
-        const gitRoot = findGitRoot(getCwd());
-        const forceBundle = !options.skipBundle && isEnvTruthy(process.env.CCR_FORCE_BUNDLE);
-        const bundleSeedGateOn = !options.skipBundle && gitRoot !== null && (isEnvTruthy(process.env.CCR_ENABLE_BUNDLE) || (await checkGate_CACHED_OR_BLOCKING('tengu_ccr_bundle_seed_enabled')));
-        if (repoInfo && !forceBundle) {
-            if (repoInfo.host === 'github.com') {
-                ghViable = await checkGithubAppInstalled(repoInfo.owner, repoInfo.name, signal);
-                sourceReason = ghViable ? 'github_preflight_ok' : 'github_preflight_failed';
-            }
-            else {
-                ghViable = true;
-                sourceReason = 'ghes_optimistic';
-            }
-        }
-        else if (forceBundle) {
-            sourceReason = 'forced_bundle';
-        }
-        else if (gitRoot) {
-            sourceReason = 'no_github_remote';
-        }
-        // Preflight failed but bundle is off — fall through optimistically like
-        // pre-preflight behavior. Backend reports the real auth error.
-        if (!ghViable && !bundleSeedGateOn && repoInfo) {
-            ghViable = true;
-        }
-        if (ghViable && repoInfo) {
-            const { host, owner, name } = repoInfo;
-            // Resolve the base branch: prefer explicit branchName, fall back to default branch
-            const revision = options.branchName ?? (await getDefaultBranch()) ?? undefined;
-            logForDebugging(`[teleportToRemote] Git source: ${host}/${owner}/${name}, revision: ${revision ?? 'none'}`);
-            gitSource = {
-                type: 'git_repository',
-                url: `https://${host}/${owner}/${name}`,
-                // The revision specifies which ref to checkout as the base branch
-                revision,
-                ...(options.reuseOutcomeBranch && {
-                    allow_unrestricted_git_push: true
-                })
-            };
-            // type: 'github' is used for all GitHub-compatible hosts (github.com and GHE).
-            // The CLI can't distinguish GHE from non-GitHub hosts (GitLab, Bitbucket)
-            // client-side — the backend validates the URL against configured GHE instances
-            // and ignores git_info for unrecognized hosts.
-            gitOutcome = {
-                type: 'git_repository',
-                git_info: {
-                    type: 'github',
-                    repo: `${owner}/${name}`,
-                    branches: [sessionBranch]
-                }
-            };
-        }
-        // Bundle fallback. Only try bundle if GitHub wasn't viable, the gate is
-        // on, and there's a .git/ to bundle from. Reaching here with
-        // ghViable=false and repoInfo non-null means the preflight failed —
-        // .git definitely exists (detectCurrentRepositoryWithHost read the
-        // remote from it).
-        if (!gitSource && bundleSeedGateOn) {
-            logForDebugging(`[teleportToRemote] Bundling (reason: ${sourceReason})`);
-            const bundle = await createAndUploadGitBundle({
-                oauthToken: accessToken,
-                sessionId: getSessionId(),
-                baseUrl: getOauthConfig().BASE_API_URL
-            }, {
-                signal
-            });
-            if (bundle.success === false) {
-                const err = bundle.error;
-                const failReason = bundle.failReason;
-                logError(new Error(`Bundle upload failed: ${err}`));
-                // Only steer users to GitHub setup when there's a remote to clone from.
-                const setup = repoInfo ? '. Please setup GitHub on https://claude.ai/code' : '';
-                let msg;
-                switch (failReason) {
-                    case 'empty_repo':
-                        msg = 'Repository has no commits — run `git add . && git commit -m "initial"` then retry';
-                        break;
-                    case 'too_large':
-                        msg = `Repo is too large to teleport${setup}`;
-                        break;
-                    case 'git_error':
-                        msg = `Failed to create git bundle (${err})${setup}`;
-                        break;
-                    default:
-                        msg = `Bundle upload failed: ${err}${setup}`;
-                }
-                options.onBundleFail?.(msg);
-                return null;
-            }
-            seedBundleFileId = bundle.fileId;
-            logEvent('tengu_teleport_bundle_mode', {
-                size_bytes: bundle.bundleSizeBytes,
-                scope: bundle.scope,
-                has_wip: bundle.hasWip,
-                reason: sourceReason
-            });
-        }
-        logEvent('tengu_teleport_source_decision', {
-            reason: sourceReason,
-            path: (gitSource ? 'github' : seedBundleFileId ? 'bundle' : 'empty')
-        });
-        if (!gitSource && !seedBundleFileId) {
-            logForDebugging('[teleportToRemote] No repository detected — session will have an empty sandbox');
-        }
-        // Fetch available environments
-        let environments = await fetchEnvironments();
-        if (!environments || environments.length === 0) {
-            logError(new Error('No environments available for session creation'));
-            return null;
-        }
-        logForDebugging(`Available environments: ${environments.map(e => `${e.environment_id} (${e.name}, ${e.kind})`).join(', ')}`);
-        // Select environment based on settings, then anthropic_cloud preference, then first available.
-        // Prefer anthropic_cloud environments over byoc: anthropic_cloud environments (e.g. "Default")
-        // are the standard compute environments with full repo access, whereas byoc environments
-        // (e.g. "monorepo") are user-owned compute that may not support the current repository.
-        const settings = getSettings_DEPRECATED();
-        const defaultEnvironmentId = options.useDefaultEnvironment ? undefined : settings?.remote?.defaultEnvironmentId;
-        let cloudEnv = environments.find(env => env.kind === 'anthropic_cloud');
-        // When the caller opts out of their configured default, do not fall
-        // through to a BYOC env that may not support the current repo or the
-        // requested permission mode. Retry once for eventual consistency,
-        // then fail loudly.
-        if (options.useDefaultEnvironment && !cloudEnv) {
-            logForDebugging(`No anthropic_cloud in env list (${environments.length} envs); retrying fetchEnvironments`);
-            const retried = await fetchEnvironments();
-            cloudEnv = retried?.find(env => env.kind === 'anthropic_cloud');
-            if (!cloudEnv) {
-                logError(new Error(`No anthropic_cloud environment available after retry (got: ${(retried ?? environments).map(e => `${e.name} (${e.kind})`).join(', ')}). Silent byoc fallthrough would launch into a dead env — fail fast instead.`));
-                return null;
-            }
-            if (retried)
-                environments = retried;
-        }
-        const selectedEnvironment = defaultEnvironmentId && environments.find(env => env.environment_id === defaultEnvironmentId) || cloudEnv || environments.find(env => env.kind !== 'bridge') || environments[0];
-        if (!selectedEnvironment) {
-            logError(new Error('No environments available for session creation'));
-            return null;
-        }
-        if (defaultEnvironmentId) {
-            const matchedDefault = selectedEnvironment.environment_id === defaultEnvironmentId;
-            logForDebugging(matchedDefault ? `Using configured default environment: ${defaultEnvironmentId}` : `Configured default environment ${defaultEnvironmentId} not found, using first available`);
-        }
-        const environmentId = selectedEnvironment.environment_id;
-        logForDebugging(`Selected environment: ${environmentId} (${selectedEnvironment.name}, ${selectedEnvironment.kind})`);
-        // Prepare API request for Sessions API
-        const url = `${getOauthConfig().BASE_API_URL}/v1/sessions`;
-        const headers = {
-            ...getOAuthHeaders(accessToken),
-            'anthropic-beta': 'ccr-byoc-2025-07-29',
-            'x-organization-uuid': orgUUID
-        };
-        const sessionContext = {
-            sources: gitSource ? [gitSource] : [],
-            ...(seedBundleFileId && {
-                seed_bundle_file_id: seedBundleFileId
-            }),
-            outcomes: gitOutcome ? [gitOutcome] : [],
-            model: options.model ?? getMainLoopModel(),
-            ...(options.reuseOutcomeBranch && {
-                reuse_outcome_branches: true
-            }),
-            ...(options.githubPr && {
-                github_pr: options.githubPr
-            })
-        };
-        // CreateCCRSessionPayload has no permission_mode field — a top-level
-        // body entry is silently dropped by the proto parser server-side.
-        // Instead prepend a set_permission_mode control_request event. Initial
-        // events are written to threadstore before the container connects, so
-        // the CLI applies the mode before the first user turn — no readiness race.
-        const events = [];
-        if (options.permissionMode) {
-            events.push({
-                type: 'event',
-                data: {
-                    type: 'control_request',
-                    request_id: `set-mode-${randomUUID()}`,
-                    request: {
-                        subtype: 'set_permission_mode',
-                        mode: options.permissionMode,
-                        ultraplan: options.ultraplan
-                    }
-                }
-            });
-        }
-        if (initialMessage) {
-            events.push({
-                type: 'event',
-                data: {
-                    uuid: randomUUID(),
-                    session_id: '',
-                    type: 'user',
-                    parent_tool_use_id: null,
-                    message: {
-                        role: 'user',
-                        content: initialMessage
-                    }
-                }
-            });
-        }
-        const requestBody = {
-            title: options.ultraplan ? `ultraplan: ${sessionTitle}` : sessionTitle,
-            events,
-            session_context: sessionContext,
-            environment_id: environmentId
-        };
-        logForDebugging(`Creating session with payload: ${jsonStringify(requestBody, null, 2)}`);
-        // Make API call
-        const response = await axios.post(url, requestBody, {
-            headers,
-            signal
-        });
-        const isSuccess = response.status === 200 || response.status === 201;
-        if (!isSuccess) {
-            logError(new Error(`API request failed with status ${response.status}: ${response.statusText}\n\nResponse data: ${jsonStringify(response.data, null, 2)}`));
-            return null;
-        }
-        // Parse response as SessionResource
-        const sessionData = response.data;
-        if (!sessionData || typeof sessionData.id !== 'string') {
-            logError(new Error(`Cannot determine session ID from API response: ${jsonStringify(response.data)}`));
-            return null;
-        }
-        logForDebugging(`Successfully created remote session: ${sessionData.id}`);
-        return {
-            id: sessionData.id,
-            title: sessionData.title || requestBody.title
-        };
-    }
-    catch (error) {
-        const err = toError(error);
-        logError(err);
-        return null;
-    }
-}
-/**
- * Best-effort session archive. POST /v1/sessions/{id}/archive has no
- * running-status check (unlike DELETE which 409s on RUNNING), so it works
- * mid-implementation. Archived sessions reject new events (send_events.go),
- * so the remote stops on its next write. 409 (already archived) treated as
- * success. Fire-and-forget; failure leaks a visible session until the
- * reaper collects it.
- */
-export async function archiveRemoteSession(sessionId) {
-    const accessToken = getClaudeAIOAuthTokens()?.accessToken;
-    if (!accessToken)
-        return;
-    const orgUUID = await getOrganizationUUID();
-    if (!orgUUID)
-        return;
-    const headers = {
-        ...getOAuthHeaders(accessToken),
-        'anthropic-beta': 'ccr-byoc-2025-07-29',
-        'x-organization-uuid': orgUUID
-    };
-    const url = `${getOauthConfig().BASE_API_URL}/v1/sessions/${sessionId}/archive`;
-    try {
-        const resp = await axios.post(url, {}, {
-            headers,
-            timeout: 10000,
-            validateStatus: s => s < 500
-        });
-        if (resp.status === 200 || resp.status === 409) {
-            logForDebugging(`[archiveRemoteSession] archived ${sessionId}`);
-        }
-        else {
-            logForDebugging(`[archiveRemoteSession] ${sessionId} failed ${resp.status}: ${jsonStringify(resp.data)}`);
-        }
-    }
-    catch (err) {
-        logError(err);
-    }
-}