glimmervoid 0.46.2-next.166 → 0.46.2-next.168
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/dist/bin/glimmervoid.js +7 -7
- package/dist/chunks/{adapters-DmzmKIDw.js → adapters-3RuVH2qm.js} +3 -1
- package/dist/chunks/{adapters-d3XIppeP.js → adapters-yHbHeeiD.js} +1 -1
- package/dist/chunks/{agent-setup-cli-C7x4N5U6.js → agent-setup-cli-DHqTFNcZ.js} +3 -68
- package/dist/chunks/grok-DnkhGGf5.js +369 -0
- package/dist/chunks/kimi-BiLAVDKd.js +232 -0
- package/dist/chunks/kimi-CjswbYS5.js +1 -0
- package/dist/chunks/kimi-home-CYJpt82i.js +860 -0
- package/dist/chunks/kimi-home-DyWG81oB.js +1 -0
- package/dist/chunks/{main-Dyx_oiMS.js → main-DZQJiOBQ.js} +24 -161
- package/dist/chunks/spawn-env-BFfAkGlR.js +82 -0
- package/dist/client/assets/{alert-sound-CMw9IYOa.js → alert-sound-Bef4LEZ_.js} +1 -1
- package/dist/client/assets/alert-sound-Bef4LEZ_.js.br +0 -0
- package/dist/client/assets/{benchmark-panel-12iKvivr.js → benchmark-panel-BXkbrZ2r.js} +1 -1
- package/dist/client/assets/benchmark-panel-BXkbrZ2r.js.br +0 -0
- package/dist/client/assets/{celebration-player-CpgG9DUA.js → celebration-player-BC_vrnJd.js} +1 -1
- package/dist/client/assets/celebration-player-BC_vrnJd.js.br +0 -0
- package/dist/client/assets/{dialogs-x_B527bk.js → dialogs-D_bkBkDI.js} +1 -1
- package/dist/client/assets/dialogs-D_bkBkDI.js.br +0 -0
- package/dist/client/assets/{doc-editor-ui-CIhJUO3J.js → doc-editor-ui-WURReoK0.js} +1 -1
- package/dist/client/assets/doc-editor-ui-WURReoK0.js.br +0 -0
- package/dist/client/assets/{feature-hint-MLJvjOT0.js → feature-hint-BsGHHzie.js} +1 -1
- package/dist/client/assets/feature-hint-BsGHHzie.js.br +0 -0
- package/dist/client/assets/{first-run-checklist-s4X-OM4Z.js → first-run-checklist-zfh60jLU.js} +1 -1
- package/dist/client/assets/first-run-checklist-zfh60jLU.js.br +0 -0
- package/dist/client/assets/{hooks-panel-121qcKFE.js → hooks-panel-_QCDTFlk.js} +1 -1
- package/dist/client/assets/hooks-panel-_QCDTFlk.js.br +0 -0
- package/dist/client/assets/{index-BJ8diTZl.js → index-2xbSsu75.js} +5 -5
- package/dist/client/assets/index-2xbSsu75.js.br +0 -0
- package/dist/client/assets/{issues-panel-CMZFcUDT.js → issues-panel-BRvuSbN2.js} +1 -1
- package/dist/client/assets/issues-panel-BRvuSbN2.js.br +0 -0
- package/dist/client/assets/{nyan-cat-BvxG-Hhz.js → nyan-cat-dzC4D1dQ.js} +1 -1
- package/dist/client/assets/nyan-cat-dzC4D1dQ.js.br +0 -0
- package/dist/client/assets/{phone-shell-DtQYi3Yz.js → phone-shell-BCoSY_6R.js} +1 -1
- package/dist/client/assets/phone-shell-BCoSY_6R.js.br +0 -0
- package/dist/client/assets/{plan-face-BfwHo5re.js → plan-face-PeDpLo-L.js} +1 -1
- package/dist/client/assets/plan-face-PeDpLo-L.js.br +0 -0
- package/dist/client/assets/{plan-render-QchOXg1E.js → plan-render-qGWAegR9.js} +1 -1
- package/dist/client/assets/plan-render-qGWAegR9.js.br +0 -0
- package/dist/client/assets/{pr-scope-tabs-BqPN4zAH.js → pr-scope-tabs-Z7CclL2Y.js} +1 -1
- package/dist/client/assets/pr-scope-tabs-Z7CclL2Y.js.br +0 -0
- package/dist/client/assets/{radar-panel-DQCaWDNM.js → radar-panel-CiwRuHcB.js} +1 -1
- package/dist/client/assets/radar-panel-CiwRuHcB.js.br +0 -0
- package/dist/client/assets/{resume-dialog-C_NFnnAx.js → resume-dialog-jMGA0X1R.js} +1 -1
- package/dist/client/assets/resume-dialog-jMGA0X1R.js.br +0 -0
- package/dist/client/assets/{review-queue-panel-DTM1__rk.js → review-queue-panel-yhBG1XCq.js} +1 -1
- package/dist/client/assets/review-queue-panel-yhBG1XCq.js.br +0 -0
- package/dist/client/assets/{settings-panel-k5MM_UFC.js → settings-panel-BbdgDk2F.js} +2 -2
- package/dist/client/assets/settings-panel-BbdgDk2F.js.br +0 -0
- package/dist/client/assets/{shown-lightbox-Bdv2LDYa.js → shown-lightbox-DdkmOdgi.js} +1 -1
- package/dist/client/assets/shown-lightbox-DdkmOdgi.js.br +0 -0
- package/dist/client/assets/{trace-panel-BlczKgbw.js → trace-panel-C8nPGXMh.js} +1 -1
- package/dist/client/assets/trace-panel-C8nPGXMh.js.br +0 -0
- package/dist/client/assets/{usage-panel-DeCYlwfG.js → usage-panel-D08cvZR-.js} +1 -1
- package/dist/client/assets/usage-panel-D08cvZR-.js.br +0 -0
- package/dist/client/assets/{visions-panel-IoBQ4LJF.js → visions-panel-jUraIFz8.js} +1 -1
- package/dist/client/assets/visions-panel-jUraIFz8.js.br +0 -0
- package/dist/client/index.html +1 -1
- package/dist/client/index.html.br +0 -0
- package/dist/server/index.js +1 -1
- package/package.json +1 -1
- package/dist/chunks/kimi-Be_QndbF.js +0 -1168
- package/dist/client/assets/alert-sound-CMw9IYOa.js.br +0 -0
- package/dist/client/assets/benchmark-panel-12iKvivr.js.br +0 -0
- package/dist/client/assets/celebration-player-CpgG9DUA.js.br +0 -0
- package/dist/client/assets/dialogs-x_B527bk.js.br +0 -0
- package/dist/client/assets/doc-editor-ui-CIhJUO3J.js.br +0 -0
- package/dist/client/assets/feature-hint-MLJvjOT0.js.br +0 -0
- package/dist/client/assets/first-run-checklist-s4X-OM4Z.js.br +0 -0
- package/dist/client/assets/hooks-panel-121qcKFE.js.br +0 -0
- package/dist/client/assets/index-BJ8diTZl.js.br +0 -0
- package/dist/client/assets/issues-panel-CMZFcUDT.js.br +0 -0
- package/dist/client/assets/nyan-cat-BvxG-Hhz.js.br +0 -0
- package/dist/client/assets/phone-shell-DtQYi3Yz.js.br +0 -0
- package/dist/client/assets/plan-face-BfwHo5re.js.br +0 -0
- package/dist/client/assets/plan-render-QchOXg1E.js.br +0 -0
- package/dist/client/assets/pr-scope-tabs-BqPN4zAH.js.br +0 -0
- package/dist/client/assets/radar-panel-DQCaWDNM.js.br +0 -0
- package/dist/client/assets/resume-dialog-C_NFnnAx.js.br +0 -0
- package/dist/client/assets/review-queue-panel-DTM1__rk.js.br +0 -0
- package/dist/client/assets/settings-panel-k5MM_UFC.js.br +0 -0
- package/dist/client/assets/shown-lightbox-Bdv2LDYa.js.br +0 -0
- package/dist/client/assets/trace-panel-BlczKgbw.js.br +0 -0
- package/dist/client/assets/usage-panel-DeCYlwfG.js.br +0 -0
- package/dist/client/assets/visions-panel-IoBQ4LJF.js.br +0 -0
|
@@ -0,0 +1,860 @@
|
|
|
1
|
+
import { a as isMissingFileError, r as errorMessage } from "./text-DoirglWV.js";
|
|
2
|
+
import { n as glimmervoidHomeDir } from "./config-path-core-DUWk0Lui.js";
|
|
3
|
+
import { t as buildHookCommand } from "./hook-command-core-qTNK-xMF.js";
|
|
4
|
+
import { p as writeTextAtomicSync } from "./json-file-BjFK_eSH.js";
|
|
5
|
+
import { createRequire } from "node:module";
|
|
6
|
+
import fs, { closeSync, mkdirSync, openSync, readdirSync, renameSync, rmSync, unlinkSync } from "node:fs";
|
|
7
|
+
import path from "node:path";
|
|
8
|
+
import os from "node:os";
|
|
9
|
+
import { randomUUID } from "node:crypto";
|
|
10
|
+
//#region session/core/kimi-hooks-block-core.ts
|
|
11
|
+
var BLOCK_START = "# >>> glimmervoid hooks (managed, inert outside Glimmervoid) >>>";
|
|
12
|
+
var BLOCK_END = "# <<< glimmervoid hooks <<<";
|
|
13
|
+
var MANAGED_LINE_PATTERNS = Object.freeze([
|
|
14
|
+
/^\[\[hooks\]\]$/,
|
|
15
|
+
/^event = "[A-Za-z][A-Za-z0-9_-]{0,63}"$/,
|
|
16
|
+
/^matcher = '\^[A-Za-z0-9_]+\$'$/,
|
|
17
|
+
/^command = 'node (?:"[^"'\r\n]*\/(?:hook-relay|hook-tool-relay)\.(?:js|ts)"|[^\s"']*\/(?:hook-relay|hook-tool-relay)\.(?:js|ts)) [A-Za-z][A-Za-z0-9_-]{0,63}(?: [A-Za-z0-9_-]+)*'$/
|
|
18
|
+
]);
|
|
19
|
+
function hookTable(event, command, matcher = null) {
|
|
20
|
+
const lines = ["[[hooks]]", `event = "${event}"`];
|
|
21
|
+
if (matcher !== null) lines.push(`matcher = '${matcher}'`);
|
|
22
|
+
lines.push(`command = '${command}'`);
|
|
23
|
+
return lines;
|
|
24
|
+
}
|
|
25
|
+
function renderKimiHooksBlock(options) {
|
|
26
|
+
const lines = [BLOCK_START];
|
|
27
|
+
for (const event of options.events) {
|
|
28
|
+
const command = buildHookCommand(options.relayPath, event);
|
|
29
|
+
if (!command) return null;
|
|
30
|
+
lines.push(...hookTable(event, command));
|
|
31
|
+
}
|
|
32
|
+
for (const event of options.toolEvents) {
|
|
33
|
+
const command = buildHookCommand(options.relayPath, event);
|
|
34
|
+
if (!command) return null;
|
|
35
|
+
for (const toolName of options.matchedToolNames) lines.push(...hookTable(event, command, `^${toolName}$`));
|
|
36
|
+
}
|
|
37
|
+
const saneYoloCommand = buildHookCommand(options.saneYolo.relayPath, "saneYolo", [options.saneYolo.agentFlavor]);
|
|
38
|
+
if (!saneYoloCommand) return null;
|
|
39
|
+
for (const toolName of options.saneYolo.toolNames) lines.push(...hookTable("PreToolUse", saneYoloCommand, `^${toolName}$`));
|
|
40
|
+
lines.push(BLOCK_END);
|
|
41
|
+
return `${lines.join("\n")}\n`;
|
|
42
|
+
}
|
|
43
|
+
function lineEndAfter(configText, index) {
|
|
44
|
+
const newlineIndex = configText.indexOf("\n", index);
|
|
45
|
+
return newlineIndex === -1 ? configText.length : newlineIndex + 1;
|
|
46
|
+
}
|
|
47
|
+
function locateBlock(configText) {
|
|
48
|
+
const lines = configText.split("\n");
|
|
49
|
+
let offset = 0;
|
|
50
|
+
let start = null;
|
|
51
|
+
let end = null;
|
|
52
|
+
for (const rawLine of lines) {
|
|
53
|
+
const line = rawLine.replace(/\r$/, "");
|
|
54
|
+
if (line === "# >>> glimmervoid hooks (managed, inert outside Glimmervoid) >>>") {
|
|
55
|
+
if (start !== null) return "foreign";
|
|
56
|
+
start = offset;
|
|
57
|
+
}
|
|
58
|
+
if (line === "# <<< glimmervoid hooks <<<") {
|
|
59
|
+
if (start === null || end !== null) return "foreign";
|
|
60
|
+
end = lineEndAfter(configText, offset);
|
|
61
|
+
}
|
|
62
|
+
offset += rawLine.length + 1;
|
|
63
|
+
}
|
|
64
|
+
if (start === null && end === null) return "absent";
|
|
65
|
+
if (start === null || end === null) return "foreign";
|
|
66
|
+
return {
|
|
67
|
+
start,
|
|
68
|
+
end
|
|
69
|
+
};
|
|
70
|
+
}
|
|
71
|
+
function isManagedBlockBody(blockText) {
|
|
72
|
+
return blockText.split("\n").map((line) => line.replace(/\r$/, "")).filter((line) => line !== "").slice(1, -1).every((line) => MANAGED_LINE_PATTERNS.some((pattern) => pattern.test(line)));
|
|
73
|
+
}
|
|
74
|
+
var TABLE_HEADER_PATTERN = /^\s*\[/;
|
|
75
|
+
var HOOKS_TABLE_HEADER_PATTERN = /^\s*\[\s*hooks\s*[\].]/;
|
|
76
|
+
var TOP_LEVEL_HOOKS_KEY_PATTERN = /^\s*hooks\s*[=.]/;
|
|
77
|
+
function definesHooksOutsideArrayTables(operatorText) {
|
|
78
|
+
let isAtTopLevel = true;
|
|
79
|
+
for (const line of operatorText.split("\n")) {
|
|
80
|
+
if (HOOKS_TABLE_HEADER_PATTERN.test(line)) return true;
|
|
81
|
+
if (TABLE_HEADER_PATTERN.test(line)) isAtTopLevel = false;
|
|
82
|
+
if (isAtTopLevel && TOP_LEVEL_HOOKS_KEY_PATTERN.test(line)) return true;
|
|
83
|
+
}
|
|
84
|
+
return false;
|
|
85
|
+
}
|
|
86
|
+
function classifyKimiConfig(configText, expectedBlock) {
|
|
87
|
+
if (configText === null) return "absent";
|
|
88
|
+
const span = locateBlock(configText);
|
|
89
|
+
if (span === "foreign") return span;
|
|
90
|
+
if (definesHooksOutsideArrayTables(span === "absent" ? configText : `${configText.slice(0, span.start)}${configText.slice(span.end)}`)) return "conflicting";
|
|
91
|
+
if (span === "absent") return span;
|
|
92
|
+
const blockText = configText.slice(span.start, span.end);
|
|
93
|
+
if (blockText === expectedBlock) return "current";
|
|
94
|
+
if (isManagedBlockBody(blockText)) return "managed-stale";
|
|
95
|
+
return "foreign";
|
|
96
|
+
}
|
|
97
|
+
function spliceKimiHooksBlock(configText, block) {
|
|
98
|
+
if (configText === null || configText === "") return {
|
|
99
|
+
contents: block,
|
|
100
|
+
changed: true
|
|
101
|
+
};
|
|
102
|
+
const classification = classifyKimiConfig(configText, block);
|
|
103
|
+
if (classification === "current") return {
|
|
104
|
+
contents: configText,
|
|
105
|
+
changed: false
|
|
106
|
+
};
|
|
107
|
+
if (classification === "foreign" || classification === "conflicting") return { refused: classification };
|
|
108
|
+
if (classification === "absent") return {
|
|
109
|
+
contents: `${configText}${configText.endsWith("\n") ? "\n" : "\n\n"}${block}`,
|
|
110
|
+
changed: true
|
|
111
|
+
};
|
|
112
|
+
const span = locateBlock(configText);
|
|
113
|
+
if (span === "absent" || span === "foreign") return { refused: "foreign" };
|
|
114
|
+
return {
|
|
115
|
+
contents: `${configText.slice(0, span.start)}${block}${configText.slice(span.end)}`,
|
|
116
|
+
changed: true
|
|
117
|
+
};
|
|
118
|
+
}
|
|
119
|
+
var KIMI_CONFIG_NAME = "config.toml";
|
|
120
|
+
var KIMI_SOURCES_NAME = ".glimmervoid-sources.json";
|
|
121
|
+
var KIMI_CONFLICTS_NAME = ".glimmervoid-conflicts";
|
|
122
|
+
var KIMI_BASE_NAME = ".glimmervoid-base.toml";
|
|
123
|
+
var KIMI_IN_USE_LOCK_NAME = ".glimmervoid-in-use.lock";
|
|
124
|
+
var GENERATED_ONLY_NAMES = /* @__PURE__ */ new Set([
|
|
125
|
+
KIMI_CONFIG_NAME,
|
|
126
|
+
KIMI_SOURCES_NAME,
|
|
127
|
+
KIMI_CONFLICTS_NAME,
|
|
128
|
+
KIMI_BASE_NAME,
|
|
129
|
+
KIMI_IN_USE_LOCK_NAME
|
|
130
|
+
]);
|
|
131
|
+
var FILE_STAMP_PREFIX = "file:";
|
|
132
|
+
var TOML_TABLE_HEADER_PATTERN = /^\s*\[\[?([^[\]=]+)\]\]?\s*(?:#.*)?$/;
|
|
133
|
+
var TOML_KEY_PATTERN = /^\s*((?:[A-Za-z0-9_-]+|"[^"]*"|'[^']*')(?:\s*\.\s*(?:[A-Za-z0-9_-]+|"[^"]*"|'[^']*'))*)\s*=/;
|
|
134
|
+
var TOML_MULTILINE_QUOTES = ["\"\"\"", "'''"];
|
|
135
|
+
function withoutBlock(configText) {
|
|
136
|
+
const span = locateBlock(configText);
|
|
137
|
+
if (span === "foreign") return span;
|
|
138
|
+
if (span === "absent") return configText;
|
|
139
|
+
const operatorText = `${configText.slice(0, span.start)}${configText.slice(span.end)}`;
|
|
140
|
+
return operatorText.endsWith("\n\n") ? operatorText.slice(0, -1) : operatorText;
|
|
141
|
+
}
|
|
142
|
+
function togglesMultilineString(line) {
|
|
143
|
+
return TOML_MULTILINE_QUOTES.some((quotes) => line.split(quotes).length % 2 === 0);
|
|
144
|
+
}
|
|
145
|
+
function splitTomlUnits(configText) {
|
|
146
|
+
const units = {
|
|
147
|
+
preamble: "",
|
|
148
|
+
keys: [],
|
|
149
|
+
tables: []
|
|
150
|
+
};
|
|
151
|
+
const tableCounts = /* @__PURE__ */ new Map();
|
|
152
|
+
let current = null;
|
|
153
|
+
let isInTable = false;
|
|
154
|
+
let isInMultilineString = false;
|
|
155
|
+
for (const line of configText.split(/(?<=\n)/)) {
|
|
156
|
+
const header = isInMultilineString ? null : TOML_TABLE_HEADER_PATTERN.exec(line);
|
|
157
|
+
const key = isInMultilineString || isInTable || header ? null : TOML_KEY_PATTERN.exec(line);
|
|
158
|
+
if (togglesMultilineString(line)) isInMultilineString = !isInMultilineString;
|
|
159
|
+
if (header) {
|
|
160
|
+
const headerId = `${line.trim().startsWith("[[") ? "[[" : "["}${(header[1] ?? "").replaceAll(/\s/g, "")}`;
|
|
161
|
+
const occurrence = (tableCounts.get(headerId) ?? 0) + 1;
|
|
162
|
+
tableCounts.set(headerId, occurrence);
|
|
163
|
+
current = {
|
|
164
|
+
id: `${headerId}#${occurrence}`,
|
|
165
|
+
text: line
|
|
166
|
+
};
|
|
167
|
+
units.tables.push(current);
|
|
168
|
+
isInTable = true;
|
|
169
|
+
continue;
|
|
170
|
+
}
|
|
171
|
+
if (key) {
|
|
172
|
+
current = {
|
|
173
|
+
id: (key[1] ?? "").replaceAll(/\s/g, ""),
|
|
174
|
+
text: line
|
|
175
|
+
};
|
|
176
|
+
units.keys.push(current);
|
|
177
|
+
continue;
|
|
178
|
+
}
|
|
179
|
+
if (current) current.text += line;
|
|
180
|
+
if (!current) units.preamble += line;
|
|
181
|
+
}
|
|
182
|
+
return units;
|
|
183
|
+
}
|
|
184
|
+
function isSameUnit(first, second) {
|
|
185
|
+
return first?.text.trimEnd() === second?.text.trimEnd();
|
|
186
|
+
}
|
|
187
|
+
function mergeUnitList(base, ours, theirs) {
|
|
188
|
+
const baseById = new Map(base.map((unit) => [unit.id, unit]));
|
|
189
|
+
const oursById = new Map(ours.map((unit) => [unit.id, unit]));
|
|
190
|
+
const theirIds = new Set(theirs.map((unit) => unit.id));
|
|
191
|
+
const merged = [];
|
|
192
|
+
for (const theirUnit of theirs) {
|
|
193
|
+
const ourUnit = oursById.get(theirUnit.id);
|
|
194
|
+
const isOnlySessionChange = !isSameUnit(ourUnit, baseById.get(theirUnit.id)) && isSameUnit(theirUnit, baseById.get(theirUnit.id));
|
|
195
|
+
if (!isOnlySessionChange) merged.push(theirUnit);
|
|
196
|
+
if (isOnlySessionChange && ourUnit) merged.push(ourUnit);
|
|
197
|
+
}
|
|
198
|
+
for (const ourUnit of ours) if (!theirIds.has(ourUnit.id) && !baseById.has(ourUnit.id)) merged.push(ourUnit);
|
|
199
|
+
return merged;
|
|
200
|
+
}
|
|
201
|
+
function mergeTopLevelKeys(base, ours, theirs) {
|
|
202
|
+
if (theirs === base) return ours;
|
|
203
|
+
if (ours === base) return theirs;
|
|
204
|
+
const [baseUnits, ourUnits, theirUnits] = [
|
|
205
|
+
splitTomlUnits(base),
|
|
206
|
+
splitTomlUnits(ours),
|
|
207
|
+
splitTomlUnits(theirs)
|
|
208
|
+
];
|
|
209
|
+
const keys = mergeUnitList(baseUnits.keys, ourUnits.keys, theirUnits.keys).map((unit) => `${unit.text.trimEnd()}\n`);
|
|
210
|
+
const tables = mergeUnitList(baseUnits.tables, ourUnits.tables, theirUnits.tables).map((unit) => `\n${unit.text.trimEnd()}\n`);
|
|
211
|
+
return [
|
|
212
|
+
theirUnits.preamble,
|
|
213
|
+
...keys,
|
|
214
|
+
...tables
|
|
215
|
+
].join("");
|
|
216
|
+
}
|
|
217
|
+
var HOOKS_ARRAY_TABLE_ID_PREFIX = "[[hooks#";
|
|
218
|
+
function withoutUnmarkedHooks(ours, base) {
|
|
219
|
+
const baseHookTexts = new Set(splitTomlUnits(base).tables.map((unit) => unit.text.trimEnd()));
|
|
220
|
+
const ourUnits = splitTomlUnits(ours);
|
|
221
|
+
const keptTables = ourUnits.tables.filter((unit) => !unit.id.startsWith(HOOKS_ARRAY_TABLE_ID_PREFIX) || baseHookTexts.has(unit.text.trimEnd()));
|
|
222
|
+
if (keptTables.length === ourUnits.tables.length) return ours;
|
|
223
|
+
return [
|
|
224
|
+
ourUnits.preamble,
|
|
225
|
+
...ourUnits.keys.map((unit) => unit.text),
|
|
226
|
+
...keptTables.map((unit) => unit.text)
|
|
227
|
+
].join("");
|
|
228
|
+
}
|
|
229
|
+
function generatedKimiConfig(sources) {
|
|
230
|
+
const realText = sources.realConfigText ?? "";
|
|
231
|
+
const theirs = withoutBlock(realText);
|
|
232
|
+
if (theirs === "foreign") return { refusal: "its Glimmervoid hooks block markers are unbalanced" };
|
|
233
|
+
const hadBlock = theirs !== realText;
|
|
234
|
+
if (sources.baseConfigText === theirs && sources.generatedConfigText !== null && classifyKimiConfig(sources.generatedConfigText, sources.hooksBlock) === "current") return {
|
|
235
|
+
text: sources.generatedConfigText,
|
|
236
|
+
base: theirs,
|
|
237
|
+
hadBlock
|
|
238
|
+
};
|
|
239
|
+
const ours = sources.generatedConfigText === null ? "foreign" : withoutBlock(sources.generatedConfigText);
|
|
240
|
+
const operatorText = ours === "foreign" || sources.baseConfigText === null ? theirs : mergeTopLevelKeys(sources.baseConfigText, withoutUnmarkedHooks(ours, sources.baseConfigText), theirs);
|
|
241
|
+
if (definesHooksOutsideArrayTables(operatorText)) return { refusal: "it defines hooks as a key or [hooks] table, which a [[hooks]] block cannot extend" };
|
|
242
|
+
const spliced = spliceKimiHooksBlock(operatorText, sources.hooksBlock);
|
|
243
|
+
if ("refused" in spliced) return { refusal: `its hooks are ${spliced.refused}` };
|
|
244
|
+
return {
|
|
245
|
+
text: spliced.contents,
|
|
246
|
+
base: theirs,
|
|
247
|
+
hadBlock
|
|
248
|
+
};
|
|
249
|
+
}
|
|
250
|
+
function linkKindFor(kind, platform) {
|
|
251
|
+
if (platform !== "win32") return "symlink";
|
|
252
|
+
return kind === "folder" ? "junction" : "hardlink";
|
|
253
|
+
}
|
|
254
|
+
function fileStampKey(name) {
|
|
255
|
+
return `${FILE_STAMP_PREFIX}${name}`;
|
|
256
|
+
}
|
|
257
|
+
function planReplacedFile(real, target, lastFileStamp) {
|
|
258
|
+
if (real.fileStamp !== null && real.fileStamp === lastFileStamp) return {
|
|
259
|
+
kind: "promote",
|
|
260
|
+
name: real.name,
|
|
261
|
+
target
|
|
262
|
+
};
|
|
263
|
+
return {
|
|
264
|
+
kind: "set-aside",
|
|
265
|
+
name: real.name
|
|
266
|
+
};
|
|
267
|
+
}
|
|
268
|
+
function planPrivateFolder(real, generated, target) {
|
|
269
|
+
const realChildNames = new Set(real.childNames);
|
|
270
|
+
if (generated.childNames.some((childName) => realChildNames.has(childName))) return "private";
|
|
271
|
+
return {
|
|
272
|
+
kind: "adopt",
|
|
273
|
+
name: real.name,
|
|
274
|
+
target,
|
|
275
|
+
childNames: generated.childNames
|
|
276
|
+
};
|
|
277
|
+
}
|
|
278
|
+
function planEntryLink(real, generated, inputs) {
|
|
279
|
+
const target = path.join(inputs.realHome, real.name);
|
|
280
|
+
const link = {
|
|
281
|
+
kind: "link",
|
|
282
|
+
name: real.name,
|
|
283
|
+
target,
|
|
284
|
+
linkKind: linkKindFor(real.kind, inputs.platform)
|
|
285
|
+
};
|
|
286
|
+
if (!generated) return [link];
|
|
287
|
+
if (generated.kind === "link") return generated.linkTarget === target ? [] : [{
|
|
288
|
+
kind: "unlink",
|
|
289
|
+
name: real.name
|
|
290
|
+
}, link];
|
|
291
|
+
if (generated.kind === "file" && real.kind === "file") return [planReplacedFile(real, target, inputs.sourceStamps[fileStampKey(real.name)]), link];
|
|
292
|
+
if (generated.kind !== "folder" || real.kind !== "folder") return "private";
|
|
293
|
+
const adoption = planPrivateFolder(real, generated, target);
|
|
294
|
+
return adoption === "private" ? adoption : [adoption, link];
|
|
295
|
+
}
|
|
296
|
+
function planKimiHome(inputs) {
|
|
297
|
+
const config = generatedKimiConfig(inputs);
|
|
298
|
+
if ("refusal" in config) return {
|
|
299
|
+
kind: "refused",
|
|
300
|
+
reason: `the real ${KIMI_CONFIG_NAME} cannot take the hooks block: ${config.refusal}`
|
|
301
|
+
};
|
|
302
|
+
const steps = [];
|
|
303
|
+
if (config.text !== inputs.generatedConfigText) steps.push({
|
|
304
|
+
kind: "write-config",
|
|
305
|
+
text: config.text
|
|
306
|
+
});
|
|
307
|
+
if (config.base !== inputs.baseConfigText) steps.push({
|
|
308
|
+
kind: "write-base",
|
|
309
|
+
text: config.base
|
|
310
|
+
});
|
|
311
|
+
const generatedByName = new Map(inputs.generatedEntries.map((entry) => [entry.name, entry]));
|
|
312
|
+
const realNames = /* @__PURE__ */ new Set();
|
|
313
|
+
const privateNames = [];
|
|
314
|
+
for (const real of inputs.realEntries) {
|
|
315
|
+
if (GENERATED_ONLY_NAMES.has(real.name)) continue;
|
|
316
|
+
realNames.add(real.name);
|
|
317
|
+
const entrySteps = planEntryLink(real, generatedByName.get(real.name), inputs);
|
|
318
|
+
if (entrySteps === "private") {
|
|
319
|
+
privateNames.push(real.name);
|
|
320
|
+
continue;
|
|
321
|
+
}
|
|
322
|
+
steps.push(...entrySteps);
|
|
323
|
+
}
|
|
324
|
+
for (const generated of inputs.generatedEntries) if (generated.kind === "link" && !realNames.has(generated.name)) steps.push({
|
|
325
|
+
kind: "unlink",
|
|
326
|
+
name: generated.name
|
|
327
|
+
});
|
|
328
|
+
return {
|
|
329
|
+
kind: "ready",
|
|
330
|
+
steps,
|
|
331
|
+
privateNames,
|
|
332
|
+
hasStaleBlockInRealConfig: config.hadBlock
|
|
333
|
+
};
|
|
334
|
+
}
|
|
335
|
+
//#endregion
|
|
336
|
+
//#region server/guardrails/session-temp-locks.ts
|
|
337
|
+
var LOCK_FILE_SUFFIX = ".lock";
|
|
338
|
+
var SESSION_TEMP_GATE_FILE_NAME = "session-temp.gate";
|
|
339
|
+
var TRASH_FOLDER_PREFIX = ".deleting-";
|
|
340
|
+
var LOCK_INSTANCE_SHAPE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
|
|
341
|
+
var SESSION_ID_SHAPE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
|
|
342
|
+
var requireFromHere = createRequire(import.meta.url);
|
|
343
|
+
var heldLockDescriptorsBySessionId = /* @__PURE__ */ new Map();
|
|
344
|
+
var fileLocks;
|
|
345
|
+
var ownInstanceId;
|
|
346
|
+
function loadFileLocks() {
|
|
347
|
+
if (fileLocks !== void 0) return fileLocks;
|
|
348
|
+
fileLocks = requireNativeFileLocks();
|
|
349
|
+
return fileLocks;
|
|
350
|
+
}
|
|
351
|
+
function requireNativeFileLocks() {
|
|
352
|
+
try {
|
|
353
|
+
return requireFromHere("fs-native-extensions");
|
|
354
|
+
} catch {
|
|
355
|
+
return null;
|
|
356
|
+
}
|
|
357
|
+
}
|
|
358
|
+
function readOwnInstanceId() {
|
|
359
|
+
ownInstanceId ??= randomUUID();
|
|
360
|
+
return ownInstanceId;
|
|
361
|
+
}
|
|
362
|
+
function ownSessionLockPath(policyDir, sessionId) {
|
|
363
|
+
return path.join(policyDir, `${sessionId}.${readOwnInstanceId()}${LOCK_FILE_SUFFIX}`);
|
|
364
|
+
}
|
|
365
|
+
function sessionIdOfLockFile(entryName) {
|
|
366
|
+
if (!entryName.endsWith(LOCK_FILE_SUFFIX)) return null;
|
|
367
|
+
const lockName = entryName.slice(0, -5);
|
|
368
|
+
const instanceSeparatorIndex = lockName.lastIndexOf(".");
|
|
369
|
+
if (instanceSeparatorIndex < 0) return null;
|
|
370
|
+
const sessionId = lockName.slice(0, instanceSeparatorIndex);
|
|
371
|
+
if (!SESSION_ID_SHAPE.test(sessionId) || !LOCK_INSTANCE_SHAPE.test(lockName.slice(instanceSeparatorIndex + 1))) return null;
|
|
372
|
+
return sessionId;
|
|
373
|
+
}
|
|
374
|
+
function openSessionTempGate(policyDir) {
|
|
375
|
+
mkdirSync(policyDir, {
|
|
376
|
+
recursive: true,
|
|
377
|
+
mode: 448
|
|
378
|
+
});
|
|
379
|
+
return openSync(path.join(policyDir, SESSION_TEMP_GATE_FILE_NAME), "a+");
|
|
380
|
+
}
|
|
381
|
+
function closeSessionTempGate(locks, gateDescriptor) {
|
|
382
|
+
try {
|
|
383
|
+
locks.unlock(gateDescriptor);
|
|
384
|
+
} finally {
|
|
385
|
+
closeSync(gateDescriptor);
|
|
386
|
+
}
|
|
387
|
+
}
|
|
388
|
+
function lockOwnSessionFile(locks, lockPath) {
|
|
389
|
+
const lockDescriptor = openSync(lockPath, "a+");
|
|
390
|
+
if (locks.tryLock(lockDescriptor)) return lockDescriptor;
|
|
391
|
+
closeSync(lockDescriptor);
|
|
392
|
+
return null;
|
|
393
|
+
}
|
|
394
|
+
function holdSessionLockWhileGated(locks, policyDir, sessionId, sessionTempFolder) {
|
|
395
|
+
const gateDescriptor = openSessionTempGate(policyDir);
|
|
396
|
+
try {
|
|
397
|
+
locks.waitForLockSync(gateDescriptor, { shared: true });
|
|
398
|
+
const lockDescriptor = lockOwnSessionFile(locks, ownSessionLockPath(policyDir, sessionId));
|
|
399
|
+
if (lockDescriptor !== null) heldLockDescriptorsBySessionId.set(sessionId, lockDescriptor);
|
|
400
|
+
mkdirSync(sessionTempFolder, { recursive: true });
|
|
401
|
+
} finally {
|
|
402
|
+
closeSessionTempGate(locks, gateDescriptor);
|
|
403
|
+
}
|
|
404
|
+
}
|
|
405
|
+
function createHeldSessionTempFolder(policyDir, sessionId, sessionTempFolder) {
|
|
406
|
+
const locks = loadFileLocks();
|
|
407
|
+
if (locks === null || heldLockDescriptorsBySessionId.has(sessionId)) {
|
|
408
|
+
mkdirSync(sessionTempFolder, { recursive: true });
|
|
409
|
+
return;
|
|
410
|
+
}
|
|
411
|
+
holdSessionLockWhileGated(locks, policyDir, sessionId, sessionTempFolder);
|
|
412
|
+
}
|
|
413
|
+
function releaseSessionLock(policyDir, sessionId) {
|
|
414
|
+
const lockDescriptor = heldLockDescriptorsBySessionId.get(sessionId);
|
|
415
|
+
if (lockDescriptor === void 0) return false;
|
|
416
|
+
heldLockDescriptorsBySessionId.delete(sessionId);
|
|
417
|
+
try {
|
|
418
|
+
unlinkSync(ownSessionLockPath(policyDir, sessionId));
|
|
419
|
+
} finally {
|
|
420
|
+
loadFileLocks()?.unlock(lockDescriptor);
|
|
421
|
+
closeSync(lockDescriptor);
|
|
422
|
+
}
|
|
423
|
+
return true;
|
|
424
|
+
}
|
|
425
|
+
function openExistingLockFile(lockPath) {
|
|
426
|
+
try {
|
|
427
|
+
return openSync(lockPath, "r+");
|
|
428
|
+
} catch {
|
|
429
|
+
return null;
|
|
430
|
+
}
|
|
431
|
+
}
|
|
432
|
+
function tryLockOrFalse(locks, lockDescriptor) {
|
|
433
|
+
try {
|
|
434
|
+
return locks.tryLock(lockDescriptor);
|
|
435
|
+
} catch {
|
|
436
|
+
return false;
|
|
437
|
+
}
|
|
438
|
+
}
|
|
439
|
+
function lockIfUnheld(locks, lockPath) {
|
|
440
|
+
const lockDescriptor = openExistingLockFile(lockPath);
|
|
441
|
+
if (lockDescriptor === null) return null;
|
|
442
|
+
if (tryLockOrFalse(locks, lockDescriptor)) return lockDescriptor;
|
|
443
|
+
closeSync(lockDescriptor);
|
|
444
|
+
return null;
|
|
445
|
+
}
|
|
446
|
+
function releaseLockDescriptors(locks, lockDescriptors) {
|
|
447
|
+
for (const lockDescriptor of lockDescriptors) {
|
|
448
|
+
locks.unlock(lockDescriptor);
|
|
449
|
+
closeSync(lockDescriptor);
|
|
450
|
+
}
|
|
451
|
+
}
|
|
452
|
+
function sessionLockPathsIn(policyDir, sessionId) {
|
|
453
|
+
return readdirSync(policyDir).filter((entryName) => sessionIdOfLockFile(entryName) === sessionId).map((entryName) => path.join(policyDir, entryName));
|
|
454
|
+
}
|
|
455
|
+
function moveFolderToTrash(sessionTempFolder, sessionId) {
|
|
456
|
+
const trashFolder = path.join(path.dirname(sessionTempFolder), `${TRASH_FOLDER_PREFIX}${sessionId}-${randomUUID()}`);
|
|
457
|
+
try {
|
|
458
|
+
renameSync(sessionTempFolder, trashFolder);
|
|
459
|
+
return trashFolder;
|
|
460
|
+
} catch (error) {
|
|
461
|
+
if (isMissingFileError(error)) return null;
|
|
462
|
+
throw error;
|
|
463
|
+
}
|
|
464
|
+
}
|
|
465
|
+
function trashFolderIfEveryLockIsFree(locks, policyDir, sessionId, sessionTempFolder, { keepWhenNoLockFiles }) {
|
|
466
|
+
const lockPaths = sessionLockPathsIn(policyDir, sessionId);
|
|
467
|
+
if (keepWhenNoLockFiles && lockPaths.length === 0) return null;
|
|
468
|
+
const claimedLockDescriptors = lockPaths.map((lockPath) => lockIfUnheld(locks, lockPath)).filter((lockDescriptor) => lockDescriptor !== null);
|
|
469
|
+
try {
|
|
470
|
+
if (claimedLockDescriptors.length !== lockPaths.length) return null;
|
|
471
|
+
const trashFolder = moveFolderToTrash(sessionTempFolder, sessionId);
|
|
472
|
+
for (const lockPath of lockPaths) rmSync(lockPath, { force: true });
|
|
473
|
+
return trashFolder;
|
|
474
|
+
} finally {
|
|
475
|
+
releaseLockDescriptors(locks, claimedLockDescriptors);
|
|
476
|
+
}
|
|
477
|
+
}
|
|
478
|
+
function trashSessionTempFolderOnceUnheld(policyDir, sessionId, sessionTempFolder, options) {
|
|
479
|
+
const locks = loadFileLocks();
|
|
480
|
+
if (locks === null) return null;
|
|
481
|
+
const gateDescriptor = openSessionTempGate(policyDir);
|
|
482
|
+
try {
|
|
483
|
+
if (!locks.tryLock(gateDescriptor)) return null;
|
|
484
|
+
return trashFolderIfEveryLockIsFree(locks, policyDir, sessionId, sessionTempFolder, options);
|
|
485
|
+
} finally {
|
|
486
|
+
closeSessionTempGate(locks, gateDescriptor);
|
|
487
|
+
}
|
|
488
|
+
}
|
|
489
|
+
//#endregion
|
|
490
|
+
//#region session/kimi-home.ts
|
|
491
|
+
var GENERATED_HOME_MODE = 448;
|
|
492
|
+
var GENERATED_FILE_MODE = 384;
|
|
493
|
+
function realKimiHome(env = process.env, homeDir = os.homedir()) {
|
|
494
|
+
const configuredHome = typeof env.KIMI_CODE_HOME === "string" ? env.KIMI_CODE_HOME.trim() : "";
|
|
495
|
+
if (configuredHome) return path.resolve(configuredHome);
|
|
496
|
+
return path.join(homeDir, ".kimi-code");
|
|
497
|
+
}
|
|
498
|
+
function generatedKimiHomePath(env = process.env, homeDir = os.homedir()) {
|
|
499
|
+
return path.join(glimmervoidHomeDir(homeDir, env), "agent-homes", "kimi");
|
|
500
|
+
}
|
|
501
|
+
function listFolder(folder) {
|
|
502
|
+
try {
|
|
503
|
+
return fs.readdirSync(folder, { withFileTypes: true });
|
|
504
|
+
} catch (error) {
|
|
505
|
+
if (isMissingFileError(error)) return [];
|
|
506
|
+
throw error;
|
|
507
|
+
}
|
|
508
|
+
}
|
|
509
|
+
function statOrNull(entryPath) {
|
|
510
|
+
try {
|
|
511
|
+
return fs.statSync(entryPath);
|
|
512
|
+
} catch {
|
|
513
|
+
return null;
|
|
514
|
+
}
|
|
515
|
+
}
|
|
516
|
+
function fileStampOf(entryStat) {
|
|
517
|
+
return `${entryStat.size}:${entryStat.mtimeMs}`;
|
|
518
|
+
}
|
|
519
|
+
function childNamesOf(folder) {
|
|
520
|
+
return listFolder(folder).map((dirent) => dirent.name);
|
|
521
|
+
}
|
|
522
|
+
function listRealEntries(realHome, privateFolderNames) {
|
|
523
|
+
const entries = [];
|
|
524
|
+
for (const dirent of listFolder(realHome)) {
|
|
525
|
+
const entryPath = path.join(realHome, dirent.name);
|
|
526
|
+
const entryStat = statOrNull(entryPath);
|
|
527
|
+
if (!entryStat) continue;
|
|
528
|
+
if (entryStat.isDirectory()) {
|
|
529
|
+
const childNames = privateFolderNames.has(dirent.name) ? childNamesOf(entryPath) : [];
|
|
530
|
+
entries.push({
|
|
531
|
+
name: dirent.name,
|
|
532
|
+
kind: "folder",
|
|
533
|
+
fileStamp: null,
|
|
534
|
+
childNames
|
|
535
|
+
});
|
|
536
|
+
continue;
|
|
537
|
+
}
|
|
538
|
+
entries.push({
|
|
539
|
+
name: dirent.name,
|
|
540
|
+
kind: "file",
|
|
541
|
+
fileStamp: fileStampOf(entryStat),
|
|
542
|
+
childNames: []
|
|
543
|
+
});
|
|
544
|
+
}
|
|
545
|
+
return entries;
|
|
546
|
+
}
|
|
547
|
+
function isSameFile(first, second) {
|
|
548
|
+
return first.dev === second.dev && first.ino === second.ino;
|
|
549
|
+
}
|
|
550
|
+
function hardLinkTarget(entryStat, realHome, name) {
|
|
551
|
+
if (entryStat.nlink < 2) return null;
|
|
552
|
+
const realPath = path.join(realHome, name);
|
|
553
|
+
try {
|
|
554
|
+
return isSameFile(entryStat, fs.statSync(realPath)) ? realPath : null;
|
|
555
|
+
} catch {
|
|
556
|
+
return null;
|
|
557
|
+
}
|
|
558
|
+
}
|
|
559
|
+
function describeGeneratedEntry(generatedHome, realHome, name) {
|
|
560
|
+
const entryPath = path.join(generatedHome, name);
|
|
561
|
+
const entryStat = fs.lstatSync(entryPath);
|
|
562
|
+
if (entryStat.isSymbolicLink()) return {
|
|
563
|
+
name,
|
|
564
|
+
kind: "link",
|
|
565
|
+
linkTarget: path.resolve(generatedHome, fs.readlinkSync(entryPath)),
|
|
566
|
+
childNames: []
|
|
567
|
+
};
|
|
568
|
+
if (entryStat.isDirectory()) return {
|
|
569
|
+
name,
|
|
570
|
+
kind: "folder",
|
|
571
|
+
linkTarget: null,
|
|
572
|
+
childNames: childNamesOf(entryPath)
|
|
573
|
+
};
|
|
574
|
+
const hardLinkedTo = hardLinkTarget(entryStat, realHome, name);
|
|
575
|
+
if (hardLinkedTo) return {
|
|
576
|
+
name,
|
|
577
|
+
kind: "link",
|
|
578
|
+
linkTarget: hardLinkedTo,
|
|
579
|
+
childNames: []
|
|
580
|
+
};
|
|
581
|
+
return {
|
|
582
|
+
name,
|
|
583
|
+
kind: "file",
|
|
584
|
+
linkTarget: null,
|
|
585
|
+
childNames: []
|
|
586
|
+
};
|
|
587
|
+
}
|
|
588
|
+
function readOptionalText(filePath) {
|
|
589
|
+
try {
|
|
590
|
+
return fs.readFileSync(filePath, "utf8");
|
|
591
|
+
} catch (error) {
|
|
592
|
+
if (isMissingFileError(error)) return null;
|
|
593
|
+
throw error;
|
|
594
|
+
}
|
|
595
|
+
}
|
|
596
|
+
function readRealConfig(realHome) {
|
|
597
|
+
const configPath = path.join(realHome, KIMI_CONFIG_NAME);
|
|
598
|
+
try {
|
|
599
|
+
return { text: fs.readFileSync(configPath, "utf8") };
|
|
600
|
+
} catch (error) {
|
|
601
|
+
if (isMissingFileError(error)) return { text: null };
|
|
602
|
+
return { refusal: `the real ${configPath} cannot be read: ${errorMessage(error)}` };
|
|
603
|
+
}
|
|
604
|
+
}
|
|
605
|
+
function readSourceStamps(generatedHome) {
|
|
606
|
+
try {
|
|
607
|
+
const parsed = JSON.parse(fs.readFileSync(path.join(generatedHome, KIMI_SOURCES_NAME), "utf8"));
|
|
608
|
+
if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
|
|
609
|
+
return Object.fromEntries(Object.entries(parsed).filter((entry) => typeof entry[1] === "string"));
|
|
610
|
+
} catch {
|
|
611
|
+
return {};
|
|
612
|
+
}
|
|
613
|
+
}
|
|
614
|
+
function inspectKimiHome(options) {
|
|
615
|
+
const realHome = realKimiHome(options.env, options.homeDir);
|
|
616
|
+
const generatedHome = generatedKimiHomePath(options.env, options.homeDir);
|
|
617
|
+
try {
|
|
618
|
+
return {
|
|
619
|
+
generatedHome,
|
|
620
|
+
realHome,
|
|
621
|
+
plan: planFromDisk(options, realHome, generatedHome)
|
|
622
|
+
};
|
|
623
|
+
} catch (error) {
|
|
624
|
+
return {
|
|
625
|
+
generatedHome,
|
|
626
|
+
realHome,
|
|
627
|
+
plan: {
|
|
628
|
+
kind: "refused",
|
|
629
|
+
reason: `${realHome} or ${generatedHome} cannot be listed: ${errorMessage(error)}`
|
|
630
|
+
}
|
|
631
|
+
};
|
|
632
|
+
}
|
|
633
|
+
}
|
|
634
|
+
function planFromDisk({ hooksBlock, platform = process.platform }, realHome, generatedHome) {
|
|
635
|
+
const realConfig = readRealConfig(realHome);
|
|
636
|
+
if ("refusal" in realConfig) return {
|
|
637
|
+
kind: "refused",
|
|
638
|
+
reason: realConfig.refusal
|
|
639
|
+
};
|
|
640
|
+
const generatedEntries = childNamesOf(generatedHome).map((name) => describeGeneratedEntry(generatedHome, realHome, name));
|
|
641
|
+
return planKimiHome({
|
|
642
|
+
realHome,
|
|
643
|
+
realEntries: listRealEntries(realHome, new Set(generatedEntries.filter((entry) => entry.kind === "folder").map((entry) => entry.name))),
|
|
644
|
+
generatedEntries,
|
|
645
|
+
realConfigText: realConfig.text,
|
|
646
|
+
baseConfigText: readOptionalText(path.join(generatedHome, KIMI_BASE_NAME)),
|
|
647
|
+
generatedConfigText: readOptionalText(path.join(generatedHome, KIMI_CONFIG_NAME)),
|
|
648
|
+
hooksBlock,
|
|
649
|
+
sourceStamps: readSourceStamps(generatedHome),
|
|
650
|
+
platform
|
|
651
|
+
});
|
|
652
|
+
}
|
|
653
|
+
function stepEntryPath(generatedHome, step) {
|
|
654
|
+
if (step.kind === "write-config") return path.join(generatedHome, KIMI_CONFIG_NAME);
|
|
655
|
+
if (step.kind === "write-base") return path.join(generatedHome, KIMI_BASE_NAME);
|
|
656
|
+
return path.join(generatedHome, step.name);
|
|
657
|
+
}
|
|
658
|
+
function promoteIntoRealHome(entryPath, target) {
|
|
659
|
+
const resolvedTarget = fs.realpathSync(target);
|
|
660
|
+
const stagedPath = `${resolvedTarget}.glimmervoid-${process.pid}`;
|
|
661
|
+
try {
|
|
662
|
+
fs.copyFileSync(entryPath, stagedPath);
|
|
663
|
+
fs.chmodSync(stagedPath, fs.statSync(resolvedTarget).mode & 511);
|
|
664
|
+
fs.renameSync(stagedPath, resolvedTarget);
|
|
665
|
+
} catch (error) {
|
|
666
|
+
fs.rmSync(stagedPath, { force: true });
|
|
667
|
+
throw error;
|
|
668
|
+
}
|
|
669
|
+
fs.unlinkSync(entryPath);
|
|
670
|
+
}
|
|
671
|
+
function setAside(generatedHome, entryPath, name) {
|
|
672
|
+
const conflictsFolder = path.join(generatedHome, KIMI_CONFLICTS_NAME);
|
|
673
|
+
fs.mkdirSync(conflictsFolder, {
|
|
674
|
+
recursive: true,
|
|
675
|
+
mode: GENERATED_HOME_MODE
|
|
676
|
+
});
|
|
677
|
+
let copyNumber = 1;
|
|
678
|
+
while (fs.existsSync(path.join(conflictsFolder, `${name}.${copyNumber}`))) copyNumber += 1;
|
|
679
|
+
fs.renameSync(entryPath, path.join(conflictsFolder, `${name}.${copyNumber}`));
|
|
680
|
+
}
|
|
681
|
+
function moveAcrossVolumes(source, destination) {
|
|
682
|
+
try {
|
|
683
|
+
fs.renameSync(source, destination);
|
|
684
|
+
} catch (error) {
|
|
685
|
+
if (!(error instanceof Error && "code" in error && error.code === "EXDEV")) throw error;
|
|
686
|
+
fs.cpSync(source, destination, {
|
|
687
|
+
recursive: true,
|
|
688
|
+
errorOnExist: true,
|
|
689
|
+
force: false,
|
|
690
|
+
preserveTimestamps: true
|
|
691
|
+
});
|
|
692
|
+
fs.rmSync(source, { recursive: true });
|
|
693
|
+
}
|
|
694
|
+
}
|
|
695
|
+
function adoptFolder(entryPath, target, childNames) {
|
|
696
|
+
for (const childName of childNames) moveAcrossVolumes(path.join(entryPath, childName), path.join(target, childName));
|
|
697
|
+
fs.rmdirSync(entryPath);
|
|
698
|
+
}
|
|
699
|
+
function applyStep(generatedHome, step) {
|
|
700
|
+
const entryPath = stepEntryPath(generatedHome, step);
|
|
701
|
+
switch (step.kind) {
|
|
702
|
+
case "write-config":
|
|
703
|
+
case "write-base":
|
|
704
|
+
writeTextAtomicSync(entryPath, step.text, {
|
|
705
|
+
mode: GENERATED_FILE_MODE,
|
|
706
|
+
enforceMode: true
|
|
707
|
+
});
|
|
708
|
+
return;
|
|
709
|
+
case "unlink":
|
|
710
|
+
fs.unlinkSync(entryPath);
|
|
711
|
+
return;
|
|
712
|
+
case "promote":
|
|
713
|
+
promoteIntoRealHome(entryPath, step.target);
|
|
714
|
+
return;
|
|
715
|
+
case "set-aside":
|
|
716
|
+
setAside(generatedHome, entryPath, step.name);
|
|
717
|
+
return;
|
|
718
|
+
case "adopt":
|
|
719
|
+
adoptFolder(entryPath, step.target, step.childNames);
|
|
720
|
+
return;
|
|
721
|
+
}
|
|
722
|
+
if (step.linkKind === "hardlink") {
|
|
723
|
+
fs.linkSync(step.target, entryPath);
|
|
724
|
+
return;
|
|
725
|
+
}
|
|
726
|
+
fs.symlinkSync(step.target, entryPath, step.linkKind === "junction" ? "junction" : void 0);
|
|
727
|
+
}
|
|
728
|
+
function stepFailure(generatedHome, step, error) {
|
|
729
|
+
const entryPath = stepEntryPath(generatedHome, step);
|
|
730
|
+
if (step.kind === "link") return `${entryPath} cannot be linked to ${step.target}: ${errorMessage(error)}`;
|
|
731
|
+
if (step.kind === "promote") return `${entryPath} cannot be moved into ${step.target}: ${errorMessage(error)}`;
|
|
732
|
+
return `${entryPath} cannot be written: ${errorMessage(error)}`;
|
|
733
|
+
}
|
|
734
|
+
function realFileStamps(realHome) {
|
|
735
|
+
const stamps = {};
|
|
736
|
+
for (const entry of listRealEntries(realHome, /* @__PURE__ */ new Set())) if (entry.fileStamp !== null) stamps[fileStampKey(entry.name)] = entry.fileStamp;
|
|
737
|
+
return stamps;
|
|
738
|
+
}
|
|
739
|
+
function prepareKimiHome(options) {
|
|
740
|
+
const generatedHome = generatedKimiHomePath(options.env, options.homeDir);
|
|
741
|
+
try {
|
|
742
|
+
fs.mkdirSync(generatedHome, {
|
|
743
|
+
recursive: true,
|
|
744
|
+
mode: GENERATED_HOME_MODE
|
|
745
|
+
});
|
|
746
|
+
fs.chmodSync(generatedHome, GENERATED_HOME_MODE);
|
|
747
|
+
} catch (error) {
|
|
748
|
+
return { refusal: `${generatedHome} cannot be created: ${errorMessage(error)}` };
|
|
749
|
+
}
|
|
750
|
+
const { plan } = inspectKimiHome(options);
|
|
751
|
+
if (plan.kind === "refused") return { refusal: plan.reason };
|
|
752
|
+
const keptPrivateNames = /* @__PURE__ */ new Set();
|
|
753
|
+
for (const step of plan.steps) {
|
|
754
|
+
if ("name" in step && keptPrivateNames.has(step.name)) continue;
|
|
755
|
+
try {
|
|
756
|
+
applyStep(generatedHome, step);
|
|
757
|
+
} catch (error) {
|
|
758
|
+
if (step.kind !== "adopt") return { refusal: stepFailure(generatedHome, step, error) };
|
|
759
|
+
keptPrivateNames.add(step.name);
|
|
760
|
+
}
|
|
761
|
+
}
|
|
762
|
+
const realHome = realKimiHome(options.env, options.homeDir);
|
|
763
|
+
try {
|
|
764
|
+
writeTextAtomicSync(path.join(generatedHome, KIMI_SOURCES_NAME), `${JSON.stringify(realFileStamps(realHome), null, 2)}\n`, { mode: GENERATED_FILE_MODE });
|
|
765
|
+
} catch (error) {
|
|
766
|
+
return { refusal: `${path.join(generatedHome, KIMI_SOURCES_NAME)} cannot be written: ${errorMessage(error)}` };
|
|
767
|
+
}
|
|
768
|
+
return { home: generatedHome };
|
|
769
|
+
}
|
|
770
|
+
function kimiHomeNotes(generatedHome, plan) {
|
|
771
|
+
const notes = [];
|
|
772
|
+
if (plan.hasStaleBlockInRealConfig) notes.push("the real config.toml still holds an old Glimmervoid hooks block, which kimi sessions here ignore and you can delete");
|
|
773
|
+
if (plan.privateNames.length > 0) notes.push(`kept only in the generated home: ${plan.privateNames.join(", ")}`);
|
|
774
|
+
const conflictNames = childNamesOf(path.join(generatedHome, KIMI_CONFLICTS_NAME));
|
|
775
|
+
if (conflictNames.length > 0) notes.push(`${conflictNames.length} kimi copies set aside after a conflict in ${path.join(generatedHome, KIMI_CONFLICTS_NAME)}`);
|
|
776
|
+
return notes;
|
|
777
|
+
}
|
|
778
|
+
function describeKimiHome(hooksBlock, env = process.env) {
|
|
779
|
+
if (hooksBlock === null) return "refused: the hook relay path cannot be written into a kimi hooks block";
|
|
780
|
+
const { generatedHome, realHome, plan } = inspectKimiHome({
|
|
781
|
+
env,
|
|
782
|
+
hooksBlock
|
|
783
|
+
});
|
|
784
|
+
if (plan.kind === "refused") return `refused: ${plan.reason}`;
|
|
785
|
+
return [`ready: ${generatedHome} (real ${realHome})`, ...kimiHomeNotes(generatedHome, plan)].join("; ");
|
|
786
|
+
}
|
|
787
|
+
var liveSessionCountByHome = /* @__PURE__ */ new Map();
|
|
788
|
+
var inUseLockDescriptorByHome = /* @__PURE__ */ new Map();
|
|
789
|
+
function inUseLockPath(generatedHome) {
|
|
790
|
+
return path.join(generatedHome, KIMI_IN_USE_LOCK_NAME);
|
|
791
|
+
}
|
|
792
|
+
function takeSharedInUseLock(generatedHome) {
|
|
793
|
+
const locks = loadFileLocks();
|
|
794
|
+
if (locks === null) return;
|
|
795
|
+
fs.mkdirSync(generatedHome, {
|
|
796
|
+
recursive: true,
|
|
797
|
+
mode: GENERATED_HOME_MODE
|
|
798
|
+
});
|
|
799
|
+
const lockDescriptor = fs.openSync(inUseLockPath(generatedHome), "a+", GENERATED_FILE_MODE);
|
|
800
|
+
locks.waitForLockSync(lockDescriptor, { shared: true });
|
|
801
|
+
inUseLockDescriptorByHome.set(generatedHome, lockDescriptor);
|
|
802
|
+
}
|
|
803
|
+
function dropSharedInUseLock(generatedHome) {
|
|
804
|
+
const lockDescriptor = inUseLockDescriptorByHome.get(generatedHome);
|
|
805
|
+
if (lockDescriptor === void 0) return;
|
|
806
|
+
inUseLockDescriptorByHome.delete(generatedHome);
|
|
807
|
+
loadFileLocks()?.unlock(lockDescriptor);
|
|
808
|
+
fs.closeSync(lockDescriptor);
|
|
809
|
+
}
|
|
810
|
+
function openInUseLock(generatedHome) {
|
|
811
|
+
try {
|
|
812
|
+
return fs.openSync(inUseLockPath(generatedHome), "a+", GENERATED_FILE_MODE);
|
|
813
|
+
} catch (error) {
|
|
814
|
+
if (isMissingFileError(error)) return null;
|
|
815
|
+
throw error;
|
|
816
|
+
}
|
|
817
|
+
}
|
|
818
|
+
function releaseSecretsUnlessHeldElsewhere(generatedHome, { whenLocksMissing }) {
|
|
819
|
+
const locks = loadFileLocks();
|
|
820
|
+
if (locks === null) {
|
|
821
|
+
if (whenLocksMissing === "release") releaseKimiHomeSecrets(generatedHome);
|
|
822
|
+
return;
|
|
823
|
+
}
|
|
824
|
+
const lockDescriptor = openInUseLock(generatedHome);
|
|
825
|
+
if (lockDescriptor === null) return;
|
|
826
|
+
try {
|
|
827
|
+
if (!locks.tryLock(lockDescriptor)) return;
|
|
828
|
+
releaseKimiHomeSecrets(generatedHome);
|
|
829
|
+
locks.unlock(lockDescriptor);
|
|
830
|
+
} finally {
|
|
831
|
+
fs.closeSync(lockDescriptor);
|
|
832
|
+
}
|
|
833
|
+
}
|
|
834
|
+
function holdKimiHome(generatedHome) {
|
|
835
|
+
const liveSessionCount = (liveSessionCountByHome.get(generatedHome) ?? 0) + 1;
|
|
836
|
+
liveSessionCountByHome.set(generatedHome, liveSessionCount);
|
|
837
|
+
if (liveSessionCount === 1) takeSharedInUseLock(generatedHome);
|
|
838
|
+
}
|
|
839
|
+
function releaseKimiHomeSecrets(generatedHome) {
|
|
840
|
+
for (const name of [KIMI_CONFIG_NAME, KIMI_BASE_NAME]) try {
|
|
841
|
+
fs.rmSync(path.join(generatedHome, name), { force: true });
|
|
842
|
+
} catch (error) {
|
|
843
|
+
console.warn(`[kimi-home] ${path.join(generatedHome, name)} could not be deleted: ${errorMessage(error)}`);
|
|
844
|
+
}
|
|
845
|
+
}
|
|
846
|
+
function releaseKimiHome(generatedHome) {
|
|
847
|
+
const liveSessionCount = (liveSessionCountByHome.get(generatedHome) ?? 0) - 1;
|
|
848
|
+
if (liveSessionCount > 0) {
|
|
849
|
+
liveSessionCountByHome.set(generatedHome, liveSessionCount);
|
|
850
|
+
return;
|
|
851
|
+
}
|
|
852
|
+
liveSessionCountByHome.delete(generatedHome);
|
|
853
|
+
dropSharedInUseLock(generatedHome);
|
|
854
|
+
releaseSecretsUnlessHeldElsewhere(generatedHome, { whenLocksMissing: "release" });
|
|
855
|
+
}
|
|
856
|
+
function releaseUnheldKimiHomeSecrets(generatedHome) {
|
|
857
|
+
releaseSecretsUnlessHeldElsewhere(generatedHome, { whenLocksMissing: "keep" });
|
|
858
|
+
}
|
|
859
|
+
//#endregion
|
|
860
|
+
export { prepareKimiHome as a, releaseKimiHomeSecrets as c, releaseSessionLock as d, sessionIdOfLockFile as f, inspectKimiHome as i, releaseUnheldKimiHomeSecrets as l, renderKimiHooksBlock as m, generatedKimiHomePath as n, realKimiHome as o, trashSessionTempFolderOnceUnheld as p, holdKimiHome as r, releaseKimiHome as s, describeKimiHome as t, createHeldSessionTempFolder as u };
|