@akasecurity/ai-tc-codex 0.9.10 → 0.9.11
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 +4 -4
- package/scripts/apply-suppressions.js +627 -435
- package/scripts/backfill.js +727 -497
- package/scripts/filescan.js +726 -496
- package/scripts/firstrun.js +775 -519
- package/scripts/history-sync.js +611 -418
- package/scripts/intro.js +242 -92
- package/scripts/onboard.js +603 -410
- package/scripts/post-tool-use.js +711 -483
- package/scripts/pre-tool-use.js +715 -485
- package/scripts/query.js +780 -524
- package/scripts/reconcile.js +707 -485
- package/scripts/remediate.js +725 -495
- package/scripts/scan-worker.js +153 -58
- package/scripts/session-start.js +755 -535
- package/scripts/start-light.js +240 -90
- package/scripts/stop.js +264 -116
- package/scripts/sync.js +722 -494
- package/scripts/user-prompt-submit.js +719 -489
package/scripts/pre-tool-use.js
CHANGED
|
@@ -492,8 +492,8 @@ var require_ignore = __commonJS({
|
|
|
492
492
|
});
|
|
493
493
|
|
|
494
494
|
// ../../packages/plugin-sdk/src/config.ts
|
|
495
|
-
import { existsSync as
|
|
496
|
-
import { join as
|
|
495
|
+
import { existsSync as existsSync8 } from "fs";
|
|
496
|
+
import { join as join14 } from "path";
|
|
497
497
|
|
|
498
498
|
// ../../packages/persistence/src/attached-derived.ts
|
|
499
499
|
import { rmSync } from "fs";
|
|
@@ -20743,13 +20743,11 @@ var FindingGroup = external_exports.object({
|
|
|
20743
20743
|
latestDetectedAt: external_exports.iso.datetime(),
|
|
20744
20744
|
instances: external_exports.array(FindingInstance),
|
|
20745
20745
|
// Derived from instances' statuses with open-dominates precedence (see
|
|
20746
|
-
//
|
|
20746
|
+
// foldGroupStatus). Undefined only when no instance carries a status.
|
|
20747
20747
|
status: FindingStatus.optional(),
|
|
20748
|
-
// The distinct people across the WHOLE group, not just the
|
|
20749
|
-
//
|
|
20750
|
-
//
|
|
20751
|
-
// instance carries a user, or when the store supplied whole-group folds
|
|
20752
|
-
// without one.
|
|
20748
|
+
// The distinct people across the WHOLE group, not just the instances
|
|
20749
|
+
// carried here. Undefined when no instance carries a user, or when the
|
|
20750
|
+
// store supplied whole-group folds without one.
|
|
20753
20751
|
users: external_exports.array(FindingUser).optional()
|
|
20754
20752
|
}).meta({ id: "FindingGroup" });
|
|
20755
20753
|
var FindingStats = external_exports.object({
|
|
@@ -20778,21 +20776,31 @@ var FindingFacets = external_exports.object({
|
|
|
20778
20776
|
// counted under no value.
|
|
20779
20777
|
status: external_exports.array(FindingFacetItem),
|
|
20780
20778
|
// Host tool (attributes.tool_name). Present only on the instance-level
|
|
20781
|
-
// reads, which can filter by it; the
|
|
20779
|
+
// reads, which can filter by it; the type-level read omits the dimension
|
|
20782
20780
|
// because a group spans tools.
|
|
20783
20781
|
tool: external_exports.array(FindingFacetItem).optional()
|
|
20784
20782
|
}).meta({ id: "FindingFacets" });
|
|
20785
|
-
var
|
|
20786
|
-
|
|
20783
|
+
var FindingTypeSummary = FindingGroup.omit({ instances: true, match: true }).meta({
|
|
20784
|
+
id: "FindingTypeSummary"
|
|
20785
|
+
});
|
|
20786
|
+
var DEFAULT_FINDING_TYPES_LIMIT = 50;
|
|
20787
|
+
var MAX_FINDING_TYPES_LIMIT = 100;
|
|
20788
|
+
var ListFindingTypesQuery = external_exports.object({
|
|
20787
20789
|
// NOTE: severity filters by Severity (critical/high/medium/low), not by
|
|
20788
|
-
// FindingAction.
|
|
20790
|
+
// FindingAction. It narrows TYPES: a type's severity is the one its newest
|
|
20791
|
+
// firing version carries, and this list pages types.
|
|
20792
|
+
//
|
|
20793
|
+
// That is NOT a claim the findings of a type share it. A rule can hold several
|
|
20794
|
+
// definition versions at different severities, so a type kept by this filter
|
|
20795
|
+
// can hold findings that individually do not match — see totals.findings on
|
|
20796
|
+
// ListFindingTypesResponse, which counts them all.
|
|
20789
20797
|
severity: external_exports.array(Severity).optional(),
|
|
20790
20798
|
subtype: external_exports.array(external_exports.string()).optional(),
|
|
20791
20799
|
provider: external_exports.array(FindingProvider).optional(),
|
|
20792
20800
|
action: external_exports.array(FindingAction).optional(),
|
|
20793
|
-
// Matches a
|
|
20794
|
-
// individual
|
|
20795
|
-
//
|
|
20801
|
+
// Matches a type's DERIVED status (see FindingGroup.status), not its
|
|
20802
|
+
// individual findings' — so a filtered row's status always reads one of the
|
|
20803
|
+
// requested values.
|
|
20796
20804
|
status: external_exports.array(FindingStatus).optional(),
|
|
20797
20805
|
q: external_exports.string().optional(),
|
|
20798
20806
|
// Scope to findings whose event carries this session id (the Activity page's
|
|
@@ -20802,23 +20810,37 @@ var ListGroupedFindingsQuery = external_exports.object({
|
|
|
20802
20810
|
// from a time-scoped page (Activity's range) can carry that scope. Absent
|
|
20803
20811
|
// means all time — this list has no default window.
|
|
20804
20812
|
from: external_exports.iso.datetime().optional(),
|
|
20805
|
-
// A
|
|
20806
|
-
//
|
|
20807
|
-
//
|
|
20808
|
-
//
|
|
20809
|
-
//
|
|
20813
|
+
// A RULE id that must appear in the page even when the cursor has already
|
|
20814
|
+
// advanced past its sort position. This is what keeps the selected type
|
|
20815
|
+
// visible in the list once it paginates: the target is appended out of sort
|
|
20816
|
+
// order rather than scanned forward for. Never affects totals, facets or the
|
|
20817
|
+
// cursor. Unlike the grouped read this replaces, it names a rule only — an
|
|
20818
|
+
// instance id is resolved by `findingInstance`, which is a primary-key seek
|
|
20819
|
+
// and so is not bounded by what any page happens to hold.
|
|
20810
20820
|
includeId: external_exports.string().optional(),
|
|
20811
|
-
|
|
20812
|
-
limit: external_exports.coerce.number().int().min(1).max(100).optional(),
|
|
20821
|
+
limit: external_exports.coerce.number().int().min(1).max(MAX_FINDING_TYPES_LIMIT).optional(),
|
|
20813
20822
|
cursor: external_exports.string().optional()
|
|
20814
20823
|
});
|
|
20815
|
-
var
|
|
20824
|
+
var ListFindingTypesResponse = external_exports.object({
|
|
20816
20825
|
totals: external_exports.object({
|
|
20826
|
+
// Findings belonging to the matching TYPES — not findings that each match
|
|
20827
|
+
// the filters. The filters here select types, so a type that survives
|
|
20828
|
+
// contributes its whole instanceCount.
|
|
20829
|
+
//
|
|
20830
|
+
// `status` is the one exception, narrowed per finding via
|
|
20831
|
+
// countInstancesByStatus. `severity`, `provider` and `action` are not, so
|
|
20832
|
+
// this can exceed what the instance read reports for the same filters: a
|
|
20833
|
+
// rule whose severity moved between versions is kept on its newest and
|
|
20834
|
+
// still counts its older findings. Narrowing the other three needs
|
|
20835
|
+
// per-dimension counts the aggregate does not carry today.
|
|
20817
20836
|
findings: external_exports.number().int().nonnegative(),
|
|
20818
|
-
|
|
20837
|
+
// Counts TYPES, which is the unit this read pages. The instance read's
|
|
20838
|
+
// own totals count findings; the two deliberately answer different
|
|
20839
|
+
// questions and are never summed.
|
|
20840
|
+
types: external_exports.number().int().nonnegative()
|
|
20819
20841
|
}),
|
|
20820
20842
|
facets: FindingFacets,
|
|
20821
|
-
items: external_exports.array(
|
|
20843
|
+
items: external_exports.array(FindingTypeSummary),
|
|
20822
20844
|
nextCursor: external_exports.string().nullable(),
|
|
20823
20845
|
// Present only on session-scoped queries (`sessionId` set): per ruleId, how
|
|
20824
20846
|
// many times that rule fired in the session's persisted transcript. Findings
|
|
@@ -20826,7 +20848,7 @@ var ListGroupedFindingsResponse = external_exports.object({
|
|
|
20826
20848
|
// every firing, so the two numbers legitimately differ — this map lets a
|
|
20827
20849
|
// session-scoped view show both.
|
|
20828
20850
|
sessionFirings: external_exports.record(external_exports.string(), external_exports.number().int().nonnegative()).optional()
|
|
20829
|
-
}).meta({ id: "
|
|
20851
|
+
}).meta({ id: "ListFindingTypesResponse" });
|
|
20830
20852
|
var ApplyFindingActionRequest = external_exports.object({
|
|
20831
20853
|
// 'quarantined' is system-assigned (see FindingAction) — clients may not set
|
|
20832
20854
|
// it, so it is excluded from the request contract. The mapping helper
|
|
@@ -20856,12 +20878,13 @@ var DEFAULT_FLAT_FINDINGS_LIMIT = 50;
|
|
|
20856
20878
|
var MAX_FLAT_FINDINGS_LIMIT = 200;
|
|
20857
20879
|
var ListFindingInstancesQuery = external_exports.object({
|
|
20858
20880
|
severity: external_exports.array(Severity).optional(),
|
|
20859
|
-
// Rule ids, the same vocabulary the
|
|
20881
|
+
// Rule ids, the same vocabulary the types list's `subtype` carries. Pinning
|
|
20882
|
+
// ONE of them is how the master/detail view scopes its right-hand panel.
|
|
20860
20883
|
subtype: external_exports.array(external_exports.string()).optional(),
|
|
20861
20884
|
provider: external_exports.array(FindingProvider).optional(),
|
|
20862
20885
|
action: external_exports.array(FindingAction).optional(),
|
|
20863
20886
|
// Matches each instance's OWN derived status (deriveFindingStatus), unlike
|
|
20864
|
-
// the
|
|
20887
|
+
// the types query's type-level fold.
|
|
20865
20888
|
status: external_exports.array(FindingStatus).optional(),
|
|
20866
20889
|
// Exact host-tool names (attributes.tool_name, e.g. 'Bash'). A real filter,
|
|
20867
20890
|
// where the free-text `q` can only match the rendered "via Bash" label.
|
|
@@ -20878,37 +20901,47 @@ var ListFindingInstancesQuery = external_exports.object({
|
|
|
20878
20901
|
});
|
|
20879
20902
|
var ListFindingInstancesResponse = external_exports.object({
|
|
20880
20903
|
// Instances matching the filters across the whole scope, not just this
|
|
20881
|
-
// page — cursor-independent, like the
|
|
20904
|
+
// page — cursor-independent, like the types list's totals.
|
|
20882
20905
|
totals: external_exports.object({ findings: external_exports.number().int().nonnegative() }),
|
|
20883
|
-
// Counts in INSTANCES here, where the
|
|
20906
|
+
// Counts in INSTANCES here, where the types response counts types. Each
|
|
20884
20907
|
// dimension still excludes its own filter.
|
|
20885
20908
|
facets: FindingFacets,
|
|
20886
20909
|
items: external_exports.array(FindingInstanceDetail),
|
|
20887
20910
|
nextCursor: external_exports.string().nullable()
|
|
20888
20911
|
}).meta({ id: "ListFindingInstancesResponse" });
|
|
20889
|
-
var
|
|
20890
|
-
//
|
|
20891
|
-
//
|
|
20892
|
-
|
|
20893
|
-
|
|
20894
|
-
|
|
20895
|
-
|
|
20896
|
-
// Folded from the instances' derived statuses with the same
|
|
20897
|
-
// open-dominates precedence a group uses.
|
|
20898
|
-
status: FindingStatus.optional(),
|
|
20899
|
-
// Distinct rules seen at this location, capped — the row shows them as
|
|
20900
|
-
// chips, and the count is what conveys scale.
|
|
20901
|
-
ruleIds: external_exports.array(external_exports.string())
|
|
20902
|
-
}).meta({ id: "FindingLocationFile" });
|
|
20903
|
-
var FindingLocationRepo = external_exports.object({
|
|
20912
|
+
var FindingLocationSummary = external_exports.object({
|
|
20913
|
+
// Opaque, stable, minted from the pair by encodeLocationId. It exists
|
|
20914
|
+
// because a location's identity is two values and a URL param carries one:
|
|
20915
|
+
// `?loc=` names a location the way `?rule=` names a type. Only ever compared
|
|
20916
|
+
// for EQUALITY — the page's selection check, this read's `includeId`, the
|
|
20917
|
+
// client's page dedupe — never decoded, and never a sort key.
|
|
20918
|
+
id: external_exports.string(),
|
|
20904
20919
|
/** Empty when the instances carried no repo attribute. */
|
|
20905
20920
|
repo: external_exports.string(),
|
|
20921
|
+
// Empty when the instances carried no file path (a prompt, or a tool call
|
|
20922
|
+
// with no file attribution). Both halves empty is a real location — usually
|
|
20923
|
+
// the largest one in a store — and is selectable like any other.
|
|
20924
|
+
file: external_exports.string(),
|
|
20906
20925
|
instanceCount: external_exports.number().int().nonnegative(),
|
|
20926
|
+
// The WORST severity present, not the first row's. It is this list's primary
|
|
20927
|
+
// sort key, so it is also what explains why a row is where it is, and it is
|
|
20928
|
+
// how a reader decides what to open without opening everything.
|
|
20907
20929
|
maxSeverity: Severity,
|
|
20908
20930
|
latestDetectedAt: external_exports.iso.datetime(),
|
|
20931
|
+
// Folded from the instances' derived statuses with the same open-dominates
|
|
20932
|
+
// precedence a group uses, so it answers "is anything left to do here" and
|
|
20933
|
+
// not much more: a location holding 1 open among 40 resolved reads like one
|
|
20934
|
+
// holding 40 open. That loss is accepted — the panel beside this list
|
|
20935
|
+
// carries each finding's own status, and instanceCount sits next to the
|
|
20936
|
+
// badge.
|
|
20909
20937
|
status: FindingStatus.optional(),
|
|
20910
|
-
|
|
20911
|
-
|
|
20938
|
+
// Every distinct rule seen at this location, UNCAPPED — so the length is a
|
|
20939
|
+
// tally rather than a sample and a row can say how many there are. Bounded
|
|
20940
|
+
// by the ruleset, not by the store. The view bounds what it DISPLAYS.
|
|
20941
|
+
ruleIds: external_exports.array(external_exports.string())
|
|
20942
|
+
}).meta({ id: "FindingLocationSummary" });
|
|
20943
|
+
var DEFAULT_FINDING_LOCATIONS_LIMIT = 50;
|
|
20944
|
+
var MAX_FINDING_LOCATIONS_LIMIT = 100;
|
|
20912
20945
|
var ListFindingLocationsQuery = external_exports.object({
|
|
20913
20946
|
severity: external_exports.array(Severity).optional(),
|
|
20914
20947
|
subtype: external_exports.array(external_exports.string()).optional(),
|
|
@@ -20921,18 +20954,42 @@ var ListFindingLocationsQuery = external_exports.object({
|
|
|
20921
20954
|
q: external_exports.string().optional(),
|
|
20922
20955
|
sessionId: external_exports.string().optional(),
|
|
20923
20956
|
from: external_exports.iso.datetime().optional(),
|
|
20924
|
-
|
|
20957
|
+
// A LOCATION id (see FindingLocationSummary.id) that must appear in the page
|
|
20958
|
+
// even when the cursor has already advanced past its sort position — the
|
|
20959
|
+
// counterpart of ListFindingTypesQuery.includeId, and needed far more often
|
|
20960
|
+
// here. Selecting a row pushes the URL, which re-renders the server and resets
|
|
20961
|
+
// the client's page cache to page 0; with distinct (repo, file) pairs running
|
|
20962
|
+
// into the thousands, a selection sitting off page 0 is the ordinary case
|
|
20963
|
+
// rather than a deep-link corner. Never affects totals, facets or the cursor.
|
|
20964
|
+
includeId: external_exports.string().optional(),
|
|
20965
|
+
limit: external_exports.coerce.number().int().min(1).max(MAX_FINDING_LOCATIONS_LIMIT).optional(),
|
|
20966
|
+
cursor: external_exports.string().optional()
|
|
20925
20967
|
});
|
|
20926
20968
|
var ListFindingLocationsResponse = external_exports.object({
|
|
20927
20969
|
totals: external_exports.object({
|
|
20970
|
+
// Findings matching the filters across the whole scope. Unlike the types
|
|
20971
|
+
// read's same-named field this needs no caveat: the filters here narrow
|
|
20972
|
+
// per finding, so this is the sum of every row's instanceCount.
|
|
20928
20973
|
findings: external_exports.number().int().nonnegative(),
|
|
20929
|
-
|
|
20930
|
-
|
|
20974
|
+
// Counts LOCATIONS, the unit this read pages — the number the paginator
|
|
20975
|
+
// states. The facets beside it count FINDINGS (see below); a surface
|
|
20976
|
+
// showing both says which is which.
|
|
20977
|
+
locations: external_exports.number().int().nonnegative()
|
|
20931
20978
|
}),
|
|
20932
|
-
|
|
20933
|
-
|
|
20934
|
-
|
|
20935
|
-
|
|
20979
|
+
// Counts in FINDINGS, where the types response counts types, each dimension
|
|
20980
|
+
// still excluding its own filter. Deliberately not locations: counting those
|
|
20981
|
+
// needs a set of location keys per dimension per value — memory tracking the
|
|
20982
|
+
// store times the vocabulary, in a read whose scan promises flat memory —
|
|
20983
|
+
// and the cheap per-location version is not an approximation but WRONG. A
|
|
20984
|
+
// location holding {claudecode, block} and {codex, warn} would survive
|
|
20985
|
+
// provider=claudecode AND action=warn, under which no single finding
|
|
20986
|
+
// matches, so the facet would contradict the instanceCount this whole view
|
|
20987
|
+
// rests on. Findings also keep the toolbar in the same unit as the page
|
|
20988
|
+
// tally and the panel it sits above.
|
|
20989
|
+
facets: FindingFacets,
|
|
20990
|
+
/** Sorted by max severity, then most recent, then (repo, file). */
|
|
20991
|
+
items: external_exports.array(FindingLocationSummary),
|
|
20992
|
+
nextCursor: external_exports.string().nullable()
|
|
20936
20993
|
}).meta({ id: "ListFindingLocationsResponse" });
|
|
20937
20994
|
|
|
20938
20995
|
// ../../packages/schema/src/zod/meta.ts
|
|
@@ -22101,6 +22158,14 @@ var ControlPlaneErrorBody = external_exports.object({
|
|
|
22101
22158
|
message: external_exports.string().optional()
|
|
22102
22159
|
}).optional()
|
|
22103
22160
|
});
|
|
22161
|
+
var RemoteFailureKind = external_exports.enum([
|
|
22162
|
+
"unauthorized",
|
|
22163
|
+
"forbidden",
|
|
22164
|
+
"route-absent",
|
|
22165
|
+
"invalid-request",
|
|
22166
|
+
"rejected",
|
|
22167
|
+
"unreachable"
|
|
22168
|
+
]);
|
|
22104
22169
|
var AttachDeviceRequest = external_exports.object({
|
|
22105
22170
|
// This machine's own continuity id, so re-attaching ROTATES the credential
|
|
22106
22171
|
// on one machine record instead of producing a second one. Client-minted
|
|
@@ -22794,139 +22859,62 @@ function deriveFindingStatus(row) {
|
|
|
22794
22859
|
if (row.latestResolutionStatus === "dismissed") return "dismissed";
|
|
22795
22860
|
return "open";
|
|
22796
22861
|
}
|
|
22797
|
-
function distinctUsers(instances) {
|
|
22798
|
-
const seen = /* @__PURE__ */ new Set();
|
|
22799
|
-
const users = [];
|
|
22800
|
-
for (const i of instances) {
|
|
22801
|
-
if (i.user === void 0 || seen.has(i.user.id)) continue;
|
|
22802
|
-
seen.add(i.user.id);
|
|
22803
|
-
users.push(i.user);
|
|
22804
|
-
}
|
|
22805
|
-
return users;
|
|
22806
|
-
}
|
|
22807
22862
|
function sortUsers(users) {
|
|
22808
22863
|
return [...users].sort((a, b) => a.name.localeCompare(b.name) || a.id.localeCompare(b.id));
|
|
22809
22864
|
}
|
|
22810
|
-
function
|
|
22811
|
-
const overrides = opts.overrides;
|
|
22865
|
+
function buildFindingTypes(aggregates, opts = {}) {
|
|
22812
22866
|
const packNames = opts.packNames;
|
|
22813
|
-
const
|
|
22814
|
-
const
|
|
22815
|
-
|
|
22816
|
-
const
|
|
22817
|
-
|
|
22818
|
-
else byRuleId.set(row.ruleId, [row]);
|
|
22819
|
-
}
|
|
22820
|
-
const groups = [];
|
|
22821
|
-
for (const [ruleId, ruleRows] of byRuleId) {
|
|
22822
|
-
const instances = ruleRows.map((r) => {
|
|
22823
|
-
const effectiveDbAction = overrides?.get(r.id) ?? r.actionTaken;
|
|
22824
|
-
return {
|
|
22825
|
-
id: r.id,
|
|
22826
|
-
provider: toApiProvider(r.sourceTool),
|
|
22827
|
-
repo: r.repo,
|
|
22828
|
-
file: r.file,
|
|
22829
|
-
...r.toolName === void 0 ? {} : { toolName: r.toolName },
|
|
22830
|
-
...r.eventId === void 0 ? {} : { eventId: r.eventId },
|
|
22831
|
-
...r.sessionId === void 0 ? {} : { sessionId: r.sessionId },
|
|
22832
|
-
...r.user === void 0 ? {} : { user: r.user },
|
|
22833
|
-
action: toApiAction(effectiveDbAction),
|
|
22834
|
-
detectedAt: r.occurredAt,
|
|
22835
|
-
confidence: r.confidence,
|
|
22836
|
-
status: r.status
|
|
22837
|
-
};
|
|
22838
|
-
});
|
|
22839
|
-
const agg = aggregates?.get(ruleId);
|
|
22840
|
-
const users = agg ? sortUsers(agg.users ?? []) : distinctUsers(instances);
|
|
22841
|
-
const latestDetectedAt = agg?.latestDetectedAt ?? ruleRows.reduce(
|
|
22842
|
-
(max, r) => r.occurredAt > max ? r.occurredAt : max,
|
|
22843
|
-
ruleRows[0]?.occurredAt ?? (/* @__PURE__ */ new Date(0)).toISOString()
|
|
22844
|
-
);
|
|
22845
|
-
const seenProviders = /* @__PURE__ */ new Set();
|
|
22846
|
-
const providers = (agg ? [...new Set(agg.sourceTools.map(toApiProvider))].sort() : instances.map((i) => i.provider)).filter((p) => {
|
|
22847
|
-
if (seenProviders.has(p)) return false;
|
|
22848
|
-
seenProviders.add(p);
|
|
22849
|
-
return true;
|
|
22850
|
-
});
|
|
22851
|
-
const actionSet = new Set(
|
|
22852
|
-
agg ? agg.actionsTaken.map(toApiAction) : instances.map((i) => i.action)
|
|
22853
|
-
);
|
|
22867
|
+
const types = [];
|
|
22868
|
+
for (const [ruleId, agg] of aggregates) {
|
|
22869
|
+
const users = sortUsers(agg.users ?? []);
|
|
22870
|
+
const providers = [...new Set(agg.sourceTools.map(toApiProvider))].sort();
|
|
22871
|
+
const actionSet = new Set(agg.actionsTaken.map(toApiAction));
|
|
22854
22872
|
const aggregateAction = actionSet.size === 1 ? [...actionSet][0] ?? null : null;
|
|
22855
|
-
const
|
|
22856
|
-
const
|
|
22857
|
-
id: ruleId,
|
|
22858
|
-
name: packNames?.get(ruleId) ?? null
|
|
22859
|
-
};
|
|
22860
|
-
const apiCategory = toApiCategory(ruleRows[0]?.category ?? "custom");
|
|
22861
|
-
const policy = { id: `category:${apiCategory}`, name: apiCategory };
|
|
22862
|
-
const match = {
|
|
22863
|
-
maskedValue: ruleRows[0]?.maskedMatch ?? "",
|
|
22864
|
-
contextPrefix: ""
|
|
22865
|
-
// empty (pending privacy review)
|
|
22866
|
-
};
|
|
22867
|
-
const status = foldGroupStatus(
|
|
22868
|
-
agg ? agg.statusInputs.map(deriveFindingStatus) : instances.map((i) => i.status)
|
|
22869
|
-
);
|
|
22870
|
-
const group = {
|
|
22873
|
+
const apiCategory = toApiCategory(agg.category ?? "custom");
|
|
22874
|
+
const type = {
|
|
22871
22875
|
id: ruleId,
|
|
22872
22876
|
category: apiCategory,
|
|
22873
22877
|
subtype: ruleId,
|
|
22874
22878
|
// human label comes with pack metadata later
|
|
22875
|
-
severity,
|
|
22876
|
-
|
|
22877
|
-
|
|
22878
|
-
|
|
22879
|
-
instanceCount: agg?.instanceCount ?? instances.length,
|
|
22879
|
+
severity: agg.severity ?? "low",
|
|
22880
|
+
detection: { id: ruleId, name: packNames?.get(ruleId) ?? null },
|
|
22881
|
+
policy: { id: `category:${apiCategory}`, name: apiCategory },
|
|
22882
|
+
instanceCount: agg.instanceCount,
|
|
22880
22883
|
providers,
|
|
22881
22884
|
aggregateAction,
|
|
22882
|
-
latestDetectedAt,
|
|
22883
|
-
|
|
22884
|
-
status,
|
|
22885
|
+
latestDetectedAt: agg.latestDetectedAt,
|
|
22886
|
+
status: foldGroupStatus(agg.statusInputs.map(deriveFindingStatus)),
|
|
22885
22887
|
...users.length > 0 ? { users } : {}
|
|
22886
22888
|
};
|
|
22887
|
-
|
|
22888
|
-
|
|
22889
|
-
|
|
22890
|
-
haystackCache.set(group, buildHaystack(group, agg.searchText));
|
|
22891
|
-
}
|
|
22889
|
+
actionsCache.set(type, [...actionSet]);
|
|
22890
|
+
if (agg.searchText !== void 0) {
|
|
22891
|
+
haystackCache.set(type, buildHaystack(type, agg.searchText));
|
|
22892
22892
|
}
|
|
22893
|
-
|
|
22893
|
+
types.push(type);
|
|
22894
22894
|
}
|
|
22895
|
-
return
|
|
22895
|
+
return types;
|
|
22896
22896
|
}
|
|
22897
22897
|
var haystackCache = /* @__PURE__ */ new WeakMap();
|
|
22898
|
-
function buildHaystack(
|
|
22898
|
+
function buildHaystack(t, extra) {
|
|
22899
22899
|
return [
|
|
22900
|
-
|
|
22901
|
-
|
|
22902
|
-
|
|
22903
|
-
|
|
22904
|
-
|
|
22905
|
-
...g.instances.map((i) => i.repo),
|
|
22906
|
-
...g.instances.map((i) => i.file),
|
|
22907
|
-
...g.instances.map((i) => i.toolName ? `via ${i.toolName}` : ""),
|
|
22908
|
-
...g.instances.map((i) => i.id),
|
|
22909
|
-
// The people: the whole group's list when the store folded one, plus the
|
|
22910
|
-
// preview's own — the two overlap, and a haystack does not mind.
|
|
22911
|
-
...(g.users ?? []).map((u) => u.name),
|
|
22912
|
-
...g.instances.map((i) => i.user?.name ?? ""),
|
|
22900
|
+
t.subtype,
|
|
22901
|
+
t.category,
|
|
22902
|
+
t.policy.name,
|
|
22903
|
+
t.id,
|
|
22904
|
+
...(t.users ?? []).map((u) => u.name),
|
|
22913
22905
|
...extra === void 0 ? [] : [extra]
|
|
22914
22906
|
].join(" ").toLowerCase();
|
|
22915
22907
|
}
|
|
22916
|
-
function
|
|
22917
|
-
const cached2 = haystackCache.get(
|
|
22908
|
+
function typeHaystack(t) {
|
|
22909
|
+
const cached2 = haystackCache.get(t);
|
|
22918
22910
|
if (cached2 !== void 0) return cached2;
|
|
22919
|
-
const haystack = buildHaystack(
|
|
22920
|
-
haystackCache.set(
|
|
22911
|
+
const haystack = buildHaystack(t);
|
|
22912
|
+
haystackCache.set(t, haystack);
|
|
22921
22913
|
return haystack;
|
|
22922
22914
|
}
|
|
22923
22915
|
var actionsCache = /* @__PURE__ */ new WeakMap();
|
|
22924
|
-
function
|
|
22925
|
-
|
|
22926
|
-
if (cached2 !== void 0) return cached2;
|
|
22927
|
-
const actions = [...new Set(g.instances.map((i) => i.action))];
|
|
22928
|
-
actionsCache.set(g, actions);
|
|
22929
|
-
return actions;
|
|
22916
|
+
function typeActions(t) {
|
|
22917
|
+
return actionsCache.get(t) ?? [];
|
|
22930
22918
|
}
|
|
22931
22919
|
function countInstancesByStatus(statusInputs, statuses) {
|
|
22932
22920
|
const statusSet = new Set(statuses);
|
|
@@ -22937,8 +22925,8 @@ function countInstancesByStatus(statusInputs, statuses) {
|
|
|
22937
22925
|
}
|
|
22938
22926
|
return sum;
|
|
22939
22927
|
}
|
|
22940
|
-
function applyFindingFilters(
|
|
22941
|
-
let filtered =
|
|
22928
|
+
function applyFindingFilters(types, opts) {
|
|
22929
|
+
let filtered = types;
|
|
22942
22930
|
if (opts.severity && opts.severity.length > 0) {
|
|
22943
22931
|
const sevSet = new Set(opts.severity);
|
|
22944
22932
|
filtered = filtered.filter((g) => sevSet.has(g.severity));
|
|
@@ -22949,7 +22937,7 @@ function applyFindingFilters(groups, opts) {
|
|
|
22949
22937
|
}
|
|
22950
22938
|
if (opts.actions && opts.actions.length > 0) {
|
|
22951
22939
|
const actionSet = new Set(opts.actions);
|
|
22952
|
-
filtered = filtered.filter((
|
|
22940
|
+
filtered = filtered.filter((t) => typeActions(t).some((a) => actionSet.has(a)));
|
|
22953
22941
|
}
|
|
22954
22942
|
if (opts.subtype && opts.subtype.length > 0) {
|
|
22955
22943
|
const subtypeSet = new Set(opts.subtype);
|
|
@@ -22961,7 +22949,7 @@ function applyFindingFilters(groups, opts) {
|
|
|
22961
22949
|
}
|
|
22962
22950
|
if (opts.q) {
|
|
22963
22951
|
const q = opts.q.toLowerCase();
|
|
22964
|
-
filtered = filtered.filter((
|
|
22952
|
+
filtered = filtered.filter((t) => typeHaystack(t).includes(q));
|
|
22965
22953
|
}
|
|
22966
22954
|
return filtered;
|
|
22967
22955
|
}
|
|
@@ -22976,11 +22964,11 @@ function compareFindingGroupOrder(a, b) {
|
|
|
22976
22964
|
if (recencyDiff !== 0) return recencyDiff;
|
|
22977
22965
|
return a.id.localeCompare(b.id);
|
|
22978
22966
|
}
|
|
22979
|
-
function
|
|
22980
|
-
return [...
|
|
22967
|
+
function sortFindingTypes(types) {
|
|
22968
|
+
return [...types].sort(compareFindingGroupOrder);
|
|
22981
22969
|
}
|
|
22982
|
-
function computeFindingFacets(
|
|
22983
|
-
const forSeverity = applyFindingFilters(
|
|
22970
|
+
function computeFindingFacets(allTypes, opts) {
|
|
22971
|
+
const forSeverity = applyFindingFilters(allTypes, {
|
|
22984
22972
|
providers: opts.providers,
|
|
22985
22973
|
actions: opts.actions,
|
|
22986
22974
|
statuses: opts.statuses,
|
|
@@ -22991,7 +22979,7 @@ function computeFindingFacets(allGroups, opts) {
|
|
|
22991
22979
|
for (const g of forSeverity) {
|
|
22992
22980
|
severityMap.set(g.severity, (severityMap.get(g.severity) ?? 0) + 1);
|
|
22993
22981
|
}
|
|
22994
|
-
const forProvider = applyFindingFilters(
|
|
22982
|
+
const forProvider = applyFindingFilters(allTypes, {
|
|
22995
22983
|
actions: opts.actions,
|
|
22996
22984
|
statuses: opts.statuses,
|
|
22997
22985
|
q: opts.q,
|
|
@@ -23002,7 +22990,7 @@ function computeFindingFacets(allGroups, opts) {
|
|
|
23002
22990
|
for (const g of forProvider) {
|
|
23003
22991
|
for (const p of g.providers) providerMap.set(p, (providerMap.get(p) ?? 0) + 1);
|
|
23004
22992
|
}
|
|
23005
|
-
const forAction = applyFindingFilters(
|
|
22993
|
+
const forAction = applyFindingFilters(allTypes, {
|
|
23006
22994
|
providers: opts.providers,
|
|
23007
22995
|
statuses: opts.statuses,
|
|
23008
22996
|
q: opts.q,
|
|
@@ -23011,9 +22999,9 @@ function computeFindingFacets(allGroups, opts) {
|
|
|
23011
22999
|
});
|
|
23012
23000
|
const actionMap = /* @__PURE__ */ new Map();
|
|
23013
23001
|
for (const g of forAction) {
|
|
23014
|
-
for (const a of
|
|
23002
|
+
for (const a of typeActions(g)) actionMap.set(a, (actionMap.get(a) ?? 0) + 1);
|
|
23015
23003
|
}
|
|
23016
|
-
const forSubtype = applyFindingFilters(
|
|
23004
|
+
const forSubtype = applyFindingFilters(allTypes, {
|
|
23017
23005
|
providers: opts.providers,
|
|
23018
23006
|
actions: opts.actions,
|
|
23019
23007
|
statuses: opts.statuses,
|
|
@@ -23022,7 +23010,7 @@ function computeFindingFacets(allGroups, opts) {
|
|
|
23022
23010
|
});
|
|
23023
23011
|
const subtypeMap = /* @__PURE__ */ new Map();
|
|
23024
23012
|
for (const g of forSubtype) subtypeMap.set(g.subtype, (subtypeMap.get(g.subtype) ?? 0) + 1);
|
|
23025
|
-
const forStatus = applyFindingFilters(
|
|
23013
|
+
const forStatus = applyFindingFilters(allTypes, {
|
|
23026
23014
|
providers: opts.providers,
|
|
23027
23015
|
actions: opts.actions,
|
|
23028
23016
|
q: opts.q,
|
|
@@ -23070,10 +23058,20 @@ function matchesDimension(row, opts, dimension) {
|
|
|
23070
23058
|
return !opts.statuses?.length || row.status !== void 0 && opts.statuses.includes(row.status);
|
|
23071
23059
|
case "tools":
|
|
23072
23060
|
return !opts.tools?.length || row.toolName !== void 0 && opts.tools.includes(row.toolName);
|
|
23061
|
+
// An EMPTY value is a real filter here, not an absent one. The location
|
|
23062
|
+
// list buckets a finding whose event recorded no repo — or no file — under
|
|
23063
|
+
// the empty string, and selecting that bucket has to narrow the panel to
|
|
23064
|
+
// exactly it. Only `undefined` means "no filter"; a caller that wants every
|
|
23065
|
+
// row omits the key, which every call site already does.
|
|
23066
|
+
//
|
|
23067
|
+
// Reading '' as unset is what this replaced, and it failed in the one place
|
|
23068
|
+
// it mattered: the no-repo/no-file bucket is often the largest in a real
|
|
23069
|
+
// store, and its panel dropped both predicates and returned the WHOLE scope
|
|
23070
|
+
// — a row reading 3 findings beside a panel listing every finding there is.
|
|
23073
23071
|
case "repo":
|
|
23074
|
-
return opts.repo === void 0 ||
|
|
23072
|
+
return opts.repo === void 0 || row.repo === opts.repo;
|
|
23075
23073
|
case "file":
|
|
23076
|
-
return opts.file === void 0 ||
|
|
23074
|
+
return opts.file === void 0 || row.file === opts.file;
|
|
23077
23075
|
case "q":
|
|
23078
23076
|
return !opts.q || rowHaystack(row).includes(opts.q.toLowerCase());
|
|
23079
23077
|
}
|
|
@@ -23187,6 +23185,23 @@ function addToLocation(acc, row) {
|
|
|
23187
23185
|
acc.statuses.push(row.status);
|
|
23188
23186
|
acc.ruleIds.add(row.ruleId);
|
|
23189
23187
|
}
|
|
23188
|
+
function compareLocationOrder(a, b) {
|
|
23189
|
+
const rankA = SEVERITY_ORDER2[a.maxSeverity] ?? -1;
|
|
23190
|
+
const rankB = SEVERITY_ORDER2[b.maxSeverity] ?? -1;
|
|
23191
|
+
if (rankA !== rankB) return rankA - rankB;
|
|
23192
|
+
if (a.latestDetectedAt !== b.latestDetectedAt) {
|
|
23193
|
+
return a.latestDetectedAt < b.latestDetectedAt ? 1 : -1;
|
|
23194
|
+
}
|
|
23195
|
+
if (a.repo !== b.repo) return a.repo < b.repo ? -1 : 1;
|
|
23196
|
+
if (a.file !== b.file) return a.file < b.file ? -1 : 1;
|
|
23197
|
+
return 0;
|
|
23198
|
+
}
|
|
23199
|
+
function encodeLocationId(repo, file2) {
|
|
23200
|
+
return `${encodePart(repo)}/${encodePart(file2)}`;
|
|
23201
|
+
}
|
|
23202
|
+
function encodePart(value) {
|
|
23203
|
+
return encodeURIComponent(value.replace(/[\uD800-\uDFFF]/gu, "\uFFFD"));
|
|
23204
|
+
}
|
|
23190
23205
|
|
|
23191
23206
|
// ../../packages/schema/src/zod/installed-pack.ts
|
|
23192
23207
|
var InstalledPack = external_exports.object({
|
|
@@ -23693,11 +23708,11 @@ var WorkspaceSettings = external_exports.object({
|
|
|
23693
23708
|
// covers the current payload and must be re-granted.
|
|
23694
23709
|
modelJudgeConsent: ModelJudgeConsent.optional(),
|
|
23695
23710
|
// Records that the user consented to the DEFERRED send — the outbox — along
|
|
23696
|
-
// with the payload shape and the endpoint they agreed to. Since payload
|
|
23697
|
-
// that covers
|
|
23698
|
-
// carry prompt/reply text in `content
|
|
23699
|
-
// Absent until granted, and a grant for a different endpoint
|
|
23700
|
-
// payload no longer counts.
|
|
23711
|
+
// with the payload shape and the endpoint they agreed to. Since payload v3
|
|
23712
|
+
// that covers the pre-attach backlog AND undelivered captures alike, and both
|
|
23713
|
+
// carry prompt/reply/tool-output text in `content`; the key name predates
|
|
23714
|
+
// both widenings. Absent until granted, and a grant for a different endpoint
|
|
23715
|
+
// or an older payload no longer counts.
|
|
23701
23716
|
historySyncConsent: HistorySyncConsent.optional()
|
|
23702
23717
|
});
|
|
23703
23718
|
function defaultWorkspaceSettings() {
|
|
@@ -23828,6 +23843,9 @@ var ManagedSettingKey = external_exports.enum([
|
|
|
23828
23843
|
"dataSharesInPlace",
|
|
23829
23844
|
"redactFallback"
|
|
23830
23845
|
]).meta({ id: "ManagedSettingKey" });
|
|
23846
|
+
function isManagedSettingKey(value) {
|
|
23847
|
+
return ManagedSettingKey.safeParse(value).success;
|
|
23848
|
+
}
|
|
23831
23849
|
var ManagedSettingsValues = external_exports.object({
|
|
23832
23850
|
runMode: external_exports.enum(["standalone", "attached"]).optional(),
|
|
23833
23851
|
controlPlane: external_exports.object({
|
|
@@ -23852,7 +23870,27 @@ var ManagedSettings = external_exports.object({
|
|
|
23852
23870
|
// Which of those the user may not change. A key here with no matching value
|
|
23853
23871
|
// freezes whatever the user last chose; a value with no lock is a DEFAULT
|
|
23854
23872
|
// the user may still override. The two are separable on purpose.
|
|
23855
|
-
|
|
23873
|
+
//
|
|
23874
|
+
// Parsed as NAMES rather than as the enum, and split below: a name this
|
|
23875
|
+
// build does not know is dropped from the locked set and reported, never a
|
|
23876
|
+
// reason to refuse the file. The same shape reaches an older build whenever
|
|
23877
|
+
// an administrator locks a key a newer build added, and refusing it there
|
|
23878
|
+
// ran that build entirely unmanaged — every pin and lock gone — on exactly
|
|
23879
|
+
// the fleets most likely to carry a version skew. A name outside the enum
|
|
23880
|
+
// is still never HONOURED: the lockable set stays explicit above.
|
|
23881
|
+
lockedFields: external_exports.array(external_exports.string()).default([])
|
|
23882
|
+
}).transform(({ lockedFields, ...rest }) => {
|
|
23883
|
+
const known = [];
|
|
23884
|
+
const unknown2 = [];
|
|
23885
|
+
for (const name of lockedFields) {
|
|
23886
|
+
if (isManagedSettingKey(name)) known.push(name);
|
|
23887
|
+
else unknown2.push(name);
|
|
23888
|
+
}
|
|
23889
|
+
return {
|
|
23890
|
+
...rest,
|
|
23891
|
+
lockedFields: known,
|
|
23892
|
+
...unknown2.length > 0 ? { unknownLockedFields: unknown2 } : {}
|
|
23893
|
+
};
|
|
23856
23894
|
}).meta({ id: "ManagedSettings" });
|
|
23857
23895
|
|
|
23858
23896
|
// ../../packages/schema/src/zod/project-files.ts
|
|
@@ -23976,7 +24014,11 @@ var FindingsTimeseriesPoint = external_exports.object({
|
|
|
23976
24014
|
timestamp: external_exports.iso.date(),
|
|
23977
24015
|
critical: external_exports.number().int().nonnegative(),
|
|
23978
24016
|
high: external_exports.number().int().nonnegative(),
|
|
23979
|
-
medium: external_exports.number().int().nonnegative()
|
|
24017
|
+
medium: external_exports.number().int().nonnegative(),
|
|
24018
|
+
// Optional and additive, so a producer written against the earlier
|
|
24019
|
+
// three-series contract keeps validating. A consumer plotting it resolves the
|
|
24020
|
+
// absent case itself — the chart point requires a number.
|
|
24021
|
+
low: external_exports.number().int().nonnegative().optional()
|
|
23980
24022
|
}).meta({ id: "FindingsTimeseriesPoint" });
|
|
23981
24023
|
var FindingsTimeseriesResponse = external_exports.object({
|
|
23982
24024
|
range: TimeRange,
|
|
@@ -24002,6 +24044,10 @@ var ResolvedFeedItem = external_exports.object({
|
|
|
24002
24044
|
findingKey: external_exports.string(),
|
|
24003
24045
|
ruleId: external_exports.string(),
|
|
24004
24046
|
severity: Severity,
|
|
24047
|
+
// Repository slug, and the file path RELATIVE to it. The pair is what
|
|
24048
|
+
// identifies the file: a bare path matches the same name in every repo.
|
|
24049
|
+
// Optional and additive; empty when the event carried no repo.
|
|
24050
|
+
repo: external_exports.string().optional(),
|
|
24005
24051
|
path: external_exports.string(),
|
|
24006
24052
|
// ISO-8601 datetime (matches FindingInstance.detectedAt / the rest of the
|
|
24007
24053
|
// findings domain). The reader `.toISOString()`s the DB epoch-ms values.
|
|
@@ -25575,7 +25621,8 @@ var SqliteActivityRepository = class {
|
|
|
25575
25621
|
SELECT 1 FROM audit_events d
|
|
25576
25622
|
WHERE d.root_session_id = audit_events.id
|
|
25577
25623
|
AND (d.content LIKE ? ESCAPE '\\'
|
|
25578
|
-
OR json_extract(d.attributes, '$.detail')
|
|
25624
|
+
OR coalesce(json_extract(d.attributes, '$.detail'),
|
|
25625
|
+
json_extract(d.attributes, '$.target')) LIKE ? ESCAPE '\\')))`
|
|
25579
25626
|
);
|
|
25580
25627
|
params.push(pattern, pattern, pattern, pattern, pattern, pattern);
|
|
25581
25628
|
}
|
|
@@ -26913,23 +26960,6 @@ var LATEST_RESOLUTION_BY_KEY_SQL = `(
|
|
|
26913
26960
|
)`;
|
|
26914
26961
|
|
|
26915
26962
|
// ../../packages/persistence/src/repositories/findings.ts
|
|
26916
|
-
var PREVIEW_INSTANCES_PER_GROUP = 200;
|
|
26917
|
-
var DEFAULT_LOCATIONS_LIMIT = 100;
|
|
26918
|
-
var LOCATION_RULE_IDS_CAP = 20;
|
|
26919
|
-
function compareLocationOrder(a, b) {
|
|
26920
|
-
return compareFindingGroupOrder(
|
|
26921
|
-
{
|
|
26922
|
-
severity: a.maxSeverity,
|
|
26923
|
-
latestDetectedAt: a.latestDetectedAt,
|
|
26924
|
-
id: ""
|
|
26925
|
-
},
|
|
26926
|
-
{
|
|
26927
|
-
severity: b.maxSeverity,
|
|
26928
|
-
latestDetectedAt: b.latestDetectedAt,
|
|
26929
|
-
id: ""
|
|
26930
|
-
}
|
|
26931
|
-
);
|
|
26932
|
-
}
|
|
26933
26963
|
var CONCAT_SEP = ",";
|
|
26934
26964
|
var TUPLE_SEP = "|";
|
|
26935
26965
|
function splitConcat(value) {
|
|
@@ -26981,13 +27011,48 @@ function decodeGroupCursor(cursor) {
|
|
|
26981
27011
|
return null;
|
|
26982
27012
|
}
|
|
26983
27013
|
function firstAfter(sorted, cursor) {
|
|
26984
|
-
const index = sorted.findIndex((
|
|
27014
|
+
const index = sorted.findIndex((t) => compareFindingGroupOrder(t, cursor) > 0);
|
|
26985
27015
|
return index === -1 ? sorted.length : index;
|
|
26986
27016
|
}
|
|
26987
27017
|
function findDeepLinked(sorted, page, id) {
|
|
26988
|
-
if (page.some((
|
|
26989
|
-
return sorted.find((
|
|
27018
|
+
if (page.some((t) => t.id === id)) return void 0;
|
|
27019
|
+
return sorted.find((t) => t.id === id);
|
|
27020
|
+
}
|
|
27021
|
+
function encodeLocationCursor(location) {
|
|
27022
|
+
const payload = {
|
|
27023
|
+
sev: location.maxSeverity,
|
|
27024
|
+
t: location.latestDetectedAt,
|
|
27025
|
+
r: location.repo,
|
|
27026
|
+
f: location.file
|
|
27027
|
+
};
|
|
27028
|
+
return Buffer.from(JSON.stringify(payload)).toString("base64url");
|
|
26990
27029
|
}
|
|
27030
|
+
function decodeLocationCursor(cursor) {
|
|
27031
|
+
const parsed2 = parseJsonObject(Buffer.from(cursor, "base64url").toString("utf8"));
|
|
27032
|
+
if (parsed2 !== void 0 && typeof parsed2.sev === "string" && typeof parsed2.t === "string" && typeof parsed2.r === "string" && typeof parsed2.f === "string") {
|
|
27033
|
+
return { maxSeverity: parsed2.sev, latestDetectedAt: parsed2.t, repo: parsed2.r, file: parsed2.f };
|
|
27034
|
+
}
|
|
27035
|
+
return null;
|
|
27036
|
+
}
|
|
27037
|
+
function firstLocationAfter(sorted, cursor) {
|
|
27038
|
+
const index = sorted.findIndex((l) => compareLocationOrder(l, cursor) > 0);
|
|
27039
|
+
return index === -1 ? sorted.length : index;
|
|
27040
|
+
}
|
|
27041
|
+
function findDeepLinkedLocation(sorted, page, id) {
|
|
27042
|
+
if (page.some((l) => l.id === id)) return void 0;
|
|
27043
|
+
return sorted.find((l) => l.id === id);
|
|
27044
|
+
}
|
|
27045
|
+
var FINDING_ROW_COLUMNS_SQL = `f.id AS id, d.rule_id AS rule_id, d.category AS category,
|
|
27046
|
+
d.severity AS severity, f.masked_match AS masked_match,
|
|
27047
|
+
f.action_taken AS action_taken, f.confidence AS confidence,
|
|
27048
|
+
e.started_at AS occurred_at,
|
|
27049
|
+
e.source_tool AS source_tool,
|
|
27050
|
+
e.repo AS repo,
|
|
27051
|
+
e.file_path AS file,
|
|
27052
|
+
e.tool_name AS tool_name,
|
|
27053
|
+
f.audit_event_id AS event_id, e.root_session_id AS session_id,
|
|
27054
|
+
e.event_type AS kind, f.finding_key AS finding_key,
|
|
27055
|
+
${latestResolutionStatusSql("f")} AS latest_status`;
|
|
26991
27056
|
var DAY_MS3 = 864e5;
|
|
26992
27057
|
var SqliteFindingsRepository = class {
|
|
26993
27058
|
constructor(db) {
|
|
@@ -27108,30 +27173,26 @@ var SqliteFindingsRepository = class {
|
|
|
27108
27173
|
);
|
|
27109
27174
|
}
|
|
27110
27175
|
/**
|
|
27111
|
-
*
|
|
27112
|
-
*
|
|
27113
|
-
*
|
|
27114
|
-
*
|
|
27115
|
-
*
|
|
27116
|
-
*
|
|
27117
|
-
*
|
|
27118
|
-
*
|
|
27119
|
-
*
|
|
27120
|
-
*
|
|
27121
|
-
*
|
|
27122
|
-
*
|
|
27176
|
+
* Finding TYPES for the dashboard — one row per rule, scoped to the four
|
|
27177
|
+
* capture kinds (audit_events also holds structural/reconciler/scan rows this
|
|
27178
|
+
* list must never surface), with per-filter-excluded facets, the requested
|
|
27179
|
+
* filters applied, and sorted by severity then recency. Filtering and faceting
|
|
27180
|
+
* run in JS via the shared @akasecurity/schema helpers. `totals` reflect the
|
|
27181
|
+
* full filtered set; `items` is the requested page (default 50), keyset-paged.
|
|
27182
|
+
* Under a `status` filter, `totals.findings` counts only findings whose
|
|
27183
|
+
* derived status was requested.
|
|
27184
|
+
*
|
|
27185
|
+
* ONE read, which materializes no findings: a single aggregate per rule_id,
|
|
27186
|
+
* folding EVERY finding into the numbers a type row and the filters need
|
|
27187
|
+
* (count, severity, category, providers, actions, statuses, latest, search
|
|
27188
|
+
* text). The findings OF a type come from listFindingInstances scoped to
|
|
27189
|
+
* `subtype`, so neither list bounds the other and no per-type cap exists.
|
|
27123
27190
|
*
|
|
27124
|
-
* Two reads, neither of which materializes a row per finding:
|
|
27125
|
-
* 1. one aggregate row per rule_id, folding EVERY instance into the numbers
|
|
27126
|
-
* the group and the filters need (count, providers, actions, statuses,
|
|
27127
|
-
* latest, search text);
|
|
27128
|
-
* 2. each group's newest PREVIEW_INSTANCES_PER_GROUP instances, which
|
|
27129
|
-
* populate `instances` for the table's expanded rows.
|
|
27130
27191
|
* The aggregates carry raw DB values and are translated by the same
|
|
27131
|
-
* @akasecurity/schema mappers
|
|
27132
|
-
* rule is ever restated in SQL.
|
|
27192
|
+
* @akasecurity/schema mappers every other path uses, so no enum mapping or
|
|
27193
|
+
* status rule is ever restated in SQL.
|
|
27133
27194
|
*/
|
|
27134
|
-
|
|
27195
|
+
listFindingTypes(query) {
|
|
27135
27196
|
const sessionPredicate = query.sessionId ? ` AND e.root_session_id = :sessionId` : "";
|
|
27136
27197
|
const fromMs = query.from === void 0 ? void 0 : isoToEpochMillis(query.from);
|
|
27137
27198
|
const fromPredicate = fromMs === void 0 ? "" : ` AND e.started_at >= :fromMs`;
|
|
@@ -27144,12 +27205,7 @@ var SqliteFindingsRepository = class {
|
|
|
27144
27205
|
predicate,
|
|
27145
27206
|
params: sessionParams
|
|
27146
27207
|
});
|
|
27147
|
-
const
|
|
27148
|
-
sessionId: query.sessionId,
|
|
27149
|
-
from: query.from
|
|
27150
|
-
});
|
|
27151
|
-
const groupable = rows.map(toFlatFindingRow);
|
|
27152
|
-
const allGroups = buildFindingGroups(groupable, { aggregates });
|
|
27208
|
+
const allTypes = buildFindingTypes(aggregates);
|
|
27153
27209
|
const filterOpts = {
|
|
27154
27210
|
severity: query.severity,
|
|
27155
27211
|
providers: query.provider,
|
|
@@ -27158,30 +27214,25 @@ var SqliteFindingsRepository = class {
|
|
|
27158
27214
|
subtype: query.subtype,
|
|
27159
27215
|
q: query.q
|
|
27160
27216
|
};
|
|
27161
|
-
const facets = computeFindingFacets(
|
|
27162
|
-
const sorted =
|
|
27217
|
+
const facets = computeFindingFacets(allTypes, filterOpts);
|
|
27218
|
+
const sorted = sortFindingTypes(applyFindingFilters(allTypes, filterOpts));
|
|
27163
27219
|
const statusFilter = query.status ?? [];
|
|
27164
27220
|
const totals = {
|
|
27165
|
-
findings: sorted.reduce((acc,
|
|
27166
|
-
if (statusFilter.length === 0) return acc +
|
|
27167
|
-
const agg = aggregates.get(
|
|
27168
|
-
return acc + (agg ? countInstancesByStatus(agg.statusInputs, statusFilter) ??
|
|
27221
|
+
findings: sorted.reduce((acc, t) => {
|
|
27222
|
+
if (statusFilter.length === 0) return acc + t.instanceCount;
|
|
27223
|
+
const agg = aggregates.get(t.id);
|
|
27224
|
+
return acc + (agg ? countInstancesByStatus(agg.statusInputs, statusFilter) ?? t.instanceCount : t.instanceCount);
|
|
27169
27225
|
}, 0),
|
|
27170
|
-
|
|
27226
|
+
types: sorted.length
|
|
27171
27227
|
};
|
|
27172
|
-
const limit = query.limit ??
|
|
27228
|
+
const limit = query.limit ?? DEFAULT_FINDING_TYPES_LIMIT;
|
|
27173
27229
|
const cursor = query.cursor === void 0 ? null : decodeGroupCursor(query.cursor);
|
|
27174
27230
|
const start = cursor === null ? 0 : firstAfter(sorted, cursor);
|
|
27175
27231
|
const page = sorted.slice(start, start + limit);
|
|
27176
27232
|
const lastOnPage = page.at(-1);
|
|
27177
27233
|
const nextCursor = start + limit < sorted.length && lastOnPage ? encodeGroupCursor(lastOnPage) : null;
|
|
27178
27234
|
const deepLinked = query.includeId === void 0 || query.includeId === "" ? void 0 : findDeepLinked(sorted, page, query.includeId);
|
|
27179
|
-
const
|
|
27180
|
-
const narrow = (g) => statusSet ? {
|
|
27181
|
-
...g,
|
|
27182
|
-
instances: g.instances.filter((i) => i.status !== void 0 && statusSet.has(i.status))
|
|
27183
|
-
} : g;
|
|
27184
|
-
const items = [...page, ...deepLinked ? [deepLinked] : []].map(narrow);
|
|
27235
|
+
const items = [...page, ...deepLinked ? [deepLinked] : []];
|
|
27185
27236
|
return Promise.resolve({
|
|
27186
27237
|
totals,
|
|
27187
27238
|
facets,
|
|
@@ -27192,7 +27243,7 @@ var SqliteFindingsRepository = class {
|
|
|
27192
27243
|
}
|
|
27193
27244
|
/**
|
|
27194
27245
|
* One row per rule_id, folding EVERY instance of the group into the values
|
|
27195
|
-
*
|
|
27246
|
+
* buildFindingTypes cannot recover from an aggregate. Bounded by the number of
|
|
27196
27247
|
* distinct rule_ids (the installed packs' rules), not by the store's size.
|
|
27197
27248
|
*
|
|
27198
27249
|
* A single scan, folded in two levels: the inner SELECT groups by
|
|
@@ -27286,13 +27337,25 @@ var SqliteFindingsRepository = class {
|
|
|
27286
27337
|
});
|
|
27287
27338
|
}
|
|
27288
27339
|
/**
|
|
27289
|
-
* The same findings folded by
|
|
27340
|
+
* The same findings folded by WHERE they live — one row per (repo, file) pair.
|
|
27290
27341
|
*
|
|
27291
27342
|
* The grouping keys come from the capturing event's attributes, which is what
|
|
27292
|
-
* the local store relates a finding to
|
|
27293
|
-
*
|
|
27294
|
-
* empty-string bucket, which
|
|
27295
|
-
*
|
|
27343
|
+
* the local store relates a finding to; there is no finding↔asset row to group
|
|
27344
|
+
* by instead. A repo or file the event did not record folds into the
|
|
27345
|
+
* empty-string bucket, which is a real location like any other: it is listed,
|
|
27346
|
+
* it is selectable, and its `?loc=` token is as good as any other row's.
|
|
27347
|
+
*
|
|
27348
|
+
* ONE flat list rather than repos nesting files. A rollup can only be paged by
|
|
27349
|
+
* repo, which leaves the file list inside it unbounded — the shape the by-type
|
|
27350
|
+
* list was rebuilt to remove — and two-level pagination inside an
|
|
27351
|
+
* expand/collapse table is what pushed that view to master/detail in the first
|
|
27352
|
+
* place.
|
|
27353
|
+
*
|
|
27354
|
+
* Every filter narrows the FINDINGS and the locations fall out of what
|
|
27355
|
+
* survives, so each row's `instanceCount` is exactly what listFindingInstances
|
|
27356
|
+
* reports for the same filters scoped to that pair. The view depends on it:
|
|
27357
|
+
* one toolbar sits over both panels precisely because a location owns none of
|
|
27358
|
+
* its fields.
|
|
27296
27359
|
*/
|
|
27297
27360
|
listFindingLocations(query) {
|
|
27298
27361
|
const opts = {
|
|
@@ -27304,13 +27367,16 @@ var SqliteFindingsRepository = class {
|
|
|
27304
27367
|
tools: query.tool,
|
|
27305
27368
|
q: query.q
|
|
27306
27369
|
};
|
|
27307
|
-
const limit = query.limit ??
|
|
27370
|
+
const limit = query.limit ?? DEFAULT_FINDING_LOCATIONS_LIMIT;
|
|
27371
|
+
const cursor = query.cursor === void 0 ? null : decodeLocationCursor(query.cursor);
|
|
27308
27372
|
const byRepo = /* @__PURE__ */ new Map();
|
|
27373
|
+
const accumulator = createInstanceFacetAccumulator(opts);
|
|
27309
27374
|
let total = 0;
|
|
27310
27375
|
for (const row of this.scanFindingRows({
|
|
27311
27376
|
sessionId: query.sessionId,
|
|
27312
27377
|
from: query.from
|
|
27313
27378
|
})) {
|
|
27379
|
+
accumulator.add(row);
|
|
27314
27380
|
if (!matchesInstanceFilters(row, opts)) continue;
|
|
27315
27381
|
total += 1;
|
|
27316
27382
|
let files = byRepo.get(row.repo);
|
|
@@ -27325,103 +27391,35 @@ var SqliteFindingsRepository = class {
|
|
|
27325
27391
|
}
|
|
27326
27392
|
addToLocation(acc, row);
|
|
27327
27393
|
}
|
|
27328
|
-
|
|
27329
|
-
const
|
|
27330
|
-
|
|
27331
|
-
|
|
27332
|
-
|
|
27333
|
-
|
|
27334
|
-
|
|
27335
|
-
|
|
27336
|
-
|
|
27337
|
-
|
|
27338
|
-
|
|
27339
|
-
|
|
27340
|
-
|
|
27341
|
-
|
|
27342
|
-
|
|
27343
|
-
|
|
27344
|
-
|
|
27345
|
-
|
|
27346
|
-
|
|
27347
|
-
|
|
27348
|
-
|
|
27349
|
-
|
|
27350
|
-
);
|
|
27351
|
-
const statuses = fileRows.map((f) => f.status);
|
|
27352
|
-
const folded = foldGroupStatus(statuses);
|
|
27353
|
-
return {
|
|
27354
|
-
repo,
|
|
27355
|
-
instanceCount: rollup.instanceCount,
|
|
27356
|
-
maxSeverity: rollup.maxSeverity,
|
|
27357
|
-
latestDetectedAt: rollup.latestDetectedAt,
|
|
27358
|
-
...folded === void 0 ? {} : { status: folded },
|
|
27359
|
-
files: fileRows
|
|
27360
|
-
};
|
|
27361
|
-
});
|
|
27362
|
-
repos.sort(compareLocationOrder);
|
|
27394
|
+
const sorted = [];
|
|
27395
|
+
for (const [repo, files] of byRepo) {
|
|
27396
|
+
for (const [file2, acc] of files) {
|
|
27397
|
+
const status = foldGroupStatus(acc.statuses);
|
|
27398
|
+
sorted.push({
|
|
27399
|
+
id: encodeLocationId(repo, file2),
|
|
27400
|
+
repo,
|
|
27401
|
+
file: file2,
|
|
27402
|
+
instanceCount: acc.instanceCount,
|
|
27403
|
+
maxSeverity: acc.maxSeverity,
|
|
27404
|
+
latestDetectedAt: acc.latestDetectedAt,
|
|
27405
|
+
...status === void 0 ? {} : { status },
|
|
27406
|
+
ruleIds: [...acc.ruleIds]
|
|
27407
|
+
});
|
|
27408
|
+
}
|
|
27409
|
+
}
|
|
27410
|
+
sorted.sort(compareLocationOrder);
|
|
27411
|
+
const start = cursor === null ? 0 : firstLocationAfter(sorted, cursor);
|
|
27412
|
+
const page = sorted.slice(start, start + limit);
|
|
27413
|
+
const lastOnPage = page.at(-1);
|
|
27414
|
+
const nextCursor = start + limit < sorted.length && lastOnPage ? encodeLocationCursor(lastOnPage) : null;
|
|
27415
|
+
const deepLinked = query.includeId === void 0 || query.includeId === "" ? void 0 : findDeepLinkedLocation(sorted, page, query.includeId);
|
|
27363
27416
|
return Promise.resolve({
|
|
27364
|
-
totals: { findings: total,
|
|
27365
|
-
|
|
27366
|
-
|
|
27417
|
+
totals: { findings: total, locations: sorted.length },
|
|
27418
|
+
facets: accumulator.facets(),
|
|
27419
|
+
items: [...page, ...deepLinked ? [deepLinked] : []],
|
|
27420
|
+
nextCursor
|
|
27367
27421
|
});
|
|
27368
27422
|
}
|
|
27369
|
-
/**
|
|
27370
|
-
* Each group's newest instances, for the table's expanded rows.
|
|
27371
|
-
*
|
|
27372
|
-
* ONE index-ordered scan with early termination, and the shape is the point.
|
|
27373
|
-
* The natural spelling — `ROW_NUMBER() OVER (PARTITION BY rule_id ORDER BY
|
|
27374
|
-
* started_at DESC)` then `WHERE rn <= cap` — sorts EVERY finding in scope
|
|
27375
|
-
* through a temp B-tree to keep a bounded preview of each group, and then
|
|
27376
|
-
* sorts the survivors again for the page order. Both sorts grow with the
|
|
27377
|
-
* store while the answer does not.
|
|
27378
|
-
*
|
|
27379
|
-
* Instead the scan walks `audit_events` newest-first off `idx_audit_started_at`
|
|
27380
|
-
* (or the session or window index the scope names — see `findingScanSql`),
|
|
27381
|
-
* which is already the order the page wants, and keeps rows per rule until
|
|
27382
|
-
* each rule has as many as it can show. The aggregate the caller already holds
|
|
27383
|
-
* says how many that is: `min(instanceCount, PREVIEW_INSTANCES_PER_GROUP)`
|
|
27384
|
-
* per rule, summed, is the number of rows this scan has to find, and it stops
|
|
27385
|
-
* on the last one. That sum is bounded by `rules * PREVIEW_INSTANCES_PER_GROUP`
|
|
27386
|
-
* (8,000 at this repo's 40-rule bench corpus), not by a fixed row count — a
|
|
27387
|
-
* store with many firing rules widens it. The bound that DOES hold
|
|
27388
|
-
* unconditionally is the sorted form's floor: this scan visits at most as
|
|
27389
|
-
* many rows as `ROW_NUMBER() OVER (PARTITION BY rule_id …)` would have
|
|
27390
|
-
* sorted, and stops the moment every rule has its cap, where the sorted form
|
|
27391
|
-
* sorts the whole scope regardless. The true worst case — the rarest rule's
|
|
27392
|
-
* wanted instances sitting at the tail of the scope — is one pass over
|
|
27393
|
-
* everything in scope with a block sort of the id tie-break only, never a
|
|
27394
|
-
* sort of the scope, which is still that floor.
|
|
27395
|
-
*
|
|
27396
|
-
* A row whose rule the aggregate did not see is skipped: the two statements
|
|
27397
|
-
* run without a shared snapshot, so a capture landing between them can add a
|
|
27398
|
-
* rule here that has no counts there, and the counts are what the group is
|
|
27399
|
-
* built from.
|
|
27400
|
-
*/
|
|
27401
|
-
previewRows(aggregates, scope) {
|
|
27402
|
-
const wanted = /* @__PURE__ */ new Map();
|
|
27403
|
-
let remaining = 0;
|
|
27404
|
-
for (const [ruleId, agg] of aggregates) {
|
|
27405
|
-
const n = Math.min(agg.instanceCount, PREVIEW_INSTANCES_PER_GROUP);
|
|
27406
|
-
wanted.set(ruleId, n);
|
|
27407
|
-
remaining += n;
|
|
27408
|
-
}
|
|
27409
|
-
const rows = [];
|
|
27410
|
-
if (remaining === 0) return rows;
|
|
27411
|
-
const { sql, params } = this.findingScanSql(scope);
|
|
27412
|
-
const taken = /* @__PURE__ */ new Map();
|
|
27413
|
-
for (const r of iterateRows(this.db.prepare(sql), params)) {
|
|
27414
|
-
const want = wanted.get(r.rule_id);
|
|
27415
|
-
if (want === void 0) continue;
|
|
27416
|
-
const have = taken.get(r.rule_id) ?? 0;
|
|
27417
|
-
if (have >= want) continue;
|
|
27418
|
-
taken.set(r.rule_id, have + 1);
|
|
27419
|
-
rows.push(r);
|
|
27420
|
-
remaining -= 1;
|
|
27421
|
-
if (remaining === 0) break;
|
|
27422
|
-
}
|
|
27423
|
-
return rows;
|
|
27424
|
-
}
|
|
27425
27423
|
/**
|
|
27426
27424
|
* Every finding in scope as a FlatFindingRow, newest first, streamed.
|
|
27427
27425
|
*
|
|
@@ -27448,6 +27446,33 @@ var SqliteFindingsRepository = class {
|
|
|
27448
27446
|
yield toFlatFindingRow(r);
|
|
27449
27447
|
}
|
|
27450
27448
|
}
|
|
27449
|
+
/**
|
|
27450
|
+
* One finding by its own id, or null when no such row exists.
|
|
27451
|
+
*
|
|
27452
|
+
* A primary-key seek on `inspection_findings`, so its cost does not grow with
|
|
27453
|
+
* the store — and, unlike anything derived from a list page, it resolves a
|
|
27454
|
+
* finding of ANY age. That is what the Findings page's one-shot `?finding=`
|
|
27455
|
+
* deep link needs: the id it carries may name a finding thousands of rows
|
|
27456
|
+
* older than anything a first page holds.
|
|
27457
|
+
*
|
|
27458
|
+
* Deliberately UNFILTERED — no capture-kind, session or time predicate. It
|
|
27459
|
+
* RESOLVES an id; whether that row would survive the list's current filters is
|
|
27460
|
+
* a different question, and hiding the target because a filter excludes it is
|
|
27461
|
+
* worse than showing it.
|
|
27462
|
+
*
|
|
27463
|
+
* `groupId` on the result IS the rule id, so this one read answers both "which
|
|
27464
|
+
* type should the list select?" and "what does the drawer show?".
|
|
27465
|
+
*/
|
|
27466
|
+
findingInstance(id) {
|
|
27467
|
+
const row = this.db.prepare(
|
|
27468
|
+
`SELECT ${FINDING_ROW_COLUMNS_SQL}
|
|
27469
|
+
FROM inspection_findings f
|
|
27470
|
+
JOIN audit_events e ON e.id = f.audit_event_id
|
|
27471
|
+
JOIN inspection_definitions d ON d.id = f.inspection_definition_id
|
|
27472
|
+
WHERE f.id = ?`
|
|
27473
|
+
).get(id);
|
|
27474
|
+
return Promise.resolve(row === void 0 ? null : toInstanceDetail(toFlatFindingRow(row)));
|
|
27475
|
+
}
|
|
27451
27476
|
/**
|
|
27452
27477
|
* The one statement both instance-level scans run: every finding in scope,
|
|
27453
27478
|
* joined to its event and definition, newest first.
|
|
@@ -27481,17 +27506,7 @@ var SqliteFindingsRepository = class {
|
|
|
27481
27506
|
conditions.push("e.started_at >= ?");
|
|
27482
27507
|
params.push(isoToEpochMillis(scope.from));
|
|
27483
27508
|
}
|
|
27484
|
-
const sql = `SELECT
|
|
27485
|
-
d.severity AS severity, f.masked_match AS masked_match,
|
|
27486
|
-
f.action_taken AS action_taken, f.confidence AS confidence,
|
|
27487
|
-
e.started_at AS occurred_at,
|
|
27488
|
-
e.source_tool AS source_tool,
|
|
27489
|
-
e.repo AS repo,
|
|
27490
|
-
e.file_path AS file,
|
|
27491
|
-
e.tool_name AS tool_name,
|
|
27492
|
-
f.audit_event_id AS event_id, e.root_session_id AS session_id,
|
|
27493
|
-
e.event_type AS kind, f.finding_key AS finding_key,
|
|
27494
|
-
${latestResolutionStatusSql("f")} AS latest_status
|
|
27509
|
+
const sql = `SELECT ${FINDING_ROW_COLUMNS_SQL}
|
|
27495
27510
|
FROM audit_events e
|
|
27496
27511
|
CROSS JOIN inspection_findings f ON f.audit_event_id = e.id
|
|
27497
27512
|
CROSS JOIN inspection_definitions d ON d.id = f.inspection_definition_id
|
|
@@ -27505,6 +27520,26 @@ var SqliteFindingsRepository = class {
|
|
|
27505
27520
|
group_concat(DISTINCT 'via ' || e.tool_name) AS tool_names` : `, NULL AS repos, NULL AS files, NULL AS tool_names`;
|
|
27506
27521
|
const rows = this.db.prepare(
|
|
27507
27522
|
`SELECT rule_id,
|
|
27523
|
+
-- BARE columns beside max(latest_at), which is deliberate and
|
|
27524
|
+
-- is SQLite's documented behaviour: with a single min()/max()
|
|
27525
|
+
-- in an aggregate query, every bare column takes its value from
|
|
27526
|
+
-- the row that produced the extremum. So these are the severity
|
|
27527
|
+
-- and category of the definition whose finding is NEWEST, which
|
|
27528
|
+
-- is what the row-based build they replaced read off its first
|
|
27529
|
+
-- (newest-first) row.
|
|
27530
|
+
--
|
|
27531
|
+
-- min() is WRONG here and was the defect: inspection_definitions
|
|
27532
|
+
-- holds one row per rule VERSION (see its writer \u2014 a version bump
|
|
27533
|
+
-- mints a new row), so a rule whose severity moved between
|
|
27534
|
+
-- versions has several, and min() picks the ALPHABETICALLY
|
|
27535
|
+
-- smallest \u2014 'low' over 'medium', but 'critical' over 'high'.
|
|
27536
|
+
-- That is arbitrary in direction, and it feeds the badge, the
|
|
27537
|
+
-- filter, the facet counts and the primary sort key.
|
|
27538
|
+
--
|
|
27539
|
+
-- Adding a second min()/max() aggregate here would make these
|
|
27540
|
+
-- bare columns ambiguous again; keep max(latest_at) the only one.
|
|
27541
|
+
severity,
|
|
27542
|
+
category,
|
|
27508
27543
|
sum(tuple_count) AS instance_count,
|
|
27509
27544
|
max(latest_at) AS latest_at,
|
|
27510
27545
|
group_concat(source_tools) AS source_tools,
|
|
@@ -27515,6 +27550,14 @@ var SqliteFindingsRepository = class {
|
|
|
27515
27550
|
group_concat(tool_names) AS tool_names
|
|
27516
27551
|
FROM (
|
|
27517
27552
|
SELECT d.rule_id AS rule_id,
|
|
27553
|
+
-- Severity and category are columns of the DEFINITION, and
|
|
27554
|
+
-- a rule can have SEVERAL definitions (one per version), so
|
|
27555
|
+
-- these are grouped on below and resolved to the newest
|
|
27556
|
+
-- firing version by the outer query's bare-column select.
|
|
27557
|
+
-- They ride the aggregate because the type build has no rows
|
|
27558
|
+
-- to read them off \u2014 see buildFindingTypes.
|
|
27559
|
+
d.severity AS severity,
|
|
27560
|
+
d.category AS category,
|
|
27518
27561
|
e.event_type || '${TUPLE_SEP}' ||
|
|
27519
27562
|
(CASE WHEN f.finding_key IS NULL THEN '' ELSE 'k' END) || '${TUPLE_SEP}' ||
|
|
27520
27563
|
coalesce(latest.status, '') AS status_tuple,
|
|
@@ -27529,7 +27572,7 @@ var SqliteFindingsRepository = class {
|
|
|
27529
27572
|
LEFT JOIN ${LATEST_RESOLUTION_BY_KEY_SQL} latest
|
|
27530
27573
|
ON latest.finding_key = f.finding_key
|
|
27531
27574
|
${scope.predicate}
|
|
27532
|
-
GROUP BY d.rule_id, status_tuple
|
|
27575
|
+
GROUP BY d.rule_id, d.severity, d.category, status_tuple
|
|
27533
27576
|
)
|
|
27534
27577
|
GROUP BY rule_id`
|
|
27535
27578
|
).all(scope.params);
|
|
@@ -27538,6 +27581,8 @@ var SqliteFindingsRepository = class {
|
|
|
27538
27581
|
r.rule_id,
|
|
27539
27582
|
{
|
|
27540
27583
|
instanceCount: r.instance_count,
|
|
27584
|
+
severity: r.severity,
|
|
27585
|
+
category: r.category,
|
|
27541
27586
|
sourceTools: splitConcat(r.source_tools),
|
|
27542
27587
|
actionsTaken: splitConcat(r.actions_taken),
|
|
27543
27588
|
statusInputs: splitConcat(r.status_inputs).map((tuple2) => {
|
|
@@ -27554,7 +27599,7 @@ var SqliteFindingsRepository = class {
|
|
|
27554
27599
|
latestDetectedAt: epochMillisToIso(r.latest_at),
|
|
27555
27600
|
// Free text only — joined and substring-matched, so group_concat's
|
|
27556
27601
|
// commas need no unpicking (a repo/path containing one still matches).
|
|
27557
|
-
// Left undefined (not '') when unfetched, so
|
|
27602
|
+
// Left undefined (not '') when unfetched, so buildFindingTypes can
|
|
27558
27603
|
// tell "no q this request" from "a group with no repo/file at all"
|
|
27559
27604
|
// and skip priming a haystack nothing will read.
|
|
27560
27605
|
...withSearchText ? {
|
|
@@ -27706,6 +27751,12 @@ var SqliteHistorySyncRepository = class {
|
|
|
27706
27751
|
this.markOwedStmt = db.prepare(
|
|
27707
27752
|
`UPDATE audit_events SET outbox_owed = 1 WHERE id = :id AND synced_at IS NULL`
|
|
27708
27753
|
);
|
|
27754
|
+
this.markCaptureBacklogOwedStmt = db.prepare(
|
|
27755
|
+
`UPDATE audit_events SET outbox_owed = 1
|
|
27756
|
+
WHERE synced_at IS NULL
|
|
27757
|
+
AND event_type IN (${CAPTURE_TYPE_LIST})
|
|
27758
|
+
AND started_at < :before`
|
|
27759
|
+
);
|
|
27709
27760
|
this.stampStmt = db.prepare(
|
|
27710
27761
|
`UPDATE audit_events SET synced_at = :at, sync_claimed_at = NULL WHERE id = :id`
|
|
27711
27762
|
);
|
|
@@ -27754,7 +27805,9 @@ var SqliteHistorySyncRepository = class {
|
|
|
27754
27805
|
);
|
|
27755
27806
|
this.disownCapturesStmt = db.prepare(
|
|
27756
27807
|
`UPDATE audit_events SET outbox_owed = NULL
|
|
27757
|
-
WHERE outbox_owed IS NOT NULL
|
|
27808
|
+
WHERE outbox_owed IS NOT NULL
|
|
27809
|
+
AND event_type IN (${CAPTURE_TYPE_LIST})
|
|
27810
|
+
AND started_at < :attachedAt`
|
|
27758
27811
|
);
|
|
27759
27812
|
this.rearmStmt = db.prepare(
|
|
27760
27813
|
`UPDATE audit_events SET synced_at = NULL
|
|
@@ -27830,6 +27883,7 @@ var SqliteHistorySyncRepository = class {
|
|
|
27830
27883
|
freezeBoundaryStmt;
|
|
27831
27884
|
captureRowsStmt;
|
|
27832
27885
|
markOwedStmt;
|
|
27886
|
+
markCaptureBacklogOwedStmt;
|
|
27833
27887
|
captureSkipCountStmt;
|
|
27834
27888
|
disownCapturesStmt;
|
|
27835
27889
|
partitionStmt;
|
|
@@ -27893,6 +27947,23 @@ var SqliteHistorySyncRepository = class {
|
|
|
27893
27947
|
markCaptureOwed(id) {
|
|
27894
27948
|
this.markOwedStmt.run({ id });
|
|
27895
27949
|
}
|
|
27950
|
+
/**
|
|
27951
|
+
* Mark every capture already on disk as owed, as of `before`.
|
|
27952
|
+
*
|
|
27953
|
+
* The consent-time backfill, called once from `aka attach` when a human
|
|
27954
|
+
* grants existing-history consent — never from an ongoing drain pass, and
|
|
27955
|
+
* never inferred from a boundary that could later move. `before` is the
|
|
27956
|
+
* caller's own "now" at the moment consent was granted, so what this marks
|
|
27957
|
+
* is exactly the backlog the consent prompt already counted, not whatever a
|
|
27958
|
+
* later re-attach or key rotation might widen it to.
|
|
27959
|
+
*
|
|
27960
|
+
* Returns how many rows matched, for the caller to log or test against. Not a
|
|
27961
|
+
* count of NEWLY marked rows — a row still unsynced from an earlier call
|
|
27962
|
+
* matches again and is counted again, the same as `UPDATE`'s own `changes`.
|
|
27963
|
+
*/
|
|
27964
|
+
markCaptureBacklogOwed(before) {
|
|
27965
|
+
return Number(this.markCaptureBacklogOwedStmt.run({ before }).changes);
|
|
27966
|
+
}
|
|
27896
27967
|
/** Record delivery. Called only AFTER the far side has accepted the rows. */
|
|
27897
27968
|
markSynced(ids, atMs) {
|
|
27898
27969
|
this.stampAll(ids, atMs);
|
|
@@ -28009,15 +28080,42 @@ var SqliteHistorySyncRepository = class {
|
|
|
28009
28080
|
*
|
|
28010
28081
|
* Delivery is a fact about ONE recipient: rows sent to the deployment a
|
|
28011
28082
|
* machine has just left are undelivered as far as the new one is concerned.
|
|
28012
|
-
* All
|
|
28013
|
-
* attributed to the wrong deployment,
|
|
28083
|
+
* All four in one transaction, so a crash between them cannot leave stamps
|
|
28084
|
+
* attributed to the wrong deployment, a boundary that belongs to another, or
|
|
28085
|
+
* a disown with no re-mark to follow it.
|
|
28014
28086
|
*
|
|
28015
28087
|
* The boundary is written HERE and only here, which is what freezes it: a
|
|
28016
28088
|
* re-attach to the SAME deployment (a key rotation) leaves the fingerprint
|
|
28017
28089
|
* unchanged, so this never runs and the backlog does not widen back over rows
|
|
28018
28090
|
* the live path has since delivered.
|
|
28091
|
+
*
|
|
28092
|
+
* `backfillCapturesBefore` is the caller's OWN "now" at the instant a human
|
|
28093
|
+
* granted existing-history consent for the deployment this call is arming —
|
|
28094
|
+
* a DIFFERENT instant from `backlogBefore`: the re-mark boundary is the GRANT
|
|
28095
|
+
* instant, `backlogBefore` is the ATTACH instant, and the two can be far
|
|
28096
|
+
* apart. Passed only when that grant is valid, since this method has no way
|
|
28097
|
+
* to check consent itself and must not mark a row owed for a machine that
|
|
28098
|
+
* never agreed to it. Applied AFTER the disown above, in the SAME
|
|
28099
|
+
* transaction: what the disown clears is every marker below `backlogBefore`,
|
|
28100
|
+
* which includes this deployment's OWN pre-attach rows — `aka attach` calls
|
|
28101
|
+
* `seedCaptureBacklogOwed` at the attach instant, so every row it marks sits
|
|
28102
|
+
* on the cleared side of that bound — and the re-mark in the same
|
|
28103
|
+
* transaction is what puts those rows back. A crash between the two cannot
|
|
28104
|
+
* strand the ledger disowned with nothing re-marked — the transaction either
|
|
28105
|
+
* lands whole or not at all, and a fingerprint mismatch that has not yet
|
|
28106
|
+
* committed re-enters this method on the very next pass. Omit it (the
|
|
28107
|
+
* structural-only tests do) to exercise the disown in isolation.
|
|
28108
|
+
*
|
|
28109
|
+
* The disown is bounded by `backlogBefore`, which is what keeps it from
|
|
28110
|
+
* touching a marker the NEW deployment's OWN live path has already set: B's
|
|
28111
|
+
* live path can mark a capture owed from the moment `aka attach` writes the
|
|
28112
|
+
* descriptor, before the drain's first pass ever reaches this method, and
|
|
28113
|
+
* such a row sits at or after the bound rather than below it. What keeps the
|
|
28114
|
+
* disown from eating THIS SAME CALL's own re-mark is the order, not the
|
|
28115
|
+
* bound — disown runs first, re-mark second, both inside the one
|
|
28116
|
+
* transaction above.
|
|
28019
28117
|
*/
|
|
28020
|
-
rearmFor(fingerprint, backlogBefore) {
|
|
28118
|
+
rearmFor(fingerprint, backlogBefore, backfillCapturesBefore) {
|
|
28021
28119
|
this.ensureRowStmt.run();
|
|
28022
28120
|
withTransaction(
|
|
28023
28121
|
this.db,
|
|
@@ -28025,7 +28123,10 @@ var SqliteHistorySyncRepository = class {
|
|
|
28025
28123
|
const previous = getRow(this.fingerprintStmt)?.fingerprint;
|
|
28026
28124
|
this.rearmStmt.run();
|
|
28027
28125
|
if (previous !== null && previous !== void 0 && previous !== fingerprint) {
|
|
28028
|
-
this.disownCapturesStmt.run();
|
|
28126
|
+
this.disownCapturesStmt.run({ attachedAt: backlogBefore });
|
|
28127
|
+
}
|
|
28128
|
+
if (backfillCapturesBefore !== void 0) {
|
|
28129
|
+
this.markCaptureBacklogOwedStmt.run({ before: backfillCapturesBefore });
|
|
28029
28130
|
}
|
|
28030
28131
|
this.setFingerprintStmt.run({ fingerprint, backlogBefore });
|
|
28031
28132
|
},
|
|
@@ -28305,7 +28406,8 @@ function managedSettingsPaths(platform2 = process.platform) {
|
|
|
28305
28406
|
}
|
|
28306
28407
|
return [posix.join("/etc", "aka", MANAGED_SETTINGS_FILENAME)];
|
|
28307
28408
|
}
|
|
28308
|
-
|
|
28409
|
+
var testOnlyManagedPaths = null;
|
|
28410
|
+
function readManagedSettings(paths = testOnlyManagedPaths ?? managedSettingsPaths()) {
|
|
28309
28411
|
for (const path of paths) {
|
|
28310
28412
|
let text;
|
|
28311
28413
|
try {
|
|
@@ -30785,7 +30887,7 @@ function toUtcDateString(ms) {
|
|
|
30785
30887
|
return new Date(ms).toISOString().slice(0, 10);
|
|
30786
30888
|
}
|
|
30787
30889
|
function isTimeseriesSeverity(s) {
|
|
30788
|
-
return s === "critical" || s === "high" || s === "medium";
|
|
30890
|
+
return s === "critical" || s === "high" || s === "medium" || s === "low";
|
|
30789
30891
|
}
|
|
30790
30892
|
var SqliteSecurityRepository = class {
|
|
30791
30893
|
constructor(db, now = () => Date.now()) {
|
|
@@ -30914,12 +31016,16 @@ var SqliteSecurityRepository = class {
|
|
|
30914
31016
|
const now = this.now();
|
|
30915
31017
|
const windowStart = startOfUtcDay2(now) - (lenDays - 1) * DAY_MS4;
|
|
30916
31018
|
const rows = this.findingsInRange(windowStart, now);
|
|
30917
|
-
const points = Array.from(
|
|
30918
|
-
|
|
30919
|
-
|
|
30920
|
-
|
|
30921
|
-
|
|
30922
|
-
|
|
31019
|
+
const points = Array.from(
|
|
31020
|
+
{ length: numBuckets },
|
|
31021
|
+
(_, i) => ({
|
|
31022
|
+
timestamp: toUtcDateString(windowStart + i * bucketMs),
|
|
31023
|
+
critical: 0,
|
|
31024
|
+
high: 0,
|
|
31025
|
+
medium: 0,
|
|
31026
|
+
low: 0
|
|
31027
|
+
})
|
|
31028
|
+
);
|
|
30923
31029
|
for (const r of rows) {
|
|
30924
31030
|
const idx = Math.floor((r.occurredAt - windowStart) / bucketMs);
|
|
30925
31031
|
const bucket = points[idx];
|
|
@@ -31137,6 +31243,7 @@ var SqliteSecurityRepository = class {
|
|
|
31137
31243
|
`SELECT f.finding_key AS finding_key,
|
|
31138
31244
|
d.rule_id AS rule_id,
|
|
31139
31245
|
d.severity AS severity,
|
|
31246
|
+
e.repo AS repo,
|
|
31140
31247
|
e.file_path AS path,
|
|
31141
31248
|
COALESCE(f.first_detected_at, e.started_at) AS first_detected_at,
|
|
31142
31249
|
latest.resolved_at AS latest_resolved_at
|
|
@@ -31156,6 +31263,7 @@ var SqliteSecurityRepository = class {
|
|
|
31156
31263
|
const items = rows.map((r) => ({
|
|
31157
31264
|
findingKey: r.finding_key,
|
|
31158
31265
|
ruleId: r.rule_id,
|
|
31266
|
+
repo: r.repo ?? "",
|
|
31159
31267
|
severity: r.severity,
|
|
31160
31268
|
path: r.path ?? "",
|
|
31161
31269
|
resolvedAt: new Date(r.latest_resolved_at).toISOString(),
|
|
@@ -31165,13 +31273,66 @@ var SqliteSecurityRepository = class {
|
|
|
31165
31273
|
}));
|
|
31166
31274
|
return Promise.resolve({ items });
|
|
31167
31275
|
}
|
|
31276
|
+
/**
|
|
31277
|
+
* Per-rule tallies of the findings that are still OPEN, whole-store.
|
|
31278
|
+
*
|
|
31279
|
+
* Scoped by status rather than by time, because the card this feeds is a to-do
|
|
31280
|
+
* list: a secret committed three weeks ago and never rotated is still the most
|
|
31281
|
+
* important thing to fix, and any window hides it. It carried a "newest N
|
|
31282
|
+
* findings" cap and then a range; the first meant a different span on every
|
|
31283
|
+
* machine, and the second reported "no recommendations" over live exposure.
|
|
31284
|
+
*
|
|
31285
|
+
* `open` mirrors `deriveFindingStatus` — at-rest, minus resolved and dismissed —
|
|
31286
|
+
* so a row's count is exactly what `?status=open&type=<rule>` returns. Note that
|
|
31287
|
+
* is NOT `severitySummary`'s `openAtRest`, which keeps dismissed findings (a
|
|
31288
|
+
* dismissal is a judgement, not a remediation) and drops untracked legacy rows.
|
|
31289
|
+
* The two answer different questions and only this one has to match a link.
|
|
31290
|
+
*
|
|
31291
|
+
* Aggregated in SQL: the result is O(distinct rule × category × severity), so a
|
|
31292
|
+
* whole-store scope costs a grouped scan rather than a row per finding.
|
|
31293
|
+
*/
|
|
31294
|
+
recommendationInputs() {
|
|
31295
|
+
const rows = allRows(
|
|
31296
|
+
this.db.prepare(
|
|
31297
|
+
`SELECT d.rule_id AS rule_id,
|
|
31298
|
+
d.category AS category,
|
|
31299
|
+
d.severity AS severity,
|
|
31300
|
+
COUNT(*) AS count
|
|
31301
|
+
FROM inspection_findings f
|
|
31302
|
+
JOIN audit_events e ON e.id = f.audit_event_id
|
|
31303
|
+
JOIN inspection_definitions d ON d.id = f.inspection_definition_id
|
|
31304
|
+
LEFT JOIN ${LATEST_RESOLUTION_BY_KEY_SQL} latest
|
|
31305
|
+
ON latest.finding_key = f.finding_key
|
|
31306
|
+
WHERE e.event_type IN (${CAPTURE_EVENT_TYPES_SQL})
|
|
31307
|
+
AND e.event_type = 'code_change'
|
|
31308
|
+
AND (
|
|
31309
|
+
f.finding_key IS NULL
|
|
31310
|
+
OR latest.status IS NULL
|
|
31311
|
+
OR latest.status NOT IN ('resolved', 'dismissed')
|
|
31312
|
+
)
|
|
31313
|
+
GROUP BY d.rule_id, d.category, d.severity`
|
|
31314
|
+
)
|
|
31315
|
+
);
|
|
31316
|
+
return Promise.resolve(
|
|
31317
|
+
rows.map((r) => ({
|
|
31318
|
+
ruleId: r.rule_id,
|
|
31319
|
+
category: r.category,
|
|
31320
|
+
severity: r.severity,
|
|
31321
|
+
count: r.count
|
|
31322
|
+
}))
|
|
31323
|
+
);
|
|
31324
|
+
}
|
|
31168
31325
|
// Findings whose parent event occurred in [fromMs, toMs), with the parent's
|
|
31169
31326
|
// epoch-millis timestamp. started_at is an INTEGER column, so the bounds stay
|
|
31170
31327
|
// numeric and the JS aggregations bucket/split on ms directly.
|
|
31171
31328
|
findingsInRange(fromMs, toMs) {
|
|
31172
31329
|
const rows = allRows(
|
|
31173
31330
|
this.db.prepare(
|
|
31174
|
-
`
|
|
31331
|
+
// `rule_id`/`category` cost nothing extra: inspection_definitions is already
|
|
31332
|
+
// joined for `severity`, so they are two more columns off a row this read
|
|
31333
|
+
// already fetches. They feed the recommended-actions rollup.
|
|
31334
|
+
`SELECT e.started_at AS occurred_at, d.severity AS severity, f.action_taken AS action_taken,
|
|
31335
|
+
d.rule_id AS rule_id, d.category AS category
|
|
31175
31336
|
FROM inspection_findings f
|
|
31176
31337
|
JOIN audit_events e ON e.id = f.audit_event_id
|
|
31177
31338
|
JOIN inspection_definitions d ON d.id = f.inspection_definition_id
|
|
@@ -31184,7 +31345,9 @@ var SqliteSecurityRepository = class {
|
|
|
31184
31345
|
return rows.map((r) => ({
|
|
31185
31346
|
occurredAt: r.occurred_at,
|
|
31186
31347
|
severity: r.severity,
|
|
31187
|
-
actionTaken: r.action_taken
|
|
31348
|
+
actionTaken: r.action_taken,
|
|
31349
|
+
ruleId: r.rule_id,
|
|
31350
|
+
category: r.category
|
|
31188
31351
|
}));
|
|
31189
31352
|
}
|
|
31190
31353
|
};
|
|
@@ -32354,14 +32517,51 @@ function openLocalDatabase(dir) {
|
|
|
32354
32517
|
};
|
|
32355
32518
|
}
|
|
32356
32519
|
|
|
32357
|
-
// ../../packages/persistence/src/
|
|
32520
|
+
// ../../packages/persistence/src/egress-wire.ts
|
|
32358
32521
|
import { createHash as createHash3 } from "crypto";
|
|
32522
|
+
function hashProjectKey(projectKey) {
|
|
32523
|
+
return createHash3("sha256").update(projectKey, "utf8").digest("hex");
|
|
32524
|
+
}
|
|
32525
|
+
function toIngestHit(hit) {
|
|
32526
|
+
return {
|
|
32527
|
+
host: hit.host,
|
|
32528
|
+
kind: hit.kind,
|
|
32529
|
+
name: hit.name,
|
|
32530
|
+
category: hit.category,
|
|
32531
|
+
trust: hit.trust,
|
|
32532
|
+
network: hit.network,
|
|
32533
|
+
method: hit.method,
|
|
32534
|
+
transport: hit.transport,
|
|
32535
|
+
url: hit.url,
|
|
32536
|
+
template: hit.template,
|
|
32537
|
+
dataClass: hit.dataClass,
|
|
32538
|
+
site: {
|
|
32539
|
+
file: hit.site.file,
|
|
32540
|
+
line: hit.site.line,
|
|
32541
|
+
dynamic: hit.site.dynamic,
|
|
32542
|
+
vendored: hit.site.vendored
|
|
32543
|
+
}
|
|
32544
|
+
};
|
|
32545
|
+
}
|
|
32546
|
+
function toEgressIngestRequest(input2) {
|
|
32547
|
+
const { hits, droppedFiles } = capHits(input2.hits, input2.reconcile.mode);
|
|
32548
|
+
const reconcile = withoutDroppedFiles(input2.reconcile, droppedFiles);
|
|
32549
|
+
return {
|
|
32550
|
+
projectKey: hashProjectKey(input2.projectKey),
|
|
32551
|
+
project: input2.project,
|
|
32552
|
+
reconcile,
|
|
32553
|
+
hits: hits.map(toIngestHit)
|
|
32554
|
+
};
|
|
32555
|
+
}
|
|
32556
|
+
|
|
32557
|
+
// ../../packages/persistence/src/finding-key.ts
|
|
32558
|
+
import { createHash as createHash4 } from "crypto";
|
|
32359
32559
|
function normalizeFilePath(filePath) {
|
|
32360
32560
|
return filePath.replaceAll("\\", "/");
|
|
32361
32561
|
}
|
|
32362
32562
|
function computeFindingKey(input2) {
|
|
32363
32563
|
const normalizedPath = normalizeFilePath(input2.filePath);
|
|
32364
|
-
return
|
|
32564
|
+
return createHash4("sha256").update(`${input2.ruleId}\0${normalizedPath}\0${input2.valueFingerprint}`).digest("hex");
|
|
32365
32565
|
}
|
|
32366
32566
|
|
|
32367
32567
|
// ../../packages/persistence/src/fingerprint.ts
|
|
@@ -32487,14 +32687,18 @@ function fingerprintValue(key, raw) {
|
|
|
32487
32687
|
return createHmac("sha256", key.material).update(raw, "utf8").digest("hex");
|
|
32488
32688
|
}
|
|
32489
32689
|
|
|
32490
|
-
// ../../packages/persistence/src/history-
|
|
32690
|
+
// ../../packages/persistence/src/history-backfill.ts
|
|
32491
32691
|
import { existsSync as existsSync4 } from "fs";
|
|
32492
32692
|
import { join as join9 } from "path";
|
|
32693
|
+
|
|
32694
|
+
// ../../packages/persistence/src/history-preview.ts
|
|
32695
|
+
import { existsSync as existsSync5 } from "fs";
|
|
32696
|
+
import { join as join10 } from "path";
|
|
32493
32697
|
import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
|
|
32494
32698
|
|
|
32495
32699
|
// ../../packages/persistence/src/store-symlinks.ts
|
|
32496
|
-
import { existsSync as
|
|
32497
|
-
import { dirname as dirname3, join as
|
|
32700
|
+
import { existsSync as existsSync6, lstatSync as lstatSync3, readlinkSync, realpathSync, statSync as statSync4 } from "fs";
|
|
32701
|
+
import { dirname as dirname3, join as join11, resolve } from "path";
|
|
32498
32702
|
var STORE_DB = "the store database (including the prompt corpus)";
|
|
32499
32703
|
var STORE_SETTINGS = "your settings file";
|
|
32500
32704
|
function storeContents(home) {
|
|
@@ -32503,7 +32707,7 @@ function storeContents(home) {
|
|
|
32503
32707
|
[settingsDir(home), STORE_SETTINGS],
|
|
32504
32708
|
[dataDir(home), STORE_DB],
|
|
32505
32709
|
[keysDir(home), "the vault key"],
|
|
32506
|
-
[
|
|
32710
|
+
[join11(settingsDir(home), "settings.json"), STORE_SETTINGS],
|
|
32507
32711
|
[dbPath(home), STORE_DB]
|
|
32508
32712
|
]);
|
|
32509
32713
|
}
|
|
@@ -32518,7 +32722,7 @@ function symlinkedStorePaths(home, platform2 = process.platform) {
|
|
|
32518
32722
|
holds,
|
|
32519
32723
|
// existsSync follows the link, so a target that is gone reads as
|
|
32520
32724
|
// absent here while lstat above still sees the link itself.
|
|
32521
|
-
missing: !
|
|
32725
|
+
missing: !existsSync6(path),
|
|
32522
32726
|
mode: targetMode(path, platform2)
|
|
32523
32727
|
}
|
|
32524
32728
|
];
|
|
@@ -32556,19 +32760,19 @@ import {
|
|
|
32556
32760
|
import { execFileSync } from "child_process";
|
|
32557
32761
|
import { randomBytes as randomBytes2 } from "crypto";
|
|
32558
32762
|
import { chmodSync as chmodSync3, readFileSync as readFileSync7, renameSync as renameSync4, rmSync as rmSync6, statSync as statSync5, writeFileSync as writeFileSync3 } from "fs";
|
|
32559
|
-
import { join as
|
|
32763
|
+
import { join as join12 } from "path";
|
|
32560
32764
|
|
|
32561
32765
|
// ../../packages/persistence/src/vault/vault.ts
|
|
32562
32766
|
import { randomBytes as randomBytes3, randomUUID as randomUUID12 } from "crypto";
|
|
32563
32767
|
|
|
32564
32768
|
// ../../packages/persistence/src/warn-era-cap.ts
|
|
32565
|
-
import { existsSync as
|
|
32566
|
-
import { join as
|
|
32769
|
+
import { existsSync as existsSync7, writeFileSync as writeFileSync4 } from "fs";
|
|
32770
|
+
import { join as join13 } from "path";
|
|
32567
32771
|
var MARKER = "warn-era-capped";
|
|
32568
32772
|
function capWarnEraEnforcementOnce(db, policyMode, dataDir2) {
|
|
32569
32773
|
if (policyMode !== "warn") return { capped: 0, skipped: "not-warn" };
|
|
32570
|
-
const marker =
|
|
32571
|
-
if (
|
|
32774
|
+
const marker = join13(dataDir2, MARKER);
|
|
32775
|
+
if (existsSync7(marker)) return { capped: 0, skipped: "already-run" };
|
|
32572
32776
|
const capped = db.policies.capCategoryActions();
|
|
32573
32777
|
writeFileSync4(marker, `${new Date(Date.now()).toISOString()}
|
|
32574
32778
|
`, { mode: DATA_FILE_MODE });
|
|
@@ -32627,8 +32831,8 @@ function resolveProvider() {
|
|
|
32627
32831
|
function loadConfig(base = defaultDataDir(), resolveProviderFn = resolveProvider) {
|
|
32628
32832
|
try {
|
|
32629
32833
|
ensureLayoutDirSync(base);
|
|
32630
|
-
const settingsFile =
|
|
32631
|
-
if (
|
|
32834
|
+
const settingsFile = join14(settingsDir(base), "settings.json");
|
|
32835
|
+
if (existsSync8(settingsFile)) tightenFile(settingsFile);
|
|
32632
32836
|
} catch {
|
|
32633
32837
|
}
|
|
32634
32838
|
migrateLegacyLayout(base);
|
|
@@ -32653,7 +32857,7 @@ function resolveProviderSafe(resolveProviderFn) {
|
|
|
32653
32857
|
// ../../packages/plugin-sdk/src/config-inventory.ts
|
|
32654
32858
|
import { readdirSync as readdirSync2, readFileSync as readFileSync9, realpathSync as realpathSync2, statSync as statSync7 } from "fs";
|
|
32655
32859
|
import { homedir as homedir2 } from "os";
|
|
32656
|
-
import { basename as basename3, join as
|
|
32860
|
+
import { basename as basename3, join as join16 } from "path";
|
|
32657
32861
|
|
|
32658
32862
|
// ../../packages/detections/src/egress/registry.ts
|
|
32659
32863
|
var EXTRACTOR_VERSION = "1";
|
|
@@ -35742,8 +35946,8 @@ function bundledDetections() {
|
|
|
35742
35946
|
}
|
|
35743
35947
|
|
|
35744
35948
|
// ../../packages/plugin-sdk/src/repo.ts
|
|
35745
|
-
import { existsSync as
|
|
35746
|
-
import { basename as basename2, dirname as dirname4, isAbsolute, join as
|
|
35949
|
+
import { existsSync as existsSync9, readFileSync as readFileSync8, statSync as statSync6 } from "fs";
|
|
35950
|
+
import { basename as basename2, dirname as dirname4, isAbsolute, join as join15, sep as sep2 } from "path";
|
|
35747
35951
|
function resolveRepo(cwd) {
|
|
35748
35952
|
try {
|
|
35749
35953
|
const root = findGitRoot(cwd);
|
|
@@ -35758,32 +35962,32 @@ function resolveRepo(cwd) {
|
|
|
35758
35962
|
function findGitRoot(start) {
|
|
35759
35963
|
let dir = start;
|
|
35760
35964
|
for (; ; ) {
|
|
35761
|
-
if (
|
|
35965
|
+
if (existsSync9(join15(dir, ".git"))) return dir;
|
|
35762
35966
|
const parent = dirname4(dir);
|
|
35763
35967
|
if (parent === dir) return void 0;
|
|
35764
35968
|
dir = parent;
|
|
35765
35969
|
}
|
|
35766
35970
|
}
|
|
35767
35971
|
function resolveGitContext(root) {
|
|
35768
|
-
const dotGit =
|
|
35972
|
+
const dotGit = join15(root, ".git");
|
|
35769
35973
|
try {
|
|
35770
35974
|
if (statSync6(dotGit).isDirectory()) {
|
|
35771
|
-
return { configPath:
|
|
35975
|
+
return { configPath: join15(dotGit, "config"), headRoot: root };
|
|
35772
35976
|
}
|
|
35773
35977
|
} catch {
|
|
35774
35978
|
return void 0;
|
|
35775
35979
|
}
|
|
35776
35980
|
const target = /^gitdir:\s*(.+?)\s*$/m.exec(safeRead(dotGit) ?? "")?.[1];
|
|
35777
35981
|
if (!target) return void 0;
|
|
35778
|
-
const gitdir = isAbsolute(target) ? target :
|
|
35779
|
-
if (
|
|
35780
|
-
return { configPath:
|
|
35982
|
+
const gitdir = isAbsolute(target) ? target : join15(root, target);
|
|
35983
|
+
if (existsSync9(join15(gitdir, "config"))) {
|
|
35984
|
+
return { configPath: join15(gitdir, "config"), headRoot: root };
|
|
35781
35985
|
}
|
|
35782
|
-
const commonRaw = safeRead(
|
|
35986
|
+
const commonRaw = safeRead(join15(gitdir, "commondir"))?.trim();
|
|
35783
35987
|
if (!commonRaw) return void 0;
|
|
35784
|
-
const commonGitDir = isAbsolute(commonRaw) ? commonRaw :
|
|
35988
|
+
const commonGitDir = isAbsolute(commonRaw) ? commonRaw : join15(gitdir, commonRaw);
|
|
35785
35989
|
const headRoot = basename2(commonGitDir) === ".git" ? dirname4(commonGitDir) : root;
|
|
35786
|
-
return { configPath:
|
|
35990
|
+
return { configPath: join15(commonGitDir, "config"), headRoot };
|
|
35787
35991
|
}
|
|
35788
35992
|
function safeRead(path) {
|
|
35789
35993
|
try {
|
|
@@ -35825,9 +36029,9 @@ function slugFromUrl(url2) {
|
|
|
35825
36029
|
}
|
|
35826
36030
|
|
|
35827
36031
|
// ../../packages/plugin-sdk/src/events.ts
|
|
35828
|
-
import { createHash as
|
|
36032
|
+
import { createHash as createHash5, randomUUID as randomUUID13 } from "crypto";
|
|
35829
36033
|
function contentHashOf(text) {
|
|
35830
|
-
return
|
|
36034
|
+
return createHash5("sha256").update(text).digest("hex");
|
|
35831
36035
|
}
|
|
35832
36036
|
function buildIngestEvent(input2) {
|
|
35833
36037
|
const contentHash = input2.contentHash ?? contentHashOf(input2.content);
|
|
@@ -35853,7 +36057,7 @@ function buildIngestEvent(input2) {
|
|
|
35853
36057
|
}
|
|
35854
36058
|
|
|
35855
36059
|
// ../../packages/plugin-sdk/src/isolated-scan.ts
|
|
35856
|
-
import { existsSync as
|
|
36060
|
+
import { existsSync as existsSync10 } from "fs";
|
|
35857
36061
|
import { fileURLToPath } from "url";
|
|
35858
36062
|
import { Worker } from "worker_threads";
|
|
35859
36063
|
var ISOLATED_SCAN_BUDGET_MS = 2e3;
|
|
@@ -35867,7 +36071,7 @@ function resolveWorkerUrl() {
|
|
|
35867
36071
|
for (const name of ["scan-worker.js", "scan-worker.ts"]) {
|
|
35868
36072
|
const candidate = new URL(name, import.meta.url);
|
|
35869
36073
|
try {
|
|
35870
|
-
if (
|
|
36074
|
+
if (existsSync10(fileURLToPath(candidate))) {
|
|
35871
36075
|
resolvedWorkerUrl = candidate;
|
|
35872
36076
|
return candidate;
|
|
35873
36077
|
}
|
|
@@ -36330,13 +36534,9 @@ function createGuardedScanner(partition, gateway, opts) {
|
|
|
36330
36534
|
};
|
|
36331
36535
|
}
|
|
36332
36536
|
|
|
36333
|
-
// ../../packages/plugin-sdk/src/
|
|
36334
|
-
|
|
36335
|
-
import {
|
|
36336
|
-
import { join as join16 } from "path";
|
|
36337
|
-
|
|
36338
|
-
// ../../packages/plugin-sdk/src/inventory-resolver.ts
|
|
36339
|
-
import { arch, hostname as hostname4, platform, release } from "os";
|
|
36537
|
+
// ../../packages/plugin-sdk/src/host-floor.ts
|
|
36538
|
+
import { readFileSync as readFileSync11 } from "fs";
|
|
36539
|
+
import { join as join18 } from "path";
|
|
36340
36540
|
|
|
36341
36541
|
// ../../packages/plugin-sdk/src/model-governance.ts
|
|
36342
36542
|
import {
|
|
@@ -36344,16 +36544,42 @@ import {
|
|
|
36344
36544
|
fstatSync,
|
|
36345
36545
|
mkdirSync as mkdirSync2,
|
|
36346
36546
|
openSync as openSync2,
|
|
36347
|
-
readFileSync as
|
|
36547
|
+
readFileSync as readFileSync10,
|
|
36348
36548
|
readSync,
|
|
36349
36549
|
writeFileSync as writeFileSync5
|
|
36350
36550
|
} from "fs";
|
|
36351
36551
|
import { join as join17 } from "path";
|
|
36352
36552
|
var TAIL_BYTES = 256 * 1024;
|
|
36353
36553
|
|
|
36554
|
+
// ../../packages/plugin-sdk/src/host-floor.ts
|
|
36555
|
+
var HOST_FEATURE = {
|
|
36556
|
+
ModelSwitch: "model-switch",
|
|
36557
|
+
VaultPointerDisplay: "vault-pointer-display"
|
|
36558
|
+
};
|
|
36559
|
+
var HOST_FLOORS = {
|
|
36560
|
+
[HOST_FEATURE.ModelSwitch]: {
|
|
36561
|
+
label: "model-switch protection",
|
|
36562
|
+
hookEvents: ["PreModelSwitch", "PostModelSwitch"],
|
|
36563
|
+
since: "2.1.251"
|
|
36564
|
+
},
|
|
36565
|
+
[HOST_FEATURE.VaultPointerDisplay]: {
|
|
36566
|
+
label: "vault pointer display",
|
|
36567
|
+
hookEvents: ["MessageDisplay"],
|
|
36568
|
+
since: "2.1.152"
|
|
36569
|
+
}
|
|
36570
|
+
};
|
|
36571
|
+
|
|
36572
|
+
// ../../packages/plugin-sdk/src/ignore-layers.ts
|
|
36573
|
+
var import_ignore = __toESM(require_ignore(), 1);
|
|
36574
|
+
import { readFileSync as readFileSync12 } from "fs";
|
|
36575
|
+
import { join as join19 } from "path";
|
|
36576
|
+
|
|
36577
|
+
// ../../packages/plugin-sdk/src/inventory-resolver.ts
|
|
36578
|
+
import { arch, hostname as hostname4, platform, release } from "os";
|
|
36579
|
+
|
|
36354
36580
|
// ../../packages/plugin-sdk/src/nudge.ts
|
|
36355
|
-
import { mkdirSync as mkdirSync3, readFileSync as
|
|
36356
|
-
import { join as
|
|
36581
|
+
import { mkdirSync as mkdirSync3, readFileSync as readFileSync13, writeFileSync as writeFileSync6 } from "fs";
|
|
36582
|
+
import { join as join20 } from "path";
|
|
36357
36583
|
|
|
36358
36584
|
// ../../packages/plugin-sdk/src/paths.ts
|
|
36359
36585
|
import { readdirSync as readdirSync3, realpathSync as realpathSync3 } from "fs";
|
|
@@ -36395,8 +36621,8 @@ function createPolicyResolver(bundle) {
|
|
|
36395
36621
|
}
|
|
36396
36622
|
|
|
36397
36623
|
// ../../packages/plugin-sdk/src/project-files.ts
|
|
36398
|
-
import { existsSync as
|
|
36399
|
-
import { basename as basename5, join as
|
|
36624
|
+
import { existsSync as existsSync11, readdirSync as readdirSync4 } from "fs";
|
|
36625
|
+
import { basename as basename5, join as join21 } from "path";
|
|
36400
36626
|
|
|
36401
36627
|
// ../../packages/plugin-sdk/src/provider-env-antigravity.ts
|
|
36402
36628
|
var optionalBaseUrl2 = external_exports.preprocess((v) => {
|
|
@@ -36427,6 +36653,14 @@ var CodexProviderEnvSchema = external_exports.object(codexProviderEnvShape);
|
|
|
36427
36653
|
// ../../packages/plugin-sdk/src/runtime.ts
|
|
36428
36654
|
import { randomUUID as randomUUID14 } from "crypto";
|
|
36429
36655
|
var ENFORCEMENT_CEILING_ENABLED = false;
|
|
36656
|
+
function applyEnforcementCeiling(action, policyMode, enabled) {
|
|
36657
|
+
if (!enabled || policyMode !== "warn") return action;
|
|
36658
|
+
return action === "block" || action === "redact" ? "warn" : action;
|
|
36659
|
+
}
|
|
36660
|
+
function resolveEnforcedAction(action, opts) {
|
|
36661
|
+
const degraded = !opts.rewritable && action === "redact" ? builtinPolicyToAction(opts.redactFallback) : action;
|
|
36662
|
+
return applyEnforcementCeiling(degraded, opts.policyMode, opts.ceilingEnabled);
|
|
36663
|
+
}
|
|
36430
36664
|
function startTiming() {
|
|
36431
36665
|
try {
|
|
36432
36666
|
return performance.now();
|
|
@@ -36535,12 +36769,12 @@ function createPluginRuntime(gateway, settings, opts) {
|
|
|
36535
36769
|
}
|
|
36536
36770
|
function actionForFinding(finding, excepted, rewritable = true) {
|
|
36537
36771
|
if (excepted?.has(finding)) return "allow";
|
|
36538
|
-
|
|
36539
|
-
|
|
36540
|
-
|
|
36541
|
-
|
|
36542
|
-
|
|
36543
|
-
|
|
36772
|
+
return resolveEnforcedAction(resolveAction(finding.ruleId, finding.category), {
|
|
36773
|
+
policyMode,
|
|
36774
|
+
redactFallback,
|
|
36775
|
+
rewritable,
|
|
36776
|
+
ceilingEnabled: ENFORCEMENT_CEILING_ENABLED
|
|
36777
|
+
});
|
|
36544
36778
|
}
|
|
36545
36779
|
function decide(findings, text, excepted, rewritable = true) {
|
|
36546
36780
|
if (findings.length === 0) return { action: "log", text, findings: [] };
|
|
@@ -36789,7 +37023,7 @@ var THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1e3;
|
|
|
36789
37023
|
|
|
36790
37024
|
// ../../packages/plugin-sdk/src/throttle.ts
|
|
36791
37025
|
import { mkdirSync as mkdirSync4, statSync as statSync8, writeFileSync as writeFileSync7 } from "fs";
|
|
36792
|
-
import { join as
|
|
37026
|
+
import { join as join22 } from "path";
|
|
36793
37027
|
|
|
36794
37028
|
// src/present.ts
|
|
36795
37029
|
var fg = (hex3) => (text) => {
|
|
@@ -36980,45 +37214,8 @@ function baseMetadata(input2) {
|
|
|
36980
37214
|
}
|
|
36981
37215
|
|
|
36982
37216
|
// src/hooks/store-health.ts
|
|
36983
|
-
import { mkdirSync as mkdirSync5, readFileSync as
|
|
36984
|
-
import { dirname as dirname6, join as
|
|
36985
|
-
|
|
36986
|
-
// ../../packages/plugin-runtime/src/attached/egress-wire.ts
|
|
36987
|
-
import { createHash as createHash5 } from "crypto";
|
|
36988
|
-
function hashProjectKey(projectKey) {
|
|
36989
|
-
return createHash5("sha256").update(projectKey, "utf8").digest("hex");
|
|
36990
|
-
}
|
|
36991
|
-
function toIngestHit(hit) {
|
|
36992
|
-
return {
|
|
36993
|
-
host: hit.host,
|
|
36994
|
-
kind: hit.kind,
|
|
36995
|
-
name: hit.name,
|
|
36996
|
-
category: hit.category,
|
|
36997
|
-
trust: hit.trust,
|
|
36998
|
-
network: hit.network,
|
|
36999
|
-
method: hit.method,
|
|
37000
|
-
transport: hit.transport,
|
|
37001
|
-
url: hit.url,
|
|
37002
|
-
template: hit.template,
|
|
37003
|
-
dataClass: hit.dataClass,
|
|
37004
|
-
site: {
|
|
37005
|
-
file: hit.site.file,
|
|
37006
|
-
line: hit.site.line,
|
|
37007
|
-
dynamic: hit.site.dynamic,
|
|
37008
|
-
vendored: hit.site.vendored
|
|
37009
|
-
}
|
|
37010
|
-
};
|
|
37011
|
-
}
|
|
37012
|
-
function toEgressIngestRequest(input2) {
|
|
37013
|
-
const { hits, droppedFiles } = capHits(input2.hits, input2.reconcile.mode);
|
|
37014
|
-
const reconcile = withoutDroppedFiles(input2.reconcile, droppedFiles);
|
|
37015
|
-
return {
|
|
37016
|
-
projectKey: hashProjectKey(input2.projectKey),
|
|
37017
|
-
project: input2.project,
|
|
37018
|
-
reconcile,
|
|
37019
|
-
hits: hits.map(toIngestHit)
|
|
37020
|
-
};
|
|
37021
|
-
}
|
|
37217
|
+
import { mkdirSync as mkdirSync5, readFileSync as readFileSync19, writeFileSync as writeFileSync8 } from "fs";
|
|
37218
|
+
import { dirname as dirname6, join as join29 } from "path";
|
|
37022
37219
|
|
|
37023
37220
|
// ../../packages/remote/src/http.ts
|
|
37024
37221
|
import { request as httpRequest } from "http";
|
|
@@ -37299,6 +37496,7 @@ function createRemoteClient(options) {
|
|
|
37299
37496
|
url: url2(ROUTES.shares),
|
|
37300
37497
|
body: JSON.stringify(validated.data)
|
|
37301
37498
|
});
|
|
37499
|
+
if (response.status === 404) throw new RemoteRouteAbsent(ROUTES.shares);
|
|
37302
37500
|
okBody(response);
|
|
37303
37501
|
},
|
|
37304
37502
|
async pollCommand() {
|
|
@@ -37321,19 +37519,51 @@ function createRemoteClient(options) {
|
|
|
37321
37519
|
};
|
|
37322
37520
|
}
|
|
37323
37521
|
|
|
37324
|
-
// ../../packages/
|
|
37522
|
+
// ../../packages/remote/src/failure-kind.ts
|
|
37325
37523
|
function statusOf(err) {
|
|
37326
37524
|
if (typeof err !== "object" || err === null || !("status" in err)) return null;
|
|
37327
37525
|
const { status } = err;
|
|
37328
37526
|
if (typeof status !== "number" || !Number.isInteger(status)) return null;
|
|
37329
37527
|
return status >= 100 && status <= 599 ? status : null;
|
|
37330
37528
|
}
|
|
37331
|
-
function
|
|
37332
|
-
|
|
37529
|
+
function nameOf(err) {
|
|
37530
|
+
if (typeof err !== "object" || err === null || !("name" in err)) return null;
|
|
37531
|
+
return typeof err.name === "string" ? err.name : null;
|
|
37532
|
+
}
|
|
37533
|
+
function classifyRemoteFailure(err) {
|
|
37534
|
+
switch (nameOf(err)) {
|
|
37535
|
+
case "RemoteRouteAbsent":
|
|
37536
|
+
return "route-absent";
|
|
37537
|
+
case "RemoteRequestInvalid":
|
|
37538
|
+
return "invalid-request";
|
|
37539
|
+
case "RemoteResponseInvalid":
|
|
37540
|
+
return "rejected";
|
|
37541
|
+
default:
|
|
37542
|
+
break;
|
|
37543
|
+
}
|
|
37544
|
+
const status = statusOf(err);
|
|
37545
|
+
if (status === null) return "unreachable";
|
|
37546
|
+
switch (status) {
|
|
37333
37547
|
case 401:
|
|
37334
37548
|
return "unauthorized";
|
|
37335
37549
|
case 403:
|
|
37336
37550
|
return "forbidden";
|
|
37551
|
+
case 429:
|
|
37552
|
+
return "unreachable";
|
|
37553
|
+
case 404:
|
|
37554
|
+
return "unreachable";
|
|
37555
|
+
default:
|
|
37556
|
+
return status >= 400 && status <= 499 ? "rejected" : "unreachable";
|
|
37557
|
+
}
|
|
37558
|
+
}
|
|
37559
|
+
|
|
37560
|
+
// ../../packages/plugin-runtime/src/attached/failure.ts
|
|
37561
|
+
function classifyFailure(err) {
|
|
37562
|
+
switch (classifyRemoteFailure(err)) {
|
|
37563
|
+
case "unauthorized":
|
|
37564
|
+
return "unauthorized";
|
|
37565
|
+
case "forbidden":
|
|
37566
|
+
return "forbidden";
|
|
37337
37567
|
default:
|
|
37338
37568
|
return "unreachable";
|
|
37339
37569
|
}
|
|
@@ -37355,11 +37585,11 @@ function withTimeout(promise2, ms) {
|
|
|
37355
37585
|
}
|
|
37356
37586
|
|
|
37357
37587
|
// ../../packages/plugin-runtime/src/attached/forward-drops.ts
|
|
37358
|
-
import { readFileSync as
|
|
37359
|
-
import { join as
|
|
37588
|
+
import { readFileSync as readFileSync14 } from "fs";
|
|
37589
|
+
import { join as join23 } from "path";
|
|
37360
37590
|
var FORWARD_DROPS_FILENAME = ATTACHED_FORWARD_DROPS_FILENAME;
|
|
37361
37591
|
function forwardDropsPath(dataDir2) {
|
|
37362
|
-
return
|
|
37592
|
+
return join23(dataDir2, FORWARD_DROPS_FILENAME);
|
|
37363
37593
|
}
|
|
37364
37594
|
function recordForwardDrops(dataDir2, count, nowMs) {
|
|
37365
37595
|
if (count <= 0) return;
|
|
@@ -37377,7 +37607,7 @@ function recordForwardDrops(dataDir2, count, nowMs) {
|
|
|
37377
37607
|
}
|
|
37378
37608
|
function readForwardDrops(dataDir2) {
|
|
37379
37609
|
try {
|
|
37380
|
-
const parsed2 = JSON.parse(
|
|
37610
|
+
const parsed2 = JSON.parse(readFileSync14(forwardDropsPath(dataDir2), "utf8"));
|
|
37381
37611
|
if (typeof parsed2 !== "object" || parsed2 === null) return null;
|
|
37382
37612
|
const record2 = parsed2;
|
|
37383
37613
|
if (typeof record2.droppedForwards !== "number" || !Number.isFinite(record2.droppedForwards)) {
|
|
@@ -37395,9 +37625,9 @@ function readForwardDrops(dataDir2) {
|
|
|
37395
37625
|
|
|
37396
37626
|
// ../../packages/plugin-runtime/src/attached/forward-policy.ts
|
|
37397
37627
|
import { randomUUID as randomUUID15 } from "crypto";
|
|
37398
|
-
import { readFileSync as
|
|
37628
|
+
import { readFileSync as readFileSync15 } from "fs";
|
|
37399
37629
|
import { readFile, rename, writeFile } from "fs/promises";
|
|
37400
|
-
import { join as
|
|
37630
|
+
import { join as join24 } from "path";
|
|
37401
37631
|
function isInvalidRequest(err) {
|
|
37402
37632
|
return typeof err === "object" && err !== null && err.name === "RemoteRequestInvalid";
|
|
37403
37633
|
}
|
|
@@ -37435,7 +37665,7 @@ function parseBreakerState(raw, nowMs) {
|
|
|
37435
37665
|
}
|
|
37436
37666
|
function createForwardPolicy(deps) {
|
|
37437
37667
|
const now = deps.now ?? (() => Date.now());
|
|
37438
|
-
const file2 =
|
|
37668
|
+
const file2 = join24(deps.dir, STATE_FILENAME);
|
|
37439
37669
|
let state = null;
|
|
37440
37670
|
let loading = null;
|
|
37441
37671
|
async function readState() {
|
|
@@ -38157,8 +38387,8 @@ function toolAuditEvent(input2) {
|
|
|
38157
38387
|
}
|
|
38158
38388
|
|
|
38159
38389
|
// ../../packages/plugin-runtime/src/attached/history-state.ts
|
|
38160
|
-
import { readFileSync as
|
|
38161
|
-
import { join as
|
|
38390
|
+
import { readFileSync as readFileSync16 } from "fs";
|
|
38391
|
+
import { join as join25 } from "path";
|
|
38162
38392
|
|
|
38163
38393
|
// ../../packages/plugin-runtime/src/attached/history-sync.ts
|
|
38164
38394
|
import { createHash as createHash6 } from "crypto";
|
|
@@ -38175,7 +38405,7 @@ import { fileURLToPath as fileURLToPath2 } from "url";
|
|
|
38175
38405
|
var HISTORY_SYNC_THROTTLE_MS = 5 * 60 * 1e3;
|
|
38176
38406
|
|
|
38177
38407
|
// ../../packages/plugin-runtime/src/attached/plugin-block.ts
|
|
38178
|
-
import { readFileSync as
|
|
38408
|
+
import { readFileSync as readFileSync17 } from "fs";
|
|
38179
38409
|
function createPluginBlock(build, policyStore) {
|
|
38180
38410
|
return async () => {
|
|
38181
38411
|
const cached2 = await policyStore.read();
|
|
@@ -38194,7 +38424,7 @@ function createPluginBlock(build, policyStore) {
|
|
|
38194
38424
|
// ../../packages/plugin-runtime/src/attached/policy-store.ts
|
|
38195
38425
|
import { randomUUID as randomUUID16 } from "crypto";
|
|
38196
38426
|
import { readFile as readFile2, rm, writeFile as writeFile2 } from "fs/promises";
|
|
38197
|
-
import { join as
|
|
38427
|
+
import { join as join26 } from "path";
|
|
38198
38428
|
|
|
38199
38429
|
// ../../packages/plugin-runtime/src/attached/atomic-publish.ts
|
|
38200
38430
|
import { rename as rename2 } from "fs/promises";
|
|
@@ -38218,7 +38448,7 @@ async function publishByRename(tmp, file2, move = rename2) {
|
|
|
38218
38448
|
|
|
38219
38449
|
// ../../packages/plugin-runtime/src/attached/policy-store.ts
|
|
38220
38450
|
function createPolicyStore(dir = dataDir()) {
|
|
38221
|
-
const file2 =
|
|
38451
|
+
const file2 = join26(dir, "policy-cache.json");
|
|
38222
38452
|
async function read() {
|
|
38223
38453
|
try {
|
|
38224
38454
|
const raw = await readFile2(file2, "utf8");
|
|
@@ -38449,11 +38679,11 @@ function readStorePosture(dbPath2) {
|
|
|
38449
38679
|
// ../../packages/plugin-runtime/src/attached/posture-store.ts
|
|
38450
38680
|
import { randomUUID as randomUUID17 } from "crypto";
|
|
38451
38681
|
import { readFile as readFile3, rm as rm2, writeFile as writeFile3 } from "fs/promises";
|
|
38452
|
-
import { join as
|
|
38682
|
+
import { join as join27 } from "path";
|
|
38453
38683
|
var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
|
|
38454
38684
|
function createPostureStore(dir = settingsDir(), legacyDir) {
|
|
38455
|
-
const file2 =
|
|
38456
|
-
const legacyFile = legacyDir === void 0 ? null :
|
|
38685
|
+
const file2 = join27(dir, "posture-state.json");
|
|
38686
|
+
const legacyFile = legacyDir === void 0 ? null : join27(legacyDir, "posture-state.json");
|
|
38457
38687
|
async function persist(state) {
|
|
38458
38688
|
await ensureDataDir(dir);
|
|
38459
38689
|
const tmp = `${file2}.${randomUUID17()}.tmp`;
|
|
@@ -38521,8 +38751,8 @@ function createPostureStore(dir = settingsDir(), legacyDir) {
|
|
|
38521
38751
|
}
|
|
38522
38752
|
|
|
38523
38753
|
// ../../packages/plugin-runtime/src/attached/sync-state.ts
|
|
38524
|
-
import { readFileSync as
|
|
38525
|
-
import { join as
|
|
38754
|
+
import { readFileSync as readFileSync18 } from "fs";
|
|
38755
|
+
import { join as join28 } from "path";
|
|
38526
38756
|
|
|
38527
38757
|
// ../../packages/plugin-runtime/src/attached/status.ts
|
|
38528
38758
|
var REFUSAL_LINES = {
|
|
@@ -39018,7 +39248,7 @@ function markerDirs(dataDir2) {
|
|
|
39018
39248
|
function alreadyClaimed(dirs, marker, sessionId) {
|
|
39019
39249
|
return dirs.some((dir) => {
|
|
39020
39250
|
try {
|
|
39021
|
-
return
|
|
39251
|
+
return readFileSync19(join29(dir, marker), "utf8") === sessionId;
|
|
39022
39252
|
} catch {
|
|
39023
39253
|
return false;
|
|
39024
39254
|
}
|
|
@@ -39028,7 +39258,7 @@ function recordClaim(dirs, marker, sessionId) {
|
|
|
39028
39258
|
for (const dir of dirs) {
|
|
39029
39259
|
try {
|
|
39030
39260
|
mkdirSync5(dir, { recursive: true, mode: DATA_DIR_MODE });
|
|
39031
|
-
writeFileSync8(
|
|
39261
|
+
writeFileSync8(join29(dir, marker), sessionId, { mode: DATA_FILE_MODE });
|
|
39032
39262
|
return;
|
|
39033
39263
|
} catch {
|
|
39034
39264
|
}
|