@aiwg/cli 2026.8.27 → 2026.9.0

package/dist/src/governance/classification.js

@@ -0,0 +1,191 @@
+import { createHash, randomUUID } from 'node:crypto';
+export const BUILTIN_CLASSIFICATIONS = {
+    public: { rank: 0, description: 'Approved for unrestricted disclosure.' },
+    internal: { rank: 10, description: 'Routine non-public operational information.' },
+    confidential: { rank: 20, description: 'Sensitive business or operational information.' },
+    'restricted-infrastructure': { rank: 30, description: 'Topology, access path, recovery, or detailed infrastructure information.' },
+    'restricted-identity': { rank: 40, description: 'Named-user, identity-provider, authentication, or entitlement information.' },
+};
+export const SECURE_KIND_DEFAULTS = {
+    ITAsset: 'restricted-infrastructure',
+    ITService: 'restricted-infrastructure',
+    ITNetworkState: 'restricted-infrastructure',
+    OpsInventory: 'restricted-infrastructure',
+    OpsPlaybook: 'internal',
+    IncidentReport: 'confidential',
+    IdentityAudit: 'restricted-identity',
+    DREvidence: 'restricted-infrastructure',
+    RawAuditEvidence: 'restricted-infrastructure',
+};
+export const SECURE_CATEGORY_DEFAULTS = {
+    'raw-audit': 'restricted-infrastructure',
+    'identity-audit': 'restricted-identity',
+    'network-inventory': 'restricted-infrastructure',
+    'dr-evidence': 'restricted-infrastructure',
+    'sanitized-summary': 'internal',
+    generic: 'internal',
+};
+function stableId(value, label) {
+    if (!/^[a-z0-9][a-z0-9.-]{0,127}$/.test(value)) {
+        throw new Error(`${label} must be a lowercase stable identifier`);
+    }
+}
+export function resolveClassificationDefinitions(policy = {}) {
+    const classes = { ...BUILTIN_CLASSIFICATIONS };
+    for (const [id, definition] of Object.entries(policy.classes ?? {})) {
+        stableId(id, 'classification');
+        if (!Number.isSafeInteger(definition.rank) || definition.rank < 0 || definition.rank > 10_000) {
+            throw new Error(`classification '${id}' rank must be an integer from 0 through 10000`);
+        }
+        const builtin = BUILTIN_CLASSIFICATIONS[id];
+        if (builtin && builtin.rank !== definition.rank) {
+            throw new Error(`built-in classification '${id}' rank cannot be changed`);
+        }
+        classes[id] = { ...definition, ...(builtin ? { rank: builtin.rank } : {}) };
+    }
+    return classes;
+}
+function mergeHandling(parent, child) {
+    return {
+        ...(parent ?? {}),
+        ...(child ?? {}),
+        ...(child?.allowedSinks ? { allowedSinks: [...child.allowedSinks] } : parent?.allowedSinks ? { allowedSinks: [...parent.allowedSinks] } : {}),
+    };
+}
+/** Resolve explicit metadata, parent inheritance, secure kind/category defaults, then the policy default. */
+export function resolveArtifactGovernance(input) {
+    const policy = input.policy ?? {};
+    const definitions = resolveClassificationDefinitions(policy);
+    const explicitRequired = new Set(policy.requireExplicitForKinds ?? []);
+    if (explicitRequired.has(input.kind) && input.metadata?.classification === undefined) {
+        throw new Error(`artifact kind '${input.kind}' requires an explicit classification`);
+    }
+    const candidates = [
+        [input.metadata?.classification, 'artifact'],
+        [input.parent?.classification, 'parent'],
+        [policy.defaultsByKind?.[input.kind] ?? SECURE_KIND_DEFAULTS[input.kind], 'kind-default'],
+        [policy.defaultsByCategory?.[input.category] ?? SECURE_CATEGORY_DEFAULTS[input.category], 'category-default'],
+        [policy.defaultClassification ?? 'internal', 'policy-default'],
+    ];
+    const selected = candidates.find(([value]) => value !== undefined);
+    const classification = selected?.[0];
+    if (!classification || !definitions[classification]) {
+        throw new Error(`unknown or missing classification '${classification ?? '<missing>'}'`);
+    }
+    const handling = mergeHandling(input.parent?.handling, input.metadata?.handling);
+    for (const sink of handling.allowedSinks ?? [])
+        stableId(sink, 'allowed sink');
+    return {
+        classification,
+        classificationRank: definitions[classification].rank,
+        classificationSource: selected[1],
+        ...(input.metadata?.owner ?? input.parent?.owner ? { owner: input.metadata?.owner ?? input.parent?.owner } : {}),
+        handling,
+    };
+}
+function defaultSinkMaxRank(sink) {
+    switch (sink.visibility) {
+        case 'public': return BUILTIN_CLASSIFICATIONS.public.rank;
+        case 'private': return BUILTIN_CLASSIFICATIONS['restricted-infrastructure'].rank;
+        case 'restricted': return BUILTIN_CLASSIFICATIONS['restricted-identity'].rank;
+        case 'unknown': return null;
+    }
+}
+function approvalIsValid(approval, artifactId, sinkId, now) {
+    if (!approval)
+        return false;
+    if (!approval.id || !approval.actor || !approval.reason.trim())
+        return false;
+    if (approval.artifactId !== artifactId || approval.sinkId !== sinkId)
+        return false;
+    const approvedAt = Date.parse(approval.approvedAt);
+    if (!Number.isFinite(approvedAt) || approvedAt > now)
+        return false;
+    if (approval.expiresAt !== undefined) {
+        const expiresAt = Date.parse(approval.expiresAt);
+        if (!Number.isFinite(expiresAt) || expiresAt <= now || expiresAt <= approvedAt)
+            return false;
+    }
+    return true;
+}
+function reasonDigest(reason) {
+    return `sha256:${createHash('sha256').update(reason).digest('hex')}`;
+}
+function correlationDigest(value) {
+    return `sha256:${createHash('sha256').update(value).digest('hex')}`;
+}
+function safeArtifactKind(value) {
+    return /^[A-Za-z][A-Za-z0-9.-]{0,127}$/.test(value) ? value : correlationDigest(value);
+}
+/** Evaluate an artifact against a known sink before disclosure. Audit data never contains payload content. */
+export function evaluatePublicationGate(input) {
+    const occurredAt = (input.now ?? new Date()).toISOString();
+    const now = Date.parse(occurredAt);
+    const sinkId = input.sink?.id ?? 'unknown';
+    const reasons = [];
+    const sink = input.sink;
+    if (!sink || sink.visibility === 'unknown') {
+        reasons.push('unknown-sink-visibility');
+    }
+    else {
+        stableId(sink.id, 'sink');
+        if (input.governance.handling.allowedSinks && !input.governance.handling.allowedSinks.includes(sink.id)) {
+            reasons.push('sink-not-allowed');
+        }
+        const definitions = input.classes ?? resolveClassificationDefinitions();
+        const configuredMax = sink.maxClassification;
+        const maxRank = configuredMax === undefined
+            ? defaultSinkMaxRank(sink)
+            : definitions[configuredMax]?.rank;
+        if (maxRank === undefined || maxRank === null)
+            reasons.push('unknown-sink-classification-limit');
+        else if (input.governance.classificationRank > maxRank)
+            reasons.push('classification-exceeds-sink');
+        const crossRepo = Boolean(input.sourceRepository && sink.repository && input.sourceRepository !== sink.repository);
+        if (crossRepo && input.governance.handling.crossRepo === 'deny')
+            reasons.push('cross-repo-denied');
+        if (crossRepo && input.governance.handling.crossRepo === 'approval-required')
+            reasons.push('cross-repo-approval-required');
+    }
+    const validApproval = approvalIsValid(input.approval, input.artifactId, sinkId, now);
+    const overridableReasons = new Set(['classification-exceeds-sink', 'cross-repo-approval-required']);
+    const approvalCoversReasons = reasons.length > 0 && reasons.every((reason) => overridableReasons.has(reason));
+    let decision;
+    if (reasons.length === 0)
+        decision = 'allow';
+    else if (validApproval && approvalCoversReasons && sink && sink.visibility !== 'unknown')
+        decision = 'override';
+    else if (sink?.acceptsSanitizedSummary)
+        decision = 'summarize';
+    else
+        decision = 'deny';
+    const audit = {
+        schemaVersion: 'ops-publication-decision.aiwg.io/v1',
+        eventId: randomUUID(),
+        occurredAt,
+        artifactId: correlationDigest(input.artifactId),
+        artifactKind: safeArtifactKind(input.artifactKind),
+        classification: input.governance.classification,
+        sinkId,
+        decision,
+        reasonCodes: [...reasons].sort(),
+        ...(decision === 'override' && input.approval ? {
+            approvalId: input.approval.id,
+            approvalActor: input.approval.actor,
+            approvalReasonDigest: reasonDigest(input.approval.reason),
+        } : {}),
+    };
+    return { decision, allowed: decision === 'allow' || decision === 'override', reasonCodes: audit.reasonCodes, audit };
+}
+/** Produce a payload-free summary suitable for a second, separately gated publication attempt. */
+export function createSanitizedSummary(input) {
+    return {
+        schemaVersion: 'ops-sanitized-summary.aiwg.io/v1',
+        artifactFingerprint: `sha256:${createHash('sha256').update(input.artifactId).digest('hex')}`,
+        artifactKind: input.artifactKind,
+        ...(input.status ? { status: input.status } : {}),
+        omittedFields: input.omittedFields,
+        redactionClasses: [...new Set(input.redactionClasses)].sort(),
+    };
+}
+//# sourceMappingURL=classification.js.map

package/dist/src/governance/index.js

@@ -0,0 +1,5 @@
+export * from './redaction.js';
+export * from './classification.js';
+export * from './retention.js';
+export * from './boundary.js';
+//# sourceMappingURL=index.js.map

package/dist/src/governance/redaction.js

@@ -0,0 +1,324 @@
+import { createHmac } from 'node:crypto';
+import { Transform } from 'node:stream';
+import { TextDecoder } from 'node:util';
+export class RedactionError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'RedactionError';
+    }
+}
+const DEFAULT_LIMITS = {
+    maxInputBytes: 8 * 1024 * 1024,
+    maxDepth: 32,
+    maxNodes: 100_000,
+    maxObjectKeys: 10_000,
+    maxArrayItems: 100_000,
+};
+const BUILTIN_SENSITIVE_KEY = /(?:^|[_-])(?:authorization|auth[_-]?header|cookie|set[_-]?cookie|credential|password|passwd|secret|token|api[_-]?key|private[_-]?key|connection[_-]?string|client[_-]?secret)(?:$|[_-])/i;
+const BUILTIN_PATTERNS = [
+    {
+        id: 'private-key',
+        pattern: /-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY-----/g,
+    },
+    {
+        id: 'authorization-header',
+        pattern: /(\bAuthorization\s*:\s*)([^\r\n]+)/gi,
+        preservePrefix: true,
+    },
+    {
+        id: 'cookie-header',
+        pattern: /(\b(?:Cookie|Set-Cookie)\s*:\s*)([^\r\n]+)/gi,
+        preservePrefix: true,
+    },
+    {
+        id: 'url-query-secret',
+        pattern: /([?&](?:access[_-]?token|refresh[_-]?token|api[_-]?key|token|secret|password|passwd|signature|sig)=)([^&#\s]+)/gi,
+        preservePrefix: true,
+    },
+    {
+        id: 'sensitive-assignment',
+        pattern: /((?:^|[\s,{])["']?(?:api[_-]?key|access[_-]?token|refresh[_-]?token|token|password|passwd|secret|client[_-]?secret|credential)["']?\s*(?:[:=]|\s+)\s*")([^"\r\n]*)(")/gim,
+        preservePrefix: true,
+        preserveSuffix: true,
+    },
+    {
+        id: 'sensitive-assignment',
+        pattern: /((?:^|[\s,{])["']?(?:api[_-]?key|access[_-]?token|refresh[_-]?token|token|password|passwd|secret|client[_-]?secret|credential)["']?\s*(?:[:=]|\s+)\s*')([^'\r\n]*)(')/gim,
+        preservePrefix: true,
+        preserveSuffix: true,
+    },
+    {
+        id: 'sensitive-assignment',
+        pattern: /((?:^|[\s,{])["']?(?:api[_-]?key|access[_-]?token|refresh[_-]?token|token|password|passwd|secret|client[_-]?secret|credential)["']?\s*(?:[:=]|\s+)\s*)([^\s"',;}\]]{4,})/gim,
+        preservePrefix: true,
+    },
+    {
+        id: 'environment-secret',
+        pattern: /(\b[A-Z][A-Z0-9_]*(?:TOKEN|SECRET|PASSWORD|PASSWD|API_KEY|PRIVATE_KEY)\s*=\s*)(?:"[^"]+"|'[^']+'|[^\s]+)/g,
+        preservePrefix: true,
+    },
+    {
+        id: 'provider-token',
+        pattern: /\b(?:sk-(?:proj-)?|gh[pousr]_|github_pat_|xox[baprs]-|AKIA)[A-Za-z0-9._~+/=-]{6,}\b/g,
+    },
+    {
+        id: 'bearer-token',
+        pattern: /(\bBearer\s+)([A-Za-z0-9._~+/=-]{6,})\b/gi,
+        preservePrefix: true,
+    },
+    {
+        id: 'connection-string',
+        pattern: /\b(?:postgres(?:ql)?|mysql|mongodb(?:\+srv)?|redis|amqps?):\/\/[^\s"'<>]+/gi,
+    },
+    {
+        id: 'url-userinfo',
+        pattern: /(https?:\/\/[^/\s:@]+:)([^/\s@]+)(@[^\s"'<>]+)/gi,
+    },
+];
+function resolvedLimits(options) {
+    const limits = { ...DEFAULT_LIMITS, ...(options.limits ?? {}) };
+    for (const [name, value] of Object.entries(limits)) {
+        if (!Number.isSafeInteger(value) || value < 1) {
+            throw new RedactionError('LIMIT_EXCEEDED', `${name} must be a positive safe integer`);
+        }
+    }
+    return limits;
+}
+function validatePatternSource(pattern) {
+    if (!/^[a-z0-9][a-z0-9-]{0,63}$/.test(pattern.id)) {
+        throw new RedactionError('INVALID_PATTERN', 'organization redaction pattern IDs must be lowercase stable identifiers');
+    }
+    if (pattern.pattern.length === 0 || pattern.pattern.length > 512) {
+        throw new RedactionError('INVALID_PATTERN', `organization pattern '${pattern.id}' must contain 1-512 characters`);
+    }
+    if (/\\[1-9]|\(\?<[=!]|\([^)]*[+*][^)]*\)[+*{]/.test(pattern.pattern)) {
+        throw new RedactionError('INVALID_PATTERN', `organization pattern '${pattern.id}' uses a disallowed high-risk construct`);
+    }
+    const requestedFlags = pattern.flags ?? 'g';
+    if (/[^gimsuy]/.test(requestedFlags)) {
+        throw new RedactionError('INVALID_PATTERN', `organization pattern '${pattern.id}' has unsupported flags`);
+    }
+    const flags = requestedFlags.includes('g') ? requestedFlags : `${requestedFlags}g`;
+    try {
+        return new RegExp(pattern.pattern, flags);
+    }
+    catch {
+        throw new RedactionError('INVALID_PATTERN', `organization pattern '${pattern.id}' is not a valid regular expression`);
+    }
+}
+function fingerprint(value, key) {
+    if (key === undefined)
+        return undefined;
+    return `hmac-sha256:${createHmac('sha256', key).update(value).digest('hex').slice(0, 16)}`;
+}
+function marker(classification, value, options) {
+    const length = Buffer.byteLength(value);
+    const valueFingerprint = fingerprint(value, options.fingerprintKey);
+    const attributes = [
+        options.includeLength === false ? null : `len=${length}`,
+        valueFingerprint ? `fp=${valueFingerprint}` : null,
+    ].filter((part) => part !== null);
+    return {
+        marker: `[REDACTED:${classification}${attributes.length ? `;${attributes.join(';')}` : ''}]`,
+        finding: {
+            class: classification,
+            ...(options.includeLength === false ? {} : { length }),
+            ...(valueFingerprint ? { fingerprint: valueFingerprint } : {}),
+        },
+    };
+}
+function applyPattern(input, definition, options, findings) {
+    definition.pattern.lastIndex = 0;
+    return input.replace(definition.pattern, (...args) => {
+        const full = String(args[0]);
+        if (definition.id === 'url-userinfo') {
+            const prefix = String(args[1]);
+            const secret = String(args[2]);
+            const suffix = String(args[3]);
+            const redacted = marker(definition.id, secret, options);
+            findings.push(redacted.finding);
+            return `${prefix}${redacted.marker}${suffix}`;
+        }
+        if (definition.preservePrefix) {
+            const prefix = String(args[1]);
+            const secret = String(args[2] ?? full.slice(prefix.length));
+            if (secret.startsWith('[REDACTED:'))
+                return full;
+            const redacted = marker(definition.id, secret, options);
+            findings.push(redacted.finding);
+            const suffix = definition.preserveSuffix ? String(args[3] ?? '') : '';
+            return `${prefix}${redacted.marker}${suffix}`;
+        }
+        const redacted = marker(definition.id, full, options);
+        findings.push(redacted.finding);
+        return redacted.marker;
+    });
+}
+function decodedSecretClass(value) {
+    if (value.length < 24 || value.length > 16 * 1024 || value.length % 4 === 1)
+        return null;
+    try {
+        const decoded = Buffer.from(value, 'base64').toString('utf8');
+        if (!decoded || decoded.includes('\uFFFD'))
+            return null;
+        if (/-----BEGIN (?:RSA |EC |DSA |OPENSSH |PGP )?PRIVATE KEY-----/.test(decoded))
+            return 'encoded-private-key';
+        if (/(?:api[_-]?key|token|password|passwd|secret|authorization)\s*[:=]/i.test(decoded))
+            return 'encoded-secret';
+        if (/(?:sk-(?:proj-)?|gh[pousr]_|github_pat_|xox[baprs]-|AKIA)[A-Za-z0-9._~+/=-]{6,}/.test(decoded))
+            return 'encoded-secret';
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Redact secret-bearing values from a complete text value. */
+export function redactText(input, options = {}) {
+    const limits = resolvedLimits(options);
+    if (Buffer.byteLength(input) > limits.maxInputBytes) {
+        throw new RedactionError('LIMIT_EXCEEDED', 'text exceeds the configured redaction byte limit');
+    }
+    const findings = [];
+    let text = input;
+    for (const definition of BUILTIN_PATTERNS) {
+        text = applyPattern(text, definition, options, findings);
+    }
+    for (const configured of options.organizationPatterns ?? []) {
+        const definition = {
+            id: `organization-${configured.id}`,
+            pattern: validatePatternSource(configured),
+        };
+        text = applyPattern(text, definition, options, findings);
+    }
+    text = text.replace(/\b[A-Za-z0-9+/]{24,}={0,2}\b/g, (candidate) => {
+        const classification = decodedSecretClass(candidate);
+        if (!classification)
+            return candidate;
+        const redacted = marker(classification, candidate, options);
+        findings.push(redacted.finding);
+        return redacted.marker;
+    });
+    return { text, sensitivity: findings.length ? 'sensitive' : 'none', findings };
+}
+function sensitiveKey(key, options) {
+    if (BUILTIN_SENSITIVE_KEY.test(key))
+        return true;
+    let matched = false;
+    for (const source of options.sensitiveKeyPatterns ?? []) {
+        if (source.length === 0 || source.length > 256) {
+            throw new RedactionError('INVALID_PATTERN', 'sensitive key patterns must contain 1-256 characters');
+        }
+        try {
+            if (new RegExp(source, 'i').test(key))
+                matched = true;
+        }
+        catch {
+            throw new RedactionError('INVALID_PATTERN', 'a sensitive key pattern is not a valid regular expression');
+        }
+    }
+    return matched;
+}
+/** Recursively redact nested JSON/YAML-compatible values while preserving shape and field names. */
+export function redactStructured(input, options = {}) {
+    const limits = resolvedLimits(options);
+    const findings = [];
+    const active = new WeakSet();
+    let nodes = 0;
+    const visit = (value, path, depth, key) => {
+        nodes += 1;
+        if (nodes > limits.maxNodes || depth > limits.maxDepth) {
+            throw new RedactionError('LIMIT_EXCEEDED', 'structured value exceeds configured redaction traversal limits');
+        }
+        if (key !== undefined && sensitiveKey(key, options)) {
+            const serialized = typeof value === 'string' ? value : JSON.stringify(value);
+            const redacted = marker('sensitive-field', serialized ?? String(value), options);
+            findings.push({ ...redacted.finding, path });
+            return redacted.marker;
+        }
+        if (value === null || typeof value === 'boolean' || typeof value === 'number')
+            return value;
+        if (typeof value === 'bigint')
+            return String(value);
+        if (typeof value === 'string') {
+            const redacted = redactText(value, options);
+            findings.push(...redacted.findings.map((finding) => ({ ...finding, path })));
+            return redacted.text;
+        }
+        if (typeof value !== 'object') {
+            throw new RedactionError('UNSUPPORTED_VALUE', `unsupported structured value at ${path}`);
+        }
+        if (active.has(value))
+            throw new RedactionError('UNSUPPORTED_VALUE', `circular structured value at ${path}`);
+        active.add(value);
+        try {
+            if (Array.isArray(value)) {
+                if (value.length > limits.maxArrayItems) {
+                    throw new RedactionError('LIMIT_EXCEEDED', `array exceeds configured item limit at ${path}`);
+                }
+                return value.map((item, index) => visit(item, `${path}/${index}`, depth + 1));
+            }
+            const entries = Object.entries(value);
+            if (entries.length > limits.maxObjectKeys) {
+                throw new RedactionError('LIMIT_EXCEEDED', `object exceeds configured key limit at ${path}`);
+            }
+            return Object.fromEntries(entries.map(([childKey, child]) => [
+                childKey,
+                visit(child, `${path}/${childKey.replaceAll('~', '~0').replaceAll('/', '~1')}`, depth + 1, childKey),
+            ]));
+        }
+        finally {
+            active.delete(value);
+        }
+    };
+    const value = visit(input, '', 0);
+    return { value, sensitivity: findings.length ? 'sensitive' : 'none', findings };
+}
+/**
+ * A bounded streaming interface. It buffers one logical output value and emits
+ * only after full-value sanitization, so secrets split across chunks cannot
+ * escape. Exceeding the configured limit fails without emitting partial data.
+ */
+export class RedactionTransform extends Transform {
+    options;
+    chunks = [];
+    bytes = 0;
+    limits;
+    constructor(options = {}) {
+        super();
+        this.options = options;
+        this.limits = resolvedLimits(options);
+    }
+    _transform(chunk, encoding, callback) {
+        const value = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
+        this.bytes += value.length;
+        if (this.bytes > this.limits.maxInputBytes) {
+            callback(new RedactionError('LIMIT_EXCEEDED', 'stream exceeds the configured redaction byte limit'));
+            return;
+        }
+        this.chunks.push(value);
+        callback();
+    }
+    _flush(callback) {
+        try {
+            let source;
+            try {
+                source = new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(this.chunks));
+            }
+            catch {
+                throw new RedactionError('INVALID_UTF8', 'stream is not valid UTF-8');
+            }
+            this.push(redactText(source, this.options).text);
+            callback();
+        }
+        catch (error) {
+            callback(error);
+        }
+    }
+}
+export function createRedactionTransform(options = {}) {
+    return new RedactionTransform(options);
+}
+//# sourceMappingURL=redaction.js.map