@westbayberry/dg 2.0.11 → 2.2.0

package/dist/launcher/run.js

@@ -4,40 +4,26 @@ import { constants as osConstants } from "node:os";
 import { fileURLToPath } from "node:url";
 import { EXIT_UNAVAILABLE } from "../commands/types.js";
 import { loadUserConfig } from "../config/settings.js";
+import { findProjectRoot, loadDgFile } from "../project/dgfile.js";
+import { writeCooldownExemptionsFile } from "../proxy/cooldown-exemptions-file.js";
+import { writePreverifiedFile } from "../proxy/preverified.js";
 import { describeBlockedInstall, describeFlaggedWarn, renderInstallDecision } from "../install-ui/block-render.js";
 import { enforceProtectedInstall } from "../proxy/enforcement.js";
 import { isCiEnv, resolvePresentation } from "../presentation/mode.js";
+import { maybeSetupNudge } from "../runtime/nudges.js";
 import { createTheme } from "../presentation/theme.js";
 import { readProxySessionState } from "../proxy/server.js";
 import { cleanupSessionSync, createSessionSync, resolveDgPaths } from "../state/index.js";
 import { classifyPackageManagerInvocation } from "./classify.js";
 import { buildProxyChildEnv } from "./env.js";
+import { prepareCargoHome, userCargoHome } from "./cargo-cache.js";
 import { cachedPipResolution } from "./install-preflight.js";
-import { parsePipReportInstallCount } from "./pip-report.js";
 import { createStreamRedactor, redactSecrets } from "./output-redaction.js";
+import { resolveSpawnInvocation } from "./spawn-invocation.js";
 import { resolveRealBinary } from "./resolve-real-binary.js";
+import { runScriptGateAfterInstall } from "../scripts/gate.js";
 export const EXIT_INSTALL_BLOCKED = 2;
-const CMD_SCRIPT_PATTERN = /\.(cmd|bat)$/i;
-const CMD_META_CHARS = /([()\][%!^"`<>&|;, *?])/g;
-export function resolveSpawnInvocation(binary, args, platform = process.platform) {
-    if (platform !== "win32" || !CMD_SCRIPT_PATTERN.test(binary)) {
-        return { command: binary, args, windowsVerbatimArguments: false };
-    }
-    const commandLine = [escapeCmdCommand(binary), ...args.map(escapeCmdArgument)].join(" ");
-    return {
-        command: process.env.comspec ?? "cmd.exe",
-        args: ["/d", "/s", "/c", `"${commandLine}"`],
-        windowsVerbatimArguments: true
-    };
-}
-function escapeCmdCommand(command) {
-    return command.replace(CMD_META_CHARS, "^$1");
-}
-// cmd shims parse their command line twice, hence the doubled meta-char escape (cross-spawn's algorithm)
-function escapeCmdArgument(argument) {
-    const quoted = `"${argument.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\*)$/, "$1$1")}"`;
-    return quoted.replace(CMD_META_CHARS, "^$1").replace(CMD_META_CHARS, "^$1");
-}
+export { resolveSpawnInvocation } from "./spawn-invocation.js";
 export function shimDepth(env) {
     const parsed = Number.parseInt(env.DG_SHIM_DEPTH ?? "", 10);
     return Number.isInteger(parsed) && parsed > 0 ? parsed : 0;
@@ -129,7 +115,7 @@ export async function runPackageManager(manager, args, options = {}) {
         return {
             exitCode: child.exitCode,
             stdout: streamedOut(child.stdout, options),
-            stderr: `${rendered}${streamedErr(child.stderr, options)}`
+            stderr: `${rendered}${streamedErr(child.stderr, options)}${scriptGateLine(plan, child.exitCode, options)}${setupNudgeAfterInstall(plan, child.exitCode, options)}`
         };
     }
     const child = await spawnPackageManager(plan, args, options);
@@ -151,6 +137,7 @@ async function runWithProductionProxy(plan, args, options) {
     }
     const restoreSignalHandlers = installProxySignalHandlers(proxy);
     try {
+        const cacheDir = prepareProxyCacheDir(plan.classification.manager, proxy.session.dir, env);
         const proxiedPlan = {
             ...plan,
             childEnv: buildProxyChildEnv({
@@ -158,7 +145,7 @@ async function runWithProductionProxy(plan, args, options) {
                 baseEnv: plan.childEnv,
                 proxyUrl: proxy.proxyUrl,
                 caBundlePath: proxy.session.files.ca,
-                cacheDir: `${proxy.session.dir}/pm-cache`
+                cacheDir
             })
         };
         const child = await spawnPackageManager(proxiedPlan, args, options);
@@ -195,7 +182,7 @@ async function runWithProductionProxy(plan, args, options) {
         return {
             exitCode: child.exitCode,
             stdout: streamedOut(child.stdout, options),
-            stderr: `${rendered}${streamedErr(child.stderr, options)}`
+            stderr: `${rendered}${streamedErr(child.stderr, options)}${scriptGateLine(plan, child.exitCode, options)}${setupNudgeAfterInstall(plan, child.exitCode, options)}`
         };
     }
     finally {
@@ -203,6 +190,22 @@ async function runWithProductionProxy(plan, args, options) {
         stopProxyWorker(proxy);
     }
 }
+function scriptGateLine(plan, exitCode, options) {
+    if (exitCode !== 0) {
+        return "";
+    }
+    return runScriptGateAfterInstall({
+        classification: plan.classification,
+        env: options.env ?? process.env,
+        ...(options.projectDir ? { projectDir: options.projectDir } : {})
+    });
+}
+function setupNudgeAfterInstall(plan, exitCode, options) {
+    if (exitCode !== 0) {
+        return "";
+    }
+    return maybeSetupNudge(plan.classification.manager, { env: options.env ?? process.env });
+}
 export function deriveLiveView(state, phase, resolvedTotal) {
     const verified = state.decisions.filter((decision) => decision.action === "pass").length;
     const warnDecisions = state.decisions.filter((decision) => decision.action === "warn");
@@ -221,57 +224,43 @@ export function deriveLiveView(state, phase, resolvedTotal) {
         ...(blocked ? { blocked: describeBlockedInstall(blocked) } : {})
     };
 }
-function resolvePipInstallTotal(binary, args, env, register) {
-    if (!binary)
-        return Promise.resolve(undefined);
-    return new Promise((resolve) => {
-        let stdout = "";
-        let settled = false;
-        let timer;
-        const finish = (value) => {
-            if (settled)
+export function prepareProxyWorker(classification, env) {
+    const worker = startProxyWorker(classification, env, undefined);
+    let discarded = false;
+    return {
+        worker,
+        discard: () => {
+            if (discarded) {
                 return;
-            settled = true;
-            if (timer)
-                clearTimeout(timer);
-            resolve(value);
-        };
-        let child;
-        try {
-            const invocation = resolveSpawnInvocation(binary, [...args, "--dry-run", "--report", "-", "--quiet"]);
-            child = spawn(invocation.command, [...invocation.args], {
-                env,
-                stdio: ["ignore", "pipe", "ignore"],
-                windowsVerbatimArguments: invocation.windowsVerbatimArguments
+            }
+            discarded = true;
+            void worker.then((proxy) => {
+                if (!("decision" in proxy)) {
+                    stopProxyWorker(proxy);
+                }
             });
         }
-        catch {
-            finish(undefined);
-            return;
-        }
-        register(child);
-        timer = setTimeout(() => {
-            try {
-                child.kill();
-            }
-            catch { /* already exited */ }
-            finish(undefined);
-        }, 30_000);
-        child.stdout?.on("data", (chunk) => { stdout += chunk.toString("utf8"); });
-        child.on("error", () => finish(undefined));
-        child.on("close", (code) => finish(code === 0 ? parsePipReportInstallCount(stdout) : undefined));
-    });
+    };
 }
-export async function runWithProductionProxyLive(plan, args, options, onView) {
+export async function runWithProductionProxyLive(plan, args, options, onView, prepared) {
     if (options.onStdout || options.onStderr) {
         throw new Error("live install mode renders its own UI and owns the terminal; streaming output callbacks are not supported");
     }
     const env = options.env ?? process.env;
     maybeWarnRootWithoutState(env);
-    const proxy = await startProxyWorker(plan.classification, env, options.forceOverride);
+    if (prepared && options.forceOverride) {
+        prepared.discard();
+        prepared = undefined;
+    }
+    const proxy = prepared
+        ? await prepared.worker
+        : await startProxyWorker(plan.classification, env, options.forceOverride);
     if ("decision" in proxy) {
         return { exitCode: EXIT_INSTALL_BLOCKED, stdout: "", stderr: redactSecrets(renderInstallDecision(proxy.decision)) };
     }
+    if (options.preverified && options.preverified.length > 0) {
+        writePreverifiedFile(proxy.session.dir, options.preverified);
+    }
     const restoreSignalHandlers = installProxySignalHandlers(proxy);
     try {
         const childEnv = buildProxyChildEnv({
@@ -279,22 +268,10 @@ export async function runWithProductionProxyLive(plan, args, options, onView) {
             baseEnv: plan.childEnv,
             proxyUrl: proxy.proxyUrl,
             caBundlePath: proxy.session.files.ca,
-            cacheDir: `${proxy.session.dir}/pm-cache`
+            cacheDir: prepareProxyCacheDir(plan.classification.manager, proxy.session.dir, env)
         });
         const spawner = options.spawner ?? defaultSpawner;
-        let resolvedTotal;
-        let dryRunChild;
-        if (plan.classification.manager === "pip") {
-            const cached = cachedPipResolution(plan.realBinary.path ?? "", args);
-            if (cached) {
-                resolvedTotal = cached.count;
-            }
-            else {
-                void resolvePipInstallTotal(plan.realBinary.path ?? "", args, childEnv, (child) => { dryRunChild = child; })
-                    .then((count) => { resolvedTotal = count; })
-                    .catch(() => undefined);
-            }
-        }
+        const resolvedTotal = plan.classification.manager === "pip" ? cachedPipResolution(plan.realBinary.path ?? "", args)?.count : undefined;
         const poll = setInterval(() => {
             onView(deriveLiveView(readProxySessionState(proxy.session), "scanning", resolvedTotal));
         }, 90);
@@ -308,12 +285,6 @@ export async function runWithProductionProxyLive(plan, args, options, onView) {
         }
         finally {
             clearInterval(poll);
-            if (dryRunChild) {
-                try {
-                    dryRunChild.kill();
-                }
-                catch { /* already exited */ }
-            }
         }
         const proxyState = readProxySessionState(proxy.session);
         onView(deriveLiveView(proxyState, "done", resolvedTotal));
@@ -331,13 +302,20 @@ export async function runWithProductionProxyLive(plan, args, options, onView) {
             const outcome = installOutcome(finished.stdout);
             return { exitCode: EXIT_INSTALL_BLOCKED, stdout: outcome, stderr: cacheOnlyNotice(outcome.length > 0) };
         }
-        return { exitCode: finished.exitCode, stdout: installOutcome(finished.stdout), stderr: "" };
+        return { exitCode: finished.exitCode, stdout: installOutcome(finished.stdout), stderr: `${scriptGateLine(plan, finished.exitCode, options)}${setupNudgeAfterInstall(plan, finished.exitCode, options)}` };
     }
     finally {
         restoreSignalHandlers();
         stopProxyWorker(proxy);
     }
 }
+function prepareProxyCacheDir(manager, sessionDir, env) {
+    const cacheDir = `${sessionDir}/pm-cache`;
+    if (manager === "cargo") {
+        prepareCargoHome(cacheDir, userCargoHome(env));
+    }
+    return cacheDir;
+}
 function cacheOnlyNotice(installedFresh) {
     const theme = createTheme(resolvePresentation().color);
     const reason = installedFresh ? "used a saved copy" : "already installed";
@@ -425,6 +403,38 @@ function renderDecisions(decisions, env) {
     const visible = isCiEnv(env) ? decisions.filter((decision) => decision.action !== "pass") : decisions;
     return visible.map((decision) => redactSecrets(renderInstallDecision(decision))).join("");
 }
+export function loadProjectCooldownExemptions(env, cwd = process.cwd()) {
+    try {
+        const root = findProjectRoot(cwd, env);
+        if (!root) {
+            return [];
+        }
+        const file = loadDgFile(root);
+        return file.readable ? file.cooldownExemptions : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function dgFileExemptionsNotice(exemptions) {
+    if (exemptions.length === 0) {
+        return "";
+    }
+    const plural = exemptions.length === 1 ? "exemption" : "exemptions";
+    return `dg: applying ${exemptions.length} cooldown ${plural} from this project's dg.json\n`;
+}
+let dgFileExemptionNoticeWritten = false;
+function maybeNoticeDgFileExemptions(exemptions) {
+    if (dgFileExemptionNoticeWritten) {
+        return;
+    }
+    const notice = dgFileExemptionsNotice(exemptions);
+    if (!notice) {
+        return;
+    }
+    dgFileExemptionNoticeWritten = true;
+    process.stderr.write(notice);
+}
 async function startProxyWorker(classification, env, forceOverride) {
     const paths = resolveDgPaths(env);
     const session = createSessionSync(paths);
@@ -439,11 +449,15 @@ async function startProxyWorker(classification, env, forceOverride) {
             throw new Error("production proxy worker is not built");
         }
         const config = loadUserConfig(env);
+        const exemptions = loadProjectCooldownExemptions(env);
+        maybeNoticeDgFileExemptions(exemptions);
+        const exemptionsEnv = writeCooldownExemptionsFile(session.dir, exemptions);
         const child = spawn(process.execPath, [workerPath, sessionBootstrapPath, config.api.baseUrl], {
             env: {
                 ...env,
                 DG_PROXY_CLASSIFICATION: JSON.stringify(classification),
-                ...(forceOverride ? { DG_FORCE_OVERRIDE_REQUEST: JSON.stringify(forceOverride) } : {})
+                ...(forceOverride ? { DG_FORCE_OVERRIDE_REQUEST: JSON.stringify(forceOverride) } : {}),
+                ...exemptionsEnv
             },
             stdio: ["pipe", "pipe", "pipe"]
         });

package/dist/launcher/spawn-invocation.js

@@ -0,0 +1,21 @@
+const CMD_SCRIPT_PATTERN = /\.(cmd|bat)$/i;
+const CMD_META_CHARS = /([()\][%!^"`<>&|;, *?])/g;
+export function resolveSpawnInvocation(binary, args, platform = process.platform) {
+    if (platform !== "win32" || !CMD_SCRIPT_PATTERN.test(binary)) {
+        return { command: binary, args, windowsVerbatimArguments: false };
+    }
+    const commandLine = [escapeCmdCommand(binary), ...args.map(escapeCmdArgument)].join(" ");
+    return {
+        command: process.env.comspec ?? "cmd.exe",
+        args: ["/d", "/s", "/c", `"${commandLine}"`],
+        windowsVerbatimArguments: true
+    };
+}
+function escapeCmdCommand(command) {
+    return command.replace(CMD_META_CHARS, "^$1");
+}
+// cmd shims parse their command line twice, hence the doubled meta-char escape (cross-spawn's algorithm)
+function escapeCmdArgument(argument) {
+    const quoted = `"${argument.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\*)$/, "$1$1")}"`;
+    return quoted.replace(CMD_META_CHARS, "^$1").replace(CMD_META_CHARS, "^$1");
+}

package/dist/policy/cooldown.js

@@ -0,0 +1,117 @@
+import { parseCooldownAge } from "../config/settings.js";
+import { cooldownExemptionActive } from "../project/dgfile.js";
+import { canonicalCooldownName, normalizePypiName } from "./pypi-name.js";
+export { normalizePypiName };
+export function durationToDays(value) {
+    const trimmed = value.trim();
+    if (trimmed === "" || trimmed === "0" || trimmed === "off") {
+        return 0;
+    }
+    const match = /^([1-9]\d{0,3})(h|d)$/.exec(trimmed);
+    if (!match || !match[1] || !match[2]) {
+        return 0;
+    }
+    const amount = Number.parseInt(match[1], 10);
+    return match[2] === "h" ? amount / 24 : amount;
+}
+export function effectiveCooldownAge(config, env, ecosystem) {
+    const fromEnv = env.DG_COOLDOWN_AGE;
+    if (fromEnv !== undefined) {
+        try {
+            return parseCooldownAge(fromEnv, "DG_COOLDOWN_AGE", false);
+        }
+        catch {
+            // fall through to config: a malformed env override must not change policy
+        }
+    }
+    const perEcosystem = ecosystem === "npm"
+        ? config.cooldown.npmAge
+        : ecosystem === "pypi"
+            ? config.cooldown.pypiAge
+            : config.cooldown.cargoAge;
+    return perEcosystem !== "" ? perEcosystem : config.cooldown.age;
+}
+export function isCooldownExempt(packageName, exempt, ecosystem) {
+    const name = ecosystem ? canonicalCooldownName(ecosystem, packageName) : packageName;
+    return exempt
+        .split(",")
+        .map((entry) => entry.trim())
+        .filter(Boolean)
+        .some((pattern) => {
+        const candidate = ecosystem ? canonicalCooldownName(ecosystem, pattern) : pattern;
+        if (candidate.endsWith("*")) {
+            return name.startsWith(candidate.slice(0, -1));
+        }
+        return name === candidate;
+    });
+}
+export function isCooldownExemptByDgFile(packageName, ecosystem, exemptions, now = new Date()) {
+    if (ecosystem !== "npm" && ecosystem !== "pypi" && ecosystem !== "cargo") {
+        return false;
+    }
+    const target = canonicalCooldownName(ecosystem, packageName);
+    return exemptions.some((e) => {
+        if (e.ecosystem !== ecosystem) {
+            return false;
+        }
+        const candidate = canonicalCooldownName(ecosystem, e.name);
+        return candidate === target && cooldownExemptionActive(e, now);
+    });
+}
+export function cooldownRequestParam(config, env, ecosystem, packageName) {
+    const minAgeDays = durationToDays(effectiveCooldownAge(config, env, ecosystem));
+    if (minAgeDays <= 0) {
+        return undefined;
+    }
+    if (packageName && isCooldownExempt(packageName, config.cooldown.exempt, ecosystem)) {
+        return undefined;
+    }
+    return { minAgeDays, onUnknown: config.cooldown.onUnknown };
+}
+export function formatCooldownDuration(days) {
+    const hours = days * 24;
+    if (hours <= 0) {
+        return "0h";
+    }
+    if (hours < 48) {
+        return `${Math.round(hours)}h`;
+    }
+    return `${Math.floor(days)}d`;
+}
+export function formatPackageAge(ageDays) {
+    if (ageDays < 0) {
+        return "in the future";
+    }
+    const hours = ageDays * 24;
+    if (hours < 1) {
+        return "<1h ago";
+    }
+    if (hours < 48) {
+        return `${Math.floor(hours)}h ago`;
+    }
+    return `${Math.floor(ageDays)}d ago`;
+}
+export function describeCooldownSettings(config, env) {
+    if (env.DG_COOLDOWN_AGE !== undefined) {
+        try {
+            const envDays = durationToDays(parseCooldownAge(env.DG_COOLDOWN_AGE, "DG_COOLDOWN_AGE", false));
+            return `${envDays > 0 ? formatCooldownDuration(envDays) : "off"} (DG_COOLDOWN_AGE)`;
+        }
+        catch {
+            // malformed env override is ignored everywhere; describe the config instead
+        }
+    }
+    const baseDays = durationToDays(config.cooldown.age);
+    const base = baseDays > 0 ? formatCooldownDuration(baseDays) : "off";
+    const overrides = ["npm", "pypi", "cargo"]
+        .map((ecosystem) => {
+        const value = ecosystem === "npm" ? config.cooldown.npmAge : ecosystem === "pypi" ? config.cooldown.pypiAge : config.cooldown.cargoAge;
+        if (value === "") {
+            return undefined;
+        }
+        const days = durationToDays(value);
+        return `${ecosystem} ${days > 0 ? formatCooldownDuration(days) : "off"}`;
+    })
+        .filter((entry) => entry !== undefined);
+    return overrides.length > 0 ? `${base} (${overrides.join(", ")})` : base;
+}

package/dist/policy/evaluate.js

@@ -1,4 +1,4 @@
-import { emitWebhookEvent, recordAuditEvent } from "../audit/events.js";
+import { recordAuditEvent } from "../audit/events.js";
 import { DEFAULT_CONFIG } from "../config/settings.js";
 export function resolveEffectivePolicy(options) {
     if (options.orgPolicy) {
@@ -69,21 +69,21 @@ export function applyForceOverride(options, env = process.env) {
         return {
             allowed: false,
             reason: "force override was not requested",
-            webhookQueued: false
+            auditRecorded: false
         };
     }
     if (options.currentAction !== "block") {
         return {
             allowed: false,
             reason: "force override is only valid for block decisions",
-            webhookQueued: false
+            auditRecorded: false
         };
     }
     if (!options.policy.allowForceOverride) {
         return {
             allowed: false,
             reason: "force override is disabled by policy",
-            webhookQueued: false
+            auditRecorded: false
         };
     }
     const event = {
@@ -93,25 +93,12 @@ export function applyForceOverride(options, env = process.env) {
         policyMode: options.policy.mode,
         createdAt: (options.now ?? new Date()).toISOString()
     };
-    recordAuditEvent(event, env);
     return {
         allowed: true,
         reason: event.reason,
-        webhookQueued: emitWebhookEvent(event, env)
+        auditRecorded: recordAuditEvent(event, env)
     };
 }
-export function scriptPolicyArgs(options) {
-    if (!options.policy.scriptHardening && options.policy.mode !== "strict") {
-        return options.existingArgs;
-    }
-    if (hasScriptDisableFlag(options.existingArgs)) {
-        return options.existingArgs;
-    }
-    if (options.manager === "yarn") {
-        return [...options.existingArgs, "--ignore-scripts"];
-    }
-    return [...options.existingArgs, "--ignore-scripts"];
-}
 function findTrustedAllowlist(packageName, policy, allowlists) {
     return allowlists.find((entry) => {
         if (entry.packageName !== packageName) {
@@ -123,6 +110,3 @@ function findTrustedAllowlist(packageName, policy, allowlists) {
         return true;
     });
 }
-function hasScriptDisableFlag(args) {
-    return args.some((arg) => arg === "--ignore-scripts" || arg === "--ignore-scripts=true");
-}

package/dist/policy/pypi-name.js

@@ -0,0 +1,17 @@
+export function normalizePypiName(name) {
+    return name.toLowerCase().replace(/[-_.]+/g, "-");
+}
+// crates.io is case-insensitive and treats '-' and '_' as equivalent, so fold
+// both to a single canonical form for exemption matching.
+export function normalizeCargoName(name) {
+    return name.toLowerCase().replace(/_/g, "-");
+}
+export function canonicalCooldownName(ecosystem, name) {
+    if (ecosystem === "pypi") {
+        return normalizePypiName(name);
+    }
+    if (ecosystem === "cargo") {
+        return normalizeCargoName(name);
+    }
+    return name;
+}

package/dist/presentation/mode.js

@@ -19,8 +19,9 @@ export function colorEnabled(input) {
     if (input.forceColorFlag) {
         return true;
     }
-    if (truthyEnv(input.env.FORCE_COLOR)) {
-        return true;
+    const forceColor = input.env.FORCE_COLOR;
+    if (forceColor !== undefined) {
+        return forceColor !== "0" && forceColor !== "false";
     }
     if (input.noColorFlag) {
         return false;

package/dist/presentation/package-page.js

@@ -0,0 +1,9 @@
+const SITE = "https://westbayberry.com";
+// Only npm and pypi have public, indexable per-package pages today; cargo and
+// other ecosystems have none, so return null rather than link to a 404.
+export function packagePageUrl(ecosystem, name) {
+    if (ecosystem !== "npm" && ecosystem !== "pypi") {
+        return null;
+    }
+    return `${SITE}/${ecosystem}/${name}`;
+}

package/dist/presentation/provenance.js

@@ -0,0 +1,23 @@
+export function provenanceLabel(provenance) {
+    if (provenance.status === "attested") {
+        const tag = slsaTag(provenance.predicateType);
+        return tag ? `attested (${tag})` : "attested";
+    }
+    if (provenance.status === "none") {
+        return "none";
+    }
+    return "unknown (not yet checked)";
+}
+export function provenanceDowngradeLine(version, provenance) {
+    if (!provenance.downgrade) {
+        return null;
+    }
+    return `provenance downgraded — ${provenance.downgrade.fromVersion} was attested, ${version} is not`;
+}
+function slsaTag(predicateType) {
+    if (!predicateType) {
+        return null;
+    }
+    const match = /slsa\.dev\/provenance\/(v[0-9][0-9.]*)/.exec(predicateType);
+    return match ? `slsa ${match[1]}` : null;
+}

package/dist/presentation/theme.js

@@ -1,12 +1,12 @@
 const ANSI = {
-    block: "",
-    warn: "",
-    pass: "",
-    unknown: "",
-    muted: "",
-    accent: ""
+    block: "\u001b[31m",
+    warn: "\u001b[33m",
+    pass: "\u001b[32m",
+    unknown: "\u001b[36m",
+    muted: "\u001b[2m",
+    accent: "\u001b[1m"
 };
-const RESET = "";
+const RESET = "\u001b[0m";
 const BADGES = {
     block: { word: "BLOCK", glyph: "✘", role: "block" },
     warn: { word: "WARN", glyph: "⚠", role: "warn" },