@akasecurity/ai-tc-codex 0.9.16 → 0.9.17
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 +6 -6
- package/scripts/apply-suppressions.js +739 -1263
- package/scripts/backfill.js +1040 -1291
- package/scripts/content-retention.js +781 -2074
- package/scripts/filescan.js +1266 -497
- package/scripts/firstrun.js +1277 -1701
- package/scripts/history-sync.js +777 -2107
- package/scripts/intro.js +141 -2190
- package/scripts/onboard.js +2806 -1186
- package/scripts/post-tool-use.js +1512 -1728
- package/scripts/pre-tool-use.js +1094 -1319
- package/scripts/query.js +1277 -1701
- package/scripts/reconcile.js +897 -1288
- package/scripts/remediate.js +1081 -1341
- package/scripts/scan-worker.js +147 -14
- package/scripts/session-start.js +1895 -827
- package/scripts/start-light.js +176 -1360
- package/scripts/stop.js +322 -1113
- package/scripts/sync.js +1818 -1029
- package/scripts/user-prompt-submit.js +1295 -1489
package/scripts/remediate.js
CHANGED
|
@@ -1,893 +1,13 @@
|
|
|
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 basename9 = 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 ? basename9 : 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
|
// src/remediation/entry.ts
|
|
876
|
-
import { readFileSync as
|
|
8
|
+
import { readFileSync as readFileSync21 } from "fs";
|
|
877
9
|
import { fileURLToPath as fileURLToPath6 } from "url";
|
|
878
10
|
|
|
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";
|
|
890
|
-
|
|
891
11
|
// ../../packages/schema/src/drizzle/deferred-migrations.ts
|
|
892
12
|
var DEFERRED_MIGRATION_TAGS = [
|
|
893
13
|
"0031_audit_capture_by_time_index",
|
|
@@ -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
|
}
|
|
@@ -22520,6 +21684,11 @@ var CaptureAttributes = external_exports.object({
|
|
|
22520
21684
|
// here too. The full statement is on EventMetadata.redactDegradedTo; it is
|
|
22521
21685
|
// repeated rather than referenced because a store reader opens this file.
|
|
22522
21686
|
redact_degraded_to: ActionTaken.optional(),
|
|
21687
|
+
// Why a capture has no content and no findings: its field was refused
|
|
21688
|
+
// because its bounded scan did not finish (see EventMetadata.scanIncomplete,
|
|
21689
|
+
// whose value this is). Absent on every capture that was scanned, so a
|
|
21690
|
+
// reader can tell a refused row from an empty clean one.
|
|
21691
|
+
scan_incomplete: external_exports.enum(["timeout", "unavailable"]).optional(),
|
|
22523
21692
|
// The scope key this capture was stamped with: the canonical repository
|
|
22524
21693
|
// (`host/owner/repo`) of the path the capture names (a relative path is read
|
|
22525
21694
|
// against its working directory), else of its own working directory, or a
|
|
@@ -22697,8 +21866,9 @@ var SessionTokenReport = external_exports.object({
|
|
|
22697
21866
|
totalTokens: external_exports.number().int().nonnegative(),
|
|
22698
21867
|
// Σ of the PRICED rollups only; null when no rollup had a known price.
|
|
22699
21868
|
estimatedCostUsd: external_exports.number().nullable(),
|
|
22700
|
-
// True whenever any
|
|
22701
|
-
//
|
|
21869
|
+
// True whenever any call priced to null (an unknown provider/model, or a call
|
|
21870
|
+
// over a long-context threshold whose rate is unpublished), so the total
|
|
21871
|
+
// understates real spend — the UI renders `≥ $X` instead of a falsely
|
|
22702
21872
|
// precise figure rather than silently dropping the unpriced calls.
|
|
22703
21873
|
costIsPartial: external_exports.boolean()
|
|
22704
21874
|
});
|
|
@@ -23575,7 +22745,15 @@ var StorePostureSnapshot = external_exports.object({
|
|
|
23575
22745
|
policyCounts: StorePosturePolicyCounts,
|
|
23576
22746
|
// OPTIONAL, not nullable: a reporter that predates this member keeps
|
|
23577
22747
|
// getting its 200 without a payload change.
|
|
23578
|
-
plugin: StorePosturePlugin.optional()
|
|
22748
|
+
plugin: StorePosturePlugin.optional(),
|
|
22749
|
+
// OPTIONAL, and sent only by a scoped attachment, always as `scoped`. A
|
|
22750
|
+
// machine attachment omits it, so its body is byte for byte the one it
|
|
22751
|
+
// sent before this member existed. Absent therefore means machine-wide OR
|
|
22752
|
+
// a reporter older than this member, never "scoped". Both values parse, so
|
|
22753
|
+
// a sender that one day spells `machine` breaks no receiver; any other
|
|
22754
|
+
// value fails the whole snapshot, which is why the reporter sends a
|
|
22755
|
+
// constant and never the raw mode.
|
|
22756
|
+
attachmentMode: AttachmentMode.optional()
|
|
23579
22757
|
}).meta({ id: "StorePostureSnapshot" });
|
|
23580
22758
|
var CAPTURE_VERSION_PREFIX = "capture/";
|
|
23581
22759
|
var RecordAuditEventRequest = AuditEventInput.extend({
|
|
@@ -23852,7 +23030,19 @@ var EventMetadata = external_exports.object({
|
|
|
23852
23030
|
// Both are pinned as behaviour in @akasecurity/plugin-sdk's runtime suite.
|
|
23853
23031
|
// Closing either means moving the reason onto the finding row, which
|
|
23854
23032
|
// already carries its own action.
|
|
23855
|
-
redactDegradedTo: ActionTaken.optional()
|
|
23033
|
+
redactDegradedTo: ActionTaken.optional(),
|
|
23034
|
+
// Set when this capture's field was REFUSED rather than scanned: a hook
|
|
23035
|
+
// bounds the scan of a large field (see `LargeInputScanOptions` in
|
|
23036
|
+
// @akasecurity/plugin-sdk), and a scan that did not finish blocks the
|
|
23037
|
+
// field instead of letting it through unscanned.
|
|
23038
|
+
//
|
|
23039
|
+
// - 'timeout': the bounded scan ran out of time.
|
|
23040
|
+
// - 'unavailable': no worker could run it.
|
|
23041
|
+
//
|
|
23042
|
+
// A refused row stores '' as its content and has no findings, which is
|
|
23043
|
+
// exactly what a clean, empty capture looks like — this marker is the only
|
|
23044
|
+
// thing that tells the two apart. Absent on every capture that was scanned.
|
|
23045
|
+
scanIncomplete: external_exports.enum(["timeout", "unavailable"]).optional()
|
|
23856
23046
|
}).meta({ id: "EventMetadata" });
|
|
23857
23047
|
var Event = external_exports.object({
|
|
23858
23048
|
id: external_exports.guid(),
|
|
@@ -24022,7 +23212,7 @@ var Rule = external_exports.strictObject({
|
|
|
24022
23212
|
postValidators: external_exports.array(PostValidatorRef).optional(),
|
|
24023
23213
|
requiresNearby: RequiresNearby.optional(),
|
|
24024
23214
|
examples: external_exports.array(external_exports.string()).optional(),
|
|
24025
|
-
// Whether the matched text is itself sensitive
|
|
23215
|
+
// Whether the matched text is itself sensitive (see RuleEvidence).
|
|
24026
23216
|
evidence: RuleEvidence.optional()
|
|
24027
23217
|
}).meta({ id: "Rule" });
|
|
24028
23218
|
var Author = external_exports.object({
|
|
@@ -24114,7 +23304,13 @@ var DetectionRule = external_exports.object({
|
|
|
24114
23304
|
// Representative matching strings the rule author shipped with the rule. The
|
|
24115
23305
|
// cheapest honest answer to "show me what this rule catches" — every bundled
|
|
24116
23306
|
// rule has them, and they are already in the stored snapshot.
|
|
24117
|
-
examples: external_exports.array(external_exports.string()).optional()
|
|
23307
|
+
examples: external_exports.array(external_exports.string()).optional(),
|
|
23308
|
+
// The rule's DECLARED evidence, as stored. Absent defers to the engine's
|
|
23309
|
+
// classification (ruleEvidence in @akasecurity/detections): a bundled
|
|
23310
|
+
// code-flaw rule reads as 'code' and anything else as 'value', and a rule
|
|
23311
|
+
// in a value category (secret/pii/financial/phi) is always 'value',
|
|
23312
|
+
// whatever it declares.
|
|
23313
|
+
evidence: RuleEvidence.optional()
|
|
24118
23314
|
}).meta({ id: "DetectionRule" });
|
|
24119
23315
|
var DetectionUpdate = external_exports.object({
|
|
24120
23316
|
available: external_exports.boolean(),
|
|
@@ -24182,8 +23378,10 @@ var ImportDetectionRequest = external_exports.object({
|
|
|
24182
23378
|
}).meta({ id: "ImportDetectionRequest" });
|
|
24183
23379
|
|
|
24184
23380
|
// ../../packages/schema/src/zod/detection-build.ts
|
|
24185
|
-
function optional2(key,
|
|
24186
|
-
if (raw === void 0
|
|
23381
|
+
function optional2(key, raw, parse4) {
|
|
23382
|
+
if (raw === void 0) return {};
|
|
23383
|
+
const parsed2 = parse4(raw);
|
|
23384
|
+
if (!parsed2.success || parsed2.data === void 0) return {};
|
|
24187
23385
|
return { [key]: parsed2.data };
|
|
24188
23386
|
}
|
|
24189
23387
|
function isStringArray(value) {
|
|
@@ -24218,10 +23416,12 @@ function rowToDetectionDetail(row, findingsLast30d, update) {
|
|
|
24218
23416
|
category: r.category,
|
|
24219
23417
|
severity: r.severity,
|
|
24220
23418
|
matcher: parsed2.data,
|
|
24221
|
-
//
|
|
24222
|
-
//
|
|
24223
|
-
//
|
|
24224
|
-
//
|
|
23419
|
+
// `appliesTo`, `postValidators` and `requiresNearby` are the rest of what
|
|
23420
|
+
// decides whether this rule fires. Carried so a consumer re-running the
|
|
23421
|
+
// rule (a preview, a tester) evaluates what the engine evaluates rather
|
|
23422
|
+
// than a matcher stripped of its guards — half the bundled catalog
|
|
23423
|
+
// carries at least one of these. `examples` and `evidence` describe the
|
|
23424
|
+
// rule and never gate a match.
|
|
24225
23425
|
//
|
|
24226
23426
|
// Enrichment is deliberately per-field and best-effort, NOT a whole-rule
|
|
24227
23427
|
// `Rule.safeParse`. Two reasons: `Rule` is a strict object pinned to
|
|
@@ -24231,18 +23431,19 @@ function rowToDetectionDetail(row, findingsLast30d, update) {
|
|
|
24231
23431
|
// test should stay exactly what it was, namely a renderable matcher. A
|
|
24232
23432
|
// field that fails validation is omitted, which reads as "not set" and is
|
|
24233
23433
|
// the same thing the consumer saw before this change.
|
|
24234
|
-
...optional2("appliesTo",
|
|
23434
|
+
...optional2("appliesTo", r.appliesTo, (v) => AppliesTo.safeParse(v)),
|
|
24235
23435
|
...optional2(
|
|
24236
23436
|
"postValidators",
|
|
24237
|
-
|
|
24238
|
-
|
|
23437
|
+
r.postValidators,
|
|
23438
|
+
(v) => PostValidatorRef.array().safeParse(v)
|
|
24239
23439
|
),
|
|
24240
|
-
...optional2("requiresNearby",
|
|
23440
|
+
...optional2("requiresNearby", r.requiresNearby, (v) => RequiresNearby.safeParse(v)),
|
|
24241
23441
|
...optional2(
|
|
24242
23442
|
"examples",
|
|
24243
|
-
|
|
24244
|
-
|
|
24245
|
-
)
|
|
23443
|
+
r.examples,
|
|
23444
|
+
(v) => isStringArray(v) ? { success: true, data: v } : { success: false }
|
|
23445
|
+
),
|
|
23446
|
+
...optional2("evidence", r.evidence, (v) => RuleEvidence.safeParse(v))
|
|
24246
23447
|
}
|
|
24247
23448
|
];
|
|
24248
23449
|
});
|
|
@@ -24935,11 +24136,14 @@ var PolicyBundle = external_exports.object({
|
|
|
24935
24136
|
ruleVersions: external_exports.record(external_exports.string(), external_exports.string()).optional(),
|
|
24936
24137
|
// Model ids (the raw `model` string a harness reports, e.g.
|
|
24937
24138
|
// `claude-opus-4-1`) the tenant has PROHIBITED. The plugin refuses to switch
|
|
24938
|
-
// a session onto one (PreModelSwitch)
|
|
24939
|
-
//
|
|
24940
|
-
//
|
|
24941
|
-
//
|
|
24942
|
-
//
|
|
24139
|
+
// a session onto one (PreModelSwitch), refuses a turn that would run on one
|
|
24140
|
+
// (UserPromptSubmit) and refuses a subagent spawn onto one (PreToolUse),
|
|
24141
|
+
// wherever the organization governs the event: everywhere on a
|
|
24142
|
+
// machine-wide attachment, and only in enrolled repositories on a scoped
|
|
24143
|
+
// one (the plugin runtime's `governanceApplies`).
|
|
24144
|
+
// Optional so an older backend — and an older on-disk cache — still
|
|
24145
|
+
// parses; consumers read `?? []`, which is the unenforced behaviour that
|
|
24146
|
+
// predates this field and the safe direction to default.
|
|
24943
24147
|
//
|
|
24944
24148
|
// Ids, not display names: the governance decision is keyed on the exact
|
|
24945
24149
|
// string the harness reports (`model_status_override.versionId` in the
|
|
@@ -25398,6 +24602,8 @@ var AttachmentScopeEntry = external_exports.object({
|
|
|
25398
24602
|
});
|
|
25399
24603
|
var AttachmentScope = external_exports.object({
|
|
25400
24604
|
endpoint: external_exports.string().min(1),
|
|
24605
|
+
tenantName: PluginWhoami.shape.tenantName.optional(),
|
|
24606
|
+
userEmail: PluginWhoami.shape.userEmail.optional(),
|
|
25401
24607
|
entries: external_exports.array(AttachmentScopeEntry)
|
|
25402
24608
|
});
|
|
25403
24609
|
var AttachmentScopeEnvelope = AttachmentScope.extend({ entries: external_exports.array(external_exports.unknown()) });
|
|
@@ -25410,7 +24616,13 @@ function parseAttachmentScope(raw) {
|
|
|
25410
24616
|
const entry = AttachmentScopeEntry.safeParse(candidate);
|
|
25411
24617
|
if (entry.success) entries.push(entry.data);
|
|
25412
24618
|
}
|
|
25413
|
-
|
|
24619
|
+
const { endpoint, tenantName, userEmail } = envelope.data;
|
|
24620
|
+
return {
|
|
24621
|
+
endpoint,
|
|
24622
|
+
...tenantName === void 0 ? {} : { tenantName },
|
|
24623
|
+
...userEmail === void 0 ? {} : { userEmail },
|
|
24624
|
+
entries
|
|
24625
|
+
};
|
|
25414
24626
|
} catch {
|
|
25415
24627
|
return void 0;
|
|
25416
24628
|
}
|
|
@@ -25647,6 +24859,7 @@ function toCaptureAttributes(event) {
|
|
|
25647
24859
|
...metadata?.exceptionIds !== void 0 ? { exception_ids: metadata.exceptionIds } : {},
|
|
25648
24860
|
...metadata?.inspectionMs !== void 0 ? { inspection_ms: metadata.inspectionMs } : {},
|
|
25649
24861
|
...metadata?.redactDegradedTo !== void 0 ? { redact_degraded_to: metadata.redactDegradedTo } : {},
|
|
24862
|
+
...metadata?.scanIncomplete !== void 0 ? { scan_incomplete: metadata.scanIncomplete } : {},
|
|
25650
24863
|
// `model`/`turnIndex` have no dedicated CaptureAttributes field (no writer
|
|
25651
24864
|
// has ever populated either), but every legacy metadata key still rides
|
|
25652
24865
|
// the bag rather than being silently dropped — CaptureAttributes'
|
|
@@ -25775,6 +24988,27 @@ var ManagedSettings = external_exports.object({
|
|
|
25775
24988
|
};
|
|
25776
24989
|
}).meta({ id: "ManagedSettings" });
|
|
25777
24990
|
|
|
24991
|
+
// ../../packages/schema/src/zod/mod-policy-snapshot.ts
|
|
24992
|
+
var MOD_POLICY_SNAPSHOT_VERSION = 1;
|
|
24993
|
+
var MOD_POLICY_SNAPSHOT_MAX_BYTES = 4 * 1024 * 1024;
|
|
24994
|
+
var ModPolicySnapshot = external_exports.object({
|
|
24995
|
+
version: external_exports.literal(MOD_POLICY_SNAPSHOT_VERSION),
|
|
24996
|
+
generatedAt: external_exports.iso.datetime(),
|
|
24997
|
+
// The complete effective ruleset, as the hook's runtime scans with it: the
|
|
24998
|
+
// user's enabled installed packs (user-modified and custom packs included).
|
|
24999
|
+
// Absent means the store holds no authoritative snapshot, and the reader
|
|
25000
|
+
// scans with the packs it ships — the hook's own fallback.
|
|
25001
|
+
rules: external_exports.array(Rule).optional(),
|
|
25002
|
+
// Rule-targeted actions (first enabled policy per rule wins).
|
|
25003
|
+
ruleActions: external_exports.record(external_exports.string(), ActionTaken),
|
|
25004
|
+
// The resolved action per detection category.
|
|
25005
|
+
categoryActions: external_exports.record(external_exports.string(), ActionTaken),
|
|
25006
|
+
// Rules with an active exception grant. Honouring a grant means matching a
|
|
25007
|
+
// keyed fingerprint of the value and consuming a use, which only the hook can
|
|
25008
|
+
// do, so the mod leaves a finding of one of these rules for the hook to decide.
|
|
25009
|
+
exceptionRuleIds: external_exports.array(external_exports.string())
|
|
25010
|
+
}).meta({ id: "ModPolicySnapshot" });
|
|
25011
|
+
|
|
25778
25012
|
// ../../packages/schema/src/zod/project-files.ts
|
|
25779
25013
|
var ProjectFileInput = external_exports.object({
|
|
25780
25014
|
path: external_exports.string().min(1),
|
|
@@ -26095,7 +25329,16 @@ var AttachInput = external_exports.object({
|
|
|
26095
25329
|
// 200 matches the tenantName bound beside it in control-plane.ts; nothing
|
|
26096
25330
|
// renders a longer one usefully.
|
|
26097
25331
|
label: printable(200).optional(),
|
|
26098
|
-
accessKey: external_exports.string()
|
|
25332
|
+
accessKey: external_exports.string(),
|
|
25333
|
+
// How much of this machine the attachment is for: everything, or only the
|
|
25334
|
+
// repositories its user enrolls. Optional, so an input without it still
|
|
25335
|
+
// parses; what an absent mode means is for whatever reads it to decide, not
|
|
25336
|
+
// this shape. This member validates the VALUE rather than leaving that to the
|
|
25337
|
+
// call site, a deliberate exception to this module's shape-only rule: a shape
|
|
25338
|
+
// rejection names the field, so a value that is not a mode is refused as a bad
|
|
25339
|
+
// `mode` rather than stripped or passed on. The dashboard's attach action reads
|
|
25340
|
+
// it as the mode to attach in.
|
|
25341
|
+
mode: AttachmentMode.optional()
|
|
26099
25342
|
});
|
|
26100
25343
|
|
|
26101
25344
|
// ../../packages/schema/src/zod/triage.ts
|
|
@@ -26381,6 +25624,18 @@ function fromCaptureStatusAttributes(bag) {
|
|
|
26381
25624
|
return parsedStatus.success ? parsedStatus.data : null;
|
|
26382
25625
|
}
|
|
26383
25626
|
|
|
25627
|
+
// ../../packages/persistence/src/attached-derived.ts
|
|
25628
|
+
import { rmSync } from "fs";
|
|
25629
|
+
import { join } from "path";
|
|
25630
|
+
var POLICY_CACHE_FILENAME = "policy-cache.json";
|
|
25631
|
+
var ATTACHED_FORWARD_STATE_FILENAME = "attached-state.json";
|
|
25632
|
+
var ATTACHED_FORWARD_DROPS_FILENAME = "attached-forward-drops.json";
|
|
25633
|
+
var ATTACHED_POSTURE_REPORT_FILENAME = "attached-posture-report.json";
|
|
25634
|
+
|
|
25635
|
+
// ../../packages/persistence/src/control-plane-credential.ts
|
|
25636
|
+
import { chmodSync as chmodSync2, lstatSync as lstatSync2, readFileSync, rmSync as rmSync3, statSync } from "fs";
|
|
25637
|
+
import { join as join2 } from "path";
|
|
25638
|
+
|
|
26384
25639
|
// ../../packages/persistence/src/paths.ts
|
|
26385
25640
|
import {
|
|
26386
25641
|
chmodSync,
|
|
@@ -26527,6 +25782,14 @@ function repairOrRefuseMode(file2) {
|
|
|
26527
25782
|
}
|
|
26528
25783
|
return "ok";
|
|
26529
25784
|
}
|
|
25785
|
+
function asReadableCredential(value) {
|
|
25786
|
+
const result = AttachedCredentialAny.safeParse(value);
|
|
25787
|
+
if (!result.success) return null;
|
|
25788
|
+
if (attachmentModeOf(result.data) === "machine" && typeof value === "object" && value !== null && Object.hasOwn(value, "mode")) {
|
|
25789
|
+
return null;
|
|
25790
|
+
}
|
|
25791
|
+
return result.data;
|
|
25792
|
+
}
|
|
26530
25793
|
function readControlPlaneCredentialFile(settingsDir2, connection) {
|
|
26531
25794
|
const file2 = controlPlaneCredentialPath(settingsDir2);
|
|
26532
25795
|
let raw;
|
|
@@ -26545,20 +25808,20 @@ function readControlPlaneCredentialFile(settingsDir2, connection) {
|
|
|
26545
25808
|
} catch {
|
|
26546
25809
|
return { usable: false, reason: "malformed" };
|
|
26547
25810
|
}
|
|
26548
|
-
const
|
|
26549
|
-
if (
|
|
26550
|
-
if (!isSafeEndpoint(
|
|
25811
|
+
const credential = asReadableCredential(parsed2);
|
|
25812
|
+
if (credential === null) return { usable: false, reason: "malformed" };
|
|
25813
|
+
if (!isSafeEndpoint(credential.endpoint)) {
|
|
26551
25814
|
return { usable: false, reason: "unsafe-endpoint" };
|
|
26552
25815
|
}
|
|
26553
|
-
if (connection !== void 0 && connection.endpoint !==
|
|
25816
|
+
if (connection !== void 0 && connection.endpoint !== credential.endpoint) {
|
|
26554
25817
|
return {
|
|
26555
25818
|
usable: false,
|
|
26556
25819
|
reason: "endpoint-mismatch",
|
|
26557
|
-
credentialEndpoint:
|
|
25820
|
+
credentialEndpoint: credential.endpoint,
|
|
26558
25821
|
settingsEndpoint: connection.endpoint
|
|
26559
25822
|
};
|
|
26560
25823
|
}
|
|
26561
|
-
return { usable: true, credential
|
|
25824
|
+
return { usable: true, credential };
|
|
26562
25825
|
}
|
|
26563
25826
|
function readControlPlaneCredential(settingsDir2, connection) {
|
|
26564
25827
|
const read = readControlPlaneCredentialFile(settingsDir2, connection);
|
|
@@ -26567,7 +25830,7 @@ function readControlPlaneCredential(settingsDir2, connection) {
|
|
|
26567
25830
|
|
|
26568
25831
|
// ../../packages/persistence/src/database.ts
|
|
26569
25832
|
import { randomUUID as randomUUID11 } from "crypto";
|
|
26570
|
-
import { dirname as dirname2, join as
|
|
25833
|
+
import { dirname as dirname2, join as join8, sep } from "path";
|
|
26571
25834
|
import { DatabaseSync } from "node:sqlite";
|
|
26572
25835
|
|
|
26573
25836
|
// ../../packages/persistence/src/ids.ts
|
|
@@ -26621,6 +25884,7 @@ function uuidFromDigest(digest) {
|
|
|
26621
25884
|
function captureWireId(sessionId, contentHash, filePath = null) {
|
|
26622
25885
|
return uuidFromDigest(captureId(sessionId, contentHash, filePath));
|
|
26623
25886
|
}
|
|
25887
|
+
var DOT = ".".charCodeAt(0);
|
|
26624
25888
|
|
|
26625
25889
|
// ../../packages/persistence/src/internal/snapshot.ts
|
|
26626
25890
|
import { randomUUID } from "crypto";
|
|
@@ -26948,6 +26212,25 @@ function scopeKeysParam(scopeKeys) {
|
|
|
26948
26212
|
var ROOT_SCOPE_KEY = `(SELECT session_root.scope_key
|
|
26949
26213
|
FROM audit_events AS session_root
|
|
26950
26214
|
WHERE session_root.id = COALESCE(audit_events.root_session_id, audit_events.id))`;
|
|
26215
|
+
var COUNTED_IN_SCOPE = `
|
|
26216
|
+
AND ${inScope("scope_key")}
|
|
26217
|
+
AND (event_type IN (${CAPTURE_TYPE_LIST}) OR ${inScope(ROOT_SCOPE_KEY)})`;
|
|
26218
|
+
var DRAIN_TOTALS = `SELECT
|
|
26219
|
+
SUM(CASE WHEN synced_at IS NULL AND started_at < :before THEN 1 ELSE 0 END) AS pending,
|
|
26220
|
+
SUM(CASE WHEN synced_at > 0 THEN 1 ELSE 0 END) AS sent,
|
|
26221
|
+
SUM(CASE WHEN synced_at = ${String(SKIPPED)}
|
|
26222
|
+
AND (sync_failure IS NULL OR sync_failure = 'payload_invalid')
|
|
26223
|
+
THEN 1 ELSE 0 END) AS skipped,
|
|
26224
|
+
SUM(CASE WHEN synced_at = ${String(SKIPPED)}
|
|
26225
|
+
AND sync_failure = 'deployment_refused' THEN 1 ELSE 0 END) AS refused,
|
|
26226
|
+
SUM(CASE WHEN synced_at = ${String(SKIPPED)}
|
|
26227
|
+
AND sync_failure = 'detached_undelivered' THEN 1 ELSE 0 END) AS detached
|
|
26228
|
+
FROM audit_events
|
|
26229
|
+
WHERE event_type IN (${TYPE_LIST})`;
|
|
26230
|
+
var CAPTURE_SKIPS = `SELECT COUNT(*) AS skipped
|
|
26231
|
+
FROM audit_events
|
|
26232
|
+
WHERE synced_at = ${String(SKIPPED)}
|
|
26233
|
+
AND event_type IN (${CAPTURE_TYPE_LIST})`;
|
|
26951
26234
|
var ROW_COLUMNS = `id,
|
|
26952
26235
|
parent_id AS parentId,
|
|
26953
26236
|
root_session_id AS rootSessionId,
|
|
@@ -27023,7 +26306,7 @@ var SqliteHistorySyncRepository = class {
|
|
|
27023
26306
|
);
|
|
27024
26307
|
this.scopedCaptureRowsStmt = db.prepare(
|
|
27025
26308
|
`SELECT ${ROW_COLUMNS}
|
|
27026
|
-
FROM audit_events
|
|
26309
|
+
FROM audit_events INDEXED BY idx_audit_scope_owed
|
|
27027
26310
|
WHERE synced_at IS NULL
|
|
27028
26311
|
AND sync_claimed_at IS NULL
|
|
27029
26312
|
AND outbox_owed = 1
|
|
@@ -27076,40 +26359,28 @@ var SqliteHistorySyncRepository = class {
|
|
|
27076
26359
|
);
|
|
27077
26360
|
this.partitionStmt = db.prepare(`SELECT${PARTITION_BUCKETS}
|
|
27078
26361
|
FROM audit_events${COUNTED_SCOPE}`);
|
|
26362
|
+
this.scopedPartitionStmt = db.prepare(`SELECT${PARTITION_BUCKETS}
|
|
26363
|
+
FROM audit_events${COUNTED_SCOPE}${COUNTED_IN_SCOPE}`);
|
|
27079
26364
|
this.partitionByKindStmt = db.prepare(
|
|
27080
26365
|
`SELECT event_type AS kind,${PARTITION_BUCKETS}
|
|
27081
26366
|
FROM audit_events INDEXED BY idx_audit_events_sync${COUNTED_SCOPE}
|
|
27082
26367
|
GROUP BY event_type`
|
|
27083
26368
|
);
|
|
27084
|
-
this.
|
|
27085
|
-
`SELECT
|
|
27086
|
-
|
|
27087
|
-
|
|
27088
|
-
|
|
27089
|
-
|
|
27090
|
-
|
|
27091
|
-
|
|
27092
|
-
|
|
27093
|
-
|
|
27094
|
-
|
|
27095
|
-
|
|
27096
|
-
|
|
27097
|
-
|
|
27098
|
-
|
|
27099
|
-
// EVERY sentinel capture, whatever the reason — deliberately NOT split the
|
|
27100
|
-
// way the structural totals are. The split exists because a refusal is
|
|
27101
|
-
// terminal only against the deployment that gave it, and the structural
|
|
27102
|
-
// re-arm frees it on a change of deployment. The capture lane has no such
|
|
27103
|
-
// escape: re-arming a capture would offer one deployment's undelivered
|
|
27104
|
-
// prompts, with their text, to a deployment that never saw them, which is
|
|
27105
|
-
// exactly what disownCapturesStmt exists to prevent. So on this lane both
|
|
27106
|
-
// reasons mean the same thing — this row will not be sent — and splitting
|
|
27107
|
-
// them would put refused captures in a bucket nothing reads and nothing
|
|
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})`
|
|
26369
|
+
this.scopedPartitionByKindStmt = db.prepare(
|
|
26370
|
+
`SELECT event_type AS kind,${PARTITION_BUCKETS}
|
|
26371
|
+
FROM audit_events INDEXED BY idx_audit_events_sync${COUNTED_SCOPE}${COUNTED_IN_SCOPE}
|
|
26372
|
+
GROUP BY event_type`
|
|
26373
|
+
);
|
|
26374
|
+
this.countsStmt = db.prepare(DRAIN_TOTALS);
|
|
26375
|
+
this.scopedCountsStmt = db.prepare(
|
|
26376
|
+
`${DRAIN_TOTALS}
|
|
26377
|
+
AND ${inScope("scope_key")}
|
|
26378
|
+
AND ${inScope(ROOT_SCOPE_KEY)}`
|
|
26379
|
+
);
|
|
26380
|
+
this.captureSkipCountStmt = db.prepare(CAPTURE_SKIPS);
|
|
26381
|
+
this.scopedCaptureSkipCountStmt = db.prepare(
|
|
26382
|
+
`${CAPTURE_SKIPS}
|
|
26383
|
+
AND ${inScope("scope_key")}`
|
|
27113
26384
|
);
|
|
27114
26385
|
this.fingerprintStmt = db.prepare(
|
|
27115
26386
|
`SELECT endpoint_fingerprint AS fingerprint, backlog_before AS backlogBefore
|
|
@@ -27223,6 +26494,10 @@ var SqliteHistorySyncRepository = class {
|
|
|
27223
26494
|
scopedCaptureRowsStmt;
|
|
27224
26495
|
scopedCaptureBacklogOwedStmt;
|
|
27225
26496
|
markScopeCapturesOwedStmt;
|
|
26497
|
+
scopedPartitionStmt;
|
|
26498
|
+
scopedPartitionByKindStmt;
|
|
26499
|
+
scopedCountsStmt;
|
|
26500
|
+
scopedCaptureSkipCountStmt;
|
|
27226
26501
|
/**
|
|
27227
26502
|
* The masked detections recorded against one tool call.
|
|
27228
26503
|
*
|
|
@@ -27444,7 +26719,29 @@ var SqliteHistorySyncRepository = class {
|
|
|
27444
26719
|
* in" — and a machine that has never attached has no boundary to pass, so
|
|
27445
26720
|
* requiring one would force a caller to invent one and report the whole store
|
|
27446
26721
|
* as queued.
|
|
26722
|
+
*
|
|
26723
|
+
* `scopeKeys` is a scoped attachment's filter: every bucket then counts only
|
|
26724
|
+
* the rows that pass the drain's reachability rule for that scope
|
|
26725
|
+
* (COUNTED_IN_SCOPE, which also names the one kind of row it counts that the
|
|
26726
|
+
* drain never offers), so a personal repository's rows are in none of them.
|
|
26727
|
+
* Omitted, this runs the machine statement, unchanged; an empty list counts
|
|
26728
|
+
* nothing.
|
|
27447
26729
|
*/
|
|
26730
|
+
partition(scopeKeys) {
|
|
26731
|
+
const row = getRow(
|
|
26732
|
+
scopeKeys === void 0 ? this.partitionStmt : this.scopedPartitionStmt,
|
|
26733
|
+
scopeKeys === void 0 ? {} : { scopeKeys: scopeKeysParam(scopeKeys) }
|
|
26734
|
+
);
|
|
26735
|
+
return {
|
|
26736
|
+
queued: row?.queued ?? 0,
|
|
26737
|
+
inProgress: row?.inProgress ?? 0,
|
|
26738
|
+
synced: row?.synced ?? 0,
|
|
26739
|
+
failed: row?.failed ?? 0,
|
|
26740
|
+
refused: row?.refused ?? 0,
|
|
26741
|
+
detached: row?.detached ?? 0,
|
|
26742
|
+
total: row?.total ?? 0
|
|
26743
|
+
};
|
|
26744
|
+
}
|
|
27448
26745
|
/**
|
|
27449
26746
|
* The same partition, one row per kind that a lane carries.
|
|
27450
26747
|
*
|
|
@@ -27454,11 +26751,14 @@ var SqliteHistorySyncRepository = class {
|
|
|
27454
26751
|
* rendering a fixed list of kinds must therefore treat a missing one as "no
|
|
27455
26752
|
* rows", never as "zero sent"; the two look identical in a bar and mean
|
|
27456
26753
|
* different things.
|
|
26754
|
+
*
|
|
26755
|
+
* `scopeKeys` scopes it with the clause `partition` uses, so the per-kind rows
|
|
26756
|
+
* still sum to the scoped aggregate. An empty list returns no rows.
|
|
27457
26757
|
*/
|
|
27458
|
-
partitionByKind() {
|
|
26758
|
+
partitionByKind(scopeKeys) {
|
|
27459
26759
|
return allRows(
|
|
27460
|
-
this.partitionByKindStmt,
|
|
27461
|
-
{}
|
|
26760
|
+
scopeKeys === void 0 ? this.partitionByKindStmt : this.scopedPartitionByKindStmt,
|
|
26761
|
+
scopeKeys === void 0 ? {} : { scopeKeys: scopeKeysParam(scopeKeys) }
|
|
27462
26762
|
).map((row) => ({
|
|
27463
26763
|
kind: row.kind,
|
|
27464
26764
|
queued: row.queued ?? 0,
|
|
@@ -27470,22 +26770,25 @@ var SqliteHistorySyncRepository = class {
|
|
|
27470
26770
|
total: row.total ?? 0
|
|
27471
26771
|
}));
|
|
27472
26772
|
}
|
|
27473
|
-
|
|
27474
|
-
|
|
27475
|
-
|
|
27476
|
-
|
|
27477
|
-
|
|
27478
|
-
|
|
27479
|
-
|
|
27480
|
-
|
|
27481
|
-
|
|
27482
|
-
|
|
27483
|
-
|
|
27484
|
-
|
|
27485
|
-
|
|
27486
|
-
|
|
27487
|
-
|
|
27488
|
-
|
|
26773
|
+
/**
|
|
26774
|
+
* The drain's totals. `pending` counts only what is inside the backlog; sent
|
|
26775
|
+
* and skipped are totals.
|
|
26776
|
+
*
|
|
26777
|
+
* `scopeKeys` is a scoped attachment's filter, and it scopes every figure,
|
|
26778
|
+
* `capturesSkipped` included: a structural row is counted only when its own
|
|
26779
|
+
* key and its session root's key are among them, a capture when its own key
|
|
26780
|
+
* is. So `pending` is exactly what pendingSessions and pendingRows page out
|
|
26781
|
+
* under the same keys and boundary. Omitted, this runs the machine
|
|
26782
|
+
* statements, unchanged; an empty list counts nothing.
|
|
26783
|
+
*/
|
|
26784
|
+
counts(before, scopeKeys) {
|
|
26785
|
+
const row = getRow(
|
|
26786
|
+
scopeKeys === void 0 ? this.countsStmt : this.scopedCountsStmt,
|
|
26787
|
+
scopeKeys === void 0 ? { before } : { before, scopeKeys: scopeKeysParam(scopeKeys) }
|
|
26788
|
+
);
|
|
26789
|
+
const captures = scopeKeys === void 0 ? getRow(this.captureSkipCountStmt) : getRow(this.scopedCaptureSkipCountStmt, {
|
|
26790
|
+
scopeKeys: scopeKeysParam(scopeKeys)
|
|
26791
|
+
});
|
|
27489
26792
|
return {
|
|
27490
26793
|
pending: row?.pending ?? 0,
|
|
27491
26794
|
sent: row?.sent ?? 0,
|
|
@@ -27737,6 +27040,7 @@ function applyMigrations(db, file2, options = {}) {
|
|
|
27737
27040
|
}
|
|
27738
27041
|
ensureSyncedAtColumn(db, "audit_events");
|
|
27739
27042
|
ensureScopeKeyColumn(db);
|
|
27043
|
+
ensureScopeOwedIndex(db);
|
|
27740
27044
|
ensureScanLedgerTable(db);
|
|
27741
27045
|
ensureHistorySyncTable(db);
|
|
27742
27046
|
ensureBlockedDetectionsTable(db);
|
|
@@ -28177,14 +27481,48 @@ function ensureScopeKeyColumn(db) {
|
|
|
28177
27481
|
function hasScopeKeyColumn(db) {
|
|
28178
27482
|
return columnNames(db, "audit_events", { includeGenerated: true }).includes("scope_key");
|
|
28179
27483
|
}
|
|
27484
|
+
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";
|
|
27485
|
+
function ensureScopeOwedIndex(db) {
|
|
27486
|
+
if (!schemaObjectExists(db, "table", "audit_events")) return;
|
|
27487
|
+
const columns = columnNames(db, "audit_events", { includeGenerated: true });
|
|
27488
|
+
const complete = ["scope_key", "outbox_owed", "synced_at"].every((c) => columns.includes(c));
|
|
27489
|
+
if (!complete) return;
|
|
27490
|
+
db.exec(SCOPE_OWED_INDEX_DDL);
|
|
27491
|
+
}
|
|
28180
27492
|
function ensureScanLedgerTable(db) {
|
|
28181
27493
|
db.exec(`CREATE TABLE IF NOT EXISTS scan_ledger (
|
|
28182
27494
|
path TEXT PRIMARY KEY,
|
|
28183
27495
|
mtime TEXT NOT NULL,
|
|
28184
27496
|
content_hash TEXT NOT NULL,
|
|
28185
27497
|
ruleset_hash TEXT NOT NULL,
|
|
28186
|
-
scanned_at INTEGER NOT NULL
|
|
27498
|
+
scanned_at INTEGER NOT NULL,
|
|
27499
|
+
scope_key TEXT,
|
|
27500
|
+
scope_root TEXT
|
|
28187
27501
|
)`);
|
|
27502
|
+
ensureScanLedgerScopeKeyColumn(db);
|
|
27503
|
+
ensureScanLedgerScopeRootColumn(db);
|
|
27504
|
+
}
|
|
27505
|
+
var SCAN_LEDGER_SCOPE_KEY_DDL = "ALTER TABLE scan_ledger ADD COLUMN scope_key TEXT";
|
|
27506
|
+
var SCAN_LEDGER_SCOPE_ROOT_DDL = "ALTER TABLE scan_ledger ADD COLUMN scope_root TEXT";
|
|
27507
|
+
function ensureScanLedgerScopeKeyColumn(db) {
|
|
27508
|
+
ensureScanLedgerColumn(db, "scope_key", SCAN_LEDGER_SCOPE_KEY_DDL);
|
|
27509
|
+
}
|
|
27510
|
+
function ensureScanLedgerScopeRootColumn(db) {
|
|
27511
|
+
ensureScanLedgerColumn(db, "scope_root", SCAN_LEDGER_SCOPE_ROOT_DDL);
|
|
27512
|
+
}
|
|
27513
|
+
function ensureScanLedgerColumn(db, column, ddl) {
|
|
27514
|
+
if (!schemaObjectExists(db, "table", "scan_ledger")) return;
|
|
27515
|
+
if (hasScanLedgerColumn(db, column)) return;
|
|
27516
|
+
withTransaction(
|
|
27517
|
+
db,
|
|
27518
|
+
() => {
|
|
27519
|
+
if (!hasScanLedgerColumn(db, column)) db.exec(ddl);
|
|
27520
|
+
},
|
|
27521
|
+
"IMMEDIATE"
|
|
27522
|
+
);
|
|
27523
|
+
}
|
|
27524
|
+
function hasScanLedgerColumn(db, column) {
|
|
27525
|
+
return columnNames(db, "scan_ledger").includes(column);
|
|
28188
27526
|
}
|
|
28189
27527
|
function ensureHistorySyncTable(db) {
|
|
28190
27528
|
db.exec(`CREATE TABLE IF NOT EXISTS history_sync (
|
|
@@ -28235,6 +27573,106 @@ function ensureRuleProbeCacheTable(db) {
|
|
|
28235
27573
|
)`);
|
|
28236
27574
|
}
|
|
28237
27575
|
|
|
27576
|
+
// ../../packages/persistence/src/mod-policy-snapshot.ts
|
|
27577
|
+
import { createHash as createHash2 } from "crypto";
|
|
27578
|
+
import { readFileSync as readFileSync2 } from "fs";
|
|
27579
|
+
import { join as join4 } from "path";
|
|
27580
|
+
var MOD_POLICY_SNAPSHOT_FILENAME = "mod-policy.json";
|
|
27581
|
+
function modPolicySnapshotPath(dataDir2) {
|
|
27582
|
+
return join4(dataDir2, MOD_POLICY_SNAPSHOT_FILENAME);
|
|
27583
|
+
}
|
|
27584
|
+
function buildModPolicySnapshot(input2, generatedAt = /* @__PURE__ */ new Date()) {
|
|
27585
|
+
const byRule = /* @__PURE__ */ new Map();
|
|
27586
|
+
const byCategory = /* @__PURE__ */ new Map();
|
|
27587
|
+
for (const policy of input2.policies) {
|
|
27588
|
+
if (!policy.enabled) continue;
|
|
27589
|
+
if ("ruleId" in policy.target) {
|
|
27590
|
+
if (!byRule.has(policy.target.ruleId)) byRule.set(policy.target.ruleId, policy.action);
|
|
27591
|
+
} else if (!byCategory.has(policy.target.category)) {
|
|
27592
|
+
byCategory.set(policy.target.category, policy.action);
|
|
27593
|
+
}
|
|
27594
|
+
}
|
|
27595
|
+
const categoryActions = {};
|
|
27596
|
+
for (const category of DetectionCategory.options) {
|
|
27597
|
+
categoryActions[category] = byCategory.get(category) ?? DEFAULT_ACTIONS[category];
|
|
27598
|
+
}
|
|
27599
|
+
return {
|
|
27600
|
+
version: MOD_POLICY_SNAPSHOT_VERSION,
|
|
27601
|
+
generatedAt: generatedAt.toISOString(),
|
|
27602
|
+
// `examples` is documentation the mod never reads, and a custom pack's are
|
|
27603
|
+
// whatever its author pasted in, so they stay behind.
|
|
27604
|
+
...input2.rules !== void 0 ? { rules: input2.rules.map(withoutExamples) } : {},
|
|
27605
|
+
ruleActions: Object.fromEntries(byRule),
|
|
27606
|
+
categoryActions,
|
|
27607
|
+
exceptionRuleIds: [...new Set(input2.exceptionRuleIds)].sort()
|
|
27608
|
+
};
|
|
27609
|
+
}
|
|
27610
|
+
function assignedRuleActionPolicies(installed) {
|
|
27611
|
+
const out = [];
|
|
27612
|
+
for (const [ruleId, action] of installed.ruleActions) {
|
|
27613
|
+
if (installed.assignedRules.has(ruleId))
|
|
27614
|
+
out.push({ target: { ruleId }, action, enabled: true });
|
|
27615
|
+
}
|
|
27616
|
+
return out;
|
|
27617
|
+
}
|
|
27618
|
+
function withoutExamples(rule) {
|
|
27619
|
+
const copy = { ...rule };
|
|
27620
|
+
delete copy.examples;
|
|
27621
|
+
return copy;
|
|
27622
|
+
}
|
|
27623
|
+
function sameContent(a, b) {
|
|
27624
|
+
return JSON.stringify({ ...a, generatedAt: "" }) === JSON.stringify({ ...b, generatedAt: "" });
|
|
27625
|
+
}
|
|
27626
|
+
function readModPolicySnapshot(dataDir2) {
|
|
27627
|
+
try {
|
|
27628
|
+
const text = readFileSync2(modPolicySnapshotPath(dataDir2), "utf8");
|
|
27629
|
+
if (text.length > MOD_POLICY_SNAPSHOT_MAX_BYTES) return null;
|
|
27630
|
+
const parsed2 = ModPolicySnapshot.safeParse(JSON.parse(text));
|
|
27631
|
+
return parsed2.success ? parsed2.data : null;
|
|
27632
|
+
} catch {
|
|
27633
|
+
return null;
|
|
27634
|
+
}
|
|
27635
|
+
}
|
|
27636
|
+
function writeModPolicySnapshot(dataDir2, snapshot) {
|
|
27637
|
+
const text = JSON.stringify(snapshot);
|
|
27638
|
+
if (Buffer.byteLength(text) > MOD_POLICY_SNAPSHOT_MAX_BYTES) return false;
|
|
27639
|
+
const existing = readModPolicySnapshot(dataDir2);
|
|
27640
|
+
if (existing !== null && sameContent(existing, snapshot)) return false;
|
|
27641
|
+
ensureDataDirSync(dataDir2);
|
|
27642
|
+
writeOwnerOnlyFileSync(modPolicySnapshotPath(dataDir2), text);
|
|
27643
|
+
return true;
|
|
27644
|
+
}
|
|
27645
|
+
function regexProbeKey(matcher) {
|
|
27646
|
+
return createHash2("sha256").update(`${matcher.pattern} ${matcher.flags}`).digest("hex");
|
|
27647
|
+
}
|
|
27648
|
+
function vetRulesForMod(rules, sources, previouslyVetted = /* @__PURE__ */ new Set()) {
|
|
27649
|
+
const bundled = new Set(sources.bundledRegexMatchers().map(regexProbeKey));
|
|
27650
|
+
return rules.filter((rule) => {
|
|
27651
|
+
if (rule.matcher.type !== "regex") return true;
|
|
27652
|
+
const key = regexProbeKey(rule.matcher);
|
|
27653
|
+
const verdict = sources.probeVerdict(key);
|
|
27654
|
+
if (verdict === "quarantined") return false;
|
|
27655
|
+
return verdict === "safe" || bundled.has(key) || previouslyVetted.has(key);
|
|
27656
|
+
});
|
|
27657
|
+
}
|
|
27658
|
+
function modPolicyInputFromStore(sources, previouslyVetted = /* @__PURE__ */ new Set()) {
|
|
27659
|
+
const policies = sources.readPolicies();
|
|
27660
|
+
const snapshot = sources.installedRuleset();
|
|
27661
|
+
const usable = snapshot.installedPacks > 0 && (snapshot.enabledPacks === 0 || snapshot.invalidRules === 0 && snapshot.rules.length > 0);
|
|
27662
|
+
const empty = snapshot.installedPacks > 0 && snapshot.enabledPacks === 0;
|
|
27663
|
+
return {
|
|
27664
|
+
...usable ? { rules: empty ? [] : vetRulesForMod(snapshot.rules, sources, previouslyVetted) } : {},
|
|
27665
|
+
policies: [...policies, ...usable && !empty ? assignedRuleActionPolicies(snapshot) : []],
|
|
27666
|
+
exceptionRuleIds: sources.activeExceptionRuleIds()
|
|
27667
|
+
};
|
|
27668
|
+
}
|
|
27669
|
+
function refreshModPolicySnapshot(dataDir2, sources) {
|
|
27670
|
+
try {
|
|
27671
|
+
writeModPolicySnapshot(dataDir2, buildModPolicySnapshot(modPolicyInputFromStore(sources)));
|
|
27672
|
+
} catch {
|
|
27673
|
+
}
|
|
27674
|
+
}
|
|
27675
|
+
|
|
28238
27676
|
// ../../packages/persistence/src/internal/json.ts
|
|
28239
27677
|
function safeJson(s, fallback) {
|
|
28240
27678
|
if (s == null) return fallback;
|
|
@@ -28409,6 +27847,11 @@ var TIMELINE_COLUMNS = `
|
|
|
28409
27847
|
json_extract(attributes, '$.targetId') AS target_id,
|
|
28410
27848
|
json_extract(attributes, '$.internal') AS internal,
|
|
28411
27849
|
json_extract(attributes, '$.flagged') AS flagged`;
|
|
27850
|
+
var CALL_PROMPT_TOKENS = `(coalesce(input_tokens, 0) + coalesce(cache_read_input_tokens, 0)
|
|
27851
|
+
+ coalesce(ephemeral_1h_input_tokens, 0) + coalesce(ephemeral_5m_input_tokens, 0))`;
|
|
27852
|
+
var CALL_BAND = LONG_CONTEXT_THRESHOLDS.length === 0 ? "0" : LONG_CONTEXT_THRESHOLDS.map((t) => `(${CALL_PROMPT_TOKENS} > ${String(Math.trunc(t))})`).join(
|
|
27853
|
+
" + "
|
|
27854
|
+
);
|
|
28412
27855
|
var LLM_USAGE_SELECT = `
|
|
28413
27856
|
SELECT root_session_id AS sessionId,
|
|
28414
27857
|
provider,
|
|
@@ -28420,9 +27863,10 @@ var LLM_USAGE_SELECT = `
|
|
|
28420
27863
|
coalesce(sum(cache_read_input_tokens), 0) AS cacheReadTokens,
|
|
28421
27864
|
coalesce(sum(ephemeral_1h_input_tokens), 0) AS ephemeral1hTokens,
|
|
28422
27865
|
coalesce(sum(ephemeral_5m_input_tokens), 0) AS ephemeral5mTokens,
|
|
28423
|
-
coalesce(sum(web_search_requests), 0) AS webSearchRequests
|
|
27866
|
+
coalesce(sum(web_search_requests), 0) AS webSearchRequests,
|
|
27867
|
+
coalesce(max(${CALL_PROMPT_TOKENS}), 0) AS promptTokens`;
|
|
28424
27868
|
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`;
|
|
27869
|
+
var LLM_USAGE_GROUP = `GROUP BY root_session_id, provider, model, service_tier, ${CALL_BAND}`;
|
|
28426
27870
|
function usageLeaves(rows) {
|
|
28427
27871
|
return rows.map((row) => {
|
|
28428
27872
|
const attributes = {
|
|
@@ -28437,7 +27881,7 @@ function usageLeaves(rows) {
|
|
|
28437
27881
|
if (row.provider !== null) attributes.provider = row.provider;
|
|
28438
27882
|
if (row.model !== null) attributes.model = row.model;
|
|
28439
27883
|
if (row.serviceTier !== null) attributes.service_tier = row.serviceTier;
|
|
28440
|
-
return { sessionId: row.sessionId, attributes };
|
|
27884
|
+
return { sessionId: row.sessionId, attributes, promptTokens: row.promptTokens };
|
|
28441
27885
|
});
|
|
28442
27886
|
}
|
|
28443
27887
|
var SESSION_ROOT = `event_type = 'session'`;
|
|
@@ -29771,9 +29215,10 @@ var ACTIVE_REVEAL_GRANT_PREDICATE = `capability = 'reveal_to_model'
|
|
|
29771
29215
|
AND conditions IS NULL
|
|
29772
29216
|
AND ${ACTIVE_PREDICATE}`;
|
|
29773
29217
|
var SqliteExceptionsRepository = class {
|
|
29774
|
-
constructor(db, now = () => Date.now()) {
|
|
29218
|
+
constructor(db, now = () => Date.now(), onChange = () => void 0) {
|
|
29775
29219
|
this.db = db;
|
|
29776
29220
|
this.now = now;
|
|
29221
|
+
this.onChange = onChange;
|
|
29777
29222
|
this.consumeStmt = db.prepare(
|
|
29778
29223
|
`UPDATE exceptions
|
|
29779
29224
|
SET use_count = use_count + 1, last_used_at = :now, updated_at = :now
|
|
@@ -29792,6 +29237,7 @@ var SqliteExceptionsRepository = class {
|
|
|
29792
29237
|
}
|
|
29793
29238
|
db;
|
|
29794
29239
|
now;
|
|
29240
|
+
onChange;
|
|
29795
29241
|
consumeStmt;
|
|
29796
29242
|
insertBlockedStmt;
|
|
29797
29243
|
sweepBlockedStmt;
|
|
@@ -29807,7 +29253,9 @@ var SqliteExceptionsRepository = class {
|
|
|
29807
29253
|
*/
|
|
29808
29254
|
create(input2) {
|
|
29809
29255
|
try {
|
|
29810
|
-
|
|
29256
|
+
const created = this.createSync(input2);
|
|
29257
|
+
this.onChange();
|
|
29258
|
+
return Promise.resolve(created);
|
|
29811
29259
|
} catch (err) {
|
|
29812
29260
|
return Promise.reject(err instanceof Error ? err : new Error(String(err)));
|
|
29813
29261
|
}
|
|
@@ -29938,6 +29386,7 @@ var SqliteExceptionsRepository = class {
|
|
|
29938
29386
|
SET revoked_at = :now, revoked_by = :revokedBy, revoke_reason = :reason, updated_at = :now
|
|
29939
29387
|
WHERE id = :id AND revoked_at IS NULL`
|
|
29940
29388
|
).run({ id, revokedBy, reason: reason ?? null, now });
|
|
29389
|
+
if (Number(result.changes) === 1) this.onChange();
|
|
29941
29390
|
return Promise.resolve(Number(result.changes) === 1);
|
|
29942
29391
|
}
|
|
29943
29392
|
/**
|
|
@@ -29950,6 +29399,15 @@ var SqliteExceptionsRepository = class {
|
|
|
29950
29399
|
const result = this.consumeStmt.run({ id, now });
|
|
29951
29400
|
return Promise.resolve(Number(result.changes) === 1);
|
|
29952
29401
|
}
|
|
29402
|
+
/** The rule ids with at least one active grant, under any key version. */
|
|
29403
|
+
activeRuleIds(now = this.now()) {
|
|
29404
|
+
return allRows(
|
|
29405
|
+
this.db.prepare(
|
|
29406
|
+
`SELECT DISTINCT rule_id AS ruleId FROM exceptions WHERE ${ACTIVE_PREDICATE}`
|
|
29407
|
+
),
|
|
29408
|
+
{ now }
|
|
29409
|
+
).map((row) => row.ruleId);
|
|
29410
|
+
}
|
|
29953
29411
|
/**
|
|
29954
29412
|
* The evaluation subset of every active grant under one fingerprint key
|
|
29955
29413
|
* version — what rides the policy bundle to the hook. Grants written under
|
|
@@ -31073,28 +30531,28 @@ var SqliteInspectionFindingsRepository = class {
|
|
|
31073
30531
|
};
|
|
31074
30532
|
|
|
31075
30533
|
// ../../packages/persistence/src/repositories/installed-packs.ts
|
|
31076
|
-
import { createHash as
|
|
30534
|
+
import { createHash as createHash3, randomUUID as randomUUID4 } from "crypto";
|
|
31077
30535
|
|
|
31078
30536
|
// ../../packages/persistence/src/policy-floor.ts
|
|
31079
|
-
import { readFileSync as
|
|
31080
|
-
import { join as
|
|
30537
|
+
import { readFileSync as readFileSync6 } from "fs";
|
|
30538
|
+
import { join as join7 } from "path";
|
|
31081
30539
|
|
|
31082
30540
|
// ../../packages/persistence/src/local-layout.ts
|
|
31083
30541
|
import { renameSync as renameSync3 } from "fs";
|
|
31084
30542
|
import { mkdir } from "fs/promises";
|
|
31085
30543
|
import { homedir } from "os";
|
|
31086
|
-
import { join as
|
|
30544
|
+
import { join as join5 } from "path";
|
|
31087
30545
|
function defaultDataDir() {
|
|
31088
|
-
return
|
|
30546
|
+
return join5(homedir(), ".aka");
|
|
31089
30547
|
}
|
|
31090
30548
|
function settingsDir(base = defaultDataDir()) {
|
|
31091
|
-
return
|
|
30549
|
+
return join5(base, "settings");
|
|
31092
30550
|
}
|
|
31093
30551
|
function dataDir(base = defaultDataDir()) {
|
|
31094
|
-
return
|
|
30552
|
+
return join5(base, "data");
|
|
31095
30553
|
}
|
|
31096
30554
|
function dbPath(base = defaultDataDir()) {
|
|
31097
|
-
return
|
|
30555
|
+
return join5(dataDir(base), "aka.db");
|
|
31098
30556
|
}
|
|
31099
30557
|
async function ensureDataDir(dir = defaultDataDir()) {
|
|
31100
30558
|
await mkdir(dir, { recursive: true, mode: DATA_DIR_MODE });
|
|
@@ -31111,8 +30569,8 @@ function migrateLegacyLayout(base = defaultDataDir()) {
|
|
|
31111
30569
|
for (const { name, dest } of moves) {
|
|
31112
30570
|
try {
|
|
31113
30571
|
ensureDataDirSync(dest);
|
|
31114
|
-
const moved =
|
|
31115
|
-
renameSync3(
|
|
30572
|
+
const moved = join5(dest, name);
|
|
30573
|
+
renameSync3(join5(base, name), moved);
|
|
31116
30574
|
tightenFile(moved);
|
|
31117
30575
|
} catch {
|
|
31118
30576
|
}
|
|
@@ -31120,8 +30578,8 @@ function migrateLegacyLayout(base = defaultDataDir()) {
|
|
|
31120
30578
|
}
|
|
31121
30579
|
|
|
31122
30580
|
// ../../packages/persistence/src/settings.ts
|
|
31123
|
-
import { readFileSync as
|
|
31124
|
-
import { join as
|
|
30581
|
+
import { readFileSync as readFileSync5 } from "fs";
|
|
30582
|
+
import { join as join6 } from "path";
|
|
31125
30583
|
|
|
31126
30584
|
// ../../packages/persistence/src/file-lock.ts
|
|
31127
30585
|
import { randomUUID as randomUUID3 } from "crypto";
|
|
@@ -31129,7 +30587,7 @@ import {
|
|
|
31129
30587
|
closeSync,
|
|
31130
30588
|
existsSync as existsSync2,
|
|
31131
30589
|
openSync,
|
|
31132
|
-
readFileSync as
|
|
30590
|
+
readFileSync as readFileSync3,
|
|
31133
30591
|
rmSync as rmSync5,
|
|
31134
30592
|
statSync as statSync3,
|
|
31135
30593
|
writeFileSync as writeFileSync2
|
|
@@ -31138,16 +30596,16 @@ import { hostname as hostname3 } from "os";
|
|
|
31138
30596
|
var PARK = new Int32Array(new SharedArrayBuffer(4));
|
|
31139
30597
|
|
|
31140
30598
|
// ../../packages/persistence/src/managed-settings.ts
|
|
31141
|
-
import { readFileSync as
|
|
30599
|
+
import { readFileSync as readFileSync4 } from "fs";
|
|
31142
30600
|
import { posix, win32 } from "path";
|
|
31143
|
-
function managedSettingsPaths(
|
|
31144
|
-
if (
|
|
30601
|
+
function managedSettingsPaths(platform = process.platform) {
|
|
30602
|
+
if (platform === "darwin") {
|
|
31145
30603
|
return [
|
|
31146
30604
|
posix.join("/Library", "Application Support", "AKASecurity", MANAGED_SETTINGS_FILENAME),
|
|
31147
30605
|
posix.join("/Library", "Managed Preferences", MANAGED_SETTINGS_FILENAME)
|
|
31148
30606
|
];
|
|
31149
30607
|
}
|
|
31150
|
-
if (
|
|
30608
|
+
if (platform === "win32") {
|
|
31151
30609
|
return [win32.join("C:\\", "ProgramData", "AKASecurity", MANAGED_SETTINGS_FILENAME)];
|
|
31152
30610
|
}
|
|
31153
30611
|
return [posix.join("/etc", "aka", MANAGED_SETTINGS_FILENAME)];
|
|
@@ -31157,7 +30615,7 @@ function readManagedSettings(paths = testOnlyManagedPaths ?? managedSettingsPath
|
|
|
31157
30615
|
for (const path of paths) {
|
|
31158
30616
|
let text;
|
|
31159
30617
|
try {
|
|
31160
|
-
text =
|
|
30618
|
+
text = readFileSync4(path, "utf8");
|
|
31161
30619
|
} catch {
|
|
31162
30620
|
continue;
|
|
31163
30621
|
}
|
|
@@ -31211,7 +30669,7 @@ function readWorkspaceSettings(base = defaultDataDir()) {
|
|
|
31211
30669
|
return overlayManagedSettings(readUserSettings(base), readManagedSettings());
|
|
31212
30670
|
}
|
|
31213
30671
|
function readUserSettings(base) {
|
|
31214
|
-
const record2 = readJson(
|
|
30672
|
+
const record2 = readJson(join6(settingsDir(base), SETTINGS_FILENAME));
|
|
31215
30673
|
if (!record2) return defaultWorkspaceSettings();
|
|
31216
30674
|
try {
|
|
31217
30675
|
return WorkspaceSettings.parse(record2);
|
|
@@ -31222,7 +30680,7 @@ function readUserSettings(base) {
|
|
|
31222
30680
|
function readJson(file2) {
|
|
31223
30681
|
let text;
|
|
31224
30682
|
try {
|
|
31225
|
-
text =
|
|
30683
|
+
text = readFileSync5(file2, "utf8");
|
|
31226
30684
|
} catch {
|
|
31227
30685
|
return null;
|
|
31228
30686
|
}
|
|
@@ -31262,7 +30720,7 @@ var PolicyFloorError = class extends Error {
|
|
|
31262
30720
|
};
|
|
31263
30721
|
function readCachedPolicyBundle(base = defaultDataDir()) {
|
|
31264
30722
|
try {
|
|
31265
|
-
const raw =
|
|
30723
|
+
const raw = readFileSync6(join7(dataDir(base), POLICY_CACHE_FILENAME), "utf8");
|
|
31266
30724
|
const parsed2 = JSON.parse(raw);
|
|
31267
30725
|
if (typeof parsed2 !== "object" || parsed2 === null) return null;
|
|
31268
30726
|
return PolicyBundle.parse(parsed2.bundle);
|
|
@@ -31386,7 +30844,7 @@ function inventorySignature(packs2) {
|
|
|
31386
30844
|
return packs2.map((p) => `${p.namespace}/${p.packId}@${p.version}#${hashRules(p.rulesJson)}`).sort().join(",");
|
|
31387
30845
|
}
|
|
31388
30846
|
function hashRules(rulesJson) {
|
|
31389
|
-
return
|
|
30847
|
+
return createHash3("sha256").update(rulesJson).digest("hex");
|
|
31390
30848
|
}
|
|
31391
30849
|
function parseVersion(v) {
|
|
31392
30850
|
const m = /^(\d+)\.(\d+)\.(\d+)/.exec(v);
|
|
@@ -31428,9 +30886,10 @@ var SqliteInstalledPacksRepository = class {
|
|
|
31428
30886
|
* from `openLocalDatabase`, which is the single construction site that owns a
|
|
31429
30887
|
* real `~/.aka`.
|
|
31430
30888
|
*/
|
|
31431
|
-
constructor(db, baseDir) {
|
|
30889
|
+
constructor(db, baseDir, onChange = () => void 0) {
|
|
31432
30890
|
this.db = db;
|
|
31433
30891
|
this.baseDir = baseDir;
|
|
30892
|
+
this.onChange = onChange;
|
|
31434
30893
|
this.insertMissingStmt = db.prepare(
|
|
31435
30894
|
`INSERT INTO installed_packs (id, namespace, pack_id, version, name, rules_json, enabled, policy_id, created_at, updated_at)
|
|
31436
30895
|
VALUES (:id, :namespace, :packId, :version, :name, :rulesJson, 1, :policyId, :now, :now)
|
|
@@ -31459,6 +30918,7 @@ var SqliteInstalledPacksRepository = class {
|
|
|
31459
30918
|
}
|
|
31460
30919
|
db;
|
|
31461
30920
|
baseDir;
|
|
30921
|
+
onChange;
|
|
31462
30922
|
insertMissingStmt;
|
|
31463
30923
|
upsertAvailableStmt;
|
|
31464
30924
|
signatureStmt;
|
|
@@ -31531,6 +30991,7 @@ var SqliteInstalledPacksRepository = class {
|
|
|
31531
30991
|
},
|
|
31532
30992
|
"IMMEDIATE"
|
|
31533
30993
|
);
|
|
30994
|
+
this.onChange();
|
|
31534
30995
|
} catch {
|
|
31535
30996
|
}
|
|
31536
30997
|
}
|
|
@@ -31605,6 +31066,7 @@ var SqliteInstalledPacksRepository = class {
|
|
|
31605
31066
|
},
|
|
31606
31067
|
"IMMEDIATE"
|
|
31607
31068
|
);
|
|
31069
|
+
if (changed) this.onChange();
|
|
31608
31070
|
return changed;
|
|
31609
31071
|
}
|
|
31610
31072
|
/**
|
|
@@ -31846,6 +31308,7 @@ var SqliteInstalledPacksRepository = class {
|
|
|
31846
31308
|
`UPDATE installed_packs SET policy_id = :policyId, updated_at = :now
|
|
31847
31309
|
WHERE namespace = :namespace AND pack_id = :packId`
|
|
31848
31310
|
).run({ policyId, now: Date.now(), namespace, packId });
|
|
31311
|
+
if (Number(res.changes) > 0) this.onChange();
|
|
31849
31312
|
return Number(res.changes) > 0;
|
|
31850
31313
|
}
|
|
31851
31314
|
/**
|
|
@@ -31870,6 +31333,7 @@ var SqliteInstalledPacksRepository = class {
|
|
|
31870
31333
|
`UPDATE installed_packs SET enabled = :enabled, updated_at = :now
|
|
31871
31334
|
WHERE namespace = :namespace AND pack_id = :packId`
|
|
31872
31335
|
).run({ enabled: boolToInt(enabled), now: Date.now(), namespace, packId });
|
|
31336
|
+
if (Number(res.changes) > 0) this.onChange();
|
|
31873
31337
|
return Number(res.changes) > 0;
|
|
31874
31338
|
}
|
|
31875
31339
|
// Fingerprint of the recorded available mirror — compared against the
|
|
@@ -32767,13 +32231,19 @@ var SqliteInventoryAssetsRepository = class {
|
|
|
32767
32231
|
import { randomUUID as randomUUID6 } from "crypto";
|
|
32768
32232
|
var SEED_BATCH_WINDOW_MS = 6e4;
|
|
32769
32233
|
var SqlitePoliciesRepository = class {
|
|
32770
|
-
constructor(db) {
|
|
32234
|
+
constructor(db, onChange = () => void 0) {
|
|
32771
32235
|
this.db = db;
|
|
32236
|
+
this.onChange = onChange;
|
|
32772
32237
|
}
|
|
32773
32238
|
db;
|
|
32239
|
+
onChange;
|
|
32774
32240
|
readPolicies() {
|
|
32241
|
+
return Promise.resolve(this.listPolicies());
|
|
32242
|
+
}
|
|
32243
|
+
/** The synchronous read behind {@link readPolicies}. */
|
|
32244
|
+
listPolicies() {
|
|
32775
32245
|
const rows = allRows(this.db.prepare("SELECT * FROM policies"));
|
|
32776
|
-
|
|
32246
|
+
return mapRowsTolerant(rows, (row) => {
|
|
32777
32247
|
const target = JSON.parse(row.target);
|
|
32778
32248
|
const customKeywords = row.custom_keywords ? JSON.parse(row.custom_keywords) : void 0;
|
|
32779
32249
|
return Policy.parse({
|
|
@@ -32785,7 +32255,6 @@ var SqlitePoliciesRepository = class {
|
|
|
32785
32255
|
customKeywords
|
|
32786
32256
|
});
|
|
32787
32257
|
});
|
|
32788
|
-
return Promise.resolve(policies);
|
|
32789
32258
|
}
|
|
32790
32259
|
// Seed one policy per bundled category at Monitor so the detection-type config
|
|
32791
32260
|
// exists from first run. An unassigned pack's rules follow these rows, so
|
|
@@ -32796,7 +32265,7 @@ var SqlitePoliciesRepository = class {
|
|
|
32796
32265
|
const count = countScalar(this.db, "SELECT count(*) AS n FROM policies");
|
|
32797
32266
|
if (count > 0) {
|
|
32798
32267
|
this.markEarlierChoices();
|
|
32799
|
-
this.monitorUntouchedSeeds();
|
|
32268
|
+
if (this.monitorUntouchedSeeds()) this.onChange();
|
|
32800
32269
|
return;
|
|
32801
32270
|
}
|
|
32802
32271
|
const stmt = this.db.prepare(
|
|
@@ -32813,6 +32282,7 @@ var SqlitePoliciesRepository = class {
|
|
|
32813
32282
|
});
|
|
32814
32283
|
}
|
|
32815
32284
|
});
|
|
32285
|
+
this.onChange();
|
|
32816
32286
|
}
|
|
32817
32287
|
// Before this build, upsertCategoryAction INSERTed a new row with updated_at
|
|
32818
32288
|
// equal to created_at, so a choice made for a category that had no row yet
|
|
@@ -32878,7 +32348,7 @@ var SqlitePoliciesRepository = class {
|
|
|
32878
32348
|
).filter(
|
|
32879
32349
|
(row) => DEFAULT_ACTIONS[row.category] === row.action
|
|
32880
32350
|
);
|
|
32881
|
-
if (untouched.length === 0) return;
|
|
32351
|
+
if (untouched.length === 0) return false;
|
|
32882
32352
|
const stmt = this.db.prepare(
|
|
32883
32353
|
`UPDATE policies SET action = 'log'
|
|
32884
32354
|
WHERE scope = 'global' AND json_extract(target, '$.category') = :category
|
|
@@ -32889,6 +32359,7 @@ var SqlitePoliciesRepository = class {
|
|
|
32889
32359
|
stmt.run({ category: row.category, seeded: row.action });
|
|
32890
32360
|
}
|
|
32891
32361
|
});
|
|
32362
|
+
return true;
|
|
32892
32363
|
}
|
|
32893
32364
|
// Insert-or-update the single global per-category policy row, keyed on the
|
|
32894
32365
|
// existing uq_policies_scope_target unique index (scope, target). `action`
|
|
@@ -32905,6 +32376,7 @@ var SqlitePoliciesRepository = class {
|
|
|
32905
32376
|
ON CONFLICT(scope, target) DO UPDATE SET action = excluded.action, enabled = 1,
|
|
32906
32377
|
updated_at = MAX(excluded.updated_at, policies.created_at + 1)`
|
|
32907
32378
|
).run({ id: randomUUID6(), target: JSON.stringify({ category }), action, now });
|
|
32379
|
+
this.onChange();
|
|
32908
32380
|
}
|
|
32909
32381
|
// Caps every global per-category policy currently set to block/redact down
|
|
32910
32382
|
// to warn (see warn-era-cap.ts). Rule-targeted policies are untouched.
|
|
@@ -32915,6 +32387,7 @@ var SqlitePoliciesRepository = class {
|
|
|
32915
32387
|
WHERE scope='global' AND action IN ('block','redact')
|
|
32916
32388
|
AND json_extract(target,'$.category') IS NOT NULL`
|
|
32917
32389
|
).run({ now: Date.now() });
|
|
32390
|
+
if (Number(info.changes) > 0) this.onChange();
|
|
32918
32391
|
return Number(info.changes);
|
|
32919
32392
|
}
|
|
32920
32393
|
// Whether the category's row was ever written after it was created — by the
|
|
@@ -33234,31 +32707,45 @@ var SqliteScanLedgerRepository = class {
|
|
|
33234
32707
|
constructor(db) {
|
|
33235
32708
|
this.db = db;
|
|
33236
32709
|
this.upsertStmt = db.prepare(
|
|
33237
|
-
`INSERT INTO scan_ledger
|
|
33238
|
-
|
|
32710
|
+
`INSERT INTO scan_ledger
|
|
32711
|
+
(path, mtime, content_hash, ruleset_hash, scope_key, scope_root, scanned_at)
|
|
32712
|
+
VALUES (:path, :mtime, :contentHash, :rulesetHash, :scopeKey, :scopeRoot, :scannedAt)
|
|
33239
32713
|
ON CONFLICT (path) DO UPDATE SET
|
|
33240
32714
|
mtime = excluded.mtime,
|
|
33241
32715
|
content_hash = excluded.content_hash,
|
|
33242
32716
|
ruleset_hash = excluded.ruleset_hash,
|
|
32717
|
+
scope_key = excluded.scope_key,
|
|
32718
|
+
scope_root = excluded.scope_root,
|
|
33243
32719
|
scanned_at = excluded.scanned_at`
|
|
33244
32720
|
);
|
|
33245
32721
|
this.readStmt = db.prepare(
|
|
33246
|
-
`SELECT path, mtime, content_hash AS contentHash
|
|
32722
|
+
`SELECT path, mtime, content_hash AS contentHash, scope_key AS scopeKey,
|
|
32723
|
+
scope_root AS scopeRoot
|
|
33247
32724
|
FROM scan_ledger WHERE ruleset_hash = :rulesetHash`
|
|
33248
32725
|
);
|
|
33249
32726
|
this.pathsStmt = db.prepare(`SELECT path FROM scan_ledger`);
|
|
32727
|
+
this.pathKeysStmt = db.prepare(`SELECT path, scope_key AS scopeKey FROM scan_ledger`);
|
|
33250
32728
|
}
|
|
33251
32729
|
db;
|
|
33252
32730
|
upsertStmt;
|
|
33253
32731
|
readStmt;
|
|
33254
32732
|
pathsStmt;
|
|
32733
|
+
pathKeysStmt;
|
|
33255
32734
|
// Previously scanned files under THIS ruleset, keyed by path. Rows from an
|
|
33256
32735
|
// older ruleset are simply absent, which reads as "never scanned".
|
|
33257
32736
|
entriesForRuleset(rulesetHash) {
|
|
33258
|
-
const rows = allRows(this.readStmt, {
|
|
33259
|
-
|
|
33260
|
-
|
|
33261
|
-
|
|
32737
|
+
const rows = allRows(this.readStmt, { rulesetHash });
|
|
32738
|
+
return new Map(
|
|
32739
|
+
rows.map((r) => [
|
|
32740
|
+
r.path,
|
|
32741
|
+
{
|
|
32742
|
+
mtime: r.mtime,
|
|
32743
|
+
contentHash: r.contentHash,
|
|
32744
|
+
...r.scopeKey !== null ? { scopeKey: r.scopeKey } : {},
|
|
32745
|
+
...r.scopeRoot !== null ? { scopeRoot: r.scopeRoot } : {}
|
|
32746
|
+
}
|
|
32747
|
+
])
|
|
32748
|
+
);
|
|
33262
32749
|
}
|
|
33263
32750
|
// Every ledgered path, whatever ruleset it was scanned under — the set a
|
|
33264
32751
|
// deletion sweep checks against disk. A file deleted before a ruleset change
|
|
@@ -33267,6 +32754,14 @@ var SqliteScanLedgerRepository = class {
|
|
|
33267
32754
|
allPaths() {
|
|
33268
32755
|
return allRows(this.pathsStmt).map((r) => r.path);
|
|
33269
32756
|
}
|
|
32757
|
+
// Every ledgered path with the repository it was in when it was last read,
|
|
32758
|
+
// whatever ruleset it was scanned under: what a deletion sweep needs to say
|
|
32759
|
+
// which repository a vanished file belonged to. `undefined` for a row with no
|
|
32760
|
+
// key, which is every row written before the column existed.
|
|
32761
|
+
pathKeys() {
|
|
32762
|
+
const rows = allRows(this.pathKeysStmt);
|
|
32763
|
+
return new Map(rows.map((r) => [r.path, r.scopeKey ?? void 0]));
|
|
32764
|
+
}
|
|
33270
32765
|
upsertEntries(entries) {
|
|
33271
32766
|
if (entries.length === 0) return;
|
|
33272
32767
|
const scannedAt = Date.now();
|
|
@@ -33277,6 +32772,8 @@ var SqliteScanLedgerRepository = class {
|
|
|
33277
32772
|
mtime: entry.mtime,
|
|
33278
32773
|
contentHash: entry.contentHash,
|
|
33279
32774
|
rulesetHash: entry.rulesetHash,
|
|
32775
|
+
scopeKey: entry.scopeKey ?? null,
|
|
32776
|
+
scopeRoot: entry.scopeRoot ?? null,
|
|
33280
32777
|
scannedAt
|
|
33281
32778
|
});
|
|
33282
32779
|
}
|
|
@@ -34364,6 +33861,11 @@ function withoutDroppedFiles(reconcile, droppedFiles) {
|
|
|
34364
33861
|
deletedFiles: reconcile.deletedFiles.filter((file2) => !dropped.has(file2))
|
|
34365
33862
|
};
|
|
34366
33863
|
}
|
|
33864
|
+
function withoutTrailingSlashes(path) {
|
|
33865
|
+
let end = path.length;
|
|
33866
|
+
while (end > 0 && path.charCodeAt(end - 1) === 47) end--;
|
|
33867
|
+
return path.slice(0, end);
|
|
33868
|
+
}
|
|
34367
33869
|
function toEndpointSummary(row) {
|
|
34368
33870
|
return {
|
|
34369
33871
|
id: row.id,
|
|
@@ -34651,7 +34153,7 @@ var SqliteSharesRepository = class {
|
|
|
34651
34153
|
*/
|
|
34652
34154
|
reconcileCallSites(projectKey, reconcile) {
|
|
34653
34155
|
if (reconcile.mode === "walk") {
|
|
34654
|
-
const prefix = reconcile.walkedPrefix
|
|
34156
|
+
const prefix = withoutTrailingSlashes(reconcile.walkedPrefix);
|
|
34655
34157
|
this.db.prepare(
|
|
34656
34158
|
`DELETE FROM share_call_site
|
|
34657
34159
|
WHERE project_key = :key
|
|
@@ -35219,7 +34721,7 @@ function backupLegacyStore(db, file2) {
|
|
|
35219
34721
|
discardStore(file2, backup);
|
|
35220
34722
|
return backup;
|
|
35221
34723
|
}
|
|
35222
|
-
function openAndInitialize(file2, base, skipTags) {
|
|
34724
|
+
function openAndInitialize(file2, base, skipTags, shippedRegexMatchers2) {
|
|
35223
34725
|
let db = openWithPragmas(file2);
|
|
35224
34726
|
try {
|
|
35225
34727
|
if (isForeignSqliteLineage(db)) {
|
|
@@ -35231,8 +34733,15 @@ function openAndInitialize(file2, base, skipTags) {
|
|
|
35231
34733
|
}
|
|
35232
34734
|
applyMigrations(db, file2, { skipTags });
|
|
35233
34735
|
tightenPerms(file2);
|
|
35234
|
-
const
|
|
35235
|
-
const
|
|
34736
|
+
const modPolicy = {};
|
|
34737
|
+
const onPolicyStateChange = () => {
|
|
34738
|
+
if (modPolicy.current !== void 0)
|
|
34739
|
+
refreshModPolicySnapshot(dirname2(file2), modPolicy.current);
|
|
34740
|
+
};
|
|
34741
|
+
const policies = new SqlitePoliciesRepository(db, onPolicyStateChange);
|
|
34742
|
+
const installedPacks = new SqliteInstalledPacksRepository(db, base, onPolicyStateChange);
|
|
34743
|
+
const ruleProbeCache = new SqliteRuleProbeCacheRepository(db);
|
|
34744
|
+
const exceptions = new SqliteExceptionsRepository(db, void 0, onPolicyStateChange);
|
|
35236
34745
|
const repositories = {
|
|
35237
34746
|
events: new SqliteEventsRepository(db),
|
|
35238
34747
|
findings: new SqliteFindingsRepository(db),
|
|
@@ -35241,9 +34750,9 @@ function openAndInitialize(file2, base, skipTags) {
|
|
|
35241
34750
|
scanLedger: new SqliteScanLedgerRepository(db),
|
|
35242
34751
|
historySync: new SqliteHistorySyncRepository(db),
|
|
35243
34752
|
secretVault: new SqliteSecretVaultRepository(db),
|
|
35244
|
-
exceptions
|
|
34753
|
+
exceptions,
|
|
35245
34754
|
resolutions: new SqliteResolutionsRepository(db),
|
|
35246
|
-
ruleProbeCache
|
|
34755
|
+
ruleProbeCache,
|
|
35247
34756
|
bodyRetention: new SqliteBodyRetentionRepository(db),
|
|
35248
34757
|
security: new SqliteSecurityRepository(db),
|
|
35249
34758
|
detections: new SqliteDetectionsRepository(db),
|
|
@@ -35261,6 +34770,13 @@ function openAndInitialize(file2, base, skipTags) {
|
|
|
35261
34770
|
inspectionFindings: new SqliteInspectionFindingsRepository(db),
|
|
35262
34771
|
configInventory: new SqliteConfigInventoryRepository(db)
|
|
35263
34772
|
};
|
|
34773
|
+
modPolicy.current = {
|
|
34774
|
+
installedRuleset: () => installedPacks.installedRuleset(),
|
|
34775
|
+
readPolicies: () => policies.listPolicies(),
|
|
34776
|
+
activeExceptionRuleIds: () => exceptions.activeRuleIds(),
|
|
34777
|
+
probeVerdict: (key) => ruleProbeCache.getVerdict(key)?.verdict,
|
|
34778
|
+
bundledRegexMatchers: () => shippedRegexMatchers2
|
|
34779
|
+
};
|
|
35264
34780
|
policies.seedDefaults();
|
|
35265
34781
|
return { db, ...repositories };
|
|
35266
34782
|
} catch (err) {
|
|
@@ -35272,7 +34788,7 @@ function openAndInitialize(file2, base, skipTags) {
|
|
|
35272
34788
|
var DEFERRED_TAGS = new Set(DEFERRED_MIGRATION_TAGS);
|
|
35273
34789
|
function openLocalDatabase(dir, options = {}) {
|
|
35274
34790
|
ensureDataDirSync(dir);
|
|
35275
|
-
const file2 =
|
|
34791
|
+
const file2 = join8(dir, DB_FILENAME);
|
|
35276
34792
|
reapStalePartials(file2);
|
|
35277
34793
|
const {
|
|
35278
34794
|
db,
|
|
@@ -35308,7 +34824,8 @@ function openLocalDatabase(dir, options = {}) {
|
|
|
35308
34824
|
// `dataDir()` — so its parent is the `~/.aka` base the layout splits into
|
|
35309
34825
|
// settings/ and data/, and the pack-policy floor needs both halves.
|
|
35310
34826
|
dirname2(dir),
|
|
35311
|
-
options.applyDeferredMigrations === true ? void 0 : DEFERRED_TAGS
|
|
34827
|
+
options.applyDeferredMigrations === true ? void 0 : DEFERRED_TAGS,
|
|
34828
|
+
options.shippedRegexMatchers ?? []
|
|
35312
34829
|
);
|
|
35313
34830
|
function captureRowId(event) {
|
|
35314
34831
|
return captureId(
|
|
@@ -35573,7 +35090,7 @@ function openLocalDatabase(dir, options = {}) {
|
|
|
35573
35090
|
}
|
|
35574
35091
|
|
|
35575
35092
|
// ../../packages/persistence/src/egress-wire.ts
|
|
35576
|
-
import { createHash as
|
|
35093
|
+
import { createHash as createHash4 } from "crypto";
|
|
35577
35094
|
var PROJECT_KEY_DIGEST_VERSION = "v2";
|
|
35578
35095
|
var SCP_FORM = /^(?:[^@/]+@)?([^/:]+):(.+)$/;
|
|
35579
35096
|
var DOS_DRIVE = /^[A-Za-z]:[\\/]/;
|
|
@@ -35605,7 +35122,7 @@ function canonicalGitUrl(url2) {
|
|
|
35605
35122
|
}
|
|
35606
35123
|
function hashProjectKey(projectKey) {
|
|
35607
35124
|
const canonical = projectKey.startsWith("git:") ? `git:${canonicalGitUrl(projectKey.slice("git:".length))}` : projectKey;
|
|
35608
|
-
return
|
|
35125
|
+
return createHash4("sha256").update(`${PROJECT_KEY_DIGEST_VERSION}:${canonical}`, "utf8").digest("hex");
|
|
35609
35126
|
}
|
|
35610
35127
|
var SCOPE_KEY = printable(ATTACHMENT_SCOPE_IDENTITY_MAX_LENGTH);
|
|
35611
35128
|
var URL_SCHEME = /^[a-z][a-z0-9+.-]*:\/\//i;
|
|
@@ -35670,24 +35187,23 @@ function toEgressIngestRequest(input2) {
|
|
|
35670
35187
|
}
|
|
35671
35188
|
|
|
35672
35189
|
// ../../packages/persistence/src/finding-key.ts
|
|
35673
|
-
import { createHash as
|
|
35190
|
+
import { createHash as createHash5 } from "crypto";
|
|
35674
35191
|
function normalizeFilePath(filePath) {
|
|
35675
35192
|
return filePath.replaceAll("\\", "/");
|
|
35676
35193
|
}
|
|
35677
35194
|
function computeFindingKey(input2) {
|
|
35678
35195
|
const normalizedPath = normalizeFilePath(input2.filePath);
|
|
35679
|
-
return
|
|
35196
|
+
return createHash5("sha256").update(`${input2.ruleId}\0${normalizedPath}\0${input2.valueFingerprint}`).digest("hex");
|
|
35680
35197
|
}
|
|
35681
35198
|
|
|
35682
35199
|
// ../../packages/persistence/src/fingerprint.ts
|
|
35683
35200
|
import { createHmac, randomBytes } from "crypto";
|
|
35684
|
-
import { existsSync as existsSync3, readFileSync as
|
|
35685
|
-
import { join as
|
|
35686
|
-
import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
|
|
35201
|
+
import { existsSync as existsSync3, readFileSync as readFileSync7 } from "fs";
|
|
35202
|
+
import { join as join9 } from "path";
|
|
35687
35203
|
var EXCEPTION_KEY_FILENAME = "exception.key";
|
|
35688
35204
|
var KEY_MATERIAL_BYTES = 32;
|
|
35689
35205
|
function keyFilePath(dataDir2) {
|
|
35690
|
-
return
|
|
35206
|
+
return join9(dataDir2, EXCEPTION_KEY_FILENAME);
|
|
35691
35207
|
}
|
|
35692
35208
|
function parseKeyFile(raw) {
|
|
35693
35209
|
const parsed2 = JSON.parse(raw);
|
|
@@ -35714,6 +35230,12 @@ var KEY_VERSION_COLUMNS = {
|
|
|
35714
35230
|
};
|
|
35715
35231
|
var SQLITE_ERROR2 = 1;
|
|
35716
35232
|
var FLOOR_BUSY_TIMEOUT_MS = 250;
|
|
35233
|
+
function openReadOnly(file2) {
|
|
35234
|
+
const host = process;
|
|
35235
|
+
const sqlite = host.getBuiltinModule?.("node:sqlite");
|
|
35236
|
+
if (sqlite === void 0) throw new Error("this Node runtime cannot load node:sqlite");
|
|
35237
|
+
return new sqlite.DatabaseSync(file2, { readOnly: true });
|
|
35238
|
+
}
|
|
35717
35239
|
var FloorUnreadableError = class extends Error {
|
|
35718
35240
|
code = "floor-unreadable";
|
|
35719
35241
|
constructor(cause) {
|
|
@@ -35725,11 +35247,11 @@ var FloorUnreadableError = class extends Error {
|
|
|
35725
35247
|
}
|
|
35726
35248
|
};
|
|
35727
35249
|
function storedKeyVersionFloor(dataDir2) {
|
|
35728
|
-
const file2 =
|
|
35250
|
+
const file2 = join9(dataDir2, DB_FILENAME);
|
|
35729
35251
|
if (!existsSync3(file2)) return 0;
|
|
35730
35252
|
let db;
|
|
35731
35253
|
try {
|
|
35732
|
-
db =
|
|
35254
|
+
db = openReadOnly(file2);
|
|
35733
35255
|
db.exec(`PRAGMA busy_timeout = ${String(FLOOR_BUSY_TIMEOUT_MS)}`);
|
|
35734
35256
|
let floor = 0;
|
|
35735
35257
|
for (const [table2, column] of Object.entries(KEY_VERSION_COLUMNS)) {
|
|
@@ -35780,7 +35302,7 @@ function occupantMessage(file2, kind) {
|
|
|
35780
35302
|
function readFingerprintKey(dataDir2) {
|
|
35781
35303
|
let raw;
|
|
35782
35304
|
try {
|
|
35783
|
-
raw =
|
|
35305
|
+
raw = readFileSync7(keyFilePath(dataDir2), "utf8");
|
|
35784
35306
|
} catch (err) {
|
|
35785
35307
|
if (err.code === "ENOENT") return null;
|
|
35786
35308
|
throw err instanceof Error ? err : new Error(String(err));
|
|
@@ -35806,8 +35328,8 @@ function exactFingerprintValue(key, raw) {
|
|
|
35806
35328
|
}
|
|
35807
35329
|
|
|
35808
35330
|
// ../../packages/persistence/src/forward-health.ts
|
|
35809
|
-
import { readFileSync as
|
|
35810
|
-
import { join as
|
|
35331
|
+
import { readFileSync as readFileSync8 } from "fs";
|
|
35332
|
+
import { join as join10 } from "path";
|
|
35811
35333
|
var BREAKER_COOLDOWN_MS = 3e4;
|
|
35812
35334
|
function parseForwardHealth(raw, nowMs) {
|
|
35813
35335
|
try {
|
|
@@ -35831,20 +35353,21 @@ function isForwardPaused(health, nowMs) {
|
|
|
35831
35353
|
|
|
35832
35354
|
// ../../packages/persistence/src/history-backfill.ts
|
|
35833
35355
|
import { existsSync as existsSync4 } from "fs";
|
|
35834
|
-
import { join as
|
|
35356
|
+
import { join as join11 } from "path";
|
|
35835
35357
|
|
|
35836
35358
|
// ../../packages/persistence/src/history-preview.ts
|
|
35837
35359
|
import { existsSync as existsSync5 } from "fs";
|
|
35838
|
-
import { join as
|
|
35839
|
-
import { DatabaseSync as
|
|
35360
|
+
import { join as join12 } from "path";
|
|
35361
|
+
import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
|
|
35840
35362
|
|
|
35841
35363
|
// ../../packages/persistence/src/history-sync-state.ts
|
|
35842
|
-
import { readFileSync as
|
|
35843
|
-
import { join as
|
|
35364
|
+
import { readFileSync as readFileSync9 } from "fs";
|
|
35365
|
+
import { join as join13 } from "path";
|
|
35366
|
+
var COUNTS_SCOPES = new Set(AttachmentMode.options);
|
|
35844
35367
|
|
|
35845
35368
|
// ../../packages/persistence/src/store-symlinks.ts
|
|
35846
35369
|
import { existsSync as existsSync6, lstatSync as lstatSync3, readlinkSync, realpathSync, statSync as statSync4 } from "fs";
|
|
35847
|
-
import { dirname as dirname3, join as
|
|
35370
|
+
import { dirname as dirname3, join as join14, resolve } from "path";
|
|
35848
35371
|
|
|
35849
35372
|
// ../../packages/persistence/src/vault/crypto.ts
|
|
35850
35373
|
import {
|
|
@@ -35858,19 +35381,19 @@ import {
|
|
|
35858
35381
|
// ../../packages/persistence/src/vault/key-provider.ts
|
|
35859
35382
|
import { execFileSync } from "child_process";
|
|
35860
35383
|
import { randomBytes as randomBytes2 } from "crypto";
|
|
35861
|
-
import { chmodSync as chmodSync3, readFileSync as
|
|
35862
|
-
import { join as
|
|
35384
|
+
import { chmodSync as chmodSync3, readFileSync as readFileSync10, renameSync as renameSync4, rmSync as rmSync6, statSync as statSync5, writeFileSync as writeFileSync3 } from "fs";
|
|
35385
|
+
import { join as join15 } from "path";
|
|
35863
35386
|
|
|
35864
35387
|
// ../../packages/persistence/src/vault/vault.ts
|
|
35865
35388
|
import { randomBytes as randomBytes3, randomUUID as randomUUID12 } from "crypto";
|
|
35866
35389
|
|
|
35867
35390
|
// ../../packages/persistence/src/warn-era-cap.ts
|
|
35868
35391
|
import { existsSync as existsSync7, writeFileSync as writeFileSync4 } from "fs";
|
|
35869
|
-
import { join as
|
|
35392
|
+
import { join as join16 } from "path";
|
|
35870
35393
|
var MARKER = "warn-era-capped";
|
|
35871
35394
|
function capWarnEraEnforcementOnce(db, policyMode, dataDir2) {
|
|
35872
35395
|
if (policyMode !== "warn") return { capped: 0, skipped: "not-warn" };
|
|
35873
|
-
const marker =
|
|
35396
|
+
const marker = join16(dataDir2, MARKER);
|
|
35874
35397
|
if (existsSync7(marker)) return { capped: 0, skipped: "already-run" };
|
|
35875
35398
|
const capped = db.policies.capCategoryActions();
|
|
35876
35399
|
writeFileSync4(marker, `${new Date(Date.now()).toISOString()}
|
|
@@ -35880,7 +35403,7 @@ function capWarnEraEnforcementOnce(db, policyMode, dataDir2) {
|
|
|
35880
35403
|
|
|
35881
35404
|
// ../../packages/plugin-sdk/src/config.ts
|
|
35882
35405
|
import { existsSync as existsSync8 } from "fs";
|
|
35883
|
-
import { join as
|
|
35406
|
+
import { join as join17 } from "path";
|
|
35884
35407
|
|
|
35885
35408
|
// ../../packages/plugin-sdk/src/provider-env.ts
|
|
35886
35409
|
var DEFAULT_ANTHROPIC_HOST = "api.anthropic.com";
|
|
@@ -35934,7 +35457,7 @@ function resolveProvider() {
|
|
|
35934
35457
|
function loadConfig(base = defaultDataDir(), resolveProviderFn = resolveProvider) {
|
|
35935
35458
|
try {
|
|
35936
35459
|
ensureLayoutDirSync(base);
|
|
35937
|
-
const settingsFile =
|
|
35460
|
+
const settingsFile = join17(settingsDir(base), "settings.json");
|
|
35938
35461
|
if (existsSync8(settingsFile)) tightenFile(settingsFile);
|
|
35939
35462
|
} catch {
|
|
35940
35463
|
}
|
|
@@ -35957,11 +35480,6 @@ function resolveProviderSafe(resolveProviderFn) {
|
|
|
35957
35480
|
}
|
|
35958
35481
|
}
|
|
35959
35482
|
|
|
35960
|
-
// ../../packages/plugin-sdk/src/config-inventory.ts
|
|
35961
|
-
import { readdirSync as readdirSync2, readFileSync as readFileSync11, realpathSync as realpathSync2, statSync as statSync7 } from "fs";
|
|
35962
|
-
import { homedir as homedir2 } from "os";
|
|
35963
|
-
import { basename as basename3, join as join18 } from "path";
|
|
35964
|
-
|
|
35965
35483
|
// ../../packages/detections/src/egress/registry.ts
|
|
35966
35484
|
var EXTRACTOR_VERSION = "3";
|
|
35967
35485
|
var PROVIDER_REGISTRY = [
|
|
@@ -36725,12 +36243,12 @@ var RegexMatcher2 = class {
|
|
|
36725
36243
|
rule.matcher,
|
|
36726
36244
|
() => new RegExp(pattern, flags.includes("d") ? flags : `${flags}d`)
|
|
36727
36245
|
);
|
|
36728
|
-
const
|
|
36246
|
+
const scanText = text.length > MAX_REGEX_INPUT_LENGTH ? text.slice(0, MAX_REGEX_INPUT_LENGTH) : text;
|
|
36729
36247
|
const spans = [];
|
|
36730
36248
|
let m;
|
|
36731
|
-
const maxIterations =
|
|
36249
|
+
const maxIterations = scanText.length + 1;
|
|
36732
36250
|
let iterations = 0;
|
|
36733
|
-
while ((m = re.exec(
|
|
36251
|
+
while ((m = re.exec(scanText)) !== null) {
|
|
36734
36252
|
if (++iterations > maxIterations) break;
|
|
36735
36253
|
const group = captureGroup != null ? m[captureGroup] : m[0];
|
|
36736
36254
|
if (m[0].length === 0) re.lastIndex++;
|
|
@@ -37072,17 +36590,18 @@ function ruleEvidence(rule) {
|
|
|
37072
36590
|
|
|
37073
36591
|
// ../../packages/detections/src/mask.ts
|
|
37074
36592
|
function maskMatch(raw) {
|
|
37075
|
-
|
|
37076
|
-
|
|
37077
|
-
|
|
37078
|
-
|
|
36593
|
+
const visible = stripInvisiblePadding(raw);
|
|
36594
|
+
if (visible.length <= 5) return "***";
|
|
36595
|
+
const atIndex = visible.indexOf("@");
|
|
36596
|
+
if (atIndex > 0 && atIndex < visible.length - 1) {
|
|
36597
|
+
const domain2 = visible.slice(atIndex + 1);
|
|
37079
36598
|
if (domain2.includes(".")) {
|
|
37080
|
-
const local =
|
|
36599
|
+
const local = visible.slice(0, atIndex);
|
|
37081
36600
|
const maskedLocal = local.length <= 1 ? local : local.charAt(0) + "*".repeat(local.length - 1);
|
|
37082
36601
|
return `${maskedLocal}@${domain2}`;
|
|
37083
36602
|
}
|
|
37084
36603
|
}
|
|
37085
|
-
return `${
|
|
36604
|
+
return `${visible.charAt(0)}${"*".repeat(6)}${visible.charAt(visible.length - 1)}`;
|
|
37086
36605
|
}
|
|
37087
36606
|
|
|
37088
36607
|
// ../../packages/detections/src/pointer-shield.ts
|
|
@@ -37318,6 +36837,38 @@ function worstProbeMs(rule, now = wallClock, corroborate) {
|
|
|
37318
36837
|
}
|
|
37319
36838
|
var CPU_CORROBORATION_SHARE = 0.2;
|
|
37320
36839
|
var CORROBORATION_FLOOR_MS = BUDGET_MS * CPU_CORROBORATION_SHARE;
|
|
36840
|
+
function repeatTo(unit, length) {
|
|
36841
|
+
return unit.repeat(Math.ceil(length / unit.length)).slice(0, length);
|
|
36842
|
+
}
|
|
36843
|
+
function joinTo(length, open3, close, item) {
|
|
36844
|
+
const parts = [];
|
|
36845
|
+
let size = open3.length;
|
|
36846
|
+
for (let i = 0; size < length; i++) {
|
|
36847
|
+
const next = (i === 0 ? "" : ",") + item(i);
|
|
36848
|
+
parts.push(next);
|
|
36849
|
+
size += next.length;
|
|
36850
|
+
}
|
|
36851
|
+
return (open3 + parts.join("") + close).slice(0, length);
|
|
36852
|
+
}
|
|
36853
|
+
var SQL_WORDS = ["select", "insert", "update", "delete", "drop", "where"];
|
|
36854
|
+
var GROWTH_CORPORA = [
|
|
36855
|
+
{
|
|
36856
|
+
name: "one-line JSON dictionary",
|
|
36857
|
+
build: (length) => joinTo(length, "{", "}", (i) => `"id-${String(i)}":"label ${String(i)}"`)
|
|
36858
|
+
},
|
|
36859
|
+
{
|
|
36860
|
+
name: "JSON array of quoted SQL keywords",
|
|
36861
|
+
build: (length) => joinTo(length, "[", "]", (i) => `"${SQL_WORDS[i % SQL_WORDS.length] ?? ""} ${String(i)}"`)
|
|
36862
|
+
},
|
|
36863
|
+
{ name: "single-quoted keyword run ('where)", build: (length) => repeatTo("'where", length) },
|
|
36864
|
+
{ name: "double-quote run", build: (length) => repeatTo('"', length) },
|
|
36865
|
+
{ name: "space run", build: (length) => repeatTo(" ", length) },
|
|
36866
|
+
{ name: "newline run", build: (length) => repeatTo("\n", length) },
|
|
36867
|
+
...["abc-", "a.", "a ", "a=", "x", "0", "a@", "a/", "ab"].map((unit) => ({
|
|
36868
|
+
name: `unit run ${JSON.stringify(unit)}`,
|
|
36869
|
+
build: (length) => repeatTo(unit, length)
|
|
36870
|
+
}))
|
|
36871
|
+
];
|
|
37321
36872
|
function checkRuleTiming(rule, corroborate) {
|
|
37322
36873
|
const { ms, probe, corroboratedMs } = worstProbeMs(rule, wallClock, corroborate);
|
|
37323
36874
|
const work = corroboratedMs ?? 0;
|
|
@@ -37344,7 +36895,12 @@ var MIN_RAW_LEN = 4;
|
|
|
37344
36895
|
var RAW_RUN_LEN = 8;
|
|
37345
36896
|
function carriesRawRun(text, rawValues) {
|
|
37346
36897
|
let windows = null;
|
|
37347
|
-
|
|
36898
|
+
const values = /* @__PURE__ */ new Set();
|
|
36899
|
+
for (const raw of rawValues) {
|
|
36900
|
+
values.add(raw);
|
|
36901
|
+
values.add(stripInvisiblePadding(raw));
|
|
36902
|
+
}
|
|
36903
|
+
for (const raw of values) {
|
|
37348
36904
|
if (raw.length < MIN_RAW_LEN) continue;
|
|
37349
36905
|
if (raw.length < RAW_RUN_LEN) {
|
|
37350
36906
|
if (text.includes(raw)) return true;
|
|
@@ -37368,11 +36924,16 @@ function carriesRawRun(text, rawValues) {
|
|
|
37368
36924
|
return false;
|
|
37369
36925
|
}
|
|
37370
36926
|
function safeMaskedMatch(rawMatch) {
|
|
37371
|
-
const
|
|
37372
|
-
|
|
37373
|
-
|
|
36927
|
+
const visible = stripInvisiblePadding(rawMatch);
|
|
36928
|
+
const masked = maskMatch(visible);
|
|
36929
|
+
const reveals = (preview) => preview === visible || visible.length >= MIN_RAW_LEN && preview.includes(visible);
|
|
36930
|
+
if (!reveals(masked)) return masked;
|
|
36931
|
+
const atIndex = masked.indexOf("@");
|
|
36932
|
+
if (atIndex > 0 && atIndex < masked.length - 1) {
|
|
36933
|
+
const emailFallback = `*${masked.slice(atIndex)}`;
|
|
36934
|
+
if (!reveals(emailFallback)) return emailFallback;
|
|
37374
36935
|
}
|
|
37375
|
-
return
|
|
36936
|
+
return "***";
|
|
37376
36937
|
}
|
|
37377
36938
|
function assertRawFree(text, rawValues) {
|
|
37378
36939
|
if (carriesRawRun(text, rawValues)) {
|
|
@@ -37609,7 +37170,7 @@ var auth_jwt_no_verify_default = {
|
|
|
37609
37170
|
severity: "critical",
|
|
37610
37171
|
matcher: {
|
|
37611
37172
|
type: "regex",
|
|
37612
|
-
pattern: "(verify\\s*=\\s*false|verify_signature
|
|
37173
|
+
pattern: "(verify\\s*=\\s*false|verify_signature(?:(?!verify_signature).)*false|algorithms\\s*=\\s*\\[\\])",
|
|
37613
37174
|
flags: "gi"
|
|
37614
37175
|
},
|
|
37615
37176
|
requiresNearby: {
|
|
@@ -37697,7 +37258,7 @@ var cmd_inject_shell_default = {
|
|
|
37697
37258
|
severity: "critical",
|
|
37698
37259
|
matcher: {
|
|
37699
37260
|
type: "regex",
|
|
37700
|
-
pattern: "subprocess\\.(run|Popen|call|check_output)\\s*\\([^)]*shell\\s*=\\s*True",
|
|
37261
|
+
pattern: "subprocess\\.(run|Popen|call|check_output)\\s*\\((?:(?!subprocess\\.(?:run|Popen|call|check_output)\\s*\\()[^)])*shell\\s*=\\s*True",
|
|
37701
37262
|
flags: "gi"
|
|
37702
37263
|
},
|
|
37703
37264
|
requiresNearby: {
|
|
@@ -37826,7 +37387,7 @@ var deser_yaml_unsafe_default = {
|
|
|
37826
37387
|
severity: "high",
|
|
37827
37388
|
matcher: {
|
|
37828
37389
|
type: "regex",
|
|
37829
|
-
pattern: "\\byaml\\.load\\s*\\((?![^)]
|
|
37390
|
+
pattern: "\\byaml\\.load\\s*\\((?!(?:(?!yaml\\.load\\s*\\()[^)])*?(?:SafeLoader|safe_load))",
|
|
37830
37391
|
flags: "gi"
|
|
37831
37392
|
},
|
|
37832
37393
|
examples: ["data = yaml.load(user_input)", "config = yaml.load(f)"],
|
|
@@ -38043,7 +37604,7 @@ var sql_inject_concat_dot_default = {
|
|
|
38043
37604
|
severity: "high",
|
|
38044
37605
|
matcher: {
|
|
38045
37606
|
type: "regex",
|
|
38046
|
-
pattern: `["'][
|
|
37607
|
+
pattern: `["'](?=([^"'\\n]*?(?:select|insert|update|delete|drop|where)))\\1(?:(?!["'][^"'\\n]*?(?:select|insert|update|delete|drop|where))[^\\n])*?["']\\s*\\.`,
|
|
38047
37608
|
flags: "gi"
|
|
38048
37609
|
},
|
|
38049
37610
|
appliesTo: {
|
|
@@ -38061,7 +37622,7 @@ var sql_inject_concat_default = {
|
|
|
38061
37622
|
severity: "high",
|
|
38062
37623
|
matcher: {
|
|
38063
37624
|
type: "regex",
|
|
38064
|
-
pattern: `["']\\s*(?:select\\b[^\\n]*?\\bfrom\\b|insert\\s+into\\b|update\\s+\\S+\\s+set\\b|delete\\s+from\\b|drop\\s+(?:table|database)\\b|where\\b[^\\n]*?=)[^\\n]*?["']\\s*\\+`,
|
|
37625
|
+
pattern: `(["'])\\s*(?=(select\\b(?:(?!\\1\\s*(?:select\\b|insert\\s+into\\b|update\\s+\\S+\\s+set\\b|delete\\s+from\\b|drop\\s+(?:table|database)\\b|where\\b))[^\\n])*?\\bfrom\\b|insert\\s+into\\b|update\\s+\\S+\\s+set\\b|delete\\s+from\\b|drop\\s+(?:table|database)\\b|where\\b(?:(?!\\1\\s*(?:select\\b|insert\\s+into\\b|update\\s+\\S+\\s+set\\b|delete\\s+from\\b|drop\\s+(?:table|database)\\b|where\\b))[^\\n])*?=))\\2(?:(?!\\1\\s*(?:select\\b|insert\\s+into\\b|update\\s+\\S+\\s+set\\b|delete\\s+from\\b|drop\\s+(?:table|database)\\b|where\\b))[^\\n])*?["']\\s*\\+`,
|
|
38065
37626
|
flags: "gi"
|
|
38066
37627
|
},
|
|
38067
37628
|
examples: ['"SELECT * FROM users WHERE id = " + userId']
|
|
@@ -38076,7 +37637,7 @@ var sql_inject_format_default = {
|
|
|
38076
37637
|
severity: "high",
|
|
38077
37638
|
matcher: {
|
|
38078
37639
|
type: "regex",
|
|
38079
|
-
pattern: "\\b(?:select\\b[^\\n]*?\\bfrom\\b|insert\\s+into\\b|update\\s+\\S+\\s+set\\b|delete\\s+from\\b|drop\\s+(?:table|database)\\b|where\\b[^\\n]*?=)[^\\n]*?(?:[%][sd]|\\{[^}]+\\})",
|
|
37640
|
+
pattern: "\\b(?=(select\\b(?:(?!\\b(?:select\\b|insert\\s+into\\b|update\\s+\\S+\\s+set\\b|delete\\s+from\\b|drop\\s+(?:table|database)\\b))[^\\n])*?\\bfrom\\b|insert\\s+into\\b|update\\s+\\S+\\s+set\\b|delete\\s+from\\b|drop\\s+(?:table|database)\\b))\\1(?:(?!\\b(?:select\\b|insert\\s+into\\b|update\\s+\\S+\\s+set\\b|delete\\s+from\\b|drop\\s+(?:table|database)\\b))[^\\n])*?(?:[%][sd]|\\{[^{}\\n]+\\})|\\b(?=(where\\b(?:(?!\\bwhere\\b)[^\\n])*?=))\\2(?:(?!\\bwhere\\b)[^\\n])*?(?:[%][sd]|\\{[^{}\\n]+\\})",
|
|
38080
37641
|
flags: "gi"
|
|
38081
37642
|
},
|
|
38082
37643
|
examples: [
|
|
@@ -38094,7 +37655,7 @@ var sql_inject_interp_default = {
|
|
|
38094
37655
|
severity: "high",
|
|
38095
37656
|
matcher: {
|
|
38096
37657
|
type: "regex",
|
|
38097
|
-
pattern: "(select|insert|update|delete|where)[^\\n]*?(#\\{|\\$[a-z_])",
|
|
37658
|
+
pattern: "(select|insert|update|delete|where)(?:(?!(?:select|insert|update|delete|where))[^\\n])*?(#\\{|\\$[a-z_])",
|
|
38098
37659
|
flags: "gi"
|
|
38099
37660
|
},
|
|
38100
37661
|
examples: [
|
|
@@ -38469,7 +38030,7 @@ var stack_trace_default = {
|
|
|
38469
38030
|
severity: "low",
|
|
38470
38031
|
matcher: {
|
|
38471
38032
|
type: "regex",
|
|
38472
|
-
pattern: "(
|
|
38033
|
+
pattern: "(?:^|(?<!\\s)\\s+)at\\s+[A-Za-z0-9._$<>]+\\.[A-Za-z0-9_$]+\\s*\\([A-Za-z0-9._\\-/:]+:\\d+:\\d+\\)",
|
|
38473
38034
|
flags: "g"
|
|
38474
38035
|
},
|
|
38475
38036
|
examples: ["at com.example.service.UserService.findUser(UserService.java:42:13)"]
|
|
@@ -39627,7 +39188,7 @@ var BUNDLED_PACKS = [
|
|
|
39627
39188
|
{
|
|
39628
39189
|
packId: "code-flaws",
|
|
39629
39190
|
name: "Code Security Flaws",
|
|
39630
|
-
version: "0.1.
|
|
39191
|
+
version: "0.1.1",
|
|
39631
39192
|
rawRules: [
|
|
39632
39193
|
sql_inject_concat_default,
|
|
39633
39194
|
sql_inject_concat_dot_default,
|
|
@@ -39677,7 +39238,7 @@ var BUNDLED_PACKS = [
|
|
|
39677
39238
|
{
|
|
39678
39239
|
packId: "core-code-context",
|
|
39679
39240
|
name: "Code Context",
|
|
39680
|
-
version: "0.2.
|
|
39241
|
+
version: "0.2.2",
|
|
39681
39242
|
rawRules: [
|
|
39682
39243
|
internal_ip_default,
|
|
39683
39244
|
localhost_ref_default,
|
|
@@ -39814,6 +39375,11 @@ function bundledDetections() {
|
|
|
39814
39375
|
}));
|
|
39815
39376
|
return cachedDetections;
|
|
39816
39377
|
}
|
|
39378
|
+
function shippedRegexMatchers() {
|
|
39379
|
+
return bundledDetections().flatMap((pack) => pack.rules).flatMap(
|
|
39380
|
+
(rule) => rule.matcher.type === "regex" ? [{ pattern: rule.matcher.pattern, flags: rule.matcher.flags }] : []
|
|
39381
|
+
);
|
|
39382
|
+
}
|
|
39817
39383
|
|
|
39818
39384
|
// ../../packages/plugin-sdk/src/mask.ts
|
|
39819
39385
|
var packsReady = false;
|
|
@@ -39835,8 +39401,8 @@ function bundledMaskingRules() {
|
|
|
39835
39401
|
}
|
|
39836
39402
|
|
|
39837
39403
|
// ../../packages/plugin-sdk/src/repo.ts
|
|
39838
|
-
import { existsSync as existsSync9, readFileSync as
|
|
39839
|
-
import { basename as basename2, dirname as dirname4, isAbsolute, join as
|
|
39404
|
+
import { existsSync as existsSync9, readFileSync as readFileSync11, statSync as statSync6 } from "fs";
|
|
39405
|
+
import { basename as basename2, dirname as dirname4, isAbsolute, join as join18, sep as sep2 } from "path";
|
|
39840
39406
|
function resolveRepo(cwd) {
|
|
39841
39407
|
try {
|
|
39842
39408
|
const location = locateRepo(cwd);
|
|
@@ -39856,36 +39422,36 @@ function resolveWorktreeRoot(cwd) {
|
|
|
39856
39422
|
function findGitRoot(start) {
|
|
39857
39423
|
let dir = start;
|
|
39858
39424
|
for (; ; ) {
|
|
39859
|
-
if (existsSync9(
|
|
39425
|
+
if (existsSync9(join18(dir, ".git"))) return dir;
|
|
39860
39426
|
const parent = dirname4(dir);
|
|
39861
39427
|
if (parent === dir) return void 0;
|
|
39862
39428
|
dir = parent;
|
|
39863
39429
|
}
|
|
39864
39430
|
}
|
|
39865
39431
|
function resolveGitContext(root) {
|
|
39866
|
-
const dotGit =
|
|
39432
|
+
const dotGit = join18(root, ".git");
|
|
39867
39433
|
try {
|
|
39868
39434
|
if (statSync6(dotGit).isDirectory()) {
|
|
39869
|
-
return { configPath:
|
|
39435
|
+
return { configPath: join18(dotGit, "config"), headRoot: root };
|
|
39870
39436
|
}
|
|
39871
39437
|
} catch {
|
|
39872
39438
|
return void 0;
|
|
39873
39439
|
}
|
|
39874
39440
|
const target = /^gitdir:\s*(.+?)\s*$/m.exec(safeRead(dotGit) ?? "")?.[1];
|
|
39875
39441
|
if (!target) return void 0;
|
|
39876
|
-
const gitdir = isAbsolute(target) ? target :
|
|
39877
|
-
if (existsSync9(
|
|
39878
|
-
return { configPath:
|
|
39442
|
+
const gitdir = isAbsolute(target) ? target : join18(root, target);
|
|
39443
|
+
if (existsSync9(join18(gitdir, "config"))) {
|
|
39444
|
+
return { configPath: join18(gitdir, "config"), headRoot: root };
|
|
39879
39445
|
}
|
|
39880
|
-
const commonRaw = safeRead(
|
|
39446
|
+
const commonRaw = safeRead(join18(gitdir, "commondir"))?.trim();
|
|
39881
39447
|
if (!commonRaw) return void 0;
|
|
39882
|
-
const commonGitDir = isAbsolute(commonRaw) ? commonRaw :
|
|
39448
|
+
const commonGitDir = isAbsolute(commonRaw) ? commonRaw : join18(gitdir, commonRaw);
|
|
39883
39449
|
const headRoot = basename2(commonGitDir) === ".git" ? dirname4(commonGitDir) : root;
|
|
39884
|
-
return { configPath:
|
|
39450
|
+
return { configPath: join18(commonGitDir, "config"), headRoot };
|
|
39885
39451
|
}
|
|
39886
39452
|
function safeRead(path) {
|
|
39887
39453
|
try {
|
|
39888
|
-
return
|
|
39454
|
+
return readFileSync11(path, "utf8");
|
|
39889
39455
|
} catch {
|
|
39890
39456
|
return void 0;
|
|
39891
39457
|
}
|
|
@@ -39932,9 +39498,9 @@ function slugFromUrl(url2) {
|
|
|
39932
39498
|
}
|
|
39933
39499
|
|
|
39934
39500
|
// ../../packages/plugin-sdk/src/events.ts
|
|
39935
|
-
import { createHash as
|
|
39501
|
+
import { createHash as createHash6, randomUUID as randomUUID13 } from "crypto";
|
|
39936
39502
|
function contentHashOf(text) {
|
|
39937
|
-
return
|
|
39503
|
+
return createHash6("sha256").update(text).digest("hex");
|
|
39938
39504
|
}
|
|
39939
39505
|
function buildIngestEvent(input2) {
|
|
39940
39506
|
const contentHash = input2.contentHash ?? contentHashOf(input2.content);
|
|
@@ -40109,9 +39675,10 @@ function createIsolatedScanner(data, opts = {}) {
|
|
|
40109
39675
|
if (job.timer !== void 0) return;
|
|
40110
39676
|
job.startedAt = performance.now();
|
|
40111
39677
|
job.progressAt = job.startedAt;
|
|
39678
|
+
const budget = job.deadlineAt === void 0 ? job.budgetMs : Math.max(0, Math.min(job.budgetMs, job.deadlineAt - job.startedAt));
|
|
40112
39679
|
job.timer = setTimeout(() => {
|
|
40113
39680
|
onDeadline(job);
|
|
40114
|
-
},
|
|
39681
|
+
}, budget);
|
|
40115
39682
|
}
|
|
40116
39683
|
function runOne(spec, fail2) {
|
|
40117
39684
|
if (closed) {
|
|
@@ -40122,6 +39689,12 @@ function createIsolatedScanner(data, opts = {}) {
|
|
|
40122
39689
|
fail2({ status: "unavailable", reason: `the scan worker crashed: ${broken}` });
|
|
40123
39690
|
return;
|
|
40124
39691
|
}
|
|
39692
|
+
const now = performance.now();
|
|
39693
|
+
const deadlineAt = spec.deadlineAt;
|
|
39694
|
+
if (deadlineAt !== void 0 && deadlineAt <= now) {
|
|
39695
|
+
fail2({ status: "timeout", culpritIndex: void 0, elapsedMs: 0 });
|
|
39696
|
+
return;
|
|
39697
|
+
}
|
|
40125
39698
|
const started = ensureWorker();
|
|
40126
39699
|
if (!(started instanceof Worker)) {
|
|
40127
39700
|
broken = started.error;
|
|
@@ -40129,11 +39702,11 @@ function createIsolatedScanner(data, opts = {}) {
|
|
|
40129
39702
|
return;
|
|
40130
39703
|
}
|
|
40131
39704
|
const id = nextJobId++;
|
|
40132
|
-
const now = performance.now();
|
|
40133
39705
|
const job = {
|
|
40134
39706
|
id,
|
|
40135
39707
|
worker: started,
|
|
40136
39708
|
budgetMs: spec.budgetMs,
|
|
39709
|
+
deadlineAt,
|
|
40137
39710
|
startedAt: now,
|
|
40138
39711
|
progressIndex: -1,
|
|
40139
39712
|
progressAt: now,
|
|
@@ -40147,14 +39720,19 @@ function createIsolatedScanner(data, opts = {}) {
|
|
|
40147
39720
|
if (readyWorker === started) {
|
|
40148
39721
|
beginDeadline(job);
|
|
40149
39722
|
} else {
|
|
39723
|
+
const startBudget = spec.startBudgetMs ?? startBudgetMs;
|
|
39724
|
+
const callerLimited = deadlineAt !== void 0 && deadlineAt - now < startBudget;
|
|
39725
|
+
const startWaitMs = callerLimited ? deadlineAt - now : startBudget;
|
|
40150
39726
|
job.startupTimer = setTimeout(() => {
|
|
40151
39727
|
if (pending !== job) return;
|
|
40152
39728
|
kill(job.worker);
|
|
40153
|
-
failPending(
|
|
40154
|
-
status: "
|
|
40155
|
-
|
|
40156
|
-
|
|
40157
|
-
|
|
39729
|
+
failPending(
|
|
39730
|
+
callerLimited ? { status: "timeout", culpritIndex: void 0, elapsedMs: performance.now() - now } : {
|
|
39731
|
+
status: "unavailable",
|
|
39732
|
+
reason: `the scan worker did not start within ${String(startBudget)}ms`
|
|
39733
|
+
}
|
|
39734
|
+
);
|
|
39735
|
+
}, startWaitMs);
|
|
40158
39736
|
}
|
|
40159
39737
|
try {
|
|
40160
39738
|
started.postMessage(spec.build(id));
|
|
@@ -40183,7 +39761,9 @@ function createIsolatedScanner(data, opts = {}) {
|
|
|
40183
39761
|
return enqueue((resolve4) => {
|
|
40184
39762
|
runOne(
|
|
40185
39763
|
{
|
|
40186
|
-
budgetMs,
|
|
39764
|
+
budgetMs: scanOpts?.budgetMs ?? budgetMs,
|
|
39765
|
+
startBudgetMs: scanOpts?.startBudgetMs,
|
|
39766
|
+
deadlineAt: scanOpts?.deadlineAt,
|
|
40187
39767
|
build: (id) => ({
|
|
40188
39768
|
kind: "scan",
|
|
40189
39769
|
id,
|
|
@@ -40377,6 +39957,9 @@ function createGuardedScanner(partition, gateway, opts) {
|
|
|
40377
39957
|
let unverified = partition.unverified;
|
|
40378
39958
|
let isolated = unverified.length > 0 ? createIsolatedScanner({ verified, unverified }, opts) : void 0;
|
|
40379
39959
|
let retired = false;
|
|
39960
|
+
let bounded;
|
|
39961
|
+
let boundedWarned = false;
|
|
39962
|
+
let closed = false;
|
|
40380
39963
|
function inProcess(text, context) {
|
|
40381
39964
|
return scan(text, verified, context);
|
|
40382
39965
|
}
|
|
@@ -40438,80 +40021,52 @@ function createGuardedScanner(partition, gateway, opts) {
|
|
|
40438
40021
|
await degrade();
|
|
40439
40022
|
return inProcess(text, context);
|
|
40440
40023
|
}
|
|
40024
|
+
async function scanBounded(text, context, bound) {
|
|
40025
|
+
const remainingMs = bound.remainingMs;
|
|
40026
|
+
let outcome;
|
|
40027
|
+
if (closed) {
|
|
40028
|
+
outcome = { status: "unavailable", reason: "the scan worker is closed" };
|
|
40029
|
+
} else if (remainingMs !== void 0 && !(remainingMs > 0)) {
|
|
40030
|
+
outcome = { status: "timeout", culpritIndex: void 0, elapsedMs: 0 };
|
|
40031
|
+
} else {
|
|
40032
|
+
bounded ??= createIsolatedScanner({ verified, unverified }, opts);
|
|
40033
|
+
const deadlineAt = remainingMs === void 0 ? void 0 : performance.now() + remainingMs;
|
|
40034
|
+
try {
|
|
40035
|
+
outcome = await bounded.scan(text, context, {
|
|
40036
|
+
budgetMs: bound.budgetMs,
|
|
40037
|
+
startBudgetMs: bound.startBudgetMs,
|
|
40038
|
+
deadlineAt
|
|
40039
|
+
});
|
|
40040
|
+
} catch (error62) {
|
|
40041
|
+
outcome = {
|
|
40042
|
+
status: "unavailable",
|
|
40043
|
+
reason: error62 instanceof Error ? error62.message : "the scan worker failed unexpectedly"
|
|
40044
|
+
};
|
|
40045
|
+
}
|
|
40046
|
+
}
|
|
40047
|
+
if (outcome.status !== "ok" && !boundedWarned) {
|
|
40048
|
+
boundedWarned = true;
|
|
40049
|
+
process.stderr.write(
|
|
40050
|
+
outcome.status === "timeout" ? `[aka] a large input could not be scanned within its time limit and was refused.
|
|
40051
|
+
` : `[aka] a large input could not be scanned and was refused: ${outcome.reason}.
|
|
40052
|
+
`
|
|
40053
|
+
);
|
|
40054
|
+
}
|
|
40055
|
+
return outcome;
|
|
40056
|
+
}
|
|
40441
40057
|
return {
|
|
40442
40058
|
scan: guardedScan,
|
|
40059
|
+
scanBounded,
|
|
40443
40060
|
degraded: () => retired,
|
|
40444
40061
|
async close() {
|
|
40445
|
-
|
|
40062
|
+
closed = true;
|
|
40063
|
+
const live = bounded;
|
|
40064
|
+
bounded = void 0;
|
|
40065
|
+
await Promise.all([retire(), live?.close()]);
|
|
40446
40066
|
}
|
|
40447
40067
|
};
|
|
40448
40068
|
}
|
|
40449
40069
|
|
|
40450
|
-
// ../../packages/plugin-sdk/src/hook-fail-opens.ts
|
|
40451
|
-
import { readFileSync as readFileSync12 } from "fs";
|
|
40452
|
-
import { join as join19 } from "path";
|
|
40453
|
-
|
|
40454
|
-
// ../../packages/plugin-sdk/src/host-floor.ts
|
|
40455
|
-
import { readFileSync as readFileSync14 } from "fs";
|
|
40456
|
-
import { join as join21 } from "path";
|
|
40457
|
-
|
|
40458
|
-
// ../../packages/plugin-sdk/src/model-governance.ts
|
|
40459
|
-
import {
|
|
40460
|
-
closeSync as closeSync2,
|
|
40461
|
-
fstatSync,
|
|
40462
|
-
mkdirSync as mkdirSync2,
|
|
40463
|
-
openSync as openSync2,
|
|
40464
|
-
readFileSync as readFileSync13,
|
|
40465
|
-
readSync,
|
|
40466
|
-
writeFileSync as writeFileSync5
|
|
40467
|
-
} from "fs";
|
|
40468
|
-
import { join as join20 } from "path";
|
|
40469
|
-
var TAIL_BYTES = 256 * 1024;
|
|
40470
|
-
|
|
40471
|
-
// ../../packages/plugin-sdk/src/host-floor.ts
|
|
40472
|
-
var HOST_FEATURE = {
|
|
40473
|
-
ModelSwitch: "model-switch",
|
|
40474
|
-
VaultPointerDisplay: "vault-pointer-display"
|
|
40475
|
-
};
|
|
40476
|
-
var HOST_FLOORS = {
|
|
40477
|
-
[HOST_FEATURE.ModelSwitch]: {
|
|
40478
|
-
label: "model-switch protection",
|
|
40479
|
-
hookEvents: ["PreModelSwitch", "PostModelSwitch"],
|
|
40480
|
-
since: "2.1.251"
|
|
40481
|
-
},
|
|
40482
|
-
[HOST_FEATURE.VaultPointerDisplay]: {
|
|
40483
|
-
label: "vault pointer display",
|
|
40484
|
-
hookEvents: ["MessageDisplay"],
|
|
40485
|
-
since: "2.1.152"
|
|
40486
|
-
}
|
|
40487
|
-
};
|
|
40488
|
-
var ANTIGRAVITY_HOST_FEATURE = {
|
|
40489
|
-
EndOfTurnCapture: "end-of-turn-capture"
|
|
40490
|
-
};
|
|
40491
|
-
var ANTIGRAVITY_HOST_FLOORS = {
|
|
40492
|
-
[ANTIGRAVITY_HOST_FEATURE.EndOfTurnCapture]: {
|
|
40493
|
-
label: "end-of-turn history capture",
|
|
40494
|
-
hookEvents: ["Stop"],
|
|
40495
|
-
since: "1.1.10"
|
|
40496
|
-
}
|
|
40497
|
-
};
|
|
40498
|
-
|
|
40499
|
-
// ../../packages/plugin-sdk/src/ignore-layers.ts
|
|
40500
|
-
var import_ignore = __toESM(require_ignore(), 1);
|
|
40501
|
-
import { readFileSync as readFileSync15 } from "fs";
|
|
40502
|
-
import { join as join22 } from "path";
|
|
40503
|
-
|
|
40504
|
-
// ../../packages/plugin-sdk/src/inventory-resolver.ts
|
|
40505
|
-
import { arch, hostname as hostname4, platform, release } from "os";
|
|
40506
|
-
|
|
40507
|
-
// ../../packages/plugin-sdk/src/nudge.ts
|
|
40508
|
-
import { mkdirSync as mkdirSync3, readFileSync as readFileSync16, writeFileSync as writeFileSync6 } from "fs";
|
|
40509
|
-
import { join as join23 } from "path";
|
|
40510
|
-
|
|
40511
|
-
// ../../packages/plugin-sdk/src/paths.ts
|
|
40512
|
-
import { readdirSync as readdirSync3, realpathSync as realpathSync3 } from "fs";
|
|
40513
|
-
import { basename as basename4, dirname as dirname5, sep as sep3 } from "path";
|
|
40514
|
-
|
|
40515
40070
|
// ../../packages/plugin-sdk/src/policy-resolver.ts
|
|
40516
40071
|
import { randomUUID as randomUUID14 } from "crypto";
|
|
40517
40072
|
function createPolicyResolver(bundle) {
|
|
@@ -40569,36 +40124,6 @@ function applyCategoryPosture(posture, repo, mode = "fill-gaps") {
|
|
|
40569
40124
|
}
|
|
40570
40125
|
}
|
|
40571
40126
|
|
|
40572
|
-
// ../../packages/plugin-sdk/src/project-files.ts
|
|
40573
|
-
import { existsSync as existsSync11, readdirSync as readdirSync4 } from "fs";
|
|
40574
|
-
import { basename as basename5, join as join24 } from "path";
|
|
40575
|
-
|
|
40576
|
-
// ../../packages/plugin-sdk/src/provider-env-antigravity.ts
|
|
40577
|
-
var optionalBaseUrl2 = external_exports.preprocess((v) => {
|
|
40578
|
-
if (typeof v === "string" && v.trim() === "") return void 0;
|
|
40579
|
-
return v;
|
|
40580
|
-
}, external_exports.string().optional()).catch(void 0);
|
|
40581
|
-
var optionalFlag = external_exports.preprocess((v) => {
|
|
40582
|
-
if (typeof v !== "string") return false;
|
|
40583
|
-
const normalized = v.trim().toLowerCase();
|
|
40584
|
-
return normalized !== "" && normalized !== "0" && normalized !== "false";
|
|
40585
|
-
}, external_exports.boolean()).catch(false);
|
|
40586
|
-
var antigravityProviderEnvShape = {
|
|
40587
|
-
GOOGLE_GENAI_USE_VERTEXAI: optionalFlag,
|
|
40588
|
-
GOOGLE_GEMINI_BASE_URL: optionalBaseUrl2
|
|
40589
|
-
};
|
|
40590
|
-
var AntigravityProviderEnvSchema = external_exports.object(antigravityProviderEnvShape);
|
|
40591
|
-
|
|
40592
|
-
// ../../packages/plugin-sdk/src/provider-env-codex.ts
|
|
40593
|
-
var optionalBaseUrl3 = external_exports.preprocess((v) => {
|
|
40594
|
-
if (typeof v === "string" && v.trim() === "") return void 0;
|
|
40595
|
-
return v;
|
|
40596
|
-
}, external_exports.string().optional()).catch(void 0);
|
|
40597
|
-
var codexProviderEnvShape = {
|
|
40598
|
-
OPENAI_BASE_URL: optionalBaseUrl3
|
|
40599
|
-
};
|
|
40600
|
-
var CodexProviderEnvSchema = external_exports.object(codexProviderEnvShape);
|
|
40601
|
-
|
|
40602
40127
|
// ../../packages/plugin-sdk/src/runtime.ts
|
|
40603
40128
|
import { randomUUID as randomUUID15 } from "crypto";
|
|
40604
40129
|
var ENFORCEMENT_CEILING_ENABLED = false;
|
|
@@ -40639,6 +40164,16 @@ function conditionsMatch(conditions, ctx) {
|
|
|
40639
40164
|
if (conditions.provider !== void 0) return false;
|
|
40640
40165
|
return true;
|
|
40641
40166
|
}
|
|
40167
|
+
function readRemainingMs(largeInput) {
|
|
40168
|
+
const read = largeInput.remainingMs;
|
|
40169
|
+
if (read === void 0) return void 0;
|
|
40170
|
+
try {
|
|
40171
|
+
const remaining = read();
|
|
40172
|
+
return typeof remaining !== "number" || Number.isNaN(remaining) ? 0 : remaining;
|
|
40173
|
+
} catch {
|
|
40174
|
+
return 0;
|
|
40175
|
+
}
|
|
40176
|
+
}
|
|
40642
40177
|
var bundlesPacked = false;
|
|
40643
40178
|
function createPluginRuntime(gateway, settings, opts) {
|
|
40644
40179
|
if (!bundlesPacked) {
|
|
@@ -40648,6 +40183,7 @@ function createPluginRuntime(gateway, settings, opts) {
|
|
|
40648
40183
|
const policyMode = settings.policy;
|
|
40649
40184
|
let redactFallback = settings.redactFallback;
|
|
40650
40185
|
const dataDir2 = opts?.dataDir;
|
|
40186
|
+
const largeInput = opts?.largeInput;
|
|
40651
40187
|
let rules = [];
|
|
40652
40188
|
let evidenceOf = evidenceLookup(rules);
|
|
40653
40189
|
let scanner;
|
|
@@ -40860,7 +40396,24 @@ function createPluginRuntime(gateway, settings, opts) {
|
|
|
40860
40396
|
await ensureInitialized();
|
|
40861
40397
|
if (!scanner) throw new Error("the runtime initialized without a scanner");
|
|
40862
40398
|
const shielded = shieldPointers(text);
|
|
40863
|
-
|
|
40399
|
+
let matched;
|
|
40400
|
+
if (largeInput !== void 0 && shielded.text.length >= largeInput.thresholdChars) {
|
|
40401
|
+
const outcome = await scanner.scanBounded(shielded.text, context, {
|
|
40402
|
+
budgetMs: largeInput.budgetMs,
|
|
40403
|
+
startBudgetMs: largeInput.startBudgetMs,
|
|
40404
|
+
remainingMs: readRemainingMs(largeInput)
|
|
40405
|
+
});
|
|
40406
|
+
if (outcome.status !== "ok") {
|
|
40407
|
+
return {
|
|
40408
|
+
decision: { action: "block", text: null, findings: [], scanIncomplete: outcome.status },
|
|
40409
|
+
excepted: /* @__PURE__ */ new Set(),
|
|
40410
|
+
exceptionIds: []
|
|
40411
|
+
};
|
|
40412
|
+
}
|
|
40413
|
+
matched = outcome.findings;
|
|
40414
|
+
} else {
|
|
40415
|
+
matched = await scanner.scan(shielded.text, context);
|
|
40416
|
+
}
|
|
40864
40417
|
const findings = dropShieldedFindings(matched, shielded.spans);
|
|
40865
40418
|
const fpCache = /* @__PURE__ */ new Map();
|
|
40866
40419
|
const { excepted, exceptionIds } = await applyExceptions(findings, ctx, fpCache);
|
|
@@ -40885,12 +40438,11 @@ function createPluginRuntime(gateway, settings, opts) {
|
|
|
40885
40438
|
async function processText(text, context, opts2 = {}) {
|
|
40886
40439
|
return (await evaluate(text, context, {}, opts2.rewritable)).decision;
|
|
40887
40440
|
}
|
|
40888
|
-
async function
|
|
40441
|
+
async function evaluateCapture(input2, opts2) {
|
|
40889
40442
|
const timingStartedAt = input2.occurredAt === void 0 ? startTiming() : void 0;
|
|
40890
|
-
const filePath = input2.metadata?.filePath;
|
|
40891
40443
|
const { decision, excepted, exceptionIds } = await evaluate(
|
|
40892
40444
|
input2.text,
|
|
40893
|
-
{ filePath, eventKind: input2.kind },
|
|
40445
|
+
{ filePath: input2.metadata?.filePath, eventKind: input2.kind },
|
|
40894
40446
|
{
|
|
40895
40447
|
sourceTool: input2.sourceTool,
|
|
40896
40448
|
metadata: input2.metadata,
|
|
@@ -40898,20 +40450,28 @@ function createPluginRuntime(gateway, settings, opts) {
|
|
|
40898
40450
|
},
|
|
40899
40451
|
opts2.rewritable
|
|
40900
40452
|
);
|
|
40901
|
-
|
|
40453
|
+
return { decision, excepted, exceptionIds, timingStartedAt };
|
|
40454
|
+
}
|
|
40455
|
+
async function persistCapture(input2, opts2, { decision, excepted, exceptionIds, timingStartedAt }) {
|
|
40456
|
+
const filePath = input2.metadata?.filePath;
|
|
40457
|
+
if (opts2.persist === "with-findings" && decision.findings.length === 0 && decision.scanIncomplete === void 0) {
|
|
40458
|
+
return;
|
|
40459
|
+
}
|
|
40902
40460
|
try {
|
|
40903
40461
|
const contentHash = contentHashOf(input2.text);
|
|
40904
40462
|
const maskedFindings = decision.findings.filter(
|
|
40905
40463
|
(match) => isActionAtLeast(actionForFinding(match, excepted, opts2.rewritable), "redact")
|
|
40906
40464
|
);
|
|
40907
|
-
const storedContent = maskedFindings.length > 0 ? redact(input2.text, maskedFindings) : input2.text;
|
|
40465
|
+
const storedContent = decision.scanIncomplete !== void 0 ? "" : maskedFindings.length > 0 ? redact(input2.text, maskedFindings) : input2.text;
|
|
40908
40466
|
const inspectionMs = elapsedMs(timingStartedAt);
|
|
40909
40467
|
const redactDegradedTo = decision.redactDegradedTo;
|
|
40910
|
-
const
|
|
40468
|
+
const scanIncomplete = decision.scanIncomplete;
|
|
40469
|
+
const metadata = exceptionIds.length > 0 || inspectionMs !== void 0 || redactDegradedTo !== void 0 || scanIncomplete !== void 0 ? {
|
|
40911
40470
|
...input2.metadata,
|
|
40912
40471
|
...exceptionIds.length > 0 ? { exceptionIds } : {},
|
|
40913
40472
|
...inspectionMs !== void 0 ? { inspectionMs } : {},
|
|
40914
|
-
...redactDegradedTo !== void 0 ? { redactDegradedTo } : {}
|
|
40473
|
+
...redactDegradedTo !== void 0 ? { redactDegradedTo } : {},
|
|
40474
|
+
...scanIncomplete !== void 0 ? { scanIncomplete } : {}
|
|
40915
40475
|
} : input2.metadata;
|
|
40916
40476
|
const event = buildIngestEvent({
|
|
40917
40477
|
kind: input2.kind,
|
|
@@ -40941,6 +40501,8 @@ function createPluginRuntime(gateway, settings, opts) {
|
|
|
40941
40501
|
// exceptions/blocked_detections when a key is available;
|
|
40942
40502
|
// falls back to the masked match so at-rest findings still get
|
|
40943
40503
|
// a stable (if weaker) identity on a workspace with no dataDir.
|
|
40504
|
+
// Both ignore the same invisible padding, so a clean and a
|
|
40505
|
+
// padded occurrence of one secret key alike on either path.
|
|
40944
40506
|
valueFingerprint: findingKeyFingerprintKey ? fingerprintOf(findingKeyFingerprintKey, match, findingKeyFpCache) : maskedMatch
|
|
40945
40507
|
}) : void 0;
|
|
40946
40508
|
return {
|
|
@@ -40968,7 +40530,37 @@ function createPluginRuntime(gateway, settings, opts) {
|
|
|
40968
40530
|
}
|
|
40969
40531
|
} catch {
|
|
40970
40532
|
}
|
|
40971
|
-
|
|
40533
|
+
}
|
|
40534
|
+
async function enforcedIn(text, context) {
|
|
40535
|
+
try {
|
|
40536
|
+
await ensureInitialized();
|
|
40537
|
+
if (!scanner) return [];
|
|
40538
|
+
const shielded = shieldPointers(text);
|
|
40539
|
+
const matched = await scanner.scan(shielded.text, context);
|
|
40540
|
+
return dropShieldedFindings(matched, shielded.spans).filter((finding) => {
|
|
40541
|
+
const action = resolveAction(finding.ruleId, finding.category);
|
|
40542
|
+
return action === "block" || action === "redact";
|
|
40543
|
+
});
|
|
40544
|
+
} catch {
|
|
40545
|
+
return [];
|
|
40546
|
+
}
|
|
40547
|
+
}
|
|
40548
|
+
async function capture(input2, opts2 = {}) {
|
|
40549
|
+
const evaluated = await evaluateCapture(input2, opts2);
|
|
40550
|
+
await persistCapture(input2, opts2, evaluated);
|
|
40551
|
+
return evaluated.decision;
|
|
40552
|
+
}
|
|
40553
|
+
async function captureDeferred(input2, opts2 = {}) {
|
|
40554
|
+
const evaluated = await evaluateCapture(input2, opts2);
|
|
40555
|
+
let recorded = false;
|
|
40556
|
+
return {
|
|
40557
|
+
result: evaluated.decision,
|
|
40558
|
+
record: async () => {
|
|
40559
|
+
if (recorded) return;
|
|
40560
|
+
recorded = true;
|
|
40561
|
+
await persistCapture(input2, opts2, evaluated);
|
|
40562
|
+
}
|
|
40563
|
+
};
|
|
40972
40564
|
}
|
|
40973
40565
|
async function rulesetFingerprint() {
|
|
40974
40566
|
try {
|
|
@@ -40989,20 +40581,17 @@ function createPluginRuntime(gateway, settings, opts) {
|
|
|
40989
40581
|
}
|
|
40990
40582
|
await gateway.close();
|
|
40991
40583
|
}
|
|
40992
|
-
return {
|
|
40584
|
+
return {
|
|
40585
|
+
processText,
|
|
40586
|
+
capture,
|
|
40587
|
+
captureDeferred,
|
|
40588
|
+
enforcedIn,
|
|
40589
|
+
rulesetFingerprint,
|
|
40590
|
+
scanIsolationDegraded,
|
|
40591
|
+
close
|
|
40592
|
+
};
|
|
40993
40593
|
}
|
|
40994
40594
|
|
|
40995
|
-
// ../../packages/plugin-sdk/src/scope-key.ts
|
|
40996
|
-
import { existsSync as existsSync12 } from "fs";
|
|
40997
|
-
import { dirname as dirname6, isAbsolute as isAbsolute2, join as join25, normalize } from "path";
|
|
40998
|
-
|
|
40999
|
-
// ../../packages/plugin-sdk/src/suppressions.ts
|
|
41000
|
-
var THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1e3;
|
|
41001
|
-
|
|
41002
|
-
// ../../packages/plugin-sdk/src/throttle.ts
|
|
41003
|
-
import { mkdirSync as mkdirSync4, statSync as statSync8, writeFileSync as writeFileSync7 } from "fs";
|
|
41004
|
-
import { join as join26 } from "path";
|
|
41005
|
-
|
|
41006
40595
|
// ../../packages/setup-wizard/src/remediation/chain.ts
|
|
41007
40596
|
var REMEDIATION_OPTIONS = [
|
|
41008
40597
|
{ id: "redact-rotation-checklist", label: "Redact + rotation checklist" },
|
|
@@ -41043,8 +40632,8 @@ function routeRemediationOption(option, handlers) {
|
|
|
41043
40632
|
}
|
|
41044
40633
|
|
|
41045
40634
|
// ../../packages/setup-wizard/src/remediation/rotation-checklist.ts
|
|
41046
|
-
import { writeFileSync as
|
|
41047
|
-
import { join as
|
|
40635
|
+
import { writeFileSync as writeFileSync5 } from "fs";
|
|
40636
|
+
import { join as join19 } from "path";
|
|
41048
40637
|
var GENERIC_CONSOLE_PATH = "rotate via the provider's own console";
|
|
41049
40638
|
var CONSOLE_PATHS = {
|
|
41050
40639
|
anthropic: "console.anthropic.com \u2192 Settings \u2192 API keys",
|
|
@@ -41129,7 +40718,7 @@ function renderRotationChecklistResolvedLine(location) {
|
|
|
41129
40718
|
return `\u2713 I drafted a rotation checklist for you (${location}).`;
|
|
41130
40719
|
}
|
|
41131
40720
|
function writeRotationChecklist(entries, targetDirectory) {
|
|
41132
|
-
|
|
40721
|
+
writeFileSync5(
|
|
41133
40722
|
`${targetDirectory}/rotation-checklist.md`,
|
|
41134
40723
|
renderChecklistMarkdown(entries),
|
|
41135
40724
|
"utf8"
|
|
@@ -41144,7 +40733,7 @@ function generateRotationChecklist(input2) {
|
|
|
41144
40733
|
try {
|
|
41145
40734
|
const target = resolveRotationChecklistTarget(input2.cwd);
|
|
41146
40735
|
targetDirectory = target.directory;
|
|
41147
|
-
const filePath =
|
|
40736
|
+
const filePath = join19(target.directory, "rotation-checklist.md");
|
|
41148
40737
|
writeRotationChecklist(input2.entries, target.directory);
|
|
41149
40738
|
return {
|
|
41150
40739
|
status: "written",
|
|
@@ -41255,9 +40844,9 @@ var RANK = Object.fromEntries(
|
|
|
41255
40844
|
);
|
|
41256
40845
|
|
|
41257
40846
|
// ../../packages/setup-wizard/src/triage/plan-file.ts
|
|
41258
|
-
import { mkdtempSync, readFileSync as
|
|
40847
|
+
import { mkdtempSync, readFileSync as readFileSync12, rmdirSync, rmSync as rmSync7, writeFileSync as writeFileSync6 } from "fs";
|
|
41259
40848
|
import { tmpdir } from "os";
|
|
41260
|
-
import { basename as
|
|
40849
|
+
import { basename as basename3, dirname as dirname5, join as join20 } from "path";
|
|
41261
40850
|
var SuppressionEntrySchema = external_exports.object({
|
|
41262
40851
|
ruleId: external_exports.string(),
|
|
41263
40852
|
category: DetectionCategory,
|
|
@@ -41375,8 +40964,8 @@ function table(headers, rows, opts = {}) {
|
|
|
41375
40964
|
const widths = headers.map(
|
|
41376
40965
|
(h, i) => Math.max(visibleLength(h), ...rows.map((r) => visibleLength(r[i] ?? "")))
|
|
41377
40966
|
);
|
|
41378
|
-
const
|
|
41379
|
-
const fmt = (cells) => cells.map((cell, i) => padEnd(cell, widths[i] ?? 0)).join(
|
|
40967
|
+
const sep3 = " ".repeat(gap);
|
|
40968
|
+
const fmt = (cells) => cells.map((cell, i) => padEnd(cell, widths[i] ?? 0)).join(sep3);
|
|
41380
40969
|
const headerLine = fmt(headers.map((h) => h.toUpperCase()));
|
|
41381
40970
|
if (opts.rowSep === true) {
|
|
41382
40971
|
const fullWidth = widths.reduce((n, w) => n + w, 0) + gap * Math.max(0, widths.length - 1);
|
|
@@ -41388,7 +40977,7 @@ function table(headers, rows, opts = {}) {
|
|
|
41388
40977
|
});
|
|
41389
40978
|
return [headerLine, rule, ...body].join("\n");
|
|
41390
40979
|
}
|
|
41391
|
-
const ruleLine = widths.map((w) => "\u2500".repeat(w)).join(
|
|
40980
|
+
const ruleLine = widths.map((w) => "\u2500".repeat(w)).join(sep3);
|
|
41392
40981
|
return [headerLine, ruleLine, ...rows.map(fmt)].join("\n");
|
|
41393
40982
|
}
|
|
41394
40983
|
function fenced(body) {
|
|
@@ -41401,8 +40990,8 @@ function show(body) {
|
|
|
41401
40990
|
}
|
|
41402
40991
|
|
|
41403
40992
|
// src/skills-registry.ts
|
|
41404
|
-
import { readdirSync as
|
|
41405
|
-
import { join as
|
|
40993
|
+
import { readdirSync as readdirSync2, readFileSync as readFileSync13 } from "fs";
|
|
40994
|
+
import { join as join21 } from "path";
|
|
41406
40995
|
import { fileURLToPath as fileURLToPath2 } from "url";
|
|
41407
40996
|
var SKILLS_DIR = fileURLToPath2(new URL("../skills", import.meta.url));
|
|
41408
40997
|
function frontmatterName(content) {
|
|
@@ -41412,10 +41001,10 @@ function frontmatterName(content) {
|
|
|
41412
41001
|
return name?.[1];
|
|
41413
41002
|
}
|
|
41414
41003
|
function readRegisteredSkills() {
|
|
41415
|
-
return
|
|
41004
|
+
return readdirSync2(SKILLS_DIR, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => {
|
|
41416
41005
|
let content;
|
|
41417
41006
|
try {
|
|
41418
|
-
content =
|
|
41007
|
+
content = readFileSync13(join21(SKILLS_DIR, entry.name, "SKILL.md"), "utf8");
|
|
41419
41008
|
} catch {
|
|
41420
41009
|
return [];
|
|
41421
41010
|
}
|
|
@@ -41476,7 +41065,7 @@ function renderRemediationDecision(findings, moreCount, registry2) {
|
|
|
41476
41065
|
}
|
|
41477
41066
|
|
|
41478
41067
|
// src/remediation/surfaced-redact.ts
|
|
41479
|
-
import { readFileSync as
|
|
41068
|
+
import { readFileSync as readFileSync20 } from "fs";
|
|
41480
41069
|
|
|
41481
41070
|
// ../../packages/remote/src/http.ts
|
|
41482
41071
|
import { request as httpRequest } from "http";
|
|
@@ -41854,11 +41443,11 @@ function withTimeout(promise2, ms) {
|
|
|
41854
41443
|
}
|
|
41855
41444
|
|
|
41856
41445
|
// ../../packages/plugin-runtime/src/attached/forward-drops.ts
|
|
41857
|
-
import { readFileSync as
|
|
41858
|
-
import { join as
|
|
41446
|
+
import { readFileSync as readFileSync14 } from "fs";
|
|
41447
|
+
import { join as join22 } from "path";
|
|
41859
41448
|
var FORWARD_DROPS_FILENAME = ATTACHED_FORWARD_DROPS_FILENAME;
|
|
41860
41449
|
function forwardDropsPath(dataDir2) {
|
|
41861
|
-
return
|
|
41450
|
+
return join22(dataDir2, FORWARD_DROPS_FILENAME);
|
|
41862
41451
|
}
|
|
41863
41452
|
function recordForwardDrops(dataDir2, count, nowMs) {
|
|
41864
41453
|
if (count <= 0) return;
|
|
@@ -41876,7 +41465,7 @@ function recordForwardDrops(dataDir2, count, nowMs) {
|
|
|
41876
41465
|
}
|
|
41877
41466
|
function readForwardDrops(dataDir2) {
|
|
41878
41467
|
try {
|
|
41879
|
-
const parsed2 = JSON.parse(
|
|
41468
|
+
const parsed2 = JSON.parse(readFileSync14(forwardDropsPath(dataDir2), "utf8"));
|
|
41880
41469
|
if (typeof parsed2 !== "object" || parsed2 === null) return null;
|
|
41881
41470
|
const record2 = parsed2;
|
|
41882
41471
|
if (typeof record2.droppedForwards !== "number" || !Number.isFinite(record2.droppedForwards)) {
|
|
@@ -41895,7 +41484,7 @@ function readForwardDrops(dataDir2) {
|
|
|
41895
41484
|
// ../../packages/plugin-runtime/src/attached/forward-policy.ts
|
|
41896
41485
|
import { randomUUID as randomUUID16 } from "crypto";
|
|
41897
41486
|
import { readFile, rename, writeFile } from "fs/promises";
|
|
41898
|
-
import { join as
|
|
41487
|
+
import { join as join23 } from "path";
|
|
41899
41488
|
function isInvalidRequest(err) {
|
|
41900
41489
|
return typeof err === "object" && err !== null && err.name === "RemoteRequestInvalid";
|
|
41901
41490
|
}
|
|
@@ -41914,7 +41503,7 @@ var FORWARD_STATE_FILENAME = ATTACHED_FORWARD_STATE_FILENAME;
|
|
|
41914
41503
|
var STATE_FILENAME = FORWARD_STATE_FILENAME;
|
|
41915
41504
|
function createForwardPolicy(deps) {
|
|
41916
41505
|
const now = deps.now ?? (() => Date.now());
|
|
41917
|
-
const file2 =
|
|
41506
|
+
const file2 = join23(deps.dir, STATE_FILENAME);
|
|
41918
41507
|
let state = null;
|
|
41919
41508
|
let loading = null;
|
|
41920
41509
|
async function readState() {
|
|
@@ -42080,6 +41669,9 @@ var AttachedDataGateway = class {
|
|
|
42080
41669
|
*
|
|
42081
41670
|
* Machine mode answers before any key is read, so a machine attachment pays
|
|
42082
41671
|
* nothing for scoping and forwards exactly what it always has.
|
|
41672
|
+
*
|
|
41673
|
+
* `governanceAppliesTo` answers from this same verdict, so it agrees with
|
|
41674
|
+
* forwarding key for key.
|
|
42083
41675
|
*/
|
|
42084
41676
|
verdictFor(keyOf) {
|
|
42085
41677
|
try {
|
|
@@ -42096,24 +41688,27 @@ var AttachedDataGateway = class {
|
|
|
42096
41688
|
* the key its row holds in the local store, recorded per root (see
|
|
42097
41689
|
* `rootVerdict`), not the key on the root event just handed in: roots are
|
|
42098
41690
|
* first-write-wins in the store, so when two producers record a root for one
|
|
42099
|
-
* session (the session-start hook, then a reconcile pass) the second leaves
|
|
42100
|
-
*
|
|
42101
|
-
*
|
|
42102
|
-
*
|
|
42103
|
-
*
|
|
42104
|
-
*
|
|
42105
|
-
*
|
|
42106
|
-
*
|
|
42107
|
-
*
|
|
42108
|
-
*
|
|
42109
|
-
*
|
|
42110
|
-
*
|
|
42111
|
-
*
|
|
42112
|
-
*
|
|
42113
|
-
*
|
|
42114
|
-
*
|
|
42115
|
-
*
|
|
42116
|
-
*
|
|
41691
|
+
* session (the session-start hook, then a reconcile pass) the second leaves the
|
|
41692
|
+
* stored row as it was. That stored row, not this event, is what a history
|
|
41693
|
+
* drain pass would decide, if the root started before the attach; the drain
|
|
41694
|
+
* never offers one that started after it (`started_at < backlogBefore`).
|
|
41695
|
+
* Whether this root EVENT is itself sent takes both keys: the stored one AND
|
|
41696
|
+
* its own. The event's attributes (cwd, project, repo) describe where it was
|
|
41697
|
+
* recorded from, so a root event keyed to a personal directory is never sent
|
|
41698
|
+
* under an enrolled stored root, though the enrolled leaves still forward under
|
|
41699
|
+
* it: the instance that wrote the stored root is expected to have forwarded it.
|
|
41700
|
+
* If it did not (the root was written while standalone or under another
|
|
41701
|
+
* attachment, or its forward failed), the plane refuses those leaves. A root
|
|
41702
|
+
* that started before the attach is shipped, ahead of its leaves, by the
|
|
41703
|
+
* history drain; one that started after it is never offered by the drain. Any
|
|
41704
|
+
* other row with a root reference (`rootSessionId`, else `parentId`) forwards
|
|
41705
|
+
* only when its own key is in scope AND this instance recorded an in-scope
|
|
41706
|
+
* verdict for that root. The audit-event route has real foreign keys on both
|
|
41707
|
+
* columns and stubs no missing root, so a leaf sent after its root was kept
|
|
41708
|
+
* local is refused there, and a refused forward counts toward the breaker that
|
|
41709
|
+
* guards every other one. A root this instance never recorded is therefore
|
|
41710
|
+
* `'local'`: the only answer that cannot orphan a row. A row with no root
|
|
41711
|
+
* reference at all has nothing to orphan, and is decided by its own key.
|
|
42117
41712
|
*
|
|
42118
41713
|
* What this costs is stated rather than discovered. A session whose stored
|
|
42119
41714
|
* root is not keyed to an enrolled repository keeps its token and tool
|
|
@@ -42184,6 +41779,87 @@ var AttachedDataGateway = class {
|
|
|
42184
41779
|
return [];
|
|
42185
41780
|
}
|
|
42186
41781
|
}
|
|
41782
|
+
/**
|
|
41783
|
+
* The verdict for the repositories nested in a scanned project, answered
|
|
41784
|
+
* TOTALLY: `'forward'` or `'local'`, never a throw.
|
|
41785
|
+
*
|
|
41786
|
+
* A walk descends into a nested clone or submodule and folds its files into
|
|
41787
|
+
* the project it is walking, so one register can carry several
|
|
41788
|
+
* repositories' call sites under one project key. Each of them must be in
|
|
41789
|
+
* scope for it to forward. One key out of scope, or a nested repository with
|
|
41790
|
+
* no remote (an `undefined` key), keeps the whole register local.
|
|
41791
|
+
*
|
|
41792
|
+
* An ABSENT list is `'local'` too. Only the code that walked the tree can say
|
|
41793
|
+
* what is nested in it, and every scan passes the list, empty when nothing
|
|
41794
|
+
* is nested. A register nobody vouched for is not one a scoped attachment
|
|
41795
|
+
* may send.
|
|
41796
|
+
*
|
|
41797
|
+
* Machine mode answers before reading the context, so a machine attachment
|
|
41798
|
+
* forwards exactly what it always has.
|
|
41799
|
+
*/
|
|
41800
|
+
nestedVerdict(context) {
|
|
41801
|
+
try {
|
|
41802
|
+
if (this.deps.attachment.mode === "machine") return "forward";
|
|
41803
|
+
const keys = context?.nestedScopeKeys;
|
|
41804
|
+
if (keys === void 0) return "local";
|
|
41805
|
+
for (const key of keys) {
|
|
41806
|
+
if (this.verdictFor(() => key) === "local") return "local";
|
|
41807
|
+
}
|
|
41808
|
+
return "forward";
|
|
41809
|
+
} catch {
|
|
41810
|
+
return "local";
|
|
41811
|
+
}
|
|
41812
|
+
}
|
|
41813
|
+
/**
|
|
41814
|
+
* The register a scoped attachment sends, once the project and the repositories
|
|
41815
|
+
* nested in it are in scope: the register itself, with `reconcile.deletedFiles`
|
|
41816
|
+
* cut to the deleted paths whose own repository is in scope. `undefined` sends
|
|
41817
|
+
* nothing. TOTAL, like `verdictFor`, and for its reasons.
|
|
41818
|
+
*
|
|
41819
|
+
* The deletion sweep takes its paths from the scan ledger, not from the walk,
|
|
41820
|
+
* and the ledger holds every file the scanner ever read under the root, nested
|
|
41821
|
+
* clones' included. So a clone that was removed, or one an ignore file now
|
|
41822
|
+
* hides, is in no walk and never reaches `nestedVerdict`, yet its ledgered
|
|
41823
|
+
* paths come back as deleted. The scan names the repository of each deleted
|
|
41824
|
+
* path (`context.deletedFileKeys`, one entry per path in the register's order)
|
|
41825
|
+
* and each is held to the same verdict as any other key. A path whose key is
|
|
41826
|
+
* absent, or out of scope, is not sent.
|
|
41827
|
+
*
|
|
41828
|
+
* The list is asked for here, and only here: it is an async read of the scan
|
|
41829
|
+
* ledger that the scan makes on being called, so a machine attachment, which
|
|
41830
|
+
* returns before this, and a register already kept local never cause it.
|
|
41831
|
+
*
|
|
41832
|
+
* Anything the scan did not vouch for sends no deleted path, and the register
|
|
41833
|
+
* itself still goes: no list, a list that throws or whose read is rejected, or a
|
|
41834
|
+
* list whose length is not the register's. Deleting is the only thing a dropped
|
|
41835
|
+
* path could have done on the server, so the cost of a refusal is a stored row
|
|
41836
|
+
* that stays, never a path that leaves.
|
|
41837
|
+
*
|
|
41838
|
+
* Machine mode returns `input` itself, the same object and unread, so a machine
|
|
41839
|
+
* attachment's request is exactly what it was. A register that lists no deleted
|
|
41840
|
+
* path, or that is not a ledger register, has nothing to cut and is returned
|
|
41841
|
+
* as it came, with the list unread.
|
|
41842
|
+
*/
|
|
41843
|
+
async registerForWire(input2, context) {
|
|
41844
|
+
try {
|
|
41845
|
+
if (this.deps.attachment.mode === "machine") return input2;
|
|
41846
|
+
const { reconcile } = input2;
|
|
41847
|
+
if (reconcile.mode !== "ledger" || reconcile.deletedFiles.length === 0) return input2;
|
|
41848
|
+
const deleted = reconcile.deletedFiles;
|
|
41849
|
+
let kept = [];
|
|
41850
|
+
try {
|
|
41851
|
+
const keys = await context?.deletedFileKeys?.();
|
|
41852
|
+
if (keys?.length === deleted.length) {
|
|
41853
|
+
kept = deleted.filter((_path, at) => this.verdictFor(() => keys[at]) === "forward");
|
|
41854
|
+
}
|
|
41855
|
+
} catch {
|
|
41856
|
+
kept = [];
|
|
41857
|
+
}
|
|
41858
|
+
return { ...input2, reconcile: { ...reconcile, deletedFiles: kept } };
|
|
41859
|
+
} catch {
|
|
41860
|
+
return void 0;
|
|
41861
|
+
}
|
|
41862
|
+
}
|
|
42187
41863
|
/**
|
|
42188
41864
|
* The event `recordCapture` sends for a capture the verdict let through, or
|
|
42189
41865
|
* `undefined` to send nothing. TOTAL, like `verdictFor`, and for its reasons.
|
|
@@ -42509,12 +42185,24 @@ var AttachedDataGateway = class {
|
|
|
42509
42185
|
* payload onto the wire-boundary-safe shape (no snippet, hashed
|
|
42510
42186
|
* projectKey), and its result is discarded: `forward.run` never throws or
|
|
42511
42187
|
* rejects, so there is nothing here to act on.
|
|
42188
|
+
*
|
|
42189
|
+
* `context.nestedScopeKeys` is what the scanner knows and the register does
|
|
42190
|
+
* not say: the key of every repository nested below the scan root, whose
|
|
42191
|
+
* files the walk folded into this register. On a scoped attachment the
|
|
42192
|
+
* register is forwarded only when the project's own key AND every one of
|
|
42193
|
+
* those is in scope (see `nestedVerdict`), and its deleted paths are cut to the
|
|
42194
|
+
* ones whose own repository is in scope (`context.deletedFileKeys`, see
|
|
42195
|
+
* `registerForWire`). Machine mode never reads either, and the local write
|
|
42196
|
+
* never receives the context and gets the register whole.
|
|
42512
42197
|
*/
|
|
42513
|
-
async recordProjectEgress(input2) {
|
|
42198
|
+
async recordProjectEgress(input2, context) {
|
|
42514
42199
|
const summary = await this.deps.local.recordProjectEgress(input2);
|
|
42515
42200
|
if (this.verdictFor(() => scopeKeyOfProjectKey(input2.projectKey)) === "local") return summary;
|
|
42201
|
+
if (this.nestedVerdict(context) === "local") return summary;
|
|
42202
|
+
const register = await this.registerForWire(input2, context);
|
|
42203
|
+
if (register === void 0) return summary;
|
|
42516
42204
|
await this.deps.forward.run(
|
|
42517
|
-
() => this.deps.client.recordProjectEgress(toEgressIngestRequest(
|
|
42205
|
+
() => this.deps.client.recordProjectEgress(toEgressIngestRequest(register))
|
|
42518
42206
|
);
|
|
42519
42207
|
return summary;
|
|
42520
42208
|
}
|
|
@@ -42568,6 +42256,11 @@ var AttachedDataGateway = class {
|
|
|
42568
42256
|
async scanLedgerPaths() {
|
|
42569
42257
|
return this.deps.local.scanLedgerPaths();
|
|
42570
42258
|
}
|
|
42259
|
+
// Delegated, like the path list. An inner gateway that cannot say answers an
|
|
42260
|
+
// empty map, which gives every deleted path no key.
|
|
42261
|
+
async scanLedgerPathKeys() {
|
|
42262
|
+
return await this.deps.local.scanLedgerPathKeys?.() ?? /* @__PURE__ */ new Map();
|
|
42263
|
+
}
|
|
42571
42264
|
async recordScanned(entries) {
|
|
42572
42265
|
return this.deps.local.recordScanned(entries);
|
|
42573
42266
|
}
|
|
@@ -42634,6 +42327,12 @@ var AttachedDataGateway = class {
|
|
|
42634
42327
|
// and the spread above would otherwise drop the field silently — which is
|
|
42635
42328
|
// exactly what it did, leaving the whole control inert on every device
|
|
42636
42329
|
// while every test around it stayed green.
|
|
42330
|
+
//
|
|
42331
|
+
// WHOLE ON EVERY ATTACHMENT. A scoped attachment does not narrow the list
|
|
42332
|
+
// here: the port's `getPolicyBundle()` takes no event, and the runtime
|
|
42333
|
+
// reads this bundle once to build detection, so the detections it carries
|
|
42334
|
+
// apply to every event on the machine. Where a prohibition applies is
|
|
42335
|
+
// answered per event by `governanceAppliesTo` below.
|
|
42637
42336
|
prohibitedModels: cached2.prohibitedModels,
|
|
42638
42337
|
// NAMED for the same reason as the line above, and it is the same defect
|
|
42639
42338
|
// if it is not: `...local` above spreads the DEVICE's bundle, so a field
|
|
@@ -42693,6 +42392,30 @@ var AttachedDataGateway = class {
|
|
|
42693
42392
|
};
|
|
42694
42393
|
}
|
|
42695
42394
|
// ---------------------------------------------------------------------
|
|
42395
|
+
// GovernanceScope — where the organization's model policy applies
|
|
42396
|
+
// ---------------------------------------------------------------------
|
|
42397
|
+
/**
|
|
42398
|
+
* Whether the organization's governance applies to an event keyed `scopeKey`:
|
|
42399
|
+
* the question a model-guard site asks once it has decided to refuse.
|
|
42400
|
+
*
|
|
42401
|
+
* THE FORWARD VERDICT, through `verdictFor`: the answer is whether a capture
|
|
42402
|
+
* with the same key would be forwarded. A machine-wide attachment governs
|
|
42403
|
+
* every event, keyless included, exactly as before. A scoped one governs an
|
|
42404
|
+
* event only when its key names an enrolled repository. An event in a
|
|
42405
|
+
* personal repository, in no repository, with an empty key, or met by a fault
|
|
42406
|
+
* is not governed.
|
|
42407
|
+
*
|
|
42408
|
+
* The event's OWN key, never its session root's. The root rule in
|
|
42409
|
+
* `auditVerdict` decides whether a row can be forwarded without orphaning it;
|
|
42410
|
+
* this decides whether a refusal applies, which is a question about where the
|
|
42411
|
+
* event happened.
|
|
42412
|
+
*
|
|
42413
|
+
* Answered from memory: no store read, no bundle read, nothing sent.
|
|
42414
|
+
*/
|
|
42415
|
+
governanceAppliesTo(scopeKey) {
|
|
42416
|
+
return this.verdictFor(() => scopeKey) === "forward";
|
|
42417
|
+
}
|
|
42418
|
+
// ---------------------------------------------------------------------
|
|
42696
42419
|
// LocalStoreMaintenance — by delegation (D3).
|
|
42697
42420
|
//
|
|
42698
42421
|
// Implementing these is what actually closes the skipped-local-maintenance
|
|
@@ -42801,14 +42524,15 @@ function toWireInspection(insp) {
|
|
|
42801
42524
|
}
|
|
42802
42525
|
|
|
42803
42526
|
// ../../packages/plugin-runtime/src/attached/history-sync.ts
|
|
42804
|
-
import { createHash as
|
|
42805
|
-
import { hostname as
|
|
42527
|
+
import { createHash as createHash7 } from "crypto";
|
|
42528
|
+
import { hostname as hostname4 } from "os";
|
|
42806
42529
|
|
|
42807
42530
|
// ../../packages/plugin-runtime/src/attached/capture-rebuild.ts
|
|
42808
42531
|
var CORRELATION_ID = EventMetadata.shape.correlationId;
|
|
42809
42532
|
var TRACE_ID = EventMetadata.shape.traceId;
|
|
42810
42533
|
var EXCEPTION_ID = EventMetadata.shape.exceptionIds.unwrap().element;
|
|
42811
42534
|
var REDACT_DEGRADED_TO = EventMetadata.shape.redactDegradedTo.unwrap();
|
|
42535
|
+
var SCAN_INCOMPLETE = EventMetadata.shape.scanIncomplete.unwrap();
|
|
42812
42536
|
|
|
42813
42537
|
// ../../packages/plugin-runtime/src/attached/history-sync.ts
|
|
42814
42538
|
var CAPTURE_BATCH_BYTES = 1024 * 1024;
|
|
@@ -42820,17 +42544,17 @@ var HISTORY_SYNC_THROTTLE_MS = 5 * 60 * 1e3;
|
|
|
42820
42544
|
|
|
42821
42545
|
// ../../packages/plugin-runtime/src/attached/install-record.ts
|
|
42822
42546
|
import { readFile as readFile2, stat } from "fs/promises";
|
|
42823
|
-
import { basename as
|
|
42547
|
+
import { basename as basename4, dirname as dirname6, join as join24, resolve as resolve2 } from "path";
|
|
42824
42548
|
async function readInstalledVersion(installRoot) {
|
|
42825
42549
|
try {
|
|
42826
42550
|
const versionDir = resolve2(installRoot);
|
|
42827
|
-
const pluginDir =
|
|
42828
|
-
const marketplaceDir =
|
|
42829
|
-
const cacheDir =
|
|
42830
|
-
if (
|
|
42831
|
-
const key = `${
|
|
42551
|
+
const pluginDir = dirname6(versionDir);
|
|
42552
|
+
const marketplaceDir = dirname6(pluginDir);
|
|
42553
|
+
const cacheDir = dirname6(marketplaceDir);
|
|
42554
|
+
if (basename4(cacheDir) !== "cache") return null;
|
|
42555
|
+
const key = `${basename4(pluginDir)}@${basename4(marketplaceDir)}`;
|
|
42832
42556
|
const record2 = JSON.parse(
|
|
42833
|
-
await readFile2(
|
|
42557
|
+
await readFile2(join24(dirname6(cacheDir), "installed_plugins.json"), "utf8")
|
|
42834
42558
|
);
|
|
42835
42559
|
const plugins = record2?.plugins;
|
|
42836
42560
|
if (typeof plugins !== "object" || plugins === null || !Object.hasOwn(plugins, key)) {
|
|
@@ -42862,7 +42586,7 @@ async function exists(path) {
|
|
|
42862
42586
|
}
|
|
42863
42587
|
|
|
42864
42588
|
// ../../packages/plugin-runtime/src/attached/plugin-block.ts
|
|
42865
|
-
import { readFileSync as
|
|
42589
|
+
import { readFileSync as readFileSync15 } from "fs";
|
|
42866
42590
|
var INSTALL_RECORD_READ_TIMEOUT_MS = REQUEST_TIMEOUT_MS / 2;
|
|
42867
42591
|
function createPluginBlock(build, policyStore) {
|
|
42868
42592
|
return async () => {
|
|
@@ -42892,7 +42616,7 @@ async function readInstalledVersionBounded(installRoot) {
|
|
|
42892
42616
|
// ../../packages/plugin-runtime/src/attached/policy-store.ts
|
|
42893
42617
|
import { randomUUID as randomUUID17 } from "crypto";
|
|
42894
42618
|
import { readFile as readFile3, rm, writeFile as writeFile2 } from "fs/promises";
|
|
42895
|
-
import { join as
|
|
42619
|
+
import { join as join25 } from "path";
|
|
42896
42620
|
|
|
42897
42621
|
// ../../packages/plugin-runtime/src/attached/atomic-publish.ts
|
|
42898
42622
|
import { rename as rename2 } from "fs/promises";
|
|
@@ -42921,7 +42645,7 @@ async function publishByRename(tmp, file2, move = rename2) {
|
|
|
42921
42645
|
|
|
42922
42646
|
// ../../packages/plugin-runtime/src/attached/policy-store.ts
|
|
42923
42647
|
function createPolicyStore(dir = dataDir()) {
|
|
42924
|
-
const file2 =
|
|
42648
|
+
const file2 = join25(dir, "policy-cache.json");
|
|
42925
42649
|
async function read() {
|
|
42926
42650
|
try {
|
|
42927
42651
|
const raw = await readFile3(file2, "utf8");
|
|
@@ -42991,8 +42715,8 @@ function createPolicyStore(dir = dataDir()) {
|
|
|
42991
42715
|
}
|
|
42992
42716
|
|
|
42993
42717
|
// ../../packages/plugin-runtime/src/attached/posture-report-state.ts
|
|
42994
|
-
import { readFileSync as
|
|
42995
|
-
import { join as
|
|
42718
|
+
import { readFileSync as readFileSync16 } from "fs";
|
|
42719
|
+
import { join as join26 } from "path";
|
|
42996
42720
|
var POSTURE_REPORT_STATE_FILENAME = ATTACHED_POSTURE_REPORT_FILENAME;
|
|
42997
42721
|
var OUTCOME_KEYS = {
|
|
42998
42722
|
ok: true,
|
|
@@ -43006,7 +42730,7 @@ var OUTCOME_KEYS = {
|
|
|
43006
42730
|
};
|
|
43007
42731
|
var OUTCOMES = new Set(Object.keys(OUTCOME_KEYS));
|
|
43008
42732
|
function postureReportStatePath(dataDir2) {
|
|
43009
|
-
return
|
|
42733
|
+
return join26(dataDir2, POSTURE_REPORT_STATE_FILENAME);
|
|
43010
42734
|
}
|
|
43011
42735
|
function writePostureReportState(dataDir2, state) {
|
|
43012
42736
|
try {
|
|
@@ -43047,10 +42771,19 @@ function createPostureReporter(deps) {
|
|
|
43047
42771
|
hostname: deps.hostname(),
|
|
43048
42772
|
capturedAt: nowMs,
|
|
43049
42773
|
...measurement,
|
|
43050
|
-
// Omit the key rather than spread an explicit `undefined
|
|
43051
|
-
//
|
|
43052
|
-
//
|
|
43053
|
-
|
|
42774
|
+
// Omit the key rather than spread an explicit `undefined`. The type
|
|
42775
|
+
// admits `undefined` here (the schema's optional member), and
|
|
42776
|
+
// JSON.stringify sends the same bytes either way. Omitting keeps the
|
|
42777
|
+
// in-memory object free of an explicit `undefined` member, which the
|
|
42778
|
+
// tests pin by key presence.
|
|
42779
|
+
...plugin === void 0 ? {} : { plugin },
|
|
42780
|
+
// LAST, and only for a scoped attachment. A machine attachment omits
|
|
42781
|
+
// the key the same way, so its body is byte for byte the one it sent
|
|
42782
|
+
// before the member existed. Anything but exactly `machine` reports the
|
|
42783
|
+
// constant `scoped`, never the raw value: that is resolveScope's own
|
|
42784
|
+
// fail direction, and a value outside the wire's vocabulary would fail
|
|
42785
|
+
// the whole snapshot at the receiver, the wipe signal with it.
|
|
42786
|
+
...deps.attachmentMode === "machine" ? {} : { attachmentMode: "scoped" }
|
|
43054
42787
|
};
|
|
43055
42788
|
} catch {
|
|
43056
42789
|
return null;
|
|
@@ -43073,8 +42806,8 @@ function createPostureReporter(deps) {
|
|
|
43073
42806
|
}
|
|
43074
42807
|
|
|
43075
42808
|
// ../../packages/plugin-runtime/src/attached/posture-snapshot.ts
|
|
43076
|
-
import { statSync as
|
|
43077
|
-
import { DatabaseSync as
|
|
42809
|
+
import { statSync as statSync7 } from "fs";
|
|
42810
|
+
import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
|
|
43078
42811
|
|
|
43079
42812
|
// ../../packages/plugin-runtime/src/attached/action-counts.ts
|
|
43080
42813
|
function emptyActionCounts() {
|
|
@@ -43104,7 +42837,7 @@ function emptyReadout(readError = false) {
|
|
|
43104
42837
|
}
|
|
43105
42838
|
function readStorePosture(dbPath2) {
|
|
43106
42839
|
try {
|
|
43107
|
-
|
|
42840
|
+
statSync7(dbPath2);
|
|
43108
42841
|
} catch (err) {
|
|
43109
42842
|
const code = err.code;
|
|
43110
42843
|
if (code === "ENOENT" || code === "ENOTDIR") return emptyReadout();
|
|
@@ -43132,7 +42865,7 @@ function readStorePosture(dbPath2) {
|
|
|
43132
42865
|
readError: false
|
|
43133
42866
|
});
|
|
43134
42867
|
try {
|
|
43135
|
-
db = new
|
|
42868
|
+
db = new DatabaseSync3(dbPath2, { readOnly: true });
|
|
43136
42869
|
db.exec("PRAGMA busy_timeout = 2000");
|
|
43137
42870
|
version2 = db.prepare("PRAGMA user_version").get().user_version;
|
|
43138
42871
|
try {
|
|
@@ -43186,11 +42919,11 @@ function readStorePosture(dbPath2) {
|
|
|
43186
42919
|
// ../../packages/plugin-runtime/src/attached/posture-store.ts
|
|
43187
42920
|
import { randomUUID as randomUUID18 } from "crypto";
|
|
43188
42921
|
import { readFile as readFile4, rm as rm2, writeFile as writeFile3 } from "fs/promises";
|
|
43189
|
-
import { join as
|
|
42922
|
+
import { join as join27 } from "path";
|
|
43190
42923
|
var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
|
|
43191
42924
|
function createPostureStore(dir = settingsDir(), legacyDir) {
|
|
43192
|
-
const file2 =
|
|
43193
|
-
const legacyFile = legacyDir === void 0 ? null :
|
|
42925
|
+
const file2 = join27(dir, "posture-state.json");
|
|
42926
|
+
const legacyFile = legacyDir === void 0 ? null : join27(legacyDir, "posture-state.json");
|
|
43194
42927
|
async function persist(state) {
|
|
43195
42928
|
await ensureDataDir(dir);
|
|
43196
42929
|
const tmp = `${file2}.${randomUUID18()}.tmp`;
|
|
@@ -43258,8 +42991,8 @@ function createPostureStore(dir = settingsDir(), legacyDir) {
|
|
|
43258
42991
|
}
|
|
43259
42992
|
|
|
43260
42993
|
// ../../packages/plugin-runtime/src/attached/sync-state.ts
|
|
43261
|
-
import { readFileSync as
|
|
43262
|
-
import { join as
|
|
42994
|
+
import { readFileSync as readFileSync17 } from "fs";
|
|
42995
|
+
import { join as join28 } from "path";
|
|
43263
42996
|
|
|
43264
42997
|
// ../../packages/plugin-runtime/src/attached/status.ts
|
|
43265
42998
|
var REFUSAL_LINES = {
|
|
@@ -43289,7 +43022,7 @@ import { fileURLToPath as fileURLToPath5 } from "url";
|
|
|
43289
43022
|
var CONTENT_RETENTION_THROTTLE_MS = 60 * 60 * 1e3;
|
|
43290
43023
|
|
|
43291
43024
|
// ../../packages/plugin-runtime/src/attached/factory.ts
|
|
43292
|
-
import { hostname as
|
|
43025
|
+
import { hostname as hostname5 } from "os";
|
|
43293
43026
|
|
|
43294
43027
|
// ../../packages/plugin-runtime/src/recorder.ts
|
|
43295
43028
|
var PLUGIN_RECORDER_BINARY = "plugin";
|
|
@@ -43302,7 +43035,7 @@ var StandaloneDataGateway = class {
|
|
|
43302
43035
|
// One notice per gateway — see warnRulesetDiscarded.
|
|
43303
43036
|
warnedRulesetDiscarded = false;
|
|
43304
43037
|
constructor(dataDir2, detections = [], meta4) {
|
|
43305
|
-
this.db = openLocalDatabase(dataDir2);
|
|
43038
|
+
this.db = openLocalDatabase(dataDir2, { shippedRegexMatchers: shippedRegexMatchers() });
|
|
43306
43039
|
this.dataDir = dataDir2;
|
|
43307
43040
|
this.db.installedPacks.recordInventory(detections, meta4);
|
|
43308
43041
|
}
|
|
@@ -43651,6 +43384,9 @@ var StandaloneDataGateway = class {
|
|
|
43651
43384
|
scanLedgerPaths() {
|
|
43652
43385
|
return Promise.resolve(this.db.scanLedger.allPaths());
|
|
43653
43386
|
}
|
|
43387
|
+
scanLedgerPathKeys() {
|
|
43388
|
+
return Promise.resolve(this.db.scanLedger.pathKeys());
|
|
43389
|
+
}
|
|
43654
43390
|
recordScanned(entries) {
|
|
43655
43391
|
this.db.scanLedger.upsertEntries(entries);
|
|
43656
43392
|
return Promise.resolve();
|
|
@@ -43736,13 +43472,17 @@ function resolveGatewayForConfig(config2, meta4) {
|
|
|
43736
43472
|
},
|
|
43737
43473
|
store: postureStore,
|
|
43738
43474
|
readStore: () => readStorePosture(config2.dbPath),
|
|
43739
|
-
hostname: () =>
|
|
43475
|
+
hostname: () => hostname5(),
|
|
43740
43476
|
now: () => Date.now(),
|
|
43477
|
+
// The mode THIS gateway enforces, from the attachment resolved above,
|
|
43478
|
+
// so the report cannot name a mode the forward paths are not using.
|
|
43479
|
+
attachmentMode: attachment.mode,
|
|
43741
43480
|
// The reporting build's identity, when the caller knows it (the plugin
|
|
43742
43481
|
// adapters do; an embedder or a test may not). Composed with the SAME
|
|
43743
43482
|
// policy store the sync child writes, so the block names the bundle
|
|
43744
|
-
// actually in force.
|
|
43745
|
-
// reporter
|
|
43483
|
+
// actually in force. The dependency key is omitted when no build is
|
|
43484
|
+
// known, and the reporter's optional call (`deps.pluginBlock?.()`)
|
|
43485
|
+
// then adds no block.
|
|
43746
43486
|
...meta4?.pluginBuild === void 0 ? {} : { pluginBlock: createPluginBlock(meta4.pluginBuild, store) }
|
|
43747
43487
|
})
|
|
43748
43488
|
});
|
|
@@ -43763,33 +43503,33 @@ import { randomUUID as randomUUID19 } from "crypto";
|
|
|
43763
43503
|
var EXCEPTION_RETENTION_MS = 90 * 24 * 60 * 60 * 1e3;
|
|
43764
43504
|
|
|
43765
43505
|
// src/history/transcripts.ts
|
|
43766
|
-
import { closeSync as
|
|
43767
|
-
import { homedir as
|
|
43768
|
-
import { join as
|
|
43506
|
+
import { closeSync as closeSync2, openSync as openSync2, readdirSync as readdirSync3, readFileSync as readFileSync18, readSync, statSync as statSync8 } from "fs";
|
|
43507
|
+
import { homedir as homedir2 } from "os";
|
|
43508
|
+
import { join as join29 } from "path";
|
|
43769
43509
|
function transcriptsDir(home) {
|
|
43770
|
-
return
|
|
43510
|
+
return join29(home ?? homedir2(), ".codex", "sessions");
|
|
43771
43511
|
}
|
|
43772
43512
|
var DAY_MS5 = 24 * 60 * 60 * 1e3;
|
|
43773
43513
|
|
|
43774
43514
|
// src/remediation/redact.ts
|
|
43775
43515
|
import {
|
|
43776
43516
|
lstatSync as lstatSync4,
|
|
43777
|
-
readdirSync as
|
|
43778
|
-
readFileSync as
|
|
43779
|
-
realpathSync as
|
|
43517
|
+
readdirSync as readdirSync4,
|
|
43518
|
+
readFileSync as readFileSync19,
|
|
43519
|
+
realpathSync as realpathSync2,
|
|
43780
43520
|
renameSync as renameSync5,
|
|
43781
43521
|
rmSync as rmSync8,
|
|
43782
|
-
statSync as
|
|
43783
|
-
writeFileSync as
|
|
43522
|
+
statSync as statSync9,
|
|
43523
|
+
writeFileSync as writeFileSync7
|
|
43784
43524
|
} from "fs";
|
|
43785
|
-
import { basename as
|
|
43525
|
+
import { basename as basename5, dirname as dirname7, isAbsolute as isAbsolute2, join as join30, relative, resolve as resolve3 } from "path";
|
|
43786
43526
|
var REDACTED_PLACEHOLDER = "[REDACTED:SECRET]";
|
|
43787
43527
|
function platformRedactionScope(home) {
|
|
43788
43528
|
return { artifactRoots: [transcriptsDir(home)] };
|
|
43789
43529
|
}
|
|
43790
43530
|
function realPathOrNull(path) {
|
|
43791
43531
|
try {
|
|
43792
|
-
return
|
|
43532
|
+
return realpathSync2(path);
|
|
43793
43533
|
} catch {
|
|
43794
43534
|
return null;
|
|
43795
43535
|
}
|
|
@@ -43798,7 +43538,7 @@ function isWithinRoot(realTarget, root) {
|
|
|
43798
43538
|
const realRoot = realPathOrNull(root);
|
|
43799
43539
|
if (realRoot === null) return false;
|
|
43800
43540
|
const rel = relative(realRoot, realTarget);
|
|
43801
|
-
return rel !== "" && !rel.startsWith("..") && !
|
|
43541
|
+
return rel !== "" && !rel.startsWith("..") && !isAbsolute2(rel);
|
|
43802
43542
|
}
|
|
43803
43543
|
function resolveRedactableArtifact(filePath, scope) {
|
|
43804
43544
|
const realTarget = realPathOrNull(resolve3(filePath));
|
|
@@ -43818,11 +43558,11 @@ function isProcessAlive(pid) {
|
|
|
43818
43558
|
}
|
|
43819
43559
|
}
|
|
43820
43560
|
function sweepStrandedTemps(realPath) {
|
|
43821
|
-
const dir =
|
|
43822
|
-
const prefix = `${
|
|
43561
|
+
const dir = dirname7(realPath);
|
|
43562
|
+
const prefix = `${basename5(realPath)}.`;
|
|
43823
43563
|
let names;
|
|
43824
43564
|
try {
|
|
43825
|
-
names =
|
|
43565
|
+
names = readdirSync4(dir);
|
|
43826
43566
|
} catch {
|
|
43827
43567
|
return;
|
|
43828
43568
|
}
|
|
@@ -43833,7 +43573,7 @@ function sweepStrandedTemps(realPath) {
|
|
|
43833
43573
|
const pid = Number(pidPart);
|
|
43834
43574
|
if (pid !== process.pid && isProcessAlive(pid)) continue;
|
|
43835
43575
|
try {
|
|
43836
|
-
const stranded =
|
|
43576
|
+
const stranded = join30(dir, name);
|
|
43837
43577
|
if (!lstatSync4(stranded).isFile()) continue;
|
|
43838
43578
|
rmSync8(stranded, { force: true });
|
|
43839
43579
|
} catch {
|
|
@@ -43856,8 +43596,8 @@ function redactLeakedKeysDetailed(targets, scope = platformRedactionScope()) {
|
|
|
43856
43596
|
let content;
|
|
43857
43597
|
let mode;
|
|
43858
43598
|
try {
|
|
43859
|
-
mode =
|
|
43860
|
-
content =
|
|
43599
|
+
mode = statSync9(filePath).mode & 511;
|
|
43600
|
+
content = readFileSync19(filePath, "utf8");
|
|
43861
43601
|
} catch {
|
|
43862
43602
|
continue;
|
|
43863
43603
|
}
|
|
@@ -43877,7 +43617,7 @@ function redactLeakedKeysDetailed(targets, scope = platformRedactionScope()) {
|
|
|
43877
43617
|
if (struckHere.length === 0) continue;
|
|
43878
43618
|
const tmpPath = tempPathFor(filePath);
|
|
43879
43619
|
try {
|
|
43880
|
-
|
|
43620
|
+
writeFileSync7(tmpPath, content, { mode, flag: "wx" });
|
|
43881
43621
|
renameSync5(tmpPath, filePath);
|
|
43882
43622
|
} catch {
|
|
43883
43623
|
try {
|
|
@@ -43934,7 +43674,7 @@ async function redactSurfacedSecrets(findings, overrides = {}) {
|
|
|
43934
43674
|
for (const [filePath, fileFindings] of byFile) {
|
|
43935
43675
|
let content;
|
|
43936
43676
|
try {
|
|
43937
|
-
content =
|
|
43677
|
+
content = readFileSync20(filePath, "utf8");
|
|
43938
43678
|
} catch {
|
|
43939
43679
|
unrecovered.push(...fileFindings);
|
|
43940
43680
|
continue;
|
|
@@ -44092,7 +43832,7 @@ if (process.argv[1] && fileURLToPath6(import.meta.url) === process.argv[1]) {
|
|
|
44092
43832
|
try {
|
|
44093
43833
|
const argv = process.argv.slice(2);
|
|
44094
43834
|
const optionIndex = argv.indexOf("--option");
|
|
44095
|
-
const frameText =
|
|
43835
|
+
const frameText = readFileSync21(0, "utf8");
|
|
44096
43836
|
if (optionIndex === -1) {
|
|
44097
43837
|
present(frameText);
|
|
44098
43838
|
} else {
|