@akasecurity/ai-tc-codex 0.9.16 → 0.9.17-beta.1
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/.codex-plugin/plugin.json +1 -1
- package/package.json +5 -5
- package/scripts/apply-suppressions.js +678 -1252
- package/scripts/backfill.js +879 -1267
- package/scripts/content-retention.js +761 -2073
- package/scripts/filescan.js +1105 -473
- package/scripts/firstrun.js +1215 -1690
- package/scripts/history-sync.js +750 -2106
- package/scripts/intro.js +123 -2189
- package/scripts/onboard.js +2755 -1185
- package/scripts/post-tool-use.js +1302 -1696
- package/scripts/pre-tool-use.js +903 -1295
- package/scripts/query.js +1215 -1690
- package/scripts/reconcile.js +835 -1277
- package/scripts/remediate.js +920 -1317
- package/scripts/scan-worker.js +97 -13
- package/scripts/session-start.js +1819 -816
- package/scripts/start-light.js +127 -1360
- package/scripts/stop.js +271 -1112
- package/scripts/sync.js +1657 -1005
- package/scripts/user-prompt-submit.js +1042 -1404
|
@@ -1,892 +1,12 @@
|
|
|
1
|
-
var __create = Object.create;
|
|
2
1
|
var __defProp = Object.defineProperty;
|
|
3
|
-
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
4
|
-
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
5
|
-
var __getProtoOf = Object.getPrototypeOf;
|
|
6
|
-
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
7
|
-
var __commonJS = (cb, mod) => function __require() {
|
|
8
|
-
try {
|
|
9
|
-
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
|
|
10
|
-
} catch (e) {
|
|
11
|
-
throw mod = 0, e;
|
|
12
|
-
}
|
|
13
|
-
};
|
|
14
2
|
var __export = (target, all) => {
|
|
15
3
|
for (var name in all)
|
|
16
4
|
__defProp(target, name, { get: all[name], enumerable: true });
|
|
17
5
|
};
|
|
18
|
-
var __copyProps = (to, from, except, desc) => {
|
|
19
|
-
if (from && typeof from === "object" || typeof from === "function") {
|
|
20
|
-
for (let key of __getOwnPropNames(from))
|
|
21
|
-
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
22
|
-
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
|
23
|
-
}
|
|
24
|
-
return to;
|
|
25
|
-
};
|
|
26
|
-
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
|
|
27
|
-
// If the importer is in node compatibility mode or this is not an ESM
|
|
28
|
-
// file that has been converted to a CommonJS file using a Babel-
|
|
29
|
-
// compatible transform (i.e. "__esModule" has not been set), then set
|
|
30
|
-
// "default" to the CommonJS "module.exports" for node compatibility.
|
|
31
|
-
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
|
|
32
|
-
mod
|
|
33
|
-
));
|
|
34
|
-
|
|
35
|
-
// ../../node_modules/.pnpm/ignore@7.0.11/node_modules/ignore/index.js
|
|
36
|
-
var require_ignore = __commonJS({
|
|
37
|
-
"../../node_modules/.pnpm/ignore@7.0.11/node_modules/ignore/index.js"(exports, module) {
|
|
38
|
-
"use strict";
|
|
39
|
-
function makeArray(subject) {
|
|
40
|
-
return Array.isArray(subject) ? subject : [subject];
|
|
41
|
-
}
|
|
42
|
-
var UNDEFINED = void 0;
|
|
43
|
-
var EMPTY = "";
|
|
44
|
-
var SPACE = " ";
|
|
45
|
-
var ESCAPE = "\\";
|
|
46
|
-
var REGEX_LITERAL_SPECIAL = /[.*+?()[\]{}^$|\\/]/;
|
|
47
|
-
var REGEX_TEST_BLANK_LINE = /^\uFEFF? *$/;
|
|
48
|
-
var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
|
|
49
|
-
var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
|
|
50
|
-
var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
|
|
51
|
-
var REGEX_SPLITALL_CRLF = /\r?\n/g;
|
|
52
|
-
var DOUBLE_SLASH = "//";
|
|
53
|
-
var SLASH_CODE = 47;
|
|
54
|
-
var DOT_CODE = 46;
|
|
55
|
-
var SLASH3 = "/";
|
|
56
|
-
var TMP_KEY_IGNORE = "node-ignore";
|
|
57
|
-
if (typeof Symbol !== "undefined") {
|
|
58
|
-
TMP_KEY_IGNORE = /* @__PURE__ */ Symbol.for("node-ignore");
|
|
59
|
-
}
|
|
60
|
-
var KEY_IGNORE = TMP_KEY_IGNORE;
|
|
61
|
-
var define = (object2, key, value) => {
|
|
62
|
-
Object.defineProperty(object2, key, { value });
|
|
63
|
-
return value;
|
|
64
|
-
};
|
|
65
|
-
var RETURN_FALSE = () => false;
|
|
66
|
-
var cleanRangeBackSlash = (slashes) => {
|
|
67
|
-
const { length } = slashes;
|
|
68
|
-
return slashes.slice(0, length - length % 2);
|
|
69
|
-
};
|
|
70
|
-
var POSIX_CLASSES = {
|
|
71
|
-
alnum: "0-9A-Za-z",
|
|
72
|
-
alpha: "A-Za-z",
|
|
73
|
-
blank: " \\t",
|
|
74
|
-
cntrl: "\\x00-\\x1f\\x7f",
|
|
75
|
-
digit: "0-9",
|
|
76
|
-
graph: "!-.0-~",
|
|
77
|
-
lower: "a-z",
|
|
78
|
-
print: " -.0-~",
|
|
79
|
-
punct: "!-.:-@\\[-`{-~",
|
|
80
|
-
// git's `sane-ctype.h` classifies \v and \f as control, not space,
|
|
81
|
-
// unlike C's `isspace`
|
|
82
|
-
space: " \\t\\n\\r",
|
|
83
|
-
upper: "A-Z",
|
|
84
|
-
xdigit: "0-9A-Fa-f"
|
|
85
|
-
};
|
|
86
|
-
var CLASS_MEMBERS_TO_ESCAPE = "\\]^-[";
|
|
87
|
-
var escapeMember = (char) => CLASS_MEMBERS_TO_ESCAPE.indexOf(char) < 0 ? char : ESCAPE + char;
|
|
88
|
-
var NON_SLASH = "(?!\\/)";
|
|
89
|
-
var classSource = (negated, body) => {
|
|
90
|
-
if (negated) {
|
|
91
|
-
return `[^\\/${body}]`;
|
|
92
|
-
}
|
|
93
|
-
const source = `[${body}]`;
|
|
94
|
-
return new RegExp(source).test("/") ? NON_SLASH + source : source;
|
|
95
|
-
};
|
|
96
|
-
var scanBracket = (pattern, start) => {
|
|
97
|
-
const { length } = pattern;
|
|
98
|
-
let index = start + 1;
|
|
99
|
-
let negated = EMPTY;
|
|
100
|
-
const lead = pattern[index];
|
|
101
|
-
if (lead === "!" || lead === "^") {
|
|
102
|
-
negated = "^";
|
|
103
|
-
index++;
|
|
104
|
-
}
|
|
105
|
-
let body = EMPTY;
|
|
106
|
-
let prev = EMPTY;
|
|
107
|
-
for (; ; ) {
|
|
108
|
-
const char = pattern[index];
|
|
109
|
-
if (char === UNDEFINED) {
|
|
110
|
-
return null;
|
|
111
|
-
}
|
|
112
|
-
if (char === ESCAPE) {
|
|
113
|
-
const escaped = pattern[index + 1];
|
|
114
|
-
if (escaped === UNDEFINED) {
|
|
115
|
-
return null;
|
|
116
|
-
}
|
|
117
|
-
body += escapeMember(escaped);
|
|
118
|
-
prev = escaped;
|
|
119
|
-
index++;
|
|
120
|
-
} else if (char === "-" && prev && index + 1 < length && pattern[index + 1] !== "]") {
|
|
121
|
-
index++;
|
|
122
|
-
let to = pattern[index];
|
|
123
|
-
if (to === ESCAPE) {
|
|
124
|
-
to = pattern[index += 1];
|
|
125
|
-
}
|
|
126
|
-
if (prev <= to) {
|
|
127
|
-
body += `-${escapeMember(to)}`;
|
|
128
|
-
}
|
|
129
|
-
prev = EMPTY;
|
|
130
|
-
} else if (char === "[" && pattern[index + 1] === ":") {
|
|
131
|
-
const nameStart = index + 2;
|
|
132
|
-
let end = nameStart;
|
|
133
|
-
while (end < length && pattern[end] !== "]") {
|
|
134
|
-
end++;
|
|
135
|
-
}
|
|
136
|
-
if (end === length) {
|
|
137
|
-
return null;
|
|
138
|
-
}
|
|
139
|
-
if (end > nameStart && pattern[end - 1] === ":") {
|
|
140
|
-
const expanded = POSIX_CLASSES[pattern.slice(nameStart, end - 1)];
|
|
141
|
-
if (expanded === UNDEFINED) {
|
|
142
|
-
return null;
|
|
143
|
-
}
|
|
144
|
-
body += expanded;
|
|
145
|
-
prev = EMPTY;
|
|
146
|
-
index = end;
|
|
147
|
-
} else {
|
|
148
|
-
body += escapeMember("[");
|
|
149
|
-
prev = "[";
|
|
150
|
-
index = nameStart - 2;
|
|
151
|
-
}
|
|
152
|
-
} else {
|
|
153
|
-
body += escapeMember(char);
|
|
154
|
-
prev = char;
|
|
155
|
-
}
|
|
156
|
-
index++;
|
|
157
|
-
if (pattern[index] === "]") {
|
|
158
|
-
return {
|
|
159
|
-
end: index,
|
|
160
|
-
source: classSource(negated, body)
|
|
161
|
-
};
|
|
162
|
-
}
|
|
163
|
-
}
|
|
164
|
-
};
|
|
165
|
-
var NEVER_MATCH = "[]";
|
|
166
|
-
var PLACEHOLDER = "\0";
|
|
167
|
-
var REGEX_RESTORE_PLACEHOLDER = new RegExp(
|
|
168
|
-
`${PLACEHOLDER}(\\d+)${PLACEHOLDER}`,
|
|
169
|
-
"g"
|
|
170
|
-
);
|
|
171
|
-
var TRAILING_WILDCARD = "\uE000";
|
|
172
|
-
var TRAILING_DOUBLESTAR = "\uE001";
|
|
173
|
-
var extractBrackets = (pattern) => {
|
|
174
|
-
const sources = [];
|
|
175
|
-
const hold = (source) => `${PLACEHOLDER}${sources.push(source) - 1}${PLACEHOLDER}`;
|
|
176
|
-
const { length } = pattern;
|
|
177
|
-
let out = EMPTY;
|
|
178
|
-
let index = 0;
|
|
179
|
-
while (index < length) {
|
|
180
|
-
const char = pattern[index];
|
|
181
|
-
if (char === ESCAPE) {
|
|
182
|
-
const escaped = pattern[index + 1];
|
|
183
|
-
if (escaped === "*" || escaped === "[" || escaped === SPACE || escaped === ESCAPE) {
|
|
184
|
-
out += pattern.slice(index, index + 2);
|
|
185
|
-
} else {
|
|
186
|
-
out += hold(
|
|
187
|
-
REGEX_LITERAL_SPECIAL.test(escaped) ? ESCAPE + escaped : escaped
|
|
188
|
-
);
|
|
189
|
-
}
|
|
190
|
-
index += 2;
|
|
191
|
-
} else if (char === PLACEHOLDER) {
|
|
192
|
-
out += hold(`[${PLACEHOLDER}]`);
|
|
193
|
-
index++;
|
|
194
|
-
} else if (char === "[") {
|
|
195
|
-
const scanned = scanBracket(pattern, index);
|
|
196
|
-
if (scanned === null) {
|
|
197
|
-
out += hold(NEVER_MATCH);
|
|
198
|
-
index = length;
|
|
199
|
-
} else {
|
|
200
|
-
out += hold(scanned.source);
|
|
201
|
-
index = scanned.end + 1;
|
|
202
|
-
}
|
|
203
|
-
} else {
|
|
204
|
-
out += char;
|
|
205
|
-
index++;
|
|
206
|
-
}
|
|
207
|
-
}
|
|
208
|
-
return {
|
|
209
|
-
source: out,
|
|
210
|
-
sources
|
|
211
|
-
};
|
|
212
|
-
};
|
|
213
|
-
var DIRECT = null;
|
|
214
|
-
var REGEX_INNER_SLASH = /\/(?!$)/;
|
|
215
|
-
var REPLACERS = [
|
|
216
|
-
[
|
|
217
|
-
// Remove BOM
|
|
218
|
-
// TODO:
|
|
219
|
-
// Other similar zero-width characters?
|
|
220
|
-
/^\uFEFF/,
|
|
221
|
-
() => EMPTY,
|
|
222
|
-
"\uFEFF"
|
|
223
|
-
],
|
|
224
|
-
[
|
|
225
|
-
// A trailing line terminator, left on when a whole file's contents are
|
|
226
|
-
// added as one pattern rather than split into lines. git never sees one
|
|
227
|
-
// -- it reads a `.gitignore` line by line -- so it is not part of the
|
|
228
|
-
// pattern and is dropped here, apart from the trailing-space trimming,
|
|
229
|
-
// which follows git in touching spaces and nothing else.
|
|
230
|
-
/[\r\n]+$/,
|
|
231
|
-
() => EMPTY
|
|
232
|
-
],
|
|
233
|
-
// > Trailing spaces are ignored unless they are quoted with backslash ("\")
|
|
234
|
-
[
|
|
235
|
-
// Only spaces, never tabs or other whitespace: git trims a trailing run
|
|
236
|
-
// of `' '` and nothing else (dir.c, `trim_trailing_spaces`, a single
|
|
237
|
-
// `case ' '`), so a pattern ending in a tab keeps it as a literal.
|
|
238
|
-
// (a\ ) -> (a )
|
|
239
|
-
// (a ) -> (a)
|
|
240
|
-
// (a ) -> (a)
|
|
241
|
-
// (a \ ) -> (a )
|
|
242
|
-
/((?:\\\\)*?)(\\? +)$/,
|
|
243
|
-
(_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)
|
|
244
|
-
],
|
|
245
|
-
// Replace (\ ) with ' '
|
|
246
|
-
// Only a space: an escaped tab or other whitespace is already a literal by
|
|
247
|
-
// the time it reaches here, and a bare tab must be left as one, not turned
|
|
248
|
-
// into a space.
|
|
249
|
-
// (\ ) -> ' '
|
|
250
|
-
// (\\ ) -> '\\ '
|
|
251
|
-
// (\\\ ) -> '\\ '
|
|
252
|
-
[
|
|
253
|
-
/(\\+?) /g,
|
|
254
|
-
(_, m1) => {
|
|
255
|
-
const { length } = m1;
|
|
256
|
-
return m1.slice(0, length - length % 2) + SPACE;
|
|
257
|
-
}
|
|
258
|
-
],
|
|
259
|
-
// Escape metacharacters
|
|
260
|
-
// which is written down by users but means special for regular expressions.
|
|
261
|
-
// > There are 12 characters with special meanings:
|
|
262
|
-
// > - the backslash \,
|
|
263
|
-
// > - the caret ^,
|
|
264
|
-
// > - the dollar sign $,
|
|
265
|
-
// > - the period or dot .,
|
|
266
|
-
// > - the vertical bar or pipe symbol |,
|
|
267
|
-
// > - the question mark ?,
|
|
268
|
-
// > - the asterisk or star *,
|
|
269
|
-
// > - the plus sign +,
|
|
270
|
-
// > - the opening parenthesis (,
|
|
271
|
-
// > - the closing parenthesis ),
|
|
272
|
-
// > - and the opening square bracket [,
|
|
273
|
-
// > - the opening curly brace {,
|
|
274
|
-
// > These special characters are often called "metacharacters".
|
|
275
|
-
[
|
|
276
|
-
/[\\$.|*+(){^]/g,
|
|
277
|
-
(match) => `\\${match}`
|
|
278
|
-
],
|
|
279
|
-
[
|
|
280
|
-
// > a question mark (?) matches a single character
|
|
281
|
-
/(?!\\)\?/g,
|
|
282
|
-
() => "[^/]",
|
|
283
|
-
"?"
|
|
284
|
-
],
|
|
285
|
-
// leading slash
|
|
286
|
-
[
|
|
287
|
-
// > A leading slash matches the beginning of the pathname.
|
|
288
|
-
// > For example, "/*.c" matches "cat-file.c" but not "mozilla-sha1/sha1.c".
|
|
289
|
-
// A leading slash matches the beginning of the pathname
|
|
290
|
-
/^\//,
|
|
291
|
-
() => "^",
|
|
292
|
-
SLASH3
|
|
293
|
-
],
|
|
294
|
-
// replace special metacharacter slash after the leading slash
|
|
295
|
-
[
|
|
296
|
-
/\//g,
|
|
297
|
-
() => "\\/",
|
|
298
|
-
SLASH3
|
|
299
|
-
],
|
|
300
|
-
[
|
|
301
|
-
// > A leading "**" followed by a slash means match in all directories.
|
|
302
|
-
// > For example, "**/foo" matches file or directory "foo" anywhere,
|
|
303
|
-
// > the same as pattern "foo".
|
|
304
|
-
// > "**/foo/bar" matches file or directory "bar" anywhere that is directly
|
|
305
|
-
// > under directory "foo".
|
|
306
|
-
// Notice that the '*'s have been replaced as '\\*'
|
|
307
|
-
/^\^*(?:\\\*\\\*\\\/)+/,
|
|
308
|
-
// '**/foo' <-> 'foo'
|
|
309
|
-
() => "^(?:.*\\/)?",
|
|
310
|
-
"*"
|
|
311
|
-
],
|
|
312
|
-
// starting
|
|
313
|
-
[
|
|
314
|
-
// there will be no leading '/'
|
|
315
|
-
// (which has been replaced by section "leading slash")
|
|
316
|
-
// If starts with '**', adding a '^' to the regular expression also works
|
|
317
|
-
DIRECT,
|
|
318
|
-
(source, pattern) => {
|
|
319
|
-
if (!source || source[0] === "^") {
|
|
320
|
-
return source;
|
|
321
|
-
}
|
|
322
|
-
const anchor2 = !REGEX_INNER_SLASH.test(pattern) ? "(?:^|\\/)" : "^";
|
|
323
|
-
return anchor2 + source;
|
|
324
|
-
}
|
|
325
|
-
],
|
|
326
|
-
// two globstars
|
|
327
|
-
[
|
|
328
|
-
// Use lookahead assertions so that we could match more than one `'/**'`
|
|
329
|
-
/\\\/\\\*\\\*(?=\\\/|$)/g,
|
|
330
|
-
// Zero, one or several directories
|
|
331
|
-
// should not use '*', or it will be replaced by the next replacer
|
|
332
|
-
// Check if it is not the last `'/**'`
|
|
333
|
-
(_, index, str2) => index + 6 < str2.length ? str2.slice(index + 6) === "\\/" ? "(?:\\/[^\\/]+)+" : "(?:\\/[^\\/]+)*" : `\\/${TRAILING_DOUBLESTAR}`,
|
|
334
|
-
"*"
|
|
335
|
-
],
|
|
336
|
-
// normal intermediate wildcards
|
|
337
|
-
[
|
|
338
|
-
// Never replace escaped '*'
|
|
339
|
-
// ignore rule '\*' will match the path '*'
|
|
340
|
-
// 'abc.*/' -> go
|
|
341
|
-
// 'abc.*' -> skip this rule,
|
|
342
|
-
// coz trailing single wildcard will be handed by [trailing wildcard]
|
|
343
|
-
/(^|[^\\]+)(\\\*)+(?=.+)/g,
|
|
344
|
-
// '*.js' matches '.js'
|
|
345
|
-
// '*.js' doesn't match 'abc'
|
|
346
|
-
(_, p1, p2) => {
|
|
347
|
-
const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
|
|
348
|
-
return p1 + unescaped;
|
|
349
|
-
},
|
|
350
|
-
"*"
|
|
351
|
-
],
|
|
352
|
-
// trailing wildcard, held apart from a literal star
|
|
353
|
-
[
|
|
354
|
-
// The step above leaves a trailing `*` alone, so a single `\*` is all that
|
|
355
|
-
// can be left at the end here. Whether it is a wildcard or a literal
|
|
356
|
-
// turns on the backslashes the user put in front of it: the escaper has
|
|
357
|
-
// since doubled every one, so what stands here is those `2N` doubled
|
|
358
|
-
// backslashes and then the star's own escape. An even number of the
|
|
359
|
-
// original `N` leaves the star unescaped -- a wildcard -- and an odd
|
|
360
|
-
// number escapes it -- a literal. This runs while the two are still
|
|
361
|
-
// distinct, before the unescape steps below collapse the literal onto
|
|
362
|
-
// the very `\*` a wildcard leaves behind.
|
|
363
|
-
/(^|[^\\])((?:\\\\)*)\\\*$/,
|
|
364
|
-
(match, p1, p2) => (
|
|
365
|
-
// `p2` holds the doubled user backslashes; half of them is `N`.
|
|
366
|
-
p2.length / 2 % 2 === 0 ? p1 + p2 + TRAILING_WILDCARD : match
|
|
367
|
-
),
|
|
368
|
-
"*"
|
|
369
|
-
],
|
|
370
|
-
[
|
|
371
|
-
// unescape, revert step 3 except for back slash
|
|
372
|
-
// For example, if a user escape a '\\*',
|
|
373
|
-
// after step 3, the result will be '\\\\\\*'
|
|
374
|
-
/\\\\\\(?=[$.|*+(){^])/g,
|
|
375
|
-
() => ESCAPE,
|
|
376
|
-
ESCAPE + ESCAPE
|
|
377
|
-
],
|
|
378
|
-
[
|
|
379
|
-
// '\\\\' -> '\\'
|
|
380
|
-
/\\\\/g,
|
|
381
|
-
() => ESCAPE,
|
|
382
|
-
ESCAPE + ESCAPE
|
|
383
|
-
],
|
|
384
|
-
[
|
|
385
|
-
// Every real bracket expression -- POSIX classes included -- has already
|
|
386
|
-
// been held aside by `extractBrackets`, so the only `[` left in the
|
|
387
|
-
// pattern is an escaped, literal one.
|
|
388
|
-
// `\` is escaped by step 3
|
|
389
|
-
/\\\[([^\]/]*?)(\\*)($|\])/g,
|
|
390
|
-
// '\\[bar]' -> '\\\\[bar\\]'
|
|
391
|
-
(match, range, endEscape, close) => `\\[${range}${cleanRangeBackSlash(endEscape)}${close}`,
|
|
392
|
-
"["
|
|
393
|
-
],
|
|
394
|
-
// ending
|
|
395
|
-
[
|
|
396
|
-
// 'js' will not match 'js.'
|
|
397
|
-
// 'ab' will not match 'abc'
|
|
398
|
-
DIRECT,
|
|
399
|
-
// WTF!
|
|
400
|
-
// https://git-scm.com/docs/gitignore
|
|
401
|
-
// changes in [2.22.1](https://git-scm.com/docs/gitignore/2.22.1)
|
|
402
|
-
// which re-fixes #24, #38
|
|
403
|
-
// > If there is a separator at the end of the pattern then the pattern
|
|
404
|
-
// > will only match directories, otherwise the pattern can match both
|
|
405
|
-
// > files and directories.
|
|
406
|
-
// 'js*' will not match 'a.js'
|
|
407
|
-
// 'js/' will not match 'a.js'
|
|
408
|
-
// 'js' will match 'a.js' and 'a.js/'
|
|
409
|
-
(source) => {
|
|
410
|
-
const last = source[source.length - 1];
|
|
411
|
-
if (!last || last === TRAILING_WILDCARD || last === TRAILING_DOUBLESTAR) {
|
|
412
|
-
return source;
|
|
413
|
-
}
|
|
414
|
-
return last === SLASH3 ? `${source}$` : `${source}(?=$|\\/$)`;
|
|
415
|
-
}
|
|
416
|
-
]
|
|
417
|
-
];
|
|
418
|
-
var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\uE000$/;
|
|
419
|
-
var MODE_IGNORE = "regex";
|
|
420
|
-
var MODE_CHECK_IGNORE = "checkRegex";
|
|
421
|
-
var UNDERSCORE = "_";
|
|
422
|
-
var replaceTrailingWildcard = (_, p1) => {
|
|
423
|
-
const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
|
|
424
|
-
return `${prefix}(?=$|\\/$)`;
|
|
425
|
-
};
|
|
426
|
-
var REGEX_REPLACE_TRAILING_DOUBLESTAR = /\uE001$/;
|
|
427
|
-
var replaceTrailingDoublestar = () => ".+(?=$|\\/$)";
|
|
428
|
-
var WILDCARD = "[^\\/]*";
|
|
429
|
-
var separatorAfter = (run, at) => {
|
|
430
|
-
let separator = EMPTY;
|
|
431
|
-
for (let index = at + 1; index < run.length && !run[index].wildcard; index++) {
|
|
432
|
-
separator += run[index].single;
|
|
433
|
-
}
|
|
434
|
-
return separator;
|
|
435
|
-
};
|
|
436
|
-
var pinWildcards = (source) => {
|
|
437
|
-
if (source.indexOf(WILDCARD) < 0) {
|
|
438
|
-
return source;
|
|
439
|
-
}
|
|
440
|
-
const tokens = [];
|
|
441
|
-
const { length } = source;
|
|
442
|
-
let index = 0;
|
|
443
|
-
while (index < length) {
|
|
444
|
-
const char = source[index];
|
|
445
|
-
if (source.startsWith(WILDCARD, index)) {
|
|
446
|
-
tokens.push({ wildcard: true });
|
|
447
|
-
index += WILDCARD.length;
|
|
448
|
-
} else if (char === "[") {
|
|
449
|
-
let end = index + 1;
|
|
450
|
-
if (source[end] === "^") {
|
|
451
|
-
end++;
|
|
452
|
-
}
|
|
453
|
-
if (source[end] === "]") {
|
|
454
|
-
end++;
|
|
455
|
-
}
|
|
456
|
-
while (end < length && source[end] !== "]") {
|
|
457
|
-
end += source[end] === ESCAPE ? 2 : 1;
|
|
458
|
-
}
|
|
459
|
-
end++;
|
|
460
|
-
tokens.push({ single: source.slice(index, end) });
|
|
461
|
-
index = end;
|
|
462
|
-
} else if (char === ESCAPE) {
|
|
463
|
-
tokens.push({ single: source.slice(index, index + 2) });
|
|
464
|
-
index += 2;
|
|
465
|
-
} else if (char === "(") {
|
|
466
|
-
let depth = 0;
|
|
467
|
-
let end = index;
|
|
468
|
-
do {
|
|
469
|
-
if (source[end] === ESCAPE) {
|
|
470
|
-
end++;
|
|
471
|
-
} else if (source[end] === "(") {
|
|
472
|
-
depth++;
|
|
473
|
-
} else if (source[end] === ")") {
|
|
474
|
-
depth--;
|
|
475
|
-
}
|
|
476
|
-
end++;
|
|
477
|
-
} while (end < length && depth > 0);
|
|
478
|
-
if ("*+?".indexOf(source[end]) >= 0) {
|
|
479
|
-
end++;
|
|
480
|
-
}
|
|
481
|
-
tokens.push({ boundary: source.slice(index, end) });
|
|
482
|
-
index = end;
|
|
483
|
-
} else if (char === "^" || char === "$") {
|
|
484
|
-
tokens.push({ boundary: char });
|
|
485
|
-
index++;
|
|
486
|
-
} else {
|
|
487
|
-
tokens.push({ single: char });
|
|
488
|
-
index++;
|
|
489
|
-
}
|
|
490
|
-
}
|
|
491
|
-
let out = EMPTY;
|
|
492
|
-
let run = [];
|
|
493
|
-
const flush = () => {
|
|
494
|
-
let lastWildcard;
|
|
495
|
-
run.forEach((token, at) => {
|
|
496
|
-
if (token.wildcard) {
|
|
497
|
-
lastWildcard = at;
|
|
498
|
-
}
|
|
499
|
-
});
|
|
500
|
-
run.forEach((token, at) => {
|
|
501
|
-
if (!token.wildcard) {
|
|
502
|
-
out += token.single;
|
|
503
|
-
return;
|
|
504
|
-
}
|
|
505
|
-
out += at === lastWildcard ? WILDCARD : `(?:(?!${separatorAfter(run, at)})[^\\/])*`;
|
|
506
|
-
});
|
|
507
|
-
run = [];
|
|
508
|
-
};
|
|
509
|
-
tokens.forEach((token) => {
|
|
510
|
-
if (token.boundary === void 0) {
|
|
511
|
-
run.push(token);
|
|
512
|
-
return;
|
|
513
|
-
}
|
|
514
|
-
flush();
|
|
515
|
-
out += token.boundary;
|
|
516
|
-
});
|
|
517
|
-
flush();
|
|
518
|
-
return out;
|
|
519
|
-
};
|
|
520
|
-
var makeRegexPrefix = (pattern) => {
|
|
521
|
-
const { source, sources } = extractBrackets(pattern);
|
|
522
|
-
const replaced = REPLACERS.reduce(
|
|
523
|
-
// A pass whose matcher finds nothing hands back the very string it was
|
|
524
|
-
// given, so asking first costs a search and saves a rewrite. Ten of the
|
|
525
|
-
// fifteen passes never fire for a typical .gitignore line, and between
|
|
526
|
-
// them they were 45% of this chain.
|
|
527
|
-
(prev, [matcher, replacer, required2]) => {
|
|
528
|
-
if (matcher === DIRECT) {
|
|
529
|
-
return replacer(prev, pattern);
|
|
530
|
-
}
|
|
531
|
-
if (required2 !== UNDEFINED && prev.indexOf(required2) < 0) {
|
|
532
|
-
return prev;
|
|
533
|
-
}
|
|
534
|
-
return matcher.test(prev) ? prev.replace(matcher, replacer.bind(pattern)) : prev;
|
|
535
|
-
},
|
|
536
|
-
source
|
|
537
|
-
);
|
|
538
|
-
return sources.length ? replaced.replace(
|
|
539
|
-
REGEX_RESTORE_PLACEHOLDER,
|
|
540
|
-
(match, index) => sources[index]
|
|
541
|
-
) : replaced;
|
|
542
|
-
};
|
|
543
|
-
var checkSourceOf = (body, prefix) => {
|
|
544
|
-
if (body[body.length - 1] === SLASH3) {
|
|
545
|
-
prefix = makeRegexPrefix(body.slice(0, -1));
|
|
546
|
-
}
|
|
547
|
-
const head = prefix.slice(0, -1);
|
|
548
|
-
const last = prefix[prefix.length - 1];
|
|
549
|
-
return last === TRAILING_WILDCARD ? `${head}$` : last === TRAILING_DOUBLESTAR ? `${head}.*$` : NEVER_MATCH;
|
|
550
|
-
};
|
|
551
|
-
var matchesBasename = (body) => {
|
|
552
|
-
const index = body.indexOf(SLASH3);
|
|
553
|
-
return index < 0 || index === body.length - 1;
|
|
554
|
-
};
|
|
555
|
-
var basenameOf = (path) => {
|
|
556
|
-
const end = path.length - 1;
|
|
557
|
-
const index = path.lastIndexOf(
|
|
558
|
-
SLASH3,
|
|
559
|
-
path[end] === SLASH3 ? end - 1 : end
|
|
560
|
-
);
|
|
561
|
-
return index < 0 ? path : path.slice(index + 1);
|
|
562
|
-
};
|
|
563
|
-
var parentOf = (path) => {
|
|
564
|
-
if (path.charCodeAt(0) === SLASH_CODE || path.indexOf(DOUBLE_SLASH) >= 0) {
|
|
565
|
-
const slices = path.split(SLASH3).filter(Boolean);
|
|
566
|
-
slices.pop();
|
|
567
|
-
return slices.length ? slices.join(SLASH3) + SLASH3 : EMPTY;
|
|
568
|
-
}
|
|
569
|
-
const end = path.length - 1;
|
|
570
|
-
const cut = path.lastIndexOf(
|
|
571
|
-
SLASH3,
|
|
572
|
-
path.charCodeAt(end) === SLASH_CODE ? end - 1 : end
|
|
573
|
-
);
|
|
574
|
-
return cut < 0 ? EMPTY : path.slice(0, cut + 1);
|
|
575
|
-
};
|
|
576
|
-
var isString = (subject) => typeof subject === "string";
|
|
577
|
-
var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
|
|
578
|
-
var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
|
|
579
|
-
var IgnoreRule = class {
|
|
580
|
-
constructor(pattern, mark, body, ignoreCase, negative, prefix) {
|
|
581
|
-
this.pattern = pattern;
|
|
582
|
-
this.mark = mark;
|
|
583
|
-
this.negative = negative;
|
|
584
|
-
define(this, "body", body);
|
|
585
|
-
define(this, "ignoreCase", ignoreCase);
|
|
586
|
-
define(this, "regexPrefix", prefix);
|
|
587
|
-
}
|
|
588
|
-
// Worked out on first use and kept behind an own property, the way `regex`
|
|
589
|
-
// caches itself in `_regex`. Deciding it in the constructor instead would
|
|
590
|
-
// add a fourth `defineProperty` to every rule ever built, which cost 4% of
|
|
591
|
-
// every compile -- including the compiles of rules that are never matched
|
|
592
|
-
// against anything.
|
|
593
|
-
get _basenameOnly() {
|
|
594
|
-
return define(this, "_basenameOnly", matchesBasename(this.body));
|
|
595
|
-
}
|
|
596
|
-
get regex() {
|
|
597
|
-
const key = UNDERSCORE + MODE_IGNORE;
|
|
598
|
-
if (this[key]) {
|
|
599
|
-
return this[key];
|
|
600
|
-
}
|
|
601
|
-
return this._make(MODE_IGNORE, key);
|
|
602
|
-
}
|
|
603
|
-
get checkRegex() {
|
|
604
|
-
const key = UNDERSCORE + MODE_CHECK_IGNORE;
|
|
605
|
-
if (this[key]) {
|
|
606
|
-
return this[key];
|
|
607
|
-
}
|
|
608
|
-
return this._make(MODE_CHECK_IGNORE, key);
|
|
609
|
-
}
|
|
610
|
-
_make(mode, key) {
|
|
611
|
-
const str2 = pinWildcards(
|
|
612
|
-
mode === MODE_IGNORE ? this.regexPrefix.replace(REGEX_REPLACE_TRAILING_WILDCARD, replaceTrailingWildcard).replace(REGEX_REPLACE_TRAILING_DOUBLESTAR, replaceTrailingDoublestar) : checkSourceOf(this.body, this.regexPrefix)
|
|
613
|
-
);
|
|
614
|
-
const regex = this.ignoreCase ? new RegExp(str2, "i") : new RegExp(str2);
|
|
615
|
-
return define(this, key, regex);
|
|
616
|
-
}
|
|
617
|
-
};
|
|
618
|
-
var createRule = ({
|
|
619
|
-
pattern,
|
|
620
|
-
mark
|
|
621
|
-
}, ignoreCase) => {
|
|
622
|
-
let negative = false;
|
|
623
|
-
let body = pattern;
|
|
624
|
-
if (body.indexOf("!") === 0) {
|
|
625
|
-
negative = true;
|
|
626
|
-
body = body.substr(1);
|
|
627
|
-
}
|
|
628
|
-
body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
|
|
629
|
-
const regexPrefix = makeRegexPrefix(body);
|
|
630
|
-
return new IgnoreRule(
|
|
631
|
-
pattern,
|
|
632
|
-
mark,
|
|
633
|
-
body,
|
|
634
|
-
ignoreCase,
|
|
635
|
-
negative,
|
|
636
|
-
regexPrefix
|
|
637
|
-
);
|
|
638
|
-
};
|
|
639
|
-
var RuleManager = class {
|
|
640
|
-
constructor(ignoreCase) {
|
|
641
|
-
this._ignoreCase = ignoreCase;
|
|
642
|
-
this._rules = [];
|
|
643
|
-
this._basenameCount = 0;
|
|
644
|
-
}
|
|
645
|
-
_add(pattern) {
|
|
646
|
-
if (pattern && pattern[KEY_IGNORE]) {
|
|
647
|
-
this._rules = this._rules.concat(pattern._rules._rules);
|
|
648
|
-
this._basenameCount += pattern._rules._basenameCount;
|
|
649
|
-
this._added = true;
|
|
650
|
-
return;
|
|
651
|
-
}
|
|
652
|
-
if (isString(pattern)) {
|
|
653
|
-
pattern = {
|
|
654
|
-
pattern
|
|
655
|
-
};
|
|
656
|
-
}
|
|
657
|
-
if (checkPattern(pattern.pattern)) {
|
|
658
|
-
const rule = createRule(pattern, this._ignoreCase);
|
|
659
|
-
this._added = true;
|
|
660
|
-
this._rules.push(rule);
|
|
661
|
-
if (matchesBasename(rule.body)) {
|
|
662
|
-
this._basenameCount++;
|
|
663
|
-
}
|
|
664
|
-
}
|
|
665
|
-
}
|
|
666
|
-
// @param {Array<string> | string | Ignore} pattern
|
|
667
|
-
add(pattern) {
|
|
668
|
-
this._added = false;
|
|
669
|
-
makeArray(
|
|
670
|
-
isString(pattern) ? splitPattern(pattern) : pattern
|
|
671
|
-
).forEach(this._add, this);
|
|
672
|
-
if (this._added) {
|
|
673
|
-
this._literalRules = UNDEFINED;
|
|
674
|
-
}
|
|
675
|
-
return this._added;
|
|
676
|
-
}
|
|
677
|
-
// Match the literal 'abc/' for `checkIgnore`, last rule wins. Only a rule
|
|
678
|
-
// ending in a wildcard can match it (see `checkSourceOf`), so the rest
|
|
679
|
-
// are left out once, rather than tested or compiled for every path.
|
|
680
|
-
testLiteral(path) {
|
|
681
|
-
const rules = this._literalRules || (this._literalRules = this._rules.filter(
|
|
682
|
-
({ body }) => body[body.length - (body[body.length - 1] === SLASH3 ? 2 : 1)] === "*"
|
|
683
|
-
));
|
|
684
|
-
let ignored = false;
|
|
685
|
-
let unignored = false;
|
|
686
|
-
let matchedRule;
|
|
687
|
-
for (let index = rules.length - 1; index >= 0; index--) {
|
|
688
|
-
const rule = rules[index];
|
|
689
|
-
if (rule.checkRegex.test(path)) {
|
|
690
|
-
ignored = !rule.negative;
|
|
691
|
-
unignored = rule.negative;
|
|
692
|
-
matchedRule = rule.negative ? UNDEFINED : rule;
|
|
693
|
-
break;
|
|
694
|
-
}
|
|
695
|
-
}
|
|
696
|
-
const ret = {
|
|
697
|
-
ignored,
|
|
698
|
-
unignored
|
|
699
|
-
};
|
|
700
|
-
if (matchedRule) {
|
|
701
|
-
ret.rule = matchedRule;
|
|
702
|
-
}
|
|
703
|
-
return ret;
|
|
704
|
-
}
|
|
705
|
-
// Test one single path without recursively checking parent directories
|
|
706
|
-
//
|
|
707
|
-
// - checkUnignored `boolean` whether should check if the path is unignored,
|
|
708
|
-
// setting `checkUnignored` to `false` could reduce additional
|
|
709
|
-
// path matching.
|
|
710
|
-
// - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
|
|
711
|
-
// @returns {TestResult} true if a file is ignored
|
|
712
|
-
test(path, checkUnignored, mode) {
|
|
713
|
-
let ignored = false;
|
|
714
|
-
let unignored = false;
|
|
715
|
-
let matchedRule;
|
|
716
|
-
const rules = this._rules;
|
|
717
|
-
const { length } = rules;
|
|
718
|
-
const shortcut = this._basenameCount * 2 >= length;
|
|
719
|
-
const basename7 = shortcut ? basenameOf(path) : path;
|
|
720
|
-
for (let index = 0; index < length; index++) {
|
|
721
|
-
const rule = rules[index];
|
|
722
|
-
const { negative } = rule;
|
|
723
|
-
const skip = unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored;
|
|
724
|
-
if (!skip && rule[mode].test(
|
|
725
|
-
shortcut && rule._basenameOnly ? basename7 : path
|
|
726
|
-
)) {
|
|
727
|
-
ignored = !negative;
|
|
728
|
-
unignored = negative;
|
|
729
|
-
matchedRule = negative ? UNDEFINED : rule;
|
|
730
|
-
}
|
|
731
|
-
}
|
|
732
|
-
const ret = {
|
|
733
|
-
ignored,
|
|
734
|
-
unignored
|
|
735
|
-
};
|
|
736
|
-
if (matchedRule) {
|
|
737
|
-
ret.rule = matchedRule;
|
|
738
|
-
}
|
|
739
|
-
return ret;
|
|
740
|
-
}
|
|
741
|
-
};
|
|
742
|
-
var throwError = (message, Ctor) => {
|
|
743
|
-
throw new Ctor(message);
|
|
744
|
-
};
|
|
745
|
-
var checkPath = (path, originalPath, doThrow) => {
|
|
746
|
-
if (!isString(path)) {
|
|
747
|
-
return doThrow(
|
|
748
|
-
`path must be a string, but got \`${originalPath}\``,
|
|
749
|
-
TypeError
|
|
750
|
-
);
|
|
751
|
-
}
|
|
752
|
-
if (!path) {
|
|
753
|
-
return doThrow(`path must not be empty`, TypeError);
|
|
754
|
-
}
|
|
755
|
-
if (checkPath.isNotRelative(path)) {
|
|
756
|
-
const r = "`path.relative()`d";
|
|
757
|
-
return doThrow(
|
|
758
|
-
`path should be a ${r} string, but got "${originalPath}"`,
|
|
759
|
-
RangeError
|
|
760
|
-
);
|
|
761
|
-
}
|
|
762
|
-
return true;
|
|
763
|
-
};
|
|
764
|
-
var isNotRelative = (path) => {
|
|
765
|
-
const first = path.charCodeAt(0);
|
|
766
|
-
if (first === SLASH_CODE) {
|
|
767
|
-
return true;
|
|
768
|
-
}
|
|
769
|
-
if (first !== DOT_CODE) {
|
|
770
|
-
return false;
|
|
771
|
-
}
|
|
772
|
-
if (path.length === 1) {
|
|
773
|
-
return true;
|
|
774
|
-
}
|
|
775
|
-
const second = path.charCodeAt(1);
|
|
776
|
-
if (second === SLASH_CODE) {
|
|
777
|
-
return true;
|
|
778
|
-
}
|
|
779
|
-
if (second !== DOT_CODE) {
|
|
780
|
-
return false;
|
|
781
|
-
}
|
|
782
|
-
return path.length === 2 || path.charCodeAt(2) === SLASH_CODE;
|
|
783
|
-
};
|
|
784
|
-
checkPath.isNotRelative = isNotRelative;
|
|
785
|
-
checkPath.convert = (p) => p;
|
|
786
|
-
var Ignore = class {
|
|
787
|
-
constructor({
|
|
788
|
-
ignorecase = true,
|
|
789
|
-
ignoreCase = ignorecase,
|
|
790
|
-
allowRelativePaths = false
|
|
791
|
-
} = {}) {
|
|
792
|
-
define(this, KEY_IGNORE, true);
|
|
793
|
-
this._rules = new RuleManager(ignoreCase);
|
|
794
|
-
this._strictPathCheck = !allowRelativePaths;
|
|
795
|
-
this._initCache();
|
|
796
|
-
}
|
|
797
|
-
_initCache() {
|
|
798
|
-
this._ignoreCache = /* @__PURE__ */ Object.create(null);
|
|
799
|
-
this._testCache = /* @__PURE__ */ Object.create(null);
|
|
800
|
-
}
|
|
801
|
-
add(pattern) {
|
|
802
|
-
if (this._rules.add(pattern)) {
|
|
803
|
-
this._initCache();
|
|
804
|
-
}
|
|
805
|
-
return this;
|
|
806
|
-
}
|
|
807
|
-
// legacy
|
|
808
|
-
addPattern(pattern) {
|
|
809
|
-
return this.add(pattern);
|
|
810
|
-
}
|
|
811
|
-
// @returns {TestResult}
|
|
812
|
-
_test(originalPath, cache, checkUnignored) {
|
|
813
|
-
const path = originalPath && checkPath.convert(originalPath);
|
|
814
|
-
checkPath(
|
|
815
|
-
path,
|
|
816
|
-
originalPath,
|
|
817
|
-
this._strictPathCheck ? throwError : RETURN_FALSE
|
|
818
|
-
);
|
|
819
|
-
return this._t(path, cache, checkUnignored);
|
|
820
|
-
}
|
|
821
|
-
checkIgnore(path) {
|
|
822
|
-
if (path.charCodeAt(path.length - 1) !== SLASH_CODE) {
|
|
823
|
-
return this.test(path);
|
|
824
|
-
}
|
|
825
|
-
const dir = this._t(path, this._testCache, true);
|
|
826
|
-
if (dir.ignored) {
|
|
827
|
-
return dir;
|
|
828
|
-
}
|
|
829
|
-
const literal2 = this._rules.testLiteral(path);
|
|
830
|
-
return literal2.ignored || literal2.unignored ? literal2 : dir;
|
|
831
|
-
}
|
|
832
|
-
_t(path, cache, checkUnignored) {
|
|
833
|
-
if (path in cache) {
|
|
834
|
-
return cache[path];
|
|
835
|
-
}
|
|
836
|
-
const parentPath = parentOf(path);
|
|
837
|
-
const parent = parentPath ? this._t(parentPath, cache, checkUnignored) : UNDEFINED;
|
|
838
|
-
return cache[path] = parent && parent.ignored ? parent : this._rules.test(path, checkUnignored, MODE_IGNORE);
|
|
839
|
-
}
|
|
840
|
-
ignores(path) {
|
|
841
|
-
return this._test(path, this._ignoreCache, false).ignored;
|
|
842
|
-
}
|
|
843
|
-
createFilter() {
|
|
844
|
-
return (path) => !this.ignores(path);
|
|
845
|
-
}
|
|
846
|
-
filter(paths) {
|
|
847
|
-
return makeArray(paths).filter(this.createFilter());
|
|
848
|
-
}
|
|
849
|
-
// @returns {TestResult}
|
|
850
|
-
test(path) {
|
|
851
|
-
return this._test(path, this._testCache, true);
|
|
852
|
-
}
|
|
853
|
-
};
|
|
854
|
-
var factory = (options) => new Ignore(options);
|
|
855
|
-
var isPathValid = (path) => checkPath(path && checkPath.convert(path), path, RETURN_FALSE);
|
|
856
|
-
var setupWindows = () => {
|
|
857
|
-
const makePosix = (str2) => /^\\\\\?\\/.test(str2) || /["<>|\u0000-\u001F]+/u.test(str2) ? str2 : str2.replace(/\\/g, "/");
|
|
858
|
-
checkPath.convert = makePosix;
|
|
859
|
-
const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
|
|
860
|
-
checkPath.isNotRelative = (path) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path) || isNotRelative(path);
|
|
861
|
-
};
|
|
862
|
-
if (
|
|
863
|
-
// Detect `process` so that it can run in browsers.
|
|
864
|
-
typeof process !== "undefined" && process.platform === "win32"
|
|
865
|
-
) {
|
|
866
|
-
setupWindows();
|
|
867
|
-
}
|
|
868
|
-
module.exports = factory;
|
|
869
|
-
factory.default = factory;
|
|
870
|
-
module.exports.isPathValid = isPathValid;
|
|
871
|
-
define(module.exports, /* @__PURE__ */ Symbol.for("setupWindows"), setupWindows);
|
|
872
|
-
}
|
|
873
|
-
});
|
|
874
6
|
|
|
875
7
|
// ../../packages/plugin-sdk/src/config.ts
|
|
876
8
|
import { existsSync as existsSync8 } from "fs";
|
|
877
|
-
import { join as
|
|
878
|
-
|
|
879
|
-
// ../../packages/persistence/src/attached-derived.ts
|
|
880
|
-
import { rmSync } from "fs";
|
|
881
|
-
import { join } from "path";
|
|
882
|
-
var POLICY_CACHE_FILENAME = "policy-cache.json";
|
|
883
|
-
var ATTACHED_FORWARD_STATE_FILENAME = "attached-state.json";
|
|
884
|
-
var ATTACHED_FORWARD_DROPS_FILENAME = "attached-forward-drops.json";
|
|
885
|
-
var ATTACHED_POSTURE_REPORT_FILENAME = "attached-posture-report.json";
|
|
886
|
-
|
|
887
|
-
// ../../packages/persistence/src/control-plane-credential.ts
|
|
888
|
-
import { chmodSync as chmodSync2, lstatSync as lstatSync2, readFileSync, rmSync as rmSync3, statSync } from "fs";
|
|
889
|
-
import { join as join2 } from "path";
|
|
9
|
+
import { join as join17 } from "path";
|
|
890
10
|
|
|
891
11
|
// ../../packages/schema/src/drizzle/deferred-migrations.ts
|
|
892
12
|
var DEFERRED_MIGRATION_TAGS = [
|
|
@@ -1059,7 +179,7 @@ var MAX_TEMPORARY_MS = 24 * HOUR_MS;
|
|
|
1059
179
|
var ONCE_BACKSTOP_MS = 30 * MINUTE_MS;
|
|
1060
180
|
|
|
1061
181
|
// ../../packages/schema/src/invisible-padding.ts
|
|
1062
|
-
var INVISIBLE_PADDING = /[\u00AD\u200B\u2060-\u2064\u202A-\u202E\u2066-\u2069\uFEFF\u{E0001}\u{E0020}-\u{E007F}]/gu;
|
|
182
|
+
var INVISIBLE_PADDING = /[\u00AD\u061C\u180E\u200B\u200E\u200F\u2060-\u2064\u202A-\u202E\u2066-\u2069\uFEFF\uFFF9-\uFFFB\u{E0001}\u{E0020}-\u{E007F}]/gu;
|
|
1063
183
|
function stripInvisiblePadding(text) {
|
|
1064
184
|
return text.replace(INVISIBLE_PADDING, "");
|
|
1065
185
|
}
|
|
@@ -3877,9 +2997,9 @@ var asciiTabOrNewline = /[\t\n\r]/g;
|
|
|
3877
2997
|
function stripTabAndNewline(value) {
|
|
3878
2998
|
return value.replace(asciiTabOrNewline, "");
|
|
3879
2999
|
}
|
|
3880
|
-
function urlHostnameOk(url2,
|
|
3881
|
-
|
|
3882
|
-
return
|
|
3000
|
+
function urlHostnameOk(url2, hostname6) {
|
|
3001
|
+
hostname6.lastIndex = 0;
|
|
3002
|
+
return hostname6.test(url2.hostname);
|
|
3883
3003
|
}
|
|
3884
3004
|
function urlProtocolOk(url2, protocol) {
|
|
3885
3005
|
protocol.lastIndex = 0;
|
|
@@ -20799,13 +19919,16 @@ function serviceTierMultiplier(tier) {
|
|
|
20799
19919
|
if (tier === void 0) return 1;
|
|
20800
19920
|
return SERVICE_TIER_MULTIPLIERS.get(tier) ?? 1;
|
|
20801
19921
|
}
|
|
19922
|
+
function promptTokensOf(usage) {
|
|
19923
|
+
return usage.promptTokens ?? (usage.inputTokens ?? 0) + (usage.cacheReadTokens ?? 0) + (usage.cacheWrite1hTokens ?? 0) + (usage.cacheWrite5mTokens ?? 0);
|
|
19924
|
+
}
|
|
20802
19925
|
function costOf(price, usage) {
|
|
20803
19926
|
const metered = [
|
|
20804
19927
|
[usage.cacheWrite1hTokens ?? 0, price.cacheWrite1h],
|
|
20805
19928
|
[usage.cacheWrite5mTokens ?? 0, price.cacheWrite5m],
|
|
20806
19929
|
[usage.cacheReadTokens ?? 0, price.cacheRead]
|
|
20807
19930
|
];
|
|
20808
|
-
const band = price.longContext !== null && (usage
|
|
19931
|
+
const band = price.longContext !== null && promptTokensOf(usage) > price.longContext.thresholdInputTokens ? price.longContext : null;
|
|
20809
19932
|
if (band !== null && (band.input === null || band.output === null)) return null;
|
|
20810
19933
|
const inputRate = band?.input ?? price.input;
|
|
20811
19934
|
const outputRate = band?.output ?? price.output;
|
|
@@ -20878,8 +20001,8 @@ var PLATFORM_HOSTING = /* @__PURE__ */ new Map([
|
|
|
20878
20001
|
["ollama", "local"],
|
|
20879
20002
|
["local", "local"]
|
|
20880
20003
|
]);
|
|
20881
|
-
function hostingFor(
|
|
20882
|
-
return PLATFORM_HOSTING.get(
|
|
20004
|
+
function hostingFor(platform) {
|
|
20005
|
+
return PLATFORM_HOSTING.get(platform) ?? "api";
|
|
20883
20006
|
}
|
|
20884
20007
|
var FIRST_PARTY = /* @__PURE__ */ new Map([
|
|
20885
20008
|
["anthropic", "anthropic"],
|
|
@@ -20893,8 +20016,8 @@ var FIRST_PARTY = /* @__PURE__ */ new Map([
|
|
|
20893
20016
|
function firstPartyPlatformFor(vendor2) {
|
|
20894
20017
|
return FIRST_PARTY.get(vendor2) ?? null;
|
|
20895
20018
|
}
|
|
20896
|
-
function isFirstParty(vendor2,
|
|
20897
|
-
return FIRST_PARTY.get(vendor2) ===
|
|
20019
|
+
function isFirstParty(vendor2, platform) {
|
|
20020
|
+
return FIRST_PARTY.get(vendor2) === platform;
|
|
20898
20021
|
}
|
|
20899
20022
|
var PLATFORM_NAMESPACES = Object.freeze([
|
|
20900
20023
|
"anthropic",
|
|
@@ -20955,14 +20078,14 @@ var ModelVendorBuilder = class {
|
|
|
20955
20078
|
);
|
|
20956
20079
|
}
|
|
20957
20080
|
for (const ref of spec.on ?? []) {
|
|
20958
|
-
const { platform
|
|
20959
|
-
const firstParty = isFirstParty(this.vendor,
|
|
20960
|
-
const hosting = hostingFor(
|
|
20081
|
+
const { platform, price, retention, region } = normalizeRef(ref);
|
|
20082
|
+
const firstParty = isFirstParty(this.vendor, platform);
|
|
20083
|
+
const hosting = hostingFor(platform);
|
|
20961
20084
|
const isSelfHosted = hosting === "local";
|
|
20962
20085
|
platforms.set(
|
|
20963
|
-
|
|
20086
|
+
platform,
|
|
20964
20087
|
Object.freeze({
|
|
20965
|
-
platform
|
|
20088
|
+
platform,
|
|
20966
20089
|
hosting,
|
|
20967
20090
|
firstParty,
|
|
20968
20091
|
price: price ?? (isSelfHosted ? ZERO_PRICE : firstParty ? spec.price ?? null : null),
|
|
@@ -21015,35 +20138,35 @@ var GATEWAY_VENDOR_SLASH_RE = /^[a-z0-9][\w.-]*\//iu;
|
|
|
21015
20138
|
var BEDROCK_VERSION_RE = /-v\d+:\d+$/u;
|
|
21016
20139
|
var BEDROCK_REVISION_RE = /:\d+$/u;
|
|
21017
20140
|
var VERTEX_VERSION_RE = /@[\w-]+$/u;
|
|
21018
|
-
var DATED_SUFFIX_RE =
|
|
20141
|
+
var DATED_SUFFIX_RE = /-(?:\d{8}|\d{4}-\d{2}-\d{2})$/u;
|
|
21019
20142
|
function stripPlatformDecorations(model) {
|
|
21020
20143
|
let id = model.trim();
|
|
21021
|
-
let
|
|
20144
|
+
let platform = null;
|
|
21022
20145
|
if (GEO_PREFIX_RE.test(id)) {
|
|
21023
20146
|
id = id.replace(GEO_PREFIX_RE, "");
|
|
21024
|
-
|
|
20147
|
+
platform = "bedrock";
|
|
21025
20148
|
}
|
|
21026
20149
|
if (NAMESPACE_DOT_RE.test(id)) {
|
|
21027
20150
|
id = id.replace(NAMESPACE_DOT_RE, "");
|
|
21028
|
-
|
|
20151
|
+
platform ??= "bedrock";
|
|
21029
20152
|
}
|
|
21030
20153
|
if (BEDROCK_VERSION_RE.test(id)) {
|
|
21031
20154
|
id = id.replace(BEDROCK_VERSION_RE, "");
|
|
21032
|
-
|
|
20155
|
+
platform ??= "bedrock";
|
|
21033
20156
|
} else if (BEDROCK_REVISION_RE.test(id)) {
|
|
21034
20157
|
id = id.replace(BEDROCK_REVISION_RE, "");
|
|
21035
|
-
|
|
20158
|
+
platform ??= "bedrock";
|
|
21036
20159
|
}
|
|
21037
20160
|
if (VERTEX_VERSION_RE.test(id)) {
|
|
21038
20161
|
id = id.replace(VERTEX_VERSION_RE, "");
|
|
21039
|
-
|
|
20162
|
+
platform ??= "vertex";
|
|
21040
20163
|
}
|
|
21041
20164
|
if (NAMESPACE_SLASH_RE.test(id)) {
|
|
21042
20165
|
id = id.replace(NAMESPACE_SLASH_RE, "");
|
|
21043
20166
|
} else if (GATEWAY_VENDOR_SLASH_RE.test(id)) {
|
|
21044
20167
|
id = id.replace(GATEWAY_VENDOR_SLASH_RE, "");
|
|
21045
20168
|
}
|
|
21046
|
-
return { id, platform
|
|
20169
|
+
return { id, platform };
|
|
21047
20170
|
}
|
|
21048
20171
|
function buildModelIndex(entries) {
|
|
21049
20172
|
const byId = /* @__PURE__ */ new Map();
|
|
@@ -21060,19 +20183,19 @@ function resolveModel(raw, index) {
|
|
|
21060
20183
|
if (exact !== void 0) {
|
|
21061
20184
|
return { entry: exact, canonicalId: raw, platform: null, raw };
|
|
21062
20185
|
}
|
|
21063
|
-
const { id, platform
|
|
20186
|
+
const { id, platform } = stripPlatformDecorations(raw);
|
|
21064
20187
|
const stripped = index.byId.get(id);
|
|
21065
20188
|
if (stripped !== void 0) {
|
|
21066
|
-
return { entry: stripped, canonicalId: id, platform
|
|
20189
|
+
return { entry: stripped, canonicalId: id, platform, raw };
|
|
21067
20190
|
}
|
|
21068
20191
|
if (DATED_SUFFIX_RE.test(id)) {
|
|
21069
20192
|
const undated = id.replace(DATED_SUFFIX_RE, "");
|
|
21070
20193
|
const byDate = index.byId.get(undated);
|
|
21071
20194
|
if (byDate !== void 0) {
|
|
21072
|
-
return { entry: byDate, canonicalId: undated, platform
|
|
20195
|
+
return { entry: byDate, canonicalId: undated, platform, raw };
|
|
21073
20196
|
}
|
|
21074
20197
|
}
|
|
21075
|
-
return { entry: null, canonicalId: raw, platform
|
|
20198
|
+
return { entry: null, canonicalId: raw, platform, raw };
|
|
21076
20199
|
}
|
|
21077
20200
|
|
|
21078
20201
|
// ../../packages/schema/src/model/catalog.ts
|
|
@@ -21165,7 +20288,7 @@ anthropic.model("claude-haiku-4-5", {
|
|
|
21165
20288
|
name: "Claude Haiku 4.5",
|
|
21166
20289
|
ctx: 2e5,
|
|
21167
20290
|
maxOut: 64e3,
|
|
21168
|
-
// Reviewed: fast/cheap tier,
|
|
20291
|
+
// Reviewed: fast/cheap general-purpose tier, not a reasoning or code model.
|
|
21169
20292
|
capability: null,
|
|
21170
20293
|
price: anthropicPrice(1, 5, 0.1),
|
|
21171
20294
|
// The vendor documents `claude-haiku-4-5-20251001` as the versioned id and
|
|
@@ -21296,6 +20419,11 @@ openai.model("gpt-4o", {
|
|
|
21296
20419
|
price: tokenPrice(2.5, 10, { cacheRead: 1.25 }),
|
|
21297
20420
|
on: [...OPENAI_RESELLERS]
|
|
21298
20421
|
});
|
|
20422
|
+
openai.model("gpt-4o-2024-05-13", {
|
|
20423
|
+
name: "GPT-4o (2024-05-13)",
|
|
20424
|
+
price: tokenPrice(5, 15),
|
|
20425
|
+
on: [...OPENAI_RESELLERS]
|
|
20426
|
+
});
|
|
21299
20427
|
openai.model("gpt-4o-mini", {
|
|
21300
20428
|
name: "GPT-4o mini",
|
|
21301
20429
|
price: tokenPrice(0.15, 0.6, { cacheRead: 0.075 }),
|
|
@@ -21315,6 +20443,24 @@ openai.model("o3", {
|
|
|
21315
20443
|
price: tokenPrice(2, 8, { cacheRead: 0.5 }),
|
|
21316
20444
|
on: [...OPENAI_RESELLERS]
|
|
21317
20445
|
});
|
|
20446
|
+
openai.model("text-embedding-3-small", {
|
|
20447
|
+
name: "text-embedding-3-small",
|
|
20448
|
+
capability: "embedding",
|
|
20449
|
+
price: tokenPrice(0.02, 0),
|
|
20450
|
+
on: [...OPENAI_RESELLERS]
|
|
20451
|
+
});
|
|
20452
|
+
openai.model("text-embedding-3-large", {
|
|
20453
|
+
name: "text-embedding-3-large",
|
|
20454
|
+
capability: "embedding",
|
|
20455
|
+
price: tokenPrice(0.13, 0),
|
|
20456
|
+
on: [...OPENAI_RESELLERS]
|
|
20457
|
+
});
|
|
20458
|
+
openai.model("text-embedding-ada-002", {
|
|
20459
|
+
name: "text-embedding-ada-002",
|
|
20460
|
+
capability: "embedding",
|
|
20461
|
+
price: tokenPrice(0.1, 0),
|
|
20462
|
+
on: [...OPENAI_RESELLERS]
|
|
20463
|
+
});
|
|
21318
20464
|
openai.model("gpt-oss-120b", {
|
|
21319
20465
|
name: "GPT-OSS 120B",
|
|
21320
20466
|
openWeights: true,
|
|
@@ -21601,10 +20747,21 @@ var MODEL_ENTRIES = Object.freeze([
|
|
|
21601
20747
|
...alibaba.models(),
|
|
21602
20748
|
...amazon.models()
|
|
21603
20749
|
]);
|
|
20750
|
+
var LONG_CONTEXT_THRESHOLDS = Object.freeze(
|
|
20751
|
+
[
|
|
20752
|
+
...new Set(
|
|
20753
|
+
MODEL_ENTRIES.flatMap(
|
|
20754
|
+
(entry) => [...entry.platforms.values()].flatMap(
|
|
20755
|
+
(offering) => offering.price?.longContext ? [offering.price.longContext.thresholdInputTokens] : []
|
|
20756
|
+
)
|
|
20757
|
+
)
|
|
20758
|
+
)
|
|
20759
|
+
].sort((a, b) => a - b)
|
|
20760
|
+
);
|
|
21604
20761
|
var MODEL_INDEX = buildModelIndex(MODEL_ENTRIES);
|
|
21605
20762
|
|
|
21606
20763
|
// ../../packages/schema/src/model/governance.ts
|
|
21607
|
-
var ModelCapability = external_exports.enum(["reasoning", "code"]);
|
|
20764
|
+
var ModelCapability = external_exports.enum(["reasoning", "code", "embedding"]);
|
|
21608
20765
|
var DataRetention = external_exports.enum([
|
|
21609
20766
|
"zero_retention",
|
|
21610
20767
|
"no_storage",
|
|
@@ -21700,16 +20857,16 @@ function platformForProvider(provider) {
|
|
|
21700
20857
|
return PROVIDER_PLATFORM.get(provider.trim().toLowerCase()) ?? null;
|
|
21701
20858
|
}
|
|
21702
20859
|
function isLocalProvider(provider) {
|
|
21703
|
-
const
|
|
21704
|
-
return
|
|
20860
|
+
const platform = platformForProvider(provider);
|
|
20861
|
+
return platform !== null && hostingFor(platform) === "local";
|
|
21705
20862
|
}
|
|
21706
20863
|
function priceFor(provider, model) {
|
|
21707
20864
|
if (isLocalProvider(provider)) return ZERO_PRICE;
|
|
21708
20865
|
const resolved = resolveModel(model, MODEL_INDEX);
|
|
21709
20866
|
if (resolved.entry === null) return null;
|
|
21710
|
-
const
|
|
21711
|
-
if (
|
|
21712
|
-
return resolved.entry.platforms.get(
|
|
20867
|
+
const platform = resolved.platform ?? platformForProvider(provider);
|
|
20868
|
+
if (platform === null) return null;
|
|
20869
|
+
return resolved.entry.platforms.get(platform)?.price ?? null;
|
|
21713
20870
|
}
|
|
21714
20871
|
var defaultCostModel = {
|
|
21715
20872
|
normalizeModelId(provider, model) {
|
|
@@ -21735,7 +20892,7 @@ var COMPACT = new Intl.NumberFormat("en-US", {
|
|
|
21735
20892
|
|
|
21736
20893
|
// ../../packages/schema/src/token/token-report.ts
|
|
21737
20894
|
var num = (value) => value ?? 0;
|
|
21738
|
-
function costUsageOf(a) {
|
|
20895
|
+
function costUsageOf(a, promptTokens) {
|
|
21739
20896
|
const usage = {
|
|
21740
20897
|
inputTokens: num(a.input_tokens),
|
|
21741
20898
|
outputTokens: num(a.output_tokens),
|
|
@@ -21745,11 +20902,12 @@ function costUsageOf(a) {
|
|
|
21745
20902
|
webSearchRequests: num(a.web_search_requests)
|
|
21746
20903
|
};
|
|
21747
20904
|
if (a.service_tier !== void 0) usage.serviceTier = a.service_tier;
|
|
20905
|
+
if (promptTokens !== void 0) usage.promptTokens = promptTokens;
|
|
21748
20906
|
return usage;
|
|
21749
20907
|
}
|
|
21750
20908
|
function buildTokenReports(leaves, costModel) {
|
|
21751
20909
|
const bySession = /* @__PURE__ */ new Map();
|
|
21752
|
-
for (const { sessionId, attributes } of leaves) {
|
|
20910
|
+
for (const { sessionId, attributes, promptTokens } of leaves) {
|
|
21753
20911
|
const provider = attributes.provider ?? "unknown";
|
|
21754
20912
|
const model = attributes.model ?? "unknown";
|
|
21755
20913
|
const key = `${provider} ${model}`;
|
|
@@ -21768,7 +20926,8 @@ function buildTokenReports(leaves, costModel) {
|
|
|
21768
20926
|
cacheCreation: 0,
|
|
21769
20927
|
cacheRead: 0,
|
|
21770
20928
|
costUsd: 0,
|
|
21771
|
-
priced: false
|
|
20929
|
+
priced: false,
|
|
20930
|
+
partial: false
|
|
21772
20931
|
};
|
|
21773
20932
|
rollups.set(key, acc);
|
|
21774
20933
|
}
|
|
@@ -21776,8 +20935,14 @@ function buildTokenReports(leaves, costModel) {
|
|
|
21776
20935
|
acc.output += num(attributes.output_tokens);
|
|
21777
20936
|
acc.cacheCreation += num(attributes.cache_creation_input_tokens);
|
|
21778
20937
|
acc.cacheRead += num(attributes.cache_read_input_tokens);
|
|
21779
|
-
const leafCost = costModel.costFor({
|
|
21780
|
-
|
|
20938
|
+
const leafCost = costModel.costFor({
|
|
20939
|
+
provider,
|
|
20940
|
+
model,
|
|
20941
|
+
usage: costUsageOf(attributes, promptTokens)
|
|
20942
|
+
});
|
|
20943
|
+
if (leafCost === null) {
|
|
20944
|
+
acc.partial = true;
|
|
20945
|
+
} else {
|
|
21781
20946
|
acc.costUsd += leafCost;
|
|
21782
20947
|
acc.priced = true;
|
|
21783
20948
|
}
|
|
@@ -21793,9 +20958,8 @@ function buildTokenReports(leaves, costModel) {
|
|
|
21793
20958
|
const rollupTotal = acc.input + acc.output + acc.cacheCreation + acc.cacheRead;
|
|
21794
20959
|
totalTokens += rollupTotal;
|
|
21795
20960
|
const estimatedCostUsd = acc.priced ? acc.costUsd : null;
|
|
21796
|
-
if (
|
|
21797
|
-
|
|
21798
|
-
} else {
|
|
20961
|
+
if (acc.partial) anyUnpriced = true;
|
|
20962
|
+
if (estimatedCostUsd !== null) {
|
|
21799
20963
|
anyPriced = true;
|
|
21800
20964
|
costUsd += estimatedCostUsd;
|
|
21801
20965
|
}
|
|
@@ -21818,7 +20982,7 @@ function buildTokenReports(leaves, costModel) {
|
|
|
21818
20982
|
totalTokens,
|
|
21819
20983
|
// Σ of the PRICED rollups; null when none had a known price.
|
|
21820
20984
|
estimatedCostUsd: anyPriced ? costUsd : null,
|
|
21821
|
-
// Any
|
|
20985
|
+
// Any call priced to null means the total understates real spend.
|
|
21822
20986
|
costIsPartial: anyUnpriced
|
|
21823
20987
|
});
|
|
21824
20988
|
}
|
|
@@ -22697,8 +21861,9 @@ var SessionTokenReport = external_exports.object({
|
|
|
22697
21861
|
totalTokens: external_exports.number().int().nonnegative(),
|
|
22698
21862
|
// Σ of the PRICED rollups only; null when no rollup had a known price.
|
|
22699
21863
|
estimatedCostUsd: external_exports.number().nullable(),
|
|
22700
|
-
// True whenever any
|
|
22701
|
-
//
|
|
21864
|
+
// True whenever any call priced to null (an unknown provider/model, or a call
|
|
21865
|
+
// over a long-context threshold whose rate is unpublished), so the total
|
|
21866
|
+
// understates real spend — the UI renders `≥ $X` instead of a falsely
|
|
22702
21867
|
// precise figure rather than silently dropping the unpriced calls.
|
|
22703
21868
|
costIsPartial: external_exports.boolean()
|
|
22704
21869
|
});
|
|
@@ -23575,7 +22740,15 @@ var StorePostureSnapshot = external_exports.object({
|
|
|
23575
22740
|
policyCounts: StorePosturePolicyCounts,
|
|
23576
22741
|
// OPTIONAL, not nullable: a reporter that predates this member keeps
|
|
23577
22742
|
// getting its 200 without a payload change.
|
|
23578
|
-
plugin: StorePosturePlugin.optional()
|
|
22743
|
+
plugin: StorePosturePlugin.optional(),
|
|
22744
|
+
// OPTIONAL, and sent only by a scoped attachment, always as `scoped`. A
|
|
22745
|
+
// machine attachment omits it, so its body is byte for byte the one it
|
|
22746
|
+
// sent before this member existed. Absent therefore means machine-wide OR
|
|
22747
|
+
// a reporter older than this member, never "scoped". Both values parse, so
|
|
22748
|
+
// a sender that one day spells `machine` breaks no receiver; any other
|
|
22749
|
+
// value fails the whole snapshot, which is why the reporter sends a
|
|
22750
|
+
// constant and never the raw mode.
|
|
22751
|
+
attachmentMode: AttachmentMode.optional()
|
|
23579
22752
|
}).meta({ id: "StorePostureSnapshot" });
|
|
23580
22753
|
var CAPTURE_VERSION_PREFIX = "capture/";
|
|
23581
22754
|
var RecordAuditEventRequest = AuditEventInput.extend({
|
|
@@ -24022,7 +23195,7 @@ var Rule = external_exports.strictObject({
|
|
|
24022
23195
|
postValidators: external_exports.array(PostValidatorRef).optional(),
|
|
24023
23196
|
requiresNearby: RequiresNearby.optional(),
|
|
24024
23197
|
examples: external_exports.array(external_exports.string()).optional(),
|
|
24025
|
-
// Whether the matched text is itself sensitive
|
|
23198
|
+
// Whether the matched text is itself sensitive (see RuleEvidence).
|
|
24026
23199
|
evidence: RuleEvidence.optional()
|
|
24027
23200
|
}).meta({ id: "Rule" });
|
|
24028
23201
|
var Author = external_exports.object({
|
|
@@ -24114,7 +23287,13 @@ var DetectionRule = external_exports.object({
|
|
|
24114
23287
|
// Representative matching strings the rule author shipped with the rule. The
|
|
24115
23288
|
// cheapest honest answer to "show me what this rule catches" — every bundled
|
|
24116
23289
|
// rule has them, and they are already in the stored snapshot.
|
|
24117
|
-
examples: external_exports.array(external_exports.string()).optional()
|
|
23290
|
+
examples: external_exports.array(external_exports.string()).optional(),
|
|
23291
|
+
// The rule's DECLARED evidence, as stored. Absent defers to the engine's
|
|
23292
|
+
// classification (ruleEvidence in @akasecurity/detections): a bundled
|
|
23293
|
+
// code-flaw rule reads as 'code' and anything else as 'value', and a rule
|
|
23294
|
+
// in a value category (secret/pii/financial/phi) is always 'value',
|
|
23295
|
+
// whatever it declares.
|
|
23296
|
+
evidence: RuleEvidence.optional()
|
|
24118
23297
|
}).meta({ id: "DetectionRule" });
|
|
24119
23298
|
var DetectionUpdate = external_exports.object({
|
|
24120
23299
|
available: external_exports.boolean(),
|
|
@@ -24182,8 +23361,10 @@ var ImportDetectionRequest = external_exports.object({
|
|
|
24182
23361
|
}).meta({ id: "ImportDetectionRequest" });
|
|
24183
23362
|
|
|
24184
23363
|
// ../../packages/schema/src/zod/detection-build.ts
|
|
24185
|
-
function optional2(key,
|
|
24186
|
-
if (raw === void 0
|
|
23364
|
+
function optional2(key, raw, parse4) {
|
|
23365
|
+
if (raw === void 0) return {};
|
|
23366
|
+
const parsed2 = parse4(raw);
|
|
23367
|
+
if (!parsed2.success || parsed2.data === void 0) return {};
|
|
24187
23368
|
return { [key]: parsed2.data };
|
|
24188
23369
|
}
|
|
24189
23370
|
function isStringArray(value) {
|
|
@@ -24218,10 +23399,12 @@ function rowToDetectionDetail(row, findingsLast30d, update) {
|
|
|
24218
23399
|
category: r.category,
|
|
24219
23400
|
severity: r.severity,
|
|
24220
23401
|
matcher: parsed2.data,
|
|
24221
|
-
//
|
|
24222
|
-
//
|
|
24223
|
-
//
|
|
24224
|
-
//
|
|
23402
|
+
// `appliesTo`, `postValidators` and `requiresNearby` are the rest of what
|
|
23403
|
+
// decides whether this rule fires. Carried so a consumer re-running the
|
|
23404
|
+
// rule (a preview, a tester) evaluates what the engine evaluates rather
|
|
23405
|
+
// than a matcher stripped of its guards — half the bundled catalog
|
|
23406
|
+
// carries at least one of these. `examples` and `evidence` describe the
|
|
23407
|
+
// rule and never gate a match.
|
|
24225
23408
|
//
|
|
24226
23409
|
// Enrichment is deliberately per-field and best-effort, NOT a whole-rule
|
|
24227
23410
|
// `Rule.safeParse`. Two reasons: `Rule` is a strict object pinned to
|
|
@@ -24231,18 +23414,19 @@ function rowToDetectionDetail(row, findingsLast30d, update) {
|
|
|
24231
23414
|
// test should stay exactly what it was, namely a renderable matcher. A
|
|
24232
23415
|
// field that fails validation is omitted, which reads as "not set" and is
|
|
24233
23416
|
// the same thing the consumer saw before this change.
|
|
24234
|
-
...optional2("appliesTo",
|
|
23417
|
+
...optional2("appliesTo", r.appliesTo, (v) => AppliesTo.safeParse(v)),
|
|
24235
23418
|
...optional2(
|
|
24236
23419
|
"postValidators",
|
|
24237
|
-
|
|
24238
|
-
|
|
23420
|
+
r.postValidators,
|
|
23421
|
+
(v) => PostValidatorRef.array().safeParse(v)
|
|
24239
23422
|
),
|
|
24240
|
-
...optional2("requiresNearby",
|
|
23423
|
+
...optional2("requiresNearby", r.requiresNearby, (v) => RequiresNearby.safeParse(v)),
|
|
24241
23424
|
...optional2(
|
|
24242
23425
|
"examples",
|
|
24243
|
-
|
|
24244
|
-
|
|
24245
|
-
)
|
|
23426
|
+
r.examples,
|
|
23427
|
+
(v) => isStringArray(v) ? { success: true, data: v } : { success: false }
|
|
23428
|
+
),
|
|
23429
|
+
...optional2("evidence", r.evidence, (v) => RuleEvidence.safeParse(v))
|
|
24246
23430
|
}
|
|
24247
23431
|
];
|
|
24248
23432
|
});
|
|
@@ -24935,11 +24119,14 @@ var PolicyBundle = external_exports.object({
|
|
|
24935
24119
|
ruleVersions: external_exports.record(external_exports.string(), external_exports.string()).optional(),
|
|
24936
24120
|
// Model ids (the raw `model` string a harness reports, e.g.
|
|
24937
24121
|
// `claude-opus-4-1`) the tenant has PROHIBITED. The plugin refuses to switch
|
|
24938
|
-
// a session onto one (PreModelSwitch)
|
|
24939
|
-
//
|
|
24940
|
-
//
|
|
24941
|
-
//
|
|
24942
|
-
//
|
|
24122
|
+
// a session onto one (PreModelSwitch), refuses a turn that would run on one
|
|
24123
|
+
// (UserPromptSubmit) and refuses a subagent spawn onto one (PreToolUse),
|
|
24124
|
+
// wherever the organization governs the event: everywhere on a
|
|
24125
|
+
// machine-wide attachment, and only in enrolled repositories on a scoped
|
|
24126
|
+
// one (the plugin runtime's `governanceApplies`).
|
|
24127
|
+
// Optional so an older backend — and an older on-disk cache — still
|
|
24128
|
+
// parses; consumers read `?? []`, which is the unenforced behaviour that
|
|
24129
|
+
// predates this field and the safe direction to default.
|
|
24943
24130
|
//
|
|
24944
24131
|
// Ids, not display names: the governance decision is keyed on the exact
|
|
24945
24132
|
// string the harness reports (`model_status_override.versionId` in the
|
|
@@ -25398,6 +24585,8 @@ var AttachmentScopeEntry = external_exports.object({
|
|
|
25398
24585
|
});
|
|
25399
24586
|
var AttachmentScope = external_exports.object({
|
|
25400
24587
|
endpoint: external_exports.string().min(1),
|
|
24588
|
+
tenantName: PluginWhoami.shape.tenantName.optional(),
|
|
24589
|
+
userEmail: PluginWhoami.shape.userEmail.optional(),
|
|
25401
24590
|
entries: external_exports.array(AttachmentScopeEntry)
|
|
25402
24591
|
});
|
|
25403
24592
|
var AttachmentScopeEnvelope = AttachmentScope.extend({ entries: external_exports.array(external_exports.unknown()) });
|
|
@@ -25410,7 +24599,13 @@ function parseAttachmentScope(raw) {
|
|
|
25410
24599
|
const entry = AttachmentScopeEntry.safeParse(candidate);
|
|
25411
24600
|
if (entry.success) entries.push(entry.data);
|
|
25412
24601
|
}
|
|
25413
|
-
|
|
24602
|
+
const { endpoint, tenantName, userEmail } = envelope.data;
|
|
24603
|
+
return {
|
|
24604
|
+
endpoint,
|
|
24605
|
+
...tenantName === void 0 ? {} : { tenantName },
|
|
24606
|
+
...userEmail === void 0 ? {} : { userEmail },
|
|
24607
|
+
entries
|
|
24608
|
+
};
|
|
25414
24609
|
} catch {
|
|
25415
24610
|
return void 0;
|
|
25416
24611
|
}
|
|
@@ -25775,6 +24970,27 @@ var ManagedSettings = external_exports.object({
|
|
|
25775
24970
|
};
|
|
25776
24971
|
}).meta({ id: "ManagedSettings" });
|
|
25777
24972
|
|
|
24973
|
+
// ../../packages/schema/src/zod/mod-policy-snapshot.ts
|
|
24974
|
+
var MOD_POLICY_SNAPSHOT_VERSION = 1;
|
|
24975
|
+
var MOD_POLICY_SNAPSHOT_MAX_BYTES = 4 * 1024 * 1024;
|
|
24976
|
+
var ModPolicySnapshot = external_exports.object({
|
|
24977
|
+
version: external_exports.literal(MOD_POLICY_SNAPSHOT_VERSION),
|
|
24978
|
+
generatedAt: external_exports.iso.datetime(),
|
|
24979
|
+
// The complete effective ruleset, as the hook's runtime scans with it: the
|
|
24980
|
+
// user's enabled installed packs (user-modified and custom packs included).
|
|
24981
|
+
// Absent means the store holds no authoritative snapshot, and the reader
|
|
24982
|
+
// scans with the packs it ships — the hook's own fallback.
|
|
24983
|
+
rules: external_exports.array(Rule).optional(),
|
|
24984
|
+
// Rule-targeted actions (first enabled policy per rule wins).
|
|
24985
|
+
ruleActions: external_exports.record(external_exports.string(), ActionTaken),
|
|
24986
|
+
// The resolved action per detection category.
|
|
24987
|
+
categoryActions: external_exports.record(external_exports.string(), ActionTaken),
|
|
24988
|
+
// Rules with an active exception grant. Honouring a grant means matching a
|
|
24989
|
+
// keyed fingerprint of the value and consuming a use, which only the hook can
|
|
24990
|
+
// do, so the mod leaves a finding of one of these rules for the hook to decide.
|
|
24991
|
+
exceptionRuleIds: external_exports.array(external_exports.string())
|
|
24992
|
+
}).meta({ id: "ModPolicySnapshot" });
|
|
24993
|
+
|
|
25778
24994
|
// ../../packages/schema/src/zod/project-files.ts
|
|
25779
24995
|
var ProjectFileInput = external_exports.object({
|
|
25780
24996
|
path: external_exports.string().min(1),
|
|
@@ -26095,7 +25311,16 @@ var AttachInput = external_exports.object({
|
|
|
26095
25311
|
// 200 matches the tenantName bound beside it in control-plane.ts; nothing
|
|
26096
25312
|
// renders a longer one usefully.
|
|
26097
25313
|
label: printable(200).optional(),
|
|
26098
|
-
accessKey: external_exports.string()
|
|
25314
|
+
accessKey: external_exports.string(),
|
|
25315
|
+
// How much of this machine the attachment is for: everything, or only the
|
|
25316
|
+
// repositories its user enrolls. Optional, so an input without it still
|
|
25317
|
+
// parses; what an absent mode means is for whatever reads it to decide, not
|
|
25318
|
+
// this shape. This member validates the VALUE rather than leaving that to the
|
|
25319
|
+
// call site, a deliberate exception to this module's shape-only rule: a shape
|
|
25320
|
+
// rejection names the field, so a value that is not a mode is refused as a bad
|
|
25321
|
+
// `mode` rather than stripped or passed on. The dashboard's attach action reads
|
|
25322
|
+
// it as the mode to attach in.
|
|
25323
|
+
mode: AttachmentMode.optional()
|
|
26099
25324
|
});
|
|
26100
25325
|
|
|
26101
25326
|
// ../../packages/schema/src/zod/triage.ts
|
|
@@ -26381,6 +25606,18 @@ function fromCaptureStatusAttributes(bag) {
|
|
|
26381
25606
|
return parsedStatus.success ? parsedStatus.data : null;
|
|
26382
25607
|
}
|
|
26383
25608
|
|
|
25609
|
+
// ../../packages/persistence/src/attached-derived.ts
|
|
25610
|
+
import { rmSync } from "fs";
|
|
25611
|
+
import { join } from "path";
|
|
25612
|
+
var POLICY_CACHE_FILENAME = "policy-cache.json";
|
|
25613
|
+
var ATTACHED_FORWARD_STATE_FILENAME = "attached-state.json";
|
|
25614
|
+
var ATTACHED_FORWARD_DROPS_FILENAME = "attached-forward-drops.json";
|
|
25615
|
+
var ATTACHED_POSTURE_REPORT_FILENAME = "attached-posture-report.json";
|
|
25616
|
+
|
|
25617
|
+
// ../../packages/persistence/src/control-plane-credential.ts
|
|
25618
|
+
import { chmodSync as chmodSync2, lstatSync as lstatSync2, readFileSync, rmSync as rmSync3, statSync } from "fs";
|
|
25619
|
+
import { join as join2 } from "path";
|
|
25620
|
+
|
|
26384
25621
|
// ../../packages/persistence/src/paths.ts
|
|
26385
25622
|
import {
|
|
26386
25623
|
chmodSync,
|
|
@@ -26527,6 +25764,14 @@ function repairOrRefuseMode(file2) {
|
|
|
26527
25764
|
}
|
|
26528
25765
|
return "ok";
|
|
26529
25766
|
}
|
|
25767
|
+
function asReadableCredential(value) {
|
|
25768
|
+
const result = AttachedCredentialAny.safeParse(value);
|
|
25769
|
+
if (!result.success) return null;
|
|
25770
|
+
if (attachmentModeOf(result.data) === "machine" && typeof value === "object" && value !== null && Object.hasOwn(value, "mode")) {
|
|
25771
|
+
return null;
|
|
25772
|
+
}
|
|
25773
|
+
return result.data;
|
|
25774
|
+
}
|
|
26530
25775
|
function readControlPlaneCredentialFile(settingsDir2, connection) {
|
|
26531
25776
|
const file2 = controlPlaneCredentialPath(settingsDir2);
|
|
26532
25777
|
let raw;
|
|
@@ -26545,20 +25790,20 @@ function readControlPlaneCredentialFile(settingsDir2, connection) {
|
|
|
26545
25790
|
} catch {
|
|
26546
25791
|
return { usable: false, reason: "malformed" };
|
|
26547
25792
|
}
|
|
26548
|
-
const
|
|
26549
|
-
if (
|
|
26550
|
-
if (!isSafeEndpoint(
|
|
25793
|
+
const credential = asReadableCredential(parsed2);
|
|
25794
|
+
if (credential === null) return { usable: false, reason: "malformed" };
|
|
25795
|
+
if (!isSafeEndpoint(credential.endpoint)) {
|
|
26551
25796
|
return { usable: false, reason: "unsafe-endpoint" };
|
|
26552
25797
|
}
|
|
26553
|
-
if (connection !== void 0 && connection.endpoint !==
|
|
25798
|
+
if (connection !== void 0 && connection.endpoint !== credential.endpoint) {
|
|
26554
25799
|
return {
|
|
26555
25800
|
usable: false,
|
|
26556
25801
|
reason: "endpoint-mismatch",
|
|
26557
|
-
credentialEndpoint:
|
|
25802
|
+
credentialEndpoint: credential.endpoint,
|
|
26558
25803
|
settingsEndpoint: connection.endpoint
|
|
26559
25804
|
};
|
|
26560
25805
|
}
|
|
26561
|
-
return { usable: true, credential
|
|
25806
|
+
return { usable: true, credential };
|
|
26562
25807
|
}
|
|
26563
25808
|
function readControlPlaneCredential(settingsDir2, connection) {
|
|
26564
25809
|
const read = readControlPlaneCredentialFile(settingsDir2, connection);
|
|
@@ -26567,7 +25812,7 @@ function readControlPlaneCredential(settingsDir2, connection) {
|
|
|
26567
25812
|
|
|
26568
25813
|
// ../../packages/persistence/src/database.ts
|
|
26569
25814
|
import { randomUUID as randomUUID11 } from "crypto";
|
|
26570
|
-
import { dirname as dirname2, join as
|
|
25815
|
+
import { dirname as dirname2, join as join8, sep } from "path";
|
|
26571
25816
|
import { DatabaseSync } from "node:sqlite";
|
|
26572
25817
|
|
|
26573
25818
|
// ../../packages/persistence/src/ids.ts
|
|
@@ -26621,6 +25866,7 @@ function uuidFromDigest(digest) {
|
|
|
26621
25866
|
function captureWireId(sessionId, contentHash, filePath = null) {
|
|
26622
25867
|
return uuidFromDigest(captureId(sessionId, contentHash, filePath));
|
|
26623
25868
|
}
|
|
25869
|
+
var DOT = ".".charCodeAt(0);
|
|
26624
25870
|
|
|
26625
25871
|
// ../../packages/persistence/src/internal/snapshot.ts
|
|
26626
25872
|
import { randomUUID } from "crypto";
|
|
@@ -26948,6 +26194,25 @@ function scopeKeysParam(scopeKeys) {
|
|
|
26948
26194
|
var ROOT_SCOPE_KEY = `(SELECT session_root.scope_key
|
|
26949
26195
|
FROM audit_events AS session_root
|
|
26950
26196
|
WHERE session_root.id = COALESCE(audit_events.root_session_id, audit_events.id))`;
|
|
26197
|
+
var COUNTED_IN_SCOPE = `
|
|
26198
|
+
AND ${inScope("scope_key")}
|
|
26199
|
+
AND (event_type IN (${CAPTURE_TYPE_LIST}) OR ${inScope(ROOT_SCOPE_KEY)})`;
|
|
26200
|
+
var DRAIN_TOTALS = `SELECT
|
|
26201
|
+
SUM(CASE WHEN synced_at IS NULL AND started_at < :before THEN 1 ELSE 0 END) AS pending,
|
|
26202
|
+
SUM(CASE WHEN synced_at > 0 THEN 1 ELSE 0 END) AS sent,
|
|
26203
|
+
SUM(CASE WHEN synced_at = ${String(SKIPPED)}
|
|
26204
|
+
AND (sync_failure IS NULL OR sync_failure = 'payload_invalid')
|
|
26205
|
+
THEN 1 ELSE 0 END) AS skipped,
|
|
26206
|
+
SUM(CASE WHEN synced_at = ${String(SKIPPED)}
|
|
26207
|
+
AND sync_failure = 'deployment_refused' THEN 1 ELSE 0 END) AS refused,
|
|
26208
|
+
SUM(CASE WHEN synced_at = ${String(SKIPPED)}
|
|
26209
|
+
AND sync_failure = 'detached_undelivered' THEN 1 ELSE 0 END) AS detached
|
|
26210
|
+
FROM audit_events
|
|
26211
|
+
WHERE event_type IN (${TYPE_LIST})`;
|
|
26212
|
+
var CAPTURE_SKIPS = `SELECT COUNT(*) AS skipped
|
|
26213
|
+
FROM audit_events
|
|
26214
|
+
WHERE synced_at = ${String(SKIPPED)}
|
|
26215
|
+
AND event_type IN (${CAPTURE_TYPE_LIST})`;
|
|
26951
26216
|
var ROW_COLUMNS = `id,
|
|
26952
26217
|
parent_id AS parentId,
|
|
26953
26218
|
root_session_id AS rootSessionId,
|
|
@@ -27023,7 +26288,7 @@ var SqliteHistorySyncRepository = class {
|
|
|
27023
26288
|
);
|
|
27024
26289
|
this.scopedCaptureRowsStmt = db.prepare(
|
|
27025
26290
|
`SELECT ${ROW_COLUMNS}
|
|
27026
|
-
FROM audit_events
|
|
26291
|
+
FROM audit_events INDEXED BY idx_audit_scope_owed
|
|
27027
26292
|
WHERE synced_at IS NULL
|
|
27028
26293
|
AND sync_claimed_at IS NULL
|
|
27029
26294
|
AND outbox_owed = 1
|
|
@@ -27076,40 +26341,28 @@ var SqliteHistorySyncRepository = class {
|
|
|
27076
26341
|
);
|
|
27077
26342
|
this.partitionStmt = db.prepare(`SELECT${PARTITION_BUCKETS}
|
|
27078
26343
|
FROM audit_events${COUNTED_SCOPE}`);
|
|
26344
|
+
this.scopedPartitionStmt = db.prepare(`SELECT${PARTITION_BUCKETS}
|
|
26345
|
+
FROM audit_events${COUNTED_SCOPE}${COUNTED_IN_SCOPE}`);
|
|
27079
26346
|
this.partitionByKindStmt = db.prepare(
|
|
27080
26347
|
`SELECT event_type AS kind,${PARTITION_BUCKETS}
|
|
27081
26348
|
FROM audit_events INDEXED BY idx_audit_events_sync${COUNTED_SCOPE}
|
|
27082
26349
|
GROUP BY event_type`
|
|
27083
26350
|
);
|
|
27084
|
-
this.
|
|
27085
|
-
`SELECT
|
|
27086
|
-
|
|
27087
|
-
|
|
27088
|
-
SUM(CASE WHEN synced_at = ${String(SKIPPED)}
|
|
27089
|
-
AND (sync_failure IS NULL OR sync_failure = 'payload_invalid')
|
|
27090
|
-
THEN 1 ELSE 0 END) AS skipped,
|
|
27091
|
-
SUM(CASE WHEN synced_at = ${String(SKIPPED)}
|
|
27092
|
-
AND sync_failure = 'deployment_refused' THEN 1 ELSE 0 END) AS refused,
|
|
27093
|
-
SUM(CASE WHEN synced_at = ${String(SKIPPED)}
|
|
27094
|
-
AND sync_failure = 'detached_undelivered' THEN 1 ELSE 0 END) AS detached
|
|
27095
|
-
FROM audit_events
|
|
27096
|
-
WHERE event_type IN (${TYPE_LIST})`
|
|
26351
|
+
this.scopedPartitionByKindStmt = db.prepare(
|
|
26352
|
+
`SELECT event_type AS kind,${PARTITION_BUCKETS}
|
|
26353
|
+
FROM audit_events INDEXED BY idx_audit_events_sync${COUNTED_SCOPE}${COUNTED_IN_SCOPE}
|
|
26354
|
+
GROUP BY event_type`
|
|
27097
26355
|
);
|
|
27098
|
-
this.
|
|
27099
|
-
|
|
27100
|
-
|
|
27101
|
-
|
|
27102
|
-
|
|
27103
|
-
|
|
27104
|
-
|
|
27105
|
-
|
|
27106
|
-
|
|
27107
|
-
|
|
27108
|
-
// frees.
|
|
27109
|
-
`SELECT COUNT(*) AS skipped
|
|
27110
|
-
FROM audit_events
|
|
27111
|
-
WHERE synced_at = ${String(SKIPPED)}
|
|
27112
|
-
AND event_type IN (${CAPTURE_TYPE_LIST})`
|
|
26356
|
+
this.countsStmt = db.prepare(DRAIN_TOTALS);
|
|
26357
|
+
this.scopedCountsStmt = db.prepare(
|
|
26358
|
+
`${DRAIN_TOTALS}
|
|
26359
|
+
AND ${inScope("scope_key")}
|
|
26360
|
+
AND ${inScope(ROOT_SCOPE_KEY)}`
|
|
26361
|
+
);
|
|
26362
|
+
this.captureSkipCountStmt = db.prepare(CAPTURE_SKIPS);
|
|
26363
|
+
this.scopedCaptureSkipCountStmt = db.prepare(
|
|
26364
|
+
`${CAPTURE_SKIPS}
|
|
26365
|
+
AND ${inScope("scope_key")}`
|
|
27113
26366
|
);
|
|
27114
26367
|
this.fingerprintStmt = db.prepare(
|
|
27115
26368
|
`SELECT endpoint_fingerprint AS fingerprint, backlog_before AS backlogBefore
|
|
@@ -27223,6 +26476,10 @@ var SqliteHistorySyncRepository = class {
|
|
|
27223
26476
|
scopedCaptureRowsStmt;
|
|
27224
26477
|
scopedCaptureBacklogOwedStmt;
|
|
27225
26478
|
markScopeCapturesOwedStmt;
|
|
26479
|
+
scopedPartitionStmt;
|
|
26480
|
+
scopedPartitionByKindStmt;
|
|
26481
|
+
scopedCountsStmt;
|
|
26482
|
+
scopedCaptureSkipCountStmt;
|
|
27226
26483
|
/**
|
|
27227
26484
|
* The masked detections recorded against one tool call.
|
|
27228
26485
|
*
|
|
@@ -27444,7 +26701,29 @@ var SqliteHistorySyncRepository = class {
|
|
|
27444
26701
|
* in" — and a machine that has never attached has no boundary to pass, so
|
|
27445
26702
|
* requiring one would force a caller to invent one and report the whole store
|
|
27446
26703
|
* as queued.
|
|
26704
|
+
*
|
|
26705
|
+
* `scopeKeys` is a scoped attachment's filter: every bucket then counts only
|
|
26706
|
+
* the rows that pass the drain's reachability rule for that scope
|
|
26707
|
+
* (COUNTED_IN_SCOPE, which also names the one kind of row it counts that the
|
|
26708
|
+
* drain never offers), so a personal repository's rows are in none of them.
|
|
26709
|
+
* Omitted, this runs the machine statement, unchanged; an empty list counts
|
|
26710
|
+
* nothing.
|
|
27447
26711
|
*/
|
|
26712
|
+
partition(scopeKeys) {
|
|
26713
|
+
const row = getRow(
|
|
26714
|
+
scopeKeys === void 0 ? this.partitionStmt : this.scopedPartitionStmt,
|
|
26715
|
+
scopeKeys === void 0 ? {} : { scopeKeys: scopeKeysParam(scopeKeys) }
|
|
26716
|
+
);
|
|
26717
|
+
return {
|
|
26718
|
+
queued: row?.queued ?? 0,
|
|
26719
|
+
inProgress: row?.inProgress ?? 0,
|
|
26720
|
+
synced: row?.synced ?? 0,
|
|
26721
|
+
failed: row?.failed ?? 0,
|
|
26722
|
+
refused: row?.refused ?? 0,
|
|
26723
|
+
detached: row?.detached ?? 0,
|
|
26724
|
+
total: row?.total ?? 0
|
|
26725
|
+
};
|
|
26726
|
+
}
|
|
27448
26727
|
/**
|
|
27449
26728
|
* The same partition, one row per kind that a lane carries.
|
|
27450
26729
|
*
|
|
@@ -27454,11 +26733,14 @@ var SqliteHistorySyncRepository = class {
|
|
|
27454
26733
|
* rendering a fixed list of kinds must therefore treat a missing one as "no
|
|
27455
26734
|
* rows", never as "zero sent"; the two look identical in a bar and mean
|
|
27456
26735
|
* different things.
|
|
26736
|
+
*
|
|
26737
|
+
* `scopeKeys` scopes it with the clause `partition` uses, so the per-kind rows
|
|
26738
|
+
* still sum to the scoped aggregate. An empty list returns no rows.
|
|
27457
26739
|
*/
|
|
27458
|
-
partitionByKind() {
|
|
26740
|
+
partitionByKind(scopeKeys) {
|
|
27459
26741
|
return allRows(
|
|
27460
|
-
this.partitionByKindStmt,
|
|
27461
|
-
{}
|
|
26742
|
+
scopeKeys === void 0 ? this.partitionByKindStmt : this.scopedPartitionByKindStmt,
|
|
26743
|
+
scopeKeys === void 0 ? {} : { scopeKeys: scopeKeysParam(scopeKeys) }
|
|
27462
26744
|
).map((row) => ({
|
|
27463
26745
|
kind: row.kind,
|
|
27464
26746
|
queued: row.queued ?? 0,
|
|
@@ -27470,22 +26752,25 @@ var SqliteHistorySyncRepository = class {
|
|
|
27470
26752
|
total: row.total ?? 0
|
|
27471
26753
|
}));
|
|
27472
26754
|
}
|
|
27473
|
-
|
|
27474
|
-
|
|
27475
|
-
|
|
27476
|
-
|
|
27477
|
-
|
|
27478
|
-
|
|
27479
|
-
|
|
27480
|
-
|
|
27481
|
-
|
|
27482
|
-
|
|
27483
|
-
|
|
27484
|
-
|
|
27485
|
-
|
|
27486
|
-
|
|
27487
|
-
|
|
27488
|
-
|
|
26755
|
+
/**
|
|
26756
|
+
* The drain's totals. `pending` counts only what is inside the backlog; sent
|
|
26757
|
+
* and skipped are totals.
|
|
26758
|
+
*
|
|
26759
|
+
* `scopeKeys` is a scoped attachment's filter, and it scopes every figure,
|
|
26760
|
+
* `capturesSkipped` included: a structural row is counted only when its own
|
|
26761
|
+
* key and its session root's key are among them, a capture when its own key
|
|
26762
|
+
* is. So `pending` is exactly what pendingSessions and pendingRows page out
|
|
26763
|
+
* under the same keys and boundary. Omitted, this runs the machine
|
|
26764
|
+
* statements, unchanged; an empty list counts nothing.
|
|
26765
|
+
*/
|
|
26766
|
+
counts(before, scopeKeys) {
|
|
26767
|
+
const row = getRow(
|
|
26768
|
+
scopeKeys === void 0 ? this.countsStmt : this.scopedCountsStmt,
|
|
26769
|
+
scopeKeys === void 0 ? { before } : { before, scopeKeys: scopeKeysParam(scopeKeys) }
|
|
26770
|
+
);
|
|
26771
|
+
const captures = scopeKeys === void 0 ? getRow(this.captureSkipCountStmt) : getRow(this.scopedCaptureSkipCountStmt, {
|
|
26772
|
+
scopeKeys: scopeKeysParam(scopeKeys)
|
|
26773
|
+
});
|
|
27489
26774
|
return {
|
|
27490
26775
|
pending: row?.pending ?? 0,
|
|
27491
26776
|
sent: row?.sent ?? 0,
|
|
@@ -27737,6 +27022,7 @@ function applyMigrations(db, file2, options = {}) {
|
|
|
27737
27022
|
}
|
|
27738
27023
|
ensureSyncedAtColumn(db, "audit_events");
|
|
27739
27024
|
ensureScopeKeyColumn(db);
|
|
27025
|
+
ensureScopeOwedIndex(db);
|
|
27740
27026
|
ensureScanLedgerTable(db);
|
|
27741
27027
|
ensureHistorySyncTable(db);
|
|
27742
27028
|
ensureBlockedDetectionsTable(db);
|
|
@@ -28177,14 +27463,48 @@ function ensureScopeKeyColumn(db) {
|
|
|
28177
27463
|
function hasScopeKeyColumn(db) {
|
|
28178
27464
|
return columnNames(db, "audit_events", { includeGenerated: true }).includes("scope_key");
|
|
28179
27465
|
}
|
|
27466
|
+
var SCOPE_OWED_INDEX_DDL = "CREATE INDEX IF NOT EXISTS idx_audit_scope_owed ON audit_events (scope_key, event_type, started_at) WHERE outbox_owed = 1 AND synced_at IS NULL";
|
|
27467
|
+
function ensureScopeOwedIndex(db) {
|
|
27468
|
+
if (!schemaObjectExists(db, "table", "audit_events")) return;
|
|
27469
|
+
const columns = columnNames(db, "audit_events", { includeGenerated: true });
|
|
27470
|
+
const complete = ["scope_key", "outbox_owed", "synced_at"].every((c) => columns.includes(c));
|
|
27471
|
+
if (!complete) return;
|
|
27472
|
+
db.exec(SCOPE_OWED_INDEX_DDL);
|
|
27473
|
+
}
|
|
28180
27474
|
function ensureScanLedgerTable(db) {
|
|
28181
27475
|
db.exec(`CREATE TABLE IF NOT EXISTS scan_ledger (
|
|
28182
27476
|
path TEXT PRIMARY KEY,
|
|
28183
27477
|
mtime TEXT NOT NULL,
|
|
28184
27478
|
content_hash TEXT NOT NULL,
|
|
28185
27479
|
ruleset_hash TEXT NOT NULL,
|
|
28186
|
-
scanned_at INTEGER NOT NULL
|
|
27480
|
+
scanned_at INTEGER NOT NULL,
|
|
27481
|
+
scope_key TEXT,
|
|
27482
|
+
scope_root TEXT
|
|
28187
27483
|
)`);
|
|
27484
|
+
ensureScanLedgerScopeKeyColumn(db);
|
|
27485
|
+
ensureScanLedgerScopeRootColumn(db);
|
|
27486
|
+
}
|
|
27487
|
+
var SCAN_LEDGER_SCOPE_KEY_DDL = "ALTER TABLE scan_ledger ADD COLUMN scope_key TEXT";
|
|
27488
|
+
var SCAN_LEDGER_SCOPE_ROOT_DDL = "ALTER TABLE scan_ledger ADD COLUMN scope_root TEXT";
|
|
27489
|
+
function ensureScanLedgerScopeKeyColumn(db) {
|
|
27490
|
+
ensureScanLedgerColumn(db, "scope_key", SCAN_LEDGER_SCOPE_KEY_DDL);
|
|
27491
|
+
}
|
|
27492
|
+
function ensureScanLedgerScopeRootColumn(db) {
|
|
27493
|
+
ensureScanLedgerColumn(db, "scope_root", SCAN_LEDGER_SCOPE_ROOT_DDL);
|
|
27494
|
+
}
|
|
27495
|
+
function ensureScanLedgerColumn(db, column, ddl) {
|
|
27496
|
+
if (!schemaObjectExists(db, "table", "scan_ledger")) return;
|
|
27497
|
+
if (hasScanLedgerColumn(db, column)) return;
|
|
27498
|
+
withTransaction(
|
|
27499
|
+
db,
|
|
27500
|
+
() => {
|
|
27501
|
+
if (!hasScanLedgerColumn(db, column)) db.exec(ddl);
|
|
27502
|
+
},
|
|
27503
|
+
"IMMEDIATE"
|
|
27504
|
+
);
|
|
27505
|
+
}
|
|
27506
|
+
function hasScanLedgerColumn(db, column) {
|
|
27507
|
+
return columnNames(db, "scan_ledger").includes(column);
|
|
28188
27508
|
}
|
|
28189
27509
|
function ensureHistorySyncTable(db) {
|
|
28190
27510
|
db.exec(`CREATE TABLE IF NOT EXISTS history_sync (
|
|
@@ -28235,6 +27555,106 @@ function ensureRuleProbeCacheTable(db) {
|
|
|
28235
27555
|
)`);
|
|
28236
27556
|
}
|
|
28237
27557
|
|
|
27558
|
+
// ../../packages/persistence/src/mod-policy-snapshot.ts
|
|
27559
|
+
import { createHash as createHash2 } from "crypto";
|
|
27560
|
+
import { readFileSync as readFileSync2 } from "fs";
|
|
27561
|
+
import { join as join4 } from "path";
|
|
27562
|
+
var MOD_POLICY_SNAPSHOT_FILENAME = "mod-policy.json";
|
|
27563
|
+
function modPolicySnapshotPath(dataDir2) {
|
|
27564
|
+
return join4(dataDir2, MOD_POLICY_SNAPSHOT_FILENAME);
|
|
27565
|
+
}
|
|
27566
|
+
function buildModPolicySnapshot(input2, generatedAt = /* @__PURE__ */ new Date()) {
|
|
27567
|
+
const byRule = /* @__PURE__ */ new Map();
|
|
27568
|
+
const byCategory = /* @__PURE__ */ new Map();
|
|
27569
|
+
for (const policy of input2.policies) {
|
|
27570
|
+
if (!policy.enabled) continue;
|
|
27571
|
+
if ("ruleId" in policy.target) {
|
|
27572
|
+
if (!byRule.has(policy.target.ruleId)) byRule.set(policy.target.ruleId, policy.action);
|
|
27573
|
+
} else if (!byCategory.has(policy.target.category)) {
|
|
27574
|
+
byCategory.set(policy.target.category, policy.action);
|
|
27575
|
+
}
|
|
27576
|
+
}
|
|
27577
|
+
const categoryActions = {};
|
|
27578
|
+
for (const category of DetectionCategory.options) {
|
|
27579
|
+
categoryActions[category] = byCategory.get(category) ?? DEFAULT_ACTIONS[category];
|
|
27580
|
+
}
|
|
27581
|
+
return {
|
|
27582
|
+
version: MOD_POLICY_SNAPSHOT_VERSION,
|
|
27583
|
+
generatedAt: generatedAt.toISOString(),
|
|
27584
|
+
// `examples` is documentation the mod never reads, and a custom pack's are
|
|
27585
|
+
// whatever its author pasted in, so they stay behind.
|
|
27586
|
+
...input2.rules !== void 0 ? { rules: input2.rules.map(withoutExamples) } : {},
|
|
27587
|
+
ruleActions: Object.fromEntries(byRule),
|
|
27588
|
+
categoryActions,
|
|
27589
|
+
exceptionRuleIds: [...new Set(input2.exceptionRuleIds)].sort()
|
|
27590
|
+
};
|
|
27591
|
+
}
|
|
27592
|
+
function assignedRuleActionPolicies(installed) {
|
|
27593
|
+
const out = [];
|
|
27594
|
+
for (const [ruleId, action] of installed.ruleActions) {
|
|
27595
|
+
if (installed.assignedRules.has(ruleId))
|
|
27596
|
+
out.push({ target: { ruleId }, action, enabled: true });
|
|
27597
|
+
}
|
|
27598
|
+
return out;
|
|
27599
|
+
}
|
|
27600
|
+
function withoutExamples(rule) {
|
|
27601
|
+
const copy = { ...rule };
|
|
27602
|
+
delete copy.examples;
|
|
27603
|
+
return copy;
|
|
27604
|
+
}
|
|
27605
|
+
function sameContent(a, b) {
|
|
27606
|
+
return JSON.stringify({ ...a, generatedAt: "" }) === JSON.stringify({ ...b, generatedAt: "" });
|
|
27607
|
+
}
|
|
27608
|
+
function readModPolicySnapshot(dataDir2) {
|
|
27609
|
+
try {
|
|
27610
|
+
const text = readFileSync2(modPolicySnapshotPath(dataDir2), "utf8");
|
|
27611
|
+
if (text.length > MOD_POLICY_SNAPSHOT_MAX_BYTES) return null;
|
|
27612
|
+
const parsed2 = ModPolicySnapshot.safeParse(JSON.parse(text));
|
|
27613
|
+
return parsed2.success ? parsed2.data : null;
|
|
27614
|
+
} catch {
|
|
27615
|
+
return null;
|
|
27616
|
+
}
|
|
27617
|
+
}
|
|
27618
|
+
function writeModPolicySnapshot(dataDir2, snapshot) {
|
|
27619
|
+
const text = JSON.stringify(snapshot);
|
|
27620
|
+
if (Buffer.byteLength(text) > MOD_POLICY_SNAPSHOT_MAX_BYTES) return false;
|
|
27621
|
+
const existing = readModPolicySnapshot(dataDir2);
|
|
27622
|
+
if (existing !== null && sameContent(existing, snapshot)) return false;
|
|
27623
|
+
ensureDataDirSync(dataDir2);
|
|
27624
|
+
writeOwnerOnlyFileSync(modPolicySnapshotPath(dataDir2), text);
|
|
27625
|
+
return true;
|
|
27626
|
+
}
|
|
27627
|
+
function regexProbeKey(matcher) {
|
|
27628
|
+
return createHash2("sha256").update(`${matcher.pattern} ${matcher.flags}`).digest("hex");
|
|
27629
|
+
}
|
|
27630
|
+
function vetRulesForMod(rules, sources, previouslyVetted = /* @__PURE__ */ new Set()) {
|
|
27631
|
+
const bundled = new Set(sources.bundledRegexMatchers().map(regexProbeKey));
|
|
27632
|
+
return rules.filter((rule) => {
|
|
27633
|
+
if (rule.matcher.type !== "regex") return true;
|
|
27634
|
+
const key = regexProbeKey(rule.matcher);
|
|
27635
|
+
const verdict = sources.probeVerdict(key);
|
|
27636
|
+
if (verdict === "quarantined") return false;
|
|
27637
|
+
return verdict === "safe" || bundled.has(key) || previouslyVetted.has(key);
|
|
27638
|
+
});
|
|
27639
|
+
}
|
|
27640
|
+
function modPolicyInputFromStore(sources, previouslyVetted = /* @__PURE__ */ new Set()) {
|
|
27641
|
+
const policies = sources.readPolicies();
|
|
27642
|
+
const snapshot = sources.installedRuleset();
|
|
27643
|
+
const usable = snapshot.installedPacks > 0 && (snapshot.enabledPacks === 0 || snapshot.invalidRules === 0 && snapshot.rules.length > 0);
|
|
27644
|
+
const empty = snapshot.installedPacks > 0 && snapshot.enabledPacks === 0;
|
|
27645
|
+
return {
|
|
27646
|
+
...usable ? { rules: empty ? [] : vetRulesForMod(snapshot.rules, sources, previouslyVetted) } : {},
|
|
27647
|
+
policies: [...policies, ...usable && !empty ? assignedRuleActionPolicies(snapshot) : []],
|
|
27648
|
+
exceptionRuleIds: sources.activeExceptionRuleIds()
|
|
27649
|
+
};
|
|
27650
|
+
}
|
|
27651
|
+
function refreshModPolicySnapshot(dataDir2, sources) {
|
|
27652
|
+
try {
|
|
27653
|
+
writeModPolicySnapshot(dataDir2, buildModPolicySnapshot(modPolicyInputFromStore(sources)));
|
|
27654
|
+
} catch {
|
|
27655
|
+
}
|
|
27656
|
+
}
|
|
27657
|
+
|
|
28238
27658
|
// ../../packages/persistence/src/internal/json.ts
|
|
28239
27659
|
function safeJson(s, fallback) {
|
|
28240
27660
|
if (s == null) return fallback;
|
|
@@ -28409,6 +27829,11 @@ var TIMELINE_COLUMNS = `
|
|
|
28409
27829
|
json_extract(attributes, '$.targetId') AS target_id,
|
|
28410
27830
|
json_extract(attributes, '$.internal') AS internal,
|
|
28411
27831
|
json_extract(attributes, '$.flagged') AS flagged`;
|
|
27832
|
+
var CALL_PROMPT_TOKENS = `(coalesce(input_tokens, 0) + coalesce(cache_read_input_tokens, 0)
|
|
27833
|
+
+ coalesce(ephemeral_1h_input_tokens, 0) + coalesce(ephemeral_5m_input_tokens, 0))`;
|
|
27834
|
+
var CALL_BAND = LONG_CONTEXT_THRESHOLDS.length === 0 ? "0" : LONG_CONTEXT_THRESHOLDS.map((t) => `(${CALL_PROMPT_TOKENS} > ${String(Math.trunc(t))})`).join(
|
|
27835
|
+
" + "
|
|
27836
|
+
);
|
|
28412
27837
|
var LLM_USAGE_SELECT = `
|
|
28413
27838
|
SELECT root_session_id AS sessionId,
|
|
28414
27839
|
provider,
|
|
@@ -28420,9 +27845,10 @@ var LLM_USAGE_SELECT = `
|
|
|
28420
27845
|
coalesce(sum(cache_read_input_tokens), 0) AS cacheReadTokens,
|
|
28421
27846
|
coalesce(sum(ephemeral_1h_input_tokens), 0) AS ephemeral1hTokens,
|
|
28422
27847
|
coalesce(sum(ephemeral_5m_input_tokens), 0) AS ephemeral5mTokens,
|
|
28423
|
-
coalesce(sum(web_search_requests), 0) AS webSearchRequests
|
|
27848
|
+
coalesce(sum(web_search_requests), 0) AS webSearchRequests,
|
|
27849
|
+
coalesce(max(${CALL_PROMPT_TOKENS}), 0) AS promptTokens`;
|
|
28424
27850
|
var LLM_USAGE_SCOPE = `event_type = 'llm_call' AND attributes IS NOT NULL AND root_session_id IS NOT NULL`;
|
|
28425
|
-
var LLM_USAGE_GROUP = `GROUP BY root_session_id, provider, model, service_tier`;
|
|
27851
|
+
var LLM_USAGE_GROUP = `GROUP BY root_session_id, provider, model, service_tier, ${CALL_BAND}`;
|
|
28426
27852
|
function usageLeaves(rows) {
|
|
28427
27853
|
return rows.map((row) => {
|
|
28428
27854
|
const attributes = {
|
|
@@ -28437,7 +27863,7 @@ function usageLeaves(rows) {
|
|
|
28437
27863
|
if (row.provider !== null) attributes.provider = row.provider;
|
|
28438
27864
|
if (row.model !== null) attributes.model = row.model;
|
|
28439
27865
|
if (row.serviceTier !== null) attributes.service_tier = row.serviceTier;
|
|
28440
|
-
return { sessionId: row.sessionId, attributes };
|
|
27866
|
+
return { sessionId: row.sessionId, attributes, promptTokens: row.promptTokens };
|
|
28441
27867
|
});
|
|
28442
27868
|
}
|
|
28443
27869
|
var SESSION_ROOT = `event_type = 'session'`;
|
|
@@ -29771,9 +29197,10 @@ var ACTIVE_REVEAL_GRANT_PREDICATE = `capability = 'reveal_to_model'
|
|
|
29771
29197
|
AND conditions IS NULL
|
|
29772
29198
|
AND ${ACTIVE_PREDICATE}`;
|
|
29773
29199
|
var SqliteExceptionsRepository = class {
|
|
29774
|
-
constructor(db, now = () => Date.now()) {
|
|
29200
|
+
constructor(db, now = () => Date.now(), onChange = () => void 0) {
|
|
29775
29201
|
this.db = db;
|
|
29776
29202
|
this.now = now;
|
|
29203
|
+
this.onChange = onChange;
|
|
29777
29204
|
this.consumeStmt = db.prepare(
|
|
29778
29205
|
`UPDATE exceptions
|
|
29779
29206
|
SET use_count = use_count + 1, last_used_at = :now, updated_at = :now
|
|
@@ -29792,6 +29219,7 @@ var SqliteExceptionsRepository = class {
|
|
|
29792
29219
|
}
|
|
29793
29220
|
db;
|
|
29794
29221
|
now;
|
|
29222
|
+
onChange;
|
|
29795
29223
|
consumeStmt;
|
|
29796
29224
|
insertBlockedStmt;
|
|
29797
29225
|
sweepBlockedStmt;
|
|
@@ -29807,7 +29235,9 @@ var SqliteExceptionsRepository = class {
|
|
|
29807
29235
|
*/
|
|
29808
29236
|
create(input2) {
|
|
29809
29237
|
try {
|
|
29810
|
-
|
|
29238
|
+
const created = this.createSync(input2);
|
|
29239
|
+
this.onChange();
|
|
29240
|
+
return Promise.resolve(created);
|
|
29811
29241
|
} catch (err) {
|
|
29812
29242
|
return Promise.reject(err instanceof Error ? err : new Error(String(err)));
|
|
29813
29243
|
}
|
|
@@ -29938,6 +29368,7 @@ var SqliteExceptionsRepository = class {
|
|
|
29938
29368
|
SET revoked_at = :now, revoked_by = :revokedBy, revoke_reason = :reason, updated_at = :now
|
|
29939
29369
|
WHERE id = :id AND revoked_at IS NULL`
|
|
29940
29370
|
).run({ id, revokedBy, reason: reason ?? null, now });
|
|
29371
|
+
if (Number(result.changes) === 1) this.onChange();
|
|
29941
29372
|
return Promise.resolve(Number(result.changes) === 1);
|
|
29942
29373
|
}
|
|
29943
29374
|
/**
|
|
@@ -29950,6 +29381,15 @@ var SqliteExceptionsRepository = class {
|
|
|
29950
29381
|
const result = this.consumeStmt.run({ id, now });
|
|
29951
29382
|
return Promise.resolve(Number(result.changes) === 1);
|
|
29952
29383
|
}
|
|
29384
|
+
/** The rule ids with at least one active grant, under any key version. */
|
|
29385
|
+
activeRuleIds(now = this.now()) {
|
|
29386
|
+
return allRows(
|
|
29387
|
+
this.db.prepare(
|
|
29388
|
+
`SELECT DISTINCT rule_id AS ruleId FROM exceptions WHERE ${ACTIVE_PREDICATE}`
|
|
29389
|
+
),
|
|
29390
|
+
{ now }
|
|
29391
|
+
).map((row) => row.ruleId);
|
|
29392
|
+
}
|
|
29953
29393
|
/**
|
|
29954
29394
|
* The evaluation subset of every active grant under one fingerprint key
|
|
29955
29395
|
* version — what rides the policy bundle to the hook. Grants written under
|
|
@@ -31073,31 +30513,31 @@ var SqliteInspectionFindingsRepository = class {
|
|
|
31073
30513
|
};
|
|
31074
30514
|
|
|
31075
30515
|
// ../../packages/persistence/src/repositories/installed-packs.ts
|
|
31076
|
-
import { createHash as
|
|
30516
|
+
import { createHash as createHash3, randomUUID as randomUUID4 } from "crypto";
|
|
31077
30517
|
|
|
31078
30518
|
// ../../packages/persistence/src/policy-floor.ts
|
|
31079
|
-
import { readFileSync as
|
|
31080
|
-
import { join as
|
|
30519
|
+
import { readFileSync as readFileSync6 } from "fs";
|
|
30520
|
+
import { join as join7 } from "path";
|
|
31081
30521
|
|
|
31082
30522
|
// ../../packages/persistence/src/local-layout.ts
|
|
31083
30523
|
import { renameSync as renameSync3 } from "fs";
|
|
31084
30524
|
import { mkdir } from "fs/promises";
|
|
31085
30525
|
import { homedir } from "os";
|
|
31086
|
-
import { join as
|
|
30526
|
+
import { join as join5 } from "path";
|
|
31087
30527
|
function defaultDataDir() {
|
|
31088
|
-
return
|
|
30528
|
+
return join5(homedir(), ".aka");
|
|
31089
30529
|
}
|
|
31090
30530
|
function settingsDir(base = defaultDataDir()) {
|
|
31091
|
-
return
|
|
30531
|
+
return join5(base, "settings");
|
|
31092
30532
|
}
|
|
31093
30533
|
function dataDir(base = defaultDataDir()) {
|
|
31094
|
-
return
|
|
30534
|
+
return join5(base, "data");
|
|
31095
30535
|
}
|
|
31096
30536
|
function dbPath(base = defaultDataDir()) {
|
|
31097
|
-
return
|
|
30537
|
+
return join5(dataDir(base), "aka.db");
|
|
31098
30538
|
}
|
|
31099
30539
|
function keysDir(base = defaultDataDir()) {
|
|
31100
|
-
return
|
|
30540
|
+
return join5(base, "keys");
|
|
31101
30541
|
}
|
|
31102
30542
|
async function ensureDataDir(dir = defaultDataDir()) {
|
|
31103
30543
|
await mkdir(dir, { recursive: true, mode: DATA_DIR_MODE });
|
|
@@ -31114,8 +30554,8 @@ function migrateLegacyLayout(base = defaultDataDir()) {
|
|
|
31114
30554
|
for (const { name, dest } of moves) {
|
|
31115
30555
|
try {
|
|
31116
30556
|
ensureDataDirSync(dest);
|
|
31117
|
-
const moved =
|
|
31118
|
-
renameSync3(
|
|
30557
|
+
const moved = join5(dest, name);
|
|
30558
|
+
renameSync3(join5(base, name), moved);
|
|
31119
30559
|
tightenFile(moved);
|
|
31120
30560
|
} catch {
|
|
31121
30561
|
}
|
|
@@ -31123,8 +30563,8 @@ function migrateLegacyLayout(base = defaultDataDir()) {
|
|
|
31123
30563
|
}
|
|
31124
30564
|
|
|
31125
30565
|
// ../../packages/persistence/src/settings.ts
|
|
31126
|
-
import { readFileSync as
|
|
31127
|
-
import { join as
|
|
30566
|
+
import { readFileSync as readFileSync5 } from "fs";
|
|
30567
|
+
import { join as join6 } from "path";
|
|
31128
30568
|
|
|
31129
30569
|
// ../../packages/persistence/src/file-lock.ts
|
|
31130
30570
|
import { randomUUID as randomUUID3 } from "crypto";
|
|
@@ -31132,7 +30572,7 @@ import {
|
|
|
31132
30572
|
closeSync,
|
|
31133
30573
|
existsSync as existsSync2,
|
|
31134
30574
|
openSync,
|
|
31135
|
-
readFileSync as
|
|
30575
|
+
readFileSync as readFileSync3,
|
|
31136
30576
|
rmSync as rmSync5,
|
|
31137
30577
|
statSync as statSync3,
|
|
31138
30578
|
writeFileSync as writeFileSync2
|
|
@@ -31141,16 +30581,16 @@ import { hostname as hostname3 } from "os";
|
|
|
31141
30581
|
var PARK = new Int32Array(new SharedArrayBuffer(4));
|
|
31142
30582
|
|
|
31143
30583
|
// ../../packages/persistence/src/managed-settings.ts
|
|
31144
|
-
import { readFileSync as
|
|
30584
|
+
import { readFileSync as readFileSync4 } from "fs";
|
|
31145
30585
|
import { posix, win32 } from "path";
|
|
31146
|
-
function managedSettingsPaths(
|
|
31147
|
-
if (
|
|
30586
|
+
function managedSettingsPaths(platform = process.platform) {
|
|
30587
|
+
if (platform === "darwin") {
|
|
31148
30588
|
return [
|
|
31149
30589
|
posix.join("/Library", "Application Support", "AKASecurity", MANAGED_SETTINGS_FILENAME),
|
|
31150
30590
|
posix.join("/Library", "Managed Preferences", MANAGED_SETTINGS_FILENAME)
|
|
31151
30591
|
];
|
|
31152
30592
|
}
|
|
31153
|
-
if (
|
|
30593
|
+
if (platform === "win32") {
|
|
31154
30594
|
return [win32.join("C:\\", "ProgramData", "AKASecurity", MANAGED_SETTINGS_FILENAME)];
|
|
31155
30595
|
}
|
|
31156
30596
|
return [posix.join("/etc", "aka", MANAGED_SETTINGS_FILENAME)];
|
|
@@ -31160,7 +30600,7 @@ function readManagedSettings(paths = testOnlyManagedPaths ?? managedSettingsPath
|
|
|
31160
30600
|
for (const path of paths) {
|
|
31161
30601
|
let text;
|
|
31162
30602
|
try {
|
|
31163
|
-
text =
|
|
30603
|
+
text = readFileSync4(path, "utf8");
|
|
31164
30604
|
} catch {
|
|
31165
30605
|
continue;
|
|
31166
30606
|
}
|
|
@@ -31214,7 +30654,7 @@ function readWorkspaceSettings(base = defaultDataDir()) {
|
|
|
31214
30654
|
return overlayManagedSettings(readUserSettings(base), readManagedSettings());
|
|
31215
30655
|
}
|
|
31216
30656
|
function readUserSettings(base) {
|
|
31217
|
-
const record2 = readJson(
|
|
30657
|
+
const record2 = readJson(join6(settingsDir(base), SETTINGS_FILENAME));
|
|
31218
30658
|
if (!record2) return defaultWorkspaceSettings();
|
|
31219
30659
|
try {
|
|
31220
30660
|
return WorkspaceSettings.parse(record2);
|
|
@@ -31225,7 +30665,7 @@ function readUserSettings(base) {
|
|
|
31225
30665
|
function readJson(file2) {
|
|
31226
30666
|
let text;
|
|
31227
30667
|
try {
|
|
31228
|
-
text =
|
|
30668
|
+
text = readFileSync5(file2, "utf8");
|
|
31229
30669
|
} catch {
|
|
31230
30670
|
return null;
|
|
31231
30671
|
}
|
|
@@ -31265,7 +30705,7 @@ var PolicyFloorError = class extends Error {
|
|
|
31265
30705
|
};
|
|
31266
30706
|
function readCachedPolicyBundle(base = defaultDataDir()) {
|
|
31267
30707
|
try {
|
|
31268
|
-
const raw =
|
|
30708
|
+
const raw = readFileSync6(join7(dataDir(base), POLICY_CACHE_FILENAME), "utf8");
|
|
31269
30709
|
const parsed2 = JSON.parse(raw);
|
|
31270
30710
|
if (typeof parsed2 !== "object" || parsed2 === null) return null;
|
|
31271
30711
|
return PolicyBundle.parse(parsed2.bundle);
|
|
@@ -31389,7 +30829,7 @@ function inventorySignature(packs2) {
|
|
|
31389
30829
|
return packs2.map((p) => `${p.namespace}/${p.packId}@${p.version}#${hashRules(p.rulesJson)}`).sort().join(",");
|
|
31390
30830
|
}
|
|
31391
30831
|
function hashRules(rulesJson) {
|
|
31392
|
-
return
|
|
30832
|
+
return createHash3("sha256").update(rulesJson).digest("hex");
|
|
31393
30833
|
}
|
|
31394
30834
|
function parseVersion(v) {
|
|
31395
30835
|
const m = /^(\d+)\.(\d+)\.(\d+)/.exec(v);
|
|
@@ -31431,9 +30871,10 @@ var SqliteInstalledPacksRepository = class {
|
|
|
31431
30871
|
* from `openLocalDatabase`, which is the single construction site that owns a
|
|
31432
30872
|
* real `~/.aka`.
|
|
31433
30873
|
*/
|
|
31434
|
-
constructor(db, baseDir) {
|
|
30874
|
+
constructor(db, baseDir, onChange = () => void 0) {
|
|
31435
30875
|
this.db = db;
|
|
31436
30876
|
this.baseDir = baseDir;
|
|
30877
|
+
this.onChange = onChange;
|
|
31437
30878
|
this.insertMissingStmt = db.prepare(
|
|
31438
30879
|
`INSERT INTO installed_packs (id, namespace, pack_id, version, name, rules_json, enabled, policy_id, created_at, updated_at)
|
|
31439
30880
|
VALUES (:id, :namespace, :packId, :version, :name, :rulesJson, 1, :policyId, :now, :now)
|
|
@@ -31462,6 +30903,7 @@ var SqliteInstalledPacksRepository = class {
|
|
|
31462
30903
|
}
|
|
31463
30904
|
db;
|
|
31464
30905
|
baseDir;
|
|
30906
|
+
onChange;
|
|
31465
30907
|
insertMissingStmt;
|
|
31466
30908
|
upsertAvailableStmt;
|
|
31467
30909
|
signatureStmt;
|
|
@@ -31534,6 +30976,7 @@ var SqliteInstalledPacksRepository = class {
|
|
|
31534
30976
|
},
|
|
31535
30977
|
"IMMEDIATE"
|
|
31536
30978
|
);
|
|
30979
|
+
this.onChange();
|
|
31537
30980
|
} catch {
|
|
31538
30981
|
}
|
|
31539
30982
|
}
|
|
@@ -31608,6 +31051,7 @@ var SqliteInstalledPacksRepository = class {
|
|
|
31608
31051
|
},
|
|
31609
31052
|
"IMMEDIATE"
|
|
31610
31053
|
);
|
|
31054
|
+
if (changed) this.onChange();
|
|
31611
31055
|
return changed;
|
|
31612
31056
|
}
|
|
31613
31057
|
/**
|
|
@@ -31849,6 +31293,7 @@ var SqliteInstalledPacksRepository = class {
|
|
|
31849
31293
|
`UPDATE installed_packs SET policy_id = :policyId, updated_at = :now
|
|
31850
31294
|
WHERE namespace = :namespace AND pack_id = :packId`
|
|
31851
31295
|
).run({ policyId, now: Date.now(), namespace, packId });
|
|
31296
|
+
if (Number(res.changes) > 0) this.onChange();
|
|
31852
31297
|
return Number(res.changes) > 0;
|
|
31853
31298
|
}
|
|
31854
31299
|
/**
|
|
@@ -31873,6 +31318,7 @@ var SqliteInstalledPacksRepository = class {
|
|
|
31873
31318
|
`UPDATE installed_packs SET enabled = :enabled, updated_at = :now
|
|
31874
31319
|
WHERE namespace = :namespace AND pack_id = :packId`
|
|
31875
31320
|
).run({ enabled: boolToInt(enabled), now: Date.now(), namespace, packId });
|
|
31321
|
+
if (Number(res.changes) > 0) this.onChange();
|
|
31876
31322
|
return Number(res.changes) > 0;
|
|
31877
31323
|
}
|
|
31878
31324
|
// Fingerprint of the recorded available mirror — compared against the
|
|
@@ -32770,13 +32216,19 @@ var SqliteInventoryAssetsRepository = class {
|
|
|
32770
32216
|
import { randomUUID as randomUUID6 } from "crypto";
|
|
32771
32217
|
var SEED_BATCH_WINDOW_MS = 6e4;
|
|
32772
32218
|
var SqlitePoliciesRepository = class {
|
|
32773
|
-
constructor(db) {
|
|
32219
|
+
constructor(db, onChange = () => void 0) {
|
|
32774
32220
|
this.db = db;
|
|
32221
|
+
this.onChange = onChange;
|
|
32775
32222
|
}
|
|
32776
32223
|
db;
|
|
32224
|
+
onChange;
|
|
32777
32225
|
readPolicies() {
|
|
32226
|
+
return Promise.resolve(this.listPolicies());
|
|
32227
|
+
}
|
|
32228
|
+
/** The synchronous read behind {@link readPolicies}. */
|
|
32229
|
+
listPolicies() {
|
|
32778
32230
|
const rows = allRows(this.db.prepare("SELECT * FROM policies"));
|
|
32779
|
-
|
|
32231
|
+
return mapRowsTolerant(rows, (row) => {
|
|
32780
32232
|
const target = JSON.parse(row.target);
|
|
32781
32233
|
const customKeywords = row.custom_keywords ? JSON.parse(row.custom_keywords) : void 0;
|
|
32782
32234
|
return Policy.parse({
|
|
@@ -32788,7 +32240,6 @@ var SqlitePoliciesRepository = class {
|
|
|
32788
32240
|
customKeywords
|
|
32789
32241
|
});
|
|
32790
32242
|
});
|
|
32791
|
-
return Promise.resolve(policies);
|
|
32792
32243
|
}
|
|
32793
32244
|
// Seed one policy per bundled category at Monitor so the detection-type config
|
|
32794
32245
|
// exists from first run. An unassigned pack's rules follow these rows, so
|
|
@@ -32799,7 +32250,7 @@ var SqlitePoliciesRepository = class {
|
|
|
32799
32250
|
const count = countScalar(this.db, "SELECT count(*) AS n FROM policies");
|
|
32800
32251
|
if (count > 0) {
|
|
32801
32252
|
this.markEarlierChoices();
|
|
32802
|
-
this.monitorUntouchedSeeds();
|
|
32253
|
+
if (this.monitorUntouchedSeeds()) this.onChange();
|
|
32803
32254
|
return;
|
|
32804
32255
|
}
|
|
32805
32256
|
const stmt = this.db.prepare(
|
|
@@ -32816,6 +32267,7 @@ var SqlitePoliciesRepository = class {
|
|
|
32816
32267
|
});
|
|
32817
32268
|
}
|
|
32818
32269
|
});
|
|
32270
|
+
this.onChange();
|
|
32819
32271
|
}
|
|
32820
32272
|
// Before this build, upsertCategoryAction INSERTed a new row with updated_at
|
|
32821
32273
|
// equal to created_at, so a choice made for a category that had no row yet
|
|
@@ -32881,7 +32333,7 @@ var SqlitePoliciesRepository = class {
|
|
|
32881
32333
|
).filter(
|
|
32882
32334
|
(row) => DEFAULT_ACTIONS[row.category] === row.action
|
|
32883
32335
|
);
|
|
32884
|
-
if (untouched.length === 0) return;
|
|
32336
|
+
if (untouched.length === 0) return false;
|
|
32885
32337
|
const stmt = this.db.prepare(
|
|
32886
32338
|
`UPDATE policies SET action = 'log'
|
|
32887
32339
|
WHERE scope = 'global' AND json_extract(target, '$.category') = :category
|
|
@@ -32892,6 +32344,7 @@ var SqlitePoliciesRepository = class {
|
|
|
32892
32344
|
stmt.run({ category: row.category, seeded: row.action });
|
|
32893
32345
|
}
|
|
32894
32346
|
});
|
|
32347
|
+
return true;
|
|
32895
32348
|
}
|
|
32896
32349
|
// Insert-or-update the single global per-category policy row, keyed on the
|
|
32897
32350
|
// existing uq_policies_scope_target unique index (scope, target). `action`
|
|
@@ -32908,6 +32361,7 @@ var SqlitePoliciesRepository = class {
|
|
|
32908
32361
|
ON CONFLICT(scope, target) DO UPDATE SET action = excluded.action, enabled = 1,
|
|
32909
32362
|
updated_at = MAX(excluded.updated_at, policies.created_at + 1)`
|
|
32910
32363
|
).run({ id: randomUUID6(), target: JSON.stringify({ category }), action, now });
|
|
32364
|
+
this.onChange();
|
|
32911
32365
|
}
|
|
32912
32366
|
// Caps every global per-category policy currently set to block/redact down
|
|
32913
32367
|
// to warn (see warn-era-cap.ts). Rule-targeted policies are untouched.
|
|
@@ -32918,6 +32372,7 @@ var SqlitePoliciesRepository = class {
|
|
|
32918
32372
|
WHERE scope='global' AND action IN ('block','redact')
|
|
32919
32373
|
AND json_extract(target,'$.category') IS NOT NULL`
|
|
32920
32374
|
).run({ now: Date.now() });
|
|
32375
|
+
if (Number(info.changes) > 0) this.onChange();
|
|
32921
32376
|
return Number(info.changes);
|
|
32922
32377
|
}
|
|
32923
32378
|
// Whether the category's row was ever written after it was created — by the
|
|
@@ -33237,31 +32692,45 @@ var SqliteScanLedgerRepository = class {
|
|
|
33237
32692
|
constructor(db) {
|
|
33238
32693
|
this.db = db;
|
|
33239
32694
|
this.upsertStmt = db.prepare(
|
|
33240
|
-
`INSERT INTO scan_ledger
|
|
33241
|
-
|
|
32695
|
+
`INSERT INTO scan_ledger
|
|
32696
|
+
(path, mtime, content_hash, ruleset_hash, scope_key, scope_root, scanned_at)
|
|
32697
|
+
VALUES (:path, :mtime, :contentHash, :rulesetHash, :scopeKey, :scopeRoot, :scannedAt)
|
|
33242
32698
|
ON CONFLICT (path) DO UPDATE SET
|
|
33243
32699
|
mtime = excluded.mtime,
|
|
33244
32700
|
content_hash = excluded.content_hash,
|
|
33245
32701
|
ruleset_hash = excluded.ruleset_hash,
|
|
32702
|
+
scope_key = excluded.scope_key,
|
|
32703
|
+
scope_root = excluded.scope_root,
|
|
33246
32704
|
scanned_at = excluded.scanned_at`
|
|
33247
32705
|
);
|
|
33248
32706
|
this.readStmt = db.prepare(
|
|
33249
|
-
`SELECT path, mtime, content_hash AS contentHash
|
|
32707
|
+
`SELECT path, mtime, content_hash AS contentHash, scope_key AS scopeKey,
|
|
32708
|
+
scope_root AS scopeRoot
|
|
33250
32709
|
FROM scan_ledger WHERE ruleset_hash = :rulesetHash`
|
|
33251
32710
|
);
|
|
33252
32711
|
this.pathsStmt = db.prepare(`SELECT path FROM scan_ledger`);
|
|
32712
|
+
this.pathKeysStmt = db.prepare(`SELECT path, scope_key AS scopeKey FROM scan_ledger`);
|
|
33253
32713
|
}
|
|
33254
32714
|
db;
|
|
33255
32715
|
upsertStmt;
|
|
33256
32716
|
readStmt;
|
|
33257
32717
|
pathsStmt;
|
|
32718
|
+
pathKeysStmt;
|
|
33258
32719
|
// Previously scanned files under THIS ruleset, keyed by path. Rows from an
|
|
33259
32720
|
// older ruleset are simply absent, which reads as "never scanned".
|
|
33260
32721
|
entriesForRuleset(rulesetHash) {
|
|
33261
|
-
const rows = allRows(this.readStmt, {
|
|
33262
|
-
|
|
33263
|
-
|
|
33264
|
-
|
|
32722
|
+
const rows = allRows(this.readStmt, { rulesetHash });
|
|
32723
|
+
return new Map(
|
|
32724
|
+
rows.map((r) => [
|
|
32725
|
+
r.path,
|
|
32726
|
+
{
|
|
32727
|
+
mtime: r.mtime,
|
|
32728
|
+
contentHash: r.contentHash,
|
|
32729
|
+
...r.scopeKey !== null ? { scopeKey: r.scopeKey } : {},
|
|
32730
|
+
...r.scopeRoot !== null ? { scopeRoot: r.scopeRoot } : {}
|
|
32731
|
+
}
|
|
32732
|
+
])
|
|
32733
|
+
);
|
|
33265
32734
|
}
|
|
33266
32735
|
// Every ledgered path, whatever ruleset it was scanned under — the set a
|
|
33267
32736
|
// deletion sweep checks against disk. A file deleted before a ruleset change
|
|
@@ -33270,6 +32739,14 @@ var SqliteScanLedgerRepository = class {
|
|
|
33270
32739
|
allPaths() {
|
|
33271
32740
|
return allRows(this.pathsStmt).map((r) => r.path);
|
|
33272
32741
|
}
|
|
32742
|
+
// Every ledgered path with the repository it was in when it was last read,
|
|
32743
|
+
// whatever ruleset it was scanned under: what a deletion sweep needs to say
|
|
32744
|
+
// which repository a vanished file belonged to. `undefined` for a row with no
|
|
32745
|
+
// key, which is every row written before the column existed.
|
|
32746
|
+
pathKeys() {
|
|
32747
|
+
const rows = allRows(this.pathKeysStmt);
|
|
32748
|
+
return new Map(rows.map((r) => [r.path, r.scopeKey ?? void 0]));
|
|
32749
|
+
}
|
|
33273
32750
|
upsertEntries(entries) {
|
|
33274
32751
|
if (entries.length === 0) return;
|
|
33275
32752
|
const scannedAt = Date.now();
|
|
@@ -33280,6 +32757,8 @@ var SqliteScanLedgerRepository = class {
|
|
|
33280
32757
|
mtime: entry.mtime,
|
|
33281
32758
|
contentHash: entry.contentHash,
|
|
33282
32759
|
rulesetHash: entry.rulesetHash,
|
|
32760
|
+
scopeKey: entry.scopeKey ?? null,
|
|
32761
|
+
scopeRoot: entry.scopeRoot ?? null,
|
|
33283
32762
|
scannedAt
|
|
33284
32763
|
});
|
|
33285
32764
|
}
|
|
@@ -34367,6 +33846,11 @@ function withoutDroppedFiles(reconcile, droppedFiles) {
|
|
|
34367
33846
|
deletedFiles: reconcile.deletedFiles.filter((file2) => !dropped.has(file2))
|
|
34368
33847
|
};
|
|
34369
33848
|
}
|
|
33849
|
+
function withoutTrailingSlashes(path) {
|
|
33850
|
+
let end = path.length;
|
|
33851
|
+
while (end > 0 && path.charCodeAt(end - 1) === 47) end--;
|
|
33852
|
+
return path.slice(0, end);
|
|
33853
|
+
}
|
|
34370
33854
|
function toEndpointSummary(row) {
|
|
34371
33855
|
return {
|
|
34372
33856
|
id: row.id,
|
|
@@ -34654,7 +34138,7 @@ var SqliteSharesRepository = class {
|
|
|
34654
34138
|
*/
|
|
34655
34139
|
reconcileCallSites(projectKey, reconcile) {
|
|
34656
34140
|
if (reconcile.mode === "walk") {
|
|
34657
|
-
const prefix = reconcile.walkedPrefix
|
|
34141
|
+
const prefix = withoutTrailingSlashes(reconcile.walkedPrefix);
|
|
34658
34142
|
this.db.prepare(
|
|
34659
34143
|
`DELETE FROM share_call_site
|
|
34660
34144
|
WHERE project_key = :key
|
|
@@ -35222,7 +34706,7 @@ function backupLegacyStore(db, file2) {
|
|
|
35222
34706
|
discardStore(file2, backup);
|
|
35223
34707
|
return backup;
|
|
35224
34708
|
}
|
|
35225
|
-
function openAndInitialize(file2, base, skipTags) {
|
|
34709
|
+
function openAndInitialize(file2, base, skipTags, shippedRegexMatchers2) {
|
|
35226
34710
|
let db = openWithPragmas(file2);
|
|
35227
34711
|
try {
|
|
35228
34712
|
if (isForeignSqliteLineage(db)) {
|
|
@@ -35234,8 +34718,15 @@ function openAndInitialize(file2, base, skipTags) {
|
|
|
35234
34718
|
}
|
|
35235
34719
|
applyMigrations(db, file2, { skipTags });
|
|
35236
34720
|
tightenPerms(file2);
|
|
35237
|
-
const
|
|
35238
|
-
const
|
|
34721
|
+
const modPolicy = {};
|
|
34722
|
+
const onPolicyStateChange = () => {
|
|
34723
|
+
if (modPolicy.current !== void 0)
|
|
34724
|
+
refreshModPolicySnapshot(dirname2(file2), modPolicy.current);
|
|
34725
|
+
};
|
|
34726
|
+
const policies = new SqlitePoliciesRepository(db, onPolicyStateChange);
|
|
34727
|
+
const installedPacks = new SqliteInstalledPacksRepository(db, base, onPolicyStateChange);
|
|
34728
|
+
const ruleProbeCache = new SqliteRuleProbeCacheRepository(db);
|
|
34729
|
+
const exceptions = new SqliteExceptionsRepository(db, void 0, onPolicyStateChange);
|
|
35239
34730
|
const repositories = {
|
|
35240
34731
|
events: new SqliteEventsRepository(db),
|
|
35241
34732
|
findings: new SqliteFindingsRepository(db),
|
|
@@ -35244,9 +34735,9 @@ function openAndInitialize(file2, base, skipTags) {
|
|
|
35244
34735
|
scanLedger: new SqliteScanLedgerRepository(db),
|
|
35245
34736
|
historySync: new SqliteHistorySyncRepository(db),
|
|
35246
34737
|
secretVault: new SqliteSecretVaultRepository(db),
|
|
35247
|
-
exceptions
|
|
34738
|
+
exceptions,
|
|
35248
34739
|
resolutions: new SqliteResolutionsRepository(db),
|
|
35249
|
-
ruleProbeCache
|
|
34740
|
+
ruleProbeCache,
|
|
35250
34741
|
bodyRetention: new SqliteBodyRetentionRepository(db),
|
|
35251
34742
|
security: new SqliteSecurityRepository(db),
|
|
35252
34743
|
detections: new SqliteDetectionsRepository(db),
|
|
@@ -35264,6 +34755,13 @@ function openAndInitialize(file2, base, skipTags) {
|
|
|
35264
34755
|
inspectionFindings: new SqliteInspectionFindingsRepository(db),
|
|
35265
34756
|
configInventory: new SqliteConfigInventoryRepository(db)
|
|
35266
34757
|
};
|
|
34758
|
+
modPolicy.current = {
|
|
34759
|
+
installedRuleset: () => installedPacks.installedRuleset(),
|
|
34760
|
+
readPolicies: () => policies.listPolicies(),
|
|
34761
|
+
activeExceptionRuleIds: () => exceptions.activeRuleIds(),
|
|
34762
|
+
probeVerdict: (key) => ruleProbeCache.getVerdict(key)?.verdict,
|
|
34763
|
+
bundledRegexMatchers: () => shippedRegexMatchers2
|
|
34764
|
+
};
|
|
35267
34765
|
policies.seedDefaults();
|
|
35268
34766
|
return { db, ...repositories };
|
|
35269
34767
|
} catch (err) {
|
|
@@ -35275,7 +34773,7 @@ function openAndInitialize(file2, base, skipTags) {
|
|
|
35275
34773
|
var DEFERRED_TAGS = new Set(DEFERRED_MIGRATION_TAGS);
|
|
35276
34774
|
function openLocalDatabase(dir, options = {}) {
|
|
35277
34775
|
ensureDataDirSync(dir);
|
|
35278
|
-
const file2 =
|
|
34776
|
+
const file2 = join8(dir, DB_FILENAME);
|
|
35279
34777
|
reapStalePartials(file2);
|
|
35280
34778
|
const {
|
|
35281
34779
|
db,
|
|
@@ -35311,7 +34809,8 @@ function openLocalDatabase(dir, options = {}) {
|
|
|
35311
34809
|
// `dataDir()` — so its parent is the `~/.aka` base the layout splits into
|
|
35312
34810
|
// settings/ and data/, and the pack-policy floor needs both halves.
|
|
35313
34811
|
dirname2(dir),
|
|
35314
|
-
options.applyDeferredMigrations === true ? void 0 : DEFERRED_TAGS
|
|
34812
|
+
options.applyDeferredMigrations === true ? void 0 : DEFERRED_TAGS,
|
|
34813
|
+
options.shippedRegexMatchers ?? []
|
|
35315
34814
|
);
|
|
35316
34815
|
function captureRowId(event) {
|
|
35317
34816
|
return captureId(
|
|
@@ -35576,7 +35075,7 @@ function openLocalDatabase(dir, options = {}) {
|
|
|
35576
35075
|
}
|
|
35577
35076
|
|
|
35578
35077
|
// ../../packages/persistence/src/egress-wire.ts
|
|
35579
|
-
import { createHash as
|
|
35078
|
+
import { createHash as createHash4 } from "crypto";
|
|
35580
35079
|
var PROJECT_KEY_DIGEST_VERSION = "v2";
|
|
35581
35080
|
var SCP_FORM = /^(?:[^@/]+@)?([^/:]+):(.+)$/;
|
|
35582
35081
|
var DOS_DRIVE = /^[A-Za-z]:[\\/]/;
|
|
@@ -35608,7 +35107,7 @@ function canonicalGitUrl(url2) {
|
|
|
35608
35107
|
}
|
|
35609
35108
|
function hashProjectKey(projectKey) {
|
|
35610
35109
|
const canonical = projectKey.startsWith("git:") ? `git:${canonicalGitUrl(projectKey.slice("git:".length))}` : projectKey;
|
|
35611
|
-
return
|
|
35110
|
+
return createHash4("sha256").update(`${PROJECT_KEY_DIGEST_VERSION}:${canonical}`, "utf8").digest("hex");
|
|
35612
35111
|
}
|
|
35613
35112
|
var SCOPE_KEY = printable(ATTACHMENT_SCOPE_IDENTITY_MAX_LENGTH);
|
|
35614
35113
|
var URL_SCHEME = /^[a-z][a-z0-9+.-]*:\/\//i;
|
|
@@ -35673,24 +35172,23 @@ function toEgressIngestRequest(input2) {
|
|
|
35673
35172
|
}
|
|
35674
35173
|
|
|
35675
35174
|
// ../../packages/persistence/src/finding-key.ts
|
|
35676
|
-
import { createHash as
|
|
35175
|
+
import { createHash as createHash5 } from "crypto";
|
|
35677
35176
|
function normalizeFilePath(filePath) {
|
|
35678
35177
|
return filePath.replaceAll("\\", "/");
|
|
35679
35178
|
}
|
|
35680
35179
|
function computeFindingKey(input2) {
|
|
35681
35180
|
const normalizedPath = normalizeFilePath(input2.filePath);
|
|
35682
|
-
return
|
|
35181
|
+
return createHash5("sha256").update(`${input2.ruleId}\0${normalizedPath}\0${input2.valueFingerprint}`).digest("hex");
|
|
35683
35182
|
}
|
|
35684
35183
|
|
|
35685
35184
|
// ../../packages/persistence/src/fingerprint.ts
|
|
35686
35185
|
import { createHmac, randomBytes } from "crypto";
|
|
35687
|
-
import { existsSync as existsSync3, readFileSync as
|
|
35688
|
-
import { join as
|
|
35689
|
-
import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
|
|
35186
|
+
import { existsSync as existsSync3, readFileSync as readFileSync7 } from "fs";
|
|
35187
|
+
import { join as join9 } from "path";
|
|
35690
35188
|
var EXCEPTION_KEY_FILENAME = "exception.key";
|
|
35691
35189
|
var KEY_MATERIAL_BYTES = 32;
|
|
35692
35190
|
function keyFilePath(dataDir2) {
|
|
35693
|
-
return
|
|
35191
|
+
return join9(dataDir2, EXCEPTION_KEY_FILENAME);
|
|
35694
35192
|
}
|
|
35695
35193
|
function parseKeyFile(raw) {
|
|
35696
35194
|
const parsed2 = JSON.parse(raw);
|
|
@@ -35717,6 +35215,12 @@ var KEY_VERSION_COLUMNS = {
|
|
|
35717
35215
|
};
|
|
35718
35216
|
var SQLITE_ERROR2 = 1;
|
|
35719
35217
|
var FLOOR_BUSY_TIMEOUT_MS = 250;
|
|
35218
|
+
function openReadOnly(file2) {
|
|
35219
|
+
const host = process;
|
|
35220
|
+
const sqlite = host.getBuiltinModule?.("node:sqlite");
|
|
35221
|
+
if (sqlite === void 0) throw new Error("this Node runtime cannot load node:sqlite");
|
|
35222
|
+
return new sqlite.DatabaseSync(file2, { readOnly: true });
|
|
35223
|
+
}
|
|
35720
35224
|
var FloorUnreadableError = class extends Error {
|
|
35721
35225
|
code = "floor-unreadable";
|
|
35722
35226
|
constructor(cause) {
|
|
@@ -35728,11 +35232,11 @@ var FloorUnreadableError = class extends Error {
|
|
|
35728
35232
|
}
|
|
35729
35233
|
};
|
|
35730
35234
|
function storedKeyVersionFloor(dataDir2) {
|
|
35731
|
-
const file2 =
|
|
35235
|
+
const file2 = join9(dataDir2, DB_FILENAME);
|
|
35732
35236
|
if (!existsSync3(file2)) return 0;
|
|
35733
35237
|
let db;
|
|
35734
35238
|
try {
|
|
35735
|
-
db =
|
|
35239
|
+
db = openReadOnly(file2);
|
|
35736
35240
|
db.exec(`PRAGMA busy_timeout = ${String(FLOOR_BUSY_TIMEOUT_MS)}`);
|
|
35737
35241
|
let floor = 0;
|
|
35738
35242
|
for (const [table, column] of Object.entries(KEY_VERSION_COLUMNS)) {
|
|
@@ -35783,7 +35287,7 @@ function occupantMessage(file2, kind) {
|
|
|
35783
35287
|
function readFingerprintKey(dataDir2) {
|
|
35784
35288
|
let raw;
|
|
35785
35289
|
try {
|
|
35786
|
-
raw =
|
|
35290
|
+
raw = readFileSync7(keyFilePath(dataDir2), "utf8");
|
|
35787
35291
|
} catch (err) {
|
|
35788
35292
|
if (err.code === "ENOENT") return null;
|
|
35789
35293
|
throw err instanceof Error ? err : new Error(String(err));
|
|
@@ -35809,8 +35313,8 @@ function exactFingerprintValue(key, raw) {
|
|
|
35809
35313
|
}
|
|
35810
35314
|
|
|
35811
35315
|
// ../../packages/persistence/src/forward-health.ts
|
|
35812
|
-
import { readFileSync as
|
|
35813
|
-
import { join as
|
|
35316
|
+
import { readFileSync as readFileSync8 } from "fs";
|
|
35317
|
+
import { join as join10 } from "path";
|
|
35814
35318
|
var BREAKER_COOLDOWN_MS = 3e4;
|
|
35815
35319
|
function parseForwardHealth(raw, nowMs) {
|
|
35816
35320
|
try {
|
|
@@ -35834,20 +35338,21 @@ function isForwardPaused(health, nowMs) {
|
|
|
35834
35338
|
|
|
35835
35339
|
// ../../packages/persistence/src/history-backfill.ts
|
|
35836
35340
|
import { existsSync as existsSync4 } from "fs";
|
|
35837
|
-
import { join as
|
|
35341
|
+
import { join as join11 } from "path";
|
|
35838
35342
|
|
|
35839
35343
|
// ../../packages/persistence/src/history-preview.ts
|
|
35840
35344
|
import { existsSync as existsSync5 } from "fs";
|
|
35841
|
-
import { join as
|
|
35842
|
-
import { DatabaseSync as
|
|
35345
|
+
import { join as join12 } from "path";
|
|
35346
|
+
import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
|
|
35843
35347
|
|
|
35844
35348
|
// ../../packages/persistence/src/history-sync-state.ts
|
|
35845
|
-
import { readFileSync as
|
|
35846
|
-
import { join as
|
|
35349
|
+
import { readFileSync as readFileSync9 } from "fs";
|
|
35350
|
+
import { join as join13 } from "path";
|
|
35351
|
+
var COUNTS_SCOPES = new Set(AttachmentMode.options);
|
|
35847
35352
|
|
|
35848
35353
|
// ../../packages/persistence/src/store-symlinks.ts
|
|
35849
35354
|
import { existsSync as existsSync6, lstatSync as lstatSync3, readlinkSync, realpathSync, statSync as statSync4 } from "fs";
|
|
35850
|
-
import { dirname as dirname3, join as
|
|
35355
|
+
import { dirname as dirname3, join as join14, resolve } from "path";
|
|
35851
35356
|
var STORE_DB = "the store database (including the prompt corpus)";
|
|
35852
35357
|
var STORE_SETTINGS = "your settings file";
|
|
35853
35358
|
function storeContents(home) {
|
|
@@ -35856,11 +35361,11 @@ function storeContents(home) {
|
|
|
35856
35361
|
[settingsDir(home), STORE_SETTINGS],
|
|
35857
35362
|
[dataDir(home), STORE_DB],
|
|
35858
35363
|
[keysDir(home), "the vault key"],
|
|
35859
|
-
[
|
|
35364
|
+
[join14(settingsDir(home), "settings.json"), STORE_SETTINGS],
|
|
35860
35365
|
[dbPath(home), STORE_DB]
|
|
35861
35366
|
]);
|
|
35862
35367
|
}
|
|
35863
|
-
function symlinkedStorePaths(home,
|
|
35368
|
+
function symlinkedStorePaths(home, platform = process.platform) {
|
|
35864
35369
|
return [...storeContents(home)].flatMap(([path, holds]) => {
|
|
35865
35370
|
try {
|
|
35866
35371
|
if (!lstatSync3(path).isSymbolicLink()) return [];
|
|
@@ -35872,7 +35377,7 @@ function symlinkedStorePaths(home, platform2 = process.platform) {
|
|
|
35872
35377
|
// existsSync follows the link, so a target that is gone reads as
|
|
35873
35378
|
// absent here while lstat above still sees the link itself.
|
|
35874
35379
|
missing: !existsSync6(path),
|
|
35875
|
-
mode: targetMode(path,
|
|
35380
|
+
mode: targetMode(path, platform)
|
|
35876
35381
|
}
|
|
35877
35382
|
];
|
|
35878
35383
|
} catch {
|
|
@@ -35887,8 +35392,8 @@ function linkTarget(path) {
|
|
|
35887
35392
|
return resolve(dirname3(path), readlinkSync(path));
|
|
35888
35393
|
}
|
|
35889
35394
|
}
|
|
35890
|
-
function targetMode(path,
|
|
35891
|
-
if (
|
|
35395
|
+
function targetMode(path, platform) {
|
|
35396
|
+
if (platform === "win32") return void 0;
|
|
35892
35397
|
try {
|
|
35893
35398
|
return statSync4(path).mode & 511;
|
|
35894
35399
|
} catch {
|
|
@@ -35908,19 +35413,19 @@ import {
|
|
|
35908
35413
|
// ../../packages/persistence/src/vault/key-provider.ts
|
|
35909
35414
|
import { execFileSync } from "child_process";
|
|
35910
35415
|
import { randomBytes as randomBytes2 } from "crypto";
|
|
35911
|
-
import { chmodSync as chmodSync3, readFileSync as
|
|
35912
|
-
import { join as
|
|
35416
|
+
import { chmodSync as chmodSync3, readFileSync as readFileSync10, renameSync as renameSync4, rmSync as rmSync6, statSync as statSync5, writeFileSync as writeFileSync3 } from "fs";
|
|
35417
|
+
import { join as join15 } from "path";
|
|
35913
35418
|
|
|
35914
35419
|
// ../../packages/persistence/src/vault/vault.ts
|
|
35915
35420
|
import { randomBytes as randomBytes3, randomUUID as randomUUID12 } from "crypto";
|
|
35916
35421
|
|
|
35917
35422
|
// ../../packages/persistence/src/warn-era-cap.ts
|
|
35918
35423
|
import { existsSync as existsSync7, writeFileSync as writeFileSync4 } from "fs";
|
|
35919
|
-
import { join as
|
|
35424
|
+
import { join as join16 } from "path";
|
|
35920
35425
|
var MARKER = "warn-era-capped";
|
|
35921
35426
|
function capWarnEraEnforcementOnce(db, policyMode, dataDir2) {
|
|
35922
35427
|
if (policyMode !== "warn") return { capped: 0, skipped: "not-warn" };
|
|
35923
|
-
const marker =
|
|
35428
|
+
const marker = join16(dataDir2, MARKER);
|
|
35924
35429
|
if (existsSync7(marker)) return { capped: 0, skipped: "already-run" };
|
|
35925
35430
|
const capped = db.policies.capCategoryActions();
|
|
35926
35431
|
writeFileSync4(marker, `${new Date(Date.now()).toISOString()}
|
|
@@ -35980,7 +35485,7 @@ function resolveProvider() {
|
|
|
35980
35485
|
function loadConfig(base = defaultDataDir(), resolveProviderFn = resolveProvider) {
|
|
35981
35486
|
try {
|
|
35982
35487
|
ensureLayoutDirSync(base);
|
|
35983
|
-
const settingsFile =
|
|
35488
|
+
const settingsFile = join17(settingsDir(base), "settings.json");
|
|
35984
35489
|
if (existsSync8(settingsFile)) tightenFile(settingsFile);
|
|
35985
35490
|
} catch {
|
|
35986
35491
|
}
|
|
@@ -36003,11 +35508,6 @@ function resolveProviderSafe(resolveProviderFn) {
|
|
|
36003
35508
|
}
|
|
36004
35509
|
}
|
|
36005
35510
|
|
|
36006
|
-
// ../../packages/plugin-sdk/src/config-inventory.ts
|
|
36007
|
-
import { readdirSync as readdirSync2, readFileSync as readFileSync11, realpathSync as realpathSync2, statSync as statSync7 } from "fs";
|
|
36008
|
-
import { homedir as homedir2 } from "os";
|
|
36009
|
-
import { basename as basename3, join as join18 } from "path";
|
|
36010
|
-
|
|
36011
35511
|
// ../../packages/detections/src/egress/registry.ts
|
|
36012
35512
|
var EXTRACTOR_VERSION = "3";
|
|
36013
35513
|
var PROVIDER_REGISTRY = [
|
|
@@ -36771,12 +36271,12 @@ var RegexMatcher2 = class {
|
|
|
36771
36271
|
rule.matcher,
|
|
36772
36272
|
() => new RegExp(pattern, flags.includes("d") ? flags : `${flags}d`)
|
|
36773
36273
|
);
|
|
36774
|
-
const
|
|
36274
|
+
const scanText = text.length > MAX_REGEX_INPUT_LENGTH ? text.slice(0, MAX_REGEX_INPUT_LENGTH) : text;
|
|
36775
36275
|
const spans = [];
|
|
36776
36276
|
let m;
|
|
36777
|
-
const maxIterations =
|
|
36277
|
+
const maxIterations = scanText.length + 1;
|
|
36778
36278
|
let iterations = 0;
|
|
36779
|
-
while ((m = re.exec(
|
|
36279
|
+
while ((m = re.exec(scanText)) !== null) {
|
|
36780
36280
|
if (++iterations > maxIterations) break;
|
|
36781
36281
|
const group = captureGroup != null ? m[captureGroup] : m[0];
|
|
36782
36282
|
if (m[0].length === 0) re.lastIndex++;
|
|
@@ -37118,17 +36618,18 @@ function ruleEvidence(rule) {
|
|
|
37118
36618
|
|
|
37119
36619
|
// ../../packages/detections/src/mask.ts
|
|
37120
36620
|
function maskMatch(raw) {
|
|
37121
|
-
|
|
37122
|
-
|
|
37123
|
-
|
|
37124
|
-
|
|
36621
|
+
const visible = stripInvisiblePadding(raw);
|
|
36622
|
+
if (visible.length <= 5) return "***";
|
|
36623
|
+
const atIndex = visible.indexOf("@");
|
|
36624
|
+
if (atIndex > 0 && atIndex < visible.length - 1) {
|
|
36625
|
+
const domain2 = visible.slice(atIndex + 1);
|
|
37125
36626
|
if (domain2.includes(".")) {
|
|
37126
|
-
const local =
|
|
36627
|
+
const local = visible.slice(0, atIndex);
|
|
37127
36628
|
const maskedLocal = local.length <= 1 ? local : local.charAt(0) + "*".repeat(local.length - 1);
|
|
37128
36629
|
return `${maskedLocal}@${domain2}`;
|
|
37129
36630
|
}
|
|
37130
36631
|
}
|
|
37131
|
-
return `${
|
|
36632
|
+
return `${visible.charAt(0)}${"*".repeat(6)}${visible.charAt(visible.length - 1)}`;
|
|
37132
36633
|
}
|
|
37133
36634
|
|
|
37134
36635
|
// ../../packages/detections/src/pointer-shield.ts
|
|
@@ -37390,7 +36891,12 @@ var MIN_RAW_LEN = 4;
|
|
|
37390
36891
|
var RAW_RUN_LEN = 8;
|
|
37391
36892
|
function carriesRawRun(text, rawValues) {
|
|
37392
36893
|
let windows = null;
|
|
37393
|
-
|
|
36894
|
+
const values = /* @__PURE__ */ new Set();
|
|
36895
|
+
for (const raw of rawValues) {
|
|
36896
|
+
values.add(raw);
|
|
36897
|
+
values.add(stripInvisiblePadding(raw));
|
|
36898
|
+
}
|
|
36899
|
+
for (const raw of values) {
|
|
37394
36900
|
if (raw.length < MIN_RAW_LEN) continue;
|
|
37395
36901
|
if (raw.length < RAW_RUN_LEN) {
|
|
37396
36902
|
if (text.includes(raw)) return true;
|
|
@@ -37414,11 +36920,16 @@ function carriesRawRun(text, rawValues) {
|
|
|
37414
36920
|
return false;
|
|
37415
36921
|
}
|
|
37416
36922
|
function safeMaskedMatch(rawMatch) {
|
|
37417
|
-
const
|
|
37418
|
-
|
|
37419
|
-
|
|
36923
|
+
const visible = stripInvisiblePadding(rawMatch);
|
|
36924
|
+
const masked = maskMatch(visible);
|
|
36925
|
+
const reveals = (preview) => preview === visible || visible.length >= MIN_RAW_LEN && preview.includes(visible);
|
|
36926
|
+
if (!reveals(masked)) return masked;
|
|
36927
|
+
const atIndex = masked.indexOf("@");
|
|
36928
|
+
if (atIndex > 0 && atIndex < masked.length - 1) {
|
|
36929
|
+
const emailFallback = `*${masked.slice(atIndex)}`;
|
|
36930
|
+
if (!reveals(emailFallback)) return emailFallback;
|
|
37420
36931
|
}
|
|
37421
|
-
return
|
|
36932
|
+
return "***";
|
|
37422
36933
|
}
|
|
37423
36934
|
function assertRawFree(text, rawValues) {
|
|
37424
36935
|
if (carriesRawRun(text, rawValues)) {
|
|
@@ -39860,6 +39371,11 @@ function bundledDetections() {
|
|
|
39860
39371
|
}));
|
|
39861
39372
|
return cachedDetections;
|
|
39862
39373
|
}
|
|
39374
|
+
function shippedRegexMatchers() {
|
|
39375
|
+
return bundledDetections().flatMap((pack) => pack.rules).flatMap(
|
|
39376
|
+
(rule) => rule.matcher.type === "regex" ? [{ pattern: rule.matcher.pattern, flags: rule.matcher.flags }] : []
|
|
39377
|
+
);
|
|
39378
|
+
}
|
|
39863
39379
|
function uniqueRuleIds(findings) {
|
|
39864
39380
|
return [...new Set(findings.map((f) => f.ruleId))].join(", ");
|
|
39865
39381
|
}
|
|
@@ -39884,13 +39400,14 @@ function bundledMaskingRules() {
|
|
|
39884
39400
|
}
|
|
39885
39401
|
|
|
39886
39402
|
// ../../packages/plugin-sdk/src/repo.ts
|
|
39887
|
-
import { existsSync as existsSync9, readFileSync as
|
|
39888
|
-
import { basename as basename2, dirname as dirname4, isAbsolute, join as
|
|
39403
|
+
import { existsSync as existsSync9, readFileSync as readFileSync11, statSync as statSync6 } from "fs";
|
|
39404
|
+
import { basename as basename2, dirname as dirname4, isAbsolute, join as join18, sep as sep2 } from "path";
|
|
39889
39405
|
var ATTRIBUTION_MEMO_LIMIT = 64;
|
|
39890
39406
|
var attributionMemo = /* @__PURE__ */ new Map();
|
|
39891
39407
|
var NO_ATTRIBUTION = Object.freeze({});
|
|
39892
|
-
function resolveRepoAttribution(cwd) {
|
|
39408
|
+
function resolveRepoAttribution(cwd, options) {
|
|
39893
39409
|
try {
|
|
39410
|
+
if (options?.cache === false) return attributeRepo(cwd);
|
|
39894
39411
|
const remembered = attributionMemo.get(cwd);
|
|
39895
39412
|
if (remembered !== void 0) return remembered;
|
|
39896
39413
|
const attribution = attributeRepo(cwd);
|
|
@@ -39914,36 +39431,36 @@ function attributeRepo(cwd) {
|
|
|
39914
39431
|
function findGitRoot(start) {
|
|
39915
39432
|
let dir = start;
|
|
39916
39433
|
for (; ; ) {
|
|
39917
|
-
if (existsSync9(
|
|
39434
|
+
if (existsSync9(join18(dir, ".git"))) return dir;
|
|
39918
39435
|
const parent = dirname4(dir);
|
|
39919
39436
|
if (parent === dir) return void 0;
|
|
39920
39437
|
dir = parent;
|
|
39921
39438
|
}
|
|
39922
39439
|
}
|
|
39923
39440
|
function resolveGitContext(root) {
|
|
39924
|
-
const dotGit =
|
|
39441
|
+
const dotGit = join18(root, ".git");
|
|
39925
39442
|
try {
|
|
39926
39443
|
if (statSync6(dotGit).isDirectory()) {
|
|
39927
|
-
return { configPath:
|
|
39444
|
+
return { configPath: join18(dotGit, "config"), headRoot: root };
|
|
39928
39445
|
}
|
|
39929
39446
|
} catch {
|
|
39930
39447
|
return void 0;
|
|
39931
39448
|
}
|
|
39932
39449
|
const target = /^gitdir:\s*(.+?)\s*$/m.exec(safeRead(dotGit) ?? "")?.[1];
|
|
39933
39450
|
if (!target) return void 0;
|
|
39934
|
-
const gitdir = isAbsolute(target) ? target :
|
|
39935
|
-
if (existsSync9(
|
|
39936
|
-
return { configPath:
|
|
39451
|
+
const gitdir = isAbsolute(target) ? target : join18(root, target);
|
|
39452
|
+
if (existsSync9(join18(gitdir, "config"))) {
|
|
39453
|
+
return { configPath: join18(gitdir, "config"), headRoot: root };
|
|
39937
39454
|
}
|
|
39938
|
-
const commonRaw = safeRead(
|
|
39455
|
+
const commonRaw = safeRead(join18(gitdir, "commondir"))?.trim();
|
|
39939
39456
|
if (!commonRaw) return void 0;
|
|
39940
|
-
const commonGitDir = isAbsolute(commonRaw) ? commonRaw :
|
|
39457
|
+
const commonGitDir = isAbsolute(commonRaw) ? commonRaw : join18(gitdir, commonRaw);
|
|
39941
39458
|
const headRoot = basename2(commonGitDir) === ".git" ? dirname4(commonGitDir) : root;
|
|
39942
|
-
return { configPath:
|
|
39459
|
+
return { configPath: join18(commonGitDir, "config"), headRoot };
|
|
39943
39460
|
}
|
|
39944
39461
|
function safeRead(path) {
|
|
39945
39462
|
try {
|
|
39946
|
-
return
|
|
39463
|
+
return readFileSync11(path, "utf8");
|
|
39947
39464
|
} catch {
|
|
39948
39465
|
return void 0;
|
|
39949
39466
|
}
|
|
@@ -39990,9 +39507,9 @@ function slugFromUrl(url2) {
|
|
|
39990
39507
|
}
|
|
39991
39508
|
|
|
39992
39509
|
// ../../packages/plugin-sdk/src/events.ts
|
|
39993
|
-
import { createHash as
|
|
39510
|
+
import { createHash as createHash6, randomUUID as randomUUID13 } from "crypto";
|
|
39994
39511
|
function contentHashOf(text) {
|
|
39995
|
-
return
|
|
39512
|
+
return createHash6("sha256").update(text).digest("hex");
|
|
39996
39513
|
}
|
|
39997
39514
|
function buildIngestEvent(input2) {
|
|
39998
39515
|
const contentHash = input2.contentHash ?? contentHashOf(input2.content);
|
|
@@ -40543,10 +40060,6 @@ function isPositiveSafeInteger(value) {
|
|
|
40543
40060
|
return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
|
|
40544
40061
|
}
|
|
40545
40062
|
|
|
40546
|
-
// ../../packages/plugin-sdk/src/host-floor.ts
|
|
40547
|
-
import { readFileSync as readFileSync14 } from "fs";
|
|
40548
|
-
import { join as join21 } from "path";
|
|
40549
|
-
|
|
40550
40063
|
// ../../packages/plugin-sdk/src/model-governance.ts
|
|
40551
40064
|
import {
|
|
40552
40065
|
closeSync as closeSync2,
|
|
@@ -40684,54 +40197,18 @@ function buildModelRefusalEvent(input2) {
|
|
|
40684
40197
|
};
|
|
40685
40198
|
}
|
|
40686
40199
|
|
|
40687
|
-
// ../../packages/plugin-sdk/src/host-floor.ts
|
|
40688
|
-
var HOST_FEATURE = {
|
|
40689
|
-
ModelSwitch: "model-switch",
|
|
40690
|
-
VaultPointerDisplay: "vault-pointer-display"
|
|
40691
|
-
};
|
|
40692
|
-
var HOST_FLOORS = {
|
|
40693
|
-
[HOST_FEATURE.ModelSwitch]: {
|
|
40694
|
-
label: "model-switch protection",
|
|
40695
|
-
hookEvents: ["PreModelSwitch", "PostModelSwitch"],
|
|
40696
|
-
since: "2.1.251"
|
|
40697
|
-
},
|
|
40698
|
-
[HOST_FEATURE.VaultPointerDisplay]: {
|
|
40699
|
-
label: "vault pointer display",
|
|
40700
|
-
hookEvents: ["MessageDisplay"],
|
|
40701
|
-
since: "2.1.152"
|
|
40702
|
-
}
|
|
40703
|
-
};
|
|
40704
|
-
var ANTIGRAVITY_HOST_FEATURE = {
|
|
40705
|
-
EndOfTurnCapture: "end-of-turn-capture"
|
|
40706
|
-
};
|
|
40707
|
-
var ANTIGRAVITY_HOST_FLOORS = {
|
|
40708
|
-
[ANTIGRAVITY_HOST_FEATURE.EndOfTurnCapture]: {
|
|
40709
|
-
label: "end-of-turn history capture",
|
|
40710
|
-
hookEvents: ["Stop"],
|
|
40711
|
-
since: "1.1.10"
|
|
40712
|
-
}
|
|
40713
|
-
};
|
|
40714
|
-
|
|
40715
|
-
// ../../packages/plugin-sdk/src/ignore-layers.ts
|
|
40716
|
-
var import_ignore = __toESM(require_ignore(), 1);
|
|
40717
|
-
import { readFileSync as readFileSync15 } from "fs";
|
|
40718
|
-
import { join as join22 } from "path";
|
|
40719
|
-
|
|
40720
|
-
// ../../packages/plugin-sdk/src/inventory-resolver.ts
|
|
40721
|
-
import { arch, hostname as hostname4, platform, release } from "os";
|
|
40722
|
-
|
|
40723
40200
|
// ../../packages/plugin-sdk/src/nudge.ts
|
|
40724
|
-
import { mkdirSync as mkdirSync3, readFileSync as
|
|
40725
|
-
import { join as
|
|
40201
|
+
import { mkdirSync as mkdirSync3, readFileSync as readFileSync14, writeFileSync as writeFileSync6 } from "fs";
|
|
40202
|
+
import { join as join21 } from "path";
|
|
40726
40203
|
var NUDGE_MARKER = "nudge-last-session";
|
|
40727
40204
|
function claimOnboardingNudge(dataDir2, sessionId) {
|
|
40728
40205
|
return claimOncePerSession(dataDir2, NUDGE_MARKER, sessionId);
|
|
40729
40206
|
}
|
|
40730
40207
|
function claimOncePerSession(dataDir2, marker, sessionId) {
|
|
40731
40208
|
if (!sessionId) return true;
|
|
40732
|
-
const path =
|
|
40209
|
+
const path = join21(dataDir2, marker);
|
|
40733
40210
|
try {
|
|
40734
|
-
if (
|
|
40211
|
+
if (readFileSync14(path, "utf8") === sessionId) return false;
|
|
40735
40212
|
} catch {
|
|
40736
40213
|
}
|
|
40737
40214
|
try {
|
|
@@ -40742,10 +40219,6 @@ function claimOncePerSession(dataDir2, marker, sessionId) {
|
|
|
40742
40219
|
return true;
|
|
40743
40220
|
}
|
|
40744
40221
|
|
|
40745
|
-
// ../../packages/plugin-sdk/src/paths.ts
|
|
40746
|
-
import { readdirSync as readdirSync3, realpathSync as realpathSync3 } from "fs";
|
|
40747
|
-
import { basename as basename4, dirname as dirname5, sep as sep3 } from "path";
|
|
40748
|
-
|
|
40749
40222
|
// ../../packages/plugin-sdk/src/policy-resolver.ts
|
|
40750
40223
|
import { randomUUID as randomUUID14 } from "crypto";
|
|
40751
40224
|
function createPolicyResolver(bundle) {
|
|
@@ -40790,36 +40263,6 @@ function assignedRulePolicies(installed) {
|
|
|
40790
40263
|
return out;
|
|
40791
40264
|
}
|
|
40792
40265
|
|
|
40793
|
-
// ../../packages/plugin-sdk/src/project-files.ts
|
|
40794
|
-
import { existsSync as existsSync11, readdirSync as readdirSync4 } from "fs";
|
|
40795
|
-
import { basename as basename5, join as join24 } from "path";
|
|
40796
|
-
|
|
40797
|
-
// ../../packages/plugin-sdk/src/provider-env-antigravity.ts
|
|
40798
|
-
var optionalBaseUrl2 = external_exports.preprocess((v) => {
|
|
40799
|
-
if (typeof v === "string" && v.trim() === "") return void 0;
|
|
40800
|
-
return v;
|
|
40801
|
-
}, external_exports.string().optional()).catch(void 0);
|
|
40802
|
-
var optionalFlag = external_exports.preprocess((v) => {
|
|
40803
|
-
if (typeof v !== "string") return false;
|
|
40804
|
-
const normalized = v.trim().toLowerCase();
|
|
40805
|
-
return normalized !== "" && normalized !== "0" && normalized !== "false";
|
|
40806
|
-
}, external_exports.boolean()).catch(false);
|
|
40807
|
-
var antigravityProviderEnvShape = {
|
|
40808
|
-
GOOGLE_GENAI_USE_VERTEXAI: optionalFlag,
|
|
40809
|
-
GOOGLE_GEMINI_BASE_URL: optionalBaseUrl2
|
|
40810
|
-
};
|
|
40811
|
-
var AntigravityProviderEnvSchema = external_exports.object(antigravityProviderEnvShape);
|
|
40812
|
-
|
|
40813
|
-
// ../../packages/plugin-sdk/src/provider-env-codex.ts
|
|
40814
|
-
var optionalBaseUrl3 = external_exports.preprocess((v) => {
|
|
40815
|
-
if (typeof v === "string" && v.trim() === "") return void 0;
|
|
40816
|
-
return v;
|
|
40817
|
-
}, external_exports.string().optional()).catch(void 0);
|
|
40818
|
-
var codexProviderEnvShape = {
|
|
40819
|
-
OPENAI_BASE_URL: optionalBaseUrl3
|
|
40820
|
-
};
|
|
40821
|
-
var CodexProviderEnvSchema = external_exports.object(codexProviderEnvShape);
|
|
40822
|
-
|
|
40823
40266
|
// ../../packages/plugin-sdk/src/runtime.ts
|
|
40824
40267
|
import { randomUUID as randomUUID15 } from "crypto";
|
|
40825
40268
|
var ENFORCEMENT_CEILING_ENABLED = false;
|
|
@@ -41106,12 +40549,11 @@ function createPluginRuntime(gateway, settings, opts) {
|
|
|
41106
40549
|
async function processText(text, context, opts2 = {}) {
|
|
41107
40550
|
return (await evaluate(text, context, {}, opts2.rewritable)).decision;
|
|
41108
40551
|
}
|
|
41109
|
-
async function
|
|
40552
|
+
async function evaluateCapture(input2, opts2) {
|
|
41110
40553
|
const timingStartedAt = input2.occurredAt === void 0 ? startTiming() : void 0;
|
|
41111
|
-
const filePath = input2.metadata?.filePath;
|
|
41112
40554
|
const { decision, excepted, exceptionIds } = await evaluate(
|
|
41113
40555
|
input2.text,
|
|
41114
|
-
{ filePath, eventKind: input2.kind },
|
|
40556
|
+
{ filePath: input2.metadata?.filePath, eventKind: input2.kind },
|
|
41115
40557
|
{
|
|
41116
40558
|
sourceTool: input2.sourceTool,
|
|
41117
40559
|
metadata: input2.metadata,
|
|
@@ -41119,7 +40561,11 @@ function createPluginRuntime(gateway, settings, opts) {
|
|
|
41119
40561
|
},
|
|
41120
40562
|
opts2.rewritable
|
|
41121
40563
|
);
|
|
41122
|
-
|
|
40564
|
+
return { decision, excepted, exceptionIds, timingStartedAt };
|
|
40565
|
+
}
|
|
40566
|
+
async function persistCapture(input2, opts2, { decision, excepted, exceptionIds, timingStartedAt }) {
|
|
40567
|
+
const filePath = input2.metadata?.filePath;
|
|
40568
|
+
if (opts2.persist === "with-findings" && decision.findings.length === 0) return;
|
|
41123
40569
|
try {
|
|
41124
40570
|
const contentHash = contentHashOf(input2.text);
|
|
41125
40571
|
const maskedFindings = decision.findings.filter(
|
|
@@ -41162,6 +40608,8 @@ function createPluginRuntime(gateway, settings, opts) {
|
|
|
41162
40608
|
// exceptions/blocked_detections when a key is available;
|
|
41163
40609
|
// falls back to the masked match so at-rest findings still get
|
|
41164
40610
|
// a stable (if weaker) identity on a workspace with no dataDir.
|
|
40611
|
+
// Both ignore the same invisible padding, so a clean and a
|
|
40612
|
+
// padded occurrence of one secret key alike on either path.
|
|
41165
40613
|
valueFingerprint: findingKeyFingerprintKey ? fingerprintOf(findingKeyFingerprintKey, match, findingKeyFpCache) : maskedMatch
|
|
41166
40614
|
}) : void 0;
|
|
41167
40615
|
return {
|
|
@@ -41189,7 +40637,37 @@ function createPluginRuntime(gateway, settings, opts) {
|
|
|
41189
40637
|
}
|
|
41190
40638
|
} catch {
|
|
41191
40639
|
}
|
|
41192
|
-
|
|
40640
|
+
}
|
|
40641
|
+
async function enforcedIn(text, context) {
|
|
40642
|
+
try {
|
|
40643
|
+
await ensureInitialized();
|
|
40644
|
+
if (!scanner) return [];
|
|
40645
|
+
const shielded = shieldPointers(text);
|
|
40646
|
+
const matched = await scanner.scan(shielded.text, context);
|
|
40647
|
+
return dropShieldedFindings(matched, shielded.spans).filter((finding) => {
|
|
40648
|
+
const action = resolveAction(finding.ruleId, finding.category);
|
|
40649
|
+
return action === "block" || action === "redact";
|
|
40650
|
+
});
|
|
40651
|
+
} catch {
|
|
40652
|
+
return [];
|
|
40653
|
+
}
|
|
40654
|
+
}
|
|
40655
|
+
async function capture(input2, opts2 = {}) {
|
|
40656
|
+
const evaluated = await evaluateCapture(input2, opts2);
|
|
40657
|
+
await persistCapture(input2, opts2, evaluated);
|
|
40658
|
+
return evaluated.decision;
|
|
40659
|
+
}
|
|
40660
|
+
async function captureDeferred(input2, opts2 = {}) {
|
|
40661
|
+
const evaluated = await evaluateCapture(input2, opts2);
|
|
40662
|
+
let recorded = false;
|
|
40663
|
+
return {
|
|
40664
|
+
result: evaluated.decision,
|
|
40665
|
+
record: async () => {
|
|
40666
|
+
if (recorded) return;
|
|
40667
|
+
recorded = true;
|
|
40668
|
+
await persistCapture(input2, opts2, evaluated);
|
|
40669
|
+
}
|
|
40670
|
+
};
|
|
41193
40671
|
}
|
|
41194
40672
|
async function rulesetFingerprint() {
|
|
41195
40673
|
try {
|
|
@@ -41210,20 +40688,17 @@ function createPluginRuntime(gateway, settings, opts) {
|
|
|
41210
40688
|
}
|
|
41211
40689
|
await gateway.close();
|
|
41212
40690
|
}
|
|
41213
|
-
return {
|
|
40691
|
+
return {
|
|
40692
|
+
processText,
|
|
40693
|
+
capture,
|
|
40694
|
+
captureDeferred,
|
|
40695
|
+
enforcedIn,
|
|
40696
|
+
rulesetFingerprint,
|
|
40697
|
+
scanIsolationDegraded,
|
|
40698
|
+
close
|
|
40699
|
+
};
|
|
41214
40700
|
}
|
|
41215
40701
|
|
|
41216
|
-
// ../../packages/plugin-sdk/src/scope-key.ts
|
|
41217
|
-
import { existsSync as existsSync12 } from "fs";
|
|
41218
|
-
import { dirname as dirname6, isAbsolute as isAbsolute2, join as join25, normalize } from "path";
|
|
41219
|
-
|
|
41220
|
-
// ../../packages/plugin-sdk/src/suppressions.ts
|
|
41221
|
-
var THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1e3;
|
|
41222
|
-
|
|
41223
|
-
// ../../packages/plugin-sdk/src/throttle.ts
|
|
41224
|
-
import { mkdirSync as mkdirSync4, statSync as statSync8, writeFileSync as writeFileSync7 } from "fs";
|
|
41225
|
-
import { join as join26 } from "path";
|
|
41226
|
-
|
|
41227
40702
|
// src/present.ts
|
|
41228
40703
|
var fg = (hex3) => (text) => {
|
|
41229
40704
|
const r = Number.parseInt(hex3.slice(1, 3), 16);
|
|
@@ -41272,125 +40747,7 @@ function exceptionPointer(references) {
|
|
|
41272
40747
|
}
|
|
41273
40748
|
|
|
41274
40749
|
// src/hooks/model-guard.ts
|
|
41275
|
-
import { randomUUID as
|
|
41276
|
-
|
|
41277
|
-
// src/hooks/shared.ts
|
|
41278
|
-
import { isAbsolute as isAbsolute3, normalize as normalize2, resolve as resolvePath } from "path";
|
|
41279
|
-
async function readStdin() {
|
|
41280
|
-
return new Promise((resolve3) => {
|
|
41281
|
-
let data = "";
|
|
41282
|
-
let settled = false;
|
|
41283
|
-
const finish = () => {
|
|
41284
|
-
if (settled) return;
|
|
41285
|
-
settled = true;
|
|
41286
|
-
clearTimeout(timer);
|
|
41287
|
-
process.stdin.removeListener("data", onData);
|
|
41288
|
-
process.stdin.removeListener("end", finish);
|
|
41289
|
-
resolve3(data);
|
|
41290
|
-
};
|
|
41291
|
-
const onData = (chunk) => {
|
|
41292
|
-
data += chunk;
|
|
41293
|
-
};
|
|
41294
|
-
const timer = setTimeout(finish, 5e3);
|
|
41295
|
-
process.stdin.setEncoding("utf8");
|
|
41296
|
-
process.stdin.on("data", onData);
|
|
41297
|
-
process.stdin.on("end", finish);
|
|
41298
|
-
process.stdin.on("error", finish);
|
|
41299
|
-
});
|
|
41300
|
-
}
|
|
41301
|
-
function parseJson(raw) {
|
|
41302
|
-
try {
|
|
41303
|
-
const parsed2 = JSON.parse(raw);
|
|
41304
|
-
return typeof parsed2 === "object" && parsed2 !== null ? parsed2 : null;
|
|
41305
|
-
} catch {
|
|
41306
|
-
return null;
|
|
41307
|
-
}
|
|
41308
|
-
}
|
|
41309
|
-
function getString(record2, key) {
|
|
41310
|
-
const value = record2[key];
|
|
41311
|
-
return typeof value === "string" ? value : void 0;
|
|
41312
|
-
}
|
|
41313
|
-
function emit(output2) {
|
|
41314
|
-
return new Promise((resolve3) => {
|
|
41315
|
-
let settled = false;
|
|
41316
|
-
const finish = () => {
|
|
41317
|
-
if (settled) return;
|
|
41318
|
-
settled = true;
|
|
41319
|
-
resolve3();
|
|
41320
|
-
};
|
|
41321
|
-
process.stdout.on("error", finish);
|
|
41322
|
-
process.stdout.write(JSON.stringify(output2), finish);
|
|
41323
|
-
});
|
|
41324
|
-
}
|
|
41325
|
-
function baseMetadata(input2) {
|
|
41326
|
-
const metadata = {};
|
|
41327
|
-
const sessionId = getString(input2, "session_id");
|
|
41328
|
-
if (sessionId) metadata.sessionId = sessionId;
|
|
41329
|
-
const repo = resolveRepoAttribution(getString(input2, "cwd") ?? process.cwd()).repo;
|
|
41330
|
-
if (repo) metadata.repo = repo;
|
|
41331
|
-
return Object.keys(metadata).length > 0 ? metadata : void 0;
|
|
41332
|
-
}
|
|
41333
|
-
function captureScopeKey(input2, filePath) {
|
|
41334
|
-
try {
|
|
41335
|
-
if (filePath === void 0 || filePath === "") {
|
|
41336
|
-
return resolveRepoAttribution(getString(input2, "cwd") ?? process.cwd()).scopeKey;
|
|
41337
|
-
}
|
|
41338
|
-
if (isAbsolute3(filePath)) return resolveRepoAttribution(normalize2(filePath)).scopeKey;
|
|
41339
|
-
const cwd = getString(input2, "cwd") ?? process.cwd();
|
|
41340
|
-
if (!isAbsolute3(cwd)) return void 0;
|
|
41341
|
-
return resolveRepoAttribution(resolvePath(cwd, filePath)).scopeKey;
|
|
41342
|
-
} catch {
|
|
41343
|
-
return void 0;
|
|
41344
|
-
}
|
|
41345
|
-
}
|
|
41346
|
-
function countFailOpen(base) {
|
|
41347
|
-
try {
|
|
41348
|
-
recordHookFailOpen(dataDir(base), Date.now());
|
|
41349
|
-
} catch {
|
|
41350
|
-
}
|
|
41351
|
-
}
|
|
41352
|
-
|
|
41353
|
-
// src/hooks/model-guard.ts
|
|
41354
|
-
function resolveCodexSessionModel(dataDir2, sessionId, transcriptPath) {
|
|
41355
|
-
return readSessionModel(dataDir2, sessionId) ?? modelFromTranscriptTail(transcriptPath, codexModelFromRecord);
|
|
41356
|
-
}
|
|
41357
|
-
async function refuseProhibitedTurn(gateway, dataDir2, sessionId, transcriptPath) {
|
|
41358
|
-
try {
|
|
41359
|
-
const { prohibitedModels } = await gateway.getPolicyBundle();
|
|
41360
|
-
if (prohibitedModels === void 0 || prohibitedModels.length === 0) return null;
|
|
41361
|
-
const model = resolveCodexSessionModel(dataDir2, sessionId, transcriptPath);
|
|
41362
|
-
const decision = decideProhibitedModelTurn(model, prohibitedModels);
|
|
41363
|
-
return decision === null || model === void 0 ? null : { decision, model };
|
|
41364
|
-
} catch {
|
|
41365
|
-
return null;
|
|
41366
|
-
}
|
|
41367
|
-
}
|
|
41368
|
-
async function handleProhibitedTurn(gateway, dataDir2, sessionId, transcriptPath, cwd, emit2) {
|
|
41369
|
-
const blocked = await refuseProhibitedTurn(gateway, dataDir2, sessionId, transcriptPath);
|
|
41370
|
-
if (blocked === null) return false;
|
|
41371
|
-
try {
|
|
41372
|
-
await gateway.recordAuditEvent(
|
|
41373
|
-
buildModelRefusalEvent({
|
|
41374
|
-
id: randomUUID16(),
|
|
41375
|
-
sessionId,
|
|
41376
|
-
model: blocked.model,
|
|
41377
|
-
seam: "turn",
|
|
41378
|
-
sourceTool: SOURCE_TOOL.Codex,
|
|
41379
|
-
occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
|
|
41380
|
-
// Total by contract, so it cannot cost the record it stamps.
|
|
41381
|
-
scopeKey: captureScopeKey({ cwd })
|
|
41382
|
-
})
|
|
41383
|
-
);
|
|
41384
|
-
} catch {
|
|
41385
|
-
}
|
|
41386
|
-
await gateway.close();
|
|
41387
|
-
await emit2(blocked.decision);
|
|
41388
|
-
return true;
|
|
41389
|
-
}
|
|
41390
|
-
|
|
41391
|
-
// src/hooks/store-health.ts
|
|
41392
|
-
import { mkdirSync as mkdirSync5, readFileSync as readFileSync21, writeFileSync as writeFileSync8 } from "fs";
|
|
41393
|
-
import { dirname as dirname8, join as join34 } from "path";
|
|
40750
|
+
import { randomUUID as randomUUID20 } from "crypto";
|
|
41394
40751
|
|
|
41395
40752
|
// ../../packages/remote/src/http.ts
|
|
41396
40753
|
import { request as httpRequest } from "http";
|
|
@@ -41768,11 +41125,11 @@ function withTimeout(promise2, ms) {
|
|
|
41768
41125
|
}
|
|
41769
41126
|
|
|
41770
41127
|
// ../../packages/plugin-runtime/src/attached/forward-drops.ts
|
|
41771
|
-
import { readFileSync as
|
|
41772
|
-
import { join as
|
|
41128
|
+
import { readFileSync as readFileSync15 } from "fs";
|
|
41129
|
+
import { join as join22 } from "path";
|
|
41773
41130
|
var FORWARD_DROPS_FILENAME = ATTACHED_FORWARD_DROPS_FILENAME;
|
|
41774
41131
|
function forwardDropsPath(dataDir2) {
|
|
41775
|
-
return
|
|
41132
|
+
return join22(dataDir2, FORWARD_DROPS_FILENAME);
|
|
41776
41133
|
}
|
|
41777
41134
|
function recordForwardDrops(dataDir2, count, nowMs) {
|
|
41778
41135
|
if (count <= 0) return;
|
|
@@ -41790,7 +41147,7 @@ function recordForwardDrops(dataDir2, count, nowMs) {
|
|
|
41790
41147
|
}
|
|
41791
41148
|
function readForwardDrops(dataDir2) {
|
|
41792
41149
|
try {
|
|
41793
|
-
const parsed2 = JSON.parse(
|
|
41150
|
+
const parsed2 = JSON.parse(readFileSync15(forwardDropsPath(dataDir2), "utf8"));
|
|
41794
41151
|
if (typeof parsed2 !== "object" || parsed2 === null) return null;
|
|
41795
41152
|
const record2 = parsed2;
|
|
41796
41153
|
if (typeof record2.droppedForwards !== "number" || !Number.isFinite(record2.droppedForwards)) {
|
|
@@ -41807,9 +41164,9 @@ function readForwardDrops(dataDir2) {
|
|
|
41807
41164
|
}
|
|
41808
41165
|
|
|
41809
41166
|
// ../../packages/plugin-runtime/src/attached/forward-policy.ts
|
|
41810
|
-
import { randomUUID as
|
|
41167
|
+
import { randomUUID as randomUUID16 } from "crypto";
|
|
41811
41168
|
import { readFile, rename, writeFile } from "fs/promises";
|
|
41812
|
-
import { join as
|
|
41169
|
+
import { join as join23 } from "path";
|
|
41813
41170
|
function isInvalidRequest(err) {
|
|
41814
41171
|
return typeof err === "object" && err !== null && err.name === "RemoteRequestInvalid";
|
|
41815
41172
|
}
|
|
@@ -41828,7 +41185,7 @@ var FORWARD_STATE_FILENAME = ATTACHED_FORWARD_STATE_FILENAME;
|
|
|
41828
41185
|
var STATE_FILENAME = FORWARD_STATE_FILENAME;
|
|
41829
41186
|
function createForwardPolicy(deps) {
|
|
41830
41187
|
const now = deps.now ?? (() => Date.now());
|
|
41831
|
-
const file2 =
|
|
41188
|
+
const file2 = join23(deps.dir, STATE_FILENAME);
|
|
41832
41189
|
let state = null;
|
|
41833
41190
|
let loading = null;
|
|
41834
41191
|
async function readState() {
|
|
@@ -41853,7 +41210,7 @@ function createForwardPolicy(deps) {
|
|
|
41853
41210
|
state = next;
|
|
41854
41211
|
try {
|
|
41855
41212
|
await ensureDataDir(deps.dir);
|
|
41856
|
-
const tmp = `${file2}.${
|
|
41213
|
+
const tmp = `${file2}.${randomUUID16()}.tmp`;
|
|
41857
41214
|
await writeFile(tmp, JSON.stringify(next), { encoding: "utf8", mode: DATA_FILE_MODE });
|
|
41858
41215
|
await rename(tmp, file2);
|
|
41859
41216
|
} catch {
|
|
@@ -41994,6 +41351,9 @@ var AttachedDataGateway = class {
|
|
|
41994
41351
|
*
|
|
41995
41352
|
* Machine mode answers before any key is read, so a machine attachment pays
|
|
41996
41353
|
* nothing for scoping and forwards exactly what it always has.
|
|
41354
|
+
*
|
|
41355
|
+
* `governanceAppliesTo` answers from this same verdict, so it agrees with
|
|
41356
|
+
* forwarding key for key.
|
|
41997
41357
|
*/
|
|
41998
41358
|
verdictFor(keyOf) {
|
|
41999
41359
|
try {
|
|
@@ -42010,24 +41370,27 @@ var AttachedDataGateway = class {
|
|
|
42010
41370
|
* the key its row holds in the local store, recorded per root (see
|
|
42011
41371
|
* `rootVerdict`), not the key on the root event just handed in: roots are
|
|
42012
41372
|
* first-write-wins in the store, so when two producers record a root for one
|
|
42013
|
-
* session (the session-start hook, then a reconcile pass) the second leaves
|
|
42014
|
-
*
|
|
42015
|
-
*
|
|
42016
|
-
*
|
|
42017
|
-
*
|
|
42018
|
-
*
|
|
42019
|
-
*
|
|
42020
|
-
*
|
|
42021
|
-
*
|
|
42022
|
-
*
|
|
42023
|
-
*
|
|
42024
|
-
*
|
|
42025
|
-
*
|
|
42026
|
-
*
|
|
42027
|
-
*
|
|
42028
|
-
*
|
|
42029
|
-
*
|
|
42030
|
-
*
|
|
41373
|
+
* session (the session-start hook, then a reconcile pass) the second leaves the
|
|
41374
|
+
* stored row as it was. That stored row, not this event, is what a history
|
|
41375
|
+
* drain pass would decide, if the root started before the attach; the drain
|
|
41376
|
+
* never offers one that started after it (`started_at < backlogBefore`).
|
|
41377
|
+
* Whether this root EVENT is itself sent takes both keys: the stored one AND
|
|
41378
|
+
* its own. The event's attributes (cwd, project, repo) describe where it was
|
|
41379
|
+
* recorded from, so a root event keyed to a personal directory is never sent
|
|
41380
|
+
* under an enrolled stored root, though the enrolled leaves still forward under
|
|
41381
|
+
* it: the instance that wrote the stored root is expected to have forwarded it.
|
|
41382
|
+
* If it did not (the root was written while standalone or under another
|
|
41383
|
+
* attachment, or its forward failed), the plane refuses those leaves. A root
|
|
41384
|
+
* that started before the attach is shipped, ahead of its leaves, by the
|
|
41385
|
+
* history drain; one that started after it is never offered by the drain. Any
|
|
41386
|
+
* other row with a root reference (`rootSessionId`, else `parentId`) forwards
|
|
41387
|
+
* only when its own key is in scope AND this instance recorded an in-scope
|
|
41388
|
+
* verdict for that root. The audit-event route has real foreign keys on both
|
|
41389
|
+
* columns and stubs no missing root, so a leaf sent after its root was kept
|
|
41390
|
+
* local is refused there, and a refused forward counts toward the breaker that
|
|
41391
|
+
* guards every other one. A root this instance never recorded is therefore
|
|
41392
|
+
* `'local'`: the only answer that cannot orphan a row. A row with no root
|
|
41393
|
+
* reference at all has nothing to orphan, and is decided by its own key.
|
|
42031
41394
|
*
|
|
42032
41395
|
* What this costs is stated rather than discovered. A session whose stored
|
|
42033
41396
|
* root is not keyed to an enrolled repository keeps its token and tool
|
|
@@ -42098,6 +41461,87 @@ var AttachedDataGateway = class {
|
|
|
42098
41461
|
return [];
|
|
42099
41462
|
}
|
|
42100
41463
|
}
|
|
41464
|
+
/**
|
|
41465
|
+
* The verdict for the repositories nested in a scanned project, answered
|
|
41466
|
+
* TOTALLY: `'forward'` or `'local'`, never a throw.
|
|
41467
|
+
*
|
|
41468
|
+
* A walk descends into a nested clone or submodule and folds its files into
|
|
41469
|
+
* the project it is walking, so one register can carry several
|
|
41470
|
+
* repositories' call sites under one project key. Each of them must be in
|
|
41471
|
+
* scope for it to forward. One key out of scope, or a nested repository with
|
|
41472
|
+
* no remote (an `undefined` key), keeps the whole register local.
|
|
41473
|
+
*
|
|
41474
|
+
* An ABSENT list is `'local'` too. Only the code that walked the tree can say
|
|
41475
|
+
* what is nested in it, and every scan passes the list, empty when nothing
|
|
41476
|
+
* is nested. A register nobody vouched for is not one a scoped attachment
|
|
41477
|
+
* may send.
|
|
41478
|
+
*
|
|
41479
|
+
* Machine mode answers before reading the context, so a machine attachment
|
|
41480
|
+
* forwards exactly what it always has.
|
|
41481
|
+
*/
|
|
41482
|
+
nestedVerdict(context) {
|
|
41483
|
+
try {
|
|
41484
|
+
if (this.deps.attachment.mode === "machine") return "forward";
|
|
41485
|
+
const keys = context?.nestedScopeKeys;
|
|
41486
|
+
if (keys === void 0) return "local";
|
|
41487
|
+
for (const key of keys) {
|
|
41488
|
+
if (this.verdictFor(() => key) === "local") return "local";
|
|
41489
|
+
}
|
|
41490
|
+
return "forward";
|
|
41491
|
+
} catch {
|
|
41492
|
+
return "local";
|
|
41493
|
+
}
|
|
41494
|
+
}
|
|
41495
|
+
/**
|
|
41496
|
+
* The register a scoped attachment sends, once the project and the repositories
|
|
41497
|
+
* nested in it are in scope: the register itself, with `reconcile.deletedFiles`
|
|
41498
|
+
* cut to the deleted paths whose own repository is in scope. `undefined` sends
|
|
41499
|
+
* nothing. TOTAL, like `verdictFor`, and for its reasons.
|
|
41500
|
+
*
|
|
41501
|
+
* The deletion sweep takes its paths from the scan ledger, not from the walk,
|
|
41502
|
+
* and the ledger holds every file the scanner ever read under the root, nested
|
|
41503
|
+
* clones' included. So a clone that was removed, or one an ignore file now
|
|
41504
|
+
* hides, is in no walk and never reaches `nestedVerdict`, yet its ledgered
|
|
41505
|
+
* paths come back as deleted. The scan names the repository of each deleted
|
|
41506
|
+
* path (`context.deletedFileKeys`, one entry per path in the register's order)
|
|
41507
|
+
* and each is held to the same verdict as any other key. A path whose key is
|
|
41508
|
+
* absent, or out of scope, is not sent.
|
|
41509
|
+
*
|
|
41510
|
+
* The list is asked for here, and only here: it is an async read of the scan
|
|
41511
|
+
* ledger that the scan makes on being called, so a machine attachment, which
|
|
41512
|
+
* returns before this, and a register already kept local never cause it.
|
|
41513
|
+
*
|
|
41514
|
+
* Anything the scan did not vouch for sends no deleted path, and the register
|
|
41515
|
+
* itself still goes: no list, a list that throws or whose read is rejected, or a
|
|
41516
|
+
* list whose length is not the register's. Deleting is the only thing a dropped
|
|
41517
|
+
* path could have done on the server, so the cost of a refusal is a stored row
|
|
41518
|
+
* that stays, never a path that leaves.
|
|
41519
|
+
*
|
|
41520
|
+
* Machine mode returns `input` itself, the same object and unread, so a machine
|
|
41521
|
+
* attachment's request is exactly what it was. A register that lists no deleted
|
|
41522
|
+
* path, or that is not a ledger register, has nothing to cut and is returned
|
|
41523
|
+
* as it came, with the list unread.
|
|
41524
|
+
*/
|
|
41525
|
+
async registerForWire(input2, context) {
|
|
41526
|
+
try {
|
|
41527
|
+
if (this.deps.attachment.mode === "machine") return input2;
|
|
41528
|
+
const { reconcile } = input2;
|
|
41529
|
+
if (reconcile.mode !== "ledger" || reconcile.deletedFiles.length === 0) return input2;
|
|
41530
|
+
const deleted = reconcile.deletedFiles;
|
|
41531
|
+
let kept = [];
|
|
41532
|
+
try {
|
|
41533
|
+
const keys = await context?.deletedFileKeys?.();
|
|
41534
|
+
if (keys?.length === deleted.length) {
|
|
41535
|
+
kept = deleted.filter((_path, at) => this.verdictFor(() => keys[at]) === "forward");
|
|
41536
|
+
}
|
|
41537
|
+
} catch {
|
|
41538
|
+
kept = [];
|
|
41539
|
+
}
|
|
41540
|
+
return { ...input2, reconcile: { ...reconcile, deletedFiles: kept } };
|
|
41541
|
+
} catch {
|
|
41542
|
+
return void 0;
|
|
41543
|
+
}
|
|
41544
|
+
}
|
|
42101
41545
|
/**
|
|
42102
41546
|
* The event `recordCapture` sends for a capture the verdict let through, or
|
|
42103
41547
|
* `undefined` to send nothing. TOTAL, like `verdictFor`, and for its reasons.
|
|
@@ -42423,12 +41867,24 @@ var AttachedDataGateway = class {
|
|
|
42423
41867
|
* payload onto the wire-boundary-safe shape (no snippet, hashed
|
|
42424
41868
|
* projectKey), and its result is discarded: `forward.run` never throws or
|
|
42425
41869
|
* rejects, so there is nothing here to act on.
|
|
41870
|
+
*
|
|
41871
|
+
* `context.nestedScopeKeys` is what the scanner knows and the register does
|
|
41872
|
+
* not say: the key of every repository nested below the scan root, whose
|
|
41873
|
+
* files the walk folded into this register. On a scoped attachment the
|
|
41874
|
+
* register is forwarded only when the project's own key AND every one of
|
|
41875
|
+
* those is in scope (see `nestedVerdict`), and its deleted paths are cut to the
|
|
41876
|
+
* ones whose own repository is in scope (`context.deletedFileKeys`, see
|
|
41877
|
+
* `registerForWire`). Machine mode never reads either, and the local write
|
|
41878
|
+
* never receives the context and gets the register whole.
|
|
42426
41879
|
*/
|
|
42427
|
-
async recordProjectEgress(input2) {
|
|
41880
|
+
async recordProjectEgress(input2, context) {
|
|
42428
41881
|
const summary = await this.deps.local.recordProjectEgress(input2);
|
|
42429
41882
|
if (this.verdictFor(() => scopeKeyOfProjectKey(input2.projectKey)) === "local") return summary;
|
|
41883
|
+
if (this.nestedVerdict(context) === "local") return summary;
|
|
41884
|
+
const register = await this.registerForWire(input2, context);
|
|
41885
|
+
if (register === void 0) return summary;
|
|
42430
41886
|
await this.deps.forward.run(
|
|
42431
|
-
() => this.deps.client.recordProjectEgress(toEgressIngestRequest(
|
|
41887
|
+
() => this.deps.client.recordProjectEgress(toEgressIngestRequest(register))
|
|
42432
41888
|
);
|
|
42433
41889
|
return summary;
|
|
42434
41890
|
}
|
|
@@ -42482,6 +41938,11 @@ var AttachedDataGateway = class {
|
|
|
42482
41938
|
async scanLedgerPaths() {
|
|
42483
41939
|
return this.deps.local.scanLedgerPaths();
|
|
42484
41940
|
}
|
|
41941
|
+
// Delegated, like the path list. An inner gateway that cannot say answers an
|
|
41942
|
+
// empty map, which gives every deleted path no key.
|
|
41943
|
+
async scanLedgerPathKeys() {
|
|
41944
|
+
return await this.deps.local.scanLedgerPathKeys?.() ?? /* @__PURE__ */ new Map();
|
|
41945
|
+
}
|
|
42485
41946
|
async recordScanned(entries) {
|
|
42486
41947
|
return this.deps.local.recordScanned(entries);
|
|
42487
41948
|
}
|
|
@@ -42548,6 +42009,12 @@ var AttachedDataGateway = class {
|
|
|
42548
42009
|
// and the spread above would otherwise drop the field silently — which is
|
|
42549
42010
|
// exactly what it did, leaving the whole control inert on every device
|
|
42550
42011
|
// while every test around it stayed green.
|
|
42012
|
+
//
|
|
42013
|
+
// WHOLE ON EVERY ATTACHMENT. A scoped attachment does not narrow the list
|
|
42014
|
+
// here: the port's `getPolicyBundle()` takes no event, and the runtime
|
|
42015
|
+
// reads this bundle once to build detection, so the detections it carries
|
|
42016
|
+
// apply to every event on the machine. Where a prohibition applies is
|
|
42017
|
+
// answered per event by `governanceAppliesTo` below.
|
|
42551
42018
|
prohibitedModels: cached2.prohibitedModels,
|
|
42552
42019
|
// NAMED for the same reason as the line above, and it is the same defect
|
|
42553
42020
|
// if it is not: `...local` above spreads the DEVICE's bundle, so a field
|
|
@@ -42607,6 +42074,30 @@ var AttachedDataGateway = class {
|
|
|
42607
42074
|
};
|
|
42608
42075
|
}
|
|
42609
42076
|
// ---------------------------------------------------------------------
|
|
42077
|
+
// GovernanceScope — where the organization's model policy applies
|
|
42078
|
+
// ---------------------------------------------------------------------
|
|
42079
|
+
/**
|
|
42080
|
+
* Whether the organization's governance applies to an event keyed `scopeKey`:
|
|
42081
|
+
* the question a model-guard site asks once it has decided to refuse.
|
|
42082
|
+
*
|
|
42083
|
+
* THE FORWARD VERDICT, through `verdictFor`: the answer is whether a capture
|
|
42084
|
+
* with the same key would be forwarded. A machine-wide attachment governs
|
|
42085
|
+
* every event, keyless included, exactly as before. A scoped one governs an
|
|
42086
|
+
* event only when its key names an enrolled repository. An event in a
|
|
42087
|
+
* personal repository, in no repository, with an empty key, or met by a fault
|
|
42088
|
+
* is not governed.
|
|
42089
|
+
*
|
|
42090
|
+
* The event's OWN key, never its session root's. The root rule in
|
|
42091
|
+
* `auditVerdict` decides whether a row can be forwarded without orphaning it;
|
|
42092
|
+
* this decides whether a refusal applies, which is a question about where the
|
|
42093
|
+
* event happened.
|
|
42094
|
+
*
|
|
42095
|
+
* Answered from memory: no store read, no bundle read, nothing sent.
|
|
42096
|
+
*/
|
|
42097
|
+
governanceAppliesTo(scopeKey) {
|
|
42098
|
+
return this.verdictFor(() => scopeKey) === "forward";
|
|
42099
|
+
}
|
|
42100
|
+
// ---------------------------------------------------------------------
|
|
42610
42101
|
// LocalStoreMaintenance — by delegation (D3).
|
|
42611
42102
|
//
|
|
42612
42103
|
// Implementing these is what actually closes the skipped-local-maintenance
|
|
@@ -42715,8 +42206,8 @@ function toWireInspection(insp) {
|
|
|
42715
42206
|
}
|
|
42716
42207
|
|
|
42717
42208
|
// ../../packages/plugin-runtime/src/attached/history-sync.ts
|
|
42718
|
-
import { createHash as
|
|
42719
|
-
import { hostname as
|
|
42209
|
+
import { createHash as createHash7 } from "crypto";
|
|
42210
|
+
import { hostname as hostname4 } from "os";
|
|
42720
42211
|
|
|
42721
42212
|
// ../../packages/plugin-runtime/src/attached/capture-rebuild.ts
|
|
42722
42213
|
var CORRELATION_ID = EventMetadata.shape.correlationId;
|
|
@@ -42734,17 +42225,17 @@ var HISTORY_SYNC_THROTTLE_MS = 5 * 60 * 1e3;
|
|
|
42734
42225
|
|
|
42735
42226
|
// ../../packages/plugin-runtime/src/attached/install-record.ts
|
|
42736
42227
|
import { readFile as readFile2, stat } from "fs/promises";
|
|
42737
|
-
import { basename as
|
|
42228
|
+
import { basename as basename3, dirname as dirname5, join as join24, resolve as resolve2 } from "path";
|
|
42738
42229
|
async function readInstalledVersion(installRoot) {
|
|
42739
42230
|
try {
|
|
42740
42231
|
const versionDir = resolve2(installRoot);
|
|
42741
|
-
const pluginDir =
|
|
42742
|
-
const marketplaceDir =
|
|
42743
|
-
const cacheDir =
|
|
42744
|
-
if (
|
|
42745
|
-
const key = `${
|
|
42232
|
+
const pluginDir = dirname5(versionDir);
|
|
42233
|
+
const marketplaceDir = dirname5(pluginDir);
|
|
42234
|
+
const cacheDir = dirname5(marketplaceDir);
|
|
42235
|
+
if (basename3(cacheDir) !== "cache") return null;
|
|
42236
|
+
const key = `${basename3(pluginDir)}@${basename3(marketplaceDir)}`;
|
|
42746
42237
|
const record2 = JSON.parse(
|
|
42747
|
-
await readFile2(
|
|
42238
|
+
await readFile2(join24(dirname5(cacheDir), "installed_plugins.json"), "utf8")
|
|
42748
42239
|
);
|
|
42749
42240
|
const plugins = record2?.plugins;
|
|
42750
42241
|
if (typeof plugins !== "object" || plugins === null || !Object.hasOwn(plugins, key)) {
|
|
@@ -42776,7 +42267,7 @@ async function exists(path) {
|
|
|
42776
42267
|
}
|
|
42777
42268
|
|
|
42778
42269
|
// ../../packages/plugin-runtime/src/attached/plugin-block.ts
|
|
42779
|
-
import { readFileSync as
|
|
42270
|
+
import { readFileSync as readFileSync16 } from "fs";
|
|
42780
42271
|
var INSTALL_RECORD_READ_TIMEOUT_MS = REQUEST_TIMEOUT_MS / 2;
|
|
42781
42272
|
function createPluginBlock(build, policyStore) {
|
|
42782
42273
|
return async () => {
|
|
@@ -42804,9 +42295,9 @@ async function readInstalledVersionBounded(installRoot) {
|
|
|
42804
42295
|
}
|
|
42805
42296
|
|
|
42806
42297
|
// ../../packages/plugin-runtime/src/attached/policy-store.ts
|
|
42807
|
-
import { randomUUID as
|
|
42298
|
+
import { randomUUID as randomUUID17 } from "crypto";
|
|
42808
42299
|
import { readFile as readFile3, rm, writeFile as writeFile2 } from "fs/promises";
|
|
42809
|
-
import { join as
|
|
42300
|
+
import { join as join25 } from "path";
|
|
42810
42301
|
|
|
42811
42302
|
// ../../packages/plugin-runtime/src/attached/atomic-publish.ts
|
|
42812
42303
|
import { rename as rename2 } from "fs/promises";
|
|
@@ -42835,7 +42326,7 @@ async function publishByRename(tmp, file2, move = rename2) {
|
|
|
42835
42326
|
|
|
42836
42327
|
// ../../packages/plugin-runtime/src/attached/policy-store.ts
|
|
42837
42328
|
function createPolicyStore(dir = dataDir()) {
|
|
42838
|
-
const file2 =
|
|
42329
|
+
const file2 = join25(dir, "policy-cache.json");
|
|
42839
42330
|
async function read() {
|
|
42840
42331
|
try {
|
|
42841
42332
|
const raw = await readFile3(file2, "utf8");
|
|
@@ -42867,7 +42358,7 @@ function createPolicyStore(dir = dataDir()) {
|
|
|
42867
42358
|
}
|
|
42868
42359
|
}
|
|
42869
42360
|
async function publishRecord(record2) {
|
|
42870
|
-
const tmp = `${file2}.${
|
|
42361
|
+
const tmp = `${file2}.${randomUUID17()}.tmp`;
|
|
42871
42362
|
try {
|
|
42872
42363
|
await writeFile2(tmp, JSON.stringify(record2), {
|
|
42873
42364
|
encoding: "utf8",
|
|
@@ -42905,8 +42396,8 @@ function createPolicyStore(dir = dataDir()) {
|
|
|
42905
42396
|
}
|
|
42906
42397
|
|
|
42907
42398
|
// ../../packages/plugin-runtime/src/attached/posture-report-state.ts
|
|
42908
|
-
import { readFileSync as
|
|
42909
|
-
import { join as
|
|
42399
|
+
import { readFileSync as readFileSync17 } from "fs";
|
|
42400
|
+
import { join as join26 } from "path";
|
|
42910
42401
|
var POSTURE_REPORT_STATE_FILENAME = ATTACHED_POSTURE_REPORT_FILENAME;
|
|
42911
42402
|
var OUTCOME_KEYS = {
|
|
42912
42403
|
ok: true,
|
|
@@ -42920,7 +42411,7 @@ var OUTCOME_KEYS = {
|
|
|
42920
42411
|
};
|
|
42921
42412
|
var OUTCOMES = new Set(Object.keys(OUTCOME_KEYS));
|
|
42922
42413
|
function postureReportStatePath(dataDir2) {
|
|
42923
|
-
return
|
|
42414
|
+
return join26(dataDir2, POSTURE_REPORT_STATE_FILENAME);
|
|
42924
42415
|
}
|
|
42925
42416
|
function writePostureReportState(dataDir2, state) {
|
|
42926
42417
|
try {
|
|
@@ -42961,10 +42452,19 @@ function createPostureReporter(deps) {
|
|
|
42961
42452
|
hostname: deps.hostname(),
|
|
42962
42453
|
capturedAt: nowMs,
|
|
42963
42454
|
...measurement,
|
|
42964
|
-
// Omit the key rather than spread an explicit `undefined
|
|
42965
|
-
//
|
|
42966
|
-
//
|
|
42967
|
-
|
|
42455
|
+
// Omit the key rather than spread an explicit `undefined`. The type
|
|
42456
|
+
// admits `undefined` here (the schema's optional member), and
|
|
42457
|
+
// JSON.stringify sends the same bytes either way. Omitting keeps the
|
|
42458
|
+
// in-memory object free of an explicit `undefined` member, which the
|
|
42459
|
+
// tests pin by key presence.
|
|
42460
|
+
...plugin === void 0 ? {} : { plugin },
|
|
42461
|
+
// LAST, and only for a scoped attachment. A machine attachment omits
|
|
42462
|
+
// the key the same way, so its body is byte for byte the one it sent
|
|
42463
|
+
// before the member existed. Anything but exactly `machine` reports the
|
|
42464
|
+
// constant `scoped`, never the raw value: that is resolveScope's own
|
|
42465
|
+
// fail direction, and a value outside the wire's vocabulary would fail
|
|
42466
|
+
// the whole snapshot at the receiver, the wipe signal with it.
|
|
42467
|
+
...deps.attachmentMode === "machine" ? {} : { attachmentMode: "scoped" }
|
|
42968
42468
|
};
|
|
42969
42469
|
} catch {
|
|
42970
42470
|
return null;
|
|
@@ -42987,8 +42487,8 @@ function createPostureReporter(deps) {
|
|
|
42987
42487
|
}
|
|
42988
42488
|
|
|
42989
42489
|
// ../../packages/plugin-runtime/src/attached/posture-snapshot.ts
|
|
42990
|
-
import { statSync as
|
|
42991
|
-
import { DatabaseSync as
|
|
42490
|
+
import { statSync as statSync7 } from "fs";
|
|
42491
|
+
import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
|
|
42992
42492
|
|
|
42993
42493
|
// ../../packages/plugin-runtime/src/attached/action-counts.ts
|
|
42994
42494
|
function emptyActionCounts() {
|
|
@@ -43018,7 +42518,7 @@ function emptyReadout(readError = false) {
|
|
|
43018
42518
|
}
|
|
43019
42519
|
function readStorePosture(dbPath2) {
|
|
43020
42520
|
try {
|
|
43021
|
-
|
|
42521
|
+
statSync7(dbPath2);
|
|
43022
42522
|
} catch (err) {
|
|
43023
42523
|
const code = err.code;
|
|
43024
42524
|
if (code === "ENOENT" || code === "ENOTDIR") return emptyReadout();
|
|
@@ -43046,7 +42546,7 @@ function readStorePosture(dbPath2) {
|
|
|
43046
42546
|
readError: false
|
|
43047
42547
|
});
|
|
43048
42548
|
try {
|
|
43049
|
-
db = new
|
|
42549
|
+
db = new DatabaseSync3(dbPath2, { readOnly: true });
|
|
43050
42550
|
db.exec("PRAGMA busy_timeout = 2000");
|
|
43051
42551
|
version2 = db.prepare("PRAGMA user_version").get().user_version;
|
|
43052
42552
|
try {
|
|
@@ -43098,16 +42598,16 @@ function readStorePosture(dbPath2) {
|
|
|
43098
42598
|
}
|
|
43099
42599
|
|
|
43100
42600
|
// ../../packages/plugin-runtime/src/attached/posture-store.ts
|
|
43101
|
-
import { randomUUID as
|
|
42601
|
+
import { randomUUID as randomUUID18 } from "crypto";
|
|
43102
42602
|
import { readFile as readFile4, rm as rm2, writeFile as writeFile3 } from "fs/promises";
|
|
43103
|
-
import { join as
|
|
42603
|
+
import { join as join27 } from "path";
|
|
43104
42604
|
var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
|
|
43105
42605
|
function createPostureStore(dir = settingsDir(), legacyDir) {
|
|
43106
|
-
const file2 =
|
|
43107
|
-
const legacyFile = legacyDir === void 0 ? null :
|
|
42606
|
+
const file2 = join27(dir, "posture-state.json");
|
|
42607
|
+
const legacyFile = legacyDir === void 0 ? null : join27(legacyDir, "posture-state.json");
|
|
43108
42608
|
async function persist(state) {
|
|
43109
42609
|
await ensureDataDir(dir);
|
|
43110
|
-
const tmp = `${file2}.${
|
|
42610
|
+
const tmp = `${file2}.${randomUUID18()}.tmp`;
|
|
43111
42611
|
try {
|
|
43112
42612
|
await writeFile3(tmp, JSON.stringify(state), { encoding: "utf8", mode: DATA_FILE_MODE });
|
|
43113
42613
|
await publishByRename(tmp, file2);
|
|
@@ -43149,7 +42649,7 @@ function createPostureStore(dir = settingsDir(), legacyDir) {
|
|
|
43149
42649
|
}
|
|
43150
42650
|
return legacy;
|
|
43151
42651
|
}
|
|
43152
|
-
const fresh = { deviceId:
|
|
42652
|
+
const fresh = { deviceId: randomUUID18(), lastAttemptedAtMs: 0 };
|
|
43153
42653
|
try {
|
|
43154
42654
|
await ensureDataDir(dir);
|
|
43155
42655
|
if (createOwnerOnlyFileSync(file2, JSON.stringify(fresh))) return fresh;
|
|
@@ -43172,8 +42672,8 @@ function createPostureStore(dir = settingsDir(), legacyDir) {
|
|
|
43172
42672
|
}
|
|
43173
42673
|
|
|
43174
42674
|
// ../../packages/plugin-runtime/src/attached/sync-state.ts
|
|
43175
|
-
import { readFileSync as
|
|
43176
|
-
import { join as
|
|
42675
|
+
import { readFileSync as readFileSync18 } from "fs";
|
|
42676
|
+
import { join as join28 } from "path";
|
|
43177
42677
|
|
|
43178
42678
|
// ../../packages/plugin-runtime/src/attached/status.ts
|
|
43179
42679
|
var REFUSAL_LINES = {
|
|
@@ -43202,8 +42702,22 @@ import { spawn as spawn3 } from "child_process";
|
|
|
43202
42702
|
import { fileURLToPath as fileURLToPath4 } from "url";
|
|
43203
42703
|
var CONTENT_RETENTION_THROTTLE_MS = 60 * 60 * 1e3;
|
|
43204
42704
|
|
|
42705
|
+
// ../../packages/plugin-runtime/src/governance-scope.ts
|
|
42706
|
+
function offersGovernanceScope(gateway) {
|
|
42707
|
+
return typeof gateway.governanceAppliesTo === "function";
|
|
42708
|
+
}
|
|
42709
|
+
function governanceApplies(gateway, scopeKey) {
|
|
42710
|
+
try {
|
|
42711
|
+
if (!offersGovernanceScope(gateway)) return true;
|
|
42712
|
+
const answer = gateway.governanceAppliesTo(scopeKey);
|
|
42713
|
+
return answer === true;
|
|
42714
|
+
} catch {
|
|
42715
|
+
return false;
|
|
42716
|
+
}
|
|
42717
|
+
}
|
|
42718
|
+
|
|
43205
42719
|
// ../../packages/plugin-runtime/src/attached/factory.ts
|
|
43206
|
-
import { hostname as
|
|
42720
|
+
import { hostname as hostname5 } from "os";
|
|
43207
42721
|
|
|
43208
42722
|
// ../../packages/plugin-runtime/src/recorder.ts
|
|
43209
42723
|
var PLUGIN_RECORDER_BINARY = "plugin";
|
|
@@ -43216,7 +42730,7 @@ var StandaloneDataGateway = class {
|
|
|
43216
42730
|
// One notice per gateway — see warnRulesetDiscarded.
|
|
43217
42731
|
warnedRulesetDiscarded = false;
|
|
43218
42732
|
constructor(dataDir2, detections = [], meta4) {
|
|
43219
|
-
this.db = openLocalDatabase(dataDir2);
|
|
42733
|
+
this.db = openLocalDatabase(dataDir2, { shippedRegexMatchers: shippedRegexMatchers() });
|
|
43220
42734
|
this.dataDir = dataDir2;
|
|
43221
42735
|
this.db.installedPacks.recordInventory(detections, meta4);
|
|
43222
42736
|
}
|
|
@@ -43565,6 +43079,9 @@ var StandaloneDataGateway = class {
|
|
|
43565
43079
|
scanLedgerPaths() {
|
|
43566
43080
|
return Promise.resolve(this.db.scanLedger.allPaths());
|
|
43567
43081
|
}
|
|
43082
|
+
scanLedgerPathKeys() {
|
|
43083
|
+
return Promise.resolve(this.db.scanLedger.pathKeys());
|
|
43084
|
+
}
|
|
43568
43085
|
recordScanned(entries) {
|
|
43569
43086
|
this.db.scanLedger.upsertEntries(entries);
|
|
43570
43087
|
return Promise.resolve();
|
|
@@ -43650,13 +43167,17 @@ function resolveGatewayForConfig(config2, meta4) {
|
|
|
43650
43167
|
},
|
|
43651
43168
|
store: postureStore,
|
|
43652
43169
|
readStore: () => readStorePosture(config2.dbPath),
|
|
43653
|
-
hostname: () =>
|
|
43170
|
+
hostname: () => hostname5(),
|
|
43654
43171
|
now: () => Date.now(),
|
|
43172
|
+
// The mode THIS gateway enforces, from the attachment resolved above,
|
|
43173
|
+
// so the report cannot name a mode the forward paths are not using.
|
|
43174
|
+
attachmentMode: attachment.mode,
|
|
43655
43175
|
// The reporting build's identity, when the caller knows it (the plugin
|
|
43656
43176
|
// adapters do; an embedder or a test may not). Composed with the SAME
|
|
43657
43177
|
// policy store the sync child writes, so the block names the bundle
|
|
43658
|
-
// actually in force.
|
|
43659
|
-
// reporter
|
|
43178
|
+
// actually in force. The dependency key is omitted when no build is
|
|
43179
|
+
// known, and the reporter's optional call (`deps.pluginBlock?.()`)
|
|
43180
|
+
// then adds no block.
|
|
43660
43181
|
...meta4?.pluginBuild === void 0 ? {} : { pluginBlock: createPluginBlock(meta4.pluginBuild, store) }
|
|
43661
43182
|
})
|
|
43662
43183
|
});
|
|
@@ -43673,10 +43194,127 @@ function resolveDataGateway(config2, meta4, gatewayFactory = defaultGatewayFacto
|
|
|
43673
43194
|
}
|
|
43674
43195
|
|
|
43675
43196
|
// ../../packages/plugin-runtime/src/handle-session-start.ts
|
|
43676
|
-
import { randomUUID as
|
|
43197
|
+
import { randomUUID as randomUUID19 } from "crypto";
|
|
43677
43198
|
var EXCEPTION_RETENTION_MS = 90 * 24 * 60 * 60 * 1e3;
|
|
43678
43199
|
|
|
43200
|
+
// src/hooks/shared.ts
|
|
43201
|
+
import { isAbsolute as isAbsolute2, normalize, resolve as resolvePath } from "path";
|
|
43202
|
+
async function readStdin() {
|
|
43203
|
+
return new Promise((resolve3) => {
|
|
43204
|
+
let data = "";
|
|
43205
|
+
let settled = false;
|
|
43206
|
+
const finish = () => {
|
|
43207
|
+
if (settled) return;
|
|
43208
|
+
settled = true;
|
|
43209
|
+
clearTimeout(timer);
|
|
43210
|
+
process.stdin.removeListener("data", onData);
|
|
43211
|
+
process.stdin.removeListener("end", finish);
|
|
43212
|
+
resolve3(data);
|
|
43213
|
+
};
|
|
43214
|
+
const onData = (chunk) => {
|
|
43215
|
+
data += chunk;
|
|
43216
|
+
};
|
|
43217
|
+
const timer = setTimeout(finish, 5e3);
|
|
43218
|
+
process.stdin.setEncoding("utf8");
|
|
43219
|
+
process.stdin.on("data", onData);
|
|
43220
|
+
process.stdin.on("end", finish);
|
|
43221
|
+
process.stdin.on("error", finish);
|
|
43222
|
+
});
|
|
43223
|
+
}
|
|
43224
|
+
function parseJson(raw) {
|
|
43225
|
+
try {
|
|
43226
|
+
const parsed2 = JSON.parse(raw);
|
|
43227
|
+
return typeof parsed2 === "object" && parsed2 !== null ? parsed2 : null;
|
|
43228
|
+
} catch {
|
|
43229
|
+
return null;
|
|
43230
|
+
}
|
|
43231
|
+
}
|
|
43232
|
+
function getString(record2, key) {
|
|
43233
|
+
const value = record2[key];
|
|
43234
|
+
return typeof value === "string" ? value : void 0;
|
|
43235
|
+
}
|
|
43236
|
+
function emit(output2) {
|
|
43237
|
+
return new Promise((resolve3) => {
|
|
43238
|
+
let settled = false;
|
|
43239
|
+
const finish = () => {
|
|
43240
|
+
if (settled) return;
|
|
43241
|
+
settled = true;
|
|
43242
|
+
resolve3();
|
|
43243
|
+
};
|
|
43244
|
+
process.stdout.on("error", finish);
|
|
43245
|
+
process.stdout.write(JSON.stringify(output2), finish);
|
|
43246
|
+
});
|
|
43247
|
+
}
|
|
43248
|
+
function baseMetadata(input2) {
|
|
43249
|
+
const metadata = {};
|
|
43250
|
+
const sessionId = getString(input2, "session_id");
|
|
43251
|
+
if (sessionId) metadata.sessionId = sessionId;
|
|
43252
|
+
const repo = resolveRepoAttribution(getString(input2, "cwd") ?? process.cwd()).repo;
|
|
43253
|
+
if (repo) metadata.repo = repo;
|
|
43254
|
+
return Object.keys(metadata).length > 0 ? metadata : void 0;
|
|
43255
|
+
}
|
|
43256
|
+
function captureScopeKey(input2, filePath) {
|
|
43257
|
+
try {
|
|
43258
|
+
if (filePath === void 0 || filePath === "") {
|
|
43259
|
+
return resolveRepoAttribution(getString(input2, "cwd") ?? process.cwd()).scopeKey;
|
|
43260
|
+
}
|
|
43261
|
+
if (isAbsolute2(filePath)) return resolveRepoAttribution(normalize(filePath)).scopeKey;
|
|
43262
|
+
const cwd = getString(input2, "cwd") ?? process.cwd();
|
|
43263
|
+
if (!isAbsolute2(cwd)) return void 0;
|
|
43264
|
+
return resolveRepoAttribution(resolvePath(cwd, filePath)).scopeKey;
|
|
43265
|
+
} catch {
|
|
43266
|
+
return void 0;
|
|
43267
|
+
}
|
|
43268
|
+
}
|
|
43269
|
+
function countFailOpen(base) {
|
|
43270
|
+
try {
|
|
43271
|
+
recordHookFailOpen(dataDir(base), Date.now());
|
|
43272
|
+
} catch {
|
|
43273
|
+
}
|
|
43274
|
+
}
|
|
43275
|
+
|
|
43276
|
+
// src/hooks/model-guard.ts
|
|
43277
|
+
function resolveCodexSessionModel(dataDir2, sessionId, transcriptPath) {
|
|
43278
|
+
return readSessionModel(dataDir2, sessionId) ?? modelFromTranscriptTail(transcriptPath, codexModelFromRecord);
|
|
43279
|
+
}
|
|
43280
|
+
async function refuseProhibitedTurn(gateway, dataDir2, sessionId, transcriptPath) {
|
|
43281
|
+
try {
|
|
43282
|
+
const { prohibitedModels } = await gateway.getPolicyBundle();
|
|
43283
|
+
if (prohibitedModels === void 0 || prohibitedModels.length === 0) return null;
|
|
43284
|
+
const model = resolveCodexSessionModel(dataDir2, sessionId, transcriptPath);
|
|
43285
|
+
const decision = decideProhibitedModelTurn(model, prohibitedModels);
|
|
43286
|
+
return decision === null || model === void 0 ? null : { decision, model };
|
|
43287
|
+
} catch {
|
|
43288
|
+
return null;
|
|
43289
|
+
}
|
|
43290
|
+
}
|
|
43291
|
+
async function handleProhibitedTurn(gateway, dataDir2, sessionId, transcriptPath, cwd, emit2) {
|
|
43292
|
+
const blocked = await refuseProhibitedTurn(gateway, dataDir2, sessionId, transcriptPath);
|
|
43293
|
+
if (blocked === null) return false;
|
|
43294
|
+
const scopeKey = captureScopeKey({ cwd });
|
|
43295
|
+
if (!governanceApplies(gateway, scopeKey)) return false;
|
|
43296
|
+
try {
|
|
43297
|
+
await gateway.recordAuditEvent(
|
|
43298
|
+
buildModelRefusalEvent({
|
|
43299
|
+
id: randomUUID20(),
|
|
43300
|
+
sessionId,
|
|
43301
|
+
model: blocked.model,
|
|
43302
|
+
seam: "turn",
|
|
43303
|
+
sourceTool: SOURCE_TOOL.Codex,
|
|
43304
|
+
occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
|
|
43305
|
+
scopeKey
|
|
43306
|
+
})
|
|
43307
|
+
);
|
|
43308
|
+
} catch {
|
|
43309
|
+
}
|
|
43310
|
+
await gateway.close();
|
|
43311
|
+
await emit2(blocked.decision);
|
|
43312
|
+
return true;
|
|
43313
|
+
}
|
|
43314
|
+
|
|
43679
43315
|
// src/hooks/store-health.ts
|
|
43316
|
+
import { mkdirSync as mkdirSync4, readFileSync as readFileSync19, writeFileSync as writeFileSync7 } from "fs";
|
|
43317
|
+
import { dirname as dirname6, join as join29 } from "path";
|
|
43680
43318
|
var STORE_WARNING_MARKER = "store-warning-last-session";
|
|
43681
43319
|
var STORE_REDIRECT_MARKER = "store-redirect-last-session";
|
|
43682
43320
|
function openGateway(config2) {
|
|
@@ -43703,12 +43341,12 @@ function claimStoreUnavailableWarning(dataDir2, sessionId) {
|
|
|
43703
43341
|
return true;
|
|
43704
43342
|
}
|
|
43705
43343
|
function markerDirs(dataDir2) {
|
|
43706
|
-
return [dataDir2,
|
|
43344
|
+
return [dataDir2, dirname6(dataDir2)];
|
|
43707
43345
|
}
|
|
43708
43346
|
function alreadyClaimed(dirs, marker, sessionId) {
|
|
43709
43347
|
return dirs.some((dir) => {
|
|
43710
43348
|
try {
|
|
43711
|
-
return
|
|
43349
|
+
return readFileSync19(join29(dir, marker), "utf8") === sessionId;
|
|
43712
43350
|
} catch {
|
|
43713
43351
|
return false;
|
|
43714
43352
|
}
|
|
@@ -43717,14 +43355,14 @@ function alreadyClaimed(dirs, marker, sessionId) {
|
|
|
43717
43355
|
function recordClaim(dirs, marker, sessionId) {
|
|
43718
43356
|
for (const dir of dirs) {
|
|
43719
43357
|
try {
|
|
43720
|
-
|
|
43721
|
-
|
|
43358
|
+
mkdirSync4(dir, { recursive: true, mode: DATA_DIR_MODE });
|
|
43359
|
+
writeFileSync7(join29(dir, marker), sessionId, { mode: DATA_FILE_MODE });
|
|
43722
43360
|
return;
|
|
43723
43361
|
} catch {
|
|
43724
43362
|
}
|
|
43725
43363
|
}
|
|
43726
43364
|
}
|
|
43727
|
-
function storeRedirectedMessage(paths,
|
|
43365
|
+
function storeRedirectedMessage(paths, platform = process.platform) {
|
|
43728
43366
|
const where = paths.map(({ path, target, holds, missing, mode }) => {
|
|
43729
43367
|
if (missing) return `${path} -> ${target} (which does not exist; ${holds} cannot land there)`;
|
|
43730
43368
|
const loose = mode !== void 0 && (mode & 63) !== 0 ? ", NOT owner-only" : "";
|
|
@@ -43734,7 +43372,7 @@ function storeRedirectedMessage(paths, platform2 = process.platform) {
|
|
|
43734
43372
|
const subject = paths.length === 1 ? "a store path is a symlink" : `${String(paths.length)} store paths are symlinks`;
|
|
43735
43373
|
const anyResolves = paths.some(({ missing }) => !missing);
|
|
43736
43374
|
const lead = anyResolves ? `${subject}, so AKA is writing into the target instead: ${where}. ` : `${subject} resolving nowhere, so AKA cannot write there: ${where}. `;
|
|
43737
|
-
const kept = anyResolves &&
|
|
43375
|
+
const kept = anyResolves && platform !== "win32" ? "Permissions are never changed through a symlink, so the store keeps whatever the target already had. " : "";
|
|
43738
43376
|
return `[aka] ${lead}${kept}If you did not create that link, treat it as untrusted and run \`aka init\` for the full report.
|
|
43739
43377
|
`;
|
|
43740
43378
|
}
|
|
@@ -43743,7 +43381,7 @@ function formatMode(mode) {
|
|
|
43743
43381
|
}
|
|
43744
43382
|
function warnIfStoreRedirected(config2, sessionId, write = (message) => void process.stderr.write(message)) {
|
|
43745
43383
|
try {
|
|
43746
|
-
const paths = symlinkedStorePaths(
|
|
43384
|
+
const paths = symlinkedStorePaths(dirname6(config2.dataDir));
|
|
43747
43385
|
if (paths.length === 0) return;
|
|
43748
43386
|
if (!sessionId) {
|
|
43749
43387
|
write(storeRedirectedMessage(paths));
|