@aiwg/cli 2026.10.0 → 2026.10.3

package/dist/src/decision/index.js

@@ -53,6 +53,9 @@ export * from './sensitivity/index.js';
 export * from './issue-triage/index.js';
 export * from './routing/index.js';
 export * from './interop.js';
+export * from './ask.js';
+export * from './ledger.js';
+export * from './jev-credentials.js';
 export { collectHeldoutStudy, scoreHeldoutStudy } from './heldout/collector.js';
 export { heldoutDigest, heldoutExecutionDigest, planHeldoutCollection, validateHeldoutBundle, heldoutRowsInScope } from './heldout/contract.js';
 //# sourceMappingURL=index.js.map

package/dist/src/decision/interop.js

@@ -38,7 +38,8 @@ const FORBIDDEN_CONTROL_FIELDS = new Set([
     'calibration', 'executor', 'backend', 'acceptance', 'artifactPin', 'actionAuthorization',
 ]);
 const SENSITIVE_LOG_KEY = /(?:raw|body|secret|token|credential|private|locator|state|authorization|password|key)/iu;
-const SENSITIVE_LOG_VALUE = /(?:bearer\s+\S+|secret|token|file:\/\/|\/home\/|private|[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,})/iu;
+const SENSITIVE_LOG_VALUE = /(?:bearer\s+\S+|secret|token|file:\/\/|\/home\/|private)/iu;
+const MAX_LOG_VALUE_LENGTH = 65_536;
 const SUPPORTED_DMN_ELEMENTS = new Set(['definitions', 'decision', 'informationRequirement', 'requiredDecision', 'decisionTable', 'input', 'inputExpression', 'output', 'rule', 'inputEntry', 'outputEntry', 'text']);
 export function decisionInteropDefaultBounds(overrides = {}) {
     return { ...DEFAULT_BOUNDS, ...overrides };
@@ -580,7 +581,11 @@ function sanitizeJson(value, path, redaction) {
                 redaction.removed.push(`${path}.${key}`);
                 continue;
             }
-            result[key] = sanitizeJson(child, `${path}.${key}`, redaction);
+            // Keep ordinary objects while preserving __proto__ as an own JSON data key.
+            Object.defineProperty(result, key, {
+                value: sanitizeJson(child, `${path}.${key}`, redaction),
+                enumerable: true, writable: true, configurable: true,
+            });
         }
         return result;
     }
@@ -595,10 +600,16 @@ function projectOpaInput(input, allowlist, redaction) {
     for (const pointer of allowlist) {
         if (!pointer.startsWith('/'))
             throw new DecisionInteropError('opa-input-projection', 'OPA input projection allowlist entries must be JSON Pointers');
+        const path = pointer.slice(1).split('/').map(part => part.replace(/~1/gu, '/').replace(/~0/gu, '~'));
+        // Only __proto__ is forbidden in pointers; constructor/prototype are valid data keys.
+        // Own-property traversal and data-property writes keep ordinary projection objects safe.
+        if (path.some(segment => segment === '__proto__')) {
+            throw new DecisionInteropError('opa-input-projection', 'OPA input projection cannot contain __proto__ segments');
+        }
         const resolved = resolveJsonPointer(input, pointer);
         if (!resolved.found)
             continue;
-        setProjectedValue(output, pointer.slice(1).split('/').map(part => part.replace(/~1/gu, '/').replace(/~0/gu, '~')), sanitizeJson(resolved.value, `$.input${pointer}`, redaction));
+        setProjectedValue(output, path, sanitizeJson(resolved.value, `$.input${pointer}`, redaction));
     }
     return output;
 }
@@ -606,17 +617,58 @@ function setProjectedValue(target, path, value) {
     let cursor = target;
     path.forEach((segment, index) => {
         if (index === path.length - 1) {
-            cursor[segment] = value;
+            Object.defineProperty(cursor, segment, {
+                value, enumerable: true, writable: true, configurable: true,
+            });
             return;
         }
-        const existing = cursor[segment];
-        if (!existing || typeof existing !== 'object' || Array.isArray(existing))
-            cursor[segment] = {};
+        const existing = Object.hasOwn(cursor, segment) ? cursor[segment] : undefined;
+        if (!existing || typeof existing !== 'object' || Array.isArray(existing)) {
+            Object.defineProperty(cursor, segment, {
+                value: {}, enumerable: true, writable: true, configurable: true,
+            });
+        }
         cursor = cursor[segment];
     });
 }
 function isSensitiveValue(value) {
-    return typeof value === 'string' && SENSITIVE_LOG_VALUE.test(value);
+    if (typeof value !== 'string')
+        return false;
+    // Redact oversized values in full so a sensitive suffix cannot escape inspection.
+    if (value.length > MAX_LOG_VALUE_LENGTH)
+        return true;
+    if (SENSITIVE_LOG_VALUE.test(value))
+        return true;
+    let localLength = 0;
+    let domainLength = -1;
+    let suffixLength = -1;
+    for (const character of value) {
+        const letter = /[A-Z]/iu.test(character);
+        if (character === '@') {
+            domainLength = localLength > 0 ? 0 : -1;
+            suffixLength = -1;
+        }
+        else if (domainLength >= 0) {
+            if (/[A-Z0-9.-]/iu.test(character)) {
+                if (character === '.')
+                    suffixLength = domainLength > 0 ? 0 : -1;
+                else if (letter && suffixLength >= 0) {
+                    suffixLength++;
+                    if (suffixLength >= 2)
+                        return true;
+                }
+                else
+                    suffixLength = -1;
+                domainLength++;
+            }
+            else {
+                domainLength = -1;
+                suffixLength = -1;
+            }
+        }
+        localLength = /[A-Z0-9._%+-]/iu.test(character) ? localLength + 1 : 0;
+    }
+    return false;
 }
 function assertUnique(values, label) {
     const seen = new Set();

package/dist/src/decision/jev-credentials.js

@@ -0,0 +1,121 @@
+import { constants } from 'node:fs';
+import { access, chmod, mkdir, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { JevCredentialError } from './adapters/jev.js';
+export const JEV_CREDENTIAL_REF = 'typesafe-api';
+export const JEV_DEFAULT_REGION = 'us';
+function env(options) {
+    return options.env ?? process.env;
+}
+export function jevCredentialPath(options = {}) {
+    if (options.credentialPath)
+        return options.credentialPath;
+    const configuredHome = options.configHome ?? env(options).XDG_CONFIG_HOME;
+    const base = configuredHome && configuredHome.trim() ? configuredHome : path.join(options.homeDir ?? os.homedir(), '.config');
+    return path.join(base, 'aiwg', 'credentials', 'jev.json');
+}
+function isInsecureMode(mode) {
+    return (mode & 0o077) !== 0;
+}
+function parseRecord(raw) {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+        throw new JevCredentialError('configuration');
+    const record = parsed;
+    if (typeof record.token !== 'string' || !record.token.trim())
+        throw new JevCredentialError('configuration');
+    if (record.region !== undefined && (typeof record.region !== 'string' || !record.region.trim())) {
+        throw new JevCredentialError('configuration');
+    }
+    if (record.endpoint !== undefined && (typeof record.endpoint !== 'string' || !record.endpoint.trim())) {
+        throw new JevCredentialError('configuration');
+    }
+    if (record.enabled !== undefined && typeof record.enabled !== 'boolean')
+        throw new JevCredentialError('configuration');
+    return {
+        token: record.token,
+        region: typeof record.region === 'string' ? record.region : JEV_DEFAULT_REGION,
+        ...(typeof record.endpoint === 'string' ? { endpoint: record.endpoint } : {}),
+        ...(typeof record.enabled === 'boolean' ? { enabled: record.enabled } : {}),
+    };
+}
+async function readCredentialFile(options = {}) {
+    const credentialPath = jevCredentialPath(options);
+    try {
+        const [fileStat, parentStat] = await Promise.all([stat(credentialPath), stat(path.dirname(credentialPath))]);
+        if (isInsecureMode(fileStat.mode) || isInsecureMode(parentStat.mode))
+            throw new JevCredentialError('denied');
+        return parseRecord(await readFile(credentialPath, 'utf8'));
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        if (error instanceof JevCredentialError)
+            throw error;
+        if (error instanceof SyntaxError)
+            throw new JevCredentialError('configuration');
+        throw error;
+    }
+}
+export async function lookupJevCredential(options = {}) {
+    const environment = env(options);
+    const forced = environment.AIWG_DECISION_ENABLED;
+    const envToken = environment.JEV_API_KEY?.trim() || environment.AIWG_DECISION_JEV_API_KEY?.trim();
+    const fileRecord = envToken && (forced === '0' || forced === '1') ? null : await readCredentialFile(options);
+    const enabled = forced === '0' ? false : forced === '1' ? true : fileRecord?.enabled === true;
+    if (envToken)
+        return {
+            source: 'env',
+            token: envToken,
+            region: environment.AIWG_DECISION_JEV_REGION?.trim() || fileRecord?.region || JEV_DEFAULT_REGION,
+            ...(environment.AIWG_DECISION_JEV_ENDPOINT?.trim() ? { endpoint: environment.AIWG_DECISION_JEV_ENDPOINT.trim() }
+                : fileRecord?.endpoint ? { endpoint: fileRecord.endpoint } : {}),
+            enabled,
+        };
+    if (!fileRecord)
+        return null;
+    return { source: 'file', token: fileRecord.token, region: fileRecord.region, ...(fileRecord.endpoint ? { endpoint: fileRecord.endpoint } : {}), enabled };
+}
+export async function resolveJevCredentialBytes(logicalRef, options = {}) {
+    if (logicalRef !== JEV_CREDENTIAL_REF)
+        throw new JevCredentialError('configuration');
+    const credential = await lookupJevCredential(options);
+    if (!credential?.enabled)
+        throw new JevCredentialError('denied');
+    if (!credential.token)
+        throw new JevCredentialError('missing');
+    return new TextEncoder().encode(credential.token);
+}
+export async function writeJevCredentialFile(record, options = {}) {
+    const credentialPath = jevCredentialPath(options);
+    const directory = path.dirname(credentialPath);
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    await chmod(directory, 0o700);
+    const tmp = path.join(directory, `.jev.${process.pid}.${randomUUID()}.tmp`);
+    const body = `${JSON.stringify(record, null, 2)}\n`;
+    try {
+        await writeFile(tmp, body, { mode: 0o600, flag: 'wx' });
+        await chmod(tmp, 0o600);
+        await rename(tmp, credentialPath);
+        await chmod(credentialPath, 0o600);
+        return credentialPath;
+    }
+    catch (error) {
+        await rm(tmp, { force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+export async function removeJevCredentialFile(options = {}) {
+    const credentialPath = jevCredentialPath(options);
+    try {
+        await access(credentialPath, constants.F_OK);
+    }
+    catch {
+        return false;
+    }
+    await rm(credentialPath, { force: true });
+    return true;
+}
+//# sourceMappingURL=jev-credentials.js.map