agent-loft 0.2.89 → 0.2.93
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +10 -1
- package/package.json +23 -1
- package/src/channels/web/api.ts +14 -66
- package/src/channels/web/file-serve.ts +72 -0
- package/src/channels/web/tasks-api.ts +43 -11
- package/src/channels/web/workspace-api.ts +249 -0
- package/src/core/db.ts +19 -0
- package/src/core/footers.ts +26 -10
- package/src/core/git.ts +782 -0
- package/src/core/hub.ts +237 -31
- package/src/core/reply-files.ts +2 -1
- package/src/core/store.ts +8 -1
- package/src/core/task-runner.ts +5 -2
- package/src/core/tasks-bridge.ts +18 -4
- package/src/core/turn-changes.ts +179 -0
- package/src/core/types.ts +13 -0
- package/src/core/users.ts +15 -2
- package/src/core/workspace-files.ts +315 -0
- package/src/mcp/tasks-server.ts +6 -1
- package/web/css/experts.css +6 -3
- package/web/css/settings.css +31 -0
- package/web/css/tasks.css +21 -0
- package/web/css/workspace.css +1064 -0
- package/web/index.html +1 -0
- package/web/lib/api.js +1 -0
- package/web/lib/csv.js +53 -0
- package/web/lib/diff-parse.js +85 -0
- package/web/lib/dom.js +5 -0
- package/web/lib/eol.js +15 -0
- package/web/settings/users.js +23 -2
- package/web/vendor-built/LICENSE.codemirror +21 -0
- package/web/vendor-built/codemirror.js +41 -0
- package/web/views/diff-view.js +91 -0
- package/web/views/file-editor.js +146 -0
- package/web/views/file-preview.js +83 -6
- package/web/views/messages.js +55 -2
- package/web/views/sidebar-gestures.js +1 -1
- package/web/views/sidebar.js +1 -1
- package/web/views/tasks.js +108 -33
- package/web/views/topbar.js +10 -4
- package/web/views/workspace-entry.js +130 -0
- package/web/views/workspace.js +1346 -0
package/src/core/git.ts
ADDED
|
@@ -0,0 +1,782 @@
|
|
|
1
|
+
// 工作区面板的 Git 部分:当前分支、改动的文件、diff、分支和提交历史,每轮对话前后的快照,
|
|
2
|
+
// 以及用户在面板上点的操作(暂存、丢弃、提交、切换分支、撤销一轮)。
|
|
3
|
+
// 除了用户明确点的操作,不动工作区、暂存区和分支;快照只往仓库里写对象和 refs/agent-loft/ 下的引用。
|
|
4
|
+
//
|
|
5
|
+
// 仓库里的配置不可信(.git/config 可能来自解压的压缩包、agent 或别人),而 git 会按配置执行程序,
|
|
6
|
+
// 所以只用 execFile 不经过 shell,并且:
|
|
7
|
+
// - 关掉配置里能跑程序的项:core.fsmonitor、diff.external、textconv、仓库自己定义的 filter;
|
|
8
|
+
// - 不让 git 向上找到工作区之外的仓库(GIT_CEILING_DIRECTORIES),家目录是个仓库时不会把整个家目录列出来;
|
|
9
|
+
// - 去掉继承来的 GIT_* 环境变量,从 git 钩子里启动服务时也不会指到别的仓库;
|
|
10
|
+
// - 本服务自己的凭据不传下去(和 agent 子进程一样,见 agent-env.ts):用户勾选了运行钩子时,钩子也拿不到;
|
|
11
|
+
// - 不连网(GIT_ALLOW_PROTOCOL、GIT_NO_LAZY_FETCH):部分克隆缺对象时 git 会去远程地址拿,
|
|
12
|
+
// 而地址是配置里写的,ext:: 这种地址就是一条命令;
|
|
13
|
+
// - 不抢索引锁(GIT_OPTIONAL_LOCKS=0):面板在后台刷新,不能和正在干活的 agent 抢。
|
|
14
|
+
//
|
|
15
|
+
// 路径都相对仓库根目录。
|
|
16
|
+
import { execFile } from "node:child_process";
|
|
17
|
+
import fs from "node:fs";
|
|
18
|
+
import os from "node:os";
|
|
19
|
+
import path from "node:path";
|
|
20
|
+
import { agentEnvironment } from "./agent-env.js";
|
|
21
|
+
import { config } from "./config.js";
|
|
22
|
+
import { isSensitivePath } from "./reply-files.js";
|
|
23
|
+
|
|
24
|
+
const TIMEOUT_MS = 15_000;
|
|
25
|
+
/** status 的输出上限:大约几万个文件,多了也显示不过来 */
|
|
26
|
+
const STATUS_MAX_BYTES = 8 * 1024 * 1024;
|
|
27
|
+
/** 改动列表最多给这么多个文件 */
|
|
28
|
+
const STATUS_MAX_FILES = 2000;
|
|
29
|
+
/** 一个文件的 diff 最多给这么多 */
|
|
30
|
+
export const DIFF_MAX_BYTES = 2 * 1024 * 1024;
|
|
31
|
+
/** 没跟踪的文件超过这么大就不生成 diff 了 */
|
|
32
|
+
const UNTRACKED_MAX_BYTES = 5 * 1024 * 1024;
|
|
33
|
+
const BRANCHES_MAX = 500;
|
|
34
|
+
|
|
35
|
+
type RunResult = { code: number; stdout: string; stderr: string; truncated: boolean };
|
|
36
|
+
|
|
37
|
+
function gitEnv(): NodeJS.ProcessEnv {
|
|
38
|
+
const env: NodeJS.ProcessEnv = {};
|
|
39
|
+
for (const [k, v] of Object.entries(agentEnvironment())) if (!k.startsWith("GIT_")) env[k] = v;
|
|
40
|
+
env.GIT_OPTIONAL_LOCKS = "0";
|
|
41
|
+
env.GIT_NO_LAZY_FETCH = "1";
|
|
42
|
+
// 这里用到的命令都不需要连网。没有哪个协议叫这个名字,所以都不允许
|
|
43
|
+
env.GIT_ALLOW_PROTOCOL = "none";
|
|
44
|
+
env.GIT_TERMINAL_PROMPT = "0";
|
|
45
|
+
env.GIT_PAGER = "cat";
|
|
46
|
+
env.LC_ALL = "C";
|
|
47
|
+
try {
|
|
48
|
+
// 能找到工作区根目录上的仓库,但不会再往上找
|
|
49
|
+
env.GIT_CEILING_DIRECTORIES = path.dirname(fs.realpathSync(config().workspaceRoot));
|
|
50
|
+
} catch {
|
|
51
|
+
// 工作区目录没了:后面 git 自己会报错
|
|
52
|
+
}
|
|
53
|
+
return env;
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
function run(cwd: string, args: string[], maxBytes: number, opts: { env?: NodeJS.ProcessEnv; input?: string; timeoutMs?: number } = {}): Promise<RunResult> {
|
|
57
|
+
return new Promise((resolve, reject) => {
|
|
58
|
+
const child = execFile(
|
|
59
|
+
"git",
|
|
60
|
+
args,
|
|
61
|
+
{ cwd, env: { ...gitEnv(), ...opts.env }, timeout: opts.timeoutMs ?? TIMEOUT_MS, maxBuffer: maxBytes, encoding: "utf8", windowsHide: true },
|
|
62
|
+
(err, stdout, stderr) => {
|
|
63
|
+
if (!err) return resolve({ code: 0, stdout, stderr, truncated: false });
|
|
64
|
+
const e = err as NodeJS.ErrnoException & { code?: number | string; killed?: boolean };
|
|
65
|
+
if (e.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") return resolve({ code: 0, stdout, stderr, truncated: true });
|
|
66
|
+
if (typeof e.code === "number") return resolve({ code: e.code, stdout, stderr, truncated: false });
|
|
67
|
+
// 找不到 git,或者目录没了:spawn 报的都是这个
|
|
68
|
+
if (e.code === "ENOENT") return reject(new GitUnavailable());
|
|
69
|
+
reject(new Error(e.killed ? "git 执行超时" : e.message));
|
|
70
|
+
},
|
|
71
|
+
);
|
|
72
|
+
// 不给输入的命令也要关掉:git 不该等着读什么
|
|
73
|
+
child.stdin?.on("error", () => {});
|
|
74
|
+
child.stdin?.end(opts.input);
|
|
75
|
+
});
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
class GitUnavailable extends Error {
|
|
79
|
+
constructor() {
|
|
80
|
+
super("这台服务器上用不了 git(没有安装,或者目录已经不在了)");
|
|
81
|
+
}
|
|
82
|
+
}
|
|
83
|
+
|
|
84
|
+
/** 每次调用 git 都带上的配置:覆盖掉仓库配置里能跑程序的项 */
|
|
85
|
+
const SAFE_CONFIG = [
|
|
86
|
+
"core.fsmonitor=false",
|
|
87
|
+
"core.hooksPath=/dev/null",
|
|
88
|
+
"core.quotepath=false",
|
|
89
|
+
"core.pager=cat",
|
|
90
|
+
"diff.external=",
|
|
91
|
+
"status.submoduleSummary=false",
|
|
92
|
+
];
|
|
93
|
+
|
|
94
|
+
/** git lfs install --local 写进 .git/config 的标准内容:程序是固定的 git-lfs,放行,关了 LFS 文件都会显示成改过 */
|
|
95
|
+
const LFS_FILTER: Record<string, string> = {
|
|
96
|
+
"filter.lfs.clean": "git-lfs clean -- %f",
|
|
97
|
+
"filter.lfs.smudge": "git-lfs smudge -- %f",
|
|
98
|
+
"filter.lfs.process": "git-lfs filter-process",
|
|
99
|
+
"filter.lfs.required": "true",
|
|
100
|
+
};
|
|
101
|
+
|
|
102
|
+
/**
|
|
103
|
+
* 仓库自己的配置里(.git/config、worktree 配置,以及它们 include 进来的文件)符合 pattern 的项。
|
|
104
|
+
* 全局和系统配置是这台机器的主人写的,不算。注意 git config --local 默认不跟 include,不能用它来判断
|
|
105
|
+
*/
|
|
106
|
+
async function repoConfig(root: string, pattern: string): Promise<{ key: string; value: string }[]> {
|
|
107
|
+
const out = await run(root, ["config", "--show-scope", "--includes", "-z", "--get-regexp", pattern], 256 * 1024);
|
|
108
|
+
const items: { key: string; value: string }[] = [];
|
|
109
|
+
if (out.code === 0 || out.code === 1) {
|
|
110
|
+
const fields = out.stdout.split("\0");
|
|
111
|
+
for (let i = 0; i + 1 < fields.length; i += 2) {
|
|
112
|
+
const scope = fields[i]!;
|
|
113
|
+
if (scope === "global" || scope === "system") continue;
|
|
114
|
+
const entry = fields[i + 1]!;
|
|
115
|
+
const newline = entry.indexOf("\n");
|
|
116
|
+
items.push(newline < 0 ? { key: entry, value: "" } : { key: entry.slice(0, newline), value: entry.slice(newline + 1) });
|
|
117
|
+
}
|
|
118
|
+
return items;
|
|
119
|
+
}
|
|
120
|
+
// 太老的 git(2.26 以前)没有 --show-scope
|
|
121
|
+
const local = await run(root, ["config", "--local", "--includes", "-z", "--get-regexp", pattern], 256 * 1024);
|
|
122
|
+
for (const entry of local.stdout.split("\0")) {
|
|
123
|
+
if (!entry) continue;
|
|
124
|
+
const newline = entry.indexOf("\n");
|
|
125
|
+
items.push(newline < 0 ? { key: entry, value: "" } : { key: entry.slice(0, newline), value: entry.slice(newline + 1) });
|
|
126
|
+
}
|
|
127
|
+
return items;
|
|
128
|
+
}
|
|
129
|
+
|
|
130
|
+
/** 仓库自己配置里定义的 filter 的名字(git-crypt 之类)。标准的 git-lfs 不算 */
|
|
131
|
+
async function customFilters(root: string): Promise<Set<string>> {
|
|
132
|
+
const names = new Set<string>();
|
|
133
|
+
for (const { key, value } of await repoConfig(root, "^filter\\.")) {
|
|
134
|
+
const name = /^filter\.(.+)\.[^.]+$/.exec(key)?.[1];
|
|
135
|
+
if (name && LFS_FILTER[key] !== value) names.add(name);
|
|
136
|
+
}
|
|
137
|
+
return names;
|
|
138
|
+
}
|
|
139
|
+
|
|
140
|
+
/**
|
|
141
|
+
* 仓库自己定义的 filter 也能跑程序(status、diff 时会对改过的文件跑 clean):把这个仓库 .git/config 里的清空。
|
|
142
|
+
* 全局配置是这台机器的主人自己写的,不动(比如全局装的 git-lfs)。
|
|
143
|
+
*
|
|
144
|
+
* 这只适用于读:清空之后 git 看到的是没过滤的内容。写操作不能这样 ——
|
|
145
|
+
* git-crypt 的仓库清空了 filter 再 git add,提交进去的就是明文。写操作见 assertWritable。
|
|
146
|
+
*/
|
|
147
|
+
async function safeArgs(root: string): Promise<string[]> {
|
|
148
|
+
const args = SAFE_CONFIG.flatMap((c) => ["-c", c]);
|
|
149
|
+
for (const name of await customFilters(root)) {
|
|
150
|
+
args.push("-c", `filter.${name}.clean=`, "-c", `filter.${name}.smudge=`, "-c", `filter.${name}.process=`, "-c", `filter.${name}.required=false`);
|
|
151
|
+
}
|
|
152
|
+
return args;
|
|
153
|
+
}
|
|
154
|
+
|
|
155
|
+
// ---------- 仓库 ----------
|
|
156
|
+
|
|
157
|
+
export type GitRepo = { repo: true; root: string } | { repo: false; reason?: string };
|
|
158
|
+
|
|
159
|
+
/** cwd 所在的仓库。不是仓库不算错误;git 没装、仓库归属不对这些给个原因 */
|
|
160
|
+
export async function findRepo(cwd: string): Promise<GitRepo> {
|
|
161
|
+
let out: RunResult;
|
|
162
|
+
try {
|
|
163
|
+
out = await run(cwd, ["rev-parse", "--is-inside-work-tree", "--show-toplevel"], 64 * 1024);
|
|
164
|
+
} catch (err) {
|
|
165
|
+
return { repo: false, reason: err instanceof Error ? err.message : String(err) };
|
|
166
|
+
}
|
|
167
|
+
if (out.code !== 0) {
|
|
168
|
+
if (out.stderr.includes("dubious ownership")) return { repo: false, reason: "这个仓库的所有者和运行 agent-loft 的用户不同,git 拒绝读取" };
|
|
169
|
+
return { repo: false };
|
|
170
|
+
}
|
|
171
|
+
const [inTree, root] = out.stdout.split("\n");
|
|
172
|
+
if (inTree !== "true" || !root) return { repo: false };
|
|
173
|
+
// core.worktree 可以把工作树指到别处(比如 /):工作树得在工作区之内,否则改动列表、丢弃都会碰到外面去
|
|
174
|
+
try {
|
|
175
|
+
const realRoot = fs.realpathSync(config().workspaceRoot);
|
|
176
|
+
const realTree = fs.realpathSync(root);
|
|
177
|
+
if (realTree !== realRoot && !realTree.startsWith(realRoot.endsWith(path.sep) ? realRoot : realRoot + path.sep)) {
|
|
178
|
+
return { repo: false, reason: "这个仓库的工作树不在工作区之内,不能在这里操作" };
|
|
179
|
+
}
|
|
180
|
+
} catch {
|
|
181
|
+
return { repo: false };
|
|
182
|
+
}
|
|
183
|
+
return { repo: true, root };
|
|
184
|
+
}
|
|
185
|
+
|
|
186
|
+
// ---------- status ----------
|
|
187
|
+
|
|
188
|
+
export type GitFileState = "modified" | "added" | "deleted" | "renamed" | "copied" | "typechange" | "untracked" | "conflicted";
|
|
189
|
+
|
|
190
|
+
export type GitFileChange = {
|
|
191
|
+
path: string;
|
|
192
|
+
/** 重命名、复制前的路径 */
|
|
193
|
+
oldPath?: string;
|
|
194
|
+
/** 暂存区相对 HEAD 的改动 */
|
|
195
|
+
staged?: GitFileState;
|
|
196
|
+
/** 工作区相对暂存区的改动(没跟踪的、有冲突的也在这) */
|
|
197
|
+
unstaged?: GitFileState;
|
|
198
|
+
/** 密钥之类的文件:只显示有改动,不给看内容 */
|
|
199
|
+
sensitive?: boolean;
|
|
200
|
+
};
|
|
201
|
+
|
|
202
|
+
export type GitStatus = {
|
|
203
|
+
root: string;
|
|
204
|
+
/** 分支名。分离头指针时是 null,看 head */
|
|
205
|
+
branch: string | null;
|
|
206
|
+
/** 当前提交的短 hash;还没有提交时是 null */
|
|
207
|
+
head: string | null;
|
|
208
|
+
upstream?: string;
|
|
209
|
+
ahead: number;
|
|
210
|
+
behind: number;
|
|
211
|
+
files: GitFileChange[];
|
|
212
|
+
truncated: boolean;
|
|
213
|
+
};
|
|
214
|
+
|
|
215
|
+
const STATE: Record<string, GitFileState> = { M: "modified", A: "added", D: "deleted", R: "renamed", C: "copied", T: "typechange" };
|
|
216
|
+
|
|
217
|
+
/** 解析 git status --porcelain=v2 --branch -z 的输出。用 -z 路径不转义,始终相对仓库根目录 */
|
|
218
|
+
export function parseStatus(root: string, output: string): GitStatus {
|
|
219
|
+
const status: GitStatus = { root, branch: null, head: null, ahead: 0, behind: 0, files: [], truncated: false };
|
|
220
|
+
const fields = output.split("\0");
|
|
221
|
+
for (let i = 0; i < fields.length; i++) {
|
|
222
|
+
const line = fields[i]!;
|
|
223
|
+
if (line.startsWith("# ")) {
|
|
224
|
+
const [, key, ...rest] = line.split(" ");
|
|
225
|
+
if (key === "branch.oid" && rest[0] !== "(initial)") status.head = rest[0]!.slice(0, 7);
|
|
226
|
+
else if (key === "branch.head" && rest[0] !== "(detached)") status.branch = rest.join(" ");
|
|
227
|
+
else if (key === "branch.upstream") status.upstream = rest.join(" ");
|
|
228
|
+
else if (key === "branch.ab") {
|
|
229
|
+
status.ahead = Math.abs(Number(rest[0])) || 0;
|
|
230
|
+
status.behind = Math.abs(Number(rest[1])) || 0;
|
|
231
|
+
}
|
|
232
|
+
continue;
|
|
233
|
+
}
|
|
234
|
+
if (status.files.length >= STATUS_MAX_FILES) {
|
|
235
|
+
if (line) status.truncated = true;
|
|
236
|
+
continue;
|
|
237
|
+
}
|
|
238
|
+
const type = line[0];
|
|
239
|
+
if (type === "?") status.files.push({ path: line.slice(2), unstaged: "untracked" });
|
|
240
|
+
else if (type === "u") status.files.push({ path: fieldsAfter(line, 10), unstaged: "conflicted" });
|
|
241
|
+
else if (type === "1" || type === "2") {
|
|
242
|
+
const xy = line.slice(2, 4);
|
|
243
|
+
const change: GitFileChange = { path: fieldsAfter(line, type === "1" ? 8 : 9) };
|
|
244
|
+
const staged = STATE[xy[0]!];
|
|
245
|
+
const unstaged = STATE[xy[1]!];
|
|
246
|
+
if (staged) change.staged = staged;
|
|
247
|
+
if (unstaged) change.unstaged = unstaged;
|
|
248
|
+
// 重命名的第二段(原来的路径)是下一个字段
|
|
249
|
+
if (type === "2") change.oldPath = fields[++i];
|
|
250
|
+
status.files.push(change);
|
|
251
|
+
}
|
|
252
|
+
}
|
|
253
|
+
return status;
|
|
254
|
+
}
|
|
255
|
+
|
|
256
|
+
/** 去掉前 n 个空格分隔的字段,剩下的是路径(路径里可能有空格) */
|
|
257
|
+
function fieldsAfter(line: string, n: number): string {
|
|
258
|
+
let at = 0;
|
|
259
|
+
for (let i = 0; i < n; i++) at = line.indexOf(" ", at) + 1;
|
|
260
|
+
return line.slice(at);
|
|
261
|
+
}
|
|
262
|
+
|
|
263
|
+
export async function gitStatus(root: string): Promise<GitStatus> {
|
|
264
|
+
const out = await run(
|
|
265
|
+
root,
|
|
266
|
+
// 子模块里的改动不往里看:既慢,又会跑子模块自己的配置
|
|
267
|
+
[...(await safeArgs(root)), "status", "--porcelain=v2", "--branch", "-z", "--untracked-files=all", "--ignore-submodules=dirty"],
|
|
268
|
+
STATUS_MAX_BYTES,
|
|
269
|
+
);
|
|
270
|
+
if (out.code !== 0) throw new Error(out.stderr.trim() || "读取仓库状态失败");
|
|
271
|
+
// 输出被截断时最后一段不完整,丢掉
|
|
272
|
+
const text = out.truncated ? out.stdout.slice(0, out.stdout.lastIndexOf("\0") + 1) : out.stdout;
|
|
273
|
+
const status = parseStatus(root, text);
|
|
274
|
+
if (out.truncated) status.truncated = true;
|
|
275
|
+
for (const f of status.files) {
|
|
276
|
+
if (isSensitivePath(path.join(root, f.path)) || (f.oldPath && isSensitivePath(path.join(root, f.oldPath)))) f.sensitive = true;
|
|
277
|
+
}
|
|
278
|
+
return status;
|
|
279
|
+
}
|
|
280
|
+
|
|
281
|
+
// ---------- diff ----------
|
|
282
|
+
|
|
283
|
+
export type GitDiff = {
|
|
284
|
+
path: string;
|
|
285
|
+
/** unified diff 原文。二进制、不给看时是空的 */
|
|
286
|
+
diff: string;
|
|
287
|
+
truncated: boolean;
|
|
288
|
+
binary?: boolean;
|
|
289
|
+
/** 没有 diff 可看的原因:太大、敏感文件、不是普通文件 */
|
|
290
|
+
note?: string;
|
|
291
|
+
};
|
|
292
|
+
|
|
293
|
+
/**
|
|
294
|
+
* 一个文件的 diff。path 必须出现在当前的改动列表里:不接受任意路径,
|
|
295
|
+
* 免得传个目录(或已删除的目录)把里面的敏感文件一起带出来。文件不在列表里返回 undefined。
|
|
296
|
+
*/
|
|
297
|
+
export async function gitDiff(root: string, file: string, staged: boolean): Promise<GitDiff | undefined> {
|
|
298
|
+
const status = await gitStatus(root);
|
|
299
|
+
const change = status.files.find((f) => f.path === file);
|
|
300
|
+
if (!change || !(staged ? change.staged : change.unstaged)) return undefined;
|
|
301
|
+
if (change.sensitive) return { path: file, diff: "", truncated: false, note: "这是密钥一类的敏感文件,不显示内容" };
|
|
302
|
+
|
|
303
|
+
const common = ["--no-color", "--no-ext-diff", "--no-textconv", "--ignore-submodules=dirty"];
|
|
304
|
+
const safe = await safeArgs(root);
|
|
305
|
+
let out: RunResult;
|
|
306
|
+
if (change.unstaged === "untracked") {
|
|
307
|
+
const abs = path.join(root, file);
|
|
308
|
+
const st = fs.lstatSync(abs, { throwIfNoEntry: false });
|
|
309
|
+
if (!st) return undefined;
|
|
310
|
+
// 符号链接不跟过去:指向哪里不归这里管
|
|
311
|
+
if (!st.isFile()) return { path: file, diff: "", truncated: false, note: "这不是普通文件,没有内容可比较" };
|
|
312
|
+
if (st.size > UNTRACKED_MAX_BYTES) return { path: file, diff: "", truncated: false, note: "文件太大,不生成 diff" };
|
|
313
|
+
out = await run(root, [...safe, "diff", ...common, "--no-index", "--", "/dev/null", file], DIFF_MAX_BYTES);
|
|
314
|
+
// --no-index:有差异时退出码是 1
|
|
315
|
+
if (out.code === 1) out.code = 0;
|
|
316
|
+
} else {
|
|
317
|
+
const paths = change.oldPath ? [file, change.oldPath] : [file];
|
|
318
|
+
out = await run(root, [...safe, "--literal-pathspecs", "diff", ...common, ...(staged ? ["--cached", "-M"] : []), "--", ...paths], DIFF_MAX_BYTES);
|
|
319
|
+
}
|
|
320
|
+
if (out.code !== 0) throw new Error(out.stderr.trim() || "读取 diff 失败");
|
|
321
|
+
return diffResult(file, out);
|
|
322
|
+
}
|
|
323
|
+
|
|
324
|
+
function diffResult(file: string, out: RunResult): GitDiff {
|
|
325
|
+
let text = out.stdout;
|
|
326
|
+
let truncated = out.truncated;
|
|
327
|
+
// execFile 的上限数的是字符,中文一个字三个字节:这里再按字节卡一次
|
|
328
|
+
if (Buffer.byteLength(text) > DIFF_MAX_BYTES) {
|
|
329
|
+
text = Buffer.from(text).subarray(0, DIFF_MAX_BYTES).toString();
|
|
330
|
+
truncated = true;
|
|
331
|
+
}
|
|
332
|
+
// 截断时停在完整的一行上
|
|
333
|
+
if (truncated) text = text.slice(0, text.lastIndexOf("\n") + 1);
|
|
334
|
+
if (/^(?:Binary files .* differ|GIT binary patch)$/m.test(text.split("\n@@")[0]!)) return { path: file, diff: "", truncated: false, binary: true };
|
|
335
|
+
return { path: file, diff: text, truncated };
|
|
336
|
+
}
|
|
337
|
+
|
|
338
|
+
// ---------- 分支 ----------
|
|
339
|
+
|
|
340
|
+
export type GitBranch = {
|
|
341
|
+
name: string;
|
|
342
|
+
remote: boolean;
|
|
343
|
+
current: boolean;
|
|
344
|
+
upstream?: string;
|
|
345
|
+
hash: string;
|
|
346
|
+
subject: string;
|
|
347
|
+
/** 毫秒时间戳 */
|
|
348
|
+
date: number;
|
|
349
|
+
};
|
|
350
|
+
|
|
351
|
+
export async function gitBranches(root: string): Promise<{ branches: GitBranch[]; truncated: boolean }> {
|
|
352
|
+
const sep = "\x1f";
|
|
353
|
+
const format = ["%(refname)", "%(HEAD)", "%(upstream:short)", "%(objectname:short)", "%(committerdate:unix)", "%(subject)"].join(sep);
|
|
354
|
+
const out = await run(
|
|
355
|
+
root,
|
|
356
|
+
[...(await safeArgs(root)), "for-each-ref", `--format=${format}`, "--sort=-committerdate", `--count=${BRANCHES_MAX + 1}`, "refs/heads", "refs/remotes"],
|
|
357
|
+
4 * 1024 * 1024,
|
|
358
|
+
);
|
|
359
|
+
if (out.code !== 0) throw new Error(out.stderr.trim() || "读取分支失败");
|
|
360
|
+
const lines = out.stdout.split("\n").filter(Boolean);
|
|
361
|
+
const branches: GitBranch[] = [];
|
|
362
|
+
for (const line of lines.slice(0, BRANCHES_MAX)) {
|
|
363
|
+
const [ref, head, upstream, hash, date, subject] = line.split(sep);
|
|
364
|
+
// origin/HEAD 只是个指针,不是分支
|
|
365
|
+
if (!ref || ref.endsWith("/HEAD")) continue;
|
|
366
|
+
const remote = ref.startsWith("refs/remotes/");
|
|
367
|
+
branches.push({
|
|
368
|
+
name: ref.replace(/^refs\/(?:heads|remotes)\//, ""),
|
|
369
|
+
remote,
|
|
370
|
+
current: head === "*",
|
|
371
|
+
...(upstream ? { upstream } : {}),
|
|
372
|
+
hash: hash ?? "",
|
|
373
|
+
subject: subject ?? "",
|
|
374
|
+
date: Number(date) * 1000 || 0,
|
|
375
|
+
});
|
|
376
|
+
}
|
|
377
|
+
return { branches, truncated: lines.length > BRANCHES_MAX };
|
|
378
|
+
}
|
|
379
|
+
|
|
380
|
+
// ---------- 每轮对话的快照 ----------
|
|
381
|
+
//
|
|
382
|
+
// 快照是一棵 tree:工作区当时的样子。用一份临时索引生成,用户的暂存区、工作区、分支都不碰。
|
|
383
|
+
// 比较两棵 tree 就知道这一轮改了什么,agent 用工具改的、用命令改的都算在内,两种 agent 一视同仁。
|
|
384
|
+
// 敏感文件和太大的文件不进快照:不给它们在 .git 里留副本,也就不会出现在 diff 里。
|
|
385
|
+
|
|
386
|
+
/** 比这大的文件不进快照(模型、数据集、编译产物):每轮复制一份太占地方 */
|
|
387
|
+
const SNAPSHOT_MAX_FILE_BYTES = 20 * 1024 * 1024;
|
|
388
|
+
/** 改动和没跟踪的文件比这多:多半是没写 .gitignore 的依赖目录,这一轮不做快照 */
|
|
389
|
+
const SNAPSHOT_MAX_FILES = 5000;
|
|
390
|
+
|
|
391
|
+
/** 工作区现在的样子写成一棵 tree,返回它的 hash。做不了(文件太多、索引坏了)返回 undefined,不影响对话 */
|
|
392
|
+
export async function snapshotTree(root: string): Promise<string | undefined> {
|
|
393
|
+
// 自定义 filter 的仓库:清空 filter 做快照,会把 git-crypt 保护的内容以明文写进 .git。这种仓库不做快照
|
|
394
|
+
if ((await customFilters(root).catch(() => new Set(["?"]))).size) return undefined;
|
|
395
|
+
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "aloft-index-"));
|
|
396
|
+
try {
|
|
397
|
+
const safe = [...(await safeArgs(root)), "-c", "core.splitIndex=false"];
|
|
398
|
+
const indexPath = await run(root, ["rev-parse", "--git-path", "index"], 64 * 1024);
|
|
399
|
+
if (indexPath.code !== 0) return undefined;
|
|
400
|
+
const index = path.join(dir, "index");
|
|
401
|
+
// 从真的索引复制一份开始:里面有文件的状态缓存,不用把所有文件都读一遍
|
|
402
|
+
try {
|
|
403
|
+
fs.copyFileSync(path.resolve(root, indexPath.stdout.trim()), index);
|
|
404
|
+
} catch (err) {
|
|
405
|
+
if ((err as NodeJS.ErrnoException).code !== "ENOENT") return undefined;
|
|
406
|
+
}
|
|
407
|
+
const env = { GIT_INDEX_FILE: index };
|
|
408
|
+
const listed = await run(root, [...safe, "ls-files", "-z", "--modified", "--deleted", "--others", "--exclude-standard"], STATUS_MAX_BYTES, { env });
|
|
409
|
+
if (listed.code !== 0 || listed.truncated) return undefined;
|
|
410
|
+
const paths = new Set<string>();
|
|
411
|
+
for (const file of listed.stdout.split("\0")) {
|
|
412
|
+
// 以斜杠结尾的是嵌在里面的另一个仓库,不进快照
|
|
413
|
+
if (!file || file.endsWith("/")) continue;
|
|
414
|
+
const abs = path.join(root, file);
|
|
415
|
+
if (isSensitivePath(abs)) continue;
|
|
416
|
+
const st = fs.lstatSync(abs, { throwIfNoEntry: false });
|
|
417
|
+
if (st?.isFile() && st.size > SNAPSHOT_MAX_FILE_BYTES) continue;
|
|
418
|
+
paths.add(file);
|
|
419
|
+
if (paths.size > SNAPSHOT_MAX_FILES) return undefined;
|
|
420
|
+
}
|
|
421
|
+
if (paths.size) {
|
|
422
|
+
const updated = await run(root, [...safe, "update-index", "--add", "--remove", "-z", "--stdin"], 1024 * 1024, { env, input: [...paths].map((p) => `${p}\0`).join("") });
|
|
423
|
+
if (updated.code !== 0) return undefined;
|
|
424
|
+
}
|
|
425
|
+
const tree = await run(root, [...safe, "write-tree"], 1024, { env });
|
|
426
|
+
return tree.code === 0 ? tree.stdout.trim() || undefined : undefined;
|
|
427
|
+
} catch {
|
|
428
|
+
return undefined;
|
|
429
|
+
} finally {
|
|
430
|
+
fs.rmSync(dir, { recursive: true, force: true });
|
|
431
|
+
}
|
|
432
|
+
}
|
|
433
|
+
|
|
434
|
+
export type TreeFileState = "added" | "modified" | "deleted" | "renamed" | "copied" | "typechange";
|
|
435
|
+
|
|
436
|
+
export type TreeFileChange = {
|
|
437
|
+
path: string;
|
|
438
|
+
oldPath?: string;
|
|
439
|
+
status: TreeFileState;
|
|
440
|
+
added: number;
|
|
441
|
+
removed: number;
|
|
442
|
+
binary?: boolean;
|
|
443
|
+
};
|
|
444
|
+
|
|
445
|
+
const TREE_STATE: Record<string, TreeFileState> = { A: "added", M: "modified", D: "deleted", R: "renamed", C: "copied", T: "typechange" };
|
|
446
|
+
|
|
447
|
+
/** 解析 git diff-tree -z --name-status 和 --numstat 的输出,合成一份 */
|
|
448
|
+
export function parseTreeDiff(nameStatus: string, numstat: string): TreeFileChange[] {
|
|
449
|
+
const files = new Map<string, TreeFileChange>();
|
|
450
|
+
const names = nameStatus.split("\0");
|
|
451
|
+
for (let i = 0; i < names.length; i++) {
|
|
452
|
+
const code = names[i]!;
|
|
453
|
+
if (!code) continue;
|
|
454
|
+
const status = TREE_STATE[code[0]!];
|
|
455
|
+
const two = code[0] === "R" || code[0] === "C";
|
|
456
|
+
const first = names[++i];
|
|
457
|
+
const second = two ? names[++i] : undefined;
|
|
458
|
+
const target = second ?? first;
|
|
459
|
+
if (!status || !target) continue;
|
|
460
|
+
files.set(target, { path: target, ...(two ? { oldPath: first! } : {}), status, added: 0, removed: 0 });
|
|
461
|
+
}
|
|
462
|
+
const stats = numstat.split("\0");
|
|
463
|
+
for (let i = 0; i < stats.length; i++) {
|
|
464
|
+
const line = stats[i]!;
|
|
465
|
+
if (!line) continue;
|
|
466
|
+
const [added, removed, inline] = line.split("\t");
|
|
467
|
+
// 重命名:路径字段是空的,后面两段是旧路径、新路径
|
|
468
|
+
let target = inline;
|
|
469
|
+
if (!target) {
|
|
470
|
+
i++;
|
|
471
|
+
target = stats[++i];
|
|
472
|
+
}
|
|
473
|
+
const file = target ? files.get(target) : undefined;
|
|
474
|
+
if (!file) continue;
|
|
475
|
+
if (added === "-" || removed === "-") file.binary = true;
|
|
476
|
+
else {
|
|
477
|
+
file.added = Number(added) || 0;
|
|
478
|
+
file.removed = Number(removed) || 0;
|
|
479
|
+
}
|
|
480
|
+
}
|
|
481
|
+
return [...files.values()];
|
|
482
|
+
}
|
|
483
|
+
|
|
484
|
+
async function treeChanges(root: string, before: string, after: string, safe: string[]): Promise<TreeFileChange[] | undefined> {
|
|
485
|
+
const args = [...safe, "diff-tree", "-r", "-z", "-M", "--no-ext-diff", "--no-textconv"];
|
|
486
|
+
const [names, stats] = await Promise.all([
|
|
487
|
+
run(root, [...args, "--name-status", before, after], STATUS_MAX_BYTES),
|
|
488
|
+
run(root, [...args, "--numstat", before, after], STATUS_MAX_BYTES),
|
|
489
|
+
]);
|
|
490
|
+
if (names.code !== 0 || stats.code !== 0 || names.truncated || stats.truncated) return undefined;
|
|
491
|
+
return parseTreeDiff(names.stdout, stats.stdout);
|
|
492
|
+
}
|
|
493
|
+
|
|
494
|
+
/** 两棵 tree 之间改了哪些文件。比不了(快照已经没了)返回 undefined */
|
|
495
|
+
export async function diffTrees(root: string, before: string, after: string): Promise<TreeFileChange[] | undefined> {
|
|
496
|
+
return treeChanges(root, before, after, await safeArgs(root));
|
|
497
|
+
}
|
|
498
|
+
|
|
499
|
+
/** 两棵 tree 之间一个文件的 diff。和 gitDiff 一样,只认确实改了的文件;快照没了、文件不在里面都返回 undefined */
|
|
500
|
+
export async function treeFileDiff(root: string, before: string, after: string, file: string): Promise<GitDiff | undefined> {
|
|
501
|
+
const safe = await safeArgs(root);
|
|
502
|
+
const change = (await treeChanges(root, before, after, safe))?.find((f) => f.path === file);
|
|
503
|
+
if (!change) return undefined;
|
|
504
|
+
if (isSensitivePath(path.join(root, file)) || (change.oldPath && isSensitivePath(path.join(root, change.oldPath)))) {
|
|
505
|
+
return { path: file, diff: "", truncated: false, note: "这是密钥一类的敏感文件,不显示内容" };
|
|
506
|
+
}
|
|
507
|
+
const paths = change.oldPath ? [file, change.oldPath] : [file];
|
|
508
|
+
const out = await run(root, [...safe, "--literal-pathspecs", "diff", "--no-color", "--no-ext-diff", "--no-textconv", "-M", before, after, "--", ...paths], DIFF_MAX_BYTES);
|
|
509
|
+
if (out.code !== 0) return undefined;
|
|
510
|
+
return diffResult(file, out);
|
|
511
|
+
}
|
|
512
|
+
|
|
513
|
+
const SNAPSHOT_REF = "refs/agent-loft/t/";
|
|
514
|
+
|
|
515
|
+
/** 只留这些 tree 的引用,其余的删掉,让 git gc 能回收。引用不是分支,不会出现在 git branch、git log 里 */
|
|
516
|
+
export async function keepTrees(root: string, trees: Iterable<string>): Promise<void> {
|
|
517
|
+
const want = new Set(trees);
|
|
518
|
+
const refs = await run(root, ["for-each-ref", "--format=%(objectname)", SNAPSHOT_REF], 4 * 1024 * 1024);
|
|
519
|
+
if (refs.code !== 0) return;
|
|
520
|
+
const have = new Set(refs.stdout.split("\n").filter(Boolean));
|
|
521
|
+
const commands: string[] = [];
|
|
522
|
+
for (const tree of have) if (!want.has(tree)) commands.push(`delete ${SNAPSHOT_REF}${tree}`);
|
|
523
|
+
for (const tree of want) if (!have.has(tree)) commands.push(`create ${SNAPSHOT_REF}${tree} ${tree}`);
|
|
524
|
+
// 更新引用会触发 reference-transaction 钩子,一定要带上关钩子的配置
|
|
525
|
+
if (commands.length) await run(root, [...(await safeArgs(root)), "update-ref", "--stdin"], 64 * 1024, { input: `${commands.join("\n")}\n` });
|
|
526
|
+
}
|
|
527
|
+
|
|
528
|
+
// ---------- 提交历史 ----------
|
|
529
|
+
|
|
530
|
+
export type GitCommit = { hash: string; short: string; author: string; date: number; subject: string };
|
|
531
|
+
|
|
532
|
+
/** 提交历史,新的在前。还没有提交的仓库是空的 */
|
|
533
|
+
export async function gitLog(root: string, skip: number, limit: number): Promise<{ commits: GitCommit[]; more: boolean }> {
|
|
534
|
+
const out = await run(
|
|
535
|
+
root,
|
|
536
|
+
[...(await safeArgs(root)), "-c", "log.showSignature=false", "log", "-z", "--no-color", "--format=%H%x1f%h%x1f%an%x1f%at%x1f%s", `--skip=${skip}`, `-n${limit + 1}`],
|
|
537
|
+
4 * 1024 * 1024,
|
|
538
|
+
);
|
|
539
|
+
if (out.code !== 0) return { commits: [], more: false };
|
|
540
|
+
const lines = out.stdout.split("\0").filter(Boolean);
|
|
541
|
+
const commits = lines.slice(0, limit).map((line) => {
|
|
542
|
+
const [hash, short, author, date, subject] = line.split("\x1f");
|
|
543
|
+
return { hash: hash ?? "", short: short ?? "", author: author ?? "", date: Number(date) * 1000 || 0, subject: subject ?? "" };
|
|
544
|
+
});
|
|
545
|
+
return { commits, more: lines.length > limit };
|
|
546
|
+
}
|
|
547
|
+
|
|
548
|
+
/** 页面传来的提交编号:只收 hash,不能是 --option 或 HEAD~1 这种,并且要确实是个提交 */
|
|
549
|
+
async function commitAndParent(root: string, hash: string): Promise<{ commit: string; parent: string } | undefined> {
|
|
550
|
+
if (!/^[0-9a-f]{7,64}$/.test(hash)) return undefined;
|
|
551
|
+
const commit = await run(root, ["rev-parse", "--verify", "-q", `${hash}^{commit}`], 1024);
|
|
552
|
+
if (commit.code !== 0) return undefined;
|
|
553
|
+
const parent = await run(root, ["rev-parse", "--verify", "-q", `${hash}^1`], 1024);
|
|
554
|
+
if (parent.code === 0) return { commit: commit.stdout.trim(), parent: parent.stdout.trim() };
|
|
555
|
+
// 第一个提交:和空目录比
|
|
556
|
+
const empty = await run(root, ["hash-object", "-t", "tree", "--stdin"], 1024, { input: "" });
|
|
557
|
+
return empty.code === 0 ? { commit: commit.stdout.trim(), parent: empty.stdout.trim() } : undefined;
|
|
558
|
+
}
|
|
559
|
+
|
|
560
|
+
export async function commitFiles(root: string, hash: string): Promise<TreeFileChange[] | undefined> {
|
|
561
|
+
const pair = await commitAndParent(root, hash);
|
|
562
|
+
return pair ? diffTrees(root, pair.parent, pair.commit) : undefined;
|
|
563
|
+
}
|
|
564
|
+
|
|
565
|
+
export async function commitFileDiff(root: string, hash: string, file: string): Promise<GitDiff | undefined> {
|
|
566
|
+
const pair = await commitAndParent(root, hash);
|
|
567
|
+
return pair ? treeFileDiff(root, pair.parent, pair.commit, file) : undefined;
|
|
568
|
+
}
|
|
569
|
+
|
|
570
|
+
// ---------- 用户点的操作 ----------
|
|
571
|
+
//
|
|
572
|
+
// 路径都要在当前的改动列表里,分支要在分支列表里:不把页面传来的字符串直接交给 git。
|
|
573
|
+
// 敏感文件不能暂存、不能丢弃、不能提交:不让人一不小心把密钥提交进去。
|
|
574
|
+
|
|
575
|
+
/** 带 HTTP 状态的错误:接口层照着回。extra 给页面判断下一步(比如冲突的文件列表) */
|
|
576
|
+
export class GitError extends Error {
|
|
577
|
+
constructor(
|
|
578
|
+
readonly status: number,
|
|
579
|
+
message: string,
|
|
580
|
+
readonly extra: Record<string, unknown> = {},
|
|
581
|
+
) {
|
|
582
|
+
super(message);
|
|
583
|
+
}
|
|
584
|
+
}
|
|
585
|
+
|
|
586
|
+
/** git 的报错翻译成人话。认不出的原样给 */
|
|
587
|
+
function explain(stderr: string, fallback: string): string {
|
|
588
|
+
const text = stderr.trim();
|
|
589
|
+
if (/index\.lock|another git process/i.test(text)) return "另一个 git 进程正在操作这个仓库(可能是 agent),稍后再试";
|
|
590
|
+
if (/would be overwritten|commit your changes or stash/i.test(text)) return "有没提交的改动会被覆盖,git 拒绝了。先提交或丢弃这些改动";
|
|
591
|
+
if (/please tell me who you are|empty ident|unable to auto-detect email/i.test(text)) return "git 还没配置用户名和邮箱,先在终端里设置 user.name 和 user.email";
|
|
592
|
+
if (/already exists/i.test(text)) return "这个分支已经存在了";
|
|
593
|
+
if (/not a valid branch name|is not a valid/i.test(text)) return "分支名不合法";
|
|
594
|
+
return text || fallback;
|
|
595
|
+
}
|
|
596
|
+
|
|
597
|
+
/**
|
|
598
|
+
* 写操作前检查:自定义 filter 的仓库(git-crypt 之类)不能操作。
|
|
599
|
+
* 不跑仓库配置里的程序是这里的底线,而这些 filter 不跑的话,暂存就是把明文写进去、切分支就是把密文写出来
|
|
600
|
+
*/
|
|
601
|
+
async function assertWritable(root: string): Promise<void> {
|
|
602
|
+
const filters = await customFilters(root);
|
|
603
|
+
if (filters.size) throw new GitError(409, `这个仓库配置了自定义的 Git 过滤器(${[...filters].join("、")},比如 git-crypt),在面板里操作可能损坏内容或泄露明文,请在终端里操作`);
|
|
604
|
+
}
|
|
605
|
+
|
|
606
|
+
async function changesFor(root: string, paths: unknown): Promise<GitFileChange[]> {
|
|
607
|
+
if (!Array.isArray(paths) || !paths.length || paths.some((p) => typeof p !== "string")) throw new GitError(400, "没有指定文件");
|
|
608
|
+
const status = await gitStatus(root);
|
|
609
|
+
return (paths as string[]).map((file) => {
|
|
610
|
+
const change = status.files.find((f) => f.path === file);
|
|
611
|
+
if (!change) throw new GitError(404, `「${file}」现在没有改动了,刷新一下再试`);
|
|
612
|
+
return change;
|
|
613
|
+
});
|
|
614
|
+
}
|
|
615
|
+
|
|
616
|
+
function rejectSensitive(changes: GitFileChange[], action: string): void {
|
|
617
|
+
const secret = changes.find((f) => f.sensitive);
|
|
618
|
+
if (secret) throw new GitError(403, `「${secret.path}」是密钥一类的敏感文件,不能在面板里${action},需要的话请在终端里操作`);
|
|
619
|
+
}
|
|
620
|
+
|
|
621
|
+
/** git status 把嵌在里面的另一个仓库报成一个没跟踪的目录。丢弃会把整个仓库删掉,暂存会变成奇怪的 gitlink */
|
|
622
|
+
function rejectDirectories(root: string, changes: GitFileChange[], action: string): void {
|
|
623
|
+
for (const f of changes) {
|
|
624
|
+
if (f.unstaged === "untracked" && (f.path.endsWith("/") || fs.lstatSync(path.join(root, f.path), { throwIfNoEntry: false })?.isDirectory())) {
|
|
625
|
+
throw new GitError(409, `「${f.path}」是一个目录(可能是嵌在里面的另一个仓库),不能在面板里${action},请在终端里操作`);
|
|
626
|
+
}
|
|
627
|
+
}
|
|
628
|
+
}
|
|
629
|
+
|
|
630
|
+
async function write(root: string, args: string[], fallback: string, opts: { input?: string; timeoutMs?: number; env?: NodeJS.ProcessEnv } = {}): Promise<RunResult> {
|
|
631
|
+
const out = await run(root, [...(await safeArgs(root)), ...args], 1024 * 1024, opts);
|
|
632
|
+
if (out.code !== 0) throw new GitError(409, explain(out.stderr, fallback));
|
|
633
|
+
return out;
|
|
634
|
+
}
|
|
635
|
+
|
|
636
|
+
export async function gitStage(root: string, paths: unknown): Promise<void> {
|
|
637
|
+
await assertWritable(root);
|
|
638
|
+
const changes = await changesFor(root, paths);
|
|
639
|
+
rejectSensitive(changes, "暂存");
|
|
640
|
+
rejectDirectories(root, changes, "暂存");
|
|
641
|
+
await write(root, ["--literal-pathspecs", "add", "-A", "--", ...changes.map((f) => f.path)], "暂存失败");
|
|
642
|
+
}
|
|
643
|
+
|
|
644
|
+
export async function gitUnstage(root: string, paths: unknown): Promise<void> {
|
|
645
|
+
await assertWritable(root);
|
|
646
|
+
const changes = await changesFor(root, paths);
|
|
647
|
+
const targets = changes.flatMap((f) => (f.oldPath ? [f.path, f.oldPath] : [f.path]));
|
|
648
|
+
// 只动暂存区,不碰工作区;还没有提交的仓库也能用
|
|
649
|
+
await write(root, ["--literal-pathspecs", "reset", "-q", "--", ...targets], "取消暂存失败");
|
|
650
|
+
}
|
|
651
|
+
|
|
652
|
+
/** 丢弃工作区的改动:跟踪的文件恢复成暂存区的样子,没跟踪的文件删掉。暂存了的不动 */
|
|
653
|
+
export async function gitDiscard(root: string, paths: unknown): Promise<void> {
|
|
654
|
+
await assertWritable(root);
|
|
655
|
+
const changes = await changesFor(root, paths);
|
|
656
|
+
rejectSensitive(changes, "丢弃");
|
|
657
|
+
rejectDirectories(root, changes, "丢弃");
|
|
658
|
+
const conflicted = changes.find((f) => f.unstaged === "conflicted");
|
|
659
|
+
if (conflicted) throw new GitError(409, `「${conflicted.path}」有合并冲突,不能在这里丢弃`);
|
|
660
|
+
const none = changes.find((f) => !f.unstaged);
|
|
661
|
+
if (none) throw new GitError(409, `「${none.path}」只有已暂存的改动,先取消暂存再丢弃`);
|
|
662
|
+
const tracked = changes.filter((f) => f.unstaged !== "untracked").map((f) => f.path);
|
|
663
|
+
if (tracked.length) await write(root, ["--literal-pathspecs", "checkout", "--", ...tracked], "丢弃失败");
|
|
664
|
+
for (const file of changes.filter((f) => f.unstaged === "untracked")) removeWorktreeFile(root, file.path);
|
|
665
|
+
}
|
|
666
|
+
|
|
667
|
+
/** 删工作区里的一个文件,顺手把空出来的目录也删了(和 git 一样)。路径上有符号链接的不动:不能跟着链接删到外面去 */
|
|
668
|
+
function removeWorktreeFile(root: string, file: string): void {
|
|
669
|
+
const abs = path.join(root, file);
|
|
670
|
+
const parent = path.dirname(abs);
|
|
671
|
+
let realParent: string;
|
|
672
|
+
try {
|
|
673
|
+
realParent = fs.realpathSync(parent);
|
|
674
|
+
} catch {
|
|
675
|
+
return; // 目录已经没了,文件当然也没了
|
|
676
|
+
}
|
|
677
|
+
const realRoot = fs.realpathSync(root);
|
|
678
|
+
if (realParent !== realRoot && !realParent.startsWith(realRoot + path.sep)) throw new GitError(403, `「${file}」的路径经过符号链接跳出了仓库,不能操作`);
|
|
679
|
+
const target = path.join(realParent, path.basename(abs));
|
|
680
|
+
if (fs.lstatSync(target, { throwIfNoEntry: false })?.isDirectory()) throw new GitError(409, `「${file}」现在是一个目录,不能当文件删除,请在终端里处理`);
|
|
681
|
+
fs.rmSync(target, { force: true });
|
|
682
|
+
for (let dir = parent; dir !== root && dir.startsWith(root + path.sep); dir = path.dirname(dir)) {
|
|
683
|
+
try {
|
|
684
|
+
fs.rmdirSync(dir);
|
|
685
|
+
} catch {
|
|
686
|
+
break; // 不是空的
|
|
687
|
+
}
|
|
688
|
+
}
|
|
689
|
+
}
|
|
690
|
+
|
|
691
|
+
/**
|
|
692
|
+
* 提交已暂存的内容。默认不跑 Git 钩子:钩子是仓库里的程序,要用户明确勾选(hooks)才跑,而且跑的时间可能很长。
|
|
693
|
+
* 暂存区里有敏感文件不让提交。仓库配置(.git/config)里指定的签名程序不跑,全局配置的照常签名
|
|
694
|
+
*/
|
|
695
|
+
export async function gitCommit(root: string, message: unknown, opts: { hooks?: boolean } = {}): Promise<{ short: string }> {
|
|
696
|
+
await assertWritable(root);
|
|
697
|
+
const text = typeof message === "string" ? message.trim() : "";
|
|
698
|
+
if (!text) throw new GitError(400, "请写提交说明");
|
|
699
|
+
const status = await gitStatus(root);
|
|
700
|
+
const staged = status.files.filter((f) => f.staged);
|
|
701
|
+
if (!staged.length) throw new GitError(409, "没有已暂存的文件");
|
|
702
|
+
rejectSensitive(staged, "提交");
|
|
703
|
+
const noLocalSigner = (await repoConfig(root, "^(gpg\\.|commit\\.gpgsign)")).length ? ["-c", "commit.gpgsign=false"] : [];
|
|
704
|
+
// 不勾选时带 SAFE_CONFIG 里的 hooksPath=/dev/null(所有钩子都不跑);勾选了要在它后面覆盖回来
|
|
705
|
+
const hookArgs = opts.hooks ? ["-c", `core.hooksPath=${(await hooksDir(root))}`] : [];
|
|
706
|
+
// 钩子是用户明确要跑的,可能要连网(pre-commit 框架第一次要 git clone):禁止连网的设置不传给它们
|
|
707
|
+
const env = opts.hooks ? { GIT_ALLOW_PROTOCOL: undefined, GIT_NO_LAZY_FETCH: undefined } : {};
|
|
708
|
+
await write(root, [...noLocalSigner, ...hookArgs, "commit", "-q", "-F", "-"], "提交失败", { input: text, env, timeoutMs: opts.hooks ? 5 * 60_000 : 60_000 });
|
|
709
|
+
const head = await run(root, ["rev-parse", "--short", "HEAD"], 1024);
|
|
710
|
+
return { short: head.stdout.trim() };
|
|
711
|
+
}
|
|
712
|
+
|
|
713
|
+
/** 仓库本来的钩子目录:core.hooksPath 配了就是它,否则是 .git/hooks */
|
|
714
|
+
async function hooksDir(root: string): Promise<string> {
|
|
715
|
+
const out = await run(root, ["rev-parse", "--git-path", "hooks"], 4096);
|
|
716
|
+
return path.resolve(root, out.stdout.trim());
|
|
717
|
+
}
|
|
718
|
+
|
|
719
|
+
const BRANCH_NAME = /^[^\s~^:?*[\\-][^\s~^:?*[\\]*$/;
|
|
720
|
+
|
|
721
|
+
/** 切换分支。git 发现有没提交的改动会被覆盖时会拒绝,不会丢东西。remote:切到远程分支,建一个跟踪它的本地分支 */
|
|
722
|
+
export async function gitSwitch(root: string, branch: unknown): Promise<void> {
|
|
723
|
+
await assertWritable(root);
|
|
724
|
+
if (typeof branch !== "string" || !branch) throw new GitError(400, "没有指定分支");
|
|
725
|
+
const { branches } = await gitBranches(root);
|
|
726
|
+
const target = branches.find((b) => b.name === branch);
|
|
727
|
+
if (!target) throw new GitError(404, `分支「${branch}」不存在`);
|
|
728
|
+
if (target.current) return;
|
|
729
|
+
if (!target.remote) {
|
|
730
|
+
await write(root, ["checkout", "-q", target.name, "--"], "切换分支失败");
|
|
731
|
+
return;
|
|
732
|
+
}
|
|
733
|
+
const local = target.name.slice(target.name.indexOf("/") + 1);
|
|
734
|
+
if (branches.some((b) => !b.remote && b.name === local)) await write(root, ["checkout", "-q", local, "--"], "切换分支失败");
|
|
735
|
+
else await write(root, ["checkout", "-q", "--track", `refs/remotes/${target.name}`], "切换分支失败");
|
|
736
|
+
}
|
|
737
|
+
|
|
738
|
+
/** 从当前位置新建分支并切过去 */
|
|
739
|
+
export async function gitCreateBranch(root: string, name: unknown): Promise<void> {
|
|
740
|
+
await assertWritable(root);
|
|
741
|
+
const branch = typeof name === "string" ? name.trim() : "";
|
|
742
|
+
if (!BRANCH_NAME.test(branch)) throw new GitError(400, "分支名不合法");
|
|
743
|
+
const valid = await run(root, ["check-ref-format", "--branch", branch], 1024);
|
|
744
|
+
if (valid.code !== 0) throw new GitError(400, "分支名不合法");
|
|
745
|
+
await write(root, ["checkout", "-q", "-b", branch], "新建分支失败");
|
|
746
|
+
}
|
|
747
|
+
|
|
748
|
+
// ---------- 撤销一轮 ----------
|
|
749
|
+
|
|
750
|
+
/** 两棵 tree 里内容不一样的文件。不做重命名检测:撤销时重命名就是一删一增 */
|
|
751
|
+
export async function differingPaths(root: string, a: string, b: string): Promise<string[] | undefined> {
|
|
752
|
+
const out = await run(root, [...(await safeArgs(root)), "diff-tree", "-r", "-z", "--no-renames", "--name-only", a, b], STATUS_MAX_BYTES);
|
|
753
|
+
if (out.code !== 0 || out.truncated) return undefined;
|
|
754
|
+
return out.stdout.split("\0").filter(Boolean);
|
|
755
|
+
}
|
|
756
|
+
|
|
757
|
+
/**
|
|
758
|
+
* 把这些文件恢复成 tree 里的样子:tree 里有的写回工作区(权限、符号链接都按 tree 的),没有的删掉。
|
|
759
|
+
* 用临时索引,用户的暂存区不动
|
|
760
|
+
*/
|
|
761
|
+
export async function restoreFromTree(root: string, tree: string, files: string[]): Promise<void> {
|
|
762
|
+
await assertWritable(root);
|
|
763
|
+
if (!files.length) return;
|
|
764
|
+
const safe = await safeArgs(root);
|
|
765
|
+
const present = await run(root, [...safe, "--literal-pathspecs", "ls-tree", "-r", "-z", "--name-only", tree, "--", ...files], STATUS_MAX_BYTES);
|
|
766
|
+
if (present.code !== 0) throw new GitError(409, explain(present.stderr, "读取快照失败"));
|
|
767
|
+
const inTree = new Set(present.stdout.split("\0").filter(Boolean));
|
|
768
|
+
const dir = fs.mkdtempSync(path.join(os.tmpdir(), "aloft-index-"));
|
|
769
|
+
try {
|
|
770
|
+
const env = { GIT_INDEX_FILE: path.join(dir, "index") };
|
|
771
|
+
const read = await run(root, [...safe, "read-tree", tree], 64 * 1024, { env });
|
|
772
|
+
if (read.code !== 0) throw new GitError(409, explain(read.stderr, "读取快照失败"));
|
|
773
|
+
// 先删再写:一个文件变成同名目录、或者反过来时,要先把挡路的删掉
|
|
774
|
+
for (const file of files) if (!inTree.has(file)) removeWorktreeFile(root, file);
|
|
775
|
+
if (inTree.size) {
|
|
776
|
+
const out = await run(root, [...safe, "checkout-index", "-f", "-z", "--stdin"], 1024 * 1024, { env, input: [...inTree].map((p) => `${p}\0`).join("") });
|
|
777
|
+
if (out.code !== 0) throw new GitError(409, explain(out.stderr, "恢复文件失败"));
|
|
778
|
+
}
|
|
779
|
+
} finally {
|
|
780
|
+
fs.rmSync(dir, { recursive: true, force: true });
|
|
781
|
+
}
|
|
782
|
+
}
|