@iaforged/context-code 1.0.63 → 1.0.65

package/dist/src/bridge/createSession.js

@@ -1,273 +0,0 @@
-import { logForDebugging } from '../utils/debug.js';
-import { errorMessage } from '../utils/errors.js';
-import { extractErrorDetail } from './debugUtils.js';
-import { toCompatSessionId } from './sessionIdCompat.js';
-/**
- * Create a session on a bridge environment via POST /v1/sessions.
- *
- * Used by both `claude remote-control` (empty session so the user has somewhere to
- * type immediately) and `/remote-control` (session pre-populated with conversation
- * history).
- *
- * Returns the session ID on success, or null if creation fails (non-fatal).
- */
-export async function createBridgeSession({ environmentId, title, events, gitRepoUrl, branch, signal, baseUrl: baseUrlOverride, getAccessToken, permissionMode, }) {
-    const { getClaudeAIOAuthTokens } = await import('../utils/auth.js');
-    const { getOrganizationUUID } = await import('../services/oauth/client.js');
-    const { getOauthConfig } = await import('../constants/oauth.js');
-    const { getOAuthHeaders } = await import('../utils/teleport/api.js');
-    const { parseGitHubRepository } = await import('../utils/detectRepository.js');
-    const { getDefaultBranch } = await import('../utils/git.js');
-    const { getMainLoopModel } = await import('../utils/model/model.js');
-    const { default: axios } = await import('axios');
-    const accessToken = getAccessToken?.() ?? getClaudeAIOAuthTokens()?.accessToken;
-    if (!accessToken) {
-        logForDebugging('[bridge] No access token for session creation');
-        return null;
-    }
-    const orgUUID = await getOrganizationUUID();
-    if (!orgUUID) {
-        logForDebugging('[bridge] No org UUID for session creation');
-        return null;
-    }
-    // Build git source and outcome context
-    let gitSource = null;
-    let gitOutcome = null;
-    if (gitRepoUrl) {
-        const { parseGitRemote } = await import('../utils/detectRepository.js');
-        const parsed = parseGitRemote(gitRepoUrl);
-        if (parsed) {
-            const { host, owner, name } = parsed;
-            const revision = branch || (await getDefaultBranch()) || undefined;
-            gitSource = {
-                type: 'git_repository',
-                url: `https://${host}/${owner}/${name}`,
-                revision,
-            };
-            gitOutcome = {
-                type: 'git_repository',
-                git_info: {
-                    type: 'github',
-                    repo: `${owner}/${name}`,
-                    branches: [`claude/${branch || 'task'}`],
-                },
-            };
-        }
-        else {
-            // Fallback: try parseGitHubRepository for owner/repo format
-            const ownerRepo = parseGitHubRepository(gitRepoUrl);
-            if (ownerRepo) {
-                const [owner, name] = ownerRepo.split('/');
-                if (owner && name) {
-                    const revision = branch || (await getDefaultBranch()) || undefined;
-                    gitSource = {
-                        type: 'git_repository',
-                        url: `https://github.com/${owner}/${name}`,
-                        revision,
-                    };
-                    gitOutcome = {
-                        type: 'git_repository',
-                        git_info: {
-                            type: 'github',
-                            repo: `${owner}/${name}`,
-                            branches: [`claude/${branch || 'task'}`],
-                        },
-                    };
-                }
-            }
-        }
-    }
-    const requestBody = {
-        ...(title !== undefined && { title }),
-        events,
-        session_context: {
-            sources: gitSource ? [gitSource] : [],
-            outcomes: gitOutcome ? [gitOutcome] : [],
-            model: getMainLoopModel(),
-        },
-        environment_id: environmentId,
-        source: 'remote-control',
-        ...(permissionMode && { permission_mode: permissionMode }),
-    };
-    const headers = {
-        ...getOAuthHeaders(accessToken),
-        'anthropic-beta': 'ccr-byoc-2025-07-29',
-        'x-organization-uuid': orgUUID,
-    };
-    const url = `${baseUrlOverride ?? getOauthConfig().BASE_API_URL}/v1/sessions`;
-    let response;
-    try {
-        response = await axios.post(url, requestBody, {
-            headers,
-            signal,
-            validateStatus: s => s < 500,
-        });
-    }
-    catch (err) {
-        logForDebugging(`[bridge] Session creation request failed: ${errorMessage(err)}`);
-        return null;
-    }
-    const isSuccess = response.status === 200 || response.status === 201;
-    if (!isSuccess) {
-        const detail = extractErrorDetail(response.data);
-        logForDebugging(`[bridge] Session creation failed with status ${response.status}${detail ? `: ${detail}` : ''}`);
-        return null;
-    }
-    const sessionData = response.data;
-    if (!sessionData ||
-        typeof sessionData !== 'object' ||
-        !('id' in sessionData) ||
-        typeof sessionData.id !== 'string') {
-        logForDebugging('[bridge] No session ID in response');
-        return null;
-    }
-    return sessionData.id;
-}
-/**
- * Fetch a bridge session via GET /v1/sessions/{id}.
- *
- * Returns the session's environment_id (for `--session-id` resume) and title.
- * Uses the same org-scoped headers as create/archive — the environments-level
- * client in bridgeApi.ts uses a different beta header and no org UUID, which
- * makes the Sessions API return 404.
- */
-export async function getBridgeSession(sessionId, opts) {
-    const { getClaudeAIOAuthTokens } = await import('../utils/auth.js');
-    const { getOrganizationUUID } = await import('../services/oauth/client.js');
-    const { getOauthConfig } = await import('../constants/oauth.js');
-    const { getOAuthHeaders } = await import('../utils/teleport/api.js');
-    const { default: axios } = await import('axios');
-    const accessToken = opts?.getAccessToken?.() ?? getClaudeAIOAuthTokens()?.accessToken;
-    if (!accessToken) {
-        logForDebugging('[bridge] No access token for session fetch');
-        return null;
-    }
-    const orgUUID = await getOrganizationUUID();
-    if (!orgUUID) {
-        logForDebugging('[bridge] No org UUID for session fetch');
-        return null;
-    }
-    const headers = {
-        ...getOAuthHeaders(accessToken),
-        'anthropic-beta': 'ccr-byoc-2025-07-29',
-        'x-organization-uuid': orgUUID,
-    };
-    const url = `${opts?.baseUrl ?? getOauthConfig().BASE_API_URL}/v1/sessions/${sessionId}`;
-    logForDebugging(`[bridge] Fetching session ${sessionId}`);
-    let response;
-    try {
-        response = await axios.get(url, { headers, timeout: 10_000, validateStatus: s => s < 500 });
-    }
-    catch (err) {
-        logForDebugging(`[bridge] Session fetch request failed: ${errorMessage(err)}`);
-        return null;
-    }
-    if (response.status !== 200) {
-        const detail = extractErrorDetail(response.data);
-        logForDebugging(`[bridge] Session fetch failed with status ${response.status}${detail ? `: ${detail}` : ''}`);
-        return null;
-    }
-    return response.data;
-}
-/**
- * Archive a bridge session via POST /v1/sessions/{id}/archive.
- *
- * The CCR server never auto-archives sessions — archival is always an
- * explicit client action. Both `claude remote-control` (standalone bridge) and the
- * always-on `/remote-control` REPL bridge call this during shutdown to archive any
- * sessions that are still alive.
- *
- * The archive endpoint accepts sessions in any status (running, idle,
- * requires_action, pending) and returns 409 if already archived, making
- * it safe to call even if the server-side runner already archived the
- * session.
- *
- * Callers must handle errors — this function has no try/catch; 5xx,
- * timeouts, and network errors throw. Archival is best-effort during
- * cleanup; call sites wrap with .catch().
- */
-export async function archiveBridgeSession(sessionId, opts) {
-    const { getClaudeAIOAuthTokens } = await import('../utils/auth.js');
-    const { getOrganizationUUID } = await import('../services/oauth/client.js');
-    const { getOauthConfig } = await import('../constants/oauth.js');
-    const { getOAuthHeaders } = await import('../utils/teleport/api.js');
-    const { default: axios } = await import('axios');
-    const accessToken = opts?.getAccessToken?.() ?? getClaudeAIOAuthTokens()?.accessToken;
-    if (!accessToken) {
-        logForDebugging('[bridge] No access token for session archive');
-        return;
-    }
-    const orgUUID = await getOrganizationUUID();
-    if (!orgUUID) {
-        logForDebugging('[bridge] No org UUID for session archive');
-        return;
-    }
-    const headers = {
-        ...getOAuthHeaders(accessToken),
-        'anthropic-beta': 'ccr-byoc-2025-07-29',
-        'x-organization-uuid': orgUUID,
-    };
-    const url = `${opts?.baseUrl ?? getOauthConfig().BASE_API_URL}/v1/sessions/${sessionId}/archive`;
-    logForDebugging(`[bridge] Archiving session ${sessionId}`);
-    const response = await axios.post(url, {}, {
-        headers,
-        timeout: opts?.timeoutMs ?? 10_000,
-        validateStatus: s => s < 500,
-    });
-    if (response.status === 200) {
-        logForDebugging(`[bridge] Session ${sessionId} archived successfully`);
-    }
-    else {
-        const detail = extractErrorDetail(response.data);
-        logForDebugging(`[bridge] Session archive failed with status ${response.status}${detail ? `: ${detail}` : ''}`);
-    }
-}
-/**
- * Update the title of a bridge session via PATCH /v1/sessions/{id}.
- *
- * Called when the user renames a session via /rename while a bridge
- * connection is active, so the title stays in sync on claude.ai/code.
- *
- * Errors are swallowed — title sync is best-effort.
- */
-export async function updateBridgeSessionTitle(sessionId, title, opts) {
-    const { getClaudeAIOAuthTokens } = await import('../utils/auth.js');
-    const { getOrganizationUUID } = await import('../services/oauth/client.js');
-    const { getOauthConfig } = await import('../constants/oauth.js');
-    const { getOAuthHeaders } = await import('../utils/teleport/api.js');
-    const { default: axios } = await import('axios');
-    const accessToken = opts?.getAccessToken?.() ?? getClaudeAIOAuthTokens()?.accessToken;
-    if (!accessToken) {
-        logForDebugging('[bridge] No access token for session title update');
-        return;
-    }
-    const orgUUID = await getOrganizationUUID();
-    if (!orgUUID) {
-        logForDebugging('[bridge] No org UUID for session title update');
-        return;
-    }
-    const headers = {
-        ...getOAuthHeaders(accessToken),
-        'anthropic-beta': 'ccr-byoc-2025-07-29',
-        'x-organization-uuid': orgUUID,
-    };
-    // Compat gateway only accepts session_* (compat/convert.go:27). v2 callers
-    // pass raw cse_*; retag here so all callers can pass whatever they hold.
-    // Idempotent for v1's session_* and bridgeMain's pre-converted compatSessionId.
-    const compatId = toCompatSessionId(sessionId);
-    const url = `${opts?.baseUrl ?? getOauthConfig().BASE_API_URL}/v1/sessions/${compatId}`;
-    logForDebugging(`[bridge] Updating session title: ${compatId} → ${title}`);
-    try {
-        const response = await axios.patch(url, { title }, { headers, timeout: 10_000, validateStatus: s => s < 500 });
-        if (response.status === 200) {
-            logForDebugging(`[bridge] Session title updated successfully`);
-        }
-        else {
-            const detail = extractErrorDetail(response.data);
-            logForDebugging(`[bridge] Session title update failed with status ${response.status}${detail ? `: ${detail}` : ''}`);
-        }
-    }
-    catch (err) {
-        logForDebugging(`[bridge] Session title update request failed: ${errorMessage(err)}`);
-    }
-}

package/dist/src/bridge/debugUtils.js

@@ -1,115 +0,0 @@
-import { logEvent, } from '../services/analytics/index.js';
-import { logForDebugging } from '../utils/debug.js';
-import { errorMessage } from '../utils/errors.js';
-import { jsonStringify } from '../utils/slowOperations.js';
-const DEBUG_MSG_LIMIT = 2000;
-const SECRET_FIELD_NAMES = [
-    'session_ingress_token',
-    'environment_secret',
-    'access_token',
-    'secret',
-    'token',
-];
-const SECRET_PATTERN = new RegExp(`"(${SECRET_FIELD_NAMES.join('|')})"\\s*:\\s*"([^"]*)"`, 'g');
-const REDACT_MIN_LENGTH = 16;
-export function redactSecrets(s) {
-    return s.replace(SECRET_PATTERN, (_match, field, value) => {
-        if (value.length < REDACT_MIN_LENGTH) {
-            return `"${field}":"[REDACTED]"`;
-        }
-        const redacted = `${value.slice(0, 8)}...${value.slice(-4)}`;
-        return `"${field}":"${redacted}"`;
-    });
-}
-/** Truncate a string for debug logging, collapsing newlines. */
-export function debugTruncate(s) {
-    const flat = s.replace(/\n/g, '\\n');
-    if (flat.length <= DEBUG_MSG_LIMIT) {
-        return flat;
-    }
-    return flat.slice(0, DEBUG_MSG_LIMIT) + `... (${flat.length} chars)`;
-}
-/** Truncate a JSON-serializable value for debug logging. */
-export function debugBody(data) {
-    const raw = typeof data === 'string' ? data : jsonStringify(data);
-    const s = redactSecrets(raw);
-    if (s.length <= DEBUG_MSG_LIMIT) {
-        return s;
-    }
-    return s.slice(0, DEBUG_MSG_LIMIT) + `... (${s.length} chars)`;
-}
-/**
- * Extract a descriptive error message from an axios error (or any error).
- * For HTTP errors, appends the server's response body message if available,
- * since axios's default message only includes the status code.
- */
-export function describeAxiosError(err) {
-    const msg = errorMessage(err);
-    if (err && typeof err === 'object' && 'response' in err) {
-        const response = err.response;
-        if (response?.data && typeof response.data === 'object') {
-            const data = response.data;
-            const detail = typeof data.message === 'string'
-                ? data.message
-                : typeof data.error === 'object' &&
-                    data.error &&
-                    'message' in data.error &&
-                    typeof data.error.message ===
-                        'string'
-                    ? data.error.message
-                    : undefined;
-            if (detail) {
-                return `${msg}: ${detail}`;
-            }
-        }
-    }
-    return msg;
-}
-/**
- * Extract the HTTP status code from an axios error, if present.
- * Returns undefined for non-HTTP errors (e.g. network failures).
- */
-export function extractHttpStatus(err) {
-    if (err &&
-        typeof err === 'object' &&
-        'response' in err &&
-        err.response &&
-        typeof err.response.status ===
-            'number') {
-        return err.response.status;
-    }
-    return undefined;
-}
-/**
- * Pull a human-readable message out of an API error response body.
- * Checks `data.message` first, then `data.error.message`.
- */
-export function extractErrorDetail(data) {
-    if (!data || typeof data !== 'object')
-        return undefined;
-    if ('message' in data && typeof data.message === 'string') {
-        return data.message;
-    }
-    if ('error' in data &&
-        data.error !== null &&
-        typeof data.error === 'object' &&
-        'message' in data.error &&
-        typeof data.error.message === 'string') {
-        return data.error.message;
-    }
-    return undefined;
-}
-/**
- * Log a bridge init skip — debug message + `tengu_bridge_repl_skipped`
- * analytics event. Centralizes the event name and the AnalyticsMetadata
- * cast so call sites don't each repeat the 5-line boilerplate.
- */
-export function logBridgeSkip(reason, debugMsg, v2) {
-    if (debugMsg) {
-        logForDebugging(debugMsg);
-    }
-    logEvent('tengu_bridge_repl_skipped', {
-        reason: reason,
-        ...(v2 !== undefined && { v2 }),
-    });
-}

package/dist/src/bridge/envLessBridgeConfig.js

@@ -1,121 +0,0 @@
-import { MACRO } from '../recovery/bunBundleShim.js';
-import { z } from 'zod/v4';
-import { getFeatureValue_DEPRECATED } from '../services/analytics/growthbook.js';
-import { lazySchema } from '../utils/lazySchema.js';
-import { lt } from '../utils/semver.js';
-import { isEnvLessBridgeEnabled } from './bridgeEnabled.js';
-export const DEFAULT_ENV_LESS_BRIDGE_CONFIG = {
-    init_retry_max_attempts: 3,
-    init_retry_base_delay_ms: 500,
-    init_retry_jitter_fraction: 0.25,
-    init_retry_max_delay_ms: 4000,
-    http_timeout_ms: 10_000,
-    uuid_dedup_buffer_size: 2000,
-    heartbeat_interval_ms: 20_000,
-    heartbeat_jitter_fraction: 0.1,
-    token_refresh_buffer_ms: 300_000,
-    teardown_archive_timeout_ms: 1500,
-    connect_timeout_ms: 15_000,
-    min_version: '0.0.0',
-    should_show_app_upgrade_message: false,
-};
-// Floors reject the whole object on violation (fall back to DEFAULT) rather
-// than partially trusting — same defense-in-depth as pollConfig.ts.
-const envLessBridgeConfigSchema = lazySchema(() => z.object({
-    init_retry_max_attempts: z.number().int().min(1).max(10).default(3),
-    init_retry_base_delay_ms: z.number().int().min(100).default(500),
-    init_retry_jitter_fraction: z.number().min(0).max(1).default(0.25),
-    init_retry_max_delay_ms: z.number().int().min(500).default(4000),
-    http_timeout_ms: z.number().int().min(2000).default(10_000),
-    uuid_dedup_buffer_size: z.number().int().min(100).max(50_000).default(2000),
-    // Server TTL is 60s. Floor 5s prevents thrash; cap 30s keeps ≥2× margin.
-    heartbeat_interval_ms: z
-        .number()
-        .int()
-        .min(5000)
-        .max(30_000)
-        .default(20_000),
-    // ±fraction per beat. Cap 0.5: at max interval (30s) × 1.5 = 45s worst case,
-    // still under the 60s TTL.
-    heartbeat_jitter_fraction: z.number().min(0).max(0.5).default(0.1),
-    // Floor 30s prevents tight-looping. Cap 30min rejects buffer-vs-delay
-    // semantic inversion: ops entering expires_in-5min (the *delay until
-    // refresh*) instead of 5min (the *buffer before expiry*) yields
-    // delayMs = expires_in - buffer ≈ 5min instead of ≈4h. Both are positive
-    // durations so .min() alone can't distinguish; .max() catches the
-    // inverted value since buffer ≥ 30min is nonsensical for a multi-hour JWT.
-    token_refresh_buffer_ms: z
-        .number()
-        .int()
-        .min(30_000)
-        .max(1_800_000)
-        .default(300_000),
-    // Cap 2000 keeps this under gracefulShutdown's 2s cleanup race — a higher
-    // timeout just lies to axios since forceExit kills the socket regardless.
-    teardown_archive_timeout_ms: z
-        .number()
-        .int()
-        .min(500)
-        .max(2000)
-        .default(1500),
-    // Observed p99 connect is ~2-3s; 15s is ~5× headroom. Floor 5s bounds
-    // false-positive rate under transient slowness; cap 60s bounds how long
-    // a truly-stalled session stays dark.
-    connect_timeout_ms: z.number().int().min(5_000).max(60_000).default(15_000),
-    min_version: z
-        .string()
-        .refine(v => {
-        try {
-            lt(v, '0.0.0');
-            return true;
-        }
-        catch {
-            return false;
-        }
-    })
-        .default('0.0.0'),
-    should_show_app_upgrade_message: z.boolean().default(false),
-}));
-/**
- * Fetch the env-less bridge timing config from GrowthBook. Read once per
- * initEnvLessBridgeCore call — config is fixed for the lifetime of a bridge
- * session.
- *
- * Uses the blocking getter (not _CACHED_MAY_BE_STALE) because /remote-control
- * runs well after GrowthBook init — initializeGrowthBook() resolves instantly,
- * so there's no startup penalty, and we get the fresh in-memory remoteEval
- * value instead of the stale-on-first-read disk cache. The _DEPRECATED suffix
- * warns against startup-path usage, which this isn't.
- */
-export async function getEnvLessBridgeConfig() {
-    const raw = await getFeatureValue_DEPRECATED('tengu_bridge_repl_v2_config', DEFAULT_ENV_LESS_BRIDGE_CONFIG);
-    const parsed = envLessBridgeConfigSchema().safeParse(raw);
-    return parsed.success ? parsed.data : DEFAULT_ENV_LESS_BRIDGE_CONFIG;
-}
-/**
- * Returns an error message if the current CLI version is below the minimum
- * required for the env-less (v2) bridge path, or null if the version is fine.
- *
- * v2 analogue of checkBridgeMinVersion() — reads from tengu_bridge_repl_v2_config
- * instead of tengu_bridge_min_version so the two implementations can enforce
- * independent floors.
- */
-export async function checkEnvLessBridgeMinVersion() {
-    const cfg = await getEnvLessBridgeConfig();
-    if (cfg.min_version && lt(MACRO.VERSION, cfg.min_version)) {
-        return `Your version of Context Code (${MACRO.VERSION}) is too old for Remote Control.\nVersion ${cfg.min_version} or higher is required. Run \`claude update\` to update.`;
-    }
-    return null;
-}
-/**
- * Whether to nudge users toward upgrading their claude.ai app when a
- * Remote Control session starts. True only when the v2 bridge is active
- * AND the should_show_app_upgrade_message config bit is set — lets us
- * roll the v2 bridge before the app ships the new session-list query.
- */
-export async function shouldShowAppUpgradeMessage() {
-    if (!isEnvLessBridgeEnabled())
-        return false;
-    const cfg = await getEnvLessBridgeConfig();
-    return cfg.should_show_app_upgrade_message;
-}

package/dist/src/bridge/flushGate.js

@@ -1,65 +0,0 @@
-/**
- * State machine for gating message writes during an initial flush.
- *
- * When a bridge session starts, historical messages are flushed to the
- * server via a single HTTP POST. During that flush, new messages must
- * be queued to prevent them from arriving at the server interleaved
- * with the historical messages.
- *
- * Lifecycle:
- *   start() → enqueue() returns true, items are queued
- *   end()   → returns queued items for draining, enqueue() returns false
- *   drop()  → discards queued items (permanent transport close)
- *   deactivate() → clears active flag without dropping items
- *                   (transport replacement — new transport will drain)
- */
-export class FlushGate {
-    _active = false;
-    _pending = [];
-    get active() {
-        return this._active;
-    }
-    get pendingCount() {
-        return this._pending.length;
-    }
-    /** Mark flush as in-progress. enqueue() will start queuing items. */
-    start() {
-        this._active = true;
-    }
-    /**
-     * End the flush and return any queued items for draining.
-     * Caller is responsible for sending the returned items.
-     */
-    end() {
-        this._active = false;
-        return this._pending.splice(0);
-    }
-    /**
-     * If flush is active, queue the items and return true.
-     * If flush is not active, return false (caller should send directly).
-     */
-    enqueue(...items) {
-        if (!this._active)
-            return false;
-        this._pending.push(...items);
-        return true;
-    }
-    /**
-     * Discard all queued items (permanent transport close).
-     * Returns the number of items dropped.
-     */
-    drop() {
-        this._active = false;
-        const count = this._pending.length;
-        this._pending.length = 0;
-        return count;
-    }
-    /**
-     * Clear the active flag without dropping queued items.
-     * Used when the transport is replaced (onWorkReceived) — the new
-     * transport's flush will drain the pending items.
-     */
-    deactivate() {
-        this._active = false;
-    }
-}