@muyichengshayu/promptx 0.2.4 → 0.2.6

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.2.6
+
+- 修复切换任务时中栏消息偶发没有自动滚到底部的问题：任务切换后会进入一段短暂的强制跟底窗口，在 run 历史刷新、异步渲染和内容补齐期间持续补滚；如果用户主动手势滚动，则立即退出自动跟随，避免抢控制。
+- 代码变更弹窗新增二进制文件预览：图片支持变更前 / 变更后双栏预览并可点击查看大图，音频 / 视频 / PDF 支持内嵌预览，其它二进制文件会展示大小、类型与 hash 摘要，并提供受限范围内的文件下载入口。
+- 收紧二进制 diff 预览安全边界：新增的 blob 接口现在仅允许读取当前 diff 范围内的文件，不再可借由任务级 diff 预览访问仓库中的任意文件；同时补齐大文件限制、历史快照缺失时的失败兜底与相关服务端测试。
+- 优化二进制 diff 预览细节：文件列表会直接标记“二进制”并显示 MIME 类型；切换 `workspace / task / run` 或不同 run 时会正确重置预览状态，不再残留上一轮的图片或错误状态；图片预览层级也已提升，避免被代码变更弹窗遮挡。
+
+## 0.2.5
+
+- 工作台新增任务级未读提醒：当非当前聚焦任务的一次 agent turn 进入终态后，任务卡片会显示未读红点，浏览器页签标题也会切换为“你有新消息”，帮助在多任务并行时更快发现新进展。
+- 新增通知音能力与通用设置开关：通用设置里可单独控制是否播放任务未读提示音，默认关闭；同时补齐音频兼容、首次交互解锁与缓存刷新逻辑，减少浏览器不响或误触发的情况。
+- 收敛未读状态细节与稳定性：当前任务前台聚焦时不会误记未读；切换任务后中栏 Agent 过滤会自动回到“全部”；未读去重缓存改为可回收并设置上限，避免工作台长时间打开后内存状态持续膨胀。
+- 补齐未读通知相关回归测试，并修正页签标题国际化与主题色细节，确保中英文环境和不同主题下的体验更一致。
+
 ## 0.2.4
 
 - 重构远程命令安全模型：把远程 `shell` 命令放行从旧的 Relay 高权限开关收口到统一的 `remoteCommandSecurity` 配置，明确区分 `disabled / relay / trusted-proxy` 三种模式；本机 loopback 访问继续默认允许，远程入口则必须显式匹配对应安全模式。

package/apps/server/src/gitDiff.js

@@ -18,6 +18,25 @@ const DIFF_REVIEW_CACHE_TTL_MS = 4000
 const DIFF_REVIEW_CACHE_MAX_ENTRIES = 80
 const FILE_DIFF_CACHE_TTL_MS = 8000
 const FILE_DIFF_CACHE_MAX_ENTRIES = 400
+const MAX_BINARY_DIFF_BLOB_BYTES = Math.max(64 * 1024, Number(process.env.PROMPTX_GIT_DIFF_MAX_BINARY_BLOB_BYTES) || 8 * 1024 * 1024)
+
+const BINARY_PREVIEW_MIME_TYPES = new Map([
+  ['.avif', 'image/avif'],
+  ['.bmp', 'image/bmp'],
+  ['.gif', 'image/gif'],
+  ['.ico', 'image/x-icon'],
+  ['.jpeg', 'image/jpeg'],
+  ['.jpg', 'image/jpeg'],
+  ['.mp3', 'audio/mpeg'],
+  ['.mp4', 'video/mp4'],
+  ['.ogg', 'audio/ogg'],
+  ['.ogv', 'video/ogg'],
+  ['.pdf', 'application/pdf'],
+  ['.png', 'image/png'],
+  ['.wav', 'audio/wav'],
+  ['.webm', 'video/webm'],
+  ['.webp', 'image/webp'],
+])
 
 const diffReviewCache = new Map()
 const fileDiffCache = new Map()
@@ -103,6 +122,38 @@ function createHash(value) {
   return crypto.createHash('sha1').update(value).digest('hex')
 }
 
+function inferBinaryMimeType(filePath = '') {
+  return BINARY_PREVIEW_MIME_TYPES.get(path.extname(String(filePath || '').trim()).toLowerCase()) || 'application/octet-stream'
+}
+
+function inferBinaryPreviewKind(mimeType = '') {
+  const normalizedMimeType = String(mimeType || '').trim().toLowerCase()
+  if (normalizedMimeType.startsWith('image/')) {
+    return 'image'
+  }
+  if (normalizedMimeType.startsWith('audio/')) {
+    return 'audio'
+  }
+  if (normalizedMimeType.startsWith('video/')) {
+    return 'video'
+  }
+  if (normalizedMimeType === 'application/pdf') {
+    return 'pdf'
+  }
+  return 'binary'
+}
+
+function isKnownBinaryPreviewPath(filePath = '') {
+  return BINARY_PREVIEW_MIME_TYPES.has(path.extname(String(filePath || '').trim()).toLowerCase())
+}
+
+function createApiError(message = '', statusCode = 400, messageKey = 'errors.requestFailed') {
+  const error = new Error(message)
+  error.statusCode = statusCode
+  error.messageKey = messageKey
+  return error
+}
+
 function countTextLines(value = '') {
   const text = String(value || '')
   if (!text) {
@@ -419,7 +470,7 @@ function readFileState(repoRoot = '', filePath = '') {
     }
 
     const buffer = fs.readFileSync(absolutePath)
-    const isBinary = buffer.includes(0)
+    const isBinary = isKnownBinaryPreviewPath(filePath) || buffer.includes(0)
     const tooLarge = !isBinary && buffer.length > MAX_SNAPSHOT_TEXT_BYTES
 
     return {
@@ -489,7 +540,7 @@ function readHeadFileState(repoRoot = '', headOid = '', filePath = '') {
   }
 
   const buffer = result.stdout
-  const isBinary = buffer.includes(0)
+  const isBinary = isKnownBinaryPreviewPath(normalizedPath) || buffer.includes(0)
   const tooLarge = !isBinary && buffer.length > MAX_SNAPSHOT_TEXT_BYTES
 
   return {
@@ -502,6 +553,126 @@ function readHeadFileState(repoRoot = '', headOid = '', filePath = '') {
   }
 }
 
+function normalizeRepoFilePath(filePath = '') {
+  const rawPath = String(filePath || '').trim().replace(/\\/g, '/').replace(/^\/+/, '')
+  if (!rawPath || rawPath.includes('\0')) {
+    return ''
+  }
+
+  const normalizedPath = path.posix.normalize(rawPath)
+  if (!normalizedPath || normalizedPath === '.' || normalizedPath === '..' || normalizedPath.startsWith('../')) {
+    return ''
+  }
+
+  return normalizedPath
+}
+
+function createBlobPayload(filePath = '', side = '', buffer = Buffer.alloc(0)) {
+  const mimeType = inferBinaryMimeType(filePath)
+  return {
+    supported: true,
+    filePath,
+    side,
+    mimeType,
+    previewKind: inferBinaryPreviewKind(mimeType),
+    size: buffer.length,
+    hash: createHash(buffer),
+    body: buffer,
+  }
+}
+
+function createUnsupportedBlobPayload(message = '', statusCode = 404, messageKey = 'errors.gitDiffFailed') {
+  return {
+    supported: false,
+    statusCode,
+    messageKey,
+    message: String(message || '无法读取该文件内容。'),
+    filePath: '',
+    side: '',
+    mimeType: '',
+    previewKind: 'binary',
+    size: 0,
+    hash: '',
+    body: Buffer.alloc(0),
+  }
+}
+
+function enforceBlobSize(buffer = Buffer.alloc(0)) {
+  if (buffer.length > MAX_BINARY_DIFF_BLOB_BYTES) {
+    throw createApiError('文件较大，暂不支持在线预览。', 413, 'diffReview.binaryPreviewTooLarge')
+  }
+}
+
+function readHeadBlob(repoRoot = '', headOid = '', filePath = '', side = '') {
+  const normalizedHeadOid = String(headOid || '').trim()
+  const normalizedPath = normalizeRepoFilePath(filePath)
+  if (!repoRoot || !normalizedHeadOid || !normalizedPath) {
+    return createUnsupportedBlobPayload('文件不存在。', 404, 'errors.fileNotFound')
+  }
+
+  const result = runGitBuffer(repoRoot, ['show', `${normalizedHeadOid}:${normalizedPath}`], {
+    maxBuffer: MAX_BINARY_DIFF_BLOB_BYTES + 1024,
+  })
+  if (result.status !== 0) {
+    return createUnsupportedBlobPayload('文件不存在。', 404, 'errors.fileNotFound')
+  }
+
+  enforceBlobSize(result.stdout)
+  return createBlobPayload(normalizedPath, side, result.stdout)
+}
+
+function readWorkingTreeBlob(repoRoot = '', filePath = '', side = '') {
+  const normalizedPath = normalizeRepoFilePath(filePath)
+  if (!repoRoot || !normalizedPath) {
+    return createUnsupportedBlobPayload('文件不存在。', 404, 'errors.fileNotFound')
+  }
+
+  const root = path.resolve(repoRoot)
+  const absolutePath = path.resolve(root, normalizedPath)
+  if (absolutePath !== root && !absolutePath.startsWith(`${root}${path.sep}`)) {
+    return createUnsupportedBlobPayload('文件不存在。', 404, 'errors.fileNotFound')
+  }
+
+  try {
+    const stats = fs.statSync(absolutePath)
+    if (!stats.isFile()) {
+      return createUnsupportedBlobPayload('文件不存在。', 404, 'errors.fileNotFound')
+    }
+    if (stats.size > MAX_BINARY_DIFF_BLOB_BYTES) {
+      throw createApiError('文件较大，暂不支持在线预览。', 413, 'diffReview.binaryPreviewTooLarge')
+    }
+
+    return createBlobPayload(normalizedPath, side, fs.readFileSync(absolutePath))
+  } catch (error) {
+    if (error?.statusCode) {
+      throw error
+    }
+    return createUnsupportedBlobPayload('文件不存在。', 404, 'errors.fileNotFound')
+  }
+}
+
+function readSnapshotStateBlob(repoRoot = '', filePath = '', state = null, side = '') {
+  if (!state?.exists) {
+    return createUnsupportedBlobPayload('文件不存在。', 404, 'errors.fileNotFound')
+  }
+
+  if (!state.isBinary && !state.tooLarge) {
+    const buffer = Buffer.from(String(state.text || ''), 'utf8')
+    return createBlobPayload(filePath, side, buffer)
+  }
+
+  const livePayload = readWorkingTreeBlob(repoRoot, filePath, side)
+  if (livePayload.supported && String(livePayload.hash || '') === String(state.hash || '')) {
+    return livePayload
+  }
+
+  return createUnsupportedBlobPayload(
+    '历史快照中没有保存该二进制文件内容。',
+    404,
+    'diffReview.binarySnapshotUnavailable'
+  )
+}
+
 function createBaselineStateResolver(repoRoot = '', baseline = null) {
   const cache = new Map()
 
@@ -1379,6 +1550,40 @@ function sortDiffFiles(items = []) {
   })
 }
 
+function buildDiffFileSideMeta(filePath = '', state = null) {
+  const exists = Boolean(state?.exists)
+  const mimeType = exists ? inferBinaryMimeType(filePath) : ''
+  return {
+    exists,
+    size: exists ? Math.max(0, Number(state?.size) || 0) : 0,
+    hash: exists ? String(state?.hash || '') : '',
+    hashShort: exists ? String(state?.hash || '').slice(0, 7) : '',
+    mimeType,
+    previewKind: exists ? inferBinaryPreviewKind(mimeType) : 'none',
+    tooLarge: exists ? Math.max(0, Number(state?.size) || 0) > MAX_BINARY_DIFF_BLOB_BYTES : false,
+  }
+}
+
+function buildBinaryPreviewMeta(filePath = '', previousState = null, nextState = null, patchPayload = {}) {
+  const hasBinarySide = Boolean(previousState?.isBinary || nextState?.isBinary || patchPayload.binary)
+  if (!hasBinarySide) {
+    return null
+  }
+
+  const before = buildDiffFileSideMeta(filePath, previousState)
+  const after = buildDiffFileSideMeta(filePath, nextState)
+  const previewKind = after.exists ? after.previewKind : before.previewKind
+  const mimeType = after.exists ? after.mimeType : before.mimeType
+
+  return {
+    kind: previewKind,
+    mimeType,
+    maxPreviewBytes: MAX_BINARY_DIFF_BLOB_BYTES,
+    before,
+    after,
+  }
+}
+
 function createDiffFileEntry(filePath = '', previousState = null, nextState = null, options = {}) {
   if (areFileStatesEqual(previousState, nextState)) {
     return null
@@ -1413,6 +1618,7 @@ function createDiffFileEntry(filePath = '', previousState = null, nextState = nu
     patch: patchPayload.patch,
     patchLoaded: patchPayload.patchLoaded,
     message: patchPayload.message,
+    binaryPreview: buildBinaryPreviewMeta(filePath, previousState, nextState, patchPayload),
   }
 }
 
@@ -1921,6 +2127,100 @@ export function getTaskGitDiffReview(taskSlug = '', options = {}) {
   return payload
 }
 
+export function getTaskGitDiffBlob(taskSlug = '', options = {}) {
+  const normalizedTaskSlug = String(taskSlug || '').trim()
+  const filePath = normalizeRepoFilePath(options.filePath)
+  const side = String(options.side || '').trim() === 'before' ? 'before' : 'after'
+  const rawScope = String(options.scope || 'workspace').trim()
+  const scope = rawScope === 'run'
+    ? 'run'
+    : rawScope === 'task'
+      ? 'task'
+      : 'workspace'
+  const runId = String(options.runId || '').trim()
+
+  if (!normalizedTaskSlug || !filePath) {
+    return createUnsupportedBlobPayload('文件不存在。', 404, 'errors.fileNotFound')
+  }
+
+  const diffPayload = getTaskGitDiffReview(normalizedTaskSlug, {
+    scope,
+    runId,
+    filePath,
+    includeStats: false,
+  })
+  const fileInDiff = Boolean(
+    diffPayload?.supported
+    && Array.isArray(diffPayload.files)
+    && diffPayload.files.some((item) => String(item?.path || '').trim() === filePath)
+  )
+  if (!fileInDiff) {
+    return createUnsupportedBlobPayload('当前文件不在本次 diff 范围内。', 404, 'diffReview.fileNotInDiff')
+  }
+
+  if (scope === 'workspace') {
+    const repoRoot = resolveTaskRepoRoot(normalizedTaskSlug)
+    if (!repoRoot) {
+      return createUnsupportedBlobPayload('当前工作目录不是 Git 仓库，暂不支持代码变更审查。')
+    }
+    if (side === 'before') {
+      return readHeadBlob(repoRoot, resolveGitHeadOid(repoRoot), filePath, side)
+    }
+    return readWorkingTreeBlob(repoRoot, filePath, side)
+  }
+
+  let baseline = null
+  let comparisonSnapshot = null
+  if (scope === 'run') {
+    if (!runId || getRunTaskSlug(runId) !== normalizedTaskSlug) {
+      return createUnsupportedBlobPayload('没有找到对应的执行记录。', 404, 'diffReview.runNotFound')
+    }
+    baseline = loadRunBaseline(runId)
+    comparisonSnapshot = loadRunFinalSnapshot(runId)
+  } else {
+    baseline = loadTaskBaseline(normalizedTaskSlug)
+  }
+
+  if (!baseline) {
+    return createUnsupportedBlobPayload(
+      scope === 'run'
+        ? '这轮执行还没有建立代码变更基线，暂时无法查看本轮 diff。'
+        : '当前任务还没有建立代码变更基线，请先让 Codex 执行一轮。',
+      404,
+      scope === 'run' ? 'diffReview.runBaselineMissing' : 'diffReview.taskBaselineMissing'
+    )
+  }
+
+  if (scope === 'run' && !comparisonSnapshot) {
+    return createUnsupportedBlobPayload(
+      '这轮执行缺少结束快照，暂时无法准确还原本轮代码变更。',
+      404,
+      'diffReview.runSnapshotMissing'
+    )
+  }
+
+  const repoRoot = resolveGitRepoRoot(baseline.repoRoot)
+  if (!repoRoot) {
+    return createUnsupportedBlobPayload('原工作目录已不是有效的 Git 仓库，暂时无法读取代码变更。')
+  }
+
+  if (side === 'before') {
+    if (baseline.entries.has(filePath)) {
+      return readSnapshotStateBlob(repoRoot, filePath, baseline.entries.get(filePath), side)
+    }
+    return readHeadBlob(repoRoot, baseline.headOid, filePath, side)
+  }
+
+  if (scope === 'run') {
+    if (comparisonSnapshot.entries.has(filePath)) {
+      return readSnapshotStateBlob(repoRoot, filePath, comparisonSnapshot.entries.get(filePath), side)
+    }
+    return readHeadBlob(repoRoot, comparisonSnapshot.headOid, filePath, side)
+  }
+
+  return readWorkingTreeBlob(repoRoot, filePath, side)
+}
+
 export function __resetGitDiffCachesForTest() {
   diffReviewCache.clear()
   fileDiffCache.clear()

package/apps/server/src/index.js

@@ -22,6 +22,7 @@ import {
   updateTask,
 } from './repository.js'
 import {
+  getTaskGitDiffBlob,
   getWorkspaceGitDiffStatusSummaryByCwd,
 } from './gitDiff.js'
 import {
@@ -389,6 +390,7 @@ registerTaskRoutes(app, {
   getPromptxCodexSessionById,
   getRunningCodexRunByTaskSlug,
   getTaskBySlug,
+  getTaskGitDiffBlob,
   getTaskGitDiffReviewInSubprocess,
   listTaskCodexRunsWithOptions,
   listTaskWorkspaceDiffSummaries: taskWorkspaceDiffSummaryService.listTaskWorkspaceDiffSummaries,

package/apps/server/src/taskRoutes.js

@@ -204,6 +204,13 @@ function registerTaskRoutes(app, options = {}) {
     getSystemConfig = getSystemConfigForRuntime,
     getRunningCodexRunByTaskSlug,
     getTaskBySlug,
+    getTaskGitDiffBlob = () => ({
+      supported: false,
+      statusCode: 404,
+      messageKey: 'errors.gitDiffFailed',
+      message: '无法读取该文件内容。',
+      body: Buffer.alloc(0),
+    }),
     getTaskGitDiffReviewInSubprocess,
     listTaskCodexRunsWithOptions,
     listTaskWorkspaceDiffSummaries,
@@ -444,6 +451,51 @@ function registerTaskRoutes(app, options = {}) {
     }
   })
 
+  app.get('/api/tasks/:slug/git-diff/blob', async (request, reply) => {
+    purgeExpiredContent()
+    const task = getTaskBySlug(request.params.slug)
+    if (!task || task.expired) {
+      return reply.code(404).send({ messageKey: 'errors.taskNotFound', message: '任务不存在。' })
+    }
+
+    const scope = String(request.query?.scope || 'workspace').trim()
+    if (scope !== 'workspace' && scope !== 'task' && scope !== 'run') {
+      return reply.code(400).send({ messageKey: 'errors.invalidDiffScope', message: '无效的 diff 范围。' })
+    }
+
+    try {
+      const payload = getTaskGitDiffBlob(request.params.slug, {
+        scope,
+        runId: request.query?.runId,
+        filePath: request.query?.filePath,
+        side: request.query?.side,
+      })
+      if (!payload?.supported) {
+        return reply
+          .code(payload?.statusCode || 404)
+          .send({
+            messageKey: payload?.messageKey || 'errors.gitDiffFailed',
+            message: payload?.message || '无法读取该文件内容。',
+          })
+      }
+
+      return reply
+        .header('cache-control', 'no-store')
+        .header('x-promptx-file-size', String(payload.size || 0))
+        .header('x-promptx-file-hash', String(payload.hash || ''))
+        .type(payload.mimeType || 'application/octet-stream')
+        .send(payload.body)
+    } catch (error) {
+      if (error?.statusCode) {
+        return reply.code(error.statusCode).send(getApiErrorPayload(error, {
+          messageKey: error.messageKey || 'errors.gitDiffFailed',
+          message: String(error?.message || '无法读取该文件内容。'),
+        }))
+      }
+      throw error
+    }
+  })
+
   app.post('/api/tasks/:slug/codex-runs', async (request, reply) => {
     purgeExpiredContent()
     try {