cli-jaw 2.0.5 → 2.0.6

package/public/js/features/voice-recorder.ts

@@ -13,6 +13,18 @@ let chunks: Blob[] = [];
 let recordingStream: MediaStream | null = null;
 let timerInterval: ReturnType<typeof setInterval> | null = null;
 let startTime = 0;
+let startPending = false;
+let stopAction: 'stopped' | 'cancelled' | 'failed' = 'stopped';
+const MIC_PERMISSION_TIMEOUT_MS = 15000;
+
+type DocumentPermissionPolicy = {
+    allowsFeature?: (feature: string) => boolean;
+};
+
+type MicPermissionParams = {
+    origin: string;
+    alternateOrigin: string;
+};
 
 /** Pick best supported MIME type for cross-platform */
 function pickMime(): string {
@@ -39,6 +51,8 @@ function classifyMicError(err: unknown): string {
         case 'NotReadableError':
         case 'AbortError':
             return t('voice.micBusy');
+        case 'TimeoutError':
+            return micRequestTimeoutMessage();
         default:
             if (e instanceof TypeError || !navigator.mediaDevices) {
                 return t('voice.httpsRequired');
@@ -47,75 +61,231 @@ function classifyMicError(err: unknown): string {
     }
 }
 
+function getDocumentPermissionPolicy(): DocumentPermissionPolicy | null {
+    const scoped = document as Document & {
+        featurePolicy?: DocumentPermissionPolicy;
+        permissionsPolicy?: DocumentPermissionPolicy;
+    };
+    return scoped.permissionsPolicy || scoped.featurePolicy || null;
+}
+
+function isMicBlockedByDocumentPolicy(): boolean {
+    try {
+        return getDocumentPermissionPolicy()?.allowsFeature?.('microphone') === false;
+    } catch {
+        return false;
+    }
+}
+
+async function getMicrophonePermissionState(): Promise<PermissionState | null> {
+    try {
+        if (!navigator.permissions?.query) return null;
+        const status = await navigator.permissions.query({ name: 'microphone' as PermissionName });
+        return status.state;
+    } catch {
+        return null;
+    }
+}
+
+function micPermissionParams(): MicPermissionParams {
+    const current = new URL(window.location.href);
+    const alternate = new URL(current.href);
+    if (current.hostname === '127.0.0.1') {
+        alternate.hostname = 'localhost';
+    } else if (current.hostname === 'localhost') {
+        alternate.hostname = '127.0.0.1';
+    }
+    const alternateOrigin = alternate.origin === current.origin ? '' : alternate.origin;
+    return { origin: current.origin, alternateOrigin };
+}
+
+function micRequestTimeoutMessage(): string {
+    const params = micPermissionParams();
+    if (params.alternateOrigin) {
+        return t('voice.requestTimeoutLoopback', params);
+    }
+    return t('voice.requestTimeout', params);
+}
+
+function classifyRecorderStartError(err: unknown): string {
+    const e = err as DOMException;
+    if (e.name === 'NotSupportedError') return t('voice.unsupported');
+    if (e.name === 'NotReadableError' || e.name === 'AbortError') return t('voice.micBusy');
+    if (e instanceof TypeError) return t('voice.httpsRequired');
+    return t('voice.interrupted');
+}
+
+function postPreviewSttRecording(action: 'request' | 'started' | 'stopped' | 'cancelled' | 'failed'): void {
+    if (window.parent === window) return;
+    try {
+        window.parent.postMessage({ type: 'jaw-preview-stt-recording', action }, '*');
+    } catch {
+        // Preview coordination is best-effort; standalone STT must keep working.
+    }
+}
+
+function micPermissionTimeoutError(): DOMException {
+    return new DOMException('Timed out waiting for microphone permission prompt', 'TimeoutError');
+}
+
+async function requestMicStreamWithTimeout(): Promise<MediaStream> {
+    let didTimeout = false;
+    let timeoutId: ReturnType<typeof setTimeout> | null = null;
+    const mediaPromise = navigator.mediaDevices.getUserMedia({ audio: true }).then(
+        (candidate) => {
+            if (didTimeout) {
+                candidate.getTracks().forEach(track => track.stop());
+                return null;
+            }
+            return candidate;
+        },
+        (err: unknown) => {
+            if (didTimeout) return null;
+            throw err;
+        },
+    );
+    const timeoutPromise = new Promise<never>((_, reject) => {
+        timeoutId = setTimeout(() => {
+            didTimeout = true;
+            reject(micPermissionTimeoutError());
+        }, MIC_PERMISSION_TIMEOUT_MS);
+    });
+    try {
+        const stream = await Promise.race([mediaPromise, timeoutPromise]);
+        if (!stream) throw micPermissionTimeoutError();
+        return stream;
+    } finally {
+        if (timeoutId !== null) clearTimeout(timeoutId);
+    }
+}
+
 export async function startRecording(): Promise<void> {
-    if (state.isRecording) return;
+    if (state.isRecording || startPending) return;
 
     // Feature detection
     if (typeof MediaRecorder === 'undefined' || !navigator.mediaDevices?.getUserMedia) {
         addSystemMsg(t('voice.unsupported'), '', 'error');
         return;
     }
+    if (isMicBlockedByDocumentPolicy()) {
+        addSystemMsg(t('voice.policyBlocked'), '', 'error');
+        return;
+    }
+    if (await getMicrophonePermissionState() === 'denied') {
+        addSystemMsg(t('voice.permissionDeniedBrowser', micPermissionParams()), '', 'error');
+        return;
+    }
+
+    startPending = true;
+    cancelled = false;
+    stopAction = 'stopped';
+    updateRecordingUI(false);
+    postPreviewSttRecording('request');
 
+    let stream: MediaStream | null = null;
     try {
-        recordingStream = await navigator.mediaDevices.getUserMedia({ audio: true });
+        stream = await requestMicStreamWithTimeout();
+        recordingStream = stream;
     } catch (err) {
+        startPending = false;
+        updateRecordingUI(false);
+        postPreviewSttRecording('failed');
         addSystemMsg(classifyMicError(err), '', 'error');
         return;
     }
 
-    const mimeType = pickMime();
-    const options: MediaRecorderOptions = mimeType ? { mimeType } : {};
-    mediaRecorder = new MediaRecorder(recordingStream, options);
-    chunks = [];
+    try {
+        const mimeType = pickMime();
+        const options: MediaRecorderOptions = mimeType ? { mimeType } : {};
+        const recorder = new MediaRecorder(stream, options);
+        mediaRecorder = recorder;
+        chunks = [];
 
-    mediaRecorder.ondataavailable = (e) => {
-        if (e.data.size > 0) chunks.push(e.data);
-    };
+        recorder.ondataavailable = (e) => {
+            if (e.data.size > 0) chunks.push(e.data);
+        };
 
-    mediaRecorder.onerror = () => {
-        stopRecording();
-        addSystemMsg(t('voice.interrupted'), '', 'error');
-    };
+        recorder.onerror = () => {
+            cancelled = true;
+            stopAction = 'failed';
+            state.isRecording = false;
+            stopTimer();
+            updateRecordingUI(false);
+            if (recorder.state === 'recording') {
+                recorder.stop();
+            } else {
+                chunks = [];
+                releaseStream();
+                mediaRecorder = null;
+                postPreviewSttRecording('failed');
+            }
+            addSystemMsg(t('voice.interrupted'), '', 'error');
+        };
 
-    mediaRecorder.onstop = async () => {
-        if (cancelled) {
+        recorder.onstop = async () => {
+            const finalAction = stopAction;
+            const wasCancelled = cancelled || finalAction !== 'stopped';
+            stopAction = 'stopped';
+            if (wasCancelled) {
+                chunks = [];
+                releaseStream();
+                mediaRecorder = null;
+                cancelled = false;
+                postPreviewSttRecording(finalAction);
+                return;
+            }
+            const actualMime = recorder.mimeType || mimeType || 'audio/webm';
+            const ext = actualMime.includes('mp4') ? '.m4a'
+                      : actualMime.includes('ogg') ? '.ogg'
+                      : '.webm';
+            const blob = new Blob(chunks, { type: actualMime });
             chunks = [];
             releaseStream();
+            mediaRecorder = null;
             cancelled = false;
-            return;
-        }
-        const actualMime = mediaRecorder?.mimeType || mimeType || 'audio/webm';
-        const ext = actualMime.includes('mp4') ? '.m4a'
-                  : actualMime.includes('ogg') ? '.ogg'
-                  : '.webm';
-        const blob = new Blob(chunks, { type: actualMime });
-        chunks = [];
-        releaseStream();
+            postPreviewSttRecording('stopped');
 
-        if (blob.size > 20 * 1024 * 1024) {
-            addSystemMsg(t('voice.tooLarge'), '', 'error');
-            return;
-        }
-        if (blob.size < 1000) {
-            addSystemMsg(t('voice.tooShort'), '', 'error');
-            return;
-        }
+            if (blob.size > 20 * 1024 * 1024) {
+                addSystemMsg(t('voice.tooLarge'), '', 'error');
+                return;
+            }
+            if (blob.size < 1000) {
+                addSystemMsg(t('voice.tooShort'), '', 'error');
+                return;
+            }
 
-        await sendVoiceToServer(blob, ext, actualMime);
-    };
+            await sendVoiceToServer(blob, ext, actualMime);
+        };
 
-    // iOS Safari: no timeslice support → call start() without args
-    mediaRecorder.start();
-    state.isRecording = true;
-    startTime = Date.now();
-    updateRecordingUI(true);
-    startTimer();
+        // iOS Safari: no timeslice support -> call start() without args
+        recorder.start();
+        state.isRecording = true;
+        startPending = false;
+        startTime = Date.now();
+        updateRecordingUI(true);
+        startTimer();
+        postPreviewSttRecording('started');
+    } catch (err) {
+        startPending = false;
+        state.isRecording = false;
+        chunks = [];
+        mediaRecorder = null;
+        releaseStream();
+        updateRecordingUI(false);
+        postPreviewSttRecording('failed');
+        addSystemMsg(classifyRecorderStartError(err), '', 'error');
+    }
 }
 
 export function stopRecording(): void {
     if (!state.isRecording || !mediaRecorder) return;
+    stopAction = 'stopped';
     if (mediaRecorder.state === 'recording') {
         mediaRecorder.stop();
+    } else {
+        releaseStream();
+        mediaRecorder = null;
+        postPreviewSttRecording('stopped');
     }
     state.isRecording = false;
     stopTimer();
@@ -125,8 +295,14 @@ export function stopRecording(): void {
 export function cancelRecording(): void {
     if (!state.isRecording || !mediaRecorder) return;
     cancelled = true;
+    stopAction = 'cancelled';
     if (mediaRecorder.state === 'recording') {
         mediaRecorder.stop();
+    } else {
+        chunks = [];
+        releaseStream();
+        mediaRecorder = null;
+        postPreviewSttRecording('cancelled');
     }
     state.isRecording = false;
     stopTimer();
@@ -135,7 +311,7 @@ export function cancelRecording(): void {
 
 export function toggleRecording(): void {
     if (state.isRecording) stopRecording();
-    else startRecording();
+    else void startRecording();
 }
 
 function releaseStream(): void {
@@ -164,10 +340,14 @@ function stopTimer(): void {
 function updateRecordingUI(recording: boolean): void {
     const btn = document.getElementById('btnVoice');
     const cancelBtn = document.getElementById('btnVoiceCancel');
+    const pending = startPending && !recording;
     if (btn) {
         btn.classList.toggle('recording', recording);
+        btn.classList.toggle('arming', pending);
         btn.innerHTML = recording ? ICONS.stop : ICONS.mic;
-        btn.title = recording ? t('voice.stop') : t('voice.start');
+        btn.title = pending ? t('voice.requesting') : recording ? t('voice.stop') : t('voice.start');
+        btn.toggleAttribute('aria-busy', pending);
+        if (btn instanceof HTMLButtonElement) btn.disabled = pending;
     }
     if (cancelBtn) {
         cancelBtn.style.display = recording ? 'inline-block' : 'none';

package/public/js/main.ts

@@ -48,7 +48,7 @@ import {
 import { toggleSkill, filterSkills, searchSkills } from './features/skills.js';
 import {
     loadSettings, handleModelSelect, applyCustomModel, onCliChange,
-    saveActiveCliSettings, savePerCli, openPromptModal,
+    onPerCliAiEProviderChange, saveActiveCliSettings, savePerCli, openPromptModal,
     onFlushCliChange, loadFlushAgentSidebar,
     closePromptModal, savePromptFromModal, syncMcpServers, installMcpGlobal,
     loadCliStatus, scheduleCliStatusRefresh, setCliStatusInterval,
@@ -88,6 +88,26 @@ import { hydrateProviderIcons } from './provider-icons.js';
 import { initPendingQueue } from './features/pending-queue.js';
 import { initAttentionBadge } from './features/attention-badge.js';
 import { initHelpDialog } from './features/help-dialog.js';
+import { initChatSearch, toggleChatSearch, closeChatSearch } from './features/chat-search.js';
+
+function isLocalPreviewOrigin(origin: string): boolean {
+    if (origin === window.location.origin) return true;
+    try {
+        const hostname = new URL(origin).hostname;
+        return hostname === 'localhost'
+            || hostname === '127.0.0.1'
+            || hostname === '::1'
+            || hostname === '[::1]';
+    } catch {
+        return false;
+    }
+}
+
+function isVoiceRecordingShortcut(e: KeyboardEvent): boolean {
+    const primarySpace = (e.ctrlKey || e.metaKey) && e.shiftKey && e.code === 'Space';
+    const fallbackMic = e.altKey && !e.ctrlKey && !e.metaKey && !e.shiftKey && e.code === 'KeyM';
+    return primarySpace || fallbackMic;
+}
 
 // ── Chat Actions ──
 document.getElementById('btnSend')?.addEventListener('click', () => { void sendMessage('button'); });
@@ -121,6 +141,14 @@ document.querySelector('.btn-attach')?.addEventListener('click', () => {
 });
 document.getElementById('btnVoice')?.addEventListener('click', () => toggleRecording());
 document.getElementById('btnVoiceCancel')?.addEventListener('click', () => cancelRecording());
+window.addEventListener('message', (event) => {
+    if (window.parent === window) return;
+    if (event.source !== window.parent) return;
+    if (!isLocalPreviewOrigin(event.origin)) return;
+    const data = event.data as { type?: unknown } | null;
+    if (!data || data.type !== 'jaw-preview-stt-toggle') return;
+    toggleRecording();
+});
 
 // ── Left Sidebar ──
 document.getElementById('memorySidebarBtn')?.addEventListener('click', openMemoryModal);
@@ -151,6 +179,7 @@ document.querySelector('.sidebar-save-bar .btn-save')?.addEventListener('click',
 
 // ── Agents Tab ──
 document.getElementById('selCli')?.addEventListener('change', () => onCliChange());
+document.getElementById('selAiEProvider')?.addEventListener('change', () => onCliChange());
 document.getElementById('selModel')?.addEventListener('change', () => saveActiveCliSettings());
 document.getElementById('selEffort')?.addEventListener('change', () => saveActiveCliSettings());
 document.getElementById('flushCli')?.addEventListener('change', () => onFlushCliChange());
@@ -300,9 +329,17 @@ function setClaude1m(on: boolean) {
 document.getElementById('claude1mOn')?.addEventListener('click', () => setClaude1m(true));
 document.getElementById('claude1mOff')?.addEventListener('click', () => setClaude1m(false));
 // Per-CLI model selects
+function toDomSuffix(cli: string): string {
+    return cli
+        .split(/[^a-zA-Z0-9]+/)
+        .filter(Boolean)
+        .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+}
+
 function bindPerCliControlEvents(): void {
     for (const cli of getCliKeys()) {
-        const cap = cli.charAt(0).toUpperCase() + cli.slice(1);
+        const cap = toDomSuffix(cli);
         const sel = document.getElementById('model' + cap) as HTMLSelectElement | null;
         if (sel) sel.addEventListener('change', function (this: HTMLSelectElement) { handleModelSelect(cli, this); });
         const custom = document.getElementById('customModel' + cap) as HTMLInputElement | null;
@@ -310,6 +347,7 @@ function bindPerCliControlEvents(): void {
         const effort = document.getElementById('effort' + cap);
         if (effort) effort.addEventListener('change', savePerCli);
     }
+    document.getElementById('providerAiE')?.addEventListener('change', onPerCliAiEProviderChange);
 }
 
 // MCP
@@ -461,6 +499,8 @@ async function bootstrap(): Promise<void> {
     await loadCliRegistry();
     bindPerCliControlEvents();
     initHelpDialog();
+    initChatSearch();
+    document.getElementById('chatSearchTrigger')?.addEventListener('click', toggleChatSearch);
     initAttentionBadge();
     connect();
     initDragDrop();
@@ -495,9 +535,23 @@ void bootstrap().catch((err: unknown) => {
     console.error('[bootstrap]', err);
 });
 
+// ── Keyboard: Ctrl+F chat search (capture phase beats Chrome's native find) ──
+document.addEventListener('keydown', (e) => {
+    if ((e.ctrlKey || e.metaKey) && e.key === 'f') {
+        e.preventDefault();
+        e.stopPropagation();
+        toggleChatSearch();
+    }
+}, true);
+
 // ── Keyboard: Escape closes modals ──────────────────
 document.addEventListener('keydown', (e) => {
     if (e.key === 'Escape') {
+        if (document.getElementById('chatSearch')?.classList.contains('open')) {
+            e.preventDefault();
+            closeChatSearch();
+            return;
+        }
         if (state.isRecording) {
             e.preventDefault();
             cancelRecording();
@@ -507,8 +561,8 @@ document.addEventListener('keydown', (e) => {
             m.classList.remove('open');
         });
     }
-    // Ctrl+Shift+Space (Win/Linux) or Cmd+Shift+Space (Mac) toggles voice recording
-    if ((e.ctrlKey || e.metaKey) && e.shiftKey && e.code === 'Space') {
+    // Ctrl+Shift+Space (Win/Linux), Cmd+Shift+Space (Mac), or Alt/Option+M toggles voice recording.
+    if (isVoiceRecordingShortcut(e)) {
         e.preventDefault();
         toggleRecording();
     }

package/public/js/provider-icons.ts

@@ -5,11 +5,15 @@
 import claudeSvg from '../assets/providers/claude-color.svg?raw';
 import openaiSvg from '../assets/providers/openai.svg?raw';
 import geminiSvg from '../assets/providers/gemini-color.svg?raw';
+import antigravitySvg from '../assets/providers/antigravity-color.svg?raw';
+import grokSvg from '../assets/providers/grok-color.svg?raw';
 import copilotSvg from '../assets/providers/copilot-color.svg?raw';
 
 // Mono variants for dark/light mode flexibility
 import claudeMonoSvg from '../assets/providers/claude.svg?raw';
 import geminiMonoSvg from '../assets/providers/gemini.svg?raw';
+import antigravityMonoSvg from '../assets/providers/antigravity.svg?raw';
+import grokMonoSvg from '../assets/providers/grok.svg?raw';
 import copilotMonoSvg from '../assets/providers/copilot.svg?raw';
 
 // Service icons (Discord, Telegram)
@@ -17,7 +21,7 @@ import discordSvg from '../assets/providers/discord.svg?raw';
 import telegramSvg from '../assets/providers/telegram.svg?raw';
 import opencodeSvg from '../assets/providers/opencode.svg?raw';
 
-export type ProviderSlug = 'claude' | 'openai' | 'gemini' | 'copilot' | 'codex' | 'opencode' | 'discord' | 'telegram';
+export type ProviderSlug = 'ai-e' | 'claude' | 'openai' | 'gemini' | 'antigravity' | 'grok' | 'copilot' | 'codex' | 'codex-app' | 'opencode' | 'discord' | 'telegram';
 
 interface ProviderIcon {
     color: string;
@@ -25,31 +29,53 @@ interface ProviderIcon {
     label: string;
 }
 
+const openaiColorSvg = openaiSvg.replace('fill="currentColor"', 'fill="#10A37F"');
+
 const PROVIDER_ICONS: Record<ProviderSlug, ProviderIcon> = {
+    'ai-e':    { color: openaiColorSvg, mono: openaiSvg, label: 'AI-E' },
     claude:   { color: claudeSvg,  mono: claudeMonoSvg,  label: 'Claude' },
-    openai:   { color: openaiSvg,  mono: openaiSvg,      label: 'OpenAI' },
+    openai:   { color: openaiColorSvg, mono: openaiSvg,  label: 'OpenAI' },
     gemini:   { color: geminiSvg,  mono: geminiMonoSvg,   label: 'Gemini' },
-    copilot:  { color: copilotSvg, mono: copilotMonoSvg,  label: 'GitHub Copilot' },
-    codex:    { color: openaiSvg,  mono: openaiSvg,      label: 'Codex (OpenAI)' },
+    antigravity: { color: antigravitySvg, mono: antigravityMonoSvg, label: 'Antigravity' },
+    grok:     { color: grokSvg,    mono: grokMonoSvg,     label: 'Grok' },
+    copilot:  { color: copilotSvg, mono: copilotMonoSvg,  label: 'Copilot' },
+    codex:    { color: openaiSvg, mono: openaiSvg,  label: 'Codex' },
+    'codex-app': { color: openaiColorSvg, mono: openaiSvg, label: 'Codex App' },
     opencode: { color: opencodeSvg, mono: opencodeSvg,   label: 'OpenCode' },
     discord:  { color: discordSvg,  mono: discordSvg,    label: 'Discord' },
     telegram: { color: telegramSvg, mono: telegramSvg,   label: 'Telegram' },
 };
 
+const PROVIDER_LABEL_ALIASES: Record<string, string> = {
+    'claude-e': 'Claude E',
+    'ai-e': 'AI-E',
+    'claude-exec': 'Claude E',
+    'jaw-claude-i': 'Claude E',
+    'claude-i': 'Claude E',
+    'agy': 'Antigravity',
+};
+
+function resolveProviderSlug(slug: string): ProviderSlug | null {
+    const normalized = slug.toLowerCase().replace(/[-_\s]/g, '');
+    if (normalized === 'aie') return 'ai-e';
+    if (normalized === 'claude' || normalized.startsWith('claude')) return 'claude';
+    if (normalized === 'gemini' || normalized.startsWith('gemini')) return 'gemini';
+    if (normalized === 'antigravity' || normalized === 'agy' || normalized === 'googleantigravity') return 'antigravity';
+    if (normalized === 'grok' || normalized.startsWith('grok')) return 'grok';
+    if (normalized.startsWith('copilot') || normalized === 'githubcopilot') return 'copilot';
+    if (normalized === 'codexapp' || normalized === 'codexappserver') return 'codex-app';
+    if (normalized === 'codex') return 'codex';
+    if (normalized === 'opencode') return 'opencode';
+    if (normalized === 'openai' || normalized.startsWith('gpt') || normalized.startsWith('o1') || normalized.startsWith('o3') || normalized.startsWith('o4')) return 'openai';
+    if (normalized === 'discord') return 'discord';
+    if (normalized === 'telegram') return 'telegram';
+    return null;
+}
+
 /** Get a provider icon SVG string. Returns color variant by default. */
 export function providerIcon(slug: string, variant: 'color' | 'mono' = 'color'): string {
-    const normalized = slug.toLowerCase().replace(/[-_\s]/g, '');
-    // Handle aliases
-    let key: ProviderSlug;
-    if (normalized === 'claude' || normalized.startsWith('claude')) key = 'claude';
-    else if (normalized === 'gemini' || normalized.startsWith('gemini')) key = 'gemini';
-    else if (normalized.startsWith('copilot') || normalized === 'githubcopilot') key = 'copilot';
-    else if (normalized === 'codex') key = 'codex';
-    else if (normalized === 'opencode') key = 'opencode';
-    else if (normalized === 'openai' || normalized.startsWith('gpt') || normalized.startsWith('o1') || normalized.startsWith('o3') || normalized.startsWith('o4')) key = 'openai';
-    else if (normalized === 'discord') key = 'discord';
-    else if (normalized === 'telegram') key = 'telegram';
-    else return '';
+    const key = resolveProviderSlug(slug);
+    if (!key) return '';
 
     const entry = PROVIDER_ICONS[key];
     return variant === 'mono' ? entry.mono : entry.color;
@@ -73,16 +99,9 @@ export function hydrateProviderIcons(root: Element = document.body): void {
 
 /** Get a provider's display label. */
 export function providerLabel(slug: string): string {
-    const normalized = slug.toLowerCase().replace(/[-_\s]/g, '');
-    let key: ProviderSlug;
-    if (normalized === 'claude' || normalized.startsWith('claude')) key = 'claude';
-    else if (normalized === 'gemini' || normalized.startsWith('gemini')) key = 'gemini';
-    else if (normalized.startsWith('copilot') || normalized === 'githubcopilot') key = 'copilot';
-    else if (normalized === 'codex') key = 'codex';
-    else if (normalized === 'opencode') key = 'opencode';
-    else if (normalized === 'openai' || normalized.startsWith('gpt') || normalized.startsWith('o1') || normalized.startsWith('o3') || normalized.startsWith('o4')) key = 'openai';
-    else if (normalized === 'discord') key = 'discord';
-    else if (normalized === 'telegram') key = 'telegram';
-    else return slug;
+    const alias = PROVIDER_LABEL_ALIASES[slug.toLowerCase()];
+    if (alias) return alias;
+    const key = resolveProviderSlug(slug);
+    if (!key) return slug;
     return PROVIDER_ICONS[key].label;
 }

package/public/js/render/markdown.ts

@@ -46,6 +46,12 @@ function ensureMarked(): boolean {
         return `<div class="code-block"><div class="code-header"><span class="code-lang">${langDisplay}</span><button class="code-copy-btn" type="button" aria-label="${escapeHtml(copyLabel)}">${escapeHtml(copyLabel)}</button></div><pre><code class="hljs${lang ? ` language-${escapeHtml(lang)}` : ''}">${highlighted}</code></pre></div>`;
     };
 
+    renderer.link = function ({ href, title, text }: { href: string; title?: string | null; text: string }) {
+        const safeHref = escapeHtml(href || '');
+        const titleAttr = title ? ` title="${escapeHtml(title)}"` : '';
+        return `<a href="${safeHref}" target="_blank" rel="noopener noreferrer"${titleAttr}>${text}</a>`;
+    };
+
     marked.setOptions({
         renderer,
         gfm: true,