Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.
TypeScript adeagent-ideai-agentsautomationbotclaude-codecodexghosttygrok-bothermes-agentmobile-appmuseopenclawopencodeorchestrationpiruntimeterminalworktreesyc-backed
import {
TERMINAL_HTTP_URL_MAX_HARD_WRAPPED_ROWS,
TERMINAL_HTTP_URL_MAX_LENGTH
} from './terminal-http-link-limits'
import { translateLineWithColumns, type WrappedLogicalLine } from './wrapped-terminal-link-ranges'
import type { TerminalLinkBuffer } from './terminal-link-buffer'
const HTTP_SCHEME_PATTERN = /https?:\/\//i
const HTTP_SCHEME_START_PATTERN = /^https?:\/\//i
const HTTP_FRAGMENT_PATTERN = /^[^\s"'!*(){}|\\^<>`│┃║╎╏┆┇┊┋]*/
const VERTICAL_LAYOUT_FRAME_PATTERN = /[│┃║╎╏┆┇┊┋|]/
const NON_LAYOUT_SUFFIX_PATTERN = /[^\s│┃║╎╏┆┇┊┋|]/
const HARD_WRAP_CONTINUATION_SUFFIX_PATTERN = /[/?&=#%+:-]$/
const LAYOUT_SUFFIX_CHAR_PATTERN = /[\s│┃║╎╏┆┇┊┋|]/
const MIN_HARD_WRAPPED_HTTP_ROWS = 3
const MIN_HARD_WRAP_FILL_RATIO = 0.8
type TranslatedLine = ReturnType<typeof translateLineWithColumns>
// Continuation rows end in frame + prefix + URL fragment + layout-only suffix with a right frame.
function canBeFramedContinuationRow(text: string): boolean {
let contentEnd = text.length
let hasRightFrame = false
while (contentEnd > 0 && LAYOUT_SUFFIX_CHAR_PATTERN.test(text[contentEnd - 1]!)) {
hasRightFrame ||= VERTICAL_LAYOUT_FRAME_PATTERN.test(text[contentEnd - 1]!)
contentEnd--
}
return (
hasRightFrame &&
contentEnd > 0 &&
Boolean(HTTP_FRAGMENT_PATTERN.exec(text[contentEnd - 1]!)?.[0]) &&
VERTICAL_LAYOUT_FRAME_PATTERN.test(text.slice(0, contentEnd))
)
}
function findFrameIndexBefore(text: string, beforeIndex: number): number {
for (let index = beforeIndex - 1; index >= 0; index--) {
if (VERTICAL_LAYOUT_FRAME_PATTERN.test(text[index]!)) {
return index
}
}
return -1
}
function hasFrameAtColumn(translated: TranslatedLine, frameColumn: number): boolean {
const frameIndex = translated.columns.indexOf(frameColumn)
return frameIndex !== -1 && VERTICAL_LAYOUT_FRAME_PATTERN.test(translated.text[frameIndex] ?? '')
}
// Overlay rows share the frame column and inner padding; the uncovered gutter can differ.
function findOverlayFragmentStart(
translated: TranslatedLine,
frameColumn: number,
outerFrameColumn: number | null,
framedPrefix: string
): number {
// A second stable left frame under a changed prefix denotes adjacent table cells.
if (outerFrameColumn !== null && hasFrameAtColumn(translated, outerFrameColumn)) {
return -1
}
const frameIndex = translated.columns.indexOf(frameColumn)
if (frameIndex === -1) {
return -1
}
const prefixEnd = frameIndex + framedPrefix.length
return translated.text.slice(frameIndex, prefixEnd) === framedPrefix ? prefixEnd : -1
}
function buildCandidateFromStart(
buffer: TerminalLinkBuffer,
startY: number,
currentY: number,
translatedLines: Map<number, TranslatedLine>
): WrappedLogicalLine | null {
const startLine = buffer.getLine(startY)
if (!startLine) {
return null
}
const cachedStart = translatedLines.get(startY)
const startText = cachedStart?.text ?? startLine.translateToString(false)
const schemeIndex = startText.search(HTTP_SCHEME_PATTERN)
if (schemeIndex === -1 || !VERTICAL_LAYOUT_FRAME_PATTERN.test(startText.slice(0, schemeIndex))) {
return null
}
const translatedStart = cachedStart ?? translateLineWithColumns(startLine)
translatedLines.set(startY, translatedStart)
const frameIndex = findFrameIndexBefore(translatedStart.text, schemeIndex)
if (frameIndex === -1) {
return null
}
const frameColumn = translatedStart.columns[frameIndex]
if (frameColumn === undefined) {
return null
}
const outerFrameIndex = findFrameIndexBefore(translatedStart.text, frameIndex)
const outerFrameColumn =
outerFrameIndex === -1 ? null : (translatedStart.columns[outerFrameIndex] ?? null)
const rowPrefix = translatedStart.text.slice(0, schemeIndex)
const framedPrefix = translatedStart.text.slice(frameIndex, schemeIndex)
let text = ''
let rightFrameColumn: number | null = null
let previousRowCanContinue = true
let startRowFilled = false
const rows: WrappedLogicalLine['rows'] = []
for (let rowY = startY; rowY < startY + TERMINAL_HTTP_URL_MAX_HARD_WRAPPED_ROWS; rowY++) {
if (rowY > startY && !previousRowCanContinue) {
break
}
const line = buffer.getLine(rowY)
if (!line) {
break
}
const translated =
rowY === startY
? translatedStart
: (translatedLines.get(rowY) ?? translateLineWithColumns(line))
translatedLines.set(rowY, translated)
const fragmentStart =
rowY === startY || translated.text.slice(0, schemeIndex) === rowPrefix
? schemeIndex
: findOverlayFragmentStart(translated, frameColumn, outerFrameColumn, framedPrefix)
if (fragmentStart === -1) {
break
}
const fragmentStartColumn = translated.columns[fragmentStart]
if (fragmentStartColumn === undefined) {
break
}
const fragment = translated.text.slice(fragmentStart).match(HTTP_FRAGMENT_PATTERN)?.[0] ?? ''
if (!fragment || (rowY > startY && HTTP_SCHEME_START_PATTERN.test(fragment))) {
break
}
const fragmentEnd = fragmentStart + fragment.length
const layoutSuffix = translated.text.slice(fragmentEnd)
const rightFrameOffset = layoutSuffix.search(VERTICAL_LAYOUT_FRAME_PATTERN)
const currentRightFrameIndex = rightFrameOffset === -1 ? -1 : fragmentEnd + rightFrameOffset
const currentRightFrameColumn = translated.columns[currentRightFrameIndex]
if (
currentRightFrameIndex === -1 ||
currentRightFrameColumn === undefined ||
(rightFrameColumn !== null && currentRightFrameColumn !== rightFrameColumn) ||
NON_LAYOUT_SUFFIX_PATTERN.test(layoutSuffix)
) {
break
}
rightFrameColumn ??= currentRightFrameColumn
if (text.length + fragment.length > TERMINAL_HTTP_URL_MAX_LENGTH) {
return null
}
rows.push({
y: rowY,
text: fragment,
sourceText: translated.text,
columns: translated.columns.slice(fragmentStart, fragmentEnd + 1),
startIndex: text.length,
isWrapped: line.isWrapped,
lineLength: line.length
})
text += fragment
const contentWidth = currentRightFrameColumn - fragmentStartColumn
const fragmentWidth = translated.columns[fragmentEnd]! - fragmentStartColumn
const fillsRow = contentWidth > 0 && fragmentWidth / contentWidth >= MIN_HARD_WRAP_FILL_RATIO
if (rowY === startY) {
startRowFilled = fillsRow
}
previousRowCanContinue = HARD_WRAP_CONTINUATION_SUFFIX_PATTERN.test(fragment) || fillsRow
}
if (rows.length > 1 && (rows.length < MIN_HARD_WRAPPED_HTTP_ROWS || !startRowFilled)) {
// A complete URL may end in /; one adjacent framed token alone cannot prove continuation.
rows.splice(1)
text = rows[0]?.text ?? ''
}
// oxlint-disable-next-line unicorn/prefer-at -- the phone's terminal WebView (Chrome 74) has no Array#at
const lastRow: WrappedLogicalLine['rows'][number] | undefined = rows[rows.length - 1]
if (lastRow?.y === undefined || lastRow.y < currentY) {
return null
}
return {
text,
rows,
fingerprint: `hard-http:${rows.map((row) => `${row.y}:${row.sourceText}`).join('\0')}`
}
}
export function buildHardWrappedHttpLogicalLineCandidates(
buffer: TerminalLinkBuffer,
bufferLineNumber: number
): WrappedLogicalLine[] {
const currentY = bufferLineNumber - 1
const currentLine = buffer.getLine(currentY)
if (!currentLine || !VERTICAL_LAYOUT_FRAME_PATTERN.test(currentLine.translateToString(false))) {
// Skip backward scanning without the stable vertical frame required for cursor-positioned hard wraps.
return []
}
const candidates: WrappedLogicalLine[] = []
const translatedLines = new Map<number, TranslatedLine>()
const minY = Math.max(0, currentY - TERMINAL_HTTP_URL_MAX_HARD_WRAPPED_ROWS + 1)
for (let startY = currentY; startY >= minY; startY--) {
const candidate = buildCandidateFromStart(buffer, startY, currentY, translatedLines)
if (candidate) {
candidates.push(candidate)
}
// Earlier starts must continue through this row; stop at borders, prose, and blank rows.
const rowText =
translatedLines.get(startY)?.text ?? buffer.getLine(startY)?.translateToString(false)
if (rowText === undefined || !canBeFramedContinuationRow(rowText)) {
break
}
}
return candidates.sort(
(left, right) => right.rows.length - left.rows.length || right.text.length - left.text.length
)
}