@cassiomc1/forgeloop 2.1.0 → 2.3.0
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/CONTRIBUTING.md +22 -2
- package/DOCS_INDEX.md +4 -13
- package/ENG/sec-code-eng.md +1 -1
- package/ENG/test-code-eng.md +32 -1
- package/LOOP_SYSTEM_DESIGN.md +2 -3
- package/QUALITY_SCORECARD.md +0 -1
- package/README.md +19 -48
- package/THIRD_PARTY_NOTICES.md +0 -15
- package/completions/_forgeloop +7 -1
- package/completions/forgeloop.bash +13 -1
- package/completions/forgeloop.fish +51 -1
- package/docs/AGENT_PROTOCOL_SUMMARY.md +7 -1
- package/docs/ARTIFACT_REFERENCE.md +1 -0
- package/docs/CLI_REFERENCE.md +111 -3
- package/docs/CODE_ATTESTATION.md +16 -7
- package/docs/DOCUMENTATION_GUIDE.md +10 -28
- package/docs/PACKAGE_CONTENTS.md +0 -3
- package/docs/RELEASE_CHECKLIST.md +81 -15
- package/docs/REVISION_PROVIDERS.md +3 -6
- package/docs/TROUBLESHOOTING.md +11 -0
- package/docs/documentation-manifest.json +0 -13
- package/package.json +2 -6
- package/schemas/config.schema.json +1 -0
- package/scripts/CI_VALIDATORS.md +2 -2
- package/src/cli.js +31 -0
- package/src/commands/assess.js +36 -0
- package/src/commands/attestation-create.js +21 -1
- package/src/commands/complete.js +3 -0
- package/src/commands/evidence-export.js +17 -0
- package/src/commands/evidence-publish.js +22 -0
- package/src/commands/evidence-verify.js +36 -0
- package/src/commands/sync-pull.js +111 -0
- package/src/commands/sync-push.js +52 -0
- package/src/core/assessment/facts.js +146 -0
- package/src/core/assessment/plan.js +133 -0
- package/src/core/audit.js +7 -0
- package/src/core/cli-command-definitions.js +88 -0
- package/src/core/command-executors.js +42 -5
- package/src/core/config.js +44 -37
- package/src/core/error-codes.js +70 -0
- package/src/core/evidence/auto-export.js +61 -0
- package/src/core/evidence/bundle-format.js +74 -0
- package/src/core/evidence/export.js +184 -0
- package/src/core/evidence/markdown.js +40 -0
- package/src/core/evidence/publish.js +187 -0
- package/src/core/evidence/verify.js +179 -0
- package/src/core/integration-invocation-policy.js +5 -2
- package/src/core/sync/merge.js +135 -0
- package/src/core/sync/remote.js +124 -0
- package/src/core/sync/snapshot.js +129 -0
- package/docs/assets/diagrams/forgeloop-code-attestation-flow.html +0 -13852
- package/docs/assets/diagrams/forgeloop-code-attestation-flow.receipt.json +0 -37
- package/docs/assets/diagrams/forgeloop-code-attestation-flow.svg +0 -5055
- package/docs/assets/diagrams/forgeloop-engineering-flow.html +0 -13837
- package/docs/assets/diagrams/forgeloop-engineering-flow.receipt.json +0 -37
- package/docs/assets/diagrams/forgeloop-engineering-flow.svg +0 -5011
- package/docs/assets/diagrams/forgeloop-verification-trust-flow.html +0 -13795
- package/docs/assets/diagrams/forgeloop-verification-trust-flow.receipt.json +0 -37
- package/docs/assets/diagrams/forgeloop-verification-trust-flow.svg +0 -4997
- package/docs/diagrams/README.md +0 -103
- package/docs/diagrams/forgeloop-code-attestation-flow.workflow.json +0 -451
- package/docs/diagrams/forgeloop-engineering-flow.workflow.json +0 -459
- package/docs/diagrams/forgeloop-verification-trust-flow.workflow.json +0 -398
- package/docs/diagrams/manifest.json +0 -84
- package/docs/diagrams/reviews/forgeloop-code-attestation-flow.review.json +0 -20
- package/docs/diagrams/reviews/forgeloop-engineering-flow.review.json +0 -20
- package/docs/diagrams/reviews/forgeloop-verification-trust-flow.review.json +0 -20
|
@@ -0,0 +1,184 @@
|
|
|
1
|
+
import { mkdir, readFile } from "node:fs/promises";
|
|
2
|
+
import path from "node:path";
|
|
3
|
+
import { canonicalFingerprint, readJsonArtifact } from "../artifacts.js";
|
|
4
|
+
import { readAttestationStatement } from "../attestation.js";
|
|
5
|
+
import { resolveAttestationBundlePath } from "../attachment-paths.js";
|
|
6
|
+
import { readCodeManifest } from "../code-manifest.js";
|
|
7
|
+
import { validateEventLedger } from "../events.js";
|
|
8
|
+
import { E_EVIDENCE_EXPORT_UNAVAILABLE } from "../error-codes.js";
|
|
9
|
+
import { assertSafePath, ensureWithin, writeFileAtomic } from "../filesystem.js";
|
|
10
|
+
import { withSigningStatementFile } from "../signing/statement-file.js";
|
|
11
|
+
import { taskArtifactPath, taskAttestationStatementPath } from "../task-paths.js";
|
|
12
|
+
import { getPackageRoot } from "../templates.js";
|
|
13
|
+
import { withProjectReadSnapshot } from "../../storage/project-read-snapshot.js";
|
|
14
|
+
import { withOperationalAttachmentFile } from "../../storage/operational-attachments.js";
|
|
15
|
+
import {
|
|
16
|
+
DEFAULT_EVIDENCE_DIRECTORY,
|
|
17
|
+
EVIDENCE_BUNDLE_KIND,
|
|
18
|
+
EVIDENCE_BUNDLE_SCHEMA_VERSION,
|
|
19
|
+
EVIDENCE_REDACTIONS,
|
|
20
|
+
assertEvidenceTaskId,
|
|
21
|
+
evidenceBundlePath,
|
|
22
|
+
evidenceError,
|
|
23
|
+
sealEvidenceBundle,
|
|
24
|
+
serializeEvidenceBundle,
|
|
25
|
+
} from "./bundle-format.js";
|
|
26
|
+
|
|
27
|
+
async function packageVersion(packageRoot) {
|
|
28
|
+
return JSON.parse(await readFile(path.join(packageRoot, "package.json"), "utf8")).version;
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
async function readStatementText(target, taskId) {
|
|
32
|
+
return withSigningStatementFile(target, taskAttestationStatementPath(taskId), (filename) => readFile(filename, "utf8"));
|
|
33
|
+
}
|
|
34
|
+
|
|
35
|
+
async function readSignatureText(target, taskId) {
|
|
36
|
+
let bundlePath;
|
|
37
|
+
try { bundlePath = resolveAttestationBundlePath(target, taskId); } catch { return null; }
|
|
38
|
+
try {
|
|
39
|
+
return await withOperationalAttachmentFile(target, bundlePath, taskId, (filename) => readFile(filename, "utf8"));
|
|
40
|
+
} catch {
|
|
41
|
+
return null;
|
|
42
|
+
}
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
// True when a Sigstore bundle is already stored for the task's statement.
|
|
46
|
+
export async function hasAttestationSignature(target, taskId) {
|
|
47
|
+
return withProjectReadSnapshot(target, async () => (await readSignatureText(target, taskId)) !== null);
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
async function readOptional(target, relativePath, schemaName, packageRoot) {
|
|
51
|
+
try { return (await readJsonArtifact(target, relativePath, schemaName, packageRoot)).value; } catch { return null; }
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
function checkSummary(receipt) {
|
|
55
|
+
return (Array.isArray(receipt?.checks) ? receipt.checks : []).map((check) => ({
|
|
56
|
+
id: check.id,
|
|
57
|
+
requirement: typeof check.requirement === "string" ? check.requirement : null,
|
|
58
|
+
status: check.status,
|
|
59
|
+
exitCode: Number.isInteger(check.exitCode) ? check.exitCode : null,
|
|
60
|
+
})).sort((left, right) => String(left.id).localeCompare(String(right.id)));
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
const PHASE_BOUNDARIES = Object.freeze([
|
|
64
|
+
["planning", "TASK_RECEIVED", "EXECUTION_STARTED"],
|
|
65
|
+
["executing", "EXECUTION_STARTED", "VERIFICATION_STARTED"],
|
|
66
|
+
["verifying", "VERIFICATION_STARTED", "REVIEW_STARTED"],
|
|
67
|
+
["reviewing", "REVIEW_STARTED", "COMPLETION_VALIDATED"],
|
|
68
|
+
]);
|
|
69
|
+
|
|
70
|
+
function firstAt(events, name) {
|
|
71
|
+
const value = events.find((event) => event.event === name)?.at;
|
|
72
|
+
const time = value ? Date.parse(value) : Number.NaN;
|
|
73
|
+
return Number.isFinite(time) ? time : null;
|
|
74
|
+
}
|
|
75
|
+
|
|
76
|
+
// Informational lifecycle metrics from the task ledger. Self-reported and not
|
|
77
|
+
// cryptographically bound; harness and model are not recorded by the ledger.
|
|
78
|
+
export function lifecycleMetrics(events, receipt) {
|
|
79
|
+
const received = firstAt(events, "TASK_RECEIVED");
|
|
80
|
+
const completed = firstAt(events, "COMPLETION_VALIDATED");
|
|
81
|
+
const phaseDurationsMs = {};
|
|
82
|
+
for (const [phase, start, end] of PHASE_BOUNDARIES) {
|
|
83
|
+
const from = firstAt(events, start);
|
|
84
|
+
const to = firstAt(events, end);
|
|
85
|
+
if (from !== null && to !== null && to >= from) phaseDurationsMs[phase] = to - from;
|
|
86
|
+
}
|
|
87
|
+
const checks = Array.isArray(receipt?.checks) ? receipt.checks : [];
|
|
88
|
+
return {
|
|
89
|
+
bound: false,
|
|
90
|
+
receivedAt: received === null ? null : new Date(received).toISOString(),
|
|
91
|
+
completedAt: completed === null ? null : new Date(completed).toISOString(),
|
|
92
|
+
durationMs: received !== null && completed !== null && completed >= received ? completed - received : null,
|
|
93
|
+
phaseDurationsMs,
|
|
94
|
+
verificationCycles: events.filter((event) => event.event === "VERIFICATION_STARTED").length,
|
|
95
|
+
diagnoses: events.filter((event) => event.event === "DIAGNOSIS_RECORDED").length,
|
|
96
|
+
checksPassed: checks.filter((check) => check.status === "passed").length,
|
|
97
|
+
checksFailed: checks.filter((check) => check.status === "failed").length,
|
|
98
|
+
};
|
|
99
|
+
}
|
|
100
|
+
|
|
101
|
+
async function readLedgerEvents(target, taskId, packageRoot) {
|
|
102
|
+
try {
|
|
103
|
+
const ledger = await validateEventLedger(target, packageRoot, { taskId });
|
|
104
|
+
return ledger.valid ? ledger.events : [];
|
|
105
|
+
} catch {
|
|
106
|
+
return [];
|
|
107
|
+
}
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
function informationalSummary(contract, receipt) {
|
|
111
|
+
return {
|
|
112
|
+
bound: false,
|
|
113
|
+
note: "Informational projection of the contract and receipt; only the statement and manifest are cryptographically bound.",
|
|
114
|
+
objective: typeof contract?.objective === "string" ? contract.objective : null,
|
|
115
|
+
successCriteria: Array.isArray(contract?.successCriteria) ? contract.successCriteria.map(String) : [],
|
|
116
|
+
checks: checkSummary(receipt),
|
|
117
|
+
};
|
|
118
|
+
}
|
|
119
|
+
|
|
120
|
+
async function collectEvidence(target, taskId, packageRoot) {
|
|
121
|
+
let manifest;
|
|
122
|
+
let statement;
|
|
123
|
+
try {
|
|
124
|
+
manifest = await readCodeManifest({ target, packageRoot, taskId });
|
|
125
|
+
statement = await readAttestationStatement({ target, packageRoot, taskId });
|
|
126
|
+
} catch (error) {
|
|
127
|
+
throw evidenceError(E_EVIDENCE_EXPORT_UNAVAILABLE, `Task ${taskId} has no exportable attestation (${error.code ?? "unknown"}); complete it with attestation mode required and run attestation-create first`);
|
|
128
|
+
}
|
|
129
|
+
if (statement.value.predicate?.verification?.completion !== "VALID") {
|
|
130
|
+
throw evidenceError(E_EVIDENCE_EXPORT_UNAVAILABLE, `Task ${taskId} attestation does not record a VALID completion`);
|
|
131
|
+
}
|
|
132
|
+
const statementText = await readStatementText(target, taskId);
|
|
133
|
+
if (canonicalFingerprint(JSON.parse(statementText)) !== canonicalFingerprint(statement.value)) {
|
|
134
|
+
throw evidenceError(E_EVIDENCE_EXPORT_UNAVAILABLE, "Attestation statement bytes changed while exporting");
|
|
135
|
+
}
|
|
136
|
+
return {
|
|
137
|
+
manifest: manifest.value,
|
|
138
|
+
statementText,
|
|
139
|
+
signatureText: await readSignatureText(target, taskId),
|
|
140
|
+
contract: await readOptional(target, taskArtifactPath(taskId, "contract"), "current-contract", packageRoot),
|
|
141
|
+
receipt: await readOptional(target, taskArtifactPath(taskId, "receipt"), "execution-receipt", packageRoot),
|
|
142
|
+
events: await readLedgerEvents(target, taskId, packageRoot),
|
|
143
|
+
};
|
|
144
|
+
}
|
|
145
|
+
|
|
146
|
+
function assertRedacted(text, target) {
|
|
147
|
+
const absolute = path.resolve(target);
|
|
148
|
+
if (text.includes(absolute) || text.includes(absolute.replaceAll("\\", "/"))) {
|
|
149
|
+
throw evidenceError(E_EVIDENCE_EXPORT_UNAVAILABLE, "Evidence bundle would contain the absolute project path; refusing to export");
|
|
150
|
+
}
|
|
151
|
+
}
|
|
152
|
+
|
|
153
|
+
export async function exportEvidenceBundle({ target, taskId, packageRoot = getPackageRoot(), directory = DEFAULT_EVIDENCE_DIRECTORY } = {}) {
|
|
154
|
+
assertEvidenceTaskId(taskId);
|
|
155
|
+
const evidence = await withProjectReadSnapshot(target, () => collectEvidence(target, taskId, packageRoot));
|
|
156
|
+
const bundle = sealEvidenceBundle({
|
|
157
|
+
schemaVersion: EVIDENCE_BUNDLE_SCHEMA_VERSION,
|
|
158
|
+
kind: EVIDENCE_BUNDLE_KIND,
|
|
159
|
+
taskId,
|
|
160
|
+
forgeloopVersion: await packageVersion(packageRoot),
|
|
161
|
+
statement: { text: evidence.statementText },
|
|
162
|
+
manifest: evidence.manifest,
|
|
163
|
+
manifestFingerprint: canonicalFingerprint(evidence.manifest),
|
|
164
|
+
signature: evidence.signatureText === null ? null : { provider: "sigstore", bundleText: evidence.signatureText },
|
|
165
|
+
summary: informationalSummary(evidence.contract, evidence.receipt),
|
|
166
|
+
metrics: lifecycleMetrics(evidence.events, evidence.receipt),
|
|
167
|
+
redactions: [...EVIDENCE_REDACTIONS],
|
|
168
|
+
});
|
|
169
|
+
const text = serializeEvidenceBundle(bundle);
|
|
170
|
+
assertRedacted(text, target);
|
|
171
|
+
const relativePath = evidenceBundlePath(directory, taskId);
|
|
172
|
+
await mkdir(path.dirname(ensureWithin(target, relativePath)), { recursive: true });
|
|
173
|
+
await assertSafePath(target, relativePath);
|
|
174
|
+
await writeFileAtomic(ensureWithin(target, relativePath), text);
|
|
175
|
+
return {
|
|
176
|
+
schemaVersion: 1,
|
|
177
|
+
taskId,
|
|
178
|
+
path: relativePath,
|
|
179
|
+
digest: bundle.digest,
|
|
180
|
+
coveredPaths: bundle.manifest.entries.length,
|
|
181
|
+
signed: bundle.signature !== null,
|
|
182
|
+
redactions: bundle.redactions,
|
|
183
|
+
};
|
|
184
|
+
}
|
|
@@ -0,0 +1,40 @@
|
|
|
1
|
+
// Markdown projection of an evidence verification for CI step summaries and
|
|
2
|
+
// pull-request check runs. It never adds facts beyond the verification result.
|
|
3
|
+
|
|
4
|
+
const STATUS_LABEL = Object.freeze({
|
|
5
|
+
ATTESTED: "Verified and signed",
|
|
6
|
+
INTEGRITY_ONLY: "Consistent, unsigned",
|
|
7
|
+
NONE: "Not verified",
|
|
8
|
+
});
|
|
9
|
+
|
|
10
|
+
const escapeCell = (value) => String(value).replaceAll("|", "\\|").replaceAll("\n", " ");
|
|
11
|
+
|
|
12
|
+
function bundleRows(result) {
|
|
13
|
+
if (result.bundles.length === 0) return ["No evidence bundles changed in this range."];
|
|
14
|
+
return [
|
|
15
|
+
"| Task | Integrity | Signature | Matching entries |",
|
|
16
|
+
"| --- | --- | --- | --- |",
|
|
17
|
+
...result.bundles.map((bundle) => `| \`${escapeCell(bundle.taskId)}\` | ${bundle.integrity} | ${bundle.signature.status} | ${bundle.matchingEntries}/${bundle.entries} |`),
|
|
18
|
+
];
|
|
19
|
+
}
|
|
20
|
+
|
|
21
|
+
function listSection(title, items) {
|
|
22
|
+
if (items.length === 0) return [];
|
|
23
|
+
return ["", `### ${title}`, "", ...items.map((item) => `- ${item}`)];
|
|
24
|
+
}
|
|
25
|
+
|
|
26
|
+
export function formatEvidenceMarkdown(result) {
|
|
27
|
+
const icon = result.status === "VALID" ? "✅" : "❌";
|
|
28
|
+
return [
|
|
29
|
+
`## ${icon} ForgeLoop evidence: ${STATUS_LABEL[result.level] ?? result.level}`,
|
|
30
|
+
"",
|
|
31
|
+
`Status \`${result.status}\`, level \`${result.level}\`: ${result.coveredPaths}/${result.changedPaths} changed paths covered.`,
|
|
32
|
+
"",
|
|
33
|
+
...bundleRows(result),
|
|
34
|
+
...listSection("Uncovered paths", result.uncoveredPaths.map((value) => `\`${escapeCell(value)}\``)),
|
|
35
|
+
...listSection("Superseded entries", result.superseded.map((item) => `\`${escapeCell(item.path)}\` from \`${item.taskId}\`, covered by ${item.supersededBy.map((id) => `\`${id}\``).join(", ")}`)),
|
|
36
|
+
...listSection("Errors", result.errors.map((error) => `\`${error.code}\`: ${escapeCell(error.message)}`)),
|
|
37
|
+
...listSection("Warnings", result.warnings),
|
|
38
|
+
"",
|
|
39
|
+
].join("\n");
|
|
40
|
+
}
|
|
@@ -0,0 +1,187 @@
|
|
|
1
|
+
import { createHash } from "node:crypto";
|
|
2
|
+
import { mkdir, readFile, readdir, rename, writeFile } from "node:fs/promises";
|
|
3
|
+
import os from "node:os";
|
|
4
|
+
import path from "node:path";
|
|
5
|
+
|
|
6
|
+
import {
|
|
7
|
+
E_EVIDENCE_PUBLISH_CONFIG,
|
|
8
|
+
E_EVIDENCE_PUBLISH_UNAUTHORIZED,
|
|
9
|
+
} from "../error-codes.js";
|
|
10
|
+
import { ensureWithin } from "../filesystem.js";
|
|
11
|
+
import { resolveRepository } from "../sync/remote.js";
|
|
12
|
+
import { DEFAULT_EVIDENCE_DIRECTORY, assertEvidenceTaskId, evidenceBundlePath, evidenceError, parseEvidenceBundle } from "./bundle-format.js";
|
|
13
|
+
|
|
14
|
+
// Opt-in evidence publishing for the team dashboard. Nothing leaves the
|
|
15
|
+
// machine unless `forgeloop evidence-publish` runs, and only bundles that
|
|
16
|
+
// evidence-export already redacted and that still match their digest are sent.
|
|
17
|
+
// Requested bundles enter an offline queue kept outside the repository; every
|
|
18
|
+
// run retries it, so a laptop that was offline publishes on its next run. The
|
|
19
|
+
// remote treats a repeated bundle as unchanged, which makes retries safe.
|
|
20
|
+
|
|
21
|
+
export const DEFAULT_EVIDENCE_REMOTE = "https://forgeloop.monster/api/evidence";
|
|
22
|
+
const REQUEST_TIMEOUT_MS = 60_000;
|
|
23
|
+
|
|
24
|
+
function publishError(code, message) {
|
|
25
|
+
return evidenceError(code, message);
|
|
26
|
+
}
|
|
27
|
+
|
|
28
|
+
export function resolvePublishRemote(value) {
|
|
29
|
+
let url;
|
|
30
|
+
try {
|
|
31
|
+
url = new URL(value || DEFAULT_EVIDENCE_REMOTE);
|
|
32
|
+
} catch {
|
|
33
|
+
throw publishError(E_EVIDENCE_PUBLISH_CONFIG, "--remote must be a URL");
|
|
34
|
+
}
|
|
35
|
+
const local = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
|
|
36
|
+
if (url.protocol !== "https:" && !(local && url.protocol === "http:")) throw publishError(E_EVIDENCE_PUBLISH_CONFIG, "--remote must use https (http is allowed only for localhost)");
|
|
37
|
+
if (url.username || url.password || url.search || url.hash) throw publishError(E_EVIDENCE_PUBLISH_CONFIG, "--remote must not contain credentials, a query or a fragment");
|
|
38
|
+
return url.toString();
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
export function readPublishToken(env = process.env) {
|
|
42
|
+
const bearer = env.FORGELOOP_SYNC_TOKEN ?? "";
|
|
43
|
+
if (!/^[A-Za-z0-9._~+/-]{32,512}$/u.test(bearer)) throw publishError(E_EVIDENCE_PUBLISH_CONFIG, "FORGELOOP_SYNC_TOKEN must be set to a ForgeLoop token for this repository");
|
|
44
|
+
return bearer;
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
function queueFile(target, env) {
|
|
48
|
+
const base = env.FORGELOOP_EVIDENCE_QUEUE_DIR
|
|
49
|
+
|| (env.XDG_CONFIG_HOME ? path.join(env.XDG_CONFIG_HOME, "forgeloop", "evidence-queue") : path.join(os.homedir(), ".config", "forgeloop", "evidence-queue"));
|
|
50
|
+
const key = createHash("sha256").update(path.resolve(target)).digest("hex").slice(0, 32);
|
|
51
|
+
return path.join(base, `${key}.json`);
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
export async function readPublishQueue(target, { env = process.env } = {}) {
|
|
55
|
+
try {
|
|
56
|
+
const parsed = JSON.parse(await readFile(queueFile(target, env), "utf8"));
|
|
57
|
+
return Array.isArray(parsed?.items)
|
|
58
|
+
? parsed.items.filter((item) => typeof item?.taskId === "string" && typeof item?.path === "string" && typeof item?.remote === "string" && typeof item?.repository === "string")
|
|
59
|
+
: [];
|
|
60
|
+
} catch {
|
|
61
|
+
return [];
|
|
62
|
+
}
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
async function writePublishQueue(target, items, { env }) {
|
|
66
|
+
const file = queueFile(target, env);
|
|
67
|
+
await mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
|
|
68
|
+
const temporary = `${file}.${process.pid}.tmp`;
|
|
69
|
+
await writeFile(temporary, `${JSON.stringify({ schemaVersion: 1, items }, null, 2)}\n`, { mode: 0o600 });
|
|
70
|
+
await rename(temporary, file);
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
// Explicit task IDs must be valid; --all skips files whose names cannot be
|
|
74
|
+
// evidence bundles instead of aborting the run.
|
|
75
|
+
async function requestedItems(target, { taskIds, all, directory, remote, repository }) {
|
|
76
|
+
const names = new Set(taskIds.map((taskId) => assertEvidenceTaskId(taskId)));
|
|
77
|
+
const skipped = [];
|
|
78
|
+
if (all) {
|
|
79
|
+
let entries = [];
|
|
80
|
+
try { entries = await readdir(ensureWithin(target, directory)); } catch { entries = []; }
|
|
81
|
+
for (const entry of entries.filter((name) => name.endsWith(".json")).sort()) {
|
|
82
|
+
const taskId = entry.slice(0, -".json".length);
|
|
83
|
+
try { names.add(assertEvidenceTaskId(taskId)); } catch { skipped.push(entry); }
|
|
84
|
+
}
|
|
85
|
+
}
|
|
86
|
+
const items = [...names].sort().map((taskId) => ({ taskId, path: evidenceBundlePath(directory, taskId), remote, repository }));
|
|
87
|
+
return { items, skipped };
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
async function send({ remote, repository, bearer, text, fetchImpl }) {
|
|
91
|
+
const url = new URL(remote);
|
|
92
|
+
url.searchParams.set("repo", repository);
|
|
93
|
+
try {
|
|
94
|
+
return await fetchImpl(url.toString(), {
|
|
95
|
+
method: "PUT",
|
|
96
|
+
headers: { authorization: `Bearer ${bearer}`, accept: "application/json", "content-type": "application/json" },
|
|
97
|
+
body: text,
|
|
98
|
+
signal: globalThis.AbortSignal.timeout(REQUEST_TIMEOUT_MS),
|
|
99
|
+
});
|
|
100
|
+
} catch (error) {
|
|
101
|
+
return { networkError: error.message };
|
|
102
|
+
}
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
// Publishes one queued bundle. Returns the item's outcome and whether it stays
|
|
106
|
+
// in the queue.
|
|
107
|
+
async function publishItem(target, item, context) {
|
|
108
|
+
let text;
|
|
109
|
+
try {
|
|
110
|
+
text = await readFile(ensureWithin(target, item.path), "utf8");
|
|
111
|
+
} catch {
|
|
112
|
+
return { outcome: { taskId: item.taskId, status: "MISSING", message: `${item.path} no longer exists` }, keep: false };
|
|
113
|
+
}
|
|
114
|
+
let bundle;
|
|
115
|
+
try {
|
|
116
|
+
bundle = parseEvidenceBundle(text, item.taskId);
|
|
117
|
+
} catch (error) {
|
|
118
|
+
return { outcome: { taskId: item.taskId, status: "INVALID", code: error.code, message: error.message }, keep: false };
|
|
119
|
+
}
|
|
120
|
+
const response = await send({ ...context, text });
|
|
121
|
+
if (response.networkError) return { outcome: { taskId: item.taskId, digest: bundle.digest, status: "QUEUED", message: `Remote unreachable: ${response.networkError}` }, keep: true };
|
|
122
|
+
const detail = await response.json().catch(() => ({}));
|
|
123
|
+
if (response.ok) return { outcome: { taskId: item.taskId, digest: bundle.digest, status: detail?.status === "unchanged" ? "UNCHANGED" : "PUBLISHED" }, keep: false };
|
|
124
|
+
const message = typeof detail?.error === "string" ? detail.error : `HTTP ${response.status}`;
|
|
125
|
+
if (response.status === 401 || response.status === 403) return { outcome: { taskId: item.taskId, digest: bundle.digest, status: "UNAUTHORIZED", message }, keep: true, unauthorized: message };
|
|
126
|
+
if (response.status === 400 || response.status === 413) return { outcome: { taskId: item.taskId, digest: bundle.digest, status: "REJECTED", message }, keep: false };
|
|
127
|
+
return { outcome: { taskId: item.taskId, digest: bundle.digest, status: "QUEUED", message }, keep: true };
|
|
128
|
+
}
|
|
129
|
+
|
|
130
|
+
export async function publishEvidence({
|
|
131
|
+
target,
|
|
132
|
+
taskIds = [],
|
|
133
|
+
all = false,
|
|
134
|
+
directory = DEFAULT_EVIDENCE_DIRECTORY,
|
|
135
|
+
remote,
|
|
136
|
+
repository,
|
|
137
|
+
env = process.env,
|
|
138
|
+
fetchImpl = fetch,
|
|
139
|
+
} = {}) {
|
|
140
|
+
const resolvedRemote = resolvePublishRemote(remote);
|
|
141
|
+
const resolvedRepository = await resolveRepository(target, repository).catch((error) => {
|
|
142
|
+
throw publishError(E_EVIDENCE_PUBLISH_CONFIG, error.message);
|
|
143
|
+
});
|
|
144
|
+
const bearer = readPublishToken(env);
|
|
145
|
+
// Queued items stay bound to the remote and repository they were queued
|
|
146
|
+
// for; a run with other flags leaves them untouched.
|
|
147
|
+
const queue = await readPublishQueue(target, { env });
|
|
148
|
+
const matches = (item) => item.remote === resolvedRemote && item.repository === resolvedRepository;
|
|
149
|
+
const elsewhere = queue.filter((item) => !matches(item));
|
|
150
|
+
const queued = queue.filter(matches);
|
|
151
|
+
const { items: requested, skipped } = await requestedItems(target, { taskIds, all, directory, remote: resolvedRemote, repository: resolvedRepository });
|
|
152
|
+
if (queued.length === 0 && requested.length === 0) {
|
|
153
|
+
throw publishError(E_EVIDENCE_PUBLISH_CONFIG, "Nothing to publish: pass --task <id> or --all, or run again after a queued publish");
|
|
154
|
+
}
|
|
155
|
+
const pending = [...new Map([...queued, ...requested].map((item) => [item.taskId, item])).values()];
|
|
156
|
+
// Queue first, so an interrupted run still retries every requested bundle.
|
|
157
|
+
await writePublishQueue(target, [...elsewhere, ...pending], { env });
|
|
158
|
+
const context = { remote: resolvedRemote, repository: resolvedRepository, bearer, fetchImpl };
|
|
159
|
+
const results = [];
|
|
160
|
+
const remaining = [];
|
|
161
|
+
let unauthorized = null;
|
|
162
|
+
for (const item of pending) {
|
|
163
|
+
if (unauthorized) {
|
|
164
|
+
results.push({ taskId: item.taskId, status: "QUEUED", message: "Not attempted after the remote refused the token" });
|
|
165
|
+
remaining.push(item);
|
|
166
|
+
continue;
|
|
167
|
+
}
|
|
168
|
+
const { outcome, keep, unauthorized: refused } = await publishItem(target, item, context);
|
|
169
|
+
results.push(outcome);
|
|
170
|
+
if (keep) remaining.push(item);
|
|
171
|
+
if (refused) unauthorized = refused;
|
|
172
|
+
}
|
|
173
|
+
await writePublishQueue(target, [...elsewhere, ...remaining], { env });
|
|
174
|
+
if (unauthorized) {
|
|
175
|
+
throw Object.assign(publishError(E_EVIDENCE_PUBLISH_UNAUTHORIZED, `The evidence remote refused FORGELOOP_SYNC_TOKEN: ${unauthorized}`), { results, queued: remaining.length });
|
|
176
|
+
}
|
|
177
|
+
const complete = results.every((result) => result.status === "PUBLISHED" || result.status === "UNCHANGED");
|
|
178
|
+
return {
|
|
179
|
+
schemaVersion: 1,
|
|
180
|
+
status: complete ? "PUBLISHED" : remaining.length > 0 ? "QUEUED" : "INCOMPLETE",
|
|
181
|
+
remote: resolvedRemote,
|
|
182
|
+
repository: resolvedRepository,
|
|
183
|
+
results,
|
|
184
|
+
queued: remaining.length,
|
|
185
|
+
skipped,
|
|
186
|
+
};
|
|
187
|
+
}
|
|
@@ -0,0 +1,179 @@
|
|
|
1
|
+
import { mkdtemp, rm, writeFile } from "node:fs/promises";
|
|
2
|
+
import os from "node:os";
|
|
3
|
+
import path from "node:path";
|
|
4
|
+
import { validateAttestationStatement } from "../attestation.js";
|
|
5
|
+
import { assertAttestationStatementBindings, verifyCodeManifestContent } from "../attestation-verifier.js";
|
|
6
|
+
import { validateCodeManifest } from "../code-manifest.js";
|
|
7
|
+
import { E_ATTESTATION_CONTENT_MISMATCH, E_ATTESTATION_COVERAGE_GAP, E_ATTESTATION_UNSIGNED, E_EVIDENCE_BUNDLE_INVALID } from "../error-codes.js";
|
|
8
|
+
import { resolveRevisionProvider } from "../revision/provider.js";
|
|
9
|
+
import { REVISION_PROVIDERS } from "../revision/registry.js";
|
|
10
|
+
import { createSigstoreSigningProvider } from "../signing/sigstore.js";
|
|
11
|
+
import { getPackageRoot } from "../templates.js";
|
|
12
|
+
import { DEFAULT_EVIDENCE_DIRECTORY, parseEvidenceBundle } from "./bundle-format.js";
|
|
13
|
+
|
|
14
|
+
export const EVIDENCE_LEVELS = Object.freeze({ ATTESTED: "ATTESTED", INTEGRITY_ONLY: "INTEGRITY_ONLY", NONE: "NONE" });
|
|
15
|
+
export const UNSIGNED_WARNING = "Unsigned evidence bundles prove internal consistency with the committed code, not that ForgeLoop produced them; require signatures to use this check as a trust gate.";
|
|
16
|
+
|
|
17
|
+
const normalize = (value) => String(value).replaceAll("\\", "/").replace(/^\.\//u, "");
|
|
18
|
+
const entryPaths = (entry) => [entry.path, entry.sourcePath].filter(Boolean).map(normalize);
|
|
19
|
+
|
|
20
|
+
function isExcluded(value, directory, exclusions) {
|
|
21
|
+
if (value === ".forgeloop" || value.startsWith(".forgeloop/")) return true;
|
|
22
|
+
if (value === directory || value.startsWith(`${directory}/`)) return true;
|
|
23
|
+
return exclusions.some((pattern) => {
|
|
24
|
+
const normalized = normalize(pattern);
|
|
25
|
+
if (normalized.endsWith("/**")) return value === normalized.slice(0, -3) || value.startsWith(normalized.slice(0, -2));
|
|
26
|
+
return value === normalized;
|
|
27
|
+
});
|
|
28
|
+
}
|
|
29
|
+
|
|
30
|
+
async function resolveProvider(target, revisionProvider) {
|
|
31
|
+
return typeof revisionProvider === "string"
|
|
32
|
+
? resolveRevisionProvider({ target, providerName: revisionProvider, registry: REVISION_PROVIDERS })
|
|
33
|
+
: revisionProvider;
|
|
34
|
+
}
|
|
35
|
+
|
|
36
|
+
function changedBundlePaths(changedEntries, directory) {
|
|
37
|
+
return [...new Set(changedEntries
|
|
38
|
+
.filter((entry) => entry.kind !== "DELETED" && entry.operation !== "DELETED")
|
|
39
|
+
.map((entry) => normalize(entry.path))
|
|
40
|
+
.filter((value) => value.startsWith(`${directory}/`) && value.endsWith(".json")))].sort();
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
async function verifySignature({ statementText, signature, signer, policy }) {
|
|
44
|
+
if (!signature) return { status: "UNSIGNED" };
|
|
45
|
+
const directory = await mkdtemp(path.join(os.tmpdir(), "forgeloop-evidence-signature-"));
|
|
46
|
+
try {
|
|
47
|
+
await writeFile(path.join(directory, "statement.json"), statementText);
|
|
48
|
+
await writeFile(path.join(directory, "statement.sigstore.json"), signature.bundleText);
|
|
49
|
+
const result = await signer.verify({ target: directory, statementPath: "statement.json", bundlePath: "statement.sigstore.json", policy });
|
|
50
|
+
return { status: result.status, ...(result.code ? { code: result.code } : {}), ...(result.message ? { message: result.message } : {}) };
|
|
51
|
+
} finally {
|
|
52
|
+
await rm(directory, { recursive: true, force: true });
|
|
53
|
+
}
|
|
54
|
+
}
|
|
55
|
+
|
|
56
|
+
async function verifyEntries({ target, manifest, provider, headRevision }) {
|
|
57
|
+
const entries = [];
|
|
58
|
+
for (const entry of manifest.entries) {
|
|
59
|
+
try {
|
|
60
|
+
await verifyCodeManifestContent({ target, manifest: { ...manifest, entries: [entry] }, revisionProvider: provider, revision: headRevision });
|
|
61
|
+
entries.push({ paths: entryPaths(entry), digest: entry.sha256 ?? entry.providerContentId ?? entry.kind, matches: true });
|
|
62
|
+
} catch (error) {
|
|
63
|
+
if (error.code !== E_ATTESTATION_CONTENT_MISMATCH) throw error;
|
|
64
|
+
entries.push({ paths: entryPaths(entry), digest: entry.sha256 ?? entry.providerContentId ?? entry.kind, matches: false });
|
|
65
|
+
}
|
|
66
|
+
}
|
|
67
|
+
return entries;
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
async function loadBundle(context, bundlePath) {
|
|
71
|
+
const { target, provider, headRevision, packageRoot, signer, policy } = context;
|
|
72
|
+
const expectedTaskId = path.posix.basename(bundlePath, ".json");
|
|
73
|
+
const record = { path: bundlePath, taskId: expectedTaskId, integrity: "INVALID", signature: { status: "NOT_CHECKED" }, entries: [] };
|
|
74
|
+
try {
|
|
75
|
+
const bytes = await provider.readContent({ target, revision: headRevision, path: bundlePath });
|
|
76
|
+
const { bundle, statement } = parseEvidenceBundle(Buffer.from(bytes).toString("utf8"), expectedTaskId);
|
|
77
|
+
await validateAttestationStatement(statement, packageRoot);
|
|
78
|
+
const manifest = await validateCodeManifest(bundle.manifest, packageRoot);
|
|
79
|
+
assertAttestationStatementBindings(statement, manifest, bundle.taskId, bundle.manifestFingerprint);
|
|
80
|
+
record.entries = await verifyEntries({ target, manifest, provider, headRevision });
|
|
81
|
+
record.integrity = "VALID";
|
|
82
|
+
record.signature = await verifySignature({ statementText: bundle.statement.text, signature: bundle.signature, signer, policy });
|
|
83
|
+
} catch (error) {
|
|
84
|
+
if (error.code?.startsWith("E_REVISION_")) throw error;
|
|
85
|
+
record.error = { code: error.code?.startsWith("E_") ? error.code : E_EVIDENCE_BUNDLE_INVALID, message: error.message };
|
|
86
|
+
}
|
|
87
|
+
return record;
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
function coverageFor(changedPaths, bundles) {
|
|
91
|
+
const covering = new Map();
|
|
92
|
+
for (const bundle of bundles.filter((item) => item.integrity === "VALID")) {
|
|
93
|
+
for (const entry of bundle.entries.filter((item) => item.matches)) {
|
|
94
|
+
for (const value of entry.paths) covering.set(value, [...(covering.get(value) ?? []), bundle.taskId]);
|
|
95
|
+
}
|
|
96
|
+
}
|
|
97
|
+
const errors = [];
|
|
98
|
+
const superseded = [];
|
|
99
|
+
for (const bundle of bundles.filter((item) => item.integrity === "VALID")) {
|
|
100
|
+
for (const entry of bundle.entries.filter((item) => !item.matches)) {
|
|
101
|
+
for (const value of entry.paths) {
|
|
102
|
+
if (covering.has(value)) superseded.push({ path: value, taskId: bundle.taskId, supersededBy: [...new Set(covering.get(value))].sort() });
|
|
103
|
+
else errors.push({ code: E_ATTESTATION_CONTENT_MISMATCH, taskId: bundle.taskId, path: value, message: `Evidence for ${value} does not match the head revision and no other bundle covers it` });
|
|
104
|
+
}
|
|
105
|
+
}
|
|
106
|
+
}
|
|
107
|
+
const uncoveredPaths = changedPaths.filter((value) => !covering.has(value));
|
|
108
|
+
return { covering, errors, superseded, uncoveredPaths };
|
|
109
|
+
}
|
|
110
|
+
|
|
111
|
+
function signerPolicyFrom(signerPolicy) {
|
|
112
|
+
return Object.fromEntries(["identity", "issuer", "trustedRoot"].filter((key) => signerPolicy[key]).map((key) => [key, signerPolicy[key]]));
|
|
113
|
+
}
|
|
114
|
+
|
|
115
|
+
function signatureErrors(bundles) {
|
|
116
|
+
return bundles.filter((bundle) => bundle.signature.status !== "VALID").map((bundle) => ({
|
|
117
|
+
code: bundle.signature.code ?? E_ATTESTATION_UNSIGNED,
|
|
118
|
+
taskId: bundle.taskId,
|
|
119
|
+
message: bundle.signature.message ?? `Evidence for task ${bundle.taskId} has no valid signature`,
|
|
120
|
+
}));
|
|
121
|
+
}
|
|
122
|
+
|
|
123
|
+
function overallLevel(status, usedBundles) {
|
|
124
|
+
if (status !== "VALID") return EVIDENCE_LEVELS.NONE;
|
|
125
|
+
return usedBundles.length > 0 && usedBundles.every((bundle) => bundle.signature.status === "VALID") ? EVIDENCE_LEVELS.ATTESTED : EVIDENCE_LEVELS.INTEGRITY_ONLY;
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
export async function verifyEvidenceRange({
|
|
129
|
+
target,
|
|
130
|
+
packageRoot = getPackageRoot(),
|
|
131
|
+
revisionProvider = "git",
|
|
132
|
+
baseRevision,
|
|
133
|
+
headRevision,
|
|
134
|
+
directory = DEFAULT_EVIDENCE_DIRECTORY,
|
|
135
|
+
requireCompleteCoverage = true,
|
|
136
|
+
requireSignature = false,
|
|
137
|
+
signerPolicy = {},
|
|
138
|
+
signingProvider = null,
|
|
139
|
+
exclusions = [],
|
|
140
|
+
} = {}) {
|
|
141
|
+
const evidenceDirectory = normalize(directory).replace(/\/+$/u, "");
|
|
142
|
+
const provider = await resolveProvider(target, revisionProvider);
|
|
143
|
+
const changedEntries = await provider.getChangedEntries({ target, baseRevision, headRevision });
|
|
144
|
+
const changedPaths = [...new Set(changedEntries.flatMap(entryPaths))].filter((value) => !isExcluded(value, evidenceDirectory, exclusions)).sort();
|
|
145
|
+
const policy = signerPolicyFrom(signerPolicy);
|
|
146
|
+
const context = { target, provider, headRevision, packageRoot, signer: signingProvider ?? createSigstoreSigningProvider(), policy };
|
|
147
|
+
const bundles = [];
|
|
148
|
+
for (const bundlePath of changedBundlePaths(changedEntries, evidenceDirectory)) bundles.push(await loadBundle(context, bundlePath));
|
|
149
|
+
const coverage = coverageFor(changedPaths, bundles);
|
|
150
|
+
const errors = [
|
|
151
|
+
...bundles.filter((bundle) => bundle.error).map((bundle) => ({ ...bundle.error, taskId: bundle.taskId, path: bundle.path })),
|
|
152
|
+
...coverage.errors,
|
|
153
|
+
];
|
|
154
|
+
if (requireCompleteCoverage && coverage.uncoveredPaths.length > 0) {
|
|
155
|
+
errors.push({ code: E_ATTESTATION_COVERAGE_GAP, message: `Changed paths are not covered by evidence: ${coverage.uncoveredPaths.join(", ")}`, paths: coverage.uncoveredPaths });
|
|
156
|
+
}
|
|
157
|
+
const usedBundles = bundles.filter((bundle) => bundle.integrity === "VALID");
|
|
158
|
+
if (requireSignature) errors.push(...signatureErrors(usedBundles));
|
|
159
|
+
const status = errors.length === 0 ? "VALID" : "INVALID";
|
|
160
|
+
const level = overallLevel(status, usedBundles);
|
|
161
|
+
return {
|
|
162
|
+
schemaVersion: 1,
|
|
163
|
+
kind: "forgeloop-evidence-verification",
|
|
164
|
+
status,
|
|
165
|
+
level,
|
|
166
|
+
revisionProvider: provider.name ?? "unknown",
|
|
167
|
+
baseRevision: baseRevision ?? null,
|
|
168
|
+
headRevision: headRevision ?? null,
|
|
169
|
+
evidenceDirectory,
|
|
170
|
+
changedPaths: changedPaths.length,
|
|
171
|
+
coveredPaths: changedPaths.length - coverage.uncoveredPaths.length,
|
|
172
|
+
uncoveredPaths: coverage.uncoveredPaths,
|
|
173
|
+
superseded: coverage.superseded,
|
|
174
|
+
bundles: bundles.map(({ entries, ...bundle }) => ({ ...bundle, entries: entries.length, matchingEntries: entries.filter((entry) => entry.matches).length })),
|
|
175
|
+
signature: { required: requireSignature, ...policy },
|
|
176
|
+
warnings: level === EVIDENCE_LEVELS.INTEGRITY_ONLY ? [UNSIGNED_WARNING] : [],
|
|
177
|
+
errors,
|
|
178
|
+
};
|
|
179
|
+
}
|
|
@@ -26,7 +26,7 @@ export const INTEGRATION_RISK_CLASSES = Object.freeze({
|
|
|
26
26
|
|
|
27
27
|
const READ_ONLY_COMMANDS = Object.freeze(new Set([
|
|
28
28
|
"storage-migration-status",
|
|
29
|
-
"protocol-info", "decision-status", "decision-show", "context-plan", "model-route", "semantic-plan", "test-inventory", "status", "next", "continuity", "reconcile-continuity",
|
|
29
|
+
"protocol-info", "decision-status", "decision-show", "context-plan", "model-route", "semantic-plan", "test-inventory", "assess", "evidence-verify", "status", "next", "continuity", "reconcile-continuity",
|
|
30
30
|
"task-list", "task-show", "task-lock-status", "progress", "audit", "report",
|
|
31
31
|
"inspect", "validate-state", "validate-protocol", "validate-receipt",
|
|
32
32
|
"policy-status", "policy-diff", "rule-verify", "policy",
|
|
@@ -45,7 +45,7 @@ const LOOP_MUTATION_COMMANDS = Object.freeze(new Set([
|
|
|
45
45
|
"record-terminal-result", "complete",
|
|
46
46
|
"record-intervention", "record-hypothesis-disposition",
|
|
47
47
|
"usage-record",
|
|
48
|
-
"workspace-bind", "handoff-create", "handoff-accept", "responsibility-set", "verify-scope", "attestation-create",
|
|
48
|
+
"workspace-bind", "handoff-create", "handoff-accept", "responsibility-set", "verify-scope", "attestation-create", "evidence-export",
|
|
49
49
|
]));
|
|
50
50
|
|
|
51
51
|
const STATIC_RISK_CLASSES = Object.freeze({
|
|
@@ -77,6 +77,9 @@ const STATIC_RISK_CLASSES = Object.freeze({
|
|
|
77
77
|
"storage-migrate": INTEGRATION_RISK_CLASSES.MAINTENANCE,
|
|
78
78
|
"storage-backup": INTEGRATION_RISK_CLASSES.MAINTENANCE,
|
|
79
79
|
"storage-restore": INTEGRATION_RISK_CLASSES.MAINTENANCE,
|
|
80
|
+
"sync-push": INTEGRATION_RISK_CLASSES.MAINTENANCE,
|
|
81
|
+
"evidence-publish": INTEGRATION_RISK_CLASSES.MAINTENANCE,
|
|
82
|
+
"sync-pull": INTEGRATION_RISK_CLASSES.MAINTENANCE,
|
|
80
83
|
"storage-restore-resume": INTEGRATION_RISK_CLASSES.MAINTENANCE,
|
|
81
84
|
activate: INTEGRATION_RISK_CLASSES.MAINTENANCE,
|
|
82
85
|
"task-migrate": INTEGRATION_RISK_CLASSES.MAINTENANCE,
|