glimmervoid 0.46.2-next.165 → 0.46.2-next.167
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 +4 -4
- package/dist/chunks/{adapters-Dg2iqDPO.js → adapters-Br_PA1X_.js} +1 -1
- package/dist/chunks/{adapters-Dh1iSH18.js → adapters-CKy7FjTT.js} +1 -1
- package/dist/chunks/{agent-setup-cli-C7WB5FWK.js → agent-setup-cli-C8PNC8YA.js} +1 -1
- package/dist/chunks/{kimi-BjgwP49z.js → kimi-BGYddMlv.js} +517 -58
- package/dist/chunks/{main-Dz2d4cFe.js → main-DMmxYBnP.js} +23 -161
- package/dist/client/assets/{alert-sound-CzrfUQrG.js → alert-sound-CSvkaH2H.js} +1 -1
- package/dist/client/assets/alert-sound-CSvkaH2H.js.br +0 -0
- package/dist/client/assets/{benchmark-panel-DYPhj9b3.js → benchmark-panel-mns1UqN5.js} +1 -1
- package/dist/client/assets/benchmark-panel-mns1UqN5.js.br +0 -0
- package/dist/client/assets/{celebration-player-C9Pi0SmP.js → celebration-player-CFSer-rB.js} +1 -1
- package/dist/client/assets/celebration-player-CFSer-rB.js.br +0 -0
- package/dist/client/assets/{dialogs-B-EoOxFX.js → dialogs-sZ-eTR1o.js} +1 -1
- package/dist/client/assets/dialogs-sZ-eTR1o.js.br +0 -0
- package/dist/client/assets/{doc-editor-ui-D8j8RJyh.js → doc-editor-ui-gUZSzoaA.js} +1 -1
- package/dist/client/assets/doc-editor-ui-gUZSzoaA.js.br +0 -0
- package/dist/client/assets/{feature-hint-DsIenff-.js → feature-hint-BwFF1r0i.js} +1 -1
- package/dist/client/assets/feature-hint-BwFF1r0i.js.br +0 -0
- package/dist/client/assets/{first-run-checklist-CyffKgMV.js → first-run-checklist-Cdpb_P4N.js} +1 -1
- package/dist/client/assets/first-run-checklist-Cdpb_P4N.js.br +0 -0
- package/dist/client/assets/{hooks-panel-CHIQYARB.js → hooks-panel-D9BcT9I0.js} +1 -1
- package/dist/client/assets/hooks-panel-D9BcT9I0.js.br +0 -0
- package/dist/client/assets/{index-DnNiYw2m.js → index-tjVjVTuz.js} +5 -5
- package/dist/client/assets/index-tjVjVTuz.js.br +0 -0
- package/dist/client/assets/{issues-panel-CVKUFwlt.js → issues-panel-C-9kUGqO.js} +1 -1
- package/dist/client/assets/issues-panel-C-9kUGqO.js.br +0 -0
- package/dist/client/assets/{nyan-cat-B3QguTCY.js → nyan-cat-DLU7L0F2.js} +1 -1
- package/dist/client/assets/nyan-cat-DLU7L0F2.js.br +0 -0
- package/dist/client/assets/{phone-shell-BYSfe36z.js → phone-shell-CAlVRH-A.js} +1 -1
- package/dist/client/assets/phone-shell-CAlVRH-A.js.br +0 -0
- package/dist/client/assets/{plan-face-DitcLz4U.js → plan-face-WpVYeXGh.js} +1 -1
- package/dist/client/assets/plan-face-WpVYeXGh.js.br +0 -0
- package/dist/client/assets/{plan-render-Dc5BL45f.js → plan-render-D7--c3qq.js} +1 -1
- package/dist/client/assets/plan-render-D7--c3qq.js.br +0 -0
- package/dist/client/assets/{pr-scope-tabs-pVf6DvP0.js → pr-scope-tabs-SPjQar96.js} +1 -1
- package/dist/client/assets/pr-scope-tabs-SPjQar96.js.br +0 -0
- package/dist/client/assets/{radar-panel-Dcs6jJun.js → radar-panel-BhU8Tox1.js} +1 -1
- package/dist/client/assets/radar-panel-BhU8Tox1.js.br +0 -0
- package/dist/client/assets/{resume-dialog-qy_CKLp3.js → resume-dialog-DvcFxs0T.js} +1 -1
- package/dist/client/assets/resume-dialog-DvcFxs0T.js.br +0 -0
- package/dist/client/assets/{review-queue-panel-8myAgz2U.js → review-queue-panel-CXxo72KX.js} +1 -1
- package/dist/client/assets/review-queue-panel-CXxo72KX.js.br +0 -0
- package/dist/client/assets/{settings-panel-7Z7fisdK.js → settings-panel-eElgQ9sl.js} +2 -2
- package/dist/client/assets/settings-panel-eElgQ9sl.js.br +0 -0
- package/dist/client/assets/{shown-lightbox-q2P4JDCx.js → shown-lightbox-DLBCDlmL.js} +1 -1
- package/dist/client/assets/shown-lightbox-DLBCDlmL.js.br +0 -0
- package/dist/client/assets/{trace-panel-C0xa0x0u.js → trace-panel-B1eQQqmW.js} +1 -1
- package/dist/client/assets/trace-panel-B1eQQqmW.js.br +0 -0
- package/dist/client/assets/{usage-panel-BNnuZw5E.js → usage-panel-BK3HGdI3.js} +1 -1
- package/dist/client/assets/usage-panel-BK3HGdI3.js.br +0 -0
- package/dist/client/assets/{visions-panel-FupUvVpT.js → visions-panel-BXARteeE.js} +1 -1
- package/dist/client/assets/visions-panel-BXARteeE.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/client/assets/alert-sound-CzrfUQrG.js.br +0 -0
- package/dist/client/assets/benchmark-panel-DYPhj9b3.js.br +0 -0
- package/dist/client/assets/celebration-player-C9Pi0SmP.js.br +0 -0
- package/dist/client/assets/dialogs-B-EoOxFX.js.br +0 -0
- package/dist/client/assets/doc-editor-ui-D8j8RJyh.js.br +0 -0
- package/dist/client/assets/feature-hint-DsIenff-.js.br +0 -0
- package/dist/client/assets/first-run-checklist-CyffKgMV.js.br +0 -0
- package/dist/client/assets/hooks-panel-CHIQYARB.js.br +0 -0
- package/dist/client/assets/index-DnNiYw2m.js.br +0 -0
- package/dist/client/assets/issues-panel-CVKUFwlt.js.br +0 -0
- package/dist/client/assets/nyan-cat-B3QguTCY.js.br +0 -0
- package/dist/client/assets/phone-shell-BYSfe36z.js.br +0 -0
- package/dist/client/assets/plan-face-DitcLz4U.js.br +0 -0
- package/dist/client/assets/plan-render-Dc5BL45f.js.br +0 -0
- package/dist/client/assets/pr-scope-tabs-pVf6DvP0.js.br +0 -0
- package/dist/client/assets/radar-panel-Dcs6jJun.js.br +0 -0
- package/dist/client/assets/resume-dialog-qy_CKLp3.js.br +0 -0
- package/dist/client/assets/review-queue-panel-8myAgz2U.js.br +0 -0
- package/dist/client/assets/settings-panel-7Z7fisdK.js.br +0 -0
- package/dist/client/assets/shown-lightbox-q2P4JDCx.js.br +0 -0
- package/dist/client/assets/trace-panel-C0xa0x0u.js.br +0 -0
- package/dist/client/assets/usage-panel-BNnuZw5E.js.br +0 -0
- package/dist/client/assets/visions-panel-FupUvVpT.js.br +0 -0
|
@@ -9,10 +9,11 @@ import { t as HOOK_URL_ENV } from "./hook-relay-core-DA_bz2KA.js";
|
|
|
9
9
|
import { a as KIMI_SANE_YOLO_FLAVOR, o as SANE_YOLO_PATH_ENV, r as RTK_PATH_ENV, s as saneYoloEnv } from "./rtk-hook-core-23_GM8RQ.js";
|
|
10
10
|
import { t as buildHookCommand } from "./hook-command-core-qTNK-xMF.js";
|
|
11
11
|
import { p as writeTextAtomicSync } from "./json-file-BjFK_eSH.js";
|
|
12
|
-
import
|
|
12
|
+
import { createRequire } from "node:module";
|
|
13
|
+
import fs, { closeSync, mkdirSync, openSync, readdirSync, renameSync, rmSync, unlinkSync } from "node:fs";
|
|
13
14
|
import path from "node:path";
|
|
14
15
|
import os from "node:os";
|
|
15
|
-
import { createHash } from "node:crypto";
|
|
16
|
+
import { createHash, randomUUID } from "node:crypto";
|
|
16
17
|
//#region session/core/spawn-env.ts
|
|
17
18
|
var GLIMMERVOID_SCRUB_KEYS = [
|
|
18
19
|
"GLIMMERVOID_PORT",
|
|
@@ -561,62 +562,203 @@ function spliceKimiHooksBlock(configText, block) {
|
|
|
561
562
|
}
|
|
562
563
|
var KIMI_CONFIG_NAME = "config.toml";
|
|
563
564
|
var KIMI_SOURCES_NAME = ".glimmervoid-sources.json";
|
|
564
|
-
var
|
|
565
|
-
|
|
566
|
-
|
|
565
|
+
var KIMI_CONFLICTS_NAME = ".glimmervoid-conflicts";
|
|
566
|
+
var KIMI_BASE_NAME = ".glimmervoid-base.toml";
|
|
567
|
+
var KIMI_IN_USE_LOCK_NAME = ".glimmervoid-in-use.lock";
|
|
568
|
+
var GENERATED_ONLY_NAMES = /* @__PURE__ */ new Set([
|
|
569
|
+
KIMI_CONFIG_NAME,
|
|
570
|
+
KIMI_SOURCES_NAME,
|
|
571
|
+
KIMI_CONFLICTS_NAME,
|
|
572
|
+
KIMI_BASE_NAME,
|
|
573
|
+
KIMI_IN_USE_LOCK_NAME
|
|
574
|
+
]);
|
|
575
|
+
var FILE_STAMP_PREFIX = "file:";
|
|
576
|
+
var TOML_TABLE_HEADER_PATTERN = /^\s*\[\[?([^[\]=]+)\]\]?\s*(?:#.*)?$/;
|
|
577
|
+
var TOML_KEY_PATTERN = /^\s*((?:[A-Za-z0-9_-]+|"[^"]*"|'[^']*')(?:\s*\.\s*(?:[A-Za-z0-9_-]+|"[^"]*"|'[^']*'))*)\s*=/;
|
|
578
|
+
var TOML_MULTILINE_QUOTES = ["\"\"\"", "'''"];
|
|
579
|
+
function withoutBlock(configText) {
|
|
567
580
|
const span = locateBlock(configText);
|
|
568
|
-
if (span === "foreign") return
|
|
569
|
-
|
|
581
|
+
if (span === "foreign") return span;
|
|
582
|
+
if (span === "absent") return configText;
|
|
583
|
+
const operatorText = `${configText.slice(0, span.start)}${configText.slice(span.end)}`;
|
|
584
|
+
return operatorText.endsWith("\n\n") ? operatorText.slice(0, -1) : operatorText;
|
|
585
|
+
}
|
|
586
|
+
function togglesMultilineString(line) {
|
|
587
|
+
return TOML_MULTILINE_QUOTES.some((quotes) => line.split(quotes).length % 2 === 0);
|
|
588
|
+
}
|
|
589
|
+
function splitTomlUnits(configText) {
|
|
590
|
+
const units = {
|
|
591
|
+
preamble: "",
|
|
592
|
+
keys: [],
|
|
593
|
+
tables: []
|
|
594
|
+
};
|
|
595
|
+
const tableCounts = /* @__PURE__ */ new Map();
|
|
596
|
+
let current = null;
|
|
597
|
+
let isInTable = false;
|
|
598
|
+
let isInMultilineString = false;
|
|
599
|
+
for (const line of configText.split(/(?<=\n)/)) {
|
|
600
|
+
const header = isInMultilineString ? null : TOML_TABLE_HEADER_PATTERN.exec(line);
|
|
601
|
+
const key = isInMultilineString || isInTable || header ? null : TOML_KEY_PATTERN.exec(line);
|
|
602
|
+
if (togglesMultilineString(line)) isInMultilineString = !isInMultilineString;
|
|
603
|
+
if (header) {
|
|
604
|
+
const headerId = `${line.trim().startsWith("[[") ? "[[" : "["}${(header[1] ?? "").replaceAll(/\s/g, "")}`;
|
|
605
|
+
const occurrence = (tableCounts.get(headerId) ?? 0) + 1;
|
|
606
|
+
tableCounts.set(headerId, occurrence);
|
|
607
|
+
current = {
|
|
608
|
+
id: `${headerId}#${occurrence}`,
|
|
609
|
+
text: line
|
|
610
|
+
};
|
|
611
|
+
units.tables.push(current);
|
|
612
|
+
isInTable = true;
|
|
613
|
+
continue;
|
|
614
|
+
}
|
|
615
|
+
if (key) {
|
|
616
|
+
current = {
|
|
617
|
+
id: (key[1] ?? "").replaceAll(/\s/g, ""),
|
|
618
|
+
text: line
|
|
619
|
+
};
|
|
620
|
+
units.keys.push(current);
|
|
621
|
+
continue;
|
|
622
|
+
}
|
|
623
|
+
if (current) current.text += line;
|
|
624
|
+
if (!current) units.preamble += line;
|
|
625
|
+
}
|
|
626
|
+
return units;
|
|
627
|
+
}
|
|
628
|
+
function isSameUnit(first, second) {
|
|
629
|
+
return first?.text.trimEnd() === second?.text.trimEnd();
|
|
630
|
+
}
|
|
631
|
+
function mergeUnitList(base, ours, theirs) {
|
|
632
|
+
const baseById = new Map(base.map((unit) => [unit.id, unit]));
|
|
633
|
+
const oursById = new Map(ours.map((unit) => [unit.id, unit]));
|
|
634
|
+
const theirIds = new Set(theirs.map((unit) => unit.id));
|
|
635
|
+
const merged = [];
|
|
636
|
+
for (const theirUnit of theirs) {
|
|
637
|
+
const ourUnit = oursById.get(theirUnit.id);
|
|
638
|
+
const isOnlySessionChange = !isSameUnit(ourUnit, baseById.get(theirUnit.id)) && isSameUnit(theirUnit, baseById.get(theirUnit.id));
|
|
639
|
+
if (!isOnlySessionChange) merged.push(theirUnit);
|
|
640
|
+
if (isOnlySessionChange && ourUnit) merged.push(ourUnit);
|
|
641
|
+
}
|
|
642
|
+
for (const ourUnit of ours) if (!theirIds.has(ourUnit.id) && !baseById.has(ourUnit.id)) merged.push(ourUnit);
|
|
643
|
+
return merged;
|
|
644
|
+
}
|
|
645
|
+
function mergeTopLevelKeys(base, ours, theirs) {
|
|
646
|
+
if (theirs === base) return ours;
|
|
647
|
+
if (ours === base) return theirs;
|
|
648
|
+
const [baseUnits, ourUnits, theirUnits] = [
|
|
649
|
+
splitTomlUnits(base),
|
|
650
|
+
splitTomlUnits(ours),
|
|
651
|
+
splitTomlUnits(theirs)
|
|
652
|
+
];
|
|
653
|
+
const keys = mergeUnitList(baseUnits.keys, ourUnits.keys, theirUnits.keys).map((unit) => `${unit.text.trimEnd()}\n`);
|
|
654
|
+
const tables = mergeUnitList(baseUnits.tables, ourUnits.tables, theirUnits.tables).map((unit) => `\n${unit.text.trimEnd()}\n`);
|
|
655
|
+
return [
|
|
656
|
+
theirUnits.preamble,
|
|
657
|
+
...keys,
|
|
658
|
+
...tables
|
|
659
|
+
].join("");
|
|
660
|
+
}
|
|
661
|
+
var HOOKS_ARRAY_TABLE_ID_PREFIX = "[[hooks#";
|
|
662
|
+
function withoutUnmarkedHooks(ours, base) {
|
|
663
|
+
const baseHookTexts = new Set(splitTomlUnits(base).tables.map((unit) => unit.text.trimEnd()));
|
|
664
|
+
const ourUnits = splitTomlUnits(ours);
|
|
665
|
+
const keptTables = ourUnits.tables.filter((unit) => !unit.id.startsWith(HOOKS_ARRAY_TABLE_ID_PREFIX) || baseHookTexts.has(unit.text.trimEnd()));
|
|
666
|
+
if (keptTables.length === ourUnits.tables.length) return ours;
|
|
667
|
+
return [
|
|
668
|
+
ourUnits.preamble,
|
|
669
|
+
...ourUnits.keys.map((unit) => unit.text),
|
|
670
|
+
...keptTables.map((unit) => unit.text)
|
|
671
|
+
].join("");
|
|
672
|
+
}
|
|
673
|
+
function generatedKimiConfig(sources) {
|
|
674
|
+
const realText = sources.realConfigText ?? "";
|
|
675
|
+
const theirs = withoutBlock(realText);
|
|
676
|
+
if (theirs === "foreign") return { refusal: "its Glimmervoid hooks block markers are unbalanced" };
|
|
677
|
+
const hadBlock = theirs !== realText;
|
|
678
|
+
if (sources.baseConfigText === theirs && sources.generatedConfigText !== null && classifyKimiConfig(sources.generatedConfigText, sources.hooksBlock) === "current") return {
|
|
679
|
+
text: sources.generatedConfigText,
|
|
680
|
+
base: theirs,
|
|
681
|
+
hadBlock
|
|
682
|
+
};
|
|
683
|
+
const ours = sources.generatedConfigText === null ? "foreign" : withoutBlock(sources.generatedConfigText);
|
|
684
|
+
const operatorText = ours === "foreign" || sources.baseConfigText === null ? theirs : mergeTopLevelKeys(sources.baseConfigText, withoutUnmarkedHooks(ours, sources.baseConfigText), theirs);
|
|
570
685
|
if (definesHooksOutsideArrayTables(operatorText)) return { refusal: "it defines hooks as a key or [hooks] table, which a [[hooks]] block cannot extend" };
|
|
571
|
-
const spliced = spliceKimiHooksBlock(operatorText, hooksBlock);
|
|
686
|
+
const spliced = spliceKimiHooksBlock(operatorText, sources.hooksBlock);
|
|
572
687
|
if ("refused" in spliced) return { refusal: `its hooks are ${spliced.refused}` };
|
|
573
688
|
return {
|
|
574
689
|
text: spliced.contents,
|
|
575
|
-
|
|
690
|
+
base: theirs,
|
|
691
|
+
hadBlock
|
|
576
692
|
};
|
|
577
693
|
}
|
|
578
|
-
function configSourceStamp(realConfigText, hooksBlock) {
|
|
579
|
-
return createHash("sha256").update(realConfigText ?? "").update("\0").update(hooksBlock).digest("hex");
|
|
580
|
-
}
|
|
581
694
|
function linkKindFor(kind, platform) {
|
|
582
695
|
if (platform !== "win32") return "symlink";
|
|
583
696
|
return kind === "folder" ? "junction" : "hardlink";
|
|
584
697
|
}
|
|
585
|
-
function
|
|
586
|
-
|
|
698
|
+
function fileStampKey(name) {
|
|
699
|
+
return `${FILE_STAMP_PREFIX}${name}`;
|
|
700
|
+
}
|
|
701
|
+
function planReplacedFile(real, target, lastFileStamp) {
|
|
702
|
+
if (real.fileStamp !== null && real.fileStamp === lastFileStamp) return {
|
|
703
|
+
kind: "promote",
|
|
704
|
+
name: real.name,
|
|
705
|
+
target
|
|
706
|
+
};
|
|
707
|
+
return {
|
|
708
|
+
kind: "set-aside",
|
|
709
|
+
name: real.name
|
|
710
|
+
};
|
|
711
|
+
}
|
|
712
|
+
function planPrivateFolder(real, generated, target) {
|
|
713
|
+
const realChildNames = new Set(real.childNames);
|
|
714
|
+
if (generated.childNames.some((childName) => realChildNames.has(childName))) return "private";
|
|
715
|
+
return {
|
|
716
|
+
kind: "adopt",
|
|
717
|
+
name: real.name,
|
|
718
|
+
target,
|
|
719
|
+
childNames: generated.childNames
|
|
720
|
+
};
|
|
721
|
+
}
|
|
722
|
+
function planEntryLink(real, generated, inputs) {
|
|
723
|
+
const target = path.join(inputs.realHome, real.name);
|
|
587
724
|
const link = {
|
|
588
725
|
kind: "link",
|
|
589
726
|
name: real.name,
|
|
590
727
|
target,
|
|
591
|
-
linkKind: linkKindFor(real.kind, platform)
|
|
728
|
+
linkKind: linkKindFor(real.kind, inputs.platform)
|
|
592
729
|
};
|
|
593
730
|
if (!generated) return [link];
|
|
594
|
-
if (generated.kind
|
|
595
|
-
if (generated.linkTarget === target) return [];
|
|
596
|
-
return [{
|
|
731
|
+
if (generated.kind === "link") return generated.linkTarget === target ? [] : [{
|
|
597
732
|
kind: "unlink",
|
|
598
733
|
name: real.name
|
|
599
734
|
}, link];
|
|
735
|
+
if (generated.kind === "file" && real.kind === "file") return [planReplacedFile(real, target, inputs.sourceStamps[fileStampKey(real.name)]), link];
|
|
736
|
+
if (generated.kind !== "folder" || real.kind !== "folder") return "private";
|
|
737
|
+
const adoption = planPrivateFolder(real, generated, target);
|
|
738
|
+
return adoption === "private" ? adoption : [adoption, link];
|
|
600
739
|
}
|
|
601
740
|
function planKimiHome(inputs) {
|
|
602
|
-
const config = generatedKimiConfig(inputs
|
|
741
|
+
const config = generatedKimiConfig(inputs);
|
|
603
742
|
if ("refusal" in config) return {
|
|
604
743
|
kind: "refused",
|
|
605
744
|
reason: `the real ${KIMI_CONFIG_NAME} cannot take the hooks block: ${config.refusal}`
|
|
606
745
|
};
|
|
607
746
|
const steps = [];
|
|
608
|
-
|
|
609
|
-
if (!(inputs.generatedConfigText !== null && inputs.sourceStamps["config.toml"] === configStamp && classifyKimiConfig(inputs.generatedConfigText, inputs.hooksBlock) === "current")) steps.push({
|
|
747
|
+
if (config.text !== inputs.generatedConfigText) steps.push({
|
|
610
748
|
kind: "write-config",
|
|
611
749
|
text: config.text
|
|
612
750
|
});
|
|
751
|
+
if (config.base !== inputs.baseConfigText) steps.push({
|
|
752
|
+
kind: "write-base",
|
|
753
|
+
text: config.base
|
|
754
|
+
});
|
|
613
755
|
const generatedByName = new Map(inputs.generatedEntries.map((entry) => [entry.name, entry]));
|
|
614
756
|
const realNames = /* @__PURE__ */ new Set();
|
|
615
757
|
const privateNames = [];
|
|
616
758
|
for (const real of inputs.realEntries) {
|
|
617
759
|
if (GENERATED_ONLY_NAMES.has(real.name)) continue;
|
|
618
760
|
realNames.add(real.name);
|
|
619
|
-
const entrySteps = planEntryLink(real, generatedByName.get(real.name), inputs
|
|
761
|
+
const entrySteps = planEntryLink(real, generatedByName.get(real.name), inputs);
|
|
620
762
|
if (entrySteps === "private") {
|
|
621
763
|
privateNames.push(real.name);
|
|
622
764
|
continue;
|
|
@@ -630,15 +772,165 @@ function planKimiHome(inputs) {
|
|
|
630
772
|
return {
|
|
631
773
|
kind: "ready",
|
|
632
774
|
steps,
|
|
633
|
-
sourceStamps: {
|
|
634
|
-
...inputs.sourceStamps,
|
|
635
|
-
[KIMI_CONFIG_NAME]: configStamp
|
|
636
|
-
},
|
|
637
775
|
privateNames,
|
|
638
776
|
hasStaleBlockInRealConfig: config.hadBlock
|
|
639
777
|
};
|
|
640
778
|
}
|
|
641
779
|
//#endregion
|
|
780
|
+
//#region server/guardrails/session-temp-locks.ts
|
|
781
|
+
var LOCK_FILE_SUFFIX = ".lock";
|
|
782
|
+
var SESSION_TEMP_GATE_FILE_NAME = "session-temp.gate";
|
|
783
|
+
var TRASH_FOLDER_PREFIX = ".deleting-";
|
|
784
|
+
var LOCK_INSTANCE_SHAPE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
|
|
785
|
+
var SESSION_ID_SHAPE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
|
|
786
|
+
var requireFromHere = createRequire(import.meta.url);
|
|
787
|
+
var heldLockDescriptorsBySessionId = /* @__PURE__ */ new Map();
|
|
788
|
+
var fileLocks;
|
|
789
|
+
var ownInstanceId;
|
|
790
|
+
function loadFileLocks() {
|
|
791
|
+
if (fileLocks !== void 0) return fileLocks;
|
|
792
|
+
fileLocks = requireNativeFileLocks();
|
|
793
|
+
return fileLocks;
|
|
794
|
+
}
|
|
795
|
+
function requireNativeFileLocks() {
|
|
796
|
+
try {
|
|
797
|
+
return requireFromHere("fs-native-extensions");
|
|
798
|
+
} catch {
|
|
799
|
+
return null;
|
|
800
|
+
}
|
|
801
|
+
}
|
|
802
|
+
function readOwnInstanceId() {
|
|
803
|
+
ownInstanceId ??= randomUUID();
|
|
804
|
+
return ownInstanceId;
|
|
805
|
+
}
|
|
806
|
+
function ownSessionLockPath(policyDir, sessionId) {
|
|
807
|
+
return path.join(policyDir, `${sessionId}.${readOwnInstanceId()}${LOCK_FILE_SUFFIX}`);
|
|
808
|
+
}
|
|
809
|
+
function sessionIdOfLockFile(entryName) {
|
|
810
|
+
if (!entryName.endsWith(LOCK_FILE_SUFFIX)) return null;
|
|
811
|
+
const lockName = entryName.slice(0, -5);
|
|
812
|
+
const instanceSeparatorIndex = lockName.lastIndexOf(".");
|
|
813
|
+
if (instanceSeparatorIndex < 0) return null;
|
|
814
|
+
const sessionId = lockName.slice(0, instanceSeparatorIndex);
|
|
815
|
+
if (!SESSION_ID_SHAPE.test(sessionId) || !LOCK_INSTANCE_SHAPE.test(lockName.slice(instanceSeparatorIndex + 1))) return null;
|
|
816
|
+
return sessionId;
|
|
817
|
+
}
|
|
818
|
+
function openSessionTempGate(policyDir) {
|
|
819
|
+
mkdirSync(policyDir, {
|
|
820
|
+
recursive: true,
|
|
821
|
+
mode: 448
|
|
822
|
+
});
|
|
823
|
+
return openSync(path.join(policyDir, SESSION_TEMP_GATE_FILE_NAME), "a+");
|
|
824
|
+
}
|
|
825
|
+
function closeSessionTempGate(locks, gateDescriptor) {
|
|
826
|
+
try {
|
|
827
|
+
locks.unlock(gateDescriptor);
|
|
828
|
+
} finally {
|
|
829
|
+
closeSync(gateDescriptor);
|
|
830
|
+
}
|
|
831
|
+
}
|
|
832
|
+
function lockOwnSessionFile(locks, lockPath) {
|
|
833
|
+
const lockDescriptor = openSync(lockPath, "a+");
|
|
834
|
+
if (locks.tryLock(lockDescriptor)) return lockDescriptor;
|
|
835
|
+
closeSync(lockDescriptor);
|
|
836
|
+
return null;
|
|
837
|
+
}
|
|
838
|
+
function holdSessionLockWhileGated(locks, policyDir, sessionId, sessionTempFolder) {
|
|
839
|
+
const gateDescriptor = openSessionTempGate(policyDir);
|
|
840
|
+
try {
|
|
841
|
+
locks.waitForLockSync(gateDescriptor, { shared: true });
|
|
842
|
+
const lockDescriptor = lockOwnSessionFile(locks, ownSessionLockPath(policyDir, sessionId));
|
|
843
|
+
if (lockDescriptor !== null) heldLockDescriptorsBySessionId.set(sessionId, lockDescriptor);
|
|
844
|
+
mkdirSync(sessionTempFolder, { recursive: true });
|
|
845
|
+
} finally {
|
|
846
|
+
closeSessionTempGate(locks, gateDescriptor);
|
|
847
|
+
}
|
|
848
|
+
}
|
|
849
|
+
function createHeldSessionTempFolder(policyDir, sessionId, sessionTempFolder) {
|
|
850
|
+
const locks = loadFileLocks();
|
|
851
|
+
if (locks === null || heldLockDescriptorsBySessionId.has(sessionId)) {
|
|
852
|
+
mkdirSync(sessionTempFolder, { recursive: true });
|
|
853
|
+
return;
|
|
854
|
+
}
|
|
855
|
+
holdSessionLockWhileGated(locks, policyDir, sessionId, sessionTempFolder);
|
|
856
|
+
}
|
|
857
|
+
function releaseSessionLock(policyDir, sessionId) {
|
|
858
|
+
const lockDescriptor = heldLockDescriptorsBySessionId.get(sessionId);
|
|
859
|
+
if (lockDescriptor === void 0) return false;
|
|
860
|
+
heldLockDescriptorsBySessionId.delete(sessionId);
|
|
861
|
+
try {
|
|
862
|
+
unlinkSync(ownSessionLockPath(policyDir, sessionId));
|
|
863
|
+
} finally {
|
|
864
|
+
loadFileLocks()?.unlock(lockDescriptor);
|
|
865
|
+
closeSync(lockDescriptor);
|
|
866
|
+
}
|
|
867
|
+
return true;
|
|
868
|
+
}
|
|
869
|
+
function openExistingLockFile(lockPath) {
|
|
870
|
+
try {
|
|
871
|
+
return openSync(lockPath, "r+");
|
|
872
|
+
} catch {
|
|
873
|
+
return null;
|
|
874
|
+
}
|
|
875
|
+
}
|
|
876
|
+
function tryLockOrFalse(locks, lockDescriptor) {
|
|
877
|
+
try {
|
|
878
|
+
return locks.tryLock(lockDescriptor);
|
|
879
|
+
} catch {
|
|
880
|
+
return false;
|
|
881
|
+
}
|
|
882
|
+
}
|
|
883
|
+
function lockIfUnheld(locks, lockPath) {
|
|
884
|
+
const lockDescriptor = openExistingLockFile(lockPath);
|
|
885
|
+
if (lockDescriptor === null) return null;
|
|
886
|
+
if (tryLockOrFalse(locks, lockDescriptor)) return lockDescriptor;
|
|
887
|
+
closeSync(lockDescriptor);
|
|
888
|
+
return null;
|
|
889
|
+
}
|
|
890
|
+
function releaseLockDescriptors(locks, lockDescriptors) {
|
|
891
|
+
for (const lockDescriptor of lockDescriptors) {
|
|
892
|
+
locks.unlock(lockDescriptor);
|
|
893
|
+
closeSync(lockDescriptor);
|
|
894
|
+
}
|
|
895
|
+
}
|
|
896
|
+
function sessionLockPathsIn(policyDir, sessionId) {
|
|
897
|
+
return readdirSync(policyDir).filter((entryName) => sessionIdOfLockFile(entryName) === sessionId).map((entryName) => path.join(policyDir, entryName));
|
|
898
|
+
}
|
|
899
|
+
function moveFolderToTrash(sessionTempFolder, sessionId) {
|
|
900
|
+
const trashFolder = path.join(path.dirname(sessionTempFolder), `${TRASH_FOLDER_PREFIX}${sessionId}-${randomUUID()}`);
|
|
901
|
+
try {
|
|
902
|
+
renameSync(sessionTempFolder, trashFolder);
|
|
903
|
+
return trashFolder;
|
|
904
|
+
} catch (error) {
|
|
905
|
+
if (isMissingFileError(error)) return null;
|
|
906
|
+
throw error;
|
|
907
|
+
}
|
|
908
|
+
}
|
|
909
|
+
function trashFolderIfEveryLockIsFree(locks, policyDir, sessionId, sessionTempFolder, { keepWhenNoLockFiles }) {
|
|
910
|
+
const lockPaths = sessionLockPathsIn(policyDir, sessionId);
|
|
911
|
+
if (keepWhenNoLockFiles && lockPaths.length === 0) return null;
|
|
912
|
+
const claimedLockDescriptors = lockPaths.map((lockPath) => lockIfUnheld(locks, lockPath)).filter((lockDescriptor) => lockDescriptor !== null);
|
|
913
|
+
try {
|
|
914
|
+
if (claimedLockDescriptors.length !== lockPaths.length) return null;
|
|
915
|
+
const trashFolder = moveFolderToTrash(sessionTempFolder, sessionId);
|
|
916
|
+
for (const lockPath of lockPaths) rmSync(lockPath, { force: true });
|
|
917
|
+
return trashFolder;
|
|
918
|
+
} finally {
|
|
919
|
+
releaseLockDescriptors(locks, claimedLockDescriptors);
|
|
920
|
+
}
|
|
921
|
+
}
|
|
922
|
+
function trashSessionTempFolderOnceUnheld(policyDir, sessionId, sessionTempFolder, options) {
|
|
923
|
+
const locks = loadFileLocks();
|
|
924
|
+
if (locks === null) return null;
|
|
925
|
+
const gateDescriptor = openSessionTempGate(policyDir);
|
|
926
|
+
try {
|
|
927
|
+
if (!locks.tryLock(gateDescriptor)) return null;
|
|
928
|
+
return trashFolderIfEveryLockIsFree(locks, policyDir, sessionId, sessionTempFolder, options);
|
|
929
|
+
} finally {
|
|
930
|
+
closeSessionTempGate(locks, gateDescriptor);
|
|
931
|
+
}
|
|
932
|
+
}
|
|
933
|
+
//#endregion
|
|
642
934
|
//#region session/kimi-home.ts
|
|
643
935
|
var GENERATED_HOME_MODE = 448;
|
|
644
936
|
var GENERATED_FILE_MODE = 384;
|
|
@@ -658,20 +950,40 @@ function listFolder(folder) {
|
|
|
658
950
|
throw error;
|
|
659
951
|
}
|
|
660
952
|
}
|
|
661
|
-
function
|
|
953
|
+
function statOrNull(entryPath) {
|
|
662
954
|
try {
|
|
663
|
-
return fs.statSync(entryPath)
|
|
955
|
+
return fs.statSync(entryPath);
|
|
664
956
|
} catch {
|
|
665
957
|
return null;
|
|
666
958
|
}
|
|
667
959
|
}
|
|
668
|
-
function
|
|
960
|
+
function fileStampOf(entryStat) {
|
|
961
|
+
return `${entryStat.size}:${entryStat.mtimeMs}`;
|
|
962
|
+
}
|
|
963
|
+
function childNamesOf(folder) {
|
|
964
|
+
return listFolder(folder).map((dirent) => dirent.name);
|
|
965
|
+
}
|
|
966
|
+
function listRealEntries(realHome, privateFolderNames) {
|
|
669
967
|
const entries = [];
|
|
670
968
|
for (const dirent of listFolder(realHome)) {
|
|
671
|
-
const
|
|
672
|
-
|
|
969
|
+
const entryPath = path.join(realHome, dirent.name);
|
|
970
|
+
const entryStat = statOrNull(entryPath);
|
|
971
|
+
if (!entryStat) continue;
|
|
972
|
+
if (entryStat.isDirectory()) {
|
|
973
|
+
const childNames = privateFolderNames.has(dirent.name) ? childNamesOf(entryPath) : [];
|
|
974
|
+
entries.push({
|
|
975
|
+
name: dirent.name,
|
|
976
|
+
kind: "folder",
|
|
977
|
+
fileStamp: null,
|
|
978
|
+
childNames
|
|
979
|
+
});
|
|
980
|
+
continue;
|
|
981
|
+
}
|
|
982
|
+
entries.push({
|
|
673
983
|
name: dirent.name,
|
|
674
|
-
kind
|
|
984
|
+
kind: "file",
|
|
985
|
+
fileStamp: fileStampOf(entryStat),
|
|
986
|
+
childNames: []
|
|
675
987
|
});
|
|
676
988
|
}
|
|
677
989
|
return entries;
|
|
@@ -694,23 +1006,27 @@ function describeGeneratedEntry(generatedHome, realHome, name) {
|
|
|
694
1006
|
if (entryStat.isSymbolicLink()) return {
|
|
695
1007
|
name,
|
|
696
1008
|
kind: "link",
|
|
697
|
-
linkTarget: path.resolve(generatedHome, fs.readlinkSync(entryPath))
|
|
1009
|
+
linkTarget: path.resolve(generatedHome, fs.readlinkSync(entryPath)),
|
|
1010
|
+
childNames: []
|
|
698
1011
|
};
|
|
699
1012
|
if (entryStat.isDirectory()) return {
|
|
700
1013
|
name,
|
|
701
1014
|
kind: "folder",
|
|
702
|
-
linkTarget: null
|
|
1015
|
+
linkTarget: null,
|
|
1016
|
+
childNames: childNamesOf(entryPath)
|
|
703
1017
|
};
|
|
704
1018
|
const hardLinkedTo = hardLinkTarget(entryStat, realHome, name);
|
|
705
1019
|
if (hardLinkedTo) return {
|
|
706
1020
|
name,
|
|
707
1021
|
kind: "link",
|
|
708
|
-
linkTarget: hardLinkedTo
|
|
1022
|
+
linkTarget: hardLinkedTo,
|
|
1023
|
+
childNames: []
|
|
709
1024
|
};
|
|
710
1025
|
return {
|
|
711
1026
|
name,
|
|
712
1027
|
kind: "file",
|
|
713
|
-
linkTarget: null
|
|
1028
|
+
linkTarget: null,
|
|
1029
|
+
childNames: []
|
|
714
1030
|
};
|
|
715
1031
|
}
|
|
716
1032
|
function readOptionalText(filePath) {
|
|
@@ -765,12 +1081,13 @@ function planFromDisk({ hooksBlock, platform = process.platform }, realHome, gen
|
|
|
765
1081
|
kind: "refused",
|
|
766
1082
|
reason: realConfig.refusal
|
|
767
1083
|
};
|
|
768
|
-
const
|
|
1084
|
+
const generatedEntries = childNamesOf(generatedHome).map((name) => describeGeneratedEntry(generatedHome, realHome, name));
|
|
769
1085
|
return planKimiHome({
|
|
770
1086
|
realHome,
|
|
771
|
-
realEntries: listRealEntries(realHome),
|
|
772
|
-
generatedEntries
|
|
1087
|
+
realEntries: listRealEntries(realHome, new Set(generatedEntries.filter((entry) => entry.kind === "folder").map((entry) => entry.name))),
|
|
1088
|
+
generatedEntries,
|
|
773
1089
|
realConfigText: realConfig.text,
|
|
1090
|
+
baseConfigText: readOptionalText(path.join(generatedHome, KIMI_BASE_NAME)),
|
|
774
1091
|
generatedConfigText: readOptionalText(path.join(generatedHome, KIMI_CONFIG_NAME)),
|
|
775
1092
|
hooksBlock,
|
|
776
1093
|
sourceStamps: readSourceStamps(generatedHome),
|
|
@@ -778,20 +1095,73 @@ function planFromDisk({ hooksBlock, platform = process.platform }, realHome, gen
|
|
|
778
1095
|
});
|
|
779
1096
|
}
|
|
780
1097
|
function stepEntryPath(generatedHome, step) {
|
|
781
|
-
|
|
1098
|
+
if (step.kind === "write-config") return path.join(generatedHome, KIMI_CONFIG_NAME);
|
|
1099
|
+
if (step.kind === "write-base") return path.join(generatedHome, KIMI_BASE_NAME);
|
|
1100
|
+
return path.join(generatedHome, step.name);
|
|
782
1101
|
}
|
|
783
|
-
function
|
|
784
|
-
const
|
|
785
|
-
|
|
786
|
-
|
|
787
|
-
|
|
788
|
-
|
|
1102
|
+
function promoteIntoRealHome(entryPath, target) {
|
|
1103
|
+
const resolvedTarget = fs.realpathSync(target);
|
|
1104
|
+
const stagedPath = `${resolvedTarget}.glimmervoid-${process.pid}`;
|
|
1105
|
+
try {
|
|
1106
|
+
fs.copyFileSync(entryPath, stagedPath);
|
|
1107
|
+
fs.chmodSync(stagedPath, fs.statSync(resolvedTarget).mode & 511);
|
|
1108
|
+
fs.renameSync(stagedPath, resolvedTarget);
|
|
1109
|
+
} catch (error) {
|
|
1110
|
+
fs.rmSync(stagedPath, { force: true });
|
|
1111
|
+
throw error;
|
|
1112
|
+
}
|
|
1113
|
+
fs.unlinkSync(entryPath);
|
|
1114
|
+
}
|
|
1115
|
+
function setAside(generatedHome, entryPath, name) {
|
|
1116
|
+
const conflictsFolder = path.join(generatedHome, KIMI_CONFLICTS_NAME);
|
|
1117
|
+
fs.mkdirSync(conflictsFolder, {
|
|
1118
|
+
recursive: true,
|
|
1119
|
+
mode: GENERATED_HOME_MODE
|
|
1120
|
+
});
|
|
1121
|
+
let copyNumber = 1;
|
|
1122
|
+
while (fs.existsSync(path.join(conflictsFolder, `${name}.${copyNumber}`))) copyNumber += 1;
|
|
1123
|
+
fs.renameSync(entryPath, path.join(conflictsFolder, `${name}.${copyNumber}`));
|
|
1124
|
+
}
|
|
1125
|
+
function moveAcrossVolumes(source, destination) {
|
|
1126
|
+
try {
|
|
1127
|
+
fs.renameSync(source, destination);
|
|
1128
|
+
} catch (error) {
|
|
1129
|
+
if (!(error instanceof Error && "code" in error && error.code === "EXDEV")) throw error;
|
|
1130
|
+
fs.cpSync(source, destination, {
|
|
1131
|
+
recursive: true,
|
|
1132
|
+
errorOnExist: true,
|
|
1133
|
+
force: false,
|
|
1134
|
+
preserveTimestamps: true
|
|
789
1135
|
});
|
|
790
|
-
|
|
1136
|
+
fs.rmSync(source, { recursive: true });
|
|
791
1137
|
}
|
|
792
|
-
|
|
793
|
-
|
|
794
|
-
|
|
1138
|
+
}
|
|
1139
|
+
function adoptFolder(entryPath, target, childNames) {
|
|
1140
|
+
for (const childName of childNames) moveAcrossVolumes(path.join(entryPath, childName), path.join(target, childName));
|
|
1141
|
+
fs.rmdirSync(entryPath);
|
|
1142
|
+
}
|
|
1143
|
+
function applyStep(generatedHome, step) {
|
|
1144
|
+
const entryPath = stepEntryPath(generatedHome, step);
|
|
1145
|
+
switch (step.kind) {
|
|
1146
|
+
case "write-config":
|
|
1147
|
+
case "write-base":
|
|
1148
|
+
writeTextAtomicSync(entryPath, step.text, {
|
|
1149
|
+
mode: GENERATED_FILE_MODE,
|
|
1150
|
+
enforceMode: true
|
|
1151
|
+
});
|
|
1152
|
+
return;
|
|
1153
|
+
case "unlink":
|
|
1154
|
+
fs.unlinkSync(entryPath);
|
|
1155
|
+
return;
|
|
1156
|
+
case "promote":
|
|
1157
|
+
promoteIntoRealHome(entryPath, step.target);
|
|
1158
|
+
return;
|
|
1159
|
+
case "set-aside":
|
|
1160
|
+
setAside(generatedHome, entryPath, step.name);
|
|
1161
|
+
return;
|
|
1162
|
+
case "adopt":
|
|
1163
|
+
adoptFolder(entryPath, step.target, step.childNames);
|
|
1164
|
+
return;
|
|
795
1165
|
}
|
|
796
1166
|
if (step.linkKind === "hardlink") {
|
|
797
1167
|
fs.linkSync(step.target, entryPath);
|
|
@@ -802,8 +1172,14 @@ function applyStep(generatedHome, step) {
|
|
|
802
1172
|
function stepFailure(generatedHome, step, error) {
|
|
803
1173
|
const entryPath = stepEntryPath(generatedHome, step);
|
|
804
1174
|
if (step.kind === "link") return `${entryPath} cannot be linked to ${step.target}: ${errorMessage(error)}`;
|
|
1175
|
+
if (step.kind === "promote") return `${entryPath} cannot be moved into ${step.target}: ${errorMessage(error)}`;
|
|
805
1176
|
return `${entryPath} cannot be written: ${errorMessage(error)}`;
|
|
806
1177
|
}
|
|
1178
|
+
function realFileStamps(realHome) {
|
|
1179
|
+
const stamps = {};
|
|
1180
|
+
for (const entry of listRealEntries(realHome, /* @__PURE__ */ new Set())) if (entry.fileStamp !== null) stamps[fileStampKey(entry.name)] = entry.fileStamp;
|
|
1181
|
+
return stamps;
|
|
1182
|
+
}
|
|
807
1183
|
function prepareKimiHome(options) {
|
|
808
1184
|
const generatedHome = generatedKimiHomePath(options.env, options.homeDir);
|
|
809
1185
|
try {
|
|
@@ -817,18 +1193,96 @@ function prepareKimiHome(options) {
|
|
|
817
1193
|
}
|
|
818
1194
|
const { plan } = inspectKimiHome(options);
|
|
819
1195
|
if (plan.kind === "refused") return { refusal: plan.reason };
|
|
820
|
-
|
|
821
|
-
|
|
822
|
-
|
|
823
|
-
|
|
1196
|
+
const keptPrivateNames = /* @__PURE__ */ new Set();
|
|
1197
|
+
for (const step of plan.steps) {
|
|
1198
|
+
if ("name" in step && keptPrivateNames.has(step.name)) continue;
|
|
1199
|
+
try {
|
|
1200
|
+
applyStep(generatedHome, step);
|
|
1201
|
+
} catch (error) {
|
|
1202
|
+
if (step.kind !== "adopt") return { refusal: stepFailure(generatedHome, step, error) };
|
|
1203
|
+
keptPrivateNames.add(step.name);
|
|
1204
|
+
}
|
|
824
1205
|
}
|
|
1206
|
+
const realHome = realKimiHome(options.env, options.homeDir);
|
|
825
1207
|
try {
|
|
826
|
-
writeTextAtomicSync(path.join(generatedHome, KIMI_SOURCES_NAME), `${JSON.stringify(
|
|
1208
|
+
writeTextAtomicSync(path.join(generatedHome, KIMI_SOURCES_NAME), `${JSON.stringify(realFileStamps(realHome), null, 2)}\n`, { mode: GENERATED_FILE_MODE });
|
|
827
1209
|
} catch (error) {
|
|
828
1210
|
return { refusal: `${path.join(generatedHome, KIMI_SOURCES_NAME)} cannot be written: ${errorMessage(error)}` };
|
|
829
1211
|
}
|
|
830
1212
|
return { home: generatedHome };
|
|
831
1213
|
}
|
|
1214
|
+
var liveSessionCountByHome = /* @__PURE__ */ new Map();
|
|
1215
|
+
var inUseLockDescriptorByHome = /* @__PURE__ */ new Map();
|
|
1216
|
+
function inUseLockPath(generatedHome) {
|
|
1217
|
+
return path.join(generatedHome, KIMI_IN_USE_LOCK_NAME);
|
|
1218
|
+
}
|
|
1219
|
+
function takeSharedInUseLock(generatedHome) {
|
|
1220
|
+
const locks = loadFileLocks();
|
|
1221
|
+
if (locks === null) return;
|
|
1222
|
+
fs.mkdirSync(generatedHome, {
|
|
1223
|
+
recursive: true,
|
|
1224
|
+
mode: GENERATED_HOME_MODE
|
|
1225
|
+
});
|
|
1226
|
+
const lockDescriptor = fs.openSync(inUseLockPath(generatedHome), "a+", GENERATED_FILE_MODE);
|
|
1227
|
+
locks.waitForLockSync(lockDescriptor, { shared: true });
|
|
1228
|
+
inUseLockDescriptorByHome.set(generatedHome, lockDescriptor);
|
|
1229
|
+
}
|
|
1230
|
+
function dropSharedInUseLock(generatedHome) {
|
|
1231
|
+
const lockDescriptor = inUseLockDescriptorByHome.get(generatedHome);
|
|
1232
|
+
if (lockDescriptor === void 0) return;
|
|
1233
|
+
inUseLockDescriptorByHome.delete(generatedHome);
|
|
1234
|
+
loadFileLocks()?.unlock(lockDescriptor);
|
|
1235
|
+
fs.closeSync(lockDescriptor);
|
|
1236
|
+
}
|
|
1237
|
+
function openInUseLock(generatedHome) {
|
|
1238
|
+
try {
|
|
1239
|
+
return fs.openSync(inUseLockPath(generatedHome), "a+", GENERATED_FILE_MODE);
|
|
1240
|
+
} catch (error) {
|
|
1241
|
+
if (isMissingFileError(error)) return null;
|
|
1242
|
+
throw error;
|
|
1243
|
+
}
|
|
1244
|
+
}
|
|
1245
|
+
function releaseSecretsUnlessHeldElsewhere(generatedHome, { whenLocksMissing }) {
|
|
1246
|
+
const locks = loadFileLocks();
|
|
1247
|
+
if (locks === null) {
|
|
1248
|
+
if (whenLocksMissing === "release") releaseKimiHomeSecrets(generatedHome);
|
|
1249
|
+
return;
|
|
1250
|
+
}
|
|
1251
|
+
const lockDescriptor = openInUseLock(generatedHome);
|
|
1252
|
+
if (lockDescriptor === null) return;
|
|
1253
|
+
try {
|
|
1254
|
+
if (!locks.tryLock(lockDescriptor)) return;
|
|
1255
|
+
releaseKimiHomeSecrets(generatedHome);
|
|
1256
|
+
locks.unlock(lockDescriptor);
|
|
1257
|
+
} finally {
|
|
1258
|
+
fs.closeSync(lockDescriptor);
|
|
1259
|
+
}
|
|
1260
|
+
}
|
|
1261
|
+
function holdKimiHome(generatedHome) {
|
|
1262
|
+
const liveSessionCount = (liveSessionCountByHome.get(generatedHome) ?? 0) + 1;
|
|
1263
|
+
liveSessionCountByHome.set(generatedHome, liveSessionCount);
|
|
1264
|
+
if (liveSessionCount === 1) takeSharedInUseLock(generatedHome);
|
|
1265
|
+
}
|
|
1266
|
+
function releaseKimiHomeSecrets(generatedHome) {
|
|
1267
|
+
for (const name of [KIMI_CONFIG_NAME, KIMI_BASE_NAME]) try {
|
|
1268
|
+
fs.rmSync(path.join(generatedHome, name), { force: true });
|
|
1269
|
+
} catch (error) {
|
|
1270
|
+
console.warn(`[kimi-home] ${path.join(generatedHome, name)} could not be deleted: ${errorMessage(error)}`);
|
|
1271
|
+
}
|
|
1272
|
+
}
|
|
1273
|
+
function releaseKimiHome(generatedHome) {
|
|
1274
|
+
const liveSessionCount = (liveSessionCountByHome.get(generatedHome) ?? 0) - 1;
|
|
1275
|
+
if (liveSessionCount > 0) {
|
|
1276
|
+
liveSessionCountByHome.set(generatedHome, liveSessionCount);
|
|
1277
|
+
return;
|
|
1278
|
+
}
|
|
1279
|
+
liveSessionCountByHome.delete(generatedHome);
|
|
1280
|
+
dropSharedInUseLock(generatedHome);
|
|
1281
|
+
releaseSecretsUnlessHeldElsewhere(generatedHome, { whenLocksMissing: "release" });
|
|
1282
|
+
}
|
|
1283
|
+
function releaseUnheldKimiHomeSecrets(generatedHome) {
|
|
1284
|
+
releaseSecretsUnlessHeldElsewhere(generatedHome, { whenLocksMissing: "keep" });
|
|
1285
|
+
}
|
|
832
1286
|
//#endregion
|
|
833
1287
|
//#region session/adapters/kimi.ts
|
|
834
1288
|
var ID = "kimi";
|
|
@@ -946,10 +1400,14 @@ function expectedHooksBlock() {
|
|
|
946
1400
|
function prepareHome(env) {
|
|
947
1401
|
const hooksBlock = expectedHooksBlock();
|
|
948
1402
|
if (hooksBlock === null) return { refusal: "the hook relay path cannot be written into a kimi hooks block" };
|
|
949
|
-
|
|
1403
|
+
const generatedHome = generatedKimiHomePath(env);
|
|
1404
|
+
holdKimiHome(generatedHome);
|
|
1405
|
+
const prepared = prepareKimiHome({
|
|
950
1406
|
env,
|
|
951
1407
|
hooksBlock
|
|
952
1408
|
});
|
|
1409
|
+
if ("refusal" in prepared) releaseKimiHome(generatedHome);
|
|
1410
|
+
return prepared;
|
|
953
1411
|
}
|
|
954
1412
|
var WINDOWS_SHAPED_ROOT = /^(?:[A-Za-z]:\/|\/\/)/;
|
|
955
1413
|
var MAX_WORKSPACE_SLUG_LENGTH = 40;
|
|
@@ -1015,7 +1473,8 @@ var kimi = {
|
|
|
1015
1473
|
injection: {
|
|
1016
1474
|
kind: "generated-home",
|
|
1017
1475
|
homeEnvName: HOME_ENV_NAME,
|
|
1018
|
-
prepareHome
|
|
1476
|
+
prepareHome,
|
|
1477
|
+
releaseHome: releaseKimiHome
|
|
1019
1478
|
}
|
|
1020
1479
|
},
|
|
1021
1480
|
resolveCommand,
|
|
@@ -1046,4 +1505,4 @@ var kimi = {
|
|
|
1046
1505
|
}
|
|
1047
1506
|
};
|
|
1048
1507
|
//#endregion
|
|
1049
|
-
export {
|
|
1508
|
+
export { releaseSessionLock as a, classifyKimiConfig as c, classifyAgentTitle as d, isBrailleChar as f, buildAgentEnv as g, renderGrokHooksFile as h, createHeldSessionTempFolder as i, spliceKimiHooksBlock as l, classifyGrokHooksFile as m, generatedKimiHomePath as n, sessionIdOfLockFile as o, isSpinnerChar as p, releaseUnheldKimiHomeSecrets as r, trashSessionTempFolderOnceUnheld as s, kimi as t, grok as u };
|