desktop/electron/gitStatus.cjs
Rama main · réplica de lectura del repositorio original.
const { execFile } = require('child_process')
const { spawn } = require('child_process')
const readline = require('readline')
const fs = require('fs')
const path = require('path')
const GIT_TIMEOUT_MS = 60_000
/** 测试可用 MAO_TEST_GIT_TIMEOUT_MS 覆盖以缩短挂起类用例的等待时间（小于 1s 视为无效）。 */
function gitTimeoutMs() {
const override = Number(process.env.MAO_TEST_GIT_TIMEOUT_MS)
return Number.isFinite(override) && override >= 1000 ? override : GIT_TIMEOUT_MS
}
const MAX_STDOUT_BYTES = 2 * 1024 * 1024
const MAX_DIFF_LINES = 5000
const MAX_DIFF_BYTES = 512 * 1024
const EXCLUDED_REPO_DIRS = new Set([
'.nvm', '.pyenv', '.rbenv', '.nodenv', '.jenv', '.tfenv', '.sdkman',
'.oh-my-zsh', '.zprezto', '.zim', '.zinit', '.antigen', '.fzf',
])
function runGit(cwd, args) {
return new Promise((resolve) => {
let settled = false
const finish = (result) => {
if (settled) return
settled = true
resolve(result)
}
const child = execFile(
'git',
['-c', 'core.quotepath=false', ...args],
{
cwd,
encoding: 'utf8',
maxBuffer: MAX_STDOUT_BYTES,
timeout: gitTimeoutMs(),
killSignal: 'SIGKILL',
env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
},
(err, stdout, stderr) => {
finish({
exitCode: err ? (typeof err.code === 'number' ? err.code : 1) : 0,
stdout: stdout || '',
stderr: stderr || '',
timedOut: Boolean(err && (err.killed || err.code === 'ETIMEDOUT')),
// execFile maxBuffer 溢出（2 MiB）以 ERR_CHILD_PROCESS_STDIO_MAXBUFFER 终结，
// 但回调仍带预算内的已收集 stdout：读大文件内容的调用方按「成功 + 截断」处理
// （见 getGitBranchCompareFileDiff），避免静默退化成空内容。
overflowed: Boolean(err && err.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER'),
})
},
)
child.on('error', (error) => {
finish({ exitCode: 127, stdout: '', stderr: error.message || '', timedOut: false, overflowed: false })
})
})
}
async function runGitOk(cwd, args) {
const result = await runGit(cwd, args)
if (result.exitCode !== 0) return null
return result.stdout
}
function truncateText(content) {
if (content == null) return { content: '', truncated: false }
let truncated = false
const lines = content.split('\n')
if (lines.length > MAX_DIFF_LINES) {
content = lines.slice(0, MAX_DIFF_LINES).join('\n')
truncated = true
}
const buf = Buffer.from(content, 'utf8')
if (buf.length > MAX_DIFF_BYTES) {
let end = MAX_DIFF_BYTES
while (end > 0 && (buf[end - 1] & 0xc0) === 0x80) end--
content = buf.subarray(0, end).toString('utf8')
truncated = true
}
return { content, truncated }
}
function isBinaryBuffer(buf) {
for (let i = 0; i < buf.length; i++) {
if (buf[i] === 0) return true
}
return false
}
function countLines(content) {
if (!content) return 0
let lines = 1
for (let i = 0; i < content.length; i++) {
if (content[i] === '\n') lines++
}
if (content.endsWith('\n') && lines > 1) lines--
return Math.max(lines, 1)
}
function readTextLimited(filePath) {
let fd
try {
const size = fs.statSync(filePath).size
const limit = Math.min(size, MAX_DIFF_BYTES + 1)
fd = fs.openSync(filePath, 'r')
const buf = Buffer.alloc(limit)
const bytesRead = fs.readSync(fd, buf, 0, limit, 0)
const content = buf.subarray(0, bytesRead)
if (isBinaryBuffer(content)) return { content: '', truncated: false, binary: true }
const result = truncateText(content.toString('utf8'))
return { ...result, truncated: result.truncated || size > bytesRead, binary: false }
} catch {
return { content: '', truncated: false, binary: true }
} finally {
if (fd != null) fs.closeSync(fd)
}
}
function parseNameStatusLine(line) {
const parts = line.split('\t')
if (parts.length < 2) return null
const status = parts[0].trim()
const code = status.charAt(0)
if (code === 'A') return { path: parts[1].replace(/\\/g, '/'), changeType: 'CREATED' }
if (code === 'M') return { path: parts[1].replace(/\\/g, '/'), changeType: 'MODIFIED' }
if (code === 'D') return { path: parts[1].replace(/\\/g, '/'), changeType: 'DELETED' }
if (code === 'R' && parts.length >= 3) {
return {
path: parts[2].replace(/\\/g, '/'),
oldPath: parts[1].replace(/\\/g, '/'),
changeType: 'RENAMED',
}
}
if (code === 'C' && parts.length >= 3) {
return {
path: parts[2].replace(/\\/g, '/'),
oldPath: parts[1].replace(/\\/g, '/'),
changeType: 'COPIED',
}
}
return { path: parts[parts.length - 1].replace(/\\/g, '/'), changeType: 'MODIFIED' }
}
async function collectChangedFiles(repoRoot) {
/** @type {Map<string, any>} */
const files = new Map()
let nameStatus = await runGitOk(repoRoot, ['diff', '--name-status', 'HEAD'])
if (!nameStatus && !(await runGitOk(repoRoot, ['rev-parse', '--verify', 'HEAD']))) {
// 空仓库（无 commit，HEAD 不存在）：diff --name-status HEAD 必然失败，
// 回退到 --cached 统计已 staged 的文件，与 getRepos（porcelain 计入 staged）口径一致
nameStatus = await runGitOk(repoRoot, ['diff', '--name-status', '--cached'])
}
if (nameStatus) {
for (const raw of nameStatus.split('\n')) {
const line = raw.trim()
if (!line) continue
const file = parseNameStatusLine(line)
if (file) files.set(file.path, { insertions: 0, deletions: 0, ...file })
}
}
let numstat = await runGitOk(repoRoot, ['diff', '--numstat', 'HEAD'])
if (!numstat && !(await runGitOk(repoRoot, ['rev-parse', '--verify', 'HEAD']))) {
numstat = await runGitOk(repoRoot, ['diff', '--numstat', '--cached'])
}
if (numstat) {
for (const raw of numstat.split('\n')) {
const line = raw.trim()
if (!line) continue
const parts = line.split('\t')
if (parts.length < 3) continue
// 与后端 collectChangedFiles 同口径：numstat 的改名是紧凑形态（src/{a.txt => b.txt}），
// 简单切片会还原出带花括号的错键、丢合并，必须用 numstatNewPath 还原
const filePath = numstatNewPath(parts[parts.length - 1])
const file = files.get(filePath)
if (!file) continue
if (parts[0] === '-' || parts[1] === '-') {
file.binary = true
file.insertions = 0
file.deletions = 0
} else {
file.insertions = parseInt(parts[0], 10) || 0
file.deletions = parseInt(parts[1], 10) || 0
}
}
}
const untracked = await runGitOk(repoRoot, ['ls-files', '--others', '--exclude-standard'])
if (untracked) {
for (const raw of untracked.split('\n')) {
const filePath = raw.trim().replace(/\\/g, '/')
if (!filePath || files.has(filePath)) continue
const abs = path.join(repoRoot, filePath)
const entry = {
path: filePath,
changeType: 'CREATED',
untracked: true,
insertions: 0,
deletions: 0,
}
if (fs.existsSync(abs) && fs.statSync(abs).isFile()) {
const read = readTextLimited(abs)
if (read.binary) {
entry.binary = true
} else {
entry.insertions = countLines(read.content)
}
}
files.set(filePath, entry)
}
}
return files
}
async function showHeadContent(repoRoot, filePath) {
if (!filePath) return null
const result = await runGit(repoRoot, ['show', `HEAD:${filePath}`])
if (result.exitCode !== 0) return null
return result.stdout
}
async function inferChangeType(repoRoot, filePath, absolute) {
const inHead = (await showHeadContent(repoRoot, filePath)) != null
const inWorktree = fs.existsSync(absolute) && fs.statSync(absolute).isFile()
if (!inHead && inWorktree) return 'CREATED'
if (inHead && !inWorktree) return 'DELETED'
return 'MODIFIED'
}
/**
* Resolve an optional repoPath (a first-level subdirectory name relative to the workspace).
* Returns the workspace itself when repoPath is absent. Throws on invalid paths.
* @param {string} workspace
* @param {string} [repoPath]
* @returns {string}
*/
function resolveRepoDir(workspace, repoPath) {
const ws = path.resolve(workspace)
if (!repoPath || typeof repoPath !== 'string' || !repoPath.trim()) {
return ws
}
const normalized = repoPath.replace(/\\/g, '/').replace(/^\/+/, '').replace(/\/+$/, '')
if (!normalized || normalized === '.' || normalized.includes('/') || normalized.split('/').includes('..')) {
throw new Error('路径访问被拒绝')
}
const repoDir = path.resolve(ws, normalized)
// 用 path.relative 判断越界：兼容根目录工作区（如 '/'）与 Windows 大小写差异
const rel = path.relative(ws, repoDir)
if (path.isAbsolute(rel) || rel === '..' || rel.startsWith('..' + path.sep)) {
throw new Error('路径访问被拒绝')
}
if (!fs.existsSync(repoDir) || !fs.statSync(repoDir).isDirectory()) {
throw new Error('路径访问被拒绝')
}
return repoDir
}
/**
* Discover first-level git repos under a non-git workspace.
* Mirrors the backend shape: { isRootGit, repos: [{ name, path, branch, changedFileCount }] }.
* 性能：每仓库仅 1 条 `git status --porcelain=v2 --branch` 命令（此前 4 条），
* 并发上限 8（此前无上限），大量仓库时进程数与峰值资源显著下降。
* @param {string} workspace
*/
async function listGitRepos(workspace) {
if (!workspace) {
return { isRootGit: false, repos: [] }
}
const ws = path.resolve(workspace)
const repoRootStr = await runGitOk(ws, ['rev-parse', '--show-toplevel'])
if (repoRootStr) {
return { isRootGit: true, repos: [] }
}
let entries = []
try {
entries = fs.readdirSync(ws, { withFileTypes: true })
} catch {
entries = []
}
const repoDirs = entries
.filter((e) => e.isDirectory())
.map((e) => e.name)
.filter((name) => !EXCLUDED_REPO_DIRS.has(name))
.filter((name) => {
try {
return fs.existsSync(path.join(ws, name, '.git'))
} catch {
return false
}
})
.sort((a, b) => a.localeCompare(b))
const summaries = (await mapLimit(repoDirs, 8, (name) => summarizeRepoDir(name, ws))).filter(Boolean)
return {
isRootGit: false,
repos: summaries,
}
}
/**
* 对单个仓库目录执行轻量统计：分支 + 变更文件数。
* 单条 `git status --porcelain=v2 --branch -M --untracked-files=all`：
* - 分支取自 `# branch.head`（detached 时 porcelain 输出 (detached)，映射为 "HEAD" 与存量 rev-parse 语义一致）；
* - 变更文件数 = 非 # 注释行数（tracked 行以 1/2 开头、untracked 行以 ? 开头）；
* - spawn + readline 逐行统计（内存 O(1)），不依赖完整输出，避免大量变更/untracked 文件时
* 输出超限被 Node 杀死（execFile maxBuffer 上限的回归点）；
* - 失败/超时返回 unavailable 占位条目，仓库不静默消失。
* @param {string} name
* @param {string} ws
* @returns {Promise<object>}
*/
function summarizeRepoDir(name, ws) {
const dir = path.join(ws, name)
return new Promise((resolve) => {
const child = spawn('git', ['-c', 'core.quotepath=false', 'status', '--porcelain=v2', '--branch', '-M', '--untracked-files=all'], {
cwd: dir,
env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
})
let branch
let changedFileCount = 0
const untrackedPaths = []
let timedOut = false
const timer = setTimeout(() => {
timedOut = true
child.kill('SIGKILL')
}, GIT_TIMEOUT_MS)
const rl = readline.createInterface({ input: child.stdout })
rl.on('line', (line) => {
if (!line) return
if (line.startsWith('#')) {
if (line.startsWith('# branch.head ')) {
const b = line.slice('# branch.head '.length).trim()
branch = b === '(detached)' ? 'HEAD' : b
}
return
}
changedFileCount++
if (line.startsWith('? ')) untrackedPaths.push(line.slice(2))
})
child.stderr.resume() // 不合并 stderr，避免 git 警告混入计数；仅丢弃
child.on('error', () => {
clearTimeout(timer)
resolve({ name, path: name, changedFileCount: 0, unavailable: true })
})
child.on('close', async (code) => {
clearTimeout(timer)
if (timedOut || code !== 0) {
resolve({ name, path: name, changedFileCount: 0, unavailable: true })
return
}
let insertions = 0
let deletions = 0
if (changedFileCount > 0) {
let numstat = await runGitOk(dir, ['diff', '--numstat', 'HEAD'])
if (!numstat && !(await runGitOk(dir, ['rev-parse', '--verify', 'HEAD']))) {
numstat = await runGitOk(dir, ['diff', '--numstat', '--cached'])
}
if (numstat) {
for (const line of numstat.split('\n')) {
const parts = line.split('\t')
if (parts.length < 3 || parts[0] === '-' || parts[1] === '-') continue
insertions += parseInt(parts[0], 10) || 0
deletions += parseInt(parts[1], 10) || 0
}
}
for (const relativePath of untrackedPaths) {
const file = path.resolve(dir, relativePath)
if ((!file.startsWith(dir + path.sep) && file !== dir) || !fs.existsSync(file) || !fs.statSync(file).isFile()) continue
const read = readTextLimited(file)
if (!read.binary) insertions += countLines(read.content)
}
}
resolve({ name, path: name, branch, changedFileCount, insertions, deletions })
})
})
}
/**
* 有界并发执行异步映射：同时最多 limit 个任务在跑，结果保持输入顺序。
* @template T, R
* @param {T[]} items
* @param {number} limit
* @param {(item: T, idx: number, list: T[]) => Promise<R>} fn
* @returns {Promise<R[]>}
*/
async function mapLimit(items, limit, fn) {
const results = new Array(items.length)
let next = 0
const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
while (next < items.length) {
const idx = next++
results[idx] = await fn(items[idx], idx, items)
}
})
await Promise.all(workers)
return results
}
/**
* @param {string} workspace
* @param {string} [repoPath]
*/
async function getGitStatus(workspace, repoPath) {
if (!workspace) {
return { isGit: false, remoteStatusAvailable: false }
}
let cwd
try {
cwd = resolveRepoDir(workspace, repoPath)
} catch (e) {
return { isGit: false, remoteStatusAvailable: false, error: e.message || '路径无效' }
}
const repoRootStr = await runGitOk(cwd, ['rev-parse', '--show-toplevel'])
if (!repoRootStr) {
return { isGit: false, remoteStatusAvailable: false }
}
const repoRoot = path.resolve(repoRootStr.trim())
let branchOut = await runGitOk(repoRoot, ['rev-parse', '--abbrev-ref', 'HEAD'])
if (!branchOut) {
// 空仓库（无 commit）时 rev-parse 失败，用 symbolic-ref 取 unborn 分支名，与 getRepos 口径一致
const symbolic = await runGitOk(repoRoot, ['symbolic-ref', '--short', 'HEAD'])
branchOut = symbolic
}
const filesMap = await collectChangedFiles(repoRoot)
const files = Array.from(filesMap.values())
const [remotesOut, upstreamOut, symbolicHead, headOut] = await Promise.all([
runGitOk(repoRoot, ['remote']),
runGitOk(repoRoot, ['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}']),
runGitOk(repoRoot, ['symbolic-ref', '--quiet', '--short', 'HEAD']),
runGitOk(repoRoot, ['rev-parse', '--verify', 'HEAD']),
])
const remotes = remotesOut ? remotesOut.split(/\r?\n/).map((item) => item.trim()).filter(Boolean) : []
const detachedHead = !symbolicHead
let insertions = 0
let deletions = 0
for (const f of files) {
insertions += f.insertions || 0
deletions += f.deletions || 0
}
return {
isGit: true,
repoRoot,
branch: branchOut ? branchOut.trim() : undefined,
insertions,
deletions,
changedFileCount: files.length,
files,
remotes,
hasRemote: remotes.length > 0,
hasHead: Boolean(headOut),
detachedHead,
upstream: upstreamOut ? upstreamOut.trim() : undefined,
remoteStatusAvailable: false,
}
}
function sanitizeRemoteError(text) {
return String(text || '')
.replace(/([a-z][a-z0-9+.-]*:\/\/)[^\s/@]+:[^\s/@]+@/gi, '$1***@')
.replace(/([a-z][a-z0-9+.-]*:\/\/)[^\s/@]+@/gi, '$1***@')
.trim()
.slice(0, 4000)
}
function selectFetchRemote(status) {
if (status.upstream) {
const upstreamRemote = status.remotes
.filter((remote) => status.upstream.startsWith(`${remote}/`))
.sort((a, b) => b.length - a.length)[0]
if (upstreamRemote) return upstreamRemote
}
if (status.remotes.includes('origin')) return 'origin'
if (status.remotes.length === 1) return status.remotes[0]
return undefined
}
/**
* Fetch every remote in parallel (one git process per remote) before calculating divergence
* from the configured upstream. Fetch failures preserve the already collected local status.
* @param {string} workspace
* @param {string} [repoPath]
*/
async function refreshGitStatus(workspace, repoPath) {
const status = await getGitStatus(workspace, repoPath)
if (!status.isGit) return status
if (status.remotes.length === 0) {
return { ...status, remoteStatusError: '未配置可同步的 Git 远端' }
}
// 并行 fetch 全部远端（每个远端一个独立子进程、各自 60s 超时）：任意多个远端挂起时
// 总等待以单个远端的超时为上界（串行会叠成 N×60s）；单个远端挂起/失败不影响其余远端，
// 失败/超时天然归属到具体远端，无需解析 git 的本地化错误输出。
const results = await Promise.all(status.remotes.map(async (remote) => ({
remote,
result: await runGit(status.repoRoot, ['fetch', '--prune', remote]),
})))
const failures = results.filter((entry) => entry.result.exitCode !== 0)
let partialError = null
if (failures.length > 0) {
if (failures.length === status.remotes.length) {
const first = failures[0]
return {
...status,
remoteStatusError: failures.length === 1
? (first.result.timedOut
? `Git fetch 超过 ${Math.round(gitTimeoutMs() / 1000)} 秒，已终止`
: sanitizeRemoteError(first.result.stderr || first.result.stdout) || '获取远端更新失败')
: `全部远端获取失败：${failures.map((f) => f.remote).join('、')}`,
}
}
partialError = `部分远端获取失败：${failures.map((f) => f.remote).join('、')}（其余远端已更新）`
}
const refreshedStatus = await getGitStatus(workspace, repoPath)
if (!refreshedStatus.isGit) return refreshedStatus
// 部分远端失败：其余远端已更新，附加提示但不覆盖读取状态失败的原因
const withPartial = (extra) => (partialError == null || extra.remoteStatusError != null
? extra
: { ...extra, remoteStatusError: partialError })
if (!refreshedStatus.hasHead) {
return withPartial({ ...refreshedStatus, remoteStatusAvailable: true, hasCommitsToPush: false })
}
// 参照远端：仅用于「无 upstream 时」与远端同名分支比较；多远端且无法确定时为 null
const referenceRemote = selectFetchRemote(refreshedStatus)
if (!refreshedStatus.upstream) {
if (!referenceRemote) {
return withPartial({ ...refreshedStatus, remoteStatusAvailable: true, hasCommitsToPush: false })
}
const remoteBranch = `refs/remotes/${referenceRemote}/${refreshedStatus.branch}`
const exists = await runGit(refreshedStatus.repoRoot, ['rev-parse', '--verify', '--quiet', remoteBranch])
if (exists.exitCode !== 0) {
return withPartial({ ...refreshedStatus, remoteStatusAvailable: true, hasCommitsToPush: true })
}
const comparison = await runGit(refreshedStatus.repoRoot, ['rev-list', '--left-right', '--count', `HEAD...${remoteBranch}`])
const [ahead] = comparison.stdout.trim().split(/\s+/).map((value) => parseInt(value, 10))
if (comparison.exitCode !== 0 || !Number.isFinite(ahead)) {
return withPartial({ ...refreshedStatus, remoteStatusError: '读取 Git 远端状态失败' })
}
return withPartial({ ...refreshedStatus, remoteStatusAvailable: true, hasCommitsToPush: ahead > 0 })
}
const divergence = await runGit(refreshedStatus.repoRoot, ['rev-list', '--left-right', '--count', 'HEAD...@{upstream}'])
if (divergence.exitCode !== 0) {
return withPartial({
...refreshedStatus,
remoteStatusError: sanitizeRemoteError(divergence.stderr || divergence.stdout) || '读取 Git 远端状态失败',
})
}
const [aheadCount, behindCount] = divergence.stdout.trim().split(/\s+/).map((value) => parseInt(value, 10))
if (!Number.isFinite(aheadCount) || !Number.isFinite(behindCount)) {
return withPartial({ ...refreshedStatus, remoteStatusError: '读取 Git 远端状态失败' })
}
return withPartial({ ...refreshedStatus, remoteStatusAvailable: true, aheadCount, behindCount, hasCommitsToPush: aheadCount > 0 })
}
/**
* @param {string} workspace
* @param {string} [repoPath]
* @param {string} relativePath
*/
async function getGitFileDiff(workspace, repoPath, relativePath) {
if (!workspace) {
return { path: relativePath || '', changeType: 'MODIFIED', beforeContent: '', afterContent: '', unavailableReason: '工作区无效' }
}
if (!relativePath || relativePath.replace(/\\/g, '/').split('/').includes('..')) {
return { path: relativePath || '', changeType: 'MODIFIED', beforeContent: '', afterContent: '', unavailableReason: '路径无效' }
}
const normalized = relativePath.replace(/\\/g, '/').replace(/^\.\//, '')
let cwd
try {
cwd = resolveRepoDir(workspace, repoPath)
} catch (e) {
return { path: normalized, changeType: 'MODIFIED', beforeContent: '', afterContent: '', unavailableReason: e.message || '路径无效' }
}
const repoRootStr = await runGitOk(cwd, ['rev-parse', '--show-toplevel'])
if (!repoRootStr) {
return { path: normalized, changeType: 'MODIFIED', beforeContent: '', afterContent: '', unavailableReason: '当前工作区不是 Git 仓库' }
}
const repoRoot = path.resolve(repoRootStr.trim())
const absolute = path.resolve(repoRoot, normalized)
if (!absolute.startsWith(repoRoot + path.sep) && absolute !== repoRoot) {
return { path: normalized, changeType: 'MODIFIED', beforeContent: '', afterContent: '', unavailableReason: '路径访问被拒绝' }
}
const filesMap = await collectChangedFiles(repoRoot)
let meta = filesMap.get(normalized)
if (!meta) {
meta = {
path: normalized,
changeType: await inferChangeType(repoRoot, normalized, absolute),
}
}
let before = await showHeadContent(repoRoot, meta.oldPath || normalized)
let after = ''
let truncated = false
const afterMissing = !fs.existsSync(absolute) || !fs.statSync(absolute).isFile()
if (!afterMissing) {
const afterRead = readTextLimited(absolute)
if (afterRead.binary) {
return {
path: normalized,
changeType: meta.changeType,
beforeContent: '',
afterContent: '',
binary: true,
unavailableReason: '二进制文件，无法预览',
}
}
after = afterRead.content
if (afterRead.truncated) truncated = true
}
if (before != null && before.includes('\0')) {
return {
path: normalized,
changeType: meta.changeType,
beforeContent: '',
afterContent: '',
binary: true,
unavailableReason: '二进制文件，无法预览',
}
}
if (before == null) before = ''
const beforeTrunc = truncateText(before)
const afterTrunc = truncateText(after)
return {
path: normalized,
changeType: meta.changeType,
beforeContent: beforeTrunc.content,
afterContent: afterTrunc.content,
truncated: truncated || beforeTrunc.truncated || afterTrunc.truncated,
}
}
/**
* resolved 是否在 root 之内（含相等）。realpath 两侧都取，兼容 macOS /var → /private/var
* 这类符号链接（git 的 --show-toplevel 返回真实路径，而 workspace 可能是符号链接路径）。
*/
function isUnderDir(resolved, root) {
const rel = path.relative(root, resolved)
return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel))
}
function realPathOrSelf(target) {
try {
return fs.realpathSync(target)
} catch {
return target
}
}
/**
* Resolve the repo root for read-only queries. Throws when the workspace/repoPath
* is invalid or the target is not a git repository (IPC handlers surface the message).
* 与写路径 resolveRepository 同样校验 workspace 包含关系：rev-parse --show-toplevel
* 可能跳出工作区（工作区本身位于某个 git 仓库内部时），不校验会让只读方法作用到
* 外层仓库、getGitCommitFileDiff 读到工作区之外的受控文件内容。
* @param {string} workspace
* @param {string} [repoPath]
* @returns {Promise<string>}
*/
async function resolveRepoRoot(workspace, repoPath) {
if (!workspace) throw new Error('工作区无效')
const cwd = resolveRepoDir(workspace, repoPath)
const repoRootStr = await runGitOk(cwd, ['rev-parse', '--show-toplevel'])
if (!repoRootStr) throw new Error('当前工作区不是 Git 仓库')
const repoRoot = path.resolve(repoRootStr.trim())
const ws = path.resolve(workspace)
if (!isUnderDir(realPathOrSelf(repoRoot), realPathOrSelf(ws))) {
throw new Error('路径访问被拒绝')
}
return repoRoot
}
/**
* numstat 路径字段还原成完整新路径（与后端 numstatNewPath 同规则）：
* git 对检测到的改名输出紧凑形态 `old => new` 或 `prefix/{old => new}suffix`，
* name-status 的 R 行始终输出完整 old/new，必须还原才能键对齐。
*/
function numstatNewPath(raw) {
const value = String(raw || '').replace(/\\/g, '/').trim()
const arrow = value.lastIndexOf(' => ')
if (arrow < 0) return value
const braceStart = value.lastIndexOf('{', arrow)
const braceEnd = braceStart >= 0 ? value.indexOf('}', arrow) : -1
if (braceStart >= 0 && braceEnd > arrow) {
return value.slice(0, braceStart) + value.slice(arrow + 4, braceEnd) + value.slice(braceEnd + 1)
}
return value.slice(arrow + 4).trim()
}
function parseLogLine(line) {
const parts = line.split('\0')
if (parts.length < 6) return null
const [hash, shortHash, title, author, date, refs] = parts
if (!hash.trim()) return null
const entry = {
hash: hash.trim(),
shortHash: shortHash.trim(),
title,
author: author.trim(),
date: date.trim(),
}
if (refs && refs.trim()) entry.refs = refs
return entry
}
/**
* 解析 `git branch -vv` 一行（与后端 parseBranchVvLine 同规则）：
* `* main abc1234 [origin/main: ahead 1, behind 2] subject`
* detached 行 name 以 '(' 开头，由调用方跳过；空仓库未出生分支无 hash。
*/
function parseBranchVvLine(line) {
if (!line.trim()) return null
const isCurrent = line.startsWith('*')
let rest = line.replace(/^\*?\s+/, '')
const nameMatch = /^(\S+)\s*(.*)$/.exec(rest)
if (!nameMatch) return null
const name = nameMatch[1]
rest = nameMatch[2]
const hashMatch = /^([0-9a-f]{7,64})\s*(.*)$/.exec(rest)
let lastCommitHash
if (hashMatch) {
lastCommitHash = hashMatch[1]
rest = hashMatch[2]
}
let upstream
let ahead
let behind
const bracketMatch = /^\[([^\]]*)\]\s*(.*)$/.exec(rest)
if (bracketMatch) {
const inside = bracketMatch[1]
rest = bracketMatch[2]
const colonIdx = inside.indexOf(':')
const upstreamPart = (colonIdx >= 0 ? inside.slice(0, colonIdx) : inside).trim()
// 'gone' 是方括号内的跟踪态（upstream 在远端已被 prune），upstream 名本身仍展示
// （与 git branch -vv 输出一致）；ahead/behind 只在明确给出时解析，gone 时自然留空
if (upstreamPart && upstreamPart !== 'gone') upstream = upstreamPart
if (colonIdx >= 0) {
const aheadMatch = /ahead (\d+)/.exec(inside)
const behindMatch = /behind (\d+)/.exec(inside)
if (aheadMatch) ahead = parseInt(aheadMatch[1], 10)
if (behindMatch) behind = parseInt(behindMatch[1], 10)
}
}
const lastCommitTitle = rest.trim() || undefined
return { name, isCurrent, upstream, ahead, behind, lastCommitHash, lastCommitTitle }
}
function clampInt(value, fallback, min, max) {
const n = value == null ? fallback : Math.floor(value)
if (!Number.isFinite(n)) return fallback
return Math.min(max, Math.max(min, n))
}
/**
* 提交历史（分页，与后端 getLog 同命令同解析）。
* @param {string} workspace
* @param {string} [repoPath]
* @param {{limit?: number, offset?: number, path?: string, keyword?: string}} [options]
* @returns {Promise<object[]>}
*/
async function getGitLog(workspace, repoPath, options = {}) {
const repoRoot = await resolveRepoRoot(workspace, repoPath)
const limit = clampInt(options.limit, 50, 1, 200)
const offset = clampInt(options.offset, 0, 0, Number.MAX_SAFE_INTEGER)
const args = ['log', '--format=%H%x00%h%x00%s%x00%an%x00%aI%x00%D', '-n', String(limit), '--skip', String(offset)]
// 提交信息关键词：--fixed-strings 字面匹配（正则元字符不解释）、-i 大小写不敏感，
// trim 后截断 100 字符，空值不产生参数；keyword 组必须插在 `--` 之前。
const keyword = options.keyword ? String(options.keyword).trim().slice(0, 100) : ''
if (keyword) args.push(`--grep=${keyword}`, '--fixed-strings', '-i')
if (options.path && String(options.path).trim()) args.push('--', String(options.path).trim())
const out = await runGitOk(repoRoot, args)
if (!out || !out.trim()) return []
const entries = []
for (const line of out.split('\n')) {
if (!line) continue
const entry = parseLogLine(line)
if (entry) entries.push(entry)
}
return entries
}
/**
* 单次提交的文件变更清单。merge 提交必须带 --first-parent（combined diff 干净合并清单为空）。
* @param {string} workspace
* @param {string} [repoPath]
* @param {string} hash
* @returns {Promise<{hash: string, files: object[], body: string}>}
*/
async function getGitCommitFiles(workspace, repoPath, hash) {
const normalizedHash = String(hash || '').trim().toLowerCase()
if (!/^[0-9a-f]{7,64}$/.test(normalizedHash)) throw new Error('提交不存在')
const repoRoot = await resolveRepoRoot(workspace, repoPath)
const nameStatus = await runGitOk(repoRoot, ['show', '--first-parent', '--name-status', '--format=', normalizedHash])
const numstat = await runGitOk(repoRoot, ['show', '--first-parent', '--numstat', '--format=', normalizedHash])
if (nameStatus == null && numstat == null) throw new Error('提交不存在')
const files = new Map()
if (nameStatus && nameStatus.trim()) {
for (const raw of nameStatus.split('\n')) {
const line = raw.trim()
if (!line) continue
const file = parseNameStatusLine(line)
if (file) files.set(file.path, { insertions: 0, deletions: 0, ...file })
}
}
if (numstat && numstat.trim()) {
for (const raw of numstat.split('\n')) {
const line = raw.trim()
if (!line) continue
const parts = line.split('\t')
if (parts.length < 3) continue
const filePath = numstatNewPath(parts[parts.length - 1])
const file = files.get(filePath)
if (!file) continue
if (parts[0] === '-' || parts[1] === '-') {
file.binary = true
file.insertions = 0
file.deletions = 0
} else {
file.insertions = parseInt(parts[0], 10) || 0
file.deletions = parseInt(parts[1], 10) || 0
}
}
}
// 提交正文：%B 去除首行标题后的剩余部分（trim，空串表示无正文），与后端 getCommitFiles 同解析
const message = await runGitOk(repoRoot, ['show', '-s', '--format=%B', normalizedHash])
const body = message == null ? '' : message.split('\n').slice(1).join('\n').trim()
return { hash: normalizedHash, files: Array.from(files.values()), body }
}
/**
* 单提交单文件 diff：before = `git show <hash>^:<oldPath ?? path>`，after = `git show <hash>:<path>`（均取自 git 对象）。
* 改名提交必须传 oldPath（文件清单 R 行的旧路径）——新路径在父提交中不存在，不传会把 before
* 判空、changeType 退化成 CREATED，与同屏文件清单的「改名」徽章自相矛盾。
* 新增文件 before 为空（根提交同理），删除文件 after 为空（show 非零退出即空内容）。
* @param {string} workspace
* @param {string} [repoPath]
* @param {string} hash
* @param {string} relativePath
* @param {string} [oldPath]
* @returns {Promise<object>}
*/
async function getGitCommitFileDiff(workspace, repoPath, hash, relativePath, oldPath) {
const normalizedHash = String(hash || '').trim().toLowerCase()
if (!/^[0-9a-f]{7,64}$/.test(normalizedHash)) {
return { path: relativePath || '', changeType: 'MODIFIED', beforeContent: '', afterContent: '', unavailableReason: '提交不存在' }
}
if (!relativePath || relativePath.replace(/\\/g, '/').split('/').includes('..')) {
return { path: relativePath || '', changeType: 'MODIFIED', beforeContent: '', afterContent: '', unavailableReason: '路径无效' }
}
const normalized = relativePath.replace(/\\/g, '/').replace(/^\.\//, '')
const beforePath = oldPath == null || String(oldPath).trim().length === 0
? normalized
: String(oldPath).replace(/\\/g, '/').replace(/^\.\//, '')
if (beforePath.split('/').includes('..')) {
return { path: normalized, changeType: 'MODIFIED', beforeContent: '', afterContent: '', unavailableReason: '路径无效' }
}
let repoRoot
try {
repoRoot = await resolveRepoRoot(workspace, repoPath)
} catch (e) {
return { path: normalized, changeType: 'MODIFIED', beforeContent: '', afterContent: '', unavailableReason: e.message || '路径无效' }
}
const absolute = path.resolve(repoRoot, normalized)
if (!absolute.startsWith(repoRoot + path.sep) && absolute !== repoRoot) {
return { path: normalized, changeType: 'MODIFIED', beforeContent: '', afterContent: '', unavailableReason: '路径访问被拒绝' }
}
const before = await runGit(repoRoot, ['show', `${normalizedHash}^:${beforePath}`])
const after = await runGit(repoRoot, ['show', `${normalizedHash}:${normalized}`])
const beforeContent = before.exitCode === 0 ? before.stdout : null
const afterContent = after.exitCode === 0 ? after.stdout : null
const changeType = beforeContent == null && afterContent != null
? 'CREATED'
: beforeContent != null && afterContent == null
? 'DELETED'
: beforePath !== normalized ? 'RENAMED' : 'MODIFIED'
if (beforeContent != null && beforeContent.includes('\0')) {
return { path: normalized, changeType, beforeContent: '', afterContent: '', binary: true, unavailableReason: '二进制文件，无法预览' }
}
if (afterContent != null && afterContent.includes('\0')) {
return { path: normalized, changeType, beforeContent: '', afterContent: '', binary: true, unavailableReason: '二进制文件，无法预览' }
}
const beforeTrunc = truncateText(beforeContent == null ? '' : beforeContent)
const afterTrunc = truncateText(afterContent == null ? '' : afterContent)
return {
path: normalized,
changeType,
beforeContent: beforeTrunc.content,
afterContent: afterTrunc.content,
truncated: beforeTrunc.truncated || afterTrunc.truncated,
}
}
/**
* 分支名合法性（git check-ref-format 子集，只读侧的安全边界）。
*
* 规则与后端只读侧 `backend-ts/src/file/workspace-git.service.ts` 的同名实现互指（同一份规则
* 双端各一份，fixture 对跑；本文件是 .cjs、无法 import TS 工具模块）：字符类
* `^[A-Za-z0-9._/][A-Za-z0-9._/-]*$`（首字符白名单里没有 `-`，杜绝 `-x` 被 git 当选项——
* spawn 参数数组不过 shell 挡不住这一层）、长度 ≤ 200、非 `@`、无 `..`、无 `@{`、
* 不以 `/` 开头或结尾、无 `//`、不以 `.` 结尾、每个 `/` 组件非空且不以 `.` 开头、不以 `.lock` 结尾。
*
* 注意：本规则**严于**写侧的 `BRANCH_NAME_PATTERN`（`git-write-operation.service.ts`）与前端
* `desktop/src/utils/git-manager.ts` 的 isValidBranchName——那两处字符类以 `+` 收尾、首字符并不拒 `-`
* （实测 `-x` 可通过），本方案只读侧用更严正则，勿照抄现状。字符类仍窄于 check-ref-format
* （如 `+` 合法但被拒），与写侧同款的已知限制，下拉选分支时属于可忽略极端。
* @param {string} name
* @returns {boolean}
*/
function isValidBranchName(name) {
const value = String(name == null ? '' : name)
if (!value || value.length > 200) return false
if (!/^[A-Za-z0-9._/][A-Za-z0-9._/-]*$/.test(value)) return false
if (value === '@') return false
if (value.includes('..') || value.includes('@{')) return false
if (value.startsWith('/') || value.endsWith('/') || value.includes('//') || value.endsWith('.')) return false
return value.split('/').every((part) => part.length > 0 && !part.startsWith('.') && !part.endsWith('.lock'))
}
/**
* 分支名 → 对象 sha（**显式 ref 路径 + 两段式**解析，杜绝同名 tag 遮蔽分支）。
*
* 为什么不能用 `rev-parse --verify <name>`：git 的 refname 解析顺序是
* `<name>` → `refs/<name>` → `refs/tags/<name>` → `refs/heads/<name>` → `refs/remotes/<name>`，
* **tag 先于 heads**。仓库里存在与分支同名的 tag 时，`--verify <name>` / `diff <name> <name>` 这类
* 裸名字比较实际比的是 tag——用户下拉里选的是分支、结果比的却是 tag，是静默错误
* （且 git 还会往 stderr 打 `refname 'x' is ambiguous` 警告）。故这里先按 `refs/heads/<name>`（本地分支）
* 显式取，失败再试 `refs/remotes/<name>`（下拉里的 `origin/x` 远端跟踪分支形态；
* 两段都是完整 ref 路径，同名 tag 不可能命中）。
*
* 两段都失败 → 返回 null（调用方按各自契约映射「分支不存在」：compare 抛错、file-diff 返回降级对象）。
* 输出必须是对象 id（40 位 SHA-1 / 64 位 SHA-256 的 hex）；取不到（空输出 / 非 hex）同样视为未解析，
* 因为后续命令一律用 sha 拼接，拿脏字符串进参数数组就是另一类静默错误。
* @param {string} repoRoot
* @param {string} name
* @returns {Promise<string|null>}
*/
async function resolveBranchSha(repoRoot, name) {
for (const ref of [`refs/heads/${name}`, `refs/remotes/${name}`]) {
const result = await runGit(repoRoot, ['rev-parse', '--verify', ref])
if (result.exitCode !== 0) continue
const sha = result.stdout.trim()
if (/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(sha)) return sha
}
return null
}
/**
* 两个分支**当前内容**的全部差异（两点 `<base> <target>` 语义，方向 base → target）
* + 目标分支相对基准的领先/落后提交数。命令序列：
* ① 两个分支名各自两段式解析成 sha（`refs/heads/` → `refs/remotes/`，见 resolveBranchSha）
* ② rev-list --left-right --count ③ diff --name-status ④ diff --numstat，
* ②–④ 一律传解析出的 sha（不再传分支名，故同名 tag 的 `refname 'x' is ambiguous` 从根上不会出现）。
*
* 为什么清单是两点而非三点 `<base>...<target>`：三点只列「目标相对 merge-base 的独有改动」，
* 目标完全落后 / 双方分叉时基准侧独有的改动会整体消失（用户看不到反向差异）。
* 两点直接比较两棵树：base 有而 target 无 → D、target 有而 base 无 → A、内容不同 → M，
* 基准侧独有改动以反向修改/删除的形式出现，属固有行为、不做排除。
* 计数仍用 `rev-list --left-right --count <base>...<target>`（left = base 独有 = behind、
* right = target 独有 = ahead），与清单口径不同是刻意的：计数答「差几个提交」、清单答「内容差在哪」。
* 两点 diff 与上述 rev-list 对 unrelated histories 同样可用，故不再调用 merge-base、也不再判「无共同祖先」。
*
* 两处易错点：
* - **失败 ≠ 空差异**：`git diff A B` 无差异时输出为空且退出码 0，与「ref 不存在」必须可区分，
* 故先解析 ref 再 diff（顺序不可颠倒），且 rev-list / diff 一律走 `runGit` 读 `exitCode`；
* `runGitOk` 把非零 / 超时 / maxBuffer 溢出统一折成 null，会把这些失败误报成「没有差异」。
* - **rev-list 的 `...` 不是三点 diff**：`rev-list --left-right --count A...B` 只做可达性集合运算，
* 无共同祖先也能成功（有别于 `git diff A...B` 的 `fatal: ... no merge base` 报错）。
*
* 抛错形态与 `getGitCommitFiles` 一致（`Error`，main.cjs 的 catch 转成 `{ error }`）。
* 返回的 `base` / `target` 是用户传入的原始分支名（sha 只用于命令，不出现在结果里）。
* @param {string} workspace
* @param {string} [repoPath]
* @param {string} base 基准分支
* @param {string} target 目标分支
* @returns {Promise<{base: string, target: string, aheadCount: number, behindCount: number, files: object[]}>}
*/
async function getGitBranchCompare(workspace, repoPath, base, target) {
const baseRef = String(base == null ? '' : base).trim()
const targetRef = String(target == null ? '' : target).trim()
// 分支名不合法与 ref 不存在同样映射「分支不存在」（与后端 PARAM_INVALID 文案一致）
if (!isValidBranchName(baseRef) || !isValidBranchName(targetRef)) throw new Error('分支不存在')
const repoRoot = await resolveRepoRoot(workspace, repoPath)
// 分支名 → sha 用显式 ref 路径两段式解析（见 resolveBranchSha：同名 tag 会遮蔽分支），
// 两段都失败 → 与 ref 不存在同文案；随后所有 git 命令一律用 sha，不再出现分支名歧义
const baseSha = await resolveBranchSha(repoRoot, baseRef)
if (!baseSha) throw new Error('分支不存在')
const targetSha = await resolveBranchSha(repoRoot, targetRef)
if (!targetSha) throw new Error('分支不存在')
// 计数仍是三点集合运算：left = 基准独有（目标落后数），right = 目标独有（目标领先数）
const counts = await runGit(repoRoot, ['rev-list', '--left-right', '--count', `${baseSha}...${targetSha}`])
if (counts.exitCode !== 0) throw new Error('对比失败，请重试')
// 输出 `left\tright`
const countParts = counts.stdout.trim().split(/\s+/)
const behindCount = parseInt(countParts[0], 10) || 0
const aheadCount = parseInt(countParts[1], 10) || 0
// 清单是两点 diff：两个 sha 空格分隔（**不是** `<a>...<b>`），base 侧独有改动以 D / 反向 M 出现
const nameStatus = await runGit(repoRoot, ['diff', '--name-status', baseSha, targetSha])
if (nameStatus.exitCode !== 0) throw new Error('对比失败，请重试')
const numstat = await runGit(repoRoot, ['diff', '--numstat', baseSha, targetSha])
if (numstat.exitCode !== 0) throw new Error('对比失败，请重试')
// 以下合并逻辑逐行复刻 getGitCommitFiles（差异仅在命令：`show <hash>` → `diff <base> <target>`）：
// name-status 建 Map（rename 键为新路径）→ numstat 用 numstatNewPath 还原后回填行数 → `-` 判二进制
const files = new Map()
if (nameStatus.stdout && nameStatus.stdout.trim()) {
for (const raw of nameStatus.stdout.split('\n')) {
const line = raw.trim()
if (!line) continue
const file = parseNameStatusLine(line)
if (file) files.set(file.path, { insertions: 0, deletions: 0, ...file })
}
}
if (numstat.stdout && numstat.stdout.trim()) {
for (const raw of numstat.stdout.split('\n')) {
const line = raw.trim()
if (!line) continue
const parts = line.split('\t')
if (parts.length < 3) continue
// numstat 的改名是紧凑形态（src/{a.txt => b.txt}），必须用 numstatNewPath 还原才能与 name-status 键对齐
const filePath = numstatNewPath(parts[parts.length - 1])
const file = files.get(filePath)
if (!file) continue
if (parts[0] === '-' || parts[1] === '-') {
file.binary = true
file.insertions = 0
file.deletions = 0
} else {
file.insertions = parseInt(parts[0], 10) || 0
file.deletions = parseInt(parts[1], 10) || 0
}
}
}
return { base: baseRef, target: targetRef, aheadCount, behindCount, files: Array.from(files.values()) }
}
/**
* 分支对比的单文件 diff：before = `git show <baseSha>:<oldPath ?? path>`（**base tip**，不再是 merge-base），
* after = `git show <targetSha>:<path>`（均取自 git 对象、不读工作区；与 `getGitCommitFileDiff` 同结构，
* 只把 `<hash>^:` / `<hash>:` 换成 `<base 分支的 sha>:` / `<target 分支的 sha>:`）。两个分支名先用
* resolveBranchSha 两段式解析成 sha（显式 `refs/heads/` → `refs/remotes/`，同名 tag 不会遮蔽分支）。
*
* before 取 base tip 与文件清单的两点 diff 同口径：双方分叉且都改同一文件时，before 是基准分支的内容、
* 基准侧的独有改动会以反向修改/删除的形式出现在同一个 tab 里，与清单自洽（不再需要 merge-base）。
* rename 的 oldPath 是 base 侧旧路径（清单 R 行的旧路径）；base 侧已无该路径时 before 取空、
* 退化成 CREATED——两棵树直接比较的固有结果（该场景清单本身只会给出 A 新路径，不会带 oldPath）。
*
* 失败语义按 `getGitCommitFileDiff` 现状复刻：输入类失败（非法分支名 / 路径 `..` / 越界）返回带
* `unavailableReason` 的降级对象、不 throw；对象缺失（show 非零退出）不算错误——before 缺失按空内容
* 处理、由 CREATED/DELETED 推导表达；二进制 → `unavailableReason`；超限 → `truncated`；
* 真超时（非 maxBuffer 溢出）→ `'对比失败，请重试'`。返回的 `path` 恒为新路径（调用方用它生成 tab id / 标题）。
* @param {string} workspace
* @param {string} [repoPath]
* @param {string} base 基准分支
* @param {string} target 目标分支
* @param {string} relativePath 新路径（文件清单的 path）
* @param {string} [oldPath] rename 行的旧路径（base 侧旧路径）
* @returns {Promise<object>}
*/
async function getGitBranchCompareFileDiff(workspace, repoPath, base, target, relativePath, oldPath) {
const baseRef = String(base == null ? '' : base).trim()
const targetRef = String(target == null ? '' : target).trim()
const degraded = (reason, degradedPath) => ({
path: degradedPath,
changeType: 'MODIFIED',
beforeContent: '',
afterContent: '',
unavailableReason: reason,
})
if (!isValidBranchName(baseRef) || !isValidBranchName(targetRef)) {
return degraded('分支不存在', relativePath || '')
}
if (!relativePath || relativePath.replace(/\\/g, '/').split('/').includes('..')) {
return degraded('路径无效', relativePath || '')
}
const normalized = relativePath.replace(/\\/g, '/').replace(/^\.\//, '')
const beforePath = oldPath == null || String(oldPath).trim().length === 0
? normalized
: String(oldPath).replace(/\\/g, '/').replace(/^\.\//, '')
if (beforePath.split('/').includes('..')) {
return degraded('路径无效', normalized)
}
let repoRoot
try {
repoRoot = await resolveRepoRoot(workspace, repoPath)
} catch (e) {
return degraded(e.message || '路径无效', normalized)
}
const absolute = path.resolve(repoRoot, normalized)
if (!absolute.startsWith(repoRoot + path.sep) && absolute !== repoRoot) {
return degraded('路径访问被拒绝', normalized)
}
// 显式 ref 路径两段式解析（见 resolveBranchSha：同名 tag 会遮蔽分支），后续命令一律用 sha
const baseSha = await resolveBranchSha(repoRoot, baseRef)
if (!baseSha) return degraded('分支不存在', normalized)
const targetSha = await resolveBranchSha(repoRoot, targetRef)
if (!targetSha) return degraded('分支不存在', normalized)
// 两点语义：before 取 base tip、after 取 target tip（不再有 merge-base 步骤）
const before = await runGit(repoRoot, ['show', `${baseSha}:${beforePath}`])
const after = await runGit(repoRoot, ['show', `${targetSha}:${normalized}`])
// 真超时 ≠「文件不存在」：runGit 的 timeout 走 kill 分支、err.code 非数字，exitCode 会被折成 1，
// 与 show 失败（对象缺失）撞码，不能静默渲染成空 diff；maxBuffer 溢出（overflowed，stdout 是预算内
// 已收集内容）不属于超时，走下面的「成功 + 截断」分支，故显式排除。
if ((before.timedOut && !before.overflowed) || (after.timedOut && !after.overflowed)) {
return degraded('对比失败，请重试', normalized)
}
// >2 MiB 大文件：runGit 因 maxBuffer 溢出返回 overflowed（stdout 是预算内已收集的 2 MiB），
// 按「成功 + 截断」继续交给 truncateText，与 CLOUD（runGitRaw 保留预算内输出 → truncated）
// 行为一致（方案 §5.5 / §2.1）；否则会静默退化成空 diff、且不标记 truncated。
const beforeContent = before.exitCode === 0 || before.overflowed ? before.stdout : null
const afterContent = after.exitCode === 0 || after.overflowed ? after.stdout : null
const changeType = beforeContent == null && afterContent != null
? 'CREATED'
: beforeContent != null && afterContent == null
? 'DELETED'
: beforePath !== normalized ? 'RENAMED' : 'MODIFIED'
if (beforeContent != null && beforeContent.includes('\0')) {
return { path: normalized, changeType, beforeContent: '', afterContent: '', binary: true, unavailableReason: '二进制文件，无法预览' }
}
if (afterContent != null && afterContent.includes('\0')) {
return { path: normalized, changeType, beforeContent: '', afterContent: '', binary: true, unavailableReason: '二进制文件，无法预览' }
}
const beforeTrunc = truncateText(beforeContent == null ? '' : beforeContent)
const afterTrunc = truncateText(afterContent == null ? '' : afterContent)
return {
path: normalized,
changeType,
beforeContent: beforeTrunc.content,
afterContent: afterTrunc.content,
truncated: beforeTrunc.truncated || afterTrunc.truncated,
}
}
/**
* 分支列表：本地（git branch -vv）+ 远端（git branch -r -vv），与后端 getBranches 同解析。
* @param {string} workspace
* @param {string} [repoPath]
* @returns {Promise<object[]>}
*/
async function getGitBranches(workspace, repoPath) {
const repoRoot = await resolveRepoRoot(workspace, repoPath)
const [localOut, remoteOut, headOut, unbornOut] = await Promise.all([
runGitOk(repoRoot, ['branch', '-vv']),
runGitOk(repoRoot, ['branch', '-r', '-vv']),
runGitOk(repoRoot, ['rev-parse', '--abbrev-ref', 'HEAD']),
// 空仓库（未出生 HEAD）下 git branch -vv 无任何输出，用 symbolic-ref 补「即将出生的当前分支」
runGitOk(repoRoot, ['symbolic-ref', '--short', 'HEAD']),
])
const currentBranch = headOut ? headOut.trim() : ''
const branches = []
for (const line of (localOut || '').split('\n')) {
const parsed = parseBranchVvLine(line)
// detached 行形如 '* (HEAD detached at <hash>) <subject>'，不是分支，跳过
if (!parsed || parsed.name.startsWith('(')) continue
branches.push({
name: parsed.name,
isCurrent: parsed.isCurrent || (currentBranch.length > 0 && currentBranch === parsed.name),
isRemote: false,
upstream: parsed.upstream,
ahead: parsed.ahead,
behind: parsed.behind,
lastCommitHash: parsed.lastCommitHash,
lastCommitTitle: parsed.lastCommitTitle,
})
}
if (branches.length === 0 && unbornOut && unbornOut.trim().length > 0) {
branches.push({
name: unbornOut.trim(),
isCurrent: true,
isRemote: false,
lastCommitHash: undefined,
lastCommitTitle: undefined,
})
}
for (const line of (remoteOut || '').split('\n')) {
// 跳过 origin/HEAD -> origin/main 符号行
if (line.includes('->')) continue
const parsed = parseBranchVvLine(line)
if (!parsed || parsed.name.startsWith('(')) continue
branches.push({
name: parsed.name,
isCurrent: false,
isRemote: true,
lastCommitHash: parsed.lastCommitHash,
lastCommitTitle: parsed.lastCommitTitle,
})
}
return branches
}
/**
* stash 列表（%gd 索引 / %gs 消息 / %aI 时间）。
* @param {string} workspace
* @param {string} [repoPath]
* @returns {Promise<object[]>}
*/
async function getGitStashes(workspace, repoPath) {
const repoRoot = await resolveRepoRoot(workspace, repoPath)
const out = await runGitOk(repoRoot, ['stash', 'list', '--format=%gd%x00%gs%x00%aI'])
if (!out || !out.trim()) return []
const entries = []
for (const line of out.split('\n')) {
if (!line) continue
const parts = line.split('\0')
const ref = (parts[0] || '').trim()
if (!ref) continue
entries.push({ ref, message: parts[1] || '', date: (parts[2] || '').trim() })
}
return entries
}
/**
* 远端列表（fetch/push URL 合并为一条；URL 过 sanitizeRemoteError 脱敏，与后端 CREDENTIAL_URL 同语义）。
* @param {string} workspace
* @param {string} [repoPath]
* @returns {Promise<object[]>}
*/
async function getGitRemotes(workspace, repoPath) {
const repoRoot = await resolveRepoRoot(workspace, repoPath)
const out = await runGitOk(repoRoot, ['remote', '-v'])
if (!out || !out.trim()) return []
const merged = new Map()
for (const line of out.split('\n')) {
const trimmed = line.trim()
if (!trimmed) continue
const match = /^(\S+)\s+(\S+)\s+\((fetch|push)\)$/.exec(trimmed)
if (!match) continue
const [, name, url, kind] = match
const entry = merged.get(name) || {}
if (kind === 'fetch') entry.fetch = url
else entry.push = url
merged.set(name, entry)
}
const remotes = []
for (const [name, urls] of merged) {
remotes.push({
name,
fetchUrl: sanitizeRemoteError(urls.fetch || urls.push || ''),
pushUrl: sanitizeRemoteError(urls.push || urls.fetch || ''),
})
}
return remotes
}
module.exports = {
EXCLUDED_REPO_DIRS,
collectChangedFiles,
getGitBranches,
getGitBranchCompare,
getGitBranchCompareFileDiff,
getGitCommitFileDiff,
getGitCommitFiles,
getGitFileDiff,
getGitLog,
getGitRemotes,
getGitStashes,
getGitStatus,
isValidBranchName,
listGitRepos,
numstatNewPath,
parseBranchVvLine,
parseLogLine,
refreshGitStatus,
resolveRepoDir,
resolveRepoRoot,
sanitizeRemoteError,
selectFetchRemote,
}