const { app, BrowserWindow, ipcMain, shell, dialog, Menu, nativeImage, Tray, globalShortcut, Notification } = require('electron')
const { join } = require('path')
const { exec, spawn } = require('child_process')
const fs = require('fs')
const path = require('path')
const os = require('os')
const { autoUpdater } = require('electron-updater')
const { TerminalManager } = require('./terminalManager.cjs')
const { createLocalShellRuntime, resolveShellProtocol } = require('./localShell.cjs')
const promptImageResizer = require('./promptImageResizer.cjs')
const serverConfigLib = require('./serverConfig.cjs')
const { resolveShellMaoBaseUrl } = require('./shellEnv.cjs')
const chatAttachment = require('./chatAttachment.cjs')
const desktopPrefsLib = require('./desktopPrefs.cjs')
const { createTray } = require('./tray.cjs')
const { readFileBytes } = require('./localFileBytes.cjs')


app.setName('Mao')
// Windows 系统通知的前提：appUserModelId 必须与 electron-builder 的 appId 一致（package.json）。
// 收件箱的 Electron 系统通知（P2）依赖它才能正常弹出并被任务栏正确归组。
app.setAppUserModelId('cn.etarch.mao.desktop')

// 单实例锁（P2 前置）：托盘常驻 / 开机自启 / dock 复活都要求同一时刻只有一个进程，
// 否则多实例会争用 auth.json 等 userData 资源。第二个实例启动后唤起主窗再退出。
if (!app.requestSingleInstanceLock()) {
  app.quit()
} else {
  app.on('second-instance', () => {
    // app ready 前禁止创建 BrowserWindow（真实 Electron 会抛未捕获异常）：未就绪时直接返回，
    // whenReady 链会把主窗建出来，不会漏掉「唤起」语义
    if (!app.isReady()) return
    const win = mainWindow && !mainWindow.isDestroyed() ? mainWindow : createWindow()
    if (!win || win.isDestroyed()) return
    if (win.isMinimized()) win.restore()
    win.show()
    win.focus()
  })
}

let mainWindow = null
/** 系统托盘实例（P2；app ready 后创建，退出时随进程销毁） */
let appTray = null
/** before-quit 已触发：close 事件不再拦截为隐藏，保证退出路径全量清理 */
let quitting = false
/** 当前已注册的全局快捷键（换键时精确注销旧键；app 退出时随进程销毁） */
let currentShortcutAccel = null
let currentWorkspace = ''
/** @type {Map<string, (approved: boolean) => void>} */
const pendingApprovals = new Map()
/**
 * 多端审批（技术方案 2026-11-06）：决策可能早于本地弹卡到达（手机先点 / 本机还没走到
 * requestToolApproval）。命中即直接放行、不再弹一张只能撤掉的卡。
 * TTL / 上限只为兜住无人认领的迟到决策。
 */
const EARLY_APPROVAL_TTL_MS = 10 * 60 * 1000
const EARLY_APPROVAL_LIMIT = 100
/** @type {Map<string, { approved: boolean, at: number }>} */
const earlyApprovalDecisions = new Map()
/**
 * 待派发的通知点击深链：点击时刻渲染层监听可能尚未注册（应用刚启动、
 * 页面加载中、窗口重建），立即 send 会丢。这里总是留一份，由渲染层桥接
 * 就绪后主动拉取（consume），收到后回执（ack）清除，防止页面重载后
 * 拿陈旧点击重复跳转。did-finish-load 补发仅在「尚未被拉取」时执行。
 */
let pendingNotificationClick = null
const terminalManager = new TerminalManager()
terminalManager.setEnvProvider(buildShellEnv)

const PRIVATE_DIFF_FIELD = 'file_change_diff'
const SNAPSHOT_LIMIT_BYTES = 512 * 1024
const PATCH_LIMIT_CHARS = 256 * 1024
const PATCH_CONTEXT_LINES = 3
const LCS_CELL_LIMIT = 2_000_000

let updaterInitialized = false
let updateDownloaded = false
let updateCheckPromise = null
let updaterStatus = 'idle'
let updaterProgressPercent = null

function utf8Bytes(text) {
  return Buffer.byteLength(text || '', 'utf-8')
}

function isBinaryContent(text) {
  const value = text || ''
  const checkLen = Math.min(value.length, 8192)
  for (let i = 0; i < checkLen; i++) {
    if (value.charCodeAt(i) === 0) return true
  }
  return false
}

function splitLines(text) {
  if (!text) return []
  return text.split(/\r\n|\r|\n/)
}

function lcsLength(oldLines, oldStart, oldEnd, newLines, newStart, newEnd) {
  const newLen = newEnd - newStart + 1
  let previous = new Array(newLen + 1).fill(0)
  let current = new Array(newLen + 1).fill(0)

  for (let i = oldStart; i <= oldEnd; i++) {
    for (let j = 1; j <= newLen; j++) {
      if (oldLines[i] === newLines[newStart + j - 1]) {
        current[j] = previous[j - 1] + 1
      } else {
        current[j] = Math.max(previous[j], current[j - 1])
      }
    }
    const temp = previous
    previous = current
    current = temp
    current.fill(0)
  }
  return previous[newLen]
}

function computeLineDelta(beforeContent, afterContent) {
  const oldLines = splitLines(beforeContent)
  const newLines = splitLines(afterContent)
  if (oldLines.length === 0) return { linesAdded: newLines.length, linesDeleted: 0 }
  if (newLines.length === 0) return { linesAdded: 0, linesDeleted: oldLines.length }

  let prefix = 0
  while (prefix < oldLines.length && prefix < newLines.length && oldLines[prefix] === newLines[prefix]) {
    prefix++
  }

  let oldSuffix = oldLines.length - 1
  let newSuffix = newLines.length - 1
  while (oldSuffix >= prefix && newSuffix >= prefix && oldLines[oldSuffix] === newLines[newSuffix]) {
    oldSuffix--
    newSuffix--
  }

  const oldChanged = oldSuffix - prefix + 1
  const newChanged = newSuffix - prefix + 1
  if (oldChanged <= 0) return { linesAdded: Math.max(0, newChanged), linesDeleted: 0 }
  if (newChanged <= 0) return { linesAdded: 0, linesDeleted: Math.max(0, oldChanged) }

  if (oldChanged * newChanged > LCS_CELL_LIMIT) {
    return { linesAdded: newChanged, linesDeleted: oldChanged }
  }

  const lcs = lcsLength(oldLines, prefix, oldSuffix, newLines, prefix, newSuffix)
  return { linesAdded: newChanged - lcs, linesDeleted: oldChanged - lcs }
}

function appendBounded(parts, state, text) {
  if (state.length >= PATCH_LIMIT_CHARS) {
    state.truncated = true
    return
  }
  const remaining = PATCH_LIMIT_CHARS - state.length
  if (text.length <= remaining) {
    parts.push(text)
    state.length += text.length
  } else {
    parts.push(text.slice(0, remaining))
    state.length += remaining
    state.truncated = true
  }
}

function buildUnifiedPatch(filePath, before, after) {
  const oldLines = splitLines(before)
  const newLines = splitLines(after)
  let prefix = 0
  while (prefix < oldLines.length && prefix < newLines.length && oldLines[prefix] === newLines[prefix]) {
    prefix++
  }

  let oldSuffix = oldLines.length - 1
  let newSuffix = newLines.length - 1
  while (oldSuffix >= prefix && newSuffix >= prefix && oldLines[oldSuffix] === newLines[newSuffix]) {
    oldSuffix--
    newSuffix--
  }

  const contextStart = Math.max(0, prefix - PATCH_CONTEXT_LINES)
  const oldContextEnd = Math.min(oldLines.length - 1, oldSuffix + PATCH_CONTEXT_LINES)
  const newContextEnd = Math.min(newLines.length - 1, newSuffix + PATCH_CONTEXT_LINES)
  const oldStartLine = contextStart + 1
  const newStartLine = contextStart + 1
  const oldCount = Math.max(0, oldContextEnd - contextStart + 1)
  const newCount = Math.max(0, newContextEnd - contextStart + 1)

  const parts = []
  const state = { length: 0, truncated: false }
  appendBounded(parts, state, `--- a/${filePath}\n`)
  appendBounded(parts, state, `+++ b/${filePath}\n`)
  appendBounded(parts, state, `@@ -${oldStartLine},${oldCount} +${newStartLine},${newCount} @@\n`)
  for (let i = contextStart; i < prefix && i < oldLines.length; i++) {
    appendBounded(parts, state, ` ${oldLines[i]}\n`)
  }
  for (let i = prefix; i <= oldSuffix && i < oldLines.length; i++) {
    appendBounded(parts, state, `-${oldLines[i]}\n`)
  }
  for (let i = prefix; i <= newSuffix && i < newLines.length; i++) {
    appendBounded(parts, state, `+${newLines[i]}\n`)
  }
  const sharedTailStart = Math.max(prefix, Math.max(oldSuffix + 1, newSuffix + 1))
  const sharedTailEnd = Math.min(oldContextEnd, oldLines.length - 1)
  for (let i = sharedTailStart; i <= sharedTailEnd; i++) {
    appendBounded(parts, state, ` ${oldLines[i]}\n`)
  }
  let content = parts.join('')
  if (state.truncated) {
    const suffix = '\n...[diff truncated]\n'
    content = content.slice(0, Math.max(0, PATCH_LIMIT_CHARS - suffix.length)) + suffix
  }
  return { content, truncated: state.truncated }
}

function buildFileChangeDiff(filePath, beforeContent, afterContent) {
  const before = beforeContent || ''
  const after = afterContent || ''
  if (isBinaryContent(before) || isBinaryContent(after)) {
    return {
      diff_mode: 'UNSUPPORTED',
      diff_unavailable_reason: '二进制文件无法生成文本 diff',
      patch_truncated: false
    }
  }
  if (utf8Bytes(before) <= SNAPSHOT_LIMIT_BYTES && utf8Bytes(after) <= SNAPSHOT_LIMIT_BYTES) {
    return {
      diff_mode: 'SNAPSHOT',
      before_content: before,
      after_content: after,
      patch_truncated: false
    }
  }
  const patch = buildUnifiedPatch(filePath, before, after)
  return {
    diff_mode: 'PATCH',
    patch_content: patch.content,
    patch_truncated: patch.truncated
  }
}

function asBoolArg(value, fallback = false) {
  if (typeof value === 'boolean') return value
  if (typeof value === 'number' && Number.isFinite(value)) return value !== 0
  if (typeof value === 'string') {
    const s = value.trim().toLowerCase()
    if (s === 'true' || s === '1' || s === 'yes') return true
    if (s === 'false' || s === '0' || s === 'no' || s === '') return false
  }
  return fallback
}

function lineAtIndex(content, index) {
  let lineNumber = 1
  let lineStart = 0
  for (let i = 0; i < index; i++) {
    if (content[i] === '\n') {
      lineNumber++
      lineStart = i + 1
    }
  }
  let lineEnd = content.indexOf('\n', index)
  if (lineEnd === -1) lineEnd = content.length
  let lineText = content.slice(lineStart, lineEnd)
  if (lineText.endsWith('\r')) lineText = lineText.slice(0, -1)
  return { lineNumber, lineText }
}

function applyEditMatch(content, oldString, newString, replaceAll) {
  if (oldString === '') {
    return { ok: false, replacements: 0, error: 'old_string 不能为空' }
  }
  const starts = []
  let idx = 0
  while (idx < content.length) {
    const found = content.indexOf(oldString, idx)
    if (found === -1) break
    starts.push(found)
    idx = found + oldString.length
  }
  const count = starts.length
  if (count === 0) {
    return { ok: false, replacements: 0, error: '文件中未找到 old_string' }
  }
  if (count > 1 && !replaceAll) {
    const maxLines = 20
    const maxPreviews = 8
    const occurrenceLines = starts.slice(0, maxLines).map((start) => lineAtIndex(content, start).lineNumber)
    const previewCount = Math.min(maxPreviews, starts.length)
    const previews = []
    for (let i = 0; i < previewCount; i++) {
      const { lineNumber, lineText } = lineAtIndex(content, starts[i])
      const preview = lineText.length > 120 ? lineText.slice(0, 120) + '…' : lineText
      previews.push(`  第 ${lineNumber} 行: ${preview}`)
    }
    const listed = count > maxLines ? `（仅列出前 ${maxLines} 处）` : ''
    return {
      ok: false,
      replacements: 0,
      occurrences: count,
      occurrence_lines: occurrenceLines,
      error: `old_string 在文件中出现 ${count} 次，默认只替换唯一匹配，未执行编辑。`
        + '请在 old_string 中补充更多上下文使其只出现一次，或传入 replace_all=true 以替换全部出现。'
        + `出现位置（行号从 1 起）${listed}：\n`
        + previews.join('\n')
    }
  }
  return {
    ok: true,
    updated: content.split(oldString).join(newString),
    replacements: count
  }
}

function writeEditedFile(resolvedPath, filePathArg, oldString, newString, replaceAll) {
  const content = fs.readFileSync(resolvedPath, 'utf-8')
  const match = applyEditMatch(content, oldString ?? '', newString ?? '', replaceAll)
  if (!match.ok) {
    const out = { success: false, replacements: 0, error: match.error }
    if (match.occurrences != null) {
      out.occurrences = match.occurrences
      out.occurrence_lines = match.occurrence_lines
    }
    return out
  }
  fs.writeFileSync(resolvedPath, match.updated, 'utf-8')
  const lineDelta = computeLineDelta(content, match.updated)
  return {
    success: true,
    replacements: match.replacements,
    file_change: {
      path: filePathArg,
      type: 'MODIFIED',
      lines_added: lineDelta.linesAdded,
      lines_deleted: lineDelta.linesDeleted
    },
    [PRIVATE_DIFF_FIELD]: buildFileChangeDiff(filePathArg, content, match.updated)
  }
}

/**
 * Get the full user PATH by executing a login shell.
 * macOS GUI apps don't load shell configs, so we need to manually resolve the PATH
 * that includes all user-configured tools (nvm, brew, cargo, etc.)
 */
let cachedUserPath = null
async function resolveUserPath() {
  if (cachedUserPath) return cachedUserPath

  const shell = process.env.SHELL || '/bin/zsh'
  console.log('[env] Resolving user PATH, SHELL:', process.env.SHELL, 'Using shell:', shell)
  console.log('[env] Current PATH:', process.env.PATH)

  return new Promise((resolve) => {
    // Use login shell to get full user environment
    const cmd = `${shell} -l -c 'echo $PATH'`
    console.log('[env] Executing:', cmd)

    exec(cmd, {
      timeout: 10000,
      env: { ...process.env, TERM: 'dumb' } // Ensure basic env
    }, (error, stdout, stderr) => {
      if (error) {
        console.error('[env] Failed to resolve user PATH via login shell:', error.message)
        if (stderr) console.error('[env] stderr:', stderr)
        resolve(process.env.PATH)
      } else {
        const userPath = stdout.trim()
        if (userPath && userPath !== process.env.PATH) {
          cachedUserPath = userPath
          console.log('[env] Resolved user PATH via login shell:', userPath.substring(0, 100) + '...')
          resolve(userPath)
        } else {
          console.log('[env] Login shell PATH same as current, using current PATH')
          resolve(process.env.PATH)
        }
      }
    })
  })
}

/**
 * Build environment with user's full PATH and current MAO_TOKEN from local auth store.
 * 同时注入 MAO_BASE_URL（当前连接的服务器），shell 里的 mao / mao-agent 不再依赖内置默认地址。
 */
async function buildShellEnv() {
  const userPath = await resolveUserPath()
  const { token } = readAuthStore()
  const env = {
    ...process.env,
    PATH: userPath,
    TERM: 'dumb',
    PS1: ''
  }
  if (token) {
    env.MAO_TOKEN = token
  } else {
    delete env.MAO_TOKEN
  }
  const maoBaseUrl = resolveShellMaoBaseUrl({
    configured: isServerConfigured(),
    serverBaseUrl: getEffectiveServerBaseUrl()
  })
  if (maoBaseUrl) {
    env.MAO_BASE_URL = maoBaseUrl
  } else {
    delete env.MAO_BASE_URL
  }
  return env
}

/**
 * 持久 shell 会话的 env 在 spawn 后不会自动更新；每次执行命令前重新写入。
 * bash 用 export，PowerShell 用 $env:。
 */
function refreshMaoTokenInShellSession(session) {
  if (!session?.writeStdin) return
  const protocol = resolveShellProtocol()
  const { token } = readAuthStore()
  if (token) {
    session.writeStdin(protocol.envSet('MAO_TOKEN', token) + '\n')
  } else {
    session.writeStdin(protocol.envUnset('MAO_TOKEN') + '\n')
  }
  const maoBaseUrl = resolveShellMaoBaseUrl({
    configured: isServerConfigured(),
    serverBaseUrl: getEffectiveServerBaseUrl()
  })
  if (maoBaseUrl) {
    session.writeStdin(protocol.envSet('MAO_BASE_URL', maoBaseUrl) + '\n')
  } else {
    session.writeStdin(protocol.envUnset('MAO_BASE_URL') + '\n')
  }
}

function sendToRenderer(channel, data) {
  if (mainWindow && !mainWindow.isDestroyed()) {
    mainWindow.webContents.send(channel, data)
  }
}

function setUpdaterStatus(status, progressPercent = updaterProgressPercent) {
  updaterStatus = status
  updaterProgressPercent = progressPercent
  buildApplicationMenu()
}

function installDownloadedUpdate() {
  if (!updateDownloaded) {
    return { success: false, error: 'Update has not been downloaded yet.' }
  }
  // macOS 的 quitAndInstall 先关窗、后发 before-quit。默认「关窗收托盘」会在
  // quitting 仍为 false 时把 close 变成 hide，退出被取消，安装不会开始。
  quitting = true
  autoUpdater.quitAndInstall(false, true)
  return { success: true }
}

function showUpdateMessage(type, title, message, buttons = ['确定']) {
  const options = {
    type,
    title,
    message,
    buttons,
    defaultId: 0,
    cancelId: buttons.length - 1
  }
  if (mainWindow && !mainWindow.isDestroyed()) {
    return dialog.showMessageBox(mainWindow, options)
  }
  return dialog.showMessageBox(options)
}

async function showMenuUpdateCheckResult() {
  if (updateDownloaded) {
    const { response } = await showUpdateMessage(
      'info',
      '更新已就绪',
      '客户端新版本已下载完成，可以重启 Mao 完成安装。',
      ['重启完成更新', '稍后']
    )
    if (response === 0) installDownloadedUpdate()
    return
  }

  if (updaterStatus === 'available' || updaterStatus === 'downloading') {
    const progressLabel = updaterProgressPercent == null ? '' : `（${Math.round(updaterProgressPercent)}%）`
    await showUpdateMessage('info', '正在下载新版本', `已发现客户端新版本，正在后台下载${progressLabel}。`)
    return
  }

  if (updaterStatus === 'not-available') {
    await showUpdateMessage('info', '已是最新版本', `当前 Mao ${app.getVersion()} 已是最新版本。`)
    return
  }

  if (updaterStatus === 'unsupported') {
    await showUpdateMessage('warning', '无法检查更新', '自动更新仅在打包后的客户端中可用。')
  }
}

async function checkForAppUpdateFromMenu() {
  try {
    await checkForAppUpdate()
    await showMenuUpdateCheckResult()
  } catch (error) {
    const message = error?.message || '检查更新失败'
    console.error('[updater] menu check failed:', error)
    await showUpdateMessage('error', '检查更新失败', message)
  }
}

function buildUpdateMenuItem() {
  const isDownloading = updaterStatus === 'available' || updaterStatus === 'downloading'
  const progressLabel = updaterProgressPercent == null ? '' : ` ${Math.round(updaterProgressPercent)}%`

  if (updateDownloaded) {
    return {
      label: '重启完成更新',
      enabled: true,
      click: () => {
        installDownloadedUpdate()
      }
    }
  } else if (isDownloading) {
    return {
      label: `正在下载新版本${progressLabel}`,
      enabled: false
    }
  }

  return {
    label: updaterStatus === 'checking' ? '正在检查更新' : '检查更新',
    enabled: app.isPackaged && !updateCheckPromise,
    click: () => {
      checkForAppUpdateFromMenu()
    }
  }
}

function buildServerMenuItem() {
  return {
    label: '服务器设置…',
    click: () => openServerPickerWindow(),
  }
}

function buildApplicationMenu() {
  if (!app.isReady()) return

  const template = []

  if (process.platform === 'darwin') {
    template.push({
      label: 'Mao',
      submenu: [
        { role: 'about', label: '关于 Mao' },
        { type: 'separator' },
        buildServerMenuItem(),
        { type: 'separator' },
        buildUpdateMenuItem(),
        { type: 'separator' },
        { role: 'services', label: '服务' },
        { type: 'separator' },
        { role: 'hide', label: '隐藏 Mao' },
        { role: 'hideOthers', label: '隐藏其他' },
        { role: 'unhide', label: '全部显示' },
        { type: 'separator' },
        { role: 'quit', label: '退出 Mao' }
      ]
    })
  } else {
    template.push({
      label: 'Mao',
      submenu: [
        buildServerMenuItem(),
        { type: 'separator' },
        buildUpdateMenuItem(),
        { type: 'separator' },
        { role: 'quit', label: '退出 Mao' }
      ]
    })
  }

  template.push(
    {
      label: '编辑',
      submenu: [
        { role: 'undo', label: '撤销' },
        { role: 'redo', label: '重做' },
        { type: 'separator' },
        { role: 'cut', label: '剪切' },
        { role: 'copy', label: '复制' },
        { role: 'paste', label: '粘贴' },
        { role: 'selectAll', label: '全选' }
      ]
    },
    {
      label: '显示',
      submenu: [
        { role: 'reload', label: '重新加载' },
        { role: 'forceReload', label: '强制重新加载' },
        { role: 'toggleDevTools', label: '开发者工具' },
        { type: 'separator' },
        { role: 'resetZoom', label: '实际大小' },
        { role: 'zoomIn', label: '放大' },
        { role: 'zoomOut', label: '缩小' },
        { type: 'separator' },
        { role: 'togglefullscreen', label: '切换全屏' }
      ]
    },
    {
      label: '窗口',
      submenu: [
        { role: 'minimize', label: '最小化' },
        { role: 'close', label: '关闭' }
      ]
    }
  )

  Menu.setApplicationMenu(Menu.buildFromTemplate(template))
}

function serializeUpdaterError(error) {
  if (!error) return { message: 'Unknown updater error' }
  return {
    message: error.message || String(error),
    stack: error.stack
  }
}

function getUpdateFeedUrlOverride() {
  return process.env.MAO_DESKTOP_UPDATE_URL || ''
}

function applyUpdateFeedUrl() {
  const feed = serverConfigLib.resolveUpdateFeedUrl(getServerConfig(), getUpdateFeedUrlOverride())
  if (!feed.url) return { mode: feed.mode, url: null }
  try {
    autoUpdater.setFeedURL({
      provider: 'generic',
      url: feed.url,
    })
    return feed
  } catch (e) {
    console.warn('[updater] setFeedURL failed:', e?.message)
    return { mode: feed.mode, url: feed.url, error: e?.message }
  }
}

function setupAutoUpdater() {
  if (updaterInitialized) return
  updaterInitialized = true

  autoUpdater.autoDownload = true
  autoUpdater.autoInstallOnAppQuit = true

  applyUpdateFeedUrl()

  autoUpdater.on('checking-for-update', () => {
    setUpdaterStatus('checking', null)
    const feed = serverConfigLib.resolveUpdateFeedUrl(getServerConfig(), getUpdateFeedUrlOverride())
    sendToRenderer('update-checking', { feedUrl: feed.url || null })
  })

  autoUpdater.on('update-available', (info) => {
    updateDownloaded = false
    setUpdaterStatus('available', 0)
    sendToRenderer('update-available', info)
  })

  autoUpdater.on('update-not-available', (info) => {
    setUpdaterStatus('not-available', null)
    sendToRenderer('update-not-available', info)
  })

  autoUpdater.on('download-progress', (progress) => {
    setUpdaterStatus('downloading', Math.max(0, Math.min(100, progress?.percent || 0)))
    sendToRenderer('download-progress', progress)
  })

  autoUpdater.on('update-downloaded', (info) => {
    updateDownloaded = true
    setUpdaterStatus('downloaded', 100)
    sendToRenderer('update-downloaded', info)
  })

  autoUpdater.on('error', (error) => {
    console.error('[updater] error:', error)
    setUpdaterStatus('error', null)
    sendToRenderer('update-error', serializeUpdaterError(error))
  })
}

async function checkForAppUpdate() {
  if (!app.isPackaged) {
    setUpdaterStatus('unsupported', null)
    return { skipped: true, reason: 'Auto update is only available in packaged builds.' }
  }
  const feed = serverConfigLib.resolveUpdateFeedUrl(getServerConfig(), getUpdateFeedUrlOverride())
  if (feed.mode === 'disabled') {
    setUpdaterStatus('idle', null)
    return { skipped: true, reason: 'Auto update is disabled by server config.' }
  }
  setupAutoUpdater()
  applyUpdateFeedUrl()
  if (!updateCheckPromise) {
    setUpdaterStatus('checking', null)
    updateCheckPromise = autoUpdater.checkForUpdates()
      .then((result) => ({
        skipped: false,
        updateInfo: result?.updateInfo || null
      }))
      .catch((error) => {
        sendToRenderer('update-error', serializeUpdaterError(error))
        throw error
      })
      .finally(() => {
        updateCheckPromise = null
        buildApplicationMenu()
      })
  }
  return updateCheckPromise
}

function requestToolApproval(toolName, description, sessionId, dangerReason, backendRequestId, approvalHint) {
  return new Promise((resolve) => {
    const requestId = backendRequestId || `approval_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`

    // 决策已先行到达（多端审批的早到窗口）：直接按它放行，不弹本地卡
    const early = earlyApprovalDecisions.get(requestId)
    if (early) {
      earlyApprovalDecisions.delete(requestId)
      resolve(!!early.approved)
      return
    }

    pendingApprovals.set(requestId, (approved) => {
      pendingApprovals.delete(requestId)
      resolve(approved)
    })

    const payload = { requestId, toolName, description, sessionId }
    if (dangerReason) payload.dangerReason = dangerReason
    // 「总是允许」hint（V135）：服务端随 tool_execute 下发的模式提示，透传给渲染层审批卡片
    if (approvalHint) payload.approvalHint = approvalHint
    sendToRenderer('tool-approval-request', payload)
  })
}

/** Persist shell reuse / write_stdin must re-check approval — first approve must not unlock later commands. */
async function ensureShellApproval(needApproval, description, sessionId, dangerReason, backendRequestId, approvalHint) {
  if (!needApproval) return true
  return requestToolApproval('shell', description, sessionId, dangerReason, backendRequestId, approvalHint)
}

function pruneEarlyApprovalDecisions(now = Date.now()) {
  for (const [requestId, entry] of earlyApprovalDecisions) {
    if (now - entry.at > EARLY_APPROVAL_TTL_MS) earlyApprovalDecisions.delete(requestId)
  }
  while (earlyApprovalDecisions.size > EARLY_APPROVAL_LIMIT) {
    const oldest = earlyApprovalDecisions.keys().next()
    if (oldest.done) break
    earlyApprovalDecisions.delete(oldest.value)
  }
}

/**
 * 多端审批的唯一解锁入口（技术方案 2026-11-06 §4.5-10）：
 * 本地 IPC 卡点击、远端 resolved 回声、切会话清理都走这里。
 * 有 pending 就直接 resolve；没有就写入早到缓冲（不读 locallyReleased，那个由渲染层决定）。
 */
ipcMain.handle('tool-approval-remote-response', (event, payload = {}) => {
  const requestId = payload?.requestId
  if (!requestId) return false
  const resolve = pendingApprovals.get(requestId)
  if (resolve) {
    pendingApprovals.delete(requestId)
    resolve(!!payload.approved)
    return true
  }
  earlyApprovalDecisions.set(requestId, { approved: !!payload.approved, at: Date.now() })
  pruneEarlyApprovalDecisions()
  return false
})

// ========== Multi-server baseUrl config ==========

/** @type {{ config: any, fromFile: boolean } | null} */
let serverConfigCache = null
let serverPickerWindow = null

function getServerConfigStorePath() {
  return serverConfigLib.getServerConfigPath(app.getPath('userData'))
}

function loadServerConfig(force = false) {
  if (serverConfigCache && !force) return serverConfigCache
  serverConfigCache = serverConfigLib.readServerConfig(app.getPath('userData'))
  return serverConfigCache
}

function getServerConfig() {
  return loadServerConfig().config
}

function getServerBaseUrlEnvOverride() {
  return (process.env.MAO_DESKTOP_SERVER_URL || '').trim()
}

function getEffectiveServerBaseUrl() {
  const envBase = getServerBaseUrlEnvOverride()
  if (envBase) {
    const normalized = serverConfigLib.normalizeServerBaseUrl(envBase, { allowHttp: true })
    if (normalized.ok) return normalized.baseUrl
  }
  return getServerConfig().serverBaseUrl || serverConfigLib.DEFAULT_SERVER_BASE_URL
}

function isServerConfigured() {
  if (getServerBaseUrlEnvOverride()) return true
  return getServerConfig().configured === true
}

function getApiBaseUrl() {
  if (process.env.NODE_ENV === 'development' && !app.isPackaged) {
    return 'http://localhost:9080/api'
  }
  return serverConfigLib.deriveApiBase(getEffectiveServerBaseUrl())
}

function getServerHostKey() {
  return serverConfigLib.serverHostKey(getEffectiveServerBaseUrl())
}

function getServerPickerHtmlPath() {
  return path.join(__dirname, 'server-picker', 'index.html')
}

function loadServerPicker() {
  if (!mainWindow || mainWindow.isDestroyed()) return
  mainWindow.loadFile(getServerPickerHtmlPath())
}

const LOCAL_RUNTIME_ROOT = path.join(os.homedir(), '.mao', 'runtime')

function resolveLocalRuntimeDir(sessionId) {
  return path.join(LOCAL_RUNTIME_ROOT, getServerHostKey(), String(sessionId))
}

function resolveLocalSkillsDir(sessionId) {
  return path.join(resolveLocalRuntimeDir(sessionId), 'skills')
}

function resolveLocalShellOutputDir(sessionId) {
  return path.join(resolveLocalRuntimeDir(sessionId), 'shellOutput')
}

function formatLocalRuntimePath(sessionId, ...segments) {
  return ['~/.mao/runtime', getServerHostKey(), String(sessionId), ...segments].join('/')
}

const localShell = createLocalShellRuntime({
  buildEnv: buildShellEnv,
  refreshToken: refreshMaoTokenInShellSession,
  resolveOutput: (maoSessionId, shellId) => {
    const fileName = `${shellId}.out`
    return {
      absPath: path.join(resolveLocalShellOutputDir(maoSessionId || 0), fileName),
      displayPath: formatLocalRuntimePath(maoSessionId || 0, 'shellOutput', fileName),
    }
  },
})

function expandHomePath(filePath) {
  if (!filePath) return filePath
  if (filePath === '~') return os.homedir()
  if (filePath.startsWith('~/')) return path.join(os.homedir(), filePath.slice(2))
  return filePath
}

function isUnderLocalRuntime(absolutePath, maoSessionId) {
  if (!maoSessionId) return false
  const runtimeDir = resolveLocalRuntimeDir(maoSessionId)
  const resolved = path.resolve(absolutePath)
  return resolved === runtimeDir || resolved.startsWith(runtimeDir + path.sep)
}

// ========== Skill sync IPC handler ==========

function preferIpv4Loopback(url) {
  // Electron/undici 解析 localhost 会先走 ::1；TS 后端 listen 0.0.0.0 只收 IPv4。
  return String(url || '').replace('://localhost', '://127.0.0.1')
}

function resolveSkillSyncBaseUrl(apiBase) {
  const raw = typeof apiBase === 'string' && apiBase.trim() !== '' ? apiBase.trim() : getApiBaseUrl()
  return preferIpv4Loopback(raw.replace(/\/v1\/?$/, '').replace(/\/$/, ''))
}

ipcMain.handle('skill-sync', async (event, { sessionId, syncUrl, token, apiBase }) => {
  if (!sessionId) {
    const err = 'No sessionId provided for skill sync.'
    sendToRenderer('skill-sync-complete', { sessionId, success: false, error: err })
    return { success: false, error: err }
  }
  try {
    const AdmZip = require('adm-zip')
    const skillsDir = resolveLocalSkillsDir(sessionId)

    const origin = resolveSkillSyncBaseUrl(apiBase)
    const fullUrl = preferIpv4Loopback(/^https?:\/\//.test(syncUrl) ? syncUrl : `${origin}${syncUrl}`)
    const headers = token ? { 'Authorization': `Bearer ${token}` } : {}
    const response = await fetch(fullUrl, { method: 'POST', headers })
    if (!response.ok) {
      const body = await response.text().catch(() => '')
      throw new Error(`Skill sync download failed: ${response.status} ${response.statusText} - ${body}`)
    }

    const zipBuffer = Buffer.from(await response.arrayBuffer())
    fs.mkdirSync(skillsDir, { recursive: true })
    const zip = new AdmZip(zipBuffer)
    zip.extractAllTo(skillsDir, true)
    sendToRenderer('skill-sync-complete', { sessionId, success: true })
    return { success: true }
  } catch (e) {
    console.error('Skill sync failed:', e)
    sendToRenderer('skill-sync-complete', { sessionId, success: false, error: e.message })
    return { success: false, error: e.message }
  }
})

// ========== Local skills (~/.agents/skills) ==========

const LOCAL_SKILLS_DIR = path.join(os.homedir(), '.agents', 'skills')

function parseSkillMd(content) {
  if (!content || !content.startsWith('---')) return null
  const secondDelimiter = content.indexOf('---', 3)
  if (secondDelimiter === -1) return null

  const frontmatter = content.substring(3, secondDelimiter).trim()
  const body = content.substring(secondDelimiter + 3).trim()

  let name = null
  let description = null
  for (const line of frontmatter.split('\n')) {
    const nameMatch = line.match(/^name:\s*(.+)$/)
    if (nameMatch) {
      name = nameMatch[1].trim().replace(/^["']|["']$/g, '')
    }
    const descMatch = line.match(/^description:\s*(.+)$/)
    if (descMatch) {
      description = descMatch[1].trim().replace(/^["']|["']$/g, '')
    }
  }

  if (!name) return null
  return { name, description: description || '', body }
}

function resolveLocalSkillFolder(folderName) {
  if (!folderName || typeof folderName !== 'string') return null
  if (folderName.includes('/') || folderName.includes('\\') || folderName.startsWith('.')) {
    return null
  }
  const skillFolder = path.resolve(LOCAL_SKILLS_DIR, folderName)
  const normalizedRoot = path.resolve(LOCAL_SKILLS_DIR)
  if (skillFolder !== normalizedRoot && !skillFolder.startsWith(normalizedRoot + path.sep)) {
    return null
  }
  if (!fs.existsSync(skillFolder) || !fs.statSync(skillFolder).isDirectory()) {
    return null
  }
  return skillFolder
}

function collectSkillFiles(dir, baseDir, files = []) {
  const entries = fs.readdirSync(dir, { withFileTypes: true })
  for (const entry of entries) {
    if (entry.name.startsWith('.')) continue
    const fullPath = path.join(dir, entry.name)
    if (entry.isDirectory()) {
      collectSkillFiles(fullPath, baseDir, files)
    } else if (entry.isFile()) {
      const relativePath = path.relative(baseDir, fullPath).replace(/\\/g, '/')
      if (!relativePath || relativePath.includes('/.')) continue
      files.push({ relativePath, fullPath })
    }
  }
  return files
}

ipcMain.handle('list-local-skills', async () => {
  try {
    if (!fs.existsSync(LOCAL_SKILLS_DIR)) {
      return { skills: [], skillsDir: LOCAL_SKILLS_DIR }
    }

    const skills = []
    const entries = fs.readdirSync(LOCAL_SKILLS_DIR, { withFileTypes: true })
    for (const entry of entries) {
      if (!entry.isDirectory() || entry.name.startsWith('.')) continue

      const folderPath = path.join(LOCAL_SKILLS_DIR, entry.name)
      const skillMdPath = path.join(folderPath, 'SKILL.md')
      if (!fs.existsSync(skillMdPath)) continue

      try {
        const content = fs.readFileSync(skillMdPath, 'utf-8')
        const parsed = parseSkillMd(content)
        if (!parsed) continue
        skills.push({
          folderName: entry.name,
          name: parsed.name,
          description: parsed.description,
          folderPath,
        })
      } catch (e) {
        console.warn('[local-skills] Failed to parse:', entry.name, e.message)
      }
    }

    skills.sort((a, b) => a.name.localeCompare(b.name))
    return { skills, skillsDir: LOCAL_SKILLS_DIR }
  } catch (e) {
    console.error('[local-skills] list failed:', e)
    return { error: e.message, skills: [], skillsDir: LOCAL_SKILLS_DIR }
  }
})

ipcMain.handle('get-local-skill-detail', async (event, { folderName }) => {
  try {
    const skillFolder = resolveLocalSkillFolder(folderName)
    if (!skillFolder) {
      return { error: 'Skill not found: ' + folderName }
    }

    const skillMdPath = path.join(skillFolder, 'SKILL.md')
    const content = fs.readFileSync(skillMdPath, 'utf-8')
    const parsed = parseSkillMd(content)
    if (!parsed) {
      return { error: 'Invalid SKILL.md in skill: ' + folderName }
    }

    return {
      name: parsed.name,
      description: parsed.description,
      body: parsed.body,
      folderPath: skillFolder,
      filePath: skillMdPath,
      folderName,
    }
  } catch (e) {
    return { error: e.message }
  }
})

ipcMain.handle('read-local-skill-files', async (event, { folderName }) => {
  try {
    const skillFolder = resolveLocalSkillFolder(folderName)
    if (!skillFolder) {
      return { error: 'Skill not found: ' + folderName }
    }

    const fileEntries = collectSkillFiles(skillFolder, skillFolder)
    const files = fileEntries.map(({ relativePath, fullPath }) => ({
      relativePath,
      base64: fs.readFileSync(fullPath).toString('base64'),
    }))

    return { folderName, files }
  } catch (e) {
    return { error: e.message }
  }
})

ipcMain.handle('read-agents-md', async (event, { workspace }) => {
  try {
    if (!workspace) {
      return { content: null }
    }

    const agentsMdPath = path.join(workspace, 'AGENTS.md')
    if (!fs.existsSync(agentsMdPath)) {
      return { content: null }
    }

    const stat = fs.statSync(agentsMdPath)
    if (!stat.isFile()) {
      return { content: null }
    }

    const content = fs.readFileSync(agentsMdPath, 'utf-8')
    return { content: content || null }
  } catch (e) {
    console.error('[read-agents-md] Failed:', e.message)
    return { error: e.message, content: null }
  }
})

function resolveWorkspacePath(filePath, workspace, maoSessionId) {
  const effectiveWorkspace = workspace || currentWorkspace
  if (!filePath) return filePath

  const expanded = expandHomePath(filePath)
  if (path.isAbsolute(expanded)) {
    if (maoSessionId && isUnderLocalRuntime(expanded, maoSessionId)) {
      return expanded
    }
    return expanded
  }
  if (!effectiveWorkspace) return expanded
  return path.join(effectiveWorkspace, expanded)
}

function detectShell() {
  return process.env.SHELL || process.env.ComSpec || process.env.COMSPEC || (process.platform === 'win32' ? 'cmd.exe' : '/bin/sh')
}

function buildOsVersion() {
  if (process.platform === 'win32') {
    return `${os.version()} ${os.release()}`
  }
  return `${os.type()} ${os.release()}`
}

function isGitWorkspace(workspace) {
  if (!workspace) return false
  let current = path.resolve(workspace)
  while (current && current !== path.dirname(current)) {
    if (fs.existsSync(path.join(current, '.git'))) {
      return true
    }
    current = path.dirname(current)
  }
  return false
}

const { getGitStatus, refreshGitStatus, getGitFileDiff, listGitRepos, getGitLog, getGitCommitFiles, getGitCommitFileDiff, getGitBranchCompare, getGitBranchCompareFileDiff, getGitBranches, getGitStashes, getGitRemotes } = require('./gitStatus.cjs')
const { buildCommitInput, commit: gitCommit, pull: gitPull, push: gitPush, fetch: gitFetch, switchBranch: gitSwitchBranch, stashOp: gitStashOp } = require('./gitOperations.cjs')

function loadMainContent() {
  if (process.env.NODE_ENV === 'development' && !app.isPackaged) {
    mainWindow.loadURL('http://localhost:5201')
    mainWindow.webContents.openDevTools()
    return
  }

  // 生产：远程 SPA；未配置服务器时先展示本地配置页
  if (!isServerConfigured()) {
    loadServerPicker()
    return
  }

  const target = getEffectiveServerBaseUrl()
  mainWindow.loadURL(target).catch((err) => {
    console.error('[server] loadURL failed:', target, err)
    loadServerPicker()
  })
}

async function cleanupSiteScopedResources() {
  try {
    terminalManager.killAll()
  } catch (e) {
    console.warn('[server] terminal cleanup failed:', e?.message)
  }
  try {
    localShell.closeAll()
  } catch (e) {
    console.warn('[server] local shell cleanup failed:', e?.message)
  }
  const sessionIds = Array.from(mcpClients.keys())
  await Promise.all(
    sessionIds.map((sid) =>
      closeMcpSession(sid).catch((e) => console.warn('[server] mcp cleanup failed:', e?.message))
    )
  )
}

/**
 * 切换服务器：校验 → 可选探测 → host 变化时清 auth/本地资源 → 写配置 → 加载目标站。
 * @param {{ serverBaseUrl: string, updateFeedMode?: string, allowHttp?: boolean, skipProbe?: boolean }} payload
 */
async function applyServerConfig(payload = {}) {
  const allowHttp = payload.allowHttp === true
  const normalized = serverConfigLib.normalizeServerBaseUrl(payload.serverBaseUrl, { allowHttp })
  if (!normalized.ok) {
    return { ok: false, error: normalized.error }
  }

  const targetBase = normalized.baseUrl
  const previousBase = getEffectiveServerBaseUrl()
  const previousHost = serverConfigLib.serverHostKey(previousBase)
  const nextHost = serverConfigLib.serverHostKey(targetBase)
  const hostChanged = previousHost !== nextHost

  if (payload.skipProbe !== true) {
    const probe = await serverConfigLib.probeServer(targetBase)
    if (!probe.ok) {
      return { ok: false, error: probe.error || '服务器检测失败', probe }
    }
  }

  if (hostChanged) {
    writeAuthStore({ token: null, refreshToken: null })
    await cleanupSiteScopedResources()
  }

  const writeResult = serverConfigLib.writeServerConfig(app.getPath('userData'), {
    serverBaseUrl: targetBase,
    updateFeedMode: payload.updateFeedMode || getServerConfig().updateFeedMode || 'follow-site',
    allowHttp,
    configured: true,
  })
  if (!writeResult.ok) {
    return { ok: false, error: writeResult.error }
  }

  serverConfigCache = null
  loadServerConfig(true)

  // 历史只记「连接成功」过的地址，置顶去重供快速切换
  try {
    serverConfigLib.recordServerHistory(app.getPath('userData'), targetBase, allowHttp)
  } catch (e) {
    console.warn('[server] history record failed:', e?.message)
  }
  const feed = serverConfigLib.resolveUpdateFeedUrl(getServerConfig(), getUpdateFeedUrlOverride())
  if (feed.url) {
    try {
      autoUpdater.setFeedURL({ provider: 'generic', url: feed.url })
    } catch (e) {
      console.warn('[updater] setFeedURL failed:', e?.message)
    }
  }

  if (mainWindow && !mainWindow.isDestroyed()) {
    loadMainContent()
  }
  return {
    ok: true,
    serverBaseUrl: targetBase,
    hostChanged,
    updateFeedMode: writeResult.config.updateFeedMode,
  }
}

function openServerPickerWindow() {
  if (serverPickerWindow && !serverPickerWindow.isDestroyed()) {
    serverPickerWindow.focus()
    return
  }
  serverPickerWindow = new BrowserWindow({
    width: 560,
    useContentSize: true,
    resizable: false,
    minimizable: false,
    maximizable: false,
    fullscreenable: false,
    title: 'Mao · 服务器设置',
    parent: mainWindow && !mainWindow.isDestroyed() ? mainWindow : undefined,
    modal: false,
    autoHideMenuBar: true,
    webPreferences: {
      preload: join(__dirname, 'preload.cjs'),
      contextIsolation: true,
      nodeIntegration: false,
      sandbox: true,
    },
  })
  serverPickerWindow.loadFile(getServerPickerHtmlPath())
  serverPickerWindow.on('closed', () => {
    serverPickerWindow = null
  })
}

function createWindow() {
  mainWindow = new BrowserWindow({
    width: 1200,
    height: 800,
    minWidth: 800,
    minHeight: 600,
    show: false,
    title: 'Mao',
    titleBarStyle: 'hiddenInset',
    trafficLightPosition: { x: 16, y: 12 },
    backgroundColor: '#f5f5f7',
    webPreferences: {
      preload: join(__dirname, 'preload.cjs'),
      contextIsolation: true,
      nodeIntegration: false,
      sandbox: true
    }
  })

  mainWindow.once('ready-to-show', () => {
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.show()
    }
  })

  loadMainContent()

  mainWindow.webContents.setWindowOpenHandler(({ url }) => {
    shell.openExternal(url)
    return { action: 'deny' }
  })

  // 关窗拦截（P2，默认托盘化）：quitting 旗标未置位且偏好为托盘时，红点/X/窗口菜单「关闭」
  // 一律 hide 而非销毁——渲染层与 WS 存活，任务继续跑、通知照常可达。
  // 退出路径（托盘菜单 / 应用菜单 role:quit / app.quit()）都先走 before-quit 置
  // quitting=true，本拦截随之失效，窗口正常关闭并全量清理。
  mainWindow.on('close', (e) => {
    if (quitting) return
    const prefs = desktopPrefsLib.readDesktopPrefs(app.getPath('userData'))
    if (prefs.closeToTray !== 'tray') return
    e.preventDefault()
    mainWindow.hide()
    if (!prefs.trayHintShown) {
      sendToRenderer('tray-first-close-hint', {})
      desktopPrefsLib.writeDesktopPrefs(app.getPath('userData'), { trayHintShown: true })
    }
  })

  mainWindow.on('closed', () => {
    mainWindow = null
  })

  // 托盘菜单文案（显示/隐藏主窗）随窗口显示态刷新。挂在 createWindow 里而非 initTray：
  // 退出模式下关窗会销毁窗口，activate/second-instance 重建的新窗口同样需要这些监听，
  // 否则文案停留在旧状态，用户按文案点击会做出与意图相反的动作。
  // closed 也必须监听：退出模式关窗走销毁，此时 isWindowVisible() 因 mainWindow 置 null
  // 返回 false，文案应翻为「显示主窗」（点击即重建），停在「隐藏主窗」会语义相反。
  const refreshTray = () => appTray?.refresh()
  mainWindow.on('show', refreshTray)
  mainWindow.on('hide', refreshTray)
  mainWindow.on('minimize', refreshTray)
  mainWindow.on('restore', refreshTray)
  mainWindow.on('closed', refreshTray)

  // 返回实例：调用方（second-instance / 通知 click 重建路径）需要拿到它来
  // restore/show/focus 或挂加载回调，不能只靠 ready-to-show 兜底
  return mainWindow
}

// ========== P2/P3 桌面壳：托盘 / 通知 / 角标 / 偏好 / 快捷键 ==========

function readDesktopPrefs() {
  return desktopPrefsLib.readDesktopPrefs(app.getPath('userData'))
}

function initTray() {
  if (appTray) return
  appTray = createTray({
    isWindowVisible: () => !!mainWindow && !mainWindow.isDestroyed() && mainWindow.isVisible(),
    onShowHide: () => {
      const win = mainWindow
      if (!win || win.isDestroyed()) {
        createWindow()
        return
      }
      if (win.isVisible()) {
        win.hide()
      } else {
        if (win.isMinimized()) win.restore()
        win.show()
        win.focus()
      }
      appTray?.refresh()
    },
    onNewTask: () => {
      // 渲染层复用「新建任务」既有入口（Home + newTask=1）；窗口不可见时先唤起
      const win = mainWindow
      if (win && !win.isDestroyed()) {
        if (win.isMinimized()) win.restore()
        win.show()
        win.focus()
      }
      sendToRenderer('tray-new-task', {})
    },
    onQuit: () => {
      // before-quit 置 quitting → close 不再拦截 → 全量清理后退出
      app.quit()
    },
  })
}

/**
 * 全局快捷键（P3，默认 Alt+Shift+M，可改可关）：触发时窗口可见且聚焦则隐藏，否则唤起。
 * 换键顺序必须是「先注册新键、成功后再摘旧键」：反过来会在新键注册失败时把旧键也弄丢
 * （unregisterAll 先清空），而偏好文件与设置页仍显示旧键，快捷键静默失效到重启。
 * @param {string | null} accel
 * @returns {{ ok: true } | { ok: false, error: string }}
 */
function applyGlobalShortcut(accel) {
  if (!accel) {
    // 关闭：只摘当前已注册的那个键，不影响（也不存在的）其他注册项
    try {
      if (currentShortcutAccel) globalShortcut.unregister(currentShortcutAccel)
    } catch (e) {
      console.warn('[shortcut] unregister failed:', e?.message)
    }
    currentShortcutAccel = null
    return { ok: true }
  }
  // 与当前键相同：直接视为成功。Electron 对「重复注册同一 accelerator」的返回值有版本
  // 差异，早退可消掉这层不确定，也避免误导性的「被其他程序占用」提示
  if (currentShortcutAccel === accel) return { ok: true }
  try {
    const registered = globalShortcut.register(accel, () => {
      const win = mainWindow
      // 无窗口（退出模式关窗销毁后应用仍驻留）时重建：快捷键语义是「否则唤起」，
      // 直接 return 会让仍显示「已启用」的快捷键完全失效
      if (!win || win.isDestroyed()) {
        createWindow()
        appTray?.refresh()
        return
      }
      if (win.isVisible() && !win.isMinimized() && win.isFocused()) {
        win.hide()
      } else {
        if (win.isMinimized()) win.restore()
        win.show()
        win.focus()
      }
      appTray?.refresh()
    })
    if (!registered) {
      // 新键没注册上：旧键原样保持生效，偏好不写，UI 与实际状态一致
      return { ok: false, error: '快捷键注册失败，可能已被其他程序占用' }
    }
    if (currentShortcutAccel && currentShortcutAccel !== accel) {
      try {
        globalShortcut.unregister(currentShortcutAccel)
      } catch (e) {
        console.warn('[shortcut] unregister old accel failed:', e?.message)
      }
    }
    currentShortcutAccel = accel
    return { ok: true }
  } catch (e) {
    return { ok: false, error: `快捷键格式无效：${e?.message || ''}` }
  }
}

/**
 * 开机自启（P3）：仅打包后客户端可写登录项（防 dev 的 electron 二进制误入登录项，决策 8）。
 * openAsHidden 配合托盘模式：自启后驻留托盘不弹窗。
 */
function applyAutoStart(enabled) {
  if (!app.isPackaged) {
    return { ok: false, error: '开发模式下不支持开机自启，请使用打包后的客户端' }
  }
  try {
    app.setLoginItemSettings({ openAtLogin: enabled === true, openAsHidden: true })
    return { ok: true }
  } catch (e) {
    return { ok: false, error: `设置开机自启失败：${e?.message || ''}` }
  }
}

ipcMain.handle('local-copy-attachment', async (event, payload) => {
  // 落点由主进程推导（home + server host + sessionId），渲染层无法指定。
  // 异步拷贝：大文件的 copyFile 不阻塞主进程事件循环（曾用同步 copyFileSync，
  // 拖入接近上限的大附件会把整个应用卡死数十秒）。
  return chatAttachment.copyLocalAttachmentAsync({
    sourcePath: payload?.sourcePath,
    sessionId: payload?.sessionId,
    maxSizeMb: payload?.maxSizeMb,
    homeDir: os.homedir(),
    hostKey: getServerHostKey(),
  })
})

ipcMain.handle('local-write-text-file', async (event, payload) => {
  // 渲染层粘贴附件入口：同名避重，不覆盖已有附件。
  // handleLocalWriteTextFile 回的是工具协议 { success, path, bytes_written } / { error }，
  // 渲染层与 local-copy-attachment 对齐，只认 { ok, absolutePath, error }。
  // 直接把工具形态透传出去时，写盘成功也会被当成失败（error 为空 → 「写入失败」），
  // 粘贴超长文本发送会被整单取消。
  const result = await handleLocalWriteTextFile(payload, payload?.sessionId, true)
  if (result?.success && result.path) {
    return { ok: true, absolutePath: result.path }
  }
  return { ok: false, error: result?.error || '写入失败' }
})

ipcMain.handle('desktop-notify', (event, payload) => {
  const title = String(payload?.title ?? '')
  const body = String(payload?.body ?? '')
  const tag = payload?.tag != null ? String(payload.tag) : undefined
  const itemId = payload?.itemId ?? null
  const sessionId = payload?.sessionId ?? null
  if (!title) return { ok: false, error: '通知标题为空' }
  try {
    const notification = new Notification({ title, body, tag })
    notification.on('click', () => {
      // 窗口隐藏到托盘时点击通知先唤起主窗，再把跳转事件交给渲染层。
      // 窗口已销毁（退出模式 + macOS 关窗后点旧通知）时重建：否则 sendToRenderer
      // 因 mainWindow 为 null 静默丢弃，用户点了通知却什么都没有。
      // 无论走哪条路径都先入待派发队列：渲染层监听可能尚未注册（应用刚启动、
      // 页面加载中、重建窗口的渲染进程是新的），立即 send 会丢，由渲染层桥接
      // 就绪后主动 consume 兜底；did-finish-load 补发仅在尚未被拉取时执行。
      const clickPayload = { itemId, sessionId }
      pendingNotificationClick = clickPayload
      const win = mainWindow
      if (win && !win.isDestroyed()) {
        if (win.isMinimized()) win.restore()
        win.show()
        win.focus()
        sendToRenderer('desktop-notification-click', clickPayload)
        return
      }
      const created = createWindow()
      // 新窗口的渲染层（Vue 应用 + ipcRenderer.on）要等页面加载完才就绪：同步发
      // 跳转事件会丢（窗口能出来但不跳会话），等 did-finish-load 再补发。
      // 读队列与 send 同步完成，与 consume 不会交错：已被渲染层拉取时队列已空，跳过。
      if (created && !created.isDestroyed() && created.webContents) {
        created.webContents.once('did-finish-load', () => {
          const pending = pendingNotificationClick
          if (!pending) return
          sendToRenderer('desktop-notification-click', pending)
        })
      }
    })
    notification.on('failed', () => {
      console.warn('[notify] display failed:', title)
      sendToRenderer('desktop-notify-result', { ok: false, error: '系统通知展示失败', tag })
    })
    notification.show()
    return { ok: true }
  } catch (e) {
    const error = e?.message || '通知发送失败'
    sendToRenderer('desktop-notify-result', { ok: false, error, tag })
    return { ok: false, error }
  }
})

ipcMain.handle('desktop-notification-click-consume', () => {
  // 渲染层桥接就绪后主动拉取：点击时监听尚未注册（应用刚启动/页面加载中/窗口
  // 重建）导致的丢失由这里兜底。取出即清空——拉取过的点击不重复派发。
  const payload = pendingNotificationClick
  pendingNotificationClick = null
  return payload
})

ipcMain.handle('desktop-notification-click-ack', () => {
  // 渲染层已收到立即派发的点击深链：清除待派发队列，防止页面重载后
  // 桥接重新就绪时拿陈旧点击重复跳转。
  pendingNotificationClick = null
  return { ok: true }
})

ipcMain.handle('desktop-badge', (event, payload) => {
  const count = Math.max(0, Math.floor(Number(payload?.count) || 0))
  if (process.platform === 'darwin' && app.dock && typeof app.dock.setBadgeCount === 'function') {
    app.dock.setBadgeCount(count)
  }
  // win/linux no-op（overlay 角标列为后续可选）
  return { ok: true }
})

ipcMain.handle('desktop-prefs-get', () => {
  return { ok: true, prefs: readDesktopPrefs(), packaged: app.isPackaged, platform: process.platform }
})

// 本机设备身份（技术方案 2026-11-05 §4.2）：deviceId 首次取用时生成并落盘（ensure），
// 名字用主机名、平台用 process.platform——渲染层 WS auth 帧与建 LOCAL 会话时携带。
ipcMain.handle('device-info-get', () => {
  return {
    id: desktopPrefsLib.ensureDesktopDeviceId(app.getPath('userData')),
    name: os.hostname(),
    platform: process.platform,
  }
})

ipcMain.handle('desktop-prefs-set', (event, patch) => {
  const next = patch && typeof patch === 'object' ? patch : {}
  // dev 模式禁止开启自启：直接拒绝，不落盘（防打包前的误开启在打包后生效）
  if (next.autoStart === true && !app.isPackaged) {
    return { ok: false, error: '开发模式下不支持开机自启，请使用打包后的客户端' }
  }
  const result = desktopPrefsLib.writeDesktopPrefs(app.getPath('userData'), next)
  let sideError = null
  if ('autoStart' in next) {
    const applied = applyAutoStart(result.prefs.autoStart)
    if (!applied.ok) sideError = applied.error
  }
  return { ok: true, prefs: result.prefs, error: sideError || undefined }
})

ipcMain.handle('desktop-shortcut-set', (event, accel) => {
  const next = accel == null ? null : String(accel).trim()
  if (next === '') {
    return { ok: false, error: '快捷键不能为空（关闭请传 null）' }
  }
  const applied = applyGlobalShortcut(next)
  if (!applied.ok) {
    sendToRenderer('desktop-shortcut-failed', { accel: next, error: applied.error })
    return { ok: false, error: applied.error }
  }
  const result = desktopPrefsLib.writeDesktopPrefs(app.getPath('userData'), { globalShortcut: next })
  return { ok: true, prefs: result.prefs }
})

app.whenReady().then(() => {
  buildApplicationMenu()
  createWindow()
  initTray()
  // 快捷键按偏好注册（默认 Alt+Shift+M）；失败时回传提示
  const shortcut = readDesktopPrefs().globalShortcut
  const registered = applyGlobalShortcut(shortcut)
  if (!registered.ok) {
    sendToRenderer('desktop-shortcut-failed', { accel: shortcut, error: registered.error })
  }
  if (app.isPackaged) {
    setTimeout(() => {
      checkForAppUpdate().catch((error) => {
        console.error('[updater] initial check failed:', error)
      })
    }, 3000)
  }
})

app.on('window-all-closed', () => {
  // 托盘模式下窗口是 hide 而非 close，不会触发本事件；仅「退出模式」下走原逻辑
  if (process.platform !== 'darwin') {
    app.quit()
  }
})

app.on('activate', () => {
  if (BrowserWindow.getAllWindows().length === 0) {
    createWindow()
  } else if (mainWindow && !mainWindow.isDestroyed()) {
    // 托盘化后红点关闭 = 隐藏：dock 点击应恢复而非新建窗口
    if (mainWindow.isMinimized()) mainWindow.restore()
    mainWindow.show()
    appTray?.refresh()
  }
})

app.on('before-quit', () => {
  quitting = true
  // 快捷键全部注销后同步清掉跟踪值：否则退出若被中止，之后「重设同一个键」会命中
  // 同键早退而跳过 register，键保持未注册但 UI/偏好显示已启用
  currentShortcutAccel = null
  try {
    globalShortcut.unregisterAll()
  } catch (e) {
    console.warn('[shortcut] unregisterAll on quit failed:', e?.message)
  }
  terminalManager.killAll()
  localShell.closeAll()
  localShell.stopCleanup()
  // 关闭全部 MCP 连接（stdio 子进程 / HTTP 会话）
  const sessionIds = Array.from(mcpClients.keys())
  sessionIds.forEach((sid) => {
    closeMcpSession(sid).catch((e) => console.warn('[mcp] quit cleanup failed:', e.message))
  })
})

// ========== Auth token persistence (file:// localStorage is not reliable) ==========

function getAuthStorePath() {
  return path.join(app.getPath('userData'), 'auth.json')
}

function readAuthStore() {
  try {
    const authPath = getAuthStorePath()
    if (fs.existsSync(authPath)) {
      const data = JSON.parse(fs.readFileSync(authPath, 'utf8'))
      // 服务端 host 变化后旧 token 不可用，避免串站
      const currentHost = getServerHostKey()
      if (data.serverHost && data.serverHost !== currentHost) {
        return { token: null, refreshToken: null }
      }
      return {
        token: data.token || null,
        refreshToken: data.refreshToken || null
      }
    }
  } catch (e) {
    console.error('[auth] Failed to read auth store:', e.message)
  }
  return { token: null, refreshToken: null }
}

function writeAuthStore(data) {
  try {
    const authPath = getAuthStorePath()
    fs.mkdirSync(path.dirname(authPath), { recursive: true })
    const payload = {
      token: data.token || null,
      refreshToken: data.refreshToken || null,
      serverHost: data.token || data.refreshToken ? getServerHostKey() : null,
    }
    fs.writeFileSync(authPath, JSON.stringify(payload), 'utf8')
  } catch (e) {
    console.error('[auth] Failed to write auth store:', e.message)
  }
}

ipcMain.handle('auth-get-tokens', () => readAuthStore())

ipcMain.handle('auth-set-tokens', (_event, { token, refreshToken }) => {
  writeAuthStore({ token: token || null, refreshToken: refreshToken || null })
})

ipcMain.handle('auth-clear-tokens', () => {
  writeAuthStore({ token: null, refreshToken: null })
})

// ========== Server baseUrl config IPC ==========

ipcMain.handle('server-config-get', () => {
  const config = getServerConfig()
  const envOverride = getServerBaseUrlEnvOverride()
  const feed = serverConfigLib.resolveUpdateFeedUrl(config, getUpdateFeedUrlOverride())
  return {
    serverBaseUrl: getEffectiveServerBaseUrl(),
    updateFeedMode: config.updateFeedMode || 'follow-site',
    allowHttp: config.allowHttp === true,
    configured: isServerConfigured(),
    envOverride: Boolean(envOverride),
    appVersion: app.getVersion(),
    hostKey: getServerHostKey(),
    apiBase: getApiBaseUrl(),
    updateFeed: feed,
    history: serverConfigLib.readServerHistory(app.getPath('userData')),
  }
})

ipcMain.handle('server-config-probe', async (_event, payload = {}) => {
  const allowHttp = payload.allowHttp === true
  const normalized = serverConfigLib.normalizeServerBaseUrl(payload.serverBaseUrl, { allowHttp })
  if (!normalized.ok) return { ok: false, error: normalized.error }
  return serverConfigLib.probeServer(normalized.baseUrl)
})

ipcMain.handle('server-config-set', async (_event, payload = {}) => {
  return applyServerConfig(payload || {})
})

ipcMain.handle('server-config-open-picker', () => {
  openServerPickerWindow()
  return { ok: true }
})

ipcMain.handle('server-picker-close', () => {
  if (serverPickerWindow && !serverPickerWindow.isDestroyed()) {
    serverPickerWindow.close()
  }
  return { ok: true }
})

ipcMain.handle('server-config-remove-history', (_event, payload = {}) => {
  const target = String(payload?.serverBaseUrl || '').trim()
  if (!target) return { ok: false, error: '缺少地址', history: serverConfigLib.readServerHistory(app.getPath('userData')) }
  const history = serverConfigLib.removeServerHistory(app.getPath('userData'), target)
  return { ok: true, history }
})

// ========== Window control IPC handlers ==========

ipcMain.handle('window-minimize', () => {
  if (mainWindow && !mainWindow.isDestroyed()) {
    mainWindow.minimize()
  }
})

ipcMain.handle('window-maximize', () => {
  if (mainWindow && !mainWindow.isDestroyed()) {
    if (mainWindow.isMaximized()) {
      mainWindow.unmaximize()
    } else {
      mainWindow.maximize()
    }
  }
})

ipcMain.handle('window-close', () => {
  if (mainWindow && !mainWindow.isDestroyed()) {
    mainWindow.close()
  }
})

// ========== Original IPC handlers ==========

ipcMain.handle('get-app-version', () => {
  return app.getVersion()
})

ipcMain.handle('get-platform', () => {
  return process.platform
})

ipcMain.handle('check-for-update', () => {
  return checkForAppUpdate()
})

ipcMain.handle('install-update', () => {
  return installDownloadedUpdate()
})

ipcMain.handle('get-environment-info', (event, { workspace } = {}) => {
  return {
    isGit: isGitWorkspace(workspace || currentWorkspace),
    platform: process.platform,
    shell: detectShell(),
    osVersion: buildOsVersion()
  }
})

ipcMain.handle('git-repos', async (event, { workspace } = {}) => {
  try {
    return await listGitRepos(workspace || currentWorkspace)
  } catch (e) {
    return { isRootGit: false, repos: [], error: e.message || '扫描 Git 仓库失败' }
  }
})

ipcMain.handle('git-status', async (event, { workspace, repoPath } = {}) => {
  try {
    return await getGitStatus(workspace || currentWorkspace, repoPath)
  } catch (e) {
    return { isGit: false, remoteStatusAvailable: false, error: e.message || '读取 Git 状态失败' }
  }
})

ipcMain.handle('git-status-refresh', async (event, { workspace, repoPath } = {}) => {
  try {
    return await refreshGitStatus(workspace || currentWorkspace, repoPath)
  } catch (e) {
    return { isGit: false, remoteStatusAvailable: false, error: e.message || '刷新 Git 状态失败' }
  }
})

ipcMain.handle('git-file-diff', async (event, { workspace, repoPath, path: filePath } = {}) => {
  try {
    return await getGitFileDiff(workspace || currentWorkspace, repoPath, filePath)
  } catch (e) {
    return {
      path: filePath || '',
      changeType: 'MODIFIED',
      beforeContent: '',
      afterContent: '',
      unavailableReason: e.message || '读取 Git diff 失败',
    }
  }
})

ipcMain.handle('git-commit-input', async (_event, { workspace, repoPath } = {}) => {
  return buildCommitInput(workspace || currentWorkspace, repoPath)
})

ipcMain.handle('git-commit', async (_event, { workspace, repoPath, message } = {}) => {
  return gitCommit(workspace || currentWorkspace, repoPath, message)
})

ipcMain.handle('git-pull', async (_event, { workspace, repoPath } = {}) => {
  return gitPull(workspace || currentWorkspace, repoPath)
})

ipcMain.handle('git-push', async (_event, { workspace, repoPath } = {}) => {
  return gitPush(workspace || currentWorkspace, repoPath)
})

ipcMain.handle('git-log', async (_event, { workspace, repoPath, options } = {}) => {
  try {
    return await getGitLog(workspace || currentWorkspace, repoPath, options || {})
  } catch (e) {
    return { error: e.message || '读取提交历史失败' }
  }
})

ipcMain.handle('git-commit-files', async (_event, { workspace, repoPath, hash } = {}) => {
  try {
    return await getGitCommitFiles(workspace || currentWorkspace, repoPath, hash)
  } catch (e) {
    return { error: e.message || '读取提交文件清单失败' }
  }
})

ipcMain.handle('git-commit-file-diff', async (_event, { workspace, repoPath, hash, path: filePath, oldPath } = {}) => {
  try {
    return await getGitCommitFileDiff(workspace || currentWorkspace, repoPath, hash, filePath, oldPath)
  } catch (e) {
    return {
      path: filePath || '',
      changeType: 'MODIFIED',
      beforeContent: '',
      afterContent: '',
      unavailableReason: e.message || '读取提交 diff 失败',
    }
  }
})

// 分支对比：失败形状同 git-commit-files（对象形态的 { error }，由 provider 侧解包后抛错），
// 因为「ref 不存在 / 无共同祖先 / 对比失败」都必须与「两分支无差异（files: []）」可区分
ipcMain.handle('git-branch-compare', async (_event, { workspace, repoPath, base, target } = {}) => {
  try {
    return await getGitBranchCompare(workspace || currentWorkspace, repoPath, base, target)
  } catch (e) {
    return { error: e.message || '读取分支对比失败' }
  }
})

// 分支对比单文件 diff：失败形状同 git-commit-file-diff（降级 diff 对象，不抛）
ipcMain.handle('git-branch-compare-file-diff', async (_event, { workspace, repoPath, base, target, path: filePath, oldPath } = {}) => {
  try {
    return await getGitBranchCompareFileDiff(workspace || currentWorkspace, repoPath, base, target, filePath, oldPath)
  } catch (e) {
    return {
      path: filePath || '',
      changeType: 'MODIFIED',
      beforeContent: '',
      afterContent: '',
      unavailableReason: e.message || '读取分支 diff 失败',
    }
  }
})

ipcMain.handle('git-branches', async (_event, { workspace, repoPath } = {}) => {
  try {
    return await getGitBranches(workspace || currentWorkspace, repoPath)
  } catch (e) {
    return { error: e.message || '读取分支列表失败' }
  }
})

ipcMain.handle('git-stashes', async (_event, { workspace, repoPath } = {}) => {
  try {
    return await getGitStashes(workspace || currentWorkspace, repoPath)
  } catch (e) {
    return { error: e.message || '读取 stash 列表失败' }
  }
})

ipcMain.handle('git-remotes', async (_event, { workspace, repoPath } = {}) => {
  try {
    return await getGitRemotes(workspace || currentWorkspace, repoPath)
  } catch (e) {
    return { error: e.message || '读取远端列表失败' }
  }
})

ipcMain.handle('git-fetch', async (_event, { workspace, repoPath } = {}) => {
  return gitFetch(workspace || currentWorkspace, repoPath)
})

ipcMain.handle('git-switch-branch', async (_event, { workspace, repoPath, branch, create } = {}) => {
  return gitSwitchBranch(workspace || currentWorkspace, repoPath, branch, create === true)
})

ipcMain.handle('git-stash-op', async (_event, { workspace, repoPath, action, ref } = {}) => {
  return gitStashOp(workspace || currentWorkspace, repoPath, action, ref)
})

ipcMain.handle('open-external', async (event, url) => {
  if (typeof url !== 'string' || !url.trim()) {
    throw new Error('URL is required')
  }
  const parsed = new URL(url)
  if (!['http:', 'https:'].includes(parsed.protocol)) {
    throw new Error('Unsupported external URL protocol')
  }
  await shell.openExternal(parsed.toString())
})

ipcMain.handle('open-feishu-auth-window', async (event, payload) => {
  const authUrl = typeof payload === 'string' ? payload : payload?.authUrl
  const callbackPath = typeof payload === 'object' && payload?.callbackPath
    ? payload.callbackPath
    : '/api/v1/auth/feishu/callback'
  return new Promise((resolve) => {
    const authWindow = new BrowserWindow({
      width: 800,
      height: 700,
      title: '飞书登录',
      autoHideMenuBar: true,
      webPreferences: {
        nodeIntegration: false,
        contextIsolation: true,
        sandbox: true,
      },
    })

    authWindow.loadURL(authUrl)

    let resolved = false

    function checkUrl(url) {
      if (resolved) return
      try {
        const parsed = new URL(url)
        if (parsed.pathname === callbackPath || parsed.pathname.endsWith(callbackPath)) {
          resolved = true
          const state = parsed.searchParams.get('state') || ''
          const code = parsed.searchParams.get('code') || ''
          if (!authWindow.isDestroyed()) {
            authWindow.close()
          }
          resolve({ state, code })
        }
      } catch {
        // ignore invalid URLs
      }
    }

    authWindow.webContents.on('did-navigate', (_, url) => checkUrl(url))
    authWindow.webContents.on('did-navigate-in-page', (_, url) => checkUrl(url))

    authWindow.on('closed', () => {
      if (!resolved) {
        resolved = true
        resolve({ state: '' })
      }
    })
  })
})

ipcMain.handle('select-directory', async () => {
  const result = await dialog.showOpenDialog(mainWindow, {
    properties: ['openDirectory'],
    title: '选择工作目录'
  })
  if (result.canceled || result.filePaths.length === 0) {
    return null
  }
  return result.filePaths[0]
})

ipcMain.handle('open-folder', (event, folderPath) => {
  if (folderPath) shell.openPath(folderPath)
})

ipcMain.handle('show-item-in-folder', (event, fullPath) => {
  if (fullPath) shell.showItemInFolder(fullPath)
})

ipcMain.handle('open-terminal', (event, folderPath) => {
  if (!folderPath) return
  spawn('open', ['-a', 'Terminal', folderPath], { detached: true, stdio: 'ignore' }).unref()
})

// ========== Terminal IPC handlers (node-pty) ==========

ipcMain.handle('terminal:create', async (event, options) => {
  const result = await terminalManager.create(options)
  const session = terminalManager.sessions.get(result.id)

  session.pty.onData((data) => {
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('terminal:data', { id: result.id, data })
    }
  })

  session.pty.onExit(({ exitCode }) => {
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('terminal:exit', { id: result.id, exitCode })
    }
    terminalManager.sessions.delete(result.id)
  })

  return result
})

ipcMain.on('terminal:data', (event, { id, data }) => {
  terminalManager.write(id, data)
})

ipcMain.on('terminal:resize', (event, { id, cols, rows }) => {
  terminalManager.resize(id, cols, rows)
})

ipcMain.handle('terminal:kill', (event, { id }) => {
  terminalManager.kill(id)
})

ipcMain.handle('terminal:list', () => {
  return terminalManager.list()
})

// ========== Local tool execution IPC handlers ==========

ipcMain.handle('local-read-file', async (event, { path: filePath, offset, limit }) => {
  try {
    const resolvedPath = resolveWorkspacePath(filePath)
    if (mimeFromPath(filePath)) {
      return readLocalImage(resolvedPath, filePath)
    }
    if (filePath.toLowerCase().endsWith('.pdf')) {
      // PDF 预览：按字节读取并以 base64 data_uri 返回，由渲染进程转为 Blob 交给 pdf.js
      const buffer = fs.readFileSync(resolvedPath)
      return {
        content: `PDF 文件：${filePath}`,
        total_lines: 0,
        media_type: 'pdf',
        mime: 'application/pdf',
        data_uri: `data:application/pdf;base64,${buffer.toString('base64')}`,
      }
    }
    const content = fs.readFileSync(resolvedPath, 'utf-8')
    const lines = content.split('\n')
    const totalLines = lines.length
    const start = offset || 0
    const end = limit ? Math.min(start + limit, totalLines) : totalLines
    const sliced = lines.slice(start, end).join('\n')
    return { content: sliced, total_lines: totalLines }
  } catch (e) {
    return { error: e.message }
  }
})

// LOCAL 二进制字节读取（技术方案 §5.2）：zip / xlsx / docx / 媒体预览的取数通道。
// 路径解析与 local-read-file 共用 resolveWorkspacePath；类型校验与大小上限在
// localFileBytes.cjs（可单测）。文件全程不出本机，无任何上传语义。
ipcMain.handle('local-read-bytes', async (event, { path: filePath }) => {
  try {
    const resolvedPath = resolveWorkspacePath(filePath)
    return readFileBytes(resolvedPath)
  } catch (e) {
    return { error: e.message }
  }
})

ipcMain.handle('local-write-file', async (event, { path: filePath, content }) => {
  const approved = await requestToolApproval('write_file', filePath)
  if (!approved) {
    return { success: false, error: 'User denied file write.' }
  }
  try {
    const resolvedPath = resolveWorkspacePath(filePath)
    const fileExisted = fs.existsSync(resolvedPath)
    const beforeContent = fileExisted ? fs.readFileSync(resolvedPath, 'utf-8') : ''
    const dir = path.dirname(resolvedPath)
    fs.mkdirSync(dir, { recursive: true })
    fs.writeFileSync(resolvedPath, content, 'utf-8')
    const linesAdded = content.length === 0 ? 0 : content.split('\n').length
    const lineDelta = fileExisted
      ? computeLineDelta(beforeContent, content)
      : { linesAdded, linesDeleted: 0 }
    return {
      success: true,
      bytes_written: Buffer.byteLength(content, 'utf-8'),
      file_change: {
        path: filePath,
        type: fileExisted ? 'MODIFIED' : 'CREATED',
        lines_added: lineDelta.linesAdded,
        lines_deleted: lineDelta.linesDeleted
      },
      [PRIVATE_DIFF_FIELD]: buildFileChangeDiff(filePath, beforeContent, content)
    }
  } catch (e) {
    return { error: e.message }
  }
})

ipcMain.handle('local-edit-file', async (event, { path: filePath, old_string, new_string, replace_all }) => {
  const approved = await requestToolApproval('edit_file', filePath)
  if (!approved) {
    return { success: false, error: 'User denied file edit.' }
  }
  try {
    return writeEditedFile(
      resolveWorkspacePath(filePath),
      filePath,
      old_string,
      new_string,
      asBoolArg(replace_all),
    )
  } catch (e) {
    return { error: e.message }
  }
})

const IGNORED_DIRS = new Set(['node_modules', '__pycache__', '.git', 'target', 'dist', 'build', '.next', '.nuxt', '.venv', 'venv', '.idea', '.vscode'])

ipcMain.handle('list-workspace-files', async (event, { workspace, filter, limit }) => {
  try {
    if (!workspace || !fs.existsSync(workspace)) return []
    const maxResults = limit || 20
    const results = []

    function walkDir(dir, relativeBase) {
      if (results.length >= maxResults) return
      let entries
      try {
        entries = fs.readdirSync(dir, { withFileTypes: true })
      } catch {
        return
      }
      // Sort entries: files first, then dirs, alphabetically
      entries.sort((a, b) => {
        if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? 1 : -1
        return a.name.localeCompare(b.name)
      })
      for (const entry of entries) {
        if (results.length >= maxResults) return
        if (entry.name.startsWith('.')) continue
        if (entry.isDirectory() && IGNORED_DIRS.has(entry.name)) continue
        const fullPath = path.join(dir, entry.name)
        const relPath = relativeBase ? relativeBase + '/' + entry.name : entry.name
        if (entry.isDirectory()) {
          walkDir(fullPath, relPath)
        } else {
          try {
            const stat = fs.statSync(fullPath)
            if (!filter || entry.name.toLowerCase().includes(filter.toLowerCase()) || relPath.toLowerCase().includes(filter.toLowerCase())) {
              results.push({ path: relPath, name: entry.name, size: stat.size, mtime: stat.mtimeMs })
            }
          } catch {
            // skip files we can't stat
          }
        }
      }
    }

    walkDir(workspace, '')
    // Sort by modification time descending
    results.sort((a, b) => b.mtime - a.mtime)
    // Remove mtime from response
    return results.map(({ mtime, ...rest }) => rest)
  } catch (e) {
    return []
  }
})

ipcMain.handle('list-directory', async (event, { dirPath, workspace }) => {
  try {
    if (!dirPath || !workspace) return { error: 'Missing dirPath or workspace' }
    const resolvedDir = path.resolve(dirPath)
    const resolvedWorkspace = path.resolve(workspace)
    if (!resolvedDir.startsWith(resolvedWorkspace + path.sep) && resolvedDir !== resolvedWorkspace) {
      return { error: 'Access denied: path outside workspace' }
    }
    if (!fs.existsSync(resolvedDir)) return { error: 'Directory does not exist' }

    const entries = fs.readdirSync(resolvedDir, { withFileTypes: true })
    const results = []
    const MAX_ENTRIES = 500

    for (const entry of entries) {
      if (results.length >= MAX_ENTRIES) break

      const fullPath = path.join(resolvedDir, entry.name)
      const relPath = path.relative(resolvedWorkspace, fullPath)
      let isSymlink = false
      let size = 0
      let mtime = 0

      try {
        const lstat = fs.lstatSync(fullPath)
        isSymlink = lstat.isSymbolicLink()
        size = lstat.size
        mtime = lstat.mtimeMs
      } catch {
        // skip entries we can't stat
        continue
      }

      results.push({
        name: entry.name,
        path: relPath,
        isDirectory: entry.isDirectory() && !isSymlink,
        size,
        mtime,
        isSymlink
      })
    }

    // Sort: folders first alphabetically, then files alphabetically
    results.sort((a, b) => {
      if (a.isDirectory !== b.isDirectory) return a.isDirectory ? -1 : 1
      return a.name.localeCompare(b.name)
    })

    return { entries: results, truncated: entries.length > MAX_ENTRIES }
  } catch (e) {
    return { error: e.message }
  }
})

// ========== MCP (Model Context Protocol) support ==========
// LOCAL 模式下桌面端作为 MCP 客户端代理：服务端下发 mcp_sync_required，
// 主进程用官方 Node SDK 建立连接并上报工具清单；工具执行走 tool-execute 委托。

const { Client: McpClient } = require('@modelcontextprotocol/sdk/client')
const { StdioClientTransport } = require('@modelcontextprotocol/sdk/client/stdio.js')
const { StreamableHTTPClientTransport } = require('@modelcontextprotocol/sdk/client/streamableHttp.js')
const { getDefaultEnvironment } = require('@modelcontextprotocol/sdk/client/stdio.js')

const MCP_TOOL_PREFIX = 'mcp__'
const MCP_CALL_TIMEOUT_MS = 120000

/**
 * sessionId -> serverName -> { client, transport, tools }
 * @type {Map<number, Map<string, {client: import('@modelcontextprotocol/sdk/client').Client, transport: any, tools: Array}>>}
 */
const mcpClients = new Map()

function mcpServerKey(serverName) {
  return String(serverName || '')
}

/** 解析 mcp__{serverName}__{toolName}，非法名返回 null */
function parseMcpToolName(toolName) {
  if (!toolName || !toolName.startsWith(MCP_TOOL_PREFIX)) return null
  const rest = toolName.slice(MCP_TOOL_PREFIX.length)
  const sep = rest.indexOf('__')
  if (sep <= 0) return null
  const serverName = rest.slice(0, sep)
  const innerName = rest.slice(sep + 2)
  if (!serverName || !innerName) return null
  return { serverName, toolName: innerName }
}

async function connectMcpServer(sessionId, server) {
  const { name, type, command, args, url, env } = server || {}
  if (!name) throw new Error('MCP server missing name')

  let transport
  if (type === 'STDIO') {
    if (!command) throw new Error(`MCP server "${name}": STDIO requires command`)
    // 合并默认安全环境（PATH/HOME 等），再叠加管理员配置的环境变量
    const mergedEnv = { ...getDefaultEnvironment() }
    if (env && typeof env === 'object') {
      for (const [k, v] of Object.entries(env)) {
        if (v != null) mergedEnv[k] = String(v)
      }
    }
    transport = new StdioClientTransport({
      command,
      args: Array.isArray(args) ? args.map(String) : [],
      env: mergedEnv,
      stderr: 'pipe'
    })
  } else if (type === 'HTTP') {
    if (!url) throw new Error(`MCP server "${name}": HTTP requires url`)
    transport = new StreamableHTTPClientTransport(new URL(url))
  } else {
    throw new Error(`MCP server "${name}": unsupported type "${type}"`)
  }

  const client = new McpClient({ name: 'mao-desktop', version: require('../package.json').version || '1.0.0' })
  await client.connect(transport)
  const list = await client.listTools()
  const tools = (list.tools || []).map((t) => ({
    name: t.name,
    description: t.description || '',
    schema: t.inputSchema || { type: 'object', properties: {} },
    // 透传 MCP 标准注解：服务端工作集用它标注 [只读]、审批据此对明确只读的工具免审。
    annotations: t.annotations || null
  }))
  return { client, transport, tools }
}

async function closeMcpSession(sessionId) {
  const connections = mcpClients.get(Number(sessionId))
  if (!connections) return
  mcpClients.delete(Number(sessionId))
  const names = Array.from(connections.keys())
  await Promise.allSettled(names.map(async (serverName) => {
    try {
      const conn = connections.get(serverName)
      if (conn?.client) {
        await conn.client.close()
      }
    } catch (e) {
      console.warn(`[mcp] close failed for ${serverName}:`, e.message)
    }
  }))
  console.log(`[mcp] closed ${names.length} connection(s) for session ${sessionId}`)
}

async function syncMcpServers(sessionId, servers) {
  const sid = Number(sessionId)
  // 先清理旧连接，避免重复同步时泄漏
  await closeMcpSession(sid)

  const connections = new Map()
  mcpClients.set(sid, connections)

  const reports = []
  for (const server of servers || []) {
    const name = server?.name
    if (!name) continue
    try {
      const conn = await connectMcpServer(sid, server)
      connections.set(mcpServerKey(name), conn)
      reports.push({ name, connected: true, tools: conn.tools, error: null })
      console.log(`[mcp] connected server "${name}" for session ${sid}, ${conn.tools.length} tool(s)`)
    } catch (e) {
      console.warn(`[mcp] connect failed for "${name}" (session ${sid}):`, e.message)
      reports.push({ name, connected: false, tools: [], error: e.message })
    }
  }
  return reports
}

async function callMcpTool(sessionId, serverName, toolName, args) {
  const sid = Number(sessionId)
  const connections = mcpClients.get(sid)
  const conn = connections && connections.get(mcpServerKey(serverName))
  if (!conn?.client) {
    throw new Error(`MCP server "${serverName}" is not connected (session ${sid}). Re-run the session to re-sync MCP servers.`)
  }
  const timer = setTimeout(() => {
    console.warn(`[mcp] call ${serverName}.${toolName} timed out after ${MCP_CALL_TIMEOUT_MS}ms`)
  }, MCP_CALL_TIMEOUT_MS)
  try {
    const result = await conn.client.callTool({ name: toolName, arguments: args }, undefined, {
      timeout: MCP_CALL_TIMEOUT_MS
    })
    if (result?.isError) {
      throw new Error(formatCallToolResult(result) || `MCP tool ${serverName}.${toolName} returned an error`)
    }
    // 传入完整 result，保留顶层 structuredContent（部分服务器主要或仅返回该字段）
    return formatCallToolResult(result)
  } finally {
    clearTimeout(timer)
  }
}

/**
 * 将 MCP CallToolResult 转为文本（与后端 Java McpClientManager.formatResult 语义一致）：
 * - 顶层 structuredContent 非空时优先序列化输出（结构化数据更利于模型理解）；
 * - 否则拼接 content 中的文本/图片/资源内容。
 */
function formatCallToolResult(result) {
  if (!result) return ''
  if (result.structuredContent != null) {
    try { return JSON.stringify(result.structuredContent, null, 2) } catch { /* fallthrough */ }
  }
  return formatMcpContent(result.content)
}

function formatMcpContent(content) {
  if (content == null) return ''
  if (typeof content === 'string') return content
  if (!Array.isArray(content)) {
    try { return JSON.stringify(content) } catch { return String(content) }
  }
  const parts = []
  for (const item of content) {
    if (!item) continue
    if (item.type === 'text' && typeof item.text === 'string') {
      parts.push(item.text)
    } else if (item.type === 'image' && item.data) {
      parts.push(`[image data: ${item.mimeType || 'unknown'}, ${item.data.length} chars base64]`)
    } else if (item.type === 'resource' && item.resource) {
      parts.push(`[resource: ${item.resource.uri || ''}]\n${item.resource.text || ''}`)
    } else if (item.structuredContent != null) {
      try { parts.push(JSON.stringify(item.structuredContent, null, 2)) } catch { /* ignore */ }
    } else {
      try { parts.push(JSON.stringify(item)) } catch { /* ignore */ }
    }
  }
  return parts.filter(Boolean).join('\n')
}

ipcMain.handle('mcp-sync', async (event, { sessionId, servers }) => {
  if (!sessionId) return { success: false, error: 'No sessionId provided for mcp-sync.' }
  try {
    const reports = await syncMcpServers(sessionId, servers || [])
    return { success: true, reports }
  } catch (e) {
    console.error('[mcp] mcp-sync failed:', e)
    return { success: false, error: e.message, reports: [] }
  }
})

ipcMain.handle('mcp-close', async (event, { sessionId }) => {
  try {
    await closeMcpSession(Number(sessionId))
    return { success: true }
  } catch (e) {
    return { success: false, error: e.message }
  }
})

// ========== Tool execution via Streaming WS ==========

async function executeToolByName(toolName, parsedArgs, sessionId, workspace, needApproval, dangerReason, requestId, approvalHint) {
  switch (toolName) {
    case 'shell':
      return await handleShellFromWebSocket(parsedArgs, sessionId, workspace, needApproval, dangerReason, requestId, approvalHint)
    case 'read_file':
      return await handleLocalReadFile(parsedArgs, workspace, sessionId)
    case 'write_file':
      return await handleLocalWriteFile(parsedArgs, workspace, sessionId, needApproval, requestId)
    case 'edit_file':
      return await handleLocalEditFile(parsedArgs, workspace, sessionId, needApproval, requestId)
    case 'glob_search':
      return await handleLocalGlobSearch(parsedArgs, workspace, sessionId)
    case 'grep_search':
      return await handleLocalGrepSearch(parsedArgs, workspace, sessionId)
    case 'write_local_text_file':
      // dump_user_messages 委托：文件名由消息 id 决定，重复导出覆盖同一文件（幂等，dedupe=false）。
      return await handleLocalWriteTextFile(parsedArgs, sessionId, false)
    default: {
      const mcp = parseMcpToolName(toolName)
      if (mcp) {
        return await handleMcpToolFromWebSocket(mcp, parsedArgs, sessionId, needApproval, dangerReason, requestId, approvalHint)
      }
      return { error: `Unknown tool: ${toolName}` }
    }
  }
}

async function handleMcpToolFromWebSocket(mcp, parsedArgs, sessionId, needApproval, dangerReason, requestId, approvalHint) {
  // 与 shell/write_file 等一致：needApproval 时先征求用户审批再执行
  if (needApproval) {
    const description = `调用 MCP 工具 ${mcp.serverName}.${mcp.toolName}`
    const approved = await requestToolApproval(`mcp:${mcp.serverName}`, description, sessionId, dangerReason, requestId, approvalHint)
    if (!approved) {
      return { error: 'User denied MCP tool execution.' }
    }
  }
  try {
    const result = await callMcpTool(sessionId, mcp.serverName, mcp.toolName, parsedArgs)
    return { result }
  } catch (e) {
    console.error(`[mcp] tool ${mcp.serverName}.${mcp.toolName} execution failed:`, e)
    return { error: e.message || 'MCP tool execution failed' }
  }
}

ipcMain.handle('tool-execute', async (event, { toolName, args, requestId, workspace, sessionId, needApproval, dangerReason, approvalHint }) => {
  // Use the workspace from this specific tool call, falling back to currentWorkspace
  const effectiveWorkspace = workspace || currentWorkspace
  console.log('[tool-execute] received workspace:', workspace, ', effectiveWorkspace:', effectiveWorkspace, ', currentWorkspace before:', currentWorkspace, ', needApproval:', needApproval, ', dangerReason:', dangerReason)
  if (workspace) {
    console.log('[tool-execute] setting currentWorkspace:', workspace, '(was:', currentWorkspace, ')')
    currentWorkspace = workspace
  }

  let parsedArgs
  try {
    parsedArgs = typeof args === 'string' ? JSON.parse(args) : args
  } catch {
    parsedArgs = {}
  }

  try {
    const result = await executeToolByName(toolName, parsedArgs, sessionId, effectiveWorkspace, !!needApproval, dangerReason, requestId, approvalHint)
    return { requestId, result: JSON.stringify(result), error: null }
  } catch (e) {
    console.error(`Tool ${toolName} execution failed:`, e)
    return { requestId, result: null, error: e.message }
  }
})

async function handleShellFromWebSocket(args, sessionId, workspace, needApproval, dangerReason, requestId, approvalHint) {
  return localShell.handle(args, {
    conversationId: sessionId,
    workspace,
    needApproval,
    approve: (description) => ensureShellApproval(needApproval, description, sessionId, dangerReason, requestId, approvalHint),
  })
}

function extractFilePath(args) {
  return args.path || args.file || args.filePath || args.file_path || args.target_file
}

const IMAGE_EXTENSIONS = {
  '.png': 'image/png',
  '.jpg': 'image/jpeg',
  '.jpeg': 'image/jpeg',
  '.gif': 'image/gif',
  '.webp': 'image/webp'
}
const MAX_IMAGE_BYTES = 5 * 1024 * 1024

function mimeFromPath(filePath) {
  const lower = filePath.toLowerCase()
  for (const [ext, mime] of Object.entries(IMAGE_EXTENSIONS)) {
    if (lower.endsWith(ext)) return mime
  }
  return null
}

function detectMimeFromBytes(buffer) {
  if (!buffer || buffer.length < 12) return null
  if (buffer[0] === 0x89 && buffer[1] === 0x50 && buffer[2] === 0x4e && buffer[3] === 0x47) return 'image/png'
  if (buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) return 'image/jpeg'
  if (buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46) return 'image/gif'
  if (buffer[0] === 0x52 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x46
      && buffer[8] === 0x57 && buffer[9] === 0x45 && buffer[10] === 0x42 && buffer[11] === 0x50) return 'image/webp'
  return null
}

function formatImageSize(bytes) {
  if (bytes < 1024) return `${bytes} B`
  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`
  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`
}

function readLocalImage(resolvedPath, filePath) {
  const sizeBytes = fs.statSync(resolvedPath).size
  if (sizeBytes > MAX_IMAGE_BYTES) {
    return {
      content: `错误：文件过大（${formatImageSize(sizeBytes)}），图片读取上限为 ${formatImageSize(MAX_IMAGE_BYTES)}：${filePath}`,
      total_lines: 0
    }
  }
  const buffer = fs.readFileSync(resolvedPath)
  const mime = detectMimeFromBytes(buffer)
  if (!mime) {
    return {
      content: `错误：不支持的图片格式或文件内容无效：${filePath}`,
      total_lines: 0
    }
  }

  let outBuffer = buffer
  let outMime = mime
  let width = null
  let height = null
  let dimNote = ''

  const resized = promptImageResizer.resizeForPrompt(buffer, mime, nativeImage)
  if (resized) {
    outBuffer = resized.buffer
    outMime = resized.mime
    width = resized.width
    height = resized.height
    if (resized.resized) {
      try {
        const orig = nativeImage.createFromBuffer(buffer)
        if (!orig.isEmpty()) {
          const { width: ow, height: oh } = orig.getSize()
          if (ow && oh && (ow !== width || oh !== height)) {
            dimNote = `, ${ow}×${oh}→${width}×${height}`
          }
        }
      } catch { /* ignore */ }
      if (!dimNote && width && height) {
        dimNote = `, ${width}×${height}`
      }
    } else if (width && height) {
      dimNote = `, ${width}×${height}`
    }
  }

  const outSize = outBuffer.length
  const dataUri = `data:${outMime};base64,${outBuffer.toString('base64')}`
  return {
    content: `图片读取成功：${filePath} (${outMime}, ${formatImageSize(outSize)}${dimNote})`,
    total_lines: 0,
    media_type: 'image',
    mime: outMime,
    path: filePath,
    size_bytes: outSize,
    ...(width != null ? { width } : {}),
    ...(height != null ? { height } : {}),
    data_uri: dataUri
  }
}

async function handleLocalReadFile(args, workspace, maoSessionId) {
  try {
    const filePath = extractFilePath(args)
    if (!filePath) {
      return { content: '错误：缺少必填参数 path', total_lines: 0 }
    }
    const resolvedPath = resolveWorkspacePath(filePath, workspace, maoSessionId)
    if (!fs.existsSync(resolvedPath)) {
      return { content: `错误：文件不存在：${filePath}`, total_lines: 0 }
    }
    if (!fs.statSync(resolvedPath).isFile()) {
      return { content: `错误：不是普通文件：${filePath}`, total_lines: 0 }
    }
    if (mimeFromPath(filePath)) {
      return readLocalImage(resolvedPath, filePath)
    }
    const content = fs.readFileSync(resolvedPath, 'utf-8')
    const lines = content.split('\n')
    const start = args.offset || 0
    const end = args.limit ? Math.min(start + args.limit, lines.length) : lines.length
    return { content: lines.slice(start, end).join('\n'), total_lines: lines.length }
  } catch (e) {
    return { content: `错误：${e.message}`, total_lines: 0 }
  }
}

async function handleLocalWriteFile(args, workspace, sessionId, needApproval, requestId) {
  if (needApproval) {
    const approved = await requestToolApproval('write_file', args.path, sessionId, null, requestId)
    if (!approved) {
      return { success: false, error: 'User denied file write.' }
    }
  }
  try {
    const resolvedPath = resolveWorkspacePath(args.path, workspace, sessionId)
    // Snapshot before write for change tracking
    const fileExisted = fs.existsSync(resolvedPath)
    let beforeContent = ''
    if (fileExisted) {
      beforeContent = fs.readFileSync(resolvedPath, 'utf-8')
    }
    const dir = path.dirname(resolvedPath)
    fs.mkdirSync(dir, { recursive: true })
    fs.writeFileSync(resolvedPath, args.content, 'utf-8')
    // Compute file change stats
    const newLineCount = args.content.length === 0 ? 0 : args.content.split('\n').length
    const lineDelta = fileExisted
      ? computeLineDelta(beforeContent, args.content)
      : { linesAdded: newLineCount, linesDeleted: 0 }
    return {
      success: true,
      bytes_written: Buffer.byteLength(args.content, 'utf-8'),
      file_change: {
        path: args.path,
        type: fileExisted ? 'MODIFIED' : 'CREATED',
        lines_added: lineDelta.linesAdded,
        lines_deleted: lineDelta.linesDeleted
      },
      [PRIVATE_DIFF_FIELD]: buildFileChangeDiff(args.path, beforeContent, args.content)
    }
  } catch (e) {
    return { error: e.message }
  }
}

async function handleLocalEditFile(args, workspace, sessionId, needApproval, requestId) {
  if (needApproval) {
    const approved = await requestToolApproval('edit_file', args.path, sessionId, null, requestId)
    if (!approved) {
      return { success: false, error: 'User denied file edit.' }
    }
  }
  try {
    const resolvedPath = resolveWorkspacePath(args.path, workspace, sessionId)
    return writeEditedFile(
      resolvedPath,
      args.path,
      args.old_string,
      args.new_string,
      asBoolArg(args.replace_all),
    )
  } catch (e) {
    return { error: e.message }
  }
}

/**
 * LOCAL 文本落盘（dump_user_messages 的委托入口 与 渲染层粘贴附件两个来源）：
 * 把文本写到 `~/.mao/attachments/<hostKey>/<sessionId>/<fileName>`，返回本机绝对路径。
 * 落点由主进程推导（home + server host + sessionId），渲染层/服务端无法指定；
 * 写入失败不抛异常，以 { error } 形态回传（与其它 LOCAL 工具一致）。
 *
 * @param {object} args { fileName, content, maxSizeMb }
 * @param {number|string} sessionId 会话 ID
 * @param {boolean} dedupe 同名避重：true 追加 -1/-2 副本（粘贴附件），false 覆盖（dump 幂等）
 */
async function handleLocalWriteTextFile(args, sessionId, dedupe) {
  const result = await chatAttachment.writeLocalTextFileAsync({
    fileName: args?.fileName,
    content: args?.content,
    maxSizeMb: args?.maxSizeMb,
    sessionId,
    dedupe,
    homeDir: os.homedir(),
    hostKey: getServerHostKey(),
  })
  if (!result.ok) return { error: result.error }
  return { success: true, path: result.absolutePath, bytes_written: result.bytes }
}

// --- glob_search / grep_search ---

let rgAvailable = null
async function isRgAvailable() {
  if (rgAvailable !== null) return rgAvailable
  try {
    const { execFile } = require('child_process')
    await new Promise((resolve, reject) => {
      execFile('rg', ['--version'], (err) => err ? reject(err) : resolve())
    })
    rgAvailable = true
  } catch {
    rgAvailable = false
  }
  return rgAvailable
}

async function handleLocalGlobSearch(args, workspace, maoSessionId) {
  const pattern = args.pattern
  if (!pattern) return { files: [], error: 'pattern is required' }

  const headLimit = args.head_limit || 100
  const resolvedPath = args.path
    ? resolveWorkspacePath(args.path, workspace, maoSessionId)
    : (workspace || currentWorkspace || '.')

  try {
    const scope = resolveSearchScope(resolvedPath)
    let files = []
    if (await isRgAvailable()) {
      files = await globWithRg(pattern, scope, headLimit)
    } else {
      files = globWithNode(pattern, scope, headLimit)
    }

    const truncated = files.length >= headLimit
    return {
      files,
      search_root: scope.cwd,
      truncated,
      total_matched: files.length
    }
  } catch (e) {
    return { files: [], error: e.message }
  }
}

function resolveSearchScope(resolvedPath) {
  let stat
  try {
    stat = fs.statSync(resolvedPath)
  } catch {
    throw new Error(`Search path does not exist or is not accessible: ${resolvedPath}`)
  }
  if (stat.isFile()) {
    const cwd = path.dirname(resolvedPath)
    return { cwd, rgTarget: path.basename(resolvedPath), singleFile: resolvedPath }
  }
  return { cwd: resolvedPath, rgTarget: '.', singleFile: null }
}

function outputFilePath(scope, rgFilePath, workspaceRoot) {
  if (scope.singleFile) {
    const normalized = path.normalize(scope.singleFile)
    if (workspaceRoot && normalized.startsWith(path.normalize(workspaceRoot))) {
      return path.relative(workspaceRoot, normalized)
    }
    return path.basename(normalized)
  }
  return relativizeRgPath(rgFilePath, scope.cwd)
}

function relativizeRgPath(filePath, searchRoot) {
  const trimmed = filePath.startsWith('./') ? filePath.slice(2) : filePath
  if (path.isAbsolute(trimmed)) {
    const normalized = path.normalize(trimmed)
    return normalized.startsWith(searchRoot) ? path.relative(searchRoot, normalized) : normalized
  }
  return path.normalize(trimmed)
}

function globWithRg(pattern, scope, headLimit) {
  return new Promise((resolve, reject) => {
    const { execFile } = require('child_process')
    execFile('rg', ['--files', '--glob', pattern, scope.rgTarget], { cwd: scope.cwd, maxBuffer: 10 * 1024 * 1024 }, (err, stdout) => {
      if (err && !stdout) return reject(err)
      const lines = (stdout || '').split('\n').filter(Boolean).slice(0, headLimit)
      resolve(lines.map(l => relativizeRgPath(l, scope.cwd)))
    })
  })
}

function globWithNode(pattern, scope, headLimit) {
  const { minimatch } = require('minimatch')
  const files = []
  const searchRoot = scope.cwd

  function walk(dir) {
    if (files.length >= headLimit) return
    let entries
    try { entries = fs.readdirSync(dir, { withFileTypes: true }) } catch { return }
    for (const entry of entries) {
      if (files.length >= headLimit) return
      const fullPath = path.join(dir, entry.name)
      if (entry.isDirectory()) {
        if (entry.name === 'node_modules' || entry.name === '.git') continue
        walk(fullPath)
      } else if (entry.isFile()) {
        const relative = path.relative(searchRoot, fullPath)
        if (minimatch(relative, pattern) || minimatch(entry.name, pattern)) {
          files.push(relative)
        }
      }
    }
  }

  walk(searchRoot)
  return files
}

async function handleLocalGrepSearch(args, workspace, maoSessionId) {
  const pattern = args.pattern
  if (!pattern) return { matches: [], error: 'pattern is required' }

  const glob = args.glob || null
  const ignoreCase = args.ignore_case || false
  const contextLines = args.context_lines || 0
  const maxOutputChars = args.max_output_chars || 10000
  const resolvedPath = args.path
    ? resolveWorkspacePath(args.path, workspace, maoSessionId)
    : (workspace || currentWorkspace || '.')
  const workspaceRoot = workspace || currentWorkspace || '.'

  try {
    const scope = resolveSearchScope(resolvedPath)
    if (await isRgAvailable()) {
      return await grepWithRg(pattern, scope, workspaceRoot, glob, ignoreCase, contextLines, maxOutputChars)
    } else {
      return grepWithNode(pattern, scope, workspaceRoot, glob, ignoreCase, contextLines, maxOutputChars)
    }
  } catch (e) {
    return { matches: [], error: e.message }
  }
}

function grepWithRg(pattern, scope, workspaceRoot, glob, ignoreCase, contextLines, maxOutputChars) {
  return new Promise((resolve, reject) => {
    const { execFile } = require('child_process')
    const cmd = ['--line-number', '--no-heading']
    if (ignoreCase) cmd.push('--ignore-case')
    if (contextLines > 0) { cmd.push('--context'); cmd.push(String(contextLines)) }
    if (glob) { cmd.push('--glob'); cmd.push(glob) }
    cmd.push(pattern)
    cmd.push(scope.rgTarget)

    execFile('rg', cmd, { cwd: scope.cwd, maxBuffer: 10 * 1024 * 1024 }, (err, stdout) => {
      if (err && !stdout) return resolve({ matches: [], truncated: false, total_matches: 0 })

      const lines = (stdout || '').split('\n').filter(Boolean)
      const matches = []
      let totalMatches = 0
      let charsUsed = 0
      let truncated = false

      for (const line of lines) {
        if (charsUsed + line.length + 1 > maxOutputChars) {
          truncated = true
          break
        }
        const parsed = parseRgLine(line, scope, workspaceRoot)
        if (parsed) {
          matches.push(parsed)
          totalMatches++
          charsUsed += line.length + 1
        }
      }

      resolve({ matches, truncated, total_matches: totalMatches })
    })
  })
}

function parseRgLine(line, scope, workspaceRoot) {
  if (scope.singleFile) {
    return parseRgSingleFileLine(line, scope, workspaceRoot)
  }

  const firstColon = line.indexOf(':')
  if (firstColon < 0) return null
  const secondColon = line.indexOf(':', firstColon + 1)
  if (secondColon < 0) return null

  const filePath = line.substring(0, firstColon)
  const lineNumStr = line.substring(firstColon + 1, secondColon)
  const content = line.substring(secondColon + 1)

  const lineNum = parseInt(lineNumStr, 10)
  if (isNaN(lineNum)) {
    const firstDash = line.indexOf('-')
    if (firstDash < 0) return null
    const secondDash = line.indexOf('-', firstDash + 1)
    if (secondDash < 0) return null
    const dashLineNum = parseInt(line.substring(firstDash + 1, secondDash), 10)
    if (isNaN(dashLineNum)) return null
    return { file: outputFilePath(scope, line.substring(0, firstDash), workspaceRoot), line: dashLineNum, content: line.substring(secondDash + 1) }
  }

  return { file: outputFilePath(scope, filePath, workspaceRoot), line: lineNum, content }
}

function parseRgSingleFileLine(line, scope, workspaceRoot) {
  const colon = line.indexOf(':')
  const dash = line.indexOf('-')
  let sepIdx
  if (colon > 0 && (dash < 0 || colon < dash)) {
    sepIdx = colon
  } else if (dash > 0) {
    sepIdx = dash
  } else {
    return null
  }

  const lineNum = parseInt(line.substring(0, sepIdx), 10)
  if (isNaN(lineNum)) return null

  return { file: outputFilePath(scope, '', workspaceRoot), line: lineNum, content: line.substring(sepIdx + 1) }
}

function grepWithNode(pattern, scope, workspaceRoot, glob, ignoreCase, contextLines, maxOutputChars) {
  const { minimatch } = require('minimatch')
  const flags = ignoreCase ? 'i' : ''
  let regex
  try {
    regex = new RegExp(pattern, flags)
  } catch {
    return { matches: [], error: 'Invalid regex pattern: ' + pattern }
  }

  const matches = []
  let totalMatches = 0
  let charsUsed = 0
  let truncated = false

  function scanFile(fullPath) {
    if (truncated) return
    if (glob && !minimatch(path.basename(fullPath), glob)) return

    let lines
    try { lines = fs.readFileSync(fullPath, 'utf-8').split('\n') } catch { return }

    const relative = outputFilePath(scope, fullPath, workspaceRoot)

    for (let i = 0; i < lines.length; i++) {
      if (regex.test(lines[i])) {
        const match = { file: relative, line: i + 1, content: lines[i] }

        if (contextLines > 0) {
          const before = []
          for (let c = Math.max(0, i - contextLines); c < i; c++) before.push(lines[c])
          const after = []
          for (let c = i + 1; c <= Math.min(lines.length - 1, i + contextLines); c++) after.push(lines[c])
          if (before.length > 0) match.context_before = before
          if (after.length > 0) match.context_after = after
        }

        const entrySize = JSON.stringify(match).length
        if (charsUsed + entrySize > maxOutputChars) {
          truncated = true
          break
        }

        matches.push(match)
        totalMatches++
        charsUsed += entrySize
      }
    }
  }

  function walk(dir) {
    if (truncated) return
    let entries
    try { entries = fs.readdirSync(dir, { withFileTypes: true }) } catch { return }

    for (const entry of entries) {
      if (truncated) return
      const fullPath = path.join(dir, entry.name)
      if (entry.isDirectory()) {
        if (entry.name === 'node_modules' || entry.name === '.git') continue
        walk(fullPath)
      } else if (entry.isFile()) {
        scanFile(fullPath)
      }
    }
  }

  if (scope.singleFile) {
    scanFile(scope.singleFile)
  } else {
    walk(scope.cwd)
  }
  return { matches, truncated, total_matches: totalMatches }
}