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
|
@@ -0,0 +1,179 @@
|
|
|
1
|
+
// 每轮对话改了什么:一轮开始前和结束后各拍一张工作区快照(见 git.ts 的 snapshotTree),比较两张得出改动。
|
|
2
|
+
//
|
|
3
|
+
// 不靠 agent 上报:Codex 只说改了哪些路径,Claude 只报自己工具改的,用命令改的两边都不算。
|
|
4
|
+
//
|
|
5
|
+
// 时间线:
|
|
6
|
+
// - 发消息时会话空闲:先拍「开始」这张再把消息交给 agent(等不了太久,见 BEGIN_BUDGET_MS);
|
|
7
|
+
// - 一轮结束:拍「结束」这张,比较,有改动就记下来;
|
|
8
|
+
// - 排队的消息紧接着开始:不再拍,上一轮「结束」那张就是它的「开始」,每一轮都对得上。
|
|
9
|
+
//
|
|
10
|
+
// 工作区是共用的:这一轮期间你自己改的、同一仓库里别的会话改的都会算进来。别的会话在跑时会标出来(shared)。
|
|
11
|
+
//
|
|
12
|
+
// 快照是 git 对象,靠 refs/agent-loft/t/ 下的引用留着。每个仓库只留最近 KEEP_PER_REPO 轮,
|
|
13
|
+
// 更早的引用删掉,等 git gc 回收;那些轮次的摘要还在(存在脚注里),只是看不了具体内容了。
|
|
14
|
+
import crypto from "node:crypto";
|
|
15
|
+
import { sql, transaction } from "./db.js";
|
|
16
|
+
import { differingPaths, diffTrees, findRepo, GitError, keepTrees, restoreFromTree, snapshotTree, treeFileDiff, type GitDiff } from "./git.js";
|
|
17
|
+
import type { TurnChanges } from "./types.js";
|
|
18
|
+
|
|
19
|
+
/** 拍「开始」这张最多等这么久:消息不能因为仓库太大发不出去。超时这一轮就没有改动卡片 */
|
|
20
|
+
const BEGIN_BUDGET_MS = 5000;
|
|
21
|
+
const KEEP_PER_REPO = 200;
|
|
22
|
+
const KEEP_MAX_AGE_MS = 60 * 86400_000;
|
|
23
|
+
/** 摘要里最多列这么多个文件 */
|
|
24
|
+
const MAX_FILES_IN_SUMMARY = 200;
|
|
25
|
+
|
|
26
|
+
type Baseline = { cwd: string; root: string; tree: string; shared: boolean };
|
|
27
|
+
|
|
28
|
+
const baselines = new Map<string, Baseline>();
|
|
29
|
+
/** 同一条会话的快照按顺序来:结束那张没拍完,下一轮的开始不能抢在前面 */
|
|
30
|
+
const chains = new Map<string, Promise<unknown>>();
|
|
31
|
+
/** 每次开始加一:超时放弃的那次拍完了也不算数 */
|
|
32
|
+
const generations = new Map<string, number>();
|
|
33
|
+
|
|
34
|
+
function chain<T>(key: string, job: () => Promise<T>): Promise<T> {
|
|
35
|
+
const run = (chains.get(key) ?? Promise.resolve()).catch(() => {}).then(job);
|
|
36
|
+
const tail = run.catch(() => {});
|
|
37
|
+
chains.set(key, tail);
|
|
38
|
+
void tail.then(() => {
|
|
39
|
+
if (chains.get(key) === tail) chains.delete(key);
|
|
40
|
+
});
|
|
41
|
+
return run;
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
/** 一轮开始之前调用。不会抛错,也不会等太久 */
|
|
45
|
+
export async function beginTurnSnapshot(key: string, cwd: string, busyInRepo: (root: string) => boolean): Promise<void> {
|
|
46
|
+
const generation = (generations.get(key) ?? 0) + 1;
|
|
47
|
+
generations.set(key, generation);
|
|
48
|
+
const job = chain(key, async () => {
|
|
49
|
+
baselines.delete(key);
|
|
50
|
+
const repo = await findRepo(cwd);
|
|
51
|
+
if (!repo.repo) return;
|
|
52
|
+
const tree = await snapshotTree(repo.root);
|
|
53
|
+
if (tree && generations.get(key) === generation) baselines.set(key, { cwd, root: repo.root, tree, shared: busyInRepo(repo.root) });
|
|
54
|
+
}).catch((err) => console.error("[快照] 拍开始的快照失败:", err));
|
|
55
|
+
let timer: NodeJS.Timeout | undefined;
|
|
56
|
+
const timeout = new Promise<void>((resolve) => {
|
|
57
|
+
timer = setTimeout(() => {
|
|
58
|
+
// 这一轮要开始了,后面才拍完的不能当基准:里面可能已经有 agent 的改动
|
|
59
|
+
generations.set(key, generation + 1);
|
|
60
|
+
resolve();
|
|
61
|
+
}, BEGIN_BUDGET_MS);
|
|
62
|
+
timer.unref?.();
|
|
63
|
+
});
|
|
64
|
+
await Promise.race([job, timeout]);
|
|
65
|
+
clearTimeout(timer);
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
/** 一轮结束时调用。有改动返回摘要,没有(或者不是仓库、快照失败)返回 null。不会抛错 */
|
|
69
|
+
export function finishTurnSnapshot(key: string, cwd: string, busyInRepo: (root: string) => boolean): Promise<TurnChanges | null> {
|
|
70
|
+
return chain(key, async () => {
|
|
71
|
+
const base = baselines.get(key);
|
|
72
|
+
// 中途切了目录:基准是别的目录的
|
|
73
|
+
if (!base || base.cwd !== cwd) return null;
|
|
74
|
+
const shared = base.shared || busyInRepo(base.root);
|
|
75
|
+
const after = await snapshotTree(base.root);
|
|
76
|
+
if (!after) {
|
|
77
|
+
baselines.delete(key);
|
|
78
|
+
return null;
|
|
79
|
+
}
|
|
80
|
+
const before = base.tree;
|
|
81
|
+
// 下一轮接着这张比。接下来一轮的 shared 看它自己期间的情况
|
|
82
|
+
baselines.set(key, { ...base, tree: after, shared: busyInRepo(base.root) });
|
|
83
|
+
if (after === before) return null;
|
|
84
|
+
const files = await diffTrees(base.root, before, after);
|
|
85
|
+
if (!files?.length) return null;
|
|
86
|
+
const changes: TurnChanges = {
|
|
87
|
+
id: crypto.randomBytes(8).toString("hex"),
|
|
88
|
+
files: files.slice(0, MAX_FILES_IN_SUMMARY),
|
|
89
|
+
fileCount: files.length,
|
|
90
|
+
added: files.reduce((n, f) => n + f.added, 0),
|
|
91
|
+
removed: files.reduce((n, f) => n + f.removed, 0),
|
|
92
|
+
...(shared ? { shared: true } : {}),
|
|
93
|
+
};
|
|
94
|
+
await remember(changes.id, base.root, before, after);
|
|
95
|
+
return changes;
|
|
96
|
+
}).catch((err) => {
|
|
97
|
+
console.error("[快照] 比较这一轮的改动失败:", err);
|
|
98
|
+
return null;
|
|
99
|
+
});
|
|
100
|
+
}
|
|
101
|
+
|
|
102
|
+
async function remember(id: string, root: string, before: string, after: string): Promise<void> {
|
|
103
|
+
const now = Date.now();
|
|
104
|
+
const kept = transaction(() => {
|
|
105
|
+
sql("INSERT INTO turn_changes (id, root, before_tree, after_tree, at) VALUES (?, ?, ?, ?, ?)").run(id, root, before, after, now);
|
|
106
|
+
sql("DELETE FROM turn_changes WHERE at < ?").run(now - KEEP_MAX_AGE_MS);
|
|
107
|
+
sql(
|
|
108
|
+
`DELETE FROM turn_changes WHERE root = ? AND id NOT IN (
|
|
109
|
+
SELECT id FROM turn_changes WHERE root = ? ORDER BY at DESC, rowid DESC LIMIT ?)`,
|
|
110
|
+
).run(root, root, KEEP_PER_REPO);
|
|
111
|
+
return sql("SELECT before_tree AS b, after_tree AS a FROM turn_changes WHERE root = ?").all(root) as { b: string; a: string }[];
|
|
112
|
+
});
|
|
113
|
+
await keepTrees(root, kept.flatMap((r) => [r.b, r.a]));
|
|
114
|
+
}
|
|
115
|
+
|
|
116
|
+
/**
|
|
117
|
+
* 某一轮里一个文件的 diff。id 只在同一个仓库里认:不接受页面传来的 tree hash,
|
|
118
|
+
* 免得拼个 hash 读到仓库里任意的历史内容。记录没了、不是这个仓库的返回 undefined
|
|
119
|
+
*/
|
|
120
|
+
export async function turnFileDiff(root: string, id: string, file: string): Promise<GitDiff | undefined> {
|
|
121
|
+
const row = turnRow(root, id);
|
|
122
|
+
return row ? treeFileDiff(root, row.b, row.a, file) : undefined;
|
|
123
|
+
}
|
|
124
|
+
|
|
125
|
+
// ---------- 撤销和重做 ----------
|
|
126
|
+
//
|
|
127
|
+
// 不需要记「撤销过没有」:看工作区现在的样子就知道。这一轮动过的文件和「结束」那张一样就是还在,
|
|
128
|
+
// 和「开始」那张一样就是撤销过了,都不一样就是之后又改过了。
|
|
129
|
+
// 只恢复这一轮动过的文件,别的文件不碰。重做就是反过来恢复成「结束」那张。
|
|
130
|
+
|
|
131
|
+
export type TurnState = {
|
|
132
|
+
/** applied:改动还在;undone:已经撤销了;diverged:这些文件之后又被改过;expired:快照没了;unavailable:现在判断不了(工作区文件太多之类) */
|
|
133
|
+
state: "applied" | "undone" | "diverged" | "expired" | "unavailable";
|
|
134
|
+
/** diverged 时:哪些文件和这一轮结束时不一样了 */
|
|
135
|
+
diverged?: string[];
|
|
136
|
+
};
|
|
137
|
+
|
|
138
|
+
type TurnRow = { root: string; b: string; a: string };
|
|
139
|
+
|
|
140
|
+
function turnRow(root: string, id: string): TurnRow | undefined {
|
|
141
|
+
const row = sql("SELECT root, before_tree AS b, after_tree AS a FROM turn_changes WHERE id = ?").get(id) as TurnRow | undefined;
|
|
142
|
+
return row && row.root === root ? row : undefined;
|
|
143
|
+
}
|
|
144
|
+
|
|
145
|
+
async function inspect(row: TurnRow): Promise<{ state: TurnState; files: string[] }> {
|
|
146
|
+
const files = await differingPaths(row.root, row.b, row.a);
|
|
147
|
+
if (!files) return { state: { state: "expired" }, files: [] };
|
|
148
|
+
const now = await snapshotTree(row.root);
|
|
149
|
+
if (!now) return { state: { state: "unavailable" }, files };
|
|
150
|
+
const [fromAfter, fromBefore] = await Promise.all([differingPaths(row.root, row.a, now), differingPaths(row.root, row.b, now)]);
|
|
151
|
+
if (!fromAfter || !fromBefore) return { state: { state: "expired" }, files };
|
|
152
|
+
const mine = new Set(files);
|
|
153
|
+
const changed = fromAfter.filter((f) => mine.has(f));
|
|
154
|
+
if (!changed.length) return { state: { state: "applied" }, files };
|
|
155
|
+
if (!fromBefore.some((f) => mine.has(f))) return { state: { state: "undone" }, files };
|
|
156
|
+
return { state: { state: "diverged", diverged: changed }, files };
|
|
157
|
+
}
|
|
158
|
+
|
|
159
|
+
export async function turnState(root: string, id: string): Promise<TurnState> {
|
|
160
|
+
const row = turnRow(root, id);
|
|
161
|
+
return row ? (await inspect(row)).state : { state: "expired" };
|
|
162
|
+
}
|
|
163
|
+
|
|
164
|
+
/**
|
|
165
|
+
* 撤销(undo)或重做(redo)一轮。文件之后又被改过时不动手,报 409 并列出文件;force 明确要覆盖。
|
|
166
|
+
* 只改工作区里这些文件,暂存区、对话记录都不变
|
|
167
|
+
*/
|
|
168
|
+
export async function revertTurn(root: string, id: string, direction: "undo" | "redo", force: boolean): Promise<TurnState> {
|
|
169
|
+
const row = turnRow(root, id);
|
|
170
|
+
if (!row) throw new GitError(404, "这一轮的快照已经清理了,不能撤销");
|
|
171
|
+
const { state, files } = await inspect(row);
|
|
172
|
+
if (state.state === "expired") throw new GitError(404, "这一轮的快照已经清理了,不能撤销");
|
|
173
|
+
if (state.state === "unavailable") throw new GitError(409, "现在判断不了这些文件的状态(工作区的改动太多,或者这个仓库配置了自定义过滤器),没有动手");
|
|
174
|
+
const done = direction === "undo" ? "undone" : "applied";
|
|
175
|
+
if (state.state === done) return state;
|
|
176
|
+
if (state.state === "diverged" && !force) throw new GitError(409, "这些文件之后又被改过了", { conflict: "diverged", files: state.diverged });
|
|
177
|
+
await restoreFromTree(root, direction === "undo" ? row.b : row.a, files);
|
|
178
|
+
return (await inspect(row)).state;
|
|
179
|
+
}
|
package/src/core/types.ts
CHANGED
|
@@ -196,10 +196,23 @@ export type HistoryMessage = {
|
|
|
196
196
|
anchor?: string;
|
|
197
197
|
/** 助手消息:这一轮的用时 / 费用 / tokens(agent-loft 自己记的,agent 记录里没有) */
|
|
198
198
|
footer?: string;
|
|
199
|
+
/** 助手消息:这一轮改了哪些文件(agent-loft 自己比较快照得出的,见 turn-changes.ts) */
|
|
200
|
+
changes?: TurnChanges;
|
|
199
201
|
/** 用户消息:带的附件(从消息里的附件清单解析出来) */
|
|
200
202
|
attachments?: AttachmentInfo[];
|
|
201
203
|
};
|
|
202
204
|
|
|
205
|
+
/** 一轮对话改了什么。files 太多时只留前一部分,fileCount、added、removed 是全部的 */
|
|
206
|
+
export type TurnChanges = {
|
|
207
|
+
id: string;
|
|
208
|
+
files: { path: string; oldPath?: string; status: string; added: number; removed: number; binary?: boolean }[];
|
|
209
|
+
fileCount: number;
|
|
210
|
+
added: number;
|
|
211
|
+
removed: number;
|
|
212
|
+
/** 这一轮期间同一个仓库里还有别的会话在跑:可能混入了它们的改动 */
|
|
213
|
+
shared?: boolean;
|
|
214
|
+
};
|
|
215
|
+
|
|
203
216
|
export type SessionOptions = {
|
|
204
217
|
cwd: string;
|
|
205
218
|
model?: string;
|
package/src/core/users.ts
CHANGED
|
@@ -30,6 +30,8 @@ export type User = {
|
|
|
30
30
|
disabled?: boolean;
|
|
31
31
|
/** 成员能不能用远程控制(终端、桌面)。管理员一直能用,不看这个 */
|
|
32
32
|
remote?: boolean;
|
|
33
|
+
/** 成员能不能用工作区面板(浏览文件、看 Git 改动)。管理员一直能用,不看这个 */
|
|
34
|
+
files?: boolean;
|
|
33
35
|
permissions?: ResourcePermissions;
|
|
34
36
|
};
|
|
35
37
|
|
|
@@ -177,6 +179,12 @@ export function canUseRemote(user: Pick<User, "role" | "disabled" | "remote"> |
|
|
|
177
179
|
return user.role === "admin" || user.remote === true;
|
|
178
180
|
}
|
|
179
181
|
|
|
182
|
+
/** 能不能用工作区面板:能看到工作目录里的所有文件,比「只看 agent 提到的文件」宽得多,成员要单独开 */
|
|
183
|
+
export function canUseFiles(user: Pick<User, "role" | "disabled" | "files"> | undefined): boolean {
|
|
184
|
+
if (!user || user.disabled) return false;
|
|
185
|
+
return user.role === "admin" || user.files === true;
|
|
186
|
+
}
|
|
187
|
+
|
|
180
188
|
export function canUseResource(user: Pick<User, "role" | "disabled" | "permissions"> | undefined, kind: ResourceKind, id: string): boolean {
|
|
181
189
|
if (!user || user.disabled) return false;
|
|
182
190
|
return user.role === "admin" || user.permissions?.[kind] == null || user.permissions[kind]!.includes(id);
|
|
@@ -233,7 +241,7 @@ function assertAdminLeft(list: User[]): void {
|
|
|
233
241
|
if (!list.some((u) => u.role === "admin" && !u.disabled)) throw new Error("至少要保留一个能登录的管理员");
|
|
234
242
|
}
|
|
235
243
|
|
|
236
|
-
export function createUser(params: { name: string; password: string; role?: Role; remote?: boolean; permissions?: unknown }): PublicUser {
|
|
244
|
+
export function createUser(params: { name: string; password: string; role?: Role; remote?: boolean; files?: boolean; permissions?: unknown }): PublicUser {
|
|
237
245
|
const list = load();
|
|
238
246
|
const name = checkName(params.name);
|
|
239
247
|
if (list.some((u) => u.name.toLowerCase() === name.toLowerCase())) throw new Error(`用户名「${name}」已经有人用了`);
|
|
@@ -245,6 +253,7 @@ export function createUser(params: { name: string; password: string; role?: Role
|
|
|
245
253
|
passwordHash: hashPassword(params.password),
|
|
246
254
|
createdAt: Date.now(),
|
|
247
255
|
...(params.remote === true ? { remote: true } : {}),
|
|
256
|
+
...(params.files === true ? { files: true } : {}),
|
|
248
257
|
...(params.permissions !== undefined ? { permissions: cleanPermissions(params.permissions) } : {}),
|
|
249
258
|
};
|
|
250
259
|
save([...list, user]);
|
|
@@ -253,7 +262,7 @@ export function createUser(params: { name: string; password: string; role?: Role
|
|
|
253
262
|
|
|
254
263
|
export function updateUser(
|
|
255
264
|
id: string,
|
|
256
|
-
patch: { name?: string; role?: Role; disabled?: boolean; password?: string; remote?: boolean; permissions?: unknown },
|
|
265
|
+
patch: { name?: string; role?: Role; disabled?: boolean; password?: string; remote?: boolean; files?: boolean; permissions?: unknown },
|
|
257
266
|
): PublicUser {
|
|
258
267
|
const list = load().map((u) => ({ ...u }));
|
|
259
268
|
const user = list.find((u) => u.id === id);
|
|
@@ -272,6 +281,10 @@ export function updateUser(
|
|
|
272
281
|
if (patch.remote) user.remote = true;
|
|
273
282
|
else delete user.remote;
|
|
274
283
|
}
|
|
284
|
+
if (patch.files !== undefined) {
|
|
285
|
+
if (patch.files) user.files = true;
|
|
286
|
+
else delete user.files;
|
|
287
|
+
}
|
|
275
288
|
if (patch.permissions !== undefined) user.permissions = cleanPermissions(patch.permissions, user.permissions);
|
|
276
289
|
if (patch.password !== undefined) {
|
|
277
290
|
checkPassword(patch.password);
|
|
@@ -0,0 +1,315 @@
|
|
|
1
|
+
// 工作区面板的文件部分:列出会话工作目录里的文件,解析出能给前端看的路径,以及编辑、新建、重命名、删除、上传。
|
|
2
|
+
//
|
|
3
|
+
// 和 core/reply-files.ts 的区别:回复里的文件只认 agent 写过的路径;这里是用户主动浏览,
|
|
4
|
+
// 范围换成「会话的工作目录之内」,接口只收相对路径。能不能用面板由 users.ts 的 canUseFiles 决定。
|
|
5
|
+
//
|
|
6
|
+
// 三道关:
|
|
7
|
+
// 1. 写法上不能跳出工作目录(../、绝对路径);
|
|
8
|
+
// 2. 解析符号链接后不能跳出工作区根目录(链接到同一工作区的别的项目可以);
|
|
9
|
+
// 3. 解析前后都不能是敏感文件(isSensitivePath)或 .git 目录里的东西 ——
|
|
10
|
+
// .git/config 的远程地址里可能带着令牌。
|
|
11
|
+
// 写操作走同样的规矩,敏感文件和 .git 里的东西也写不了。
|
|
12
|
+
import crypto from "node:crypto";
|
|
13
|
+
import fs from "node:fs";
|
|
14
|
+
import path from "node:path";
|
|
15
|
+
import { config, resolveWorkspacePath } from "./config.js";
|
|
16
|
+
import { isSensitivePath } from "./reply-files.js";
|
|
17
|
+
|
|
18
|
+
/** 一个目录最多列这么多项:node_modules 这种没人会一项项翻 */
|
|
19
|
+
const LIST_MAX = 2000;
|
|
20
|
+
|
|
21
|
+
export type WorkspaceEntry = {
|
|
22
|
+
name: string;
|
|
23
|
+
/** 相对工作目录 */
|
|
24
|
+
path: string;
|
|
25
|
+
type: "dir" | "file";
|
|
26
|
+
/** 目录没有大小 */
|
|
27
|
+
size?: number;
|
|
28
|
+
mtime: number;
|
|
29
|
+
/** 符号链接:显示时标一下,指向的类型算在 type 里 */
|
|
30
|
+
link?: boolean;
|
|
31
|
+
};
|
|
32
|
+
|
|
33
|
+
export type WorkspaceListing = {
|
|
34
|
+
/** 相对工作目录,根目录是 "" */
|
|
35
|
+
path: string;
|
|
36
|
+
entries: WorkspaceEntry[];
|
|
37
|
+
/** 项太多,只列了前一部分 */
|
|
38
|
+
truncated: boolean;
|
|
39
|
+
};
|
|
40
|
+
|
|
41
|
+
function inside(dir: string, target: string): boolean {
|
|
42
|
+
return target === dir || target.startsWith(dir.endsWith(path.sep) ? dir : dir + path.sep);
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
/** 不分大小写的文件系统(macOS、Windows)上 .GIT 就是 .git */
|
|
46
|
+
function blocked(file: string): boolean {
|
|
47
|
+
return file.split(path.sep).some((part) => part.toLowerCase() === ".git") || isSensitivePath(file);
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
/** 给页面的相对路径一律用斜杠,Windows 上也一样 */
|
|
51
|
+
const toPosix = (rel: string): string => (path.sep === "/" ? rel : rel.split(path.sep).join("/"));
|
|
52
|
+
|
|
53
|
+
/** 会话的工作目录。目录没了、配置改过后不在工作区之内:undefined */
|
|
54
|
+
export function workspaceDir(cwd: string): string | undefined {
|
|
55
|
+
return resolveWorkspacePath(cwd) ?? undefined;
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
/** 相对路径 → 绝对路径和解析符号链接后的路径。不合规矩返回 undefined */
|
|
59
|
+
function resolveEntry(cwd: string, rel: string): { abs: string; real: string; stat: fs.Stats } | undefined {
|
|
60
|
+
if (rel.includes("\0") || path.isAbsolute(rel)) return undefined;
|
|
61
|
+
const abs = path.resolve(cwd, rel);
|
|
62
|
+
if (!inside(cwd, abs) || blocked(abs)) return undefined;
|
|
63
|
+
try {
|
|
64
|
+
const real = fs.realpathSync(abs);
|
|
65
|
+
if (!inside(fs.realpathSync(config().workspaceRoot), real) || blocked(real)) return undefined;
|
|
66
|
+
return { abs, real, stat: fs.statSync(real) };
|
|
67
|
+
} catch {
|
|
68
|
+
return undefined;
|
|
69
|
+
}
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
/** 解析成可以给前端看的真实文件路径。不存在、不是普通文件、不能看:undefined */
|
|
73
|
+
export function resolveWorkspaceFile(cwd: string, rel: string): string | undefined {
|
|
74
|
+
const entry = rel ? resolveEntry(cwd, rel) : undefined;
|
|
75
|
+
return entry?.stat.isFile() ? entry.real : undefined;
|
|
76
|
+
}
|
|
77
|
+
|
|
78
|
+
/** 列一层目录:目录在前,按名字自然排序。不能看的(敏感文件、跳出工作区的链接)直接不出现 */
|
|
79
|
+
export function listWorkspaceEntries(cwd: string, rel: string): WorkspaceListing | undefined {
|
|
80
|
+
const dir = resolveEntry(cwd, rel);
|
|
81
|
+
if (!dir?.stat.isDirectory()) return undefined;
|
|
82
|
+
const base = toPosix(path.relative(cwd, dir.abs));
|
|
83
|
+
let names: fs.Dirent[];
|
|
84
|
+
try {
|
|
85
|
+
names = fs.readdirSync(dir.real, { withFileTypes: true });
|
|
86
|
+
} catch {
|
|
87
|
+
return undefined;
|
|
88
|
+
}
|
|
89
|
+
const collator = new Intl.Collator("zh-CN", { numeric: true, sensitivity: "base" });
|
|
90
|
+
// 目录排前面再截断:项太多时不至于把目录截掉(指向目录的符号链接到后面才知道,最后再排一次)
|
|
91
|
+
names.sort((a, b) => Number(b.isDirectory()) - Number(a.isDirectory()) || collator.compare(a.name, b.name));
|
|
92
|
+
const entries: WorkspaceEntry[] = [];
|
|
93
|
+
let truncated = false;
|
|
94
|
+
for (const item of names) {
|
|
95
|
+
if (entries.length >= LIST_MAX) {
|
|
96
|
+
truncated = true;
|
|
97
|
+
break;
|
|
98
|
+
}
|
|
99
|
+
const child = base ? `${base}/${item.name}` : item.name;
|
|
100
|
+
const found = resolveEntry(cwd, child);
|
|
101
|
+
if (!found) continue;
|
|
102
|
+
const isDir = found.stat.isDirectory();
|
|
103
|
+
// 管道、设备文件之类的打开了也看不了
|
|
104
|
+
if (!isDir && !found.stat.isFile()) continue;
|
|
105
|
+
entries.push({
|
|
106
|
+
name: item.name,
|
|
107
|
+
path: child,
|
|
108
|
+
type: isDir ? "dir" : "file",
|
|
109
|
+
...(isDir ? {} : { size: found.stat.size }),
|
|
110
|
+
mtime: found.stat.mtimeMs,
|
|
111
|
+
...(item.isSymbolicLink() ? { link: true } : {}),
|
|
112
|
+
});
|
|
113
|
+
}
|
|
114
|
+
entries.sort((a, b) => Number(b.type === "dir") - Number(a.type === "dir"));
|
|
115
|
+
return { path: base, entries, truncated };
|
|
116
|
+
}
|
|
117
|
+
|
|
118
|
+
// ---------- 编辑 ----------
|
|
119
|
+
|
|
120
|
+
/** 能在网页里编辑的文件大小上限(和预览时读的上限一致:超过的只读得到开头,保存会把文件截断) */
|
|
121
|
+
export const EDIT_MAX_BYTES = 1024 * 1024;
|
|
122
|
+
/** 保存时收的内容上限:编辑时可能粘贴进更多内容 */
|
|
123
|
+
export const SAVE_MAX_BYTES = 8 * 1024 * 1024;
|
|
124
|
+
/** 上传到工作目录的文件上限(和对话附件一致) */
|
|
125
|
+
export const UPLOAD_MAX_BYTES = 50 * 1024 * 1024;
|
|
126
|
+
|
|
127
|
+
/** 带 HTTP 状态的错误:接口层照着回 */
|
|
128
|
+
export class WorkspaceError extends Error {
|
|
129
|
+
constructor(
|
|
130
|
+
readonly status: number,
|
|
131
|
+
message: string,
|
|
132
|
+
readonly extra: Record<string, unknown> = {},
|
|
133
|
+
) {
|
|
134
|
+
super(message);
|
|
135
|
+
}
|
|
136
|
+
}
|
|
137
|
+
|
|
138
|
+
const hashOf = (data: Buffer | string) => crypto.createHash("sha256").update(data).digest("hex");
|
|
139
|
+
|
|
140
|
+
export type WorkspaceText = { path: string; name: string; content: string; hash: string; size: number; mtime: number };
|
|
141
|
+
|
|
142
|
+
/** 读出来编辑。太大、不是文本、不是 UTF-8 的不给编辑 —— 改完存回去内容会坏 */
|
|
143
|
+
export function readWorkspaceText(cwd: string, rel: string): WorkspaceText {
|
|
144
|
+
const file = resolveWorkspaceFile(cwd, rel);
|
|
145
|
+
if (!file) throw new WorkspaceError(404, "文件不存在,或者不能查看");
|
|
146
|
+
const st = fs.statSync(file);
|
|
147
|
+
if (st.size > EDIT_MAX_BYTES) throw new WorkspaceError(413, "文件超过 1 MB,不能在网页里编辑");
|
|
148
|
+
const data = fs.readFileSync(file);
|
|
149
|
+
if (data.includes(0)) throw new WorkspaceError(415, "这个文件不是文本,不能编辑");
|
|
150
|
+
const content = data.toString("utf8");
|
|
151
|
+
if (!Buffer.from(content, "utf8").equals(data)) throw new WorkspaceError(415, "这个文件不是 UTF-8 编码,保存会损坏内容,不能编辑");
|
|
152
|
+
return { path: rel, name: path.basename(file), content, hash: hashOf(data), size: st.size, mtime: st.mtimeMs };
|
|
153
|
+
}
|
|
154
|
+
|
|
155
|
+
function isErrno(err: unknown, ...codes: string[]): boolean {
|
|
156
|
+
return codes.includes((err as NodeJS.ErrnoException).code ?? "");
|
|
157
|
+
}
|
|
158
|
+
|
|
159
|
+
function writeError(err: unknown, action: string): WorkspaceError {
|
|
160
|
+
if (err instanceof WorkspaceError) return err;
|
|
161
|
+
if (isErrno(err, "EACCES", "EPERM", "EROFS")) return new WorkspaceError(403, `没有权限${action}`);
|
|
162
|
+
if (isErrno(err, "ENOSPC", "EDQUOT")) return new WorkspaceError(507, "磁盘空间不足");
|
|
163
|
+
return new WorkspaceError(500, `${action}失败:${err instanceof Error ? err.message : String(err)}`);
|
|
164
|
+
}
|
|
165
|
+
|
|
166
|
+
/** 先写到同目录的临时文件再改名:写到一半出错、断电,原文件都还是完整的。保留原来的权限 */
|
|
167
|
+
function writeAtomic(file: string, data: Buffer, mode?: number): void {
|
|
168
|
+
const temp = path.join(path.dirname(file), `.${path.basename(file).slice(0, 100)}.${crypto.randomBytes(4).toString("hex")}.aloft-tmp`);
|
|
169
|
+
try {
|
|
170
|
+
fs.writeFileSync(temp, data, { flag: "wx", ...(mode !== undefined ? { mode } : {}) });
|
|
171
|
+
// writeFile 的 mode 会被 umask 削掉
|
|
172
|
+
if (mode !== undefined) fs.chmodSync(temp, mode);
|
|
173
|
+
fs.renameSync(temp, file);
|
|
174
|
+
} catch (err) {
|
|
175
|
+
fs.rmSync(temp, { force: true });
|
|
176
|
+
throw err;
|
|
177
|
+
}
|
|
178
|
+
}
|
|
179
|
+
|
|
180
|
+
/**
|
|
181
|
+
* 保存。baseHash 是读出来时的内容 hash:文件这期间被 agent 或别人改过就返回 409,不覆盖;
|
|
182
|
+
* force 明确要覆盖时不看 hash。文件已经被删掉:一样算冲突,force 时重新创建。
|
|
183
|
+
*/
|
|
184
|
+
export function saveWorkspaceText(cwd: string, rel: string, content: string, opts: { baseHash?: string; force?: boolean }): { hash: string; size: number; mtime: number } {
|
|
185
|
+
const data = Buffer.from(content, "utf8");
|
|
186
|
+
const existing = rel ? resolveEntry(cwd, rel) : undefined;
|
|
187
|
+
let target: string;
|
|
188
|
+
let mode: number | undefined;
|
|
189
|
+
if (existing) {
|
|
190
|
+
if (!existing.stat.isFile()) throw new WorkspaceError(400, "这不是文件,不能保存");
|
|
191
|
+
target = existing.real;
|
|
192
|
+
mode = existing.stat.mode & 0o7777;
|
|
193
|
+
if (!opts.force && hashOf(fs.readFileSync(target)) !== opts.baseHash) {
|
|
194
|
+
throw new WorkspaceError(409, "文件已经被改过了", { conflict: "changed" });
|
|
195
|
+
}
|
|
196
|
+
// 改名替换不看文件本身的权限,只读文件得在这里挡住
|
|
197
|
+
try {
|
|
198
|
+
fs.accessSync(target, fs.constants.W_OK);
|
|
199
|
+
} catch {
|
|
200
|
+
throw new WorkspaceError(403, "这个文件是只读的");
|
|
201
|
+
}
|
|
202
|
+
} else {
|
|
203
|
+
target = resolveNewEntry(cwd, path.dirname(rel) === "." ? "" : path.dirname(rel), path.basename(rel));
|
|
204
|
+
// 路径上有东西但看不了(比如跳出工作区的链接):不能把它换成一个文件
|
|
205
|
+
if (fs.lstatSync(target, { throwIfNoEntry: false })) throw new WorkspaceError(404, "文件不存在,或者不能查看");
|
|
206
|
+
if (!opts.force) throw new WorkspaceError(409, "文件已经被删掉了", { conflict: "deleted" });
|
|
207
|
+
}
|
|
208
|
+
try {
|
|
209
|
+
writeAtomic(target, data, mode);
|
|
210
|
+
} catch (err) {
|
|
211
|
+
throw writeError(err, "保存");
|
|
212
|
+
}
|
|
213
|
+
const st = fs.statSync(target);
|
|
214
|
+
return { hash: hashOf(data), size: st.size, mtime: st.mtimeMs };
|
|
215
|
+
}
|
|
216
|
+
|
|
217
|
+
// ---------- 新建、重命名、删除、上传 ----------
|
|
218
|
+
|
|
219
|
+
function checkName(name: unknown): string {
|
|
220
|
+
const n = typeof name === "string" ? name.trim() : "";
|
|
221
|
+
if (!n || n === "." || n === ".." || /[\\/\x00-\x1f\x7f]/.test(n) || Buffer.byteLength(n) > 255) {
|
|
222
|
+
throw new WorkspaceError(400, "请输入有效的名称,不能包含斜杠或控制字符");
|
|
223
|
+
}
|
|
224
|
+
return n;
|
|
225
|
+
}
|
|
226
|
+
|
|
227
|
+
/** 要在 dir(相对工作目录)里新建的东西的绝对路径:目录要存在且能看,新名字不能是敏感文件 */
|
|
228
|
+
function resolveNewEntry(cwd: string, dir: string, name: unknown): string {
|
|
229
|
+
const n = checkName(name);
|
|
230
|
+
const parent = resolveEntry(cwd, dir);
|
|
231
|
+
if (!parent?.stat.isDirectory()) throw new WorkspaceError(404, "目录不存在,或者不能查看");
|
|
232
|
+
const target = path.join(parent.real, n);
|
|
233
|
+
if (blocked(target) || blocked(path.join(parent.abs, n))) throw new WorkspaceError(403, "敏感文件和 .git 里的东西不能在这里操作");
|
|
234
|
+
return target;
|
|
235
|
+
}
|
|
236
|
+
|
|
237
|
+
function assertFree(target: string): void {
|
|
238
|
+
if (fs.lstatSync(target, { throwIfNoEntry: false })) throw new WorkspaceError(409, "同名文件或文件夹已存在");
|
|
239
|
+
}
|
|
240
|
+
|
|
241
|
+
export function createWorkspaceEntry(cwd: string, dir: string, name: unknown, type: unknown): { path: string; type: "file" | "dir" } {
|
|
242
|
+
const target = resolveNewEntry(cwd, dir, name);
|
|
243
|
+
assertFree(target);
|
|
244
|
+
const kind = type === "dir" ? "dir" : "file";
|
|
245
|
+
try {
|
|
246
|
+
if (kind === "dir") fs.mkdirSync(target);
|
|
247
|
+
else fs.writeFileSync(target, "", { flag: "wx" });
|
|
248
|
+
} catch (err) {
|
|
249
|
+
if (isErrno(err, "EEXIST")) throw new WorkspaceError(409, "同名文件或文件夹已存在");
|
|
250
|
+
throw writeError(err, "新建");
|
|
251
|
+
}
|
|
252
|
+
return { path: toPosix(path.join(dir, path.basename(target))), type: kind };
|
|
253
|
+
}
|
|
254
|
+
|
|
255
|
+
/**
|
|
256
|
+
* 要改名、删除的东西本身(不跟符号链接:删链接不能变成删它指向的内容)。
|
|
257
|
+
* 工作目录本身不行;目录里有别的会话的工作目录也不行,那些会话要从项目菜单里处理。
|
|
258
|
+
*/
|
|
259
|
+
function resolveExisting(cwd: string, rel: string, conversationDirs: string[]): { target: string; isDir: boolean } {
|
|
260
|
+
if (!rel || rel.includes("\0") || path.isAbsolute(rel)) throw new WorkspaceError(404, "文件不存在,或者不能操作");
|
|
261
|
+
const abs = path.resolve(cwd, rel);
|
|
262
|
+
if (abs === cwd || !inside(cwd, abs)) throw new WorkspaceError(403, "不能操作工作目录本身");
|
|
263
|
+
const parent = resolveEntry(cwd, path.relative(cwd, path.dirname(abs)));
|
|
264
|
+
if (!parent?.stat.isDirectory()) throw new WorkspaceError(404, "文件不存在,或者不能操作");
|
|
265
|
+
const target = path.join(parent.real, path.basename(abs));
|
|
266
|
+
if (blocked(target) || blocked(abs)) throw new WorkspaceError(404, "文件不存在,或者不能操作");
|
|
267
|
+
const st = fs.lstatSync(target, { throwIfNoEntry: false });
|
|
268
|
+
if (!st) throw new WorkspaceError(404, "文件不存在,或者不能操作");
|
|
269
|
+
if (st.isDirectory() && conversationDirs.some((dir) => inside(target, dir))) {
|
|
270
|
+
throw new WorkspaceError(409, "这个目录是其他会话的工作目录,或者包含其他会话的工作目录,不能在这里操作");
|
|
271
|
+
}
|
|
272
|
+
return { target, isDir: st.isDirectory() };
|
|
273
|
+
}
|
|
274
|
+
|
|
275
|
+
export function renameWorkspaceEntry(cwd: string, rel: string, name: unknown, conversationDirs: string[]): { path: string } {
|
|
276
|
+
const { target } = resolveExisting(cwd, rel, conversationDirs);
|
|
277
|
+
const relDir = path.dirname(rel) === "." ? "" : path.dirname(rel);
|
|
278
|
+
const next = resolveNewEntry(cwd, relDir, name);
|
|
279
|
+
if (next === target) return { path: rel };
|
|
280
|
+
// 不分大小写的文件系统上,只改大小写时新旧名字是同一个文件,不算重名
|
|
281
|
+
const from = fs.lstatSync(target);
|
|
282
|
+
const to = fs.lstatSync(next, { throwIfNoEntry: false });
|
|
283
|
+
if (to && (to.ino !== from.ino || to.dev !== from.dev)) throw new WorkspaceError(409, "同名文件或文件夹已存在");
|
|
284
|
+
try {
|
|
285
|
+
fs.renameSync(target, next);
|
|
286
|
+
} catch (err) {
|
|
287
|
+
if (isErrno(err, "EEXIST", "ENOTEMPTY")) throw new WorkspaceError(409, "同名文件或文件夹已存在");
|
|
288
|
+
throw writeError(err, "重命名");
|
|
289
|
+
}
|
|
290
|
+
return { path: toPosix(path.join(relDir, path.basename(next))) };
|
|
291
|
+
}
|
|
292
|
+
|
|
293
|
+
export function deleteWorkspaceEntry(cwd: string, rel: string, conversationDirs: string[]): void {
|
|
294
|
+
const { target, isDir } = resolveExisting(cwd, rel, conversationDirs);
|
|
295
|
+
try {
|
|
296
|
+
if (isDir) fs.rmSync(target, { recursive: true });
|
|
297
|
+
else fs.unlinkSync(target);
|
|
298
|
+
} catch (err) {
|
|
299
|
+
throw writeError(err, "删除");
|
|
300
|
+
}
|
|
301
|
+
}
|
|
302
|
+
|
|
303
|
+
export function uploadWorkspaceFile(cwd: string, dir: string, name: unknown, data: Buffer, overwrite: boolean): { path: string } {
|
|
304
|
+
const target = resolveNewEntry(cwd, dir, name);
|
|
305
|
+
const st = fs.lstatSync(target, { throwIfNoEntry: false });
|
|
306
|
+
if (st && !overwrite) throw new WorkspaceError(409, "同名文件已存在", { conflict: "exists" });
|
|
307
|
+
// 不替换目录,也不替换符号链接:把链接换成文件多半不是想要的结果
|
|
308
|
+
if (st && !st.isFile()) throw new WorkspaceError(409, "同名的文件夹或链接已存在,不能覆盖");
|
|
309
|
+
try {
|
|
310
|
+
writeAtomic(target, data, st ? st.mode & 0o7777 : undefined);
|
|
311
|
+
} catch (err) {
|
|
312
|
+
throw writeError(err, "上传");
|
|
313
|
+
}
|
|
314
|
+
return { path: toPosix(path.join(dir, path.basename(target))) };
|
|
315
|
+
}
|
package/src/mcp/tasks-server.ts
CHANGED
|
@@ -66,6 +66,10 @@ const TOOLS = [
|
|
|
66
66
|
enum: ["this_conversation", "dedicated"],
|
|
67
67
|
description: "this_conversation:结果回到当前对话(默认);dedicated:给任务单独开一条对话(和当前对话用同一个专家)",
|
|
68
68
|
},
|
|
69
|
+
fresh_context: {
|
|
70
|
+
type: "boolean",
|
|
71
|
+
description: "true:每次运行都不带之前的上下文,看不到聊天内容和以前的运行结果,更省 token。发到当前对话时会在独立的会话里运行,不打乱聊天。默认 false",
|
|
72
|
+
},
|
|
69
73
|
},
|
|
70
74
|
required: ["prompt", "schedule"],
|
|
71
75
|
additionalProperties: false,
|
|
@@ -74,7 +78,7 @@ const TOOLS = [
|
|
|
74
78
|
},
|
|
75
79
|
{
|
|
76
80
|
name: "update_task",
|
|
77
|
-
description: "
|
|
81
|
+
description: "修改用户的一个定时任务:改名称、提示词、频率、提醒方式、是否携带上下文,或者暂停 / 恢复(enabled)。只给要改的字段。除了暂停以外的修改会弹授权卡让用户确认。",
|
|
78
82
|
inputSchema: {
|
|
79
83
|
type: "object",
|
|
80
84
|
properties: {
|
|
@@ -84,6 +88,7 @@ const TOOLS = [
|
|
|
84
88
|
schedule: SCHEDULE,
|
|
85
89
|
notify: { type: "string", enum: ["smart", "always"] },
|
|
86
90
|
enabled: { type: "boolean", description: "false 暂停,true 恢复" },
|
|
91
|
+
fresh_context: { type: "boolean", description: "true:每次运行不带之前的上下文;false:改回携带(之前不携带时运行的内容不会恢复)" },
|
|
87
92
|
},
|
|
88
93
|
required: ["id"],
|
|
89
94
|
additionalProperties: false,
|
package/web/css/experts.css
CHANGED
|
@@ -23,11 +23,13 @@
|
|
|
23
23
|
min-width: 0;
|
|
24
24
|
}
|
|
25
25
|
|
|
26
|
-
.tool-check-item > input
|
|
26
|
+
.tool-check-item > input,
|
|
27
|
+
.perm-list > .check-item > input {
|
|
27
28
|
flex-shrink: 0;
|
|
28
29
|
}
|
|
29
30
|
|
|
30
|
-
.tool-check-item > span
|
|
31
|
+
.tool-check-item > span,
|
|
32
|
+
.perm-list > .check-item > span {
|
|
31
33
|
flex: 0 0 auto;
|
|
32
34
|
max-width: calc(100% - 28px);
|
|
33
35
|
white-space: nowrap;
|
|
@@ -35,7 +37,8 @@
|
|
|
35
37
|
text-overflow: ellipsis;
|
|
36
38
|
}
|
|
37
39
|
|
|
38
|
-
.tool-check-item > small
|
|
40
|
+
.tool-check-item > small,
|
|
41
|
+
.perm-list > .check-item > small {
|
|
39
42
|
flex: 1;
|
|
40
43
|
}
|
|
41
44
|
|
package/web/css/settings.css
CHANGED
|
@@ -1,5 +1,36 @@
|
|
|
1
1
|
/* ---------- 设置 ---------- */
|
|
2
2
|
|
|
3
|
+
/* 设置和从设置打开的弹层共用黑白主题,覆盖原生控件的系统强调色。 */
|
|
4
|
+
.settings,
|
|
5
|
+
body:has(.settings) > :is(.overlay, .menu) {
|
|
6
|
+
--accent: var(--fg);
|
|
7
|
+
--accent-fg: var(--bg);
|
|
8
|
+
--link: var(--fg);
|
|
9
|
+
accent-color: var(--accent);
|
|
10
|
+
}
|
|
11
|
+
|
|
12
|
+
:is(.settings, body:has(.settings) > .overlay, body:has(.settings) > .menu) a:not(.btn) {
|
|
13
|
+
color: var(--link);
|
|
14
|
+
}
|
|
15
|
+
|
|
16
|
+
:is(.settings, body:has(.settings) > .overlay, body:has(.settings) > .menu) .switch input:checked + .slider::before {
|
|
17
|
+
background: var(--accent-fg);
|
|
18
|
+
}
|
|
19
|
+
|
|
20
|
+
:is(.settings, body:has(.settings) > .overlay, body:has(.settings) > .menu) .btn.accent:hover:not(:disabled) {
|
|
21
|
+
opacity: 0.85;
|
|
22
|
+
}
|
|
23
|
+
|
|
24
|
+
:is(.settings, body:has(.settings) > .overlay, body:has(.settings) > .menu) .btn:disabled {
|
|
25
|
+
opacity: 0.5;
|
|
26
|
+
}
|
|
27
|
+
|
|
28
|
+
:is(.settings, body:has(.settings) > .overlay, body:has(.settings) > .menu)
|
|
29
|
+
:is(button, a, summary, input[type="checkbox"], input[type="radio"]):focus-visible {
|
|
30
|
+
outline: 2px solid var(--accent);
|
|
31
|
+
outline-offset: 2px;
|
|
32
|
+
}
|
|
33
|
+
|
|
3
34
|
.settings {
|
|
4
35
|
display: flex;
|
|
5
36
|
min-height: 0;
|