@pheem49/mint 1.16.0 → 1.18.0

package/src/renderer/shared/utils/artifactBrowser.test.ts

@@ -1,61 +1,66 @@
 import { describe, expect, it, vi } from 'vitest'
 import { installRendererPlatform } from '../platform'
 import * as desktopAdapter from '../../src/tauri'
-import { openArtifactInMintBrowser } from './artifactBrowser'
+import { openArtifactInBrowser } from './artifactBrowser'
 
 const native = vi.hoisted(() => ({ invoke: vi.fn(async () => undefined) }))
 vi.mock('@tauri-apps/api/core', () => ({ invoke: native.invoke }))
 
 const url = 'http://127.0.0.1:12345/site/index.html'
-describe('opening a preview in Mint Browser', () => {
-  it('opens an existing served URL through Mint Browser on Desktop', async () => {
+describe('opening a preview in system browser', () => {
+  it('opens an existing served URL through browser on Desktop', async () => {
     const opened: string[] = []
-    await openArtifactInMintBrowser({ path: 'site/index.html', url }, '/projects/Demo', {
+    await openArtifactInBrowser({ path: 'site/index.html', url }, '/projects/Demo', {
       desktop: true,
       startPreview: async () => { throw new Error('An existing URL must be reused') },
-      openMintBrowser: async (target) => { opened.push(target) },
+      openBrowser: async (target) => { opened.push(target) },
     })
     expect(opened).toEqual([url])
   })
-  it('serves chat artifacts from their pinned project before opening Mint Browser', async () => {
+  it('serves chat artifacts from their pinned project before opening browser', async () => {
     const actions: unknown[] = []
-    await openArtifactInMintBrowser({ path: 'site/index.html', workspacePath: '/projects/Original' }, '/projects/Other', {
+    await openArtifactInBrowser({ path: 'site/index.html', workspacePath: '/projects/Original' }, '/projects/Other', {
       desktop: true,
-      startPreview: async (root, path, mint) => { actions.push([root, path, mint]); return { url, jobId: 'preview-1' } },
-      openMintBrowser: async (target) => { actions.push(target) },
+      startPreview: async (root, path) => { actions.push([root, path]); return { url, jobId: 'preview-1' } },
+      openBrowser: async (target) => { actions.push(target) },
     })
-    expect(actions).toEqual([['/projects/Original', 'site/index.html', false], url])
+    expect(actions).toEqual([['/projects/Original', 'site/index.html'], url])
   })
-  it('opens the controlled browser through the authenticated local backend on Web', async () => {
-    const requests: unknown[] = []
-    await openArtifactInMintBrowser({ path: 'site/index.html', url, workspacePath: '/projects/Demo' }, undefined, {
+  it('opens preview via system browser on Web', async () => {
+    const actions: unknown[] = []
+    await openArtifactInBrowser({ path: 'site/index.html', url, workspacePath: '/projects/Demo' }, undefined, {
       desktop: false,
-      startPreview: async (root, path, mint) => { requests.push([root, path, mint]); return { url, jobId: 'preview-1' } },
-      openMintBrowser: async () => { throw new Error('Web must not call native IPC') },
+      startPreview: async (root, path) => { actions.push([root, path]); return { url, jobId: 'preview-1' } },
+      openBrowser: async (target) => { actions.push(target) },
     })
-    expect(requests).toEqual([['/projects/Demo', 'site/index.html', true]])
+    expect(actions).toEqual([url])
   })
   it('reports browser launch failures so the button can show an error', async () => {
-    await expect(openArtifactInMintBrowser({ path: 'site/index.html', url }, undefined, {
+    await expect(openArtifactInBrowser({ path: 'site/index.html', url }, undefined, {
       desktop: true,
       startPreview: async () => { throw new Error('Unexpected server startup') },
-      openMintBrowser: async () => { throw new Error('Chrome unavailable') },
-    })).rejects.toThrow('Chrome unavailable')
+      openBrowser: async () => { throw new Error('Browser unavailable') },
+    })).rejects.toThrow('Browser unavailable')
   })
   it('does not start a server without a source project', async () => {
-    await expect(openArtifactInMintBrowser({ path: 'site/index.html' }, undefined, {
+    await expect(openArtifactInBrowser({ path: 'site/index.html' }, undefined, {
       desktop: true,
       startPreview: async () => { throw new Error('Unexpected server startup') },
-      openMintBrowser: async () => { throw new Error('Unexpected browser startup') },
+      openBrowser: async () => { throw new Error('Unexpected browser startup') },
     })).rejects.toThrow('Select a project')
   })
 })
 
-it('sends the existing open_mint_browser IPC command for the default Desktop action', async () => {
-  installRendererPlatform({ ...desktopAdapter, isTauriRuntime: () => true })
-  native.invoke.mockClear()
-  await openArtifactInMintBrowser({ path: 'site/index.html', url }, undefined)
-  expect(native.invoke).toHaveBeenCalledWith('open_mint_browser', { url })
+it('sends the open_url desktop action for the default Desktop action', async () => {
+  vi.stubGlobal('window', { __TAURI_INTERNALS__: {} })
+  try {
+    installRendererPlatform({ ...desktopAdapter, isTauriRuntime: () => true })
+    native.invoke.mockClear()
+    await openArtifactInBrowser({ path: 'site/index.html', url }, undefined)
+    expect(native.invoke).toHaveBeenCalledWith('run_desktop_action', { action: { type: 'open_url', target: url } })
+  } finally {
+    vi.unstubAllGlobals()
+  }
 })
 
 it.each([
@@ -63,18 +68,18 @@ it.each([
   ['C:\\Projects\\Demo', 'c:\\projects\\demo\\site\\index.html', 'site/index.html'],
 ])('opens absolute artifact paths relative to their source project %s', async (root, path, relative) => {
   const requests: unknown[] = []
-  await openArtifactInMintBrowser({ path, workspacePath: root }, '/projects/Other', {
+  await openArtifactInBrowser({ path, workspacePath: root }, '/projects/Other', {
     desktop: true,
-    startPreview: async (workspace, file, mint) => { requests.push([workspace, file, mint]); return { url, jobId: 'preview-1' } },
-    openMintBrowser: async () => {},
+    startPreview: async (workspace, file) => { requests.push([workspace, file]); return { url, jobId: 'preview-1' } },
+    openBrowser: async () => {},
   })
-  expect(requests).toEqual([[root, relative, false]])
+  expect(requests).toEqual([[root, relative]])
 })
 
 it('rejects an absolute artifact from a different project without starting a server', async () => {
-  await expect(openArtifactInMintBrowser({ path: '/projects/Demo-copy/index.html', workspacePath: '/projects/Demo' }, undefined, {
+  await expect(openArtifactInBrowser({ path: '/projects/Demo-copy/index.html', workspacePath: '/projects/Demo' }, undefined, {
     desktop: true,
     startPreview: async () => { throw new Error('Unexpected server startup') },
-    openMintBrowser: async () => {},
+    openBrowser: async () => {},
   })).rejects.toThrow('outside its source project')
 })

package/src/renderer/shared/utils/artifactBrowser.ts

@@ -1,30 +1,28 @@
-import type { ArtifactFile } from '../components/ArtifactPreviewPanel'
+import type { ArtifactFile } from './artifacts'
 import { runtimePlatform, workspacePlatform } from '../platform'
 
-interface BrowserApi {
-  desktop: boolean
-  startPreview(root: string, path: string, mintBrowser: boolean): Promise<{ url: string; jobId: string }>
-  openMintBrowser(url: string): Promise<void>
+export interface BrowserApi {
+  desktop?: boolean
+  startPreview?(root: string, path: string): Promise<{ url: string; jobId: string }>
+  openBrowser?(url: string): Promise<void>
 }
 
-export async function openArtifactInMintBrowser(
+export async function openArtifactInBrowser(
   artifact: ArtifactFile,
   workspace: string | undefined,
-  api: BrowserApi = {
-    desktop: runtimePlatform.isTauriRuntime(),
-    startPreview: (root, path, mint) => workspacePlatform.startHtmlPreview(root, path, mint),
-    openMintBrowser: async (url) => {
-      const { invoke } = await import('@tauri-apps/api/core')
-      await invoke('open_mint_browser', { url })
-    },
-  },
+  api: BrowserApi = {},
 ): Promise<void> {
-  if (api.desktop && artifact.url) {
-    await api.openMintBrowser(artifact.url)
+  const openBrowser = api.openBrowser ?? (async (targetUrl: string) => {
+    await runtimePlatform.openExternal(targetUrl)
+  })
+  const startPreview = api.startPreview ?? ((root: string, targetPath: string) => workspacePlatform.startHtmlPreview(root, targetPath))
+
+  if (artifact.url) {
+    await openBrowser(artifact.url)
     return
   }
   const root = (artifact.workspacePath ?? workspace)?.trim()
-  if (!root) throw new Error('Select a project before opening its preview in Mint Browser')
+  if (!root) throw new Error('Select a project before opening its preview in browser')
   let path = artifact.path.replace(/\\/g, '/')
   if (/^(\/|[a-z]:\/)/i.test(path)) {
     const normalizedRoot = root.replace(/\\/g, '/').replace(/\/+$/, '')
@@ -35,7 +33,7 @@ export async function openArtifactInMintBrowser(
     }
     path = path.slice(prefix.length)
   }
-  // The authenticated local Web endpoint launches the same automation browser on the backend.
-  const preview = await api.startPreview(root, path, !api.desktop)
-  if (api.desktop) await api.openMintBrowser(preview.url)
+  const preview = await startPreview(root, path)
+  await openBrowser(preview.url)
 }
+

package/src/renderer/shared/utils/artifacts.ts

@@ -0,0 +1,55 @@
+export type ArtifactType =
+  | 'html'
+  | 'svg'
+  | 'markdown'
+  | 'image'
+  | 'code'
+  | 'file'
+  | 'pdf'
+  | 'audio'
+  | 'video'
+
+export type ViewportMode = 'desktop' | 'tablet' | 'mobile'
+
+export interface ArtifactFile {
+  path: string
+  workspacePath?: string
+  url?: string
+  content?: string
+  type?: ArtifactType
+  mimeType?: string
+  byteLength?: number
+  objectUrl?: boolean
+  range?: boolean
+}
+
+export function detectArtifactType(filePath: string): ArtifactType {
+  const lower = filePath.toLowerCase()
+  if (lower.endsWith('.html') || lower.endsWith('.htm')) return 'html'
+  if (/\.(png|jpe?g|gif|webp|ico)$/.test(lower)) return 'image'
+  if (lower.endsWith('.svg')) return 'svg'
+  if (lower.endsWith('.md') || lower.endsWith('.markdown')) return 'markdown'
+  if (lower.endsWith('.pdf')) return 'pdf'
+  if (/\.(mp3|wav|ogg|oga|opus|flac|m4a|aac|weba)$/.test(lower)) return 'audio'
+  if (/\.(mp4|m4v|webm|ogv|mov)$/.test(lower)) return 'video'
+  return 'code'
+}
+
+export function getFileLanguage(filePath: string): string {
+  const ext = filePath.split('.').pop()?.toLowerCase() || ''
+  const map: Record<string, string> = {
+    js: 'javascript',
+    jsx: 'javascript',
+    ts: 'typescript',
+    tsx: 'typescript',
+    html: 'html',
+    htm: 'html',
+    css: 'css',
+    json: 'json',
+    rs: 'rust',
+    py: 'python',
+    svg: 'xml',
+    md: 'markdown',
+  }
+  return map[ext] || ext || 'plaintext'
+}

package/src/renderer/shared/utils/attachedDocument.test.ts

@@ -0,0 +1,73 @@
+/// <reference path="../../env.d.ts" />
+import { describe, it, expect } from 'vitest'
+import { parseAttachedDocument } from './attachedDocument'
+
+describe('parseAttachedDocument', () => {
+  it('returns raw text unchanged when no document attachment pattern is present', () => {
+    const raw = 'สวัสดีครับ ช่วยดูโค้ดนี้หน่อย'
+    const res = parseAttachedDocument(raw)
+    expect(res.userText).toBe(raw)
+    expect(res.attachedDocument).toBeUndefined()
+  })
+
+  it('handles null, undefined, and empty string', () => {
+    expect(parseAttachedDocument(null).userText).toBe('')
+    expect(parseAttachedDocument(undefined).userText).toBe('')
+    expect(parseAttachedDocument('').userText).toBe('')
+  })
+
+  it('parses user text and attached document payload accurately', () => {
+    const raw = `@generate_harness_pdf.py ขอปรับหน่อยอะ ไฟล์ที่ลากมาวา
+
+Attached document: LICENSE.electron.txt
+Use the extracted document text below when answering. If the user asks for a summary, summarize this document.
+
+--- Extracted document text ---
+Copyright (c) Electron contributors
+Copyright (c) 2013-2020 GitHub Inc.
+
+Permission is hereby granted, free of charge.
+--- End extracted document text ---`
+
+    const res = parseAttachedDocument(raw)
+    expect(res.userText).toBe('@generate_harness_pdf.py ขอปรับหน่อยอะ ไฟล์ที่ลากมาวา')
+    expect(res.attachedDocument).toBeDefined()
+    expect(res.attachedDocument?.filename).toBe('LICENSE.electron.txt')
+    expect(res.attachedDocument?.lineCount).toBe(4)
+    expect(res.attachedDocument?.content).toContain('Copyright (c) Electron contributors')
+    expect(res.attachedDocument?.content).toContain('Permission is hereby granted, free of charge.')
+  })
+
+  it('handles when the user sent only an attachment without typing any message', () => {
+    const raw = `Attached document: notes.md
+Use the extracted document text below when answering. If the user asks for a summary, summarize this document.
+
+--- Extracted document text ---
+# Notes
+Here are the notes.
+--- End extracted document text ---`
+
+    const res = parseAttachedDocument(raw)
+    expect(res.userText).toBe('')
+    expect(res.attachedDocument?.filename).toBe('notes.md')
+    expect(res.attachedDocument?.lineCount).toBe(2)
+  })
+
+  it('handles truncated document notice properly', () => {
+    const raw = `Check this file
+
+Attached document: large.json
+Use the extracted document text below when answering. If the user asks for a summary, summarize this document.
+
+--- Extracted document text ---
+{"key": "val"}
+
+[Document text truncated because it is long.]
+--- End extracted document text ---`
+
+    const res = parseAttachedDocument(raw)
+    expect(res.userText).toBe('Check this file')
+    expect(res.attachedDocument?.filename).toBe('large.json')
+    expect(res.attachedDocument?.content).toContain('[Document text truncated because it is long.]')
+  })
+})

package/src/renderer/shared/utils/attachedDocument.ts

@@ -0,0 +1,49 @@
+/**
+ * shared/utils/attachedDocument.ts
+ *
+ * Parses document attachment text and boilerplate injected into `interaction.userText`
+ * by the backend (`with_document_text`), allowing the chat interface to separate
+ * authentic user prompt text from the attached file contents.
+ */
+
+export interface AttachedDocumentPayload {
+  filename: string
+  content: string
+  lineCount: number
+  charCount: number
+}
+
+export interface ParsedUserMessage {
+  userText: string
+  attachedDocument?: AttachedDocumentPayload
+}
+
+const ATTACHED_DOC_REGEX =
+  /(?:^|\n\n)Attached document: ([^\n]+)\nUse the extracted document text below when answering[^\n]*\n\n--- Extracted document text ---\n([\s\S]*?)\n--- End extracted document text ---$/
+
+export function parseAttachedDocument(rawText: string | null | undefined): ParsedUserMessage {
+  if (!rawText || typeof rawText !== 'string') {
+    return { userText: '' }
+  }
+
+  const match = rawText.match(ATTACHED_DOC_REGEX)
+  if (!match || match.index === undefined) {
+    return { userText: rawText }
+  }
+
+  const userText = rawText.slice(0, match.index).trim()
+  const filename = match[1].trim()
+  const content = match[2]
+  const lineCount = content ? content.split('\n').length : 0
+  const charCount = content ? content.length : 0
+
+  return {
+    userText,
+    attachedDocument: {
+      filename,
+      content,
+      lineCount,
+      charCount,
+    },
+  }
+}

package/src/renderer/shared/utils/contextCompaction.test.tsx

@@ -2,7 +2,7 @@ import React from 'react'
 import { renderToStaticMarkup } from 'react-dom/server'
 import { describe, expect, it } from 'vitest'
 import { activeCompactionFrom } from './contextCompaction'
-import { ContextCompactionStatus } from '../components/ContextCompactionStatus'
+import { ContextCompactionStatus } from '../components/chat/ContextCompactionStatus'
 import { activitiesFrom } from './agentActivity'
 import type { AgentProgress } from '../types'
 

package/src/renderer/shared/utils/externalLinks.ts

@@ -0,0 +1,91 @@
+/**
+ * Shared utility for detecting and intercepting external link navigation.
+ */
+
+/**
+ * Determines whether a given href/origin represents an external destination.
+ */
+export function isExternalHref(href: string | null | undefined, anchorOrigin?: string): boolean {
+  if (!href) return false
+  const trimmed = href.trim()
+  if (trimmed.startsWith('//') || /^(https?:)?\/\//i.test(trimmed)) {
+    return true
+  }
+
+  if (
+    trimmed.startsWith('#') ||
+    trimmed.startsWith('/') ||
+    trimmed.startsWith('./') ||
+    trimmed.startsWith('../') ||
+    trimmed.startsWith('javascript:') ||
+    trimmed.startsWith('data:') ||
+    trimmed.startsWith('blob:')
+  ) {
+    return false
+  }
+
+  if (typeof window !== 'undefined' && anchorOrigin && window.location?.origin) {
+    return anchorOrigin !== window.location.origin
+  }
+
+  return false
+}
+
+export type OpenExternalFn = (url: string) => Promise<any>
+
+/**
+ * Factory that creates a link click interceptor function for a given `openExternal` handler.
+ */
+export function createExternalLinkInterceptor(openExternal: OpenExternalFn) {
+  return function installExternalLinkInterceptor(
+    targetDocument: Document | null = typeof document !== 'undefined' ? document : null
+  ): () => void {
+    if (!targetDocument) return () => {}
+
+    const handleClick = (event: MouseEvent) => {
+      // Only handle primary click (left) or auxiliary click (middle)
+      if (event.defaultPrevented || (event.button !== 0 && event.button !== 1)) {
+        return
+      }
+
+      const target = event.target as HTMLElement | null
+      if (!target || typeof target.closest !== 'function') return
+
+      const anchor = target.closest('a') as HTMLAnchorElement | null
+      if (!anchor || anchor.hasAttribute('download')) return
+
+      const rawHref = anchor.getAttribute('href') || ''
+      let anchorOrigin = ''
+      try {
+        anchorOrigin = anchor.origin || ''
+      } catch {
+        anchorOrigin = ''
+      }
+
+      const isExternal = isExternalHref(rawHref, anchorOrigin)
+      const isBlank = anchor.target === '_blank'
+
+      // Only intercept if classified as external, or marked with target="_blank" without being relative/hash/javascript
+      if (!isExternal && (!isBlank || rawHref.startsWith('/') || rawHref.startsWith('#') || rawHref.startsWith('javascript:') || rawHref.startsWith('./') || rawHref.startsWith('../'))) {
+        return
+      }
+
+      let resolvedUrl = ''
+      try {
+        resolvedUrl = anchor.href || rawHref
+      } catch {
+        resolvedUrl = rawHref
+      }
+
+      event.preventDefault()
+      openExternal(resolvedUrl).catch((err) => {
+        console.error('Failed to open external link:', err)
+      })
+    }
+
+    targetDocument.addEventListener('click', handleClick, true)
+    return () => {
+      targetDocument.removeEventListener('click', handleClick, true)
+    }
+  }
+}

package/src/renderer/shared/utils/fileIcons.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from 'vitest'
+import {
+  getExtension,
+  materialFileIcon,
+  materialFolderIcon,
+  documentIcon,
+  folderIcon,
+  folderOpenIcon,
+  FILE_ICONS_BY_EXTENSION,
+  FILE_ICONS_BY_NAME,
+} from './fileIcons'
+
+describe('fileIcons utility', () => {
+  it('correctly extracts extensions case-insensitively', () => {
+    expect(getExtension('main.py')).toBe('py')
+    expect(getExtension('foo.BAR.TSX')).toBe('tsx')
+    expect(getExtension('Dockerfile')).toBe('')
+    expect(getExtension('.gitignore')).toBe('gitignore')
+  })
+
+  it('maps python files (.py, .pyw, .ipynb) to Python/Jupyter icons', () => {
+    const pyIcon = materialFileIcon('script.py', 'py')
+    expect(pyIcon).toBeDefined()
+    expect(pyIcon).not.toBe(documentIcon)
+    expect(pyIcon).toBe(FILE_ICONS_BY_EXTENSION['py'])
+
+    const ipynbIcon = materialFileIcon('analysis.ipynb', 'ipynb')
+    expect(ipynbIcon).toBe(FILE_ICONS_BY_EXTENSION['ipynb'])
+  })
+
+  it('maps major programming languages to their dedicated icons', () => {
+    expect(materialFileIcon('main.rs', 'rs')).toBe(FILE_ICONS_BY_EXTENSION['rs'])
+    expect(materialFileIcon('main.go', 'go')).toBe(FILE_ICONS_BY_EXTENSION['go'])
+    expect(materialFileIcon('Main.java', 'java')).toBe(FILE_ICONS_BY_EXTENSION['java'])
+    expect(materialFileIcon('app.c', 'c')).toBe(FILE_ICONS_BY_EXTENSION['c'])
+    expect(materialFileIcon('app.cpp', 'cpp')).toBe(FILE_ICONS_BY_EXTENSION['cpp'])
+    expect(materialFileIcon('App.cs', 'cs')).toBe(FILE_ICONS_BY_EXTENSION['cs'])
+    expect(materialFileIcon('script.sh', 'sh')).toBe(FILE_ICONS_BY_EXTENSION['sh'])
+    expect(materialFileIcon('query.sql', 'sql')).toBe(FILE_ICONS_BY_EXTENSION['sql'])
+    expect(materialFileIcon('doc.pdf', 'pdf')).toBe(FILE_ICONS_BY_EXTENSION['pdf'])
+  })
+
+  it('maps special file names by exact or lowercased name', () => {
+    expect(materialFileIcon('Dockerfile', '')).toBe(FILE_ICONS_BY_NAME['dockerfile'])
+    expect(materialFileIcon('.gitignore', 'gitignore')).toBe(FILE_ICONS_BY_NAME['.gitignore'])
+    expect(materialFileIcon('package.json', 'json')).toBe(FILE_ICONS_BY_NAME['package.json'])
+  })
+
+  it('falls back to documentIcon for unrecognized extensions', () => {
+    expect(materialFileIcon('mystery.unrecognizedext123', 'unrecognizedext123')).toBe(documentIcon)
+  })
+
+  it('returns appropriate folder icons', () => {
+    expect(materialFolderIcon('unknown_folder', false)).toBe(folderIcon)
+    expect(materialFolderIcon('unknown_folder', true)).toBe(folderOpenIcon)
+    expect(materialFolderIcon('src', false)).not.toBe(folderIcon)
+    expect(materialFolderIcon('src', true)).not.toBe(folderOpenIcon)
+  })
+})