@iaforged/context-code 1.0.63 → 1.0.65

package/dist/src/bridge/bridgeMessaging.js

@@ -1,353 +0,0 @@
-/**
- * Shared transport-layer helpers for bridge message handling.
- *
- * Extracted from replBridge.ts so both the env-based core (initBridgeCore)
- * and the env-less core (initEnvLessBridgeCore) can use the same ingress
- * parsing, control-request handling, and echo-dedup machinery.
- *
- * Everything here is pure — no closure over bridge-specific state. All
- * collaborators (transport, sessionId, UUID sets, callbacks) are passed
- * as params.
- */
-import { randomUUID } from 'crypto';
-import { logEvent } from '../services/analytics/index.js';
-import { EMPTY_USAGE } from '../services/api/emptyUsage.js';
-import { normalizeControlMessageKeys } from '../utils/controlMessageCompat.js';
-import { logForDebugging } from '../utils/debug.js';
-import { stripDisplayTagsAllowEmpty } from '../utils/displayTags.js';
-import { errorMessage } from '../utils/errors.js';
-import { jsonParse } from '../utils/slowOperations.js';
-// ─── Type guards ─────────────────────────────────────────────────────────────
-/** Type predicate for parsed WebSocket messages. SDKMessage is a
- *  discriminated union on `type` — validating the discriminant is
- *  sufficient for the predicate; callers narrow further via the union. */
-export function isSDKMessage(value) {
-    return (value !== null &&
-        typeof value === 'object' &&
-        'type' in value &&
-        typeof value.type === 'string');
-}
-/** Type predicate for control_response messages from the server. */
-export function isSDKControlResponse(value) {
-    return (value !== null &&
-        typeof value === 'object' &&
-        'type' in value &&
-        value.type === 'control_response' &&
-        'response' in value);
-}
-/** Type predicate for control_request messages from the server. */
-export function isSDKControlRequest(value) {
-    return (value !== null &&
-        typeof value === 'object' &&
-        'type' in value &&
-        value.type === 'control_request' &&
-        'request_id' in value &&
-        'request' in value);
-}
-/**
- * True for message types that should be forwarded to the bridge transport.
- * The server only wants user/assistant turns and slash-command system events;
- * everything else (tool_result, progress, etc.) is internal REPL chatter.
- */
-export function isEligibleBridgeMessage(m) {
-    // Virtual messages (REPL inner calls) are display-only — bridge/SDK
-    // consumers see the REPL tool_use/result which summarizes the work.
-    if ((m.type === 'user' || m.type === 'assistant') && m.isVirtual) {
-        return false;
-    }
-    return (m.type === 'user' ||
-        m.type === 'assistant' ||
-        (m.type === 'system' && m.subtype === 'local_command'));
-}
-/**
- * Extract title-worthy text from a Message for onUserMessage. Returns
- * undefined for messages that shouldn't title the session: non-user, meta
- * (nudges), tool results, compact summaries, non-human origins (task
- * notifications, channel messages), or pure display-tag content
- * (<ide_opened_file>, <session-start-hook>, etc.).
- *
- * Synthetic interrupts ([Request interrupted by user]) are NOT filtered here —
- * isSyntheticMessage lives in messages.ts (heavy import, pulls command
- * registry). The initialMessages path in initReplBridge checks it; the
- * writeMessages path reaching an interrupt as the *first* message is
- * implausible (an interrupt implies a prior prompt already flowed through).
- */
-export function extractTitleText(m) {
-    if (m.type !== 'user' || m.isMeta || m.toolUseResult || m.isCompactSummary)
-        return undefined;
-    if (m.origin && m.origin.kind !== 'human')
-        return undefined;
-    const content = m.message.content;
-    let raw;
-    if (typeof content === 'string') {
-        raw = content;
-    }
-    else {
-        for (const block of content) {
-            if (block.type === 'text') {
-                raw = block.text;
-                break;
-            }
-        }
-    }
-    if (!raw)
-        return undefined;
-    const clean = stripDisplayTagsAllowEmpty(raw);
-    return clean || undefined;
-}
-// ─── Ingress routing ─────────────────────────────────────────────────────────
-/**
- * Parse an ingress WebSocket message and route it to the appropriate handler.
- * Ignores messages whose UUID is in recentPostedUUIDs (echoes of what we sent)
- * or in recentInboundUUIDs (re-deliveries we've already forwarded — e.g.
- * server replayed history after a transport swap lost the seq-num cursor).
- */
-export function handleIngressMessage(data, recentPostedUUIDs, recentInboundUUIDs, onInboundMessage, onPermissionResponse, onControlRequest) {
-    try {
-        const parsed = normalizeControlMessageKeys(jsonParse(data));
-        // control_response is not an SDKMessage — check before the type guard
-        if (isSDKControlResponse(parsed)) {
-            logForDebugging('[bridge:repl] Ingress message type=control_response');
-            onPermissionResponse?.(parsed);
-            return;
-        }
-        // control_request from the server (initialize, set_model, can_use_tool).
-        // Must respond promptly or the server kills the WS (~10-14s timeout).
-        if (isSDKControlRequest(parsed)) {
-            logForDebugging(`[bridge:repl] Inbound control_request subtype=${parsed.request.subtype}`);
-            onControlRequest?.(parsed);
-            return;
-        }
-        if (!isSDKMessage(parsed))
-            return;
-        // Check for UUID to detect echoes of our own messages
-        const uuid = 'uuid' in parsed && typeof parsed.uuid === 'string'
-            ? parsed.uuid
-            : undefined;
-        if (uuid && recentPostedUUIDs.has(uuid)) {
-            logForDebugging(`[bridge:repl] Ignoring echo: type=${parsed.type} uuid=${uuid}`);
-            return;
-        }
-        // Defensive dedup: drop inbound prompts we've already forwarded. The
-        // SSE seq-num carryover (lastTransportSequenceNum) is the primary fix
-        // for history-replay; this catches edge cases where that negotiation
-        // fails (server ignores from_sequence_num, transport died before
-        // receiving any frames, etc).
-        if (uuid && recentInboundUUIDs.has(uuid)) {
-            logForDebugging(`[bridge:repl] Ignoring re-delivered inbound: type=${parsed.type} uuid=${uuid}`);
-            return;
-        }
-        logForDebugging(`[bridge:repl] Ingress message type=${parsed.type}${uuid ? ` uuid=${uuid}` : ''}`);
-        if (parsed.type === 'user') {
-            if (uuid)
-                recentInboundUUIDs.add(uuid);
-            logEvent('tengu_bridge_message_received', {
-                is_repl: true,
-            });
-            // Fire-and-forget — handler may be async (attachment resolution).
-            void onInboundMessage?.(parsed);
-        }
-        else {
-            logForDebugging(`[bridge:repl] Ignoring non-user inbound message: type=${parsed.type}`);
-        }
-    }
-    catch (err) {
-        logForDebugging(`[bridge:repl] Failed to parse ingress message: ${errorMessage(err)}`);
-    }
-}
-const OUTBOUND_ONLY_ERROR = 'This session is outbound-only. Enable Remote Control locally to allow inbound control.';
-/**
- * Respond to inbound control_request messages from the server. The server
- * sends these for session lifecycle events (initialize, set_model) and
- * for turn-level coordination (interrupt, set_max_thinking_tokens). If we
- * don't respond, the server hangs and kills the WS after ~10-14s.
- *
- * Previously a closure inside initBridgeCore's onWorkReceived; now takes
- * collaborators as params so both cores can use it.
- */
-export function handleServerControlRequest(request, handlers) {
-    const { transport, sessionId, outboundOnly, onInterrupt, onSetModel, onSetMaxThinkingTokens, onSetPermissionMode, } = handlers;
-    if (!transport) {
-        logForDebugging('[bridge:repl] Cannot respond to control_request: transport not configured');
-        return;
-    }
-    let response;
-    // Outbound-only: reply error for mutable requests so claude.ai doesn't show
-    // false success. initialize must still succeed (server kills the connection
-    // if it doesn't — see comment above).
-    if (outboundOnly && request.request.subtype !== 'initialize') {
-        response = {
-            type: 'control_response',
-            response: {
-                subtype: 'error',
-                request_id: request.request_id,
-                error: OUTBOUND_ONLY_ERROR,
-            },
-        };
-        const event = { ...response, session_id: sessionId };
-        void transport.write(event);
-        logForDebugging(`[bridge:repl] Rejected ${request.request.subtype} (outbound-only) request_id=${request.request_id}`);
-        return;
-    }
-    switch (request.request.subtype) {
-        case 'initialize':
-            // Respond with minimal capabilities — the REPL handles
-            // commands, models, and account info itself.
-            response = {
-                type: 'control_response',
-                response: {
-                    subtype: 'success',
-                    request_id: request.request_id,
-                    response: {
-                        commands: [],
-                        output_style: 'normal',
-                        available_output_styles: ['normal'],
-                        models: [],
-                        account: {},
-                        pid: process.pid,
-                    },
-                },
-            };
-            break;
-        case 'set_model':
-            onSetModel?.(request.request.model);
-            response = {
-                type: 'control_response',
-                response: {
-                    subtype: 'success',
-                    request_id: request.request_id,
-                },
-            };
-            break;
-        case 'set_max_thinking_tokens':
-            onSetMaxThinkingTokens?.(request.request.max_thinking_tokens);
-            response = {
-                type: 'control_response',
-                response: {
-                    subtype: 'success',
-                    request_id: request.request_id,
-                },
-            };
-            break;
-        case 'set_permission_mode': {
-            // The callback returns a policy verdict so we can send an error
-            // control_response without importing isAutoModeGateEnabled /
-            // isBypassPermissionsModeDisabled here (bootstrap-isolation). If no
-            // callback is registered (daemon context, which doesn't wire this —
-            // see daemonBridge.ts), return an error verdict rather than a silent
-            // false-success: the mode is never actually applied in that context,
-            // so success would lie to the client.
-            const verdict = onSetPermissionMode?.(request.request.mode) ?? {
-                ok: false,
-                error: 'set_permission_mode is not supported in this context (onSetPermissionMode callback not registered)',
-            };
-            if (verdict.ok) {
-                response = {
-                    type: 'control_response',
-                    response: {
-                        subtype: 'success',
-                        request_id: request.request_id,
-                    },
-                };
-            }
-            else {
-                response = {
-                    type: 'control_response',
-                    response: {
-                        subtype: 'error',
-                        request_id: request.request_id,
-                        error: verdict.error,
-                    },
-                };
-            }
-            break;
-        }
-        case 'interrupt':
-            onInterrupt?.();
-            response = {
-                type: 'control_response',
-                response: {
-                    subtype: 'success',
-                    request_id: request.request_id,
-                },
-            };
-            break;
-        default:
-            // Unknown subtype — respond with error so the server doesn't
-            // hang waiting for a reply that never comes.
-            response = {
-                type: 'control_response',
-                response: {
-                    subtype: 'error',
-                    request_id: request.request_id,
-                    error: `REPL bridge does not handle control_request subtype: ${request.request.subtype}`,
-                },
-            };
-    }
-    const event = { ...response, session_id: sessionId };
-    void transport.write(event);
-    logForDebugging(`[bridge:repl] Sent control_response for ${request.request.subtype} request_id=${request.request_id} result=${response.response.subtype}`);
-}
-// ─── Result message (for session archival on teardown) ───────────────────────
-/**
- * Build a minimal `SDKResultSuccess` message for session archival.
- * The server needs this event before a WS close to trigger archival.
- */
-export function makeResultMessage(sessionId) {
-    return {
-        type: 'result',
-        subtype: 'success',
-        duration_ms: 0,
-        duration_api_ms: 0,
-        is_error: false,
-        num_turns: 0,
-        result: '',
-        stop_reason: null,
-        total_cost_usd: 0,
-        usage: { ...EMPTY_USAGE },
-        modelUsage: {},
-        permission_denials: [],
-        session_id: sessionId,
-        uuid: randomUUID(),
-    };
-}
-// ─── BoundedUUIDSet (echo-dedup ring buffer) ─────────────────────────────────
-/**
- * FIFO-bounded set backed by a circular buffer. Evicts the oldest entry
- * when capacity is reached, keeping memory usage constant at O(capacity).
- *
- * Messages are added in chronological order, so evicted entries are always
- * the oldest. The caller relies on external ordering (the hook's
- * lastWrittenIndexRef) as the primary dedup — this set is a secondary
- * safety net for echo filtering and race-condition dedup.
- */
-export class BoundedUUIDSet {
-    capacity;
-    ring;
-    set = new Set();
-    writeIdx = 0;
-    constructor(capacity) {
-        this.capacity = capacity;
-        this.ring = new Array(capacity);
-    }
-    add(uuid) {
-        if (this.set.has(uuid))
-            return;
-        // Evict the entry at the current write position (if occupied)
-        const evicted = this.ring[this.writeIdx];
-        if (evicted !== undefined) {
-            this.set.delete(evicted);
-        }
-        this.ring[this.writeIdx] = uuid;
-        this.set.add(uuid);
-        this.writeIdx = (this.writeIdx + 1) % this.capacity;
-    }
-    has(uuid) {
-        return this.set.has(uuid);
-    }
-    clear() {
-        this.set.clear();
-        this.ring.fill(undefined);
-        this.writeIdx = 0;
-    }
-}

package/dist/src/bridge/bridgePermissionCallbacks.js

@@ -1,10 +0,0 @@
-/** Type predicate for validating a parsed control_response payload
- *  as a BridgePermissionResponse. Checks the required `behavior`
- *  discriminant rather than using an unsafe `as` cast. */
-function isBridgePermissionResponse(value) {
-    if (!value || typeof value !== 'object')
-        return false;
-    return ('behavior' in value &&
-        (value.behavior === 'allow' || value.behavior === 'deny'));
-}
-export { isBridgePermissionResponse };

package/dist/src/bridge/bridgePointer.js

@@ -1,175 +0,0 @@
-import { mkdir, readFile, stat, unlink, writeFile } from 'fs/promises';
-import { dirname, join } from 'path';
-import { z } from 'zod/v4';
-import { logForDebugging } from '../utils/debug.js';
-import { isENOENT } from '../utils/errors.js';
-import { getWorktreePathsPortable } from '../utils/getWorktreePathsPortable.js';
-import { lazySchema } from '../utils/lazySchema.js';
-import { getProjectsDir, sanitizePath, } from '../utils/sessionStoragePortable.js';
-import { jsonParse, jsonStringify } from '../utils/slowOperations.js';
-/**
- * Upper bound on worktree fanout. git worktree list is naturally bounded
- * (50 is a LOT), but this caps the parallel stat() burst and guards against
- * pathological setups. Above this, --continue falls back to current-dir-only.
- */
-const MAX_WORKTREE_FANOUT = 50;
-/**
- * Crash-recovery pointer for Remote Control sessions.
- *
- * Written immediately after a bridge session is created, periodically
- * refreshed during the session, and cleared on clean shutdown. If the
- * process dies unclean (crash, kill -9, terminal closed), the pointer
- * persists. On next startup, `claude remote-control` detects it and offers
- * to resume via the --session-id flow from #20460.
- *
- * Staleness is checked against the file's mtime (not an embedded timestamp)
- * so that a periodic re-write with the same content serves as a refresh —
- * matches the backend's rolling BRIDGE_LAST_POLL_TTL (4h) semantics. A
- * bridge that's been polling for 5+ hours and then crashes still has a
- * fresh pointer as long as the refresh ran within the window.
- *
- * Scoped per working directory (alongside transcript JSONL files) so two
- * concurrent bridges in different repos don't clobber each other.
- */
-export const BRIDGE_POINTER_TTL_MS = 4 * 60 * 60 * 1000;
-const BridgePointerSchema = lazySchema(() => z.object({
-    sessionId: z.string(),
-    environmentId: z.string(),
-    source: z.enum(['standalone', 'repl']),
-}));
-export function getBridgePointerPath(dir) {
-    return join(getProjectsDir(), sanitizePath(dir), 'bridge-pointer.json');
-}
-/**
- * Write the pointer. Also used to refresh mtime during long sessions —
- * calling with the same IDs is a cheap no-content-change write that bumps
- * the staleness clock. Best-effort — a crash-recovery file must never
- * itself cause a crash. Logs and swallows on error.
- */
-export async function writeBridgePointer(dir, pointer) {
-    const path = getBridgePointerPath(dir);
-    try {
-        await mkdir(dirname(path), { recursive: true });
-        await writeFile(path, jsonStringify(pointer), 'utf8');
-        logForDebugging(`[bridge:pointer] wrote ${path}`);
-    }
-    catch (err) {
-        logForDebugging(`[bridge:pointer] write failed: ${err}`, { level: 'warn' });
-    }
-}
-/**
- * Read the pointer and its age (ms since last write). Operates directly
- * and handles errors — no existence check (CLAUDE.md TOCTOU rule). Returns
- * null on any failure: missing file, corrupted JSON, schema mismatch, or
- * stale (mtime > 4h ago). Stale/invalid pointers are deleted so they don't
- * keep re-prompting after the backend has already GC'd the env.
- */
-export async function readBridgePointer(dir) {
-    const path = getBridgePointerPath(dir);
-    let raw;
-    let mtimeMs;
-    try {
-        // stat for mtime (staleness anchor), then read. Two syscalls, but both
-        // are needed — mtime IS the data we return, not a TOCTOU guard.
-        mtimeMs = (await stat(path)).mtimeMs;
-        raw = await readFile(path, 'utf8');
-    }
-    catch {
-        return null;
-    }
-    const parsed = BridgePointerSchema().safeParse(safeJsonParse(raw));
-    if (!parsed.success) {
-        logForDebugging(`[bridge:pointer] invalid schema, clearing: ${path}`);
-        await clearBridgePointer(dir);
-        return null;
-    }
-    const ageMs = Math.max(0, Date.now() - mtimeMs);
-    if (ageMs > BRIDGE_POINTER_TTL_MS) {
-        logForDebugging(`[bridge:pointer] stale (>4h mtime), clearing: ${path}`);
-        await clearBridgePointer(dir);
-        return null;
-    }
-    return { ...parsed.data, ageMs };
-}
-/**
- * Worktree-aware read for `--continue`. The REPL bridge writes its pointer
- * to `getOriginalCwd()` which EnterWorktreeTool/activeWorktreeSession can
- * mutate to a worktree path — but `claude remote-control --continue` runs
- * with `resolve('.')` = shell CWD. This fans out across git worktree
- * siblings to find the freshest pointer, matching /resume's semantics.
- *
- * Fast path: checks `dir` first. Only shells out to `git worktree list` if
- * that misses — the common case (pointer in launch dir) is one stat, zero
- * exec. Fanout reads run in parallel; capped at MAX_WORKTREE_FANOUT.
- *
- * Returns the pointer AND the dir it was found in, so the caller can clear
- * the right file on resume failure.
- */
-export async function readBridgePointerAcrossWorktrees(dir) {
-    // Fast path: current dir. Covers standalone bridge (always matches) and
-    // REPL bridge when no worktree mutation happened.
-    const here = await readBridgePointer(dir);
-    if (here) {
-        return { pointer: here, dir };
-    }
-    // Fanout: scan worktree siblings. getWorktreePathsPortable has a 5s
-    // timeout and returns [] on any error (not a git repo, git not installed).
-    const worktrees = await getWorktreePathsPortable(dir);
-    if (worktrees.length <= 1)
-        return null;
-    if (worktrees.length > MAX_WORKTREE_FANOUT) {
-        logForDebugging(`[bridge:pointer] ${worktrees.length} worktrees exceeds fanout cap ${MAX_WORKTREE_FANOUT}, skipping`);
-        return null;
-    }
-    // Dedupe against `dir` so we don't re-stat it. sanitizePath normalizes
-    // case/separators so worktree-list output matches our fast-path key even
-    // on Windows where git may emit C:/ vs stored c:/.
-    const dirKey = sanitizePath(dir);
-    const candidates = worktrees.filter(wt => sanitizePath(wt) !== dirKey);
-    // Parallel stat+read. Each readBridgePointer is a stat() that ENOENTs
-    // for worktrees with no pointer (cheap) plus a ~100-byte read for the
-    // rare ones that have one. Promise.all → latency ≈ slowest single stat.
-    const results = await Promise.all(candidates.map(async (wt) => {
-        const p = await readBridgePointer(wt);
-        return p ? { pointer: p, dir: wt } : null;
-    }));
-    // Pick freshest (lowest ageMs). The pointer stores environmentId so
-    // resume reconnects to the right env regardless of which worktree
-    // --continue was invoked from.
-    let freshest = null;
-    for (const r of results) {
-        if (r && (!freshest || r.pointer.ageMs < freshest.pointer.ageMs)) {
-            freshest = r;
-        }
-    }
-    if (freshest) {
-        logForDebugging(`[bridge:pointer] fanout found pointer in worktree ${freshest.dir} (ageMs=${freshest.pointer.ageMs})`);
-    }
-    return freshest;
-}
-/**
- * Delete the pointer. Idempotent — ENOENT is expected when the process
- * shut down clean previously.
- */
-export async function clearBridgePointer(dir) {
-    const path = getBridgePointerPath(dir);
-    try {
-        await unlink(path);
-        logForDebugging(`[bridge:pointer] cleared ${path}`);
-    }
-    catch (err) {
-        if (!isENOENT(err)) {
-            logForDebugging(`[bridge:pointer] clear failed: ${err}`, {
-                level: 'warn',
-            });
-        }
-    }
-}
-function safeJsonParse(raw) {
-    try {
-        return jsonParse(raw);
-    }
-    catch {
-        return null;
-    }
-}

package/dist/src/bridge/bridgeStatusUtil.js

@@ -1,105 +0,0 @@
-import { getClaudeAiBaseUrl, getRemoteSessionUrl, } from '../constants/product.js';
-import { stringWidth } from '../ink/stringWidth.js';
-import { formatDuration, truncateToWidth } from '../utils/format.js';
-import { getGraphemeSegmenter } from '../utils/intl.js';
-/** How long a tool activity line stays visible after last tool_start (ms). */
-export const TOOL_DISPLAY_EXPIRY_MS = 30_000;
-/** Interval for the shimmer animation tick (ms). */
-export const SHIMMER_INTERVAL_MS = 150;
-export function timestamp() {
-    const now = new Date();
-    const h = String(now.getHours()).padStart(2, '0');
-    const m = String(now.getMinutes()).padStart(2, '0');
-    const s = String(now.getSeconds()).padStart(2, '0');
-    return `${h}:${m}:${s}`;
-}
-export { formatDuration, truncateToWidth as truncatePrompt };
-/** Abbreviate a tool activity summary for the trail display. */
-export function abbreviateActivity(summary) {
-    return truncateToWidth(summary, 30);
-}
-/** Build the connect URL shown when the bridge is idle. */
-export function buildBridgeConnectUrl(environmentId, ingressUrl) {
-    const baseUrl = getClaudeAiBaseUrl(undefined, ingressUrl);
-    return `${baseUrl}/code?bridge=${environmentId}`;
-}
-/**
- * Build the session URL shown when a session is attached. Delegates to
- * getRemoteSessionUrl for the cse_→session_ prefix translation, then appends
- * the v1-specific ?bridge={environmentId} query.
- */
-export function buildBridgeSessionUrl(sessionId, environmentId, ingressUrl) {
-    return `${getRemoteSessionUrl(sessionId, ingressUrl)}?bridge=${environmentId}`;
-}
-/** Compute the glimmer index for a reverse-sweep shimmer animation. */
-export function computeGlimmerIndex(tick, messageWidth) {
-    const cycleLength = messageWidth + 20;
-    return messageWidth + 10 - (tick % cycleLength);
-}
-/**
- * Split text into three segments by visual column position for shimmer rendering.
- *
- * Uses grapheme segmentation and `stringWidth` so the split is correct for
- * multi-byte characters, emoji, and CJK glyphs.
- *
- * Returns `{ before, shimmer, after }` strings. Both renderers (chalk in
- * bridgeUI.ts and React/Ink in bridge.tsx) apply their own coloring to
- * these segments.
- */
-export function computeShimmerSegments(text, glimmerIndex) {
-    const messageWidth = stringWidth(text);
-    const shimmerStart = glimmerIndex - 1;
-    const shimmerEnd = glimmerIndex + 1;
-    // When shimmer is offscreen, return all text as "before"
-    if (shimmerStart >= messageWidth || shimmerEnd < 0) {
-        return { before: text, shimmer: '', after: '' };
-    }
-    // Split into at most 3 segments by visual column position
-    const clampedStart = Math.max(0, shimmerStart);
-    let colPos = 0;
-    let before = '';
-    let shimmer = '';
-    let after = '';
-    for (const { segment } of getGraphemeSegmenter().segment(text)) {
-        const segWidth = stringWidth(segment);
-        if (colPos + segWidth <= clampedStart) {
-            before += segment;
-        }
-        else if (colPos > shimmerEnd) {
-            after += segment;
-        }
-        else {
-            shimmer += segment;
-        }
-        colPos += segWidth;
-    }
-    return { before, shimmer, after };
-}
-/** Derive a status label and color from the bridge connection state. */
-export function getBridgeStatus({ error, connected, sessionActive, reconnecting, }) {
-    if (error)
-        return { label: 'Control Remoto fallido', color: 'error' };
-    if (reconnecting)
-        return { label: 'Reconectando Control Remoto', color: 'warning' };
-    if (sessionActive || connected)
-        return { label: 'Control Remoto activo', color: 'success' };
-    return { label: 'Conectando Control Remoto\u2026', color: 'warning' };
-}
-/** Footer text shown when bridge is idle (Ready state). */
-export function buildIdleFooterText(url) {
-    return `Programa en cualquier lugar con la app de Context Code o ${url}`;
-}
-/** Footer text shown when a session is active (Connected state). */
-export function buildActiveFooterText(url) {
-    return `Continúa programando en la app de Context Code o ${url}`;
-}
-/** Footer text shown when the bridge has failed. */
-export const FAILED_FOOTER_TEXT = 'Algo salió mal, por favor inténtalo de nuevo';
-/**
- * Wrap text in an OSC 8 terminal hyperlink. Zero visual width for layout purposes.
- * strip-ansi (used by stringWidth) correctly strips these sequences, so
- * countVisualLines in bridgeUI.ts remains accurate.
- */
-export function wrapWithOsc8Link(text, url) {
-    return `\x1b]8;;${url}\x07${text}\x1b]8;;\x07`;
-}