@upx-us/shield 0.2.16-beta → 0.3.5

package/dist/src/fetcher.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_ENTRIES_PER_POLL = void 0;
 exports.fetchNewEntries = fetchNewEntries;
 exports.commitCursors = commitCursors;
 const fs_1 = require("fs");
@@ -40,15 +41,16 @@ const path_1 = require("path");
 const log = __importStar(require("./log"));
 function loadCursors(cursorFile) {
     if ((0, fs_1.existsSync)(cursorFile)) {
-        return JSON.parse((0, fs_1.readFileSync)(cursorFile, 'utf-8'));
+        try {
+            return JSON.parse((0, fs_1.readFileSync)(cursorFile, 'utf-8'));
+        }
+        catch {
+            log.warn('fetcher', 'Cursor file is corrupt or unreadable — resetting to empty state. Some events may be re-processed.');
+            return {};
+        }
     }
     return {};
 }
-/**
- * Initialize cursors for a new session directory.
- * Sets all file offsets to current file size (skip historical data).
- * Only called for directories that have NO existing cursor entries.
- */
 function initCursorsForDir(sessionDir, agentId, existingCursors) {
     const init = {};
     let files;
@@ -62,15 +64,12 @@ function initCursorsForDir(sessionDir, agentId, existingCursors) {
     let skipped = 0;
     for (const file of files) {
         const cursorKey = `${agentId}/${file}`;
-        // Also check legacy key (without agent prefix) for migration
         if (existingCursors[cursorKey] !== undefined || existingCursors[file] !== undefined) {
-            // Already tracked — migrate legacy key if needed
             if (existingCursors[file] !== undefined && existingCursors[cursorKey] === undefined) {
                 init[cursorKey] = existingCursors[file];
             }
             continue;
         }
-        // New file — set cursor to current size (skip history)
         const filePath = (0, path_1.join)(sessionDir, file);
         const fd = (0, fs_1.openSync)(filePath, 'r');
         try {
@@ -95,10 +94,6 @@ function saveCursors(cursorFile, state) {
     (0, fs_1.writeFileSync)(tmp, JSON.stringify(state, null, 2));
     (0, fs_1.renameSync)(tmp, cursorFile);
 }
-/**
- * Read only the new bytes from a file starting at the given byte offset.
- * Uses low-level fd + read to avoid loading the entire file into memory.
- */
 function readNewBytes(filePath, offset) {
     const fd = (0, fs_1.openSync)(filePath, 'r');
     try {
@@ -116,18 +111,19 @@ function readNewBytes(filePath, offset) {
         (0, fs_1.closeSync)(fd);
     }
 }
-// In-memory cursor state for the current poll cycle (committed only after successful send)
 let _pendingCursors = {};
+exports.MAX_ENTRIES_PER_POLL = 5000;
 async function fetchNewEntries(config) {
     const cursors = loadCursors(config.cursorFile);
     _pendingCursors = { ...cursors };
     const results = [];
+    let capReached = false;
     for (const sessionDir of config.sessionDirs) {
+        if (capReached)
+            break;
         if (!(0, fs_1.existsSync)(sessionDir))
             continue;
-        // Derive agent name from directory path: .../agents/{agentId}/sessions
         const agentId = (0, path_1.basename)((0, path_1.dirname)(sessionDir));
-        // Initialize cursors for newly discovered agents (skip historical data)
         const initCursors = initCursorsForDir(sessionDir, agentId, _pendingCursors);
         Object.assign(_pendingCursors, initCursors);
         let files;
@@ -138,9 +134,10 @@ async function fetchNewEntries(config) {
             continue;
         }
         for (const file of files) {
+            if (capReached)
+                break;
             const filePath = (0, path_1.join)(sessionDir, file);
             const sessionId = (0, path_1.basename)(file, '.jsonl');
-            // Cursor key includes agent to avoid collisions across agents
             const cursorKey = `${agentId}/${file}`;
             const offset = _pendingCursors[cursorKey] ?? cursors[cursorKey] ?? 0;
             const { content, newSize } = readNewBytes(filePath, offset);
@@ -149,7 +146,9 @@ async function fetchNewEntries(config) {
                 continue;
             }
             const lines = content.split('\n').filter(l => l.trim());
+            let bytesConsumed = 0;
             for (const line of lines) {
+                bytesConsumed += Buffer.byteLength(line, 'utf-8') + 1;
                 try {
                     const entry = JSON.parse(line);
                     if (entry.type !== 'message')
@@ -167,9 +166,19 @@ async function fetchNewEntries(config) {
                         results.push({ ...entry, _sessionId: sessionId, _agentId: agentId });
                     }
                 }
-                catch { /* skip malformed lines */ }
+                catch { }
+                if (results.length >= exports.MAX_ENTRIES_PER_POLL) {
+                    capReached = true;
+                    log.warn('fetcher', `Entry cap reached (${exports.MAX_ENTRIES_PER_POLL}) — remaining entries deferred to next poll`);
+                    break;
+                }
+            }
+            if (capReached) {
+                _pendingCursors[cursorKey] = offset + bytesConsumed;
+            }
+            else {
+                _pendingCursors[cursorKey] = newSize;
             }
-            _pendingCursors[cursorKey] = newSize;
         }
     }
     return results;

package/dist/src/index.js

@@ -45,8 +45,10 @@ const version_1 = require("./version");
 let running = true;
 let lastTelemetryAt = 0;
 let consecutiveFailures = 0;
-const TELEMETRY_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
-const MAX_BACKOFF_MS = 5 * 60 * 1000; // 5 minutes
+let registrationOk = false;
+const TELEMETRY_INTERVAL_MS = 5 * 60 * 1000;
+const MAX_BACKOFF_MS = 5 * 60 * 1000;
+const MAX_REGISTRATION_FAILURES = 10;
 function getBackoffInterval(baseMs) {
     if (consecutiveFailures === 0)
         return baseMs;
@@ -64,11 +66,8 @@ async function poll() {
             let entries = await (0, fetcher_1.fetchNewEntries)(config);
             const now = Date.now();
             if (now - lastTelemetryAt >= TELEMETRY_INTERVAL_MS) {
-                // Host telemetry is no longer forwarded to Chronicle/SIEM.
-                // It is summarised server-side via the instance report sent to the
-                // platform backend (Cloud Run → uss.upx.com). This avoids noisy
-                // GENERIC_EVENT floods that trigger false-positive YARA-L rules.
-                (0, transformer_1.generateHostTelemetry)(); // still collect locally (for score / future use)
+                const hostSnapshot = config.collectHostMetrics ? (0, transformer_1.generateHostTelemetry)() : null;
+                const hostMeta = hostSnapshot?.event?.tool_metadata;
                 const instancePayload = {
                     machine: {
                         hostname: config.hostname,
@@ -80,12 +79,36 @@ async function poll() {
                         plugin_version: version_1.VERSION,
                         openclaw_version: (0, transformer_1.resolveOpenClawVersion)(),
                         agent_label: (0, transformer_1.resolveAgentLabel)('main'),
+                        ...(hostMeta && {
+                            gateway_bind: hostMeta['openclaw.gateway_bind'],
+                            webhook_configured: hostMeta['openclaw.webhook_configured'],
+                            browser_auth_required: hostMeta['openclaw.browser_auth_required'],
+                        }),
                     },
                 };
-                const platformOk = await (0, sender_1.reportInstance)(instancePayload, config.credentials);
-                log.info('bridge', `Instance report → Platform: success=${platformOk}`);
-                if (platformOk)
+                const result = await (0, sender_1.reportInstance)(instancePayload, config.credentials);
+                log.info('bridge', `Instance report → Platform: success=${result.ok}`);
+                if (result.ok) {
+                    registrationOk = true;
                     lastTelemetryAt = now;
+                    if (result.score) {
+                        log.info('bridge', `Protection score: ${result.score.badge} ${result.score.total}/100 (${result.score.grade})`);
+                        if (result.score.recommendations?.length) {
+                            for (const rec of result.score.recommendations) {
+                                log.warn('bridge', `⚠ ${rec}`);
+                            }
+                        }
+                    }
+                }
+                else if (!registrationOk) {
+                    consecutiveFailures++;
+                    if (consecutiveFailures >= MAX_REGISTRATION_FAILURES) {
+                        log.error('bridge', `reportInstance failed ${consecutiveFailures} consecutive times — instance not recognized. Re-run setup wizard. Exiting.`);
+                        process.exit(1);
+                    }
+                    log.warn('bridge', `reportInstance failed (attempt ${consecutiveFailures}/${MAX_REGISTRATION_FAILURES}) — skipping events this cycle (platform may still be syncing)`);
+                    continue;
+                }
             }
             if (entries.length > 0) {
                 let envelopes = (0, transformer_1.transformEntries)(entries);
@@ -115,6 +138,24 @@ async function poll() {
                         log.error('bridge', `Result: FAILED status=${r.statusCode} events=${r.eventCount} body=${r.body?.slice(0, 200)}`);
                     }
                 }
+                if (results.some(r => r.needsRegistration)) {
+                    consecutiveFailures++;
+                    registrationOk = false;
+                    lastTelemetryAt = 0;
+                    if (consecutiveFailures >= MAX_REGISTRATION_FAILURES) {
+                        log.error('bridge', `Instance not recognized by platform after ${consecutiveFailures} attempts. Re-run the setup wizard. Exiting.`);
+                        process.exit(1);
+                    }
+                    log.warn('bridge', `Instance not registered on platform (attempt ${consecutiveFailures}/${MAX_REGISTRATION_FAILURES}) — will re-register on next cycle`);
+                    continue;
+                }
+                const pendingResult = results.find(r => r.pendingNamespace);
+                if (pendingResult) {
+                    const retryAfterMs = Math.min(pendingResult.retryAfterMs ?? 300_000, MAX_BACKOFF_MS);
+                    log.warn('bridge', `Namespace pending — holding cursors, retrying in ${Math.round(retryAfterMs / 1000)}s`);
+                    await new Promise(r => setTimeout(r, retryAfterMs));
+                    continue;
+                }
                 const allSuccess = results.every(r => r.success);
                 if (allSuccess) {
                     (0, fetcher_1.commitCursors)(config, entries);
@@ -134,11 +175,6 @@ async function poll() {
                 }
             }
             else {
-                // No new entries this poll — but still commit cursors so that
-                // initCursorsForDir positions (set to current file sizes) are
-                // persisted. Without this, the next poll re-initialises cursors
-                // to the NEW current size and silently skips any events that
-                // arrived between polls.
                 (0, fetcher_1.commitCursors)(config, []);
                 consecutiveFailures = 0;
             }
@@ -162,7 +198,6 @@ async function poll() {
 function checkConfiguration() {
     if (!(0, fs_1.existsSync)(config_1.SHIELD_CONFIG_PATH)) {
         const { SHIELD_API_URL, SHIELD_INSTANCE_ID, SHIELD_HMAC_SECRET, SHIELD_FINGERPRINT, SHIELD_SECRET } = process.env;
-        // Support both new and legacy env var names
         if (SHIELD_API_URL && (SHIELD_INSTANCE_ID || SHIELD_FINGERPRINT) && (SHIELD_HMAC_SECRET || SHIELD_SECRET))
             return true;
         console.log('🛡️  OpenClaw Shield — First Time Setup Required');

package/dist/src/log.d.ts

@@ -1,37 +1,11 @@
-/**
- * log.ts — Structured logger for the Shield plugin
- *
- * Supports two backends via the LogAdapter interface:
- *   1. ConsoleLogAdapter (default) — used in standalone/docker bridge mode
- *   2. Gateway adapter — injected by the plugin entry via setAdapter()
- *
- * All internal modules use `import * as log from './log'` unchanged.
- * Standalone mode never calls setAdapter(), so console logging works
- * identically to a direct console.log/warn/error setup.
- *
- * Log level is controlled by LOG_LEVEL env var: debug | info | warn | error
- * (default: info). In debug mode, pipeline stages emit detailed per-event
- * output (transformer, validator, redactor, sender).
- */
 export interface LogAdapter {
     debug(tag: string, msg: string, data?: unknown): void;
     info(tag: string, msg: string): void;
     warn(tag: string, msg: string): void;
     error(tag: string, msg: string, err?: unknown): void;
 }
-/**
- * Swap the log backend. Plugin mode calls this with a Gateway-backed adapter.
- * Standalone/docker mode never calls this — console logging remains the default.
- * Also invalidates the cached log level so it is re-resolved on next call.
- */
 export declare function setAdapter(adapter: LogAdapter): void;
-/** Reset to the default console adapter (useful for tests). */
 export declare function resetAdapter(): void;
-/**
- * isDebug — dynamic property check.
- * Accessed as `log.isDebug` (property, not function call) throughout the codebase.
- * Using Object.defineProperty to make it a live getter on the module exports.
- */
 export declare let isDebug: boolean;
 export declare function debug(tag: string, msg: string, data?: unknown): void;
 export declare function info(tag: string, msg: string): void;

package/dist/src/log.js

@@ -1,19 +1,4 @@
 "use strict";
-/**
- * log.ts — Structured logger for the Shield plugin
- *
- * Supports two backends via the LogAdapter interface:
- *   1. ConsoleLogAdapter (default) — used in standalone/docker bridge mode
- *   2. Gateway adapter — injected by the plugin entry via setAdapter()
- *
- * All internal modules use `import * as log from './log'` unchanged.
- * Standalone mode never calls setAdapter(), so console logging works
- * identically to a direct console.log/warn/error setup.
- *
- * Log level is controlled by LOG_LEVEL env var: debug | info | warn | error
- * (default: info). In debug mode, pipeline stages emit detailed per-event
- * output (transformer, validator, redactor, sender).
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isDebug = void 0;
 exports.setAdapter = setAdapter;
@@ -36,7 +21,7 @@ function getLevel() {
     return cachedLevel;
 }
 function fmt(level, tag, msg) {
-    const ts = new Date().toISOString().slice(11, 23); // HH:MM:SS.mmm
+    const ts = new Date().toISOString().slice(11, 23);
     return `[${ts}] [${level.toUpperCase().padEnd(5)}] [${tag}] ${msg}`;
 }
 const consoleAdapter = {
@@ -64,25 +49,14 @@ const consoleAdapter = {
     },
 };
 let activeAdapter = consoleAdapter;
-/**
- * Swap the log backend. Plugin mode calls this with a Gateway-backed adapter.
- * Standalone/docker mode never calls this — console logging remains the default.
- * Also invalidates the cached log level so it is re-resolved on next call.
- */
 function setAdapter(adapter) {
     activeAdapter = adapter;
     cachedLevel = null;
 }
-/** Reset to the default console adapter (useful for tests). */
 function resetAdapter() {
     activeAdapter = consoleAdapter;
     cachedLevel = null;
 }
-/**
- * isDebug — dynamic property check.
- * Accessed as `log.isDebug` (property, not function call) throughout the codebase.
- * Using Object.defineProperty to make it a live getter on the module exports.
- */
 exports.isDebug = LEVEL_RANK[getLevel()] <= LEVEL_RANK.debug;
 Object.defineProperty(exports, 'isDebug', {
     get: () => LEVEL_RANK[getLevel()] <= LEVEL_RANK.debug,

package/dist/src/redactor/base.d.ts

@@ -1,29 +1,6 @@
-/**
- * src/redactor/base.ts — Core types for the strategy-based redaction system.
- *
- * Every redaction strategy implements RedactionStrategy. Strategies are pure
- * data transforms: they receive a value and an injected hmac function, and
- * return a redacted string. No I/O, no key management, no side effects.
- */
-/**
- * Produces a deterministic token (e.g. 'user:a3f9b2c1d4e5') and records the
- * original-to-token mapping in the vault. Injected into strategies so they
- * never own key management or storage.
- */
 export type HmacFn = (category: string, value: string) => string;
-/**
- * Contract every redaction strategy must satisfy.
- * The `key` string is what event `FieldRedaction.strategy` references.
- */
 export interface RedactionStrategy {
-    /** Unique identifier — must match the `strategy` field in FieldRedaction rules */
     key: string;
-    /** Human-readable description for documentation and debugging */
     description: string;
-    /**
-     * Apply redaction to a single string value.
-     * Must be pure: same inputs always produce same outputs.
-     * Must not throw on empty strings or unusual inputs.
-     */
     redact: (value: string, hmac: HmacFn) => string;
 }

package/dist/src/redactor/base.js

@@ -1,9 +1,2 @@
 "use strict";
-/**
- * src/redactor/base.ts — Core types for the strategy-based redaction system.
- *
- * Every redaction strategy implements RedactionStrategy. Strategies are pure
- * data transforms: they receive a value and an injected hmac function, and
- * return a redacted string. No I/O, no key management, no side effects.
- */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/redactor/index.d.ts

@@ -1,20 +1,5 @@
-/**
- * src/redactor/index.ts — Strategy engine, event redaction, and public API.
- *
- * This module wires vault + strategies into a single redaction engine.
- * All imports of './redactor' resolve here (TypeScript: directory + index.ts).
- */
 import type { FieldRedaction } from '../events/base';
-/**
- * Apply a single FieldRedaction rule to an object via dot-notation path.
- * Missing fields and null values are silently skipped.
- * Unknown strategy keys throw a descriptive error.
- */
 export declare function applyFieldRedaction(obj: any, rule: FieldRedaction): void;
-/**
- * Deep-redact a Shield envelope. Returns a new object (does not mutate input).
- * Applies base redactions + schema-specific redactions based on tool_category.
- */
 export declare function redactEvent(envelope: any): any;
 export declare function redactUsername(value: string): string;
 export declare function redactHostname(value: string): string;

package/dist/src/redactor/index.js

@@ -1,10 +1,4 @@
 "use strict";
-/**
- * src/redactor/index.ts — Strategy engine, event redaction, and public API.
- *
- * This module wires vault + strategies into a single redaction engine.
- * All imports of './redactor' resolve here (TypeScript: directory + index.ts).
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyFieldRedaction = applyFieldRedaction;
 exports.redactEvent = redactEvent;
@@ -21,14 +15,8 @@ const strategies_1 = require("./strategies");
 const vault_1 = require("./vault");
 const events_1 = require("../events");
 const base_1 = require("../events/base");
-// ─── Strategy Registry ────────────────────────────────────────────────────────
+const counters_1 = require("../counters");
 const strategyMap = new Map(strategies_1.strategies.map(s => [s.key, s]));
-// ─── Engine ───────────────────────────────────────────────────────────────────
-/**
- * Apply a single FieldRedaction rule to an object via dot-notation path.
- * Missing fields and null values are silently skipped.
- * Unknown strategy keys throw a descriptive error.
- */
 function applyFieldRedaction(obj, rule) {
     const strategy = strategyMap.get(rule.strategy);
     if (!strategy)
@@ -43,16 +31,15 @@ function applyFieldRedaction(obj, rule) {
     const last = parts[parts.length - 1];
     if (cur == null || typeof cur !== 'object' || cur[last] == null)
         return;
-    cur[last] = strategy.redact(String(cur[last]), vault_1.hmacHash);
+    const original = String(cur[last]);
+    const redacted = strategy.redact(original, vault_1.hmacHash);
+    cur[last] = redacted;
+    if (strategy.key !== 'secret-key' && redacted !== original) {
+        (0, counters_1.recordRedaction)(strategy.key.toUpperCase().replace(/-/g, '_'));
+    }
 }
-// ─── High-Level API ───────────────────────────────────────────────────────────
-/**
- * Deep-redact a Shield envelope. Returns a new object (does not mutate input).
- * Applies base redactions + schema-specific redactions based on tool_category.
- */
 function redactEvent(envelope) {
-    const e = JSON.parse(JSON.stringify(envelope));
-    // Source-level: hostname in the source block always gets redacted
+    const e = structuredClone(envelope);
     if (e.source?.hostname) {
         const hs = strategyMap.get('hostname');
         if (hs)
@@ -60,11 +47,9 @@ function redactEvent(envelope) {
     }
     if (!e.event)
         return e;
-    // Base redactions (principal.hostname, principal.user) — always apply
     for (const rule of base_1.baseRedactions) {
         applyFieldRedaction(e.event, rule);
     }
-    // Schema-specific redactions via tool_category discriminator
     const category = e.event.tool_category;
     if (category) {
         const schema = events_1.schemas.find(s => s.category === category);
@@ -76,7 +61,6 @@ function redactEvent(envelope) {
     }
     return e;
 }
-// ─── Individual Strategy Functions (backwards-compat + direct use) ────────────
 function redactUsername(value) {
     const s = strategyMap.get('username');
     return s ? s.redact(value, vault_1.hmacHash) : value;
@@ -93,17 +77,14 @@ function redactCommand(value) {
     const s = strategyMap.get('command');
     return s ? s.redact(value, vault_1.hmacHash) : value;
 }
-// ─── Lifecycle ────────────────────────────────────────────────────────────────
 function init() { (0, vault_1.initVault)(); }
 function flush() { (0, vault_1.flushVault)(); }
-// ─── Reverse Lookup ───────────────────────────────────────────────────────────
 function reverseLookup(token) {
     return (0, vault_1.reverseLookup)(token);
 }
 function getAllMappings() {
     return (0, vault_1.getAllMappings)();
 }
-// ─── Testing ──────────────────────────────────────────────────────────────────
 function _initForTesting(secret) {
     (0, vault_1._initVaultForTesting)(secret);
 }

package/dist/src/redactor/strategies/command.js

@@ -8,11 +8,8 @@ exports.commandStrategy = {
         if (!value || value.length === 0)
             return value;
         let result = value;
-        // SSH user@host patterns (e.g. ssh alice@192.168.1.1, scp bob@server:/path)
         result = result.replace(/(\b)([\w.-]+)@([\d.]+|[\w.-]+\.\w+)/g, (_, pre, user, host) => `${pre}${hmac('user', user)}@${host}`);
-        // macOS home paths
         result = result.replace(/\/Users\/([\w.-]+)\//g, (_, user) => `/Users/${hmac('user', user)}/`);
-        // Linux home paths
         result = result.replace(/\/home\/([\w.-]+)\//g, (_, user) => `/home/${hmac('user', user)}/`);
         return result;
     },

package/dist/src/redactor/strategies/hostname.js

@@ -7,7 +7,6 @@ exports.hostnameStrategy = {
     redact(value, hmac) {
         if (!value || value.length === 0)
             return value;
-        // IPv4 addresses are not redacted — they have detection value for lateral movement rules
         if (/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(value))
             return value;
         return hmac('host', value);

package/dist/src/redactor/strategies/index.d.ts

@@ -5,9 +5,4 @@ import { commandStrategy } from './command';
 import { secretKeyStrategy } from './secret-key';
 import type { RedactionStrategy } from '../base';
 export { usernameStrategy, hostnameStrategy, pathStrategy, commandStrategy, secretKeyStrategy };
-/**
- * Ordered registry of all redaction strategies.
- * The engine resolves strategies by their `key` field.
- * Order here does not affect execution — strategies are looked up by key.
- */
 export declare const strategies: RedactionStrategy[];

package/dist/src/redactor/strategies/index.js

@@ -11,11 +11,6 @@ const command_1 = require("./command");
 Object.defineProperty(exports, "commandStrategy", { enumerable: true, get: function () { return command_1.commandStrategy; } });
 const secret_key_1 = require("./secret-key");
 Object.defineProperty(exports, "secretKeyStrategy", { enumerable: true, get: function () { return secret_key_1.secretKeyStrategy; } });
-/**
- * Ordered registry of all redaction strategies.
- * The engine resolves strategies by their `key` field.
- * Order here does not affect execution — strategies are looked up by key.
- */
 exports.strategies = [
     username_1.usernameStrategy,
     hostname_1.hostnameStrategy,

package/dist/src/redactor/strategies/path.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pathStrategy = void 0;
 const HOME_PATTERNS = [
-    [/^(\/Users\/)([\w.-]+)(\/.*|$)/, '$1', '$3'], // macOS
-    [/^(\/home\/)([\w.-]+)(\/.*|$)/, '$1', '$3'], // Linux
-    [/^(C:\\Users\\)([\w.-]+)(\\.*|$)/i, '$1', '$3'], // Windows
+    [/^(\/Users\/)([\w.-]+)(\/.*|$)/, '$1', '$3'],
+    [/^(\/home\/)([\w.-]+)(\/.*|$)/, '$1', '$3'],
+    [/^(C:\\Users\\)([\w.-]+)(\\.*|$)/i, '$1', '$3'],
 ];
 exports.pathStrategy = {
     key: 'path',

package/dist/src/redactor/strategies/secret-key.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.secretKeyStrategy = void 0;
+const counters_1 = require("../../counters");
 exports.secretKeyStrategy = {
     key: 'secret-key',
     description: 'Detects and redacts API keys, bearer tokens, and secrets in free-text fields (command strings, arguments). Produces secret:HASH tokens.',
@@ -8,15 +9,38 @@ exports.secretKeyStrategy = {
         if (!value || value.length === 0)
             return value;
         let result = value;
-        // AWS access key IDs (e.g. AKIAIOSFODNN7EXAMPLE)
-        // Note: no capture groups — the entire match is the secret
-        result = result.replace(/(AKIA[0-9A-Z]{16})/g, (_, key) => hmac('secret', key));
-        // CLI flags with secrets: --token=sk_live_xxx, --api-key sk_live_xxx, --password=abc123
-        result = result.replace(/(--(?:token|api[_-]?key|secret|password)[=\s]+)(\S+)/gi, (_, flag, secret) => `${flag}${hmac('secret', secret)}`);
-        // Bearer tokens in Authorization headers
-        result = result.replace(/(Bearer\s+)(\S+)/gi, (_, prefix, token) => `${prefix}${hmac('secret', token)}`);
-        // ENV-style assignments: SECRET=value, API_KEY=value, TOKEN=value, PASSWORD=value
-        result = result.replace(/((?:SECRET|TOKEN|KEY|PASSWORD|API_KEY)=)(\S+)/gi, (_, prefix, secret) => `${prefix}${hmac('secret', secret)}`);
+        result = result.replace(/(AKIA[0-9A-Z]{16})/g, (_, key) => {
+            (0, counters_1.recordRedaction)('AWS_KEY');
+            return hmac('secret', key);
+        });
+        result = result.replace(/(--(?:token|api[_-]?key|secret|password)[=\s]+)(\S+)/gi, (_, flag, secret) => {
+            const flagLower = flag.toLowerCase();
+            if (/password/.test(flagLower))
+                (0, counters_1.recordRedaction)('PASSWORD');
+            else if (/api[_-]?key/.test(flagLower))
+                (0, counters_1.recordRedaction)('API_KEY');
+            else if (/secret/.test(flagLower))
+                (0, counters_1.recordRedaction)('SECRET_KEY');
+            else
+                (0, counters_1.recordRedaction)('TOKEN');
+            return `${flag}${hmac('secret', secret)}`;
+        });
+        result = result.replace(/(Bearer\s+)(\S+)/gi, (_, prefix, token) => {
+            (0, counters_1.recordRedaction)('BEARER_TOKEN');
+            return `${prefix}${hmac('secret', token)}`;
+        });
+        result = result.replace(/((?:SECRET|TOKEN|KEY|PASSWORD|API_KEY)=)(\S+)/gi, (_, prefix, secret) => {
+            const prefixUpper = prefix.toUpperCase();
+            if (prefixUpper.startsWith('PASSWORD'))
+                (0, counters_1.recordRedaction)('PASSWORD');
+            else if (prefixUpper.startsWith('API_KEY') || prefixUpper.startsWith('KEY'))
+                (0, counters_1.recordRedaction)('API_KEY');
+            else if (prefixUpper.startsWith('TOKEN'))
+                (0, counters_1.recordRedaction)('TOKEN');
+            else
+                (0, counters_1.recordRedaction)('SECRET_KEY');
+            return `${prefix}${hmac('secret', secret)}`;
+        });
         return result;
     },
 };

package/dist/src/redactor/vault.d.ts

@@ -1,25 +1,6 @@
-/**
- * src/redactor/vault.ts — Key management and encrypted mapping store.
- *
- * The vault owns all I/O. Key lifecycle, map persistence, reverse lookup —
- * everything involving files or crypto state lives here. No other module in
- * the redactor touches the filesystem.
- *
- * Security layers:
- *   - File permissions: 0o600 on key and vault files
- *   - Encryption at rest: AES-256-GCM with scrypt-derived key
- *   - Atomic writes: write to .tmp then rename (prevents mid-write corruption)
- *   - In-memory isolation: state fully encapsulated in this module
- *   - Test isolation: _initVaultForTesting() uses deterministic secret, no file I/O
- */
 export declare function initVault(): void;
 export declare function flushVault(): void;
-/**
- * Produce a deterministic token for a (category, value) pair and record the
- * reverse mapping. This is the HmacFn injected into every strategy.
- */
 export declare function hmacHash(category: string, value: string): string;
 export declare function reverseLookup(token: string): string | null;
 export declare function getAllMappings(): Record<string, string>;
-/** For testing only — deterministic secret, zero file I/O. */
 export declare function _initVaultForTesting(secret: string): void;