Skip to content

DeepSeek Harness Tauri 桌面版 | Only 8mb installer, zero environment setup, preset plugins, Windows / macOS / Linux.

15.4 KB
Raw Blame
/* eslint-disable no-control-regex */
import type { ReadinessPollResult, ReadinessProbeResult, StartupPhase } from './readiness'
import type { InternalPluginsPhasePayload, StartupError } from './types'
import type { PatchEntryStripReport, PatchQuarantineReport } from '@/types/plugin'
import { promiseTimeout } from '@reause/core'
import { invoke } from '@tauri-apps/api/core'
import i18next from 'i18next'
import { containsHeapOomError, containsInotifyLimitError, containsPortInUseError, heapPeakFromLogs, pickErrorLines } from '@/components/logs.utils'
import { toast } from '@/utils/toast'
import {
  HEALTH_PROBE_FAST_RETRY_INTERVAL,
  HEALTH_PROBE_INTERVAL,
  LOG_TAIL_MAX_BYTES,
  STARTUP_INACTIVITY_TIMEOUT,
} from './constants'
import {
  containsPatchEntryUnresolved,
  containsPatchLayerEncodingError,
  containsPatchLayerParseError,
  containsQuarantineFailure,
  patchEntryUnresolvedEntries,
  patchLayerErrorDetail,
  quarantineFailureDetail,
} from './patch-layer'
import { pollReadiness } from './readiness'

/**
 * 服务生命周期的无状态辅助函数:URL 生成、健康探测、日志读取、错误装饰。
 *
 * 全部与 store 实例无关(不读 `this`、不写状态),因此从 store 中抽出,
 * 便于单独推理与复用;store 只保留编排逻辑。
 */

/**
 * 构建带时间戳的 iframe URL,避免 WebView2 缓存旧页面。
 * alpha 鉴权由启动前的桌面端 patch 处理,iframe 永远不携带启动 token;旧核心
 * 同样继续使用原有的缓存查询参数。
 *
 * `dshDesktop` 是桌面载体的唯一凭据:宿主只给带该参数的 index 注入官方 Electron
 * 载体标记(`globalThis.dshDesktop`),因此用户用浏览器直开同一端口时不会被误判成
 * 桌面端而冒出账号登录入口。
 */
export function generateTimestampedUrl(baseUrl: string): string {
  const timestamp = Date.now()
  const separator = baseUrl.includes('?') ? '&' : '?'
  return `${baseUrl}${separator}t=${timestamp}&dshDesktop=1`
}

/**
 * 轮询 health check 确认 DSH 服务已真正停止,避免改写档案目录时撞文件锁。
 *
 *  - 使用剩余 timeout 约束 in-flight 的 probe(reause `promiseTimeout`),防止无限挂起
 *  - 仅当 health check 明确失败(非 transient 错误)时才视为已停止
 *  - 超时后继续执行(shutdown 可能仍在进行中)
 */
export async function waitForHarnessStopped(timeoutMs = 10_000, intervalMs = 500): Promise<void> {
  const start = Date.now()
  while (Date.now() - start < timeoutMs) {
    const remaining = timeoutMs - (Date.now() - start)
    if (remaining <= 0)
      break
    try {
      await Promise.race([invoke('proxy_health_check'), promiseTimeout(remaining, true, 'probe timeout')])
    }
    catch (e) {
      // probe 超时视为已停止
      if (e instanceof Error && e.message === 'probe timeout')
        return
      // 非 transient 错误视为已停止;transient 错误(502 等)继续重试
      if (!(e instanceof Error) || !/502|ECONNREFUSED|ETIMEDOUT/i.test(e.message))
        return
    }
    await promiseTimeout(intervalMs)
  }
}

/** 通过 Rust 代理探测服务健康状态(超时 8s,网络抖动时重试) */
export async function checkHealthViaProxy(): Promise<ReadinessProbeResult> {
  let timeoutId: ReturnType<typeof setTimeout> | undefined
  try {
    const timeoutPromise = new Promise<never>((_, reject) => {
      timeoutId = setTimeout(() => reject(new Error('health check timeout')), 8000)
    })
    const resultPromise = invoke<string | { status: string, boot_html: string, service_url: string }>('proxy_health_check')
    const result = await Promise.race([resultPromise, timeoutPromise])
    const status = typeof result === 'string' ? result : result.status
    const lower = status.toLowerCase()
    if (lower.startsWith('healthy')) {
      // 正常路径不写日志:就绪轮询每 1s 成功一次,成功噪音只会盖住真正有用的
      // 失败重试行。
      return {
        healthy: true,
        notOwned: false,
        phase: 'client-modules',
        reason: status,
        ...(typeof result === 'string' ? {} : { bootHtml: result.boot_html, bootOrigin: result.service_url }),
      }
    }
    console.warn('[Harness] health check returned:', status)
    return {
      healthy: false,
      notOwned: false,
      phase: 'client-modules',
      reason: status,
    }
  }
  catch (err) {
    const message = String(err)
    if (message.includes('HARNESS_NOT_OWNED')) {
      console.warn('[Harness] no owned dsh process, failing health check')
      return {
        healthy: false,
        notOwned: true,
        phase: 'process-boot',
        reason: message,
      }
    }
    if (message.includes('not listening yet')) {
      // 端口还没被监听:Rust 门禁直接判定,属启动早期正常态。静默返回并让轮询改用
      // 快扫间隔;若在这里记 warn,250ms 的节奏会刷满控制台。
      return {
        healthy: false,
        notOwned: false,
        notListening: true,
        phase: 'process-boot',
        reason: message,
      }
    }
    if (message.includes('boot page returned') || message.includes('HARNESS_BOOT_MANIFEST_REQUEST_FAILED')) {
      // 端口已在监听、启动页尚未登记:本轮只发了一次请求、没取任何 bundle,下一刻
      // 就可能就绪,快扫能把这 1s 空等压到 ~0.25s(实测启动尾段正是白等满一个常规
      // 间隔)。仍记一行 warn:这个窗口通常是插件 boot 登记的尾巴,是启动慢的实证。
      console.warn('[Harness] health check failed, retrying:', err)
      return {
        healthy: false,
        notOwned: false,
        bootPending: true,
        phase: 'process-boot',
        reason: message,
      }
    }
    if (message.includes('502') || message.includes('Bad Gateway')) {
      console.warn('[Harness] transient 502 during health check, retrying')
    }
    else {
      // 单次探测失败是启动期的常态:服务尚未就绪、部分 bundle 还没登记等都会走到
      // 这里,而轮询会一直重试到该阶段 deadline;真正的失败由 startupError 以
      // errors.startup_* 报出。逐次记 ERROR 只会造成「满屏错误但其实启动正常」。
      console.warn('[Harness] health check failed, retrying:', err)
    }
    return {
      healthy: false,
      notOwned: false,
      phase: message.includes('client modules') || message.includes('client plugins')
        ? 'client-modules'
        : 'process-boot',
      reason: message,
    }
  }
  finally {
    if (timeoutId !== undefined) {
      clearTimeout(timeoutId)
    }
  }
}

/** 按阶段 + 失败类型构造可展示的启动错误 */
export function startupError(
  phase: StartupPhase,
  reason: string,
  kind: 'failed' | 'inactivity' | 'absolute' | 'exited',
): StartupError {
  const phaseLabel = i18next.t(`startup.phase.${phase}`)
  const message = i18next.t(`errors.startup_${kind}`, {
    phase: phaseLabel,
    reason,
  })
  const error: StartupError = new Error(message)
  error.phase = phase
  error.lastReason = reason
  return error
}

/** 服务就绪轮询(探测实现固定为 Rust 代理健康检查) */
export function pollHarnessReadiness(
  absoluteTimeoutMs: number,
  shouldContinue: () => boolean,
  onProbe?: (result: ReadinessProbeResult) => void,
): Promise<ReadinessPollResult> {
  return pollReadiness({
    probe: checkHealthViaProxy,
    intervalMs: HEALTH_PROBE_INTERVAL,
    fastRetryIntervalMs: HEALTH_PROBE_FAST_RETRY_INTERVAL,
    inactivityTimeoutMs: STARTUP_INACTIVITY_TIMEOUT,
    absoluteTimeoutMs,
    shouldContinue,
    onProbe,
  })
}

/** 读取服务日志尾部(去掉 ANSI 转义与空行),启动失败时展示真实错误 */
export async function readServiceLogTail(): Promise<string[]> {
  try {
    const raw = await invoke<string>('read_service_logs', { maxBytes: LOG_TAIL_MAX_BYTES })
    return raw
      .split(/\r?\n/)
      .map(line => line.replace(/\x1B\[[0-9;]*m/g, '').trim())
      .filter(Boolean)
  }
  catch (err) {
    console.error('[Harness] failed to read service logs:', err)
    return []
  }
}

/** 失败时把服务日志的真实错误行与冲突提示挂到错误对象上 */
export async function attachStartupDiagnostics(err: unknown, processExited = false): Promise<StartupError> {
  // Tauri `invoke` 对 `Result<_, String>` 命令的 rejection 是裸字符串,
  // 必须先归一化为 Error 对象,否则在其上赋属性(ESM 严格模式)会抛
  // `TypeError: Cannot create property ... on string`,反而遮蔽真实错误。
  const diagnosed: StartupError = err instanceof Error ? err : new Error(String(err))
  if (!diagnosed.logs) {
    const lines = await readServiceLogTail()
    diagnosed.logLines = lines
    diagnosed.logs = pickErrorLines(lines)
    // 识别插件路由冲突(如 `duplicate prefix route "/sidebar/api"`),给出可操作的提示
    if (lines.join('\n').includes('duplicate prefix route')) {
      diagnosed.pluginConflictHint = i18next.t('errors.plugin_route_conflict')
    }
    // 识别 Linux inotify 文件监视上限(ENOSPC):harness 服务启动即崩溃且用户无法直接解决,
    // 需要系统级调高 fs.inotify.max_user_watches(见 errors.inotify_limit 文案)
    if (containsInotifyLimitError(lines)) {
      diagnosed.inotifyLimitHint = i18next.t('errors.inotify_limit')
    }
    if (processExited && containsHeapOomError(lines)) {
      // 提示里报出"崩溃时真正生效的上限":设置页里的值可能被 NODE_OPTIONS 顶掉,
      // 所以上限以后端启动链路同一份判定(get_effective_heap_limit_mb)为准。
      const effectiveLimitMb = await invoke<number | null>('get_effective_heap_limit_mb').catch(() => null)
      const peakMb = heapPeakFromLogs(lines)
      const hint = effectiveLimitMb
        ? i18next.t('errors.heap_oom', { limit: effectiveLimitMb })
        : i18next.t('errors.heap_oom_unknown')
      diagnosed.heapOomHint = peakMb === undefined ? hint : `${hint} ${i18next.t('errors.heap_oom_peak', { peak: peakMb })}`
    }
  }
  if (containsPatchLayerEncodingError(diagnosed.message)) {
    diagnosed.patchLayerHint = i18next.t('errors.patch_layer_encoding_failed', {
      detail: patchLayerErrorDetail(diagnosed.message),
    })
  }
  else if (containsPatchLayerParseError(diagnosed.message)) {
    diagnosed.patchLayerHint = i18next.t('errors.patch_layer_parse_failed', {
      detail: patchLayerErrorDetail(diagnosed.message),
    })
  }
  // 隔离没能完成(改名失败:文件被占用/权限不足):此时后端拒绝重启,否则立刻回到
  // 同一个解析失败。换成「先手动处理文件」的提示,别让用户以为已经恢复。
  if (containsQuarantineFailure(diagnosed.message)) {
    diagnosed.patchLayerHint = i18next.t('errors.patch_quarantine_failed', {
      detail: quarantineFailureDetail(diagnosed.message),
    })
  }
  // 补丁层悬空 insert(包被卸载、手写的引用还在):启动前预检已把「哪个文件、
  // 哪一行、哪个包」作为明细回传,这里转成可读提示;错误页据此给出「移除悬空
  // 条目」入口(与语法错误的「隔离」入口互斥,见 setup.tsx)。
  if (containsPatchEntryUnresolved(diagnosed.message)) {
    diagnosed.patchLayerHint = i18next.t('errors.patch_entry_unresolved', {
      detail: patchEntryUnresolvedDetail(diagnosed.message),
    })
  }
  return diagnosed
}

/** 把悬空条目明细拼成「文件 + 行号 + 包名」的提示串(明细不可解析时为空串)。 */
export function patchEntryUnresolvedDetail(message: string): string {
  return patchEntryUnresolvedEntries(message)
    .map(entry => i18next.t('errors.patch_entry_unresolved_item', {
      layer: entry.layer,
      line: entry.line,
      id: entry.id || entry.name,
      name: entry.name,
      note: entry.declared ? i18next.t('errors.patch_entry_unresolved_declared') : '',
    }))
    .join('; ')
}

/**
 * 把补丁层隔离结果告知用户:成功项逐个提示「原路径 → 备份路径」(改回原名即可
 * 恢复)。隔离是显式恢复动作,用户必须知道文件被移到了哪里;没有隔离项时完全不
 * 打扰(正常情况下点安全模式不会弹任何提示)。
 *
 * `failures` 兜底:改名失败时后端已改为返回错误(前端走
 * `errors.patch_quarantine_failed` 提示且不重启,见 `attachStartupDiagnostics`),
 * 所以成功路径上它总是空的;这里保留提示逻辑,避免契约变化时静默丢信息。
 */
export function notifyPatchQuarantine(report: PatchQuarantineReport): void {
  for (const layer of report.quarantined) {
    toast(
      i18next.t('patch.quarantined_toast', { backup: layer.backup, original: layer.original }),
      { variant: 'accent', timeout: 10_000 },
    )
  }
  for (const failure of report.failures) {
    toast(
      i18next.t('patch.quarantine_failed_toast', { path: failure.path, error: failure.error }),
      { variant: 'danger', timeout: 0 },
    )
  }
}

/**
 * 把补丁层清理结果告知用户:逐层提示「移除 N 条 + 备份路径」。
 *
 * 清理会改写用户手写的补丁层,因此必须说清原文件被备份到了哪里;没有清理项时
 * 完全不打扰(正常情况下点按钮总能清掉预检报出的那批条目)。
 */
export function notifyPatchEntryStrip(report: PatchEntryStripReport): void {
  for (const layer of report.layers) {
    toast(
      i18next.t('patch.entries_stripped_toast', {
        count: layer.removed,
        backup: layer.backup,
      }),
      { variant: 'accent', timeout: 10_000 },
    )
  }
}

export type InternalPluginPhaseTranslate = (
  key: string,
  options?: Record<string, number>,
) => string

/**
 * 内部插件装载阶段 → 展示文案(`internal-plugins-phase` 事件驱动)。
 *
 * `heartbeat` 只是「仍在进行」的心跳,不改变文案,原样返回上一句,避免文案反复闪烁。
 */
export function internalPluginReason(
  payload: InternalPluginsPhasePayload,
  previousReason: string,
  translate: InternalPluginPhaseTranslate,
): string {
  switch (payload.detail) {
    case 'waiting':
      return translate('status.internal_waiting')
    case 'checking':
      return translate('status.internal_checking', { total: payload.total })
    case 'installing':
      return translate('status.internal_installing', { total: payload.total })
    case 'heartbeat':
      return previousReason
    case 'done':
      return translate('status.internal_done', { total: payload.total })
    case 'timeout':
      return translate('status.internal_timeout')
    case 'cancelled':
      return translate('status.internal_cancelled')
  }
}

/** 端口冲突自愈的最大连续重启次数:超过则交回错误页,避免端口被反复抢占时无限重启。 */
const PORT_CONFLICT_RESTART_LIMIT = 3
let portConflictRestarts = 0

/** 每次成功就绪都要把预算清零,否则一次偶发冲突会永久抬高后续上限。 */
export function resetPortConflictRestarts(): void {
  portConflictRestarts = 0
}

/**
 * 本次崩溃是否应由「端口被占用」自愈:日志里确有 EADDRINUSE,且预算未用尽。
 *
 * 预算耗尽返回 false,让用户看到真实错误页——那种情况下端口是被外部进程长期占死,
 * 重启多少次都不会成功。
 */
export function consumePortConflictRestart(lines: readonly string[]): boolean {
  if (!containsPortInUseError(lines))
    return false
  if (portConflictRestarts >= PORT_CONFLICT_RESTART_LIMIT)
    return false
  portConflictRestarts += 1
  return true
}