@north-light/crouter 0.3.221 → 0.3.223

package/dist/clients/attach/render/markdown-source.js

@@ -22,6 +22,7 @@
 // GLYPHS. Private-use `U+XXXX` references become their glyphs (see
 // glyph-codepoints.ts), so an agent that cannot type a Nerd Font character can
 // still put one on screen.
+import { pathToFileURL } from 'node:url';
 import { expandGlyphCodepoints } from './glyph-codepoints.js';
 const ATX_HEADING = /^(\s{0,3})(#{3,6})(?:[ \t]+|$)(.*?)([ \t]+#+[ \t]*)?$/;
 const FENCE_OPEN = /^\s{0,3}(`{3,}|~{3,})/;
@@ -126,7 +127,111 @@ export function styleAttachMarkdownSource(markdown) {
  *  message keeps `styleAttachMarkdownSource` alone — the `U+XXXX` escape hatch
  *  exists for agents that cannot type a Nerd Font character. */
 export function styleAttachAgentMarkdown(markdown) {
-    return expandGlyphCodepoints(styleAttachMarkdownSource(markdown));
+    return expandGlyphCodepoints(styleAttachMarkdownSource(rewriteAbsoluteFileLinks(markdown)));
+}
+/** Give iTerm a hidden fragment so its Semantic History action receives the local target. */
+function rewriteAbsoluteFileLinks(markdown) {
+    let fence;
+    return markdown.split('\n').map((line) => {
+        const fenceMatch = FENCE_OPEN.exec(line);
+        if (fence !== undefined) {
+            if (fenceMatch?.[1][0] === fence)
+                fence = undefined;
+            return line;
+        }
+        if (fenceMatch) {
+            fence = fenceMatch[1][0];
+            return line;
+        }
+        return rewriteInlineFileLinks(line);
+    }).join('\n');
+}
+function rewriteInlineFileLinks(line) {
+    let result = '';
+    let rest = line;
+    while (rest !== '') {
+        const opening = rest.match(/`+/);
+        const prose = opening === null ? rest : rest.slice(0, opening.index);
+        result += rewriteProseFileLinks(prose);
+        if (opening === null)
+            break;
+        const delimiter = opening[0];
+        const end = rest.indexOf(delimiter, prose.length + delimiter.length);
+        if (end === -1)
+            return result + rest.slice(prose.length);
+        result += rest.slice(prose.length, end + delimiter.length);
+        rest = rest.slice(end + delimiter.length);
+    }
+    return result;
+}
+function rewriteProseFileLinks(prose) {
+    let result = '';
+    let index = 0;
+    while (index < prose.length) {
+        const start = prose.indexOf('[', index);
+        if (start === -1)
+            return result + prose.slice(index);
+        const link = parseLocalMarkdownLink(prose, start);
+        if (link === undefined) {
+            result += prose.slice(index, start + 1);
+            index = start + 1;
+            continue;
+        }
+        result += prose.slice(index, start) + `[${link.label}](${pathToFileURL(link.path).href}#crtr-file-open)`;
+        index = link.end;
+    }
+    return result;
+}
+function parseLocalMarkdownLink(line, start) {
+    const labelEnd = closingDelimiter(line, start + 1, ']');
+    if (labelEnd === undefined || line[labelEnd + 1] !== '(')
+        return undefined;
+    const destinationStart = labelEnd + 2;
+    if (line[destinationStart] === '<') {
+        const destinationEnd = closingDelimiter(line, destinationStart + 1, '>');
+        if (destinationEnd === undefined || line[destinationEnd + 1] !== ')')
+            return undefined;
+        const path = localPathFromDestination(line.slice(destinationStart + 1, destinationEnd));
+        return path === undefined ? undefined : { label: line.slice(start + 1, labelEnd), path, end: destinationEnd + 2 };
+    }
+    let depth = 0;
+    for (let index = destinationStart; index < line.length; index++) {
+        if (line[index] === '\\') {
+            index++;
+            continue;
+        }
+        if (line[index] === '(') {
+            depth++;
+            continue;
+        }
+        if (line[index] !== ')' || depth-- > 0)
+            continue;
+        const path = localPathFromDestination(line.slice(destinationStart, index));
+        return path === undefined ? undefined : { label: line.slice(start + 1, labelEnd), path, end: index + 1 };
+    }
+    return undefined;
+}
+function closingDelimiter(text, start, delimiter) {
+    for (let index = start; index < text.length; index++) {
+        if (text[index] === '\\') {
+            index++;
+            continue;
+        }
+        if (text[index] === delimiter)
+            return index;
+    }
+    return undefined;
+}
+function localPathFromDestination(destination) {
+    const unescaped = destination.replace(/\\([!"#$%&'()*+,./:;<=>?@[\\\]^_`{|}~-])/g, '$1');
+    let path = unescaped;
+    try {
+        path = decodeURIComponent(unescaped);
+    }
+    catch {
+        // A literal percent is legal in a path but not in URI decoding.
+    }
+    return path.startsWith('/') ? path : undefined;
 }
 /** Copy a pi message for terminal rendering and decorate only Markdown-bearing
  * text/thinking blocks. The broker's source event is never mutated. */

package/dist/clients/attach/session/file-links.d.ts

@@ -1,9 +1,18 @@
-/** URI of the OSC-8 hyperlink occupying the given 1-indexed terminal cell. */
-export declare function osc8UriAt(frame: readonly string[], row: number, column: number): string | undefined;
-export type LinkedFileOpenResult = 'opened' | 'missing' | 'invalid' | 'failed';
+/** A local file requested through iTerm Semantic History. */
+export interface FileOpenInput {
+    file: string | undefined;
+    remaining: string;
+}
+/**
+ * Strip the private iTerm Semantic History input and return its local path.
+ * iTerm expands `\\1` as a shell-escaped word, so decode that representation
+ * without ever evaluating it as shell input.
+ */
+export declare function extractFileOpenInput(data: string): FileOpenInput | undefined;
+export type LinkedFileOpenResult = 'opened' | 'missing' | 'failed';
 /** Replace this local viewer pane with Neovim, then reattach it when Neovim exits. */
 export declare function openLinkedFileInPane(opts: {
-    uri: string;
+    file: string;
     pane: string;
     cwd: string;
     nodeId: string;

package/dist/clients/attach/session/file-links.js

@@ -1,72 +1,68 @@
-// session/file-links.ts — OSC-8 file links in the rendered attach frame.
+// session/file-links.ts — iTerm Semantic History file-open bridge.
 //
-// A click is resolved against the physical rows last handed to the terminal,
-// not against transcript records: wrapping, fixed cockpit rows, ANSI styling,
-// and OSC-8 boundaries have all already been composed there.
+// iTerm sends the clicked path through a private input sequence. The viewer
+// validates it, replaces its pane with Neovim, then reattaches after exit.
 import { existsSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { walkRow } from '../ansi-cells.js';
 import { respawnPaneInBackground, shellQuote, viewerSplitEnv } from '../../../core/runtime/placement-tmux.js';
-/** URI of the OSC-8 hyperlink occupying the given 1-indexed terminal cell. */
-export function osc8UriAt(frame, row, column) {
-    if (!Number.isInteger(row) || !Number.isInteger(column) || row < 1 || column < 1)
+const FILE_OPEN_PREFIX = '\x1b_crtr-file-open;';
+const STRING_TERMINATOR = '\x1b\\';
+/**
+ * Strip the private iTerm Semantic History input and return its local path.
+ * iTerm expands `\\1` as a shell-escaped word, so decode that representation
+ * without ever evaluating it as shell input.
+ */
+export function extractFileOpenInput(data) {
+    const start = data.indexOf(FILE_OPEN_PREFIX);
+    if (start === -1)
         return undefined;
-    let activeUri;
-    for (let index = 0; index < Math.min(row, frame.length); index++) {
-        const hitColumn = index === row - 1 ? column : undefined;
-        const scanned = scanOsc8Row(frame[index] ?? '', activeUri, hitColumn);
-        activeUri = scanned.activeUri;
-        if (scanned.uri !== undefined)
-            return scanned.uri;
-    }
-    return undefined;
+    const pathStart = start + FILE_OPEN_PREFIX.length;
+    const end = data.indexOf(STRING_TERMINATOR, pathStart);
+    if (end === -1)
+        return undefined;
+    const file = decodeShellEscapedPath(data.slice(pathStart, end));
+    return { file, remaining: data.slice(0, start) + data.slice(end + STRING_TERMINATOR.length) };
 }
-function scanOsc8Row(line, initialUri, hitColumn) {
-    let activeUri = initialUri;
-    let uri;
-    walkRow(line, {
-        onEscape: (escape) => {
-            const osc8 = parseOsc8(escape);
-            if (osc8 !== null)
-                activeUri = osc8 === '' ? undefined : osc8;
-        },
-        onGlyph: (glyph) => {
-            if (uri !== undefined || hitColumn === undefined || activeUri === undefined || glyph.width === 0)
-                return;
-            const cell = hitColumn - 1;
-            if (cell >= glyph.cell && cell < glyph.cell + glyph.width)
-                uri = activeUri;
-        },
-    });
-    return { activeUri, uri };
+function decodeShellEscapedPath(value) {
+    const decoded = value.startsWith("'") ? decodeSingleQuotedPath(value) : decodeBackslashPath(value);
+    return decoded !== undefined && decoded.startsWith('/') && !/[\x00-\x1f\x7f]/.test(decoded) ? decoded : undefined;
 }
-/** `null` means another escape sequence; an empty URI closes the active link. */
-function parseOsc8(sequence) {
-    if (!sequence.startsWith('\x1b]8;'))
-        return null;
-    const terminatorLength = sequence.endsWith('\x1b\\') ? 2 : 1;
-    const body = sequence.slice(4, -terminatorLength);
-    const separator = body.indexOf(';');
-    if (separator === -1)
-        return null;
-    return body.slice(separator + 1);
+function decodeSingleQuotedPath(value) {
+    let result = '';
+    let index = 1;
+    while (true) {
+        const end = value.indexOf("'", index);
+        if (end === -1)
+            return undefined;
+        result += value.slice(index, end);
+        index = end + 1;
+        if (index === value.length)
+            return result;
+        if (value.slice(index, index + 3) !== "\\''")
+            return undefined;
+        result += "'";
+        index += 3;
+    }
+}
+function decodeBackslashPath(value) {
+    let result = '';
+    for (let index = 0; index < value.length; index++) {
+        if (value[index] !== '\\') {
+            result += value[index];
+            continue;
+        }
+        const escaped = value[++index];
+        if (escaped === undefined)
+            return undefined;
+        result += escaped;
+    }
+    return result;
 }
 /** Replace this local viewer pane with Neovim, then reattach it when Neovim exits. */
 export function openLinkedFileInPane(opts) {
-    let file;
-    try {
-        const url = new URL(opts.uri);
-        if (url.protocol !== 'file:')
-            return 'invalid';
-        file = fileURLToPath(url);
-    }
-    catch {
-        return 'invalid';
-    }
-    if (!existsSync(file))
+    if (!existsSync(opts.file))
         return 'missing';
     const attach = `crtr surface attach to ${shellQuote(opts.nodeId)}${opts.observer ? ' --observer' : ''}`;
-    const command = `nvim ${shellQuote(file)} || :; exec ${attach}`;
+    const command = `nvim ${shellQuote(opts.file)} || :; exec ${attach}`;
     opts.beforeRespawn();
     return respawnPaneInBackground({ pane: opts.pane, cwd: opts.cwd, env: viewerSplitEnv(), command }) ? 'opened' : 'failed';
 }