@upx-us/shield 0.3.29 → 0.4.36

package/dist/src/case-monitor.js

@@ -0,0 +1,193 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCaseMonitor = initCaseMonitor;
+exports.notifyCaseMonitorActivity = notifyCaseMonitorActivity;
+exports.getCaseMonitorStatus = getCaseMonitorStatus;
+exports.checkForNewCases = checkForNewCases;
+exports.getPendingCases = getPendingCases;
+exports.acknowledgeCases = acknowledgeCases;
+exports.formatCaseNotification = formatCaseNotification;
+exports._resetForTesting = _resetForTesting;
+const safe_io_1 = require("./safe-io");
+const client_1 = require("./rpc/client");
+const log = __importStar(require("./log"));
+const path_1 = require("path");
+const MIN_CHECK_INTERVAL_MS = 60_000;
+const MAX_CHECK_INTERVAL_MS = 900_000;
+const RECENT_EVENT_THRESHOLD_MS = 300_000;
+const MAX_ACKNOWLEDGED_IDS = 500;
+const STATE_FILE = 'case-monitor-state.json';
+let _dataDir = null;
+let _lastCheckAt = 0;
+let _lastEventAt = 0;
+let _currentIntervalMs = MAX_CHECK_INTERVAL_MS;
+function computeInterval() {
+    if (_lastCheckAt === 0)
+        return MIN_CHECK_INTERVAL_MS;
+    if (_lastEventAt === 0)
+        return MAX_CHECK_INTERVAL_MS;
+    const elapsed = Date.now() - _lastEventAt;
+    if (elapsed <= RECENT_EVENT_THRESHOLD_MS)
+        return MIN_CHECK_INTERVAL_MS;
+    const rampMs = 600_000;
+    const progress = Math.min((elapsed - RECENT_EVENT_THRESHOLD_MS) / rampMs, 1);
+    return Math.round(MIN_CHECK_INTERVAL_MS + progress * (MAX_CHECK_INTERVAL_MS - MIN_CHECK_INTERVAL_MS));
+}
+function initCaseMonitor(dataDir) {
+    _dataDir = dataDir;
+    _currentIntervalMs = MAX_CHECK_INTERVAL_MS;
+    log.info('case-monitor', 'Initialized (adaptive: 1m active → 15m idle)');
+}
+function notifyCaseMonitorActivity() {
+    _lastEventAt = Date.now();
+}
+function getCaseMonitorStatus() {
+    const interval = computeInterval();
+    const nextCheckIn = Math.max(0, (_lastCheckAt + interval) - Date.now());
+    return { intervalMs: interval, nextCheckIn, lastCheckAt: _lastCheckAt };
+}
+async function checkForNewCases(config) {
+    if (!_dataDir)
+        return;
+    if (!config.apiUrl)
+        return;
+    _currentIntervalMs = computeInterval();
+    const now = Date.now();
+    if (now - _lastCheckAt < _currentIntervalMs)
+        return;
+    _lastCheckAt = now;
+    const stateFile = (0, path_1.join)(_dataDir, STATE_FILE);
+    const state = (0, safe_io_1.readJsonSafe)(stateFile, {
+        lastCheckAt: null,
+        pendingCases: [],
+        acknowledgedIds: [],
+    }, 'case-monitor');
+    try {
+        const params = {
+            status: 'open',
+            limit: 20,
+        };
+        if (state.lastCheckAt) {
+            params.since = state.lastCheckAt;
+        }
+        const result = await (0, client_1.callPlatformApi)(config, '/v1/agent/cases', params, 'GET');
+        if (!result.ok) {
+            if (!result.error?.includes('not configured')) {
+                log.warn('case-monitor', `Failed to check cases: ${result.error}`);
+            }
+            return;
+        }
+        const cases = result.data?.cases ?? [];
+        const ackSet = new Set(state.acknowledgedIds);
+        const pendingSet = new Set(state.pendingCases.map(c => c.id));
+        const newCases = cases.filter(c => !ackSet.has(c.id) && !pendingSet.has(c.id));
+        if (newCases.length > 0) {
+            state.pendingCases = [...state.pendingCases, ...newCases];
+            log.info('case-monitor', `${newCases.length} new case(s) pending notification`);
+        }
+        state.lastCheckAt = new Date().toISOString();
+        (0, safe_io_1.writeJsonSafe)(stateFile, state);
+    }
+    catch (err) {
+        log.warn('case-monitor', `Check failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function getPendingCases() {
+    if (!_dataDir)
+        return [];
+    const stateFile = (0, path_1.join)(_dataDir, STATE_FILE);
+    const state = (0, safe_io_1.readJsonSafe)(stateFile, {
+        lastCheckAt: null,
+        pendingCases: [],
+        acknowledgedIds: [],
+    }, 'case-monitor');
+    return state.pendingCases;
+}
+function acknowledgeCases(caseIds) {
+    if (!_dataDir)
+        return;
+    const stateFile = (0, path_1.join)(_dataDir, STATE_FILE);
+    const state = (0, safe_io_1.readJsonSafe)(stateFile, {
+        lastCheckAt: null,
+        pendingCases: [],
+        acknowledgedIds: [],
+    }, 'case-monitor');
+    const ackSet = new Set(caseIds);
+    state.pendingCases = state.pendingCases.filter(c => !ackSet.has(c.id));
+    state.acknowledgedIds = [...state.acknowledgedIds, ...caseIds].slice(-MAX_ACKNOWLEDGED_IDS);
+    (0, safe_io_1.writeJsonSafe)(stateFile, state);
+    log.info('case-monitor', `Acknowledged ${caseIds.length} case(s), ${state.pendingCases.length} still pending`);
+}
+function formatCaseNotification(c) {
+    const severityEmoji = {
+        CRITICAL: '🔴',
+        HIGH: '🟠',
+        MEDIUM: '🟡',
+        LOW: '🔵',
+        INFO: 'ℹ️',
+    };
+    const emoji = severityEmoji[c.severity] || '⚠️';
+    const ago = getTimeAgo(c.created_at);
+    return [
+        `${emoji} **Shield Alert — New Case**`,
+        ``,
+        `**Rule:** ${c.rule_title}`,
+        `**Severity:** ${c.severity}`,
+        `**Time:** ${ago}`,
+        `**Events:** ${c.event_count}`,
+        ``,
+        `> ${c.summary}`,
+        ``,
+        `Ask me to investigate or resolve this case.`,
+    ].join('\n');
+}
+function getTimeAgo(isoDate) {
+    const diffMs = Date.now() - new Date(isoDate).getTime();
+    const mins = Math.floor(diffMs / 60000);
+    if (mins < 1)
+        return 'just now';
+    if (mins < 60)
+        return `${mins}m ago`;
+    const hours = Math.floor(mins / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    return `${Math.floor(hours / 24)}d ago`;
+}
+function _resetForTesting() {
+    _dataDir = null;
+    _lastCheckAt = 0;
+    _currentIntervalMs = MAX_CHECK_INTERVAL_MS;
+}

package/dist/src/cli-cases.d.ts

@@ -0,0 +1 @@
+export declare function registerCasesCli(shieldCommand: any): void;

package/dist/src/cli-cases.js

@@ -0,0 +1,184 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCasesCli = registerCasesCli;
+const config_1 = require("./config");
+function hasValidCreds(creds) {
+    return !!(creds.apiUrl && creds.instanceId && creds.hmacSecret);
+}
+function buildConfig(creds) {
+    return { apiUrl: creds.apiUrl, instanceId: creds.instanceId, hmacSecret: creds.hmacSecret };
+}
+function registerCasesCli(shieldCommand) {
+    const cases = shieldCommand.command('cases')
+        .description('List and manage Shield security cases');
+    cases.action(async () => {
+        await listCases({ status: 'open', limit: '20', format: 'table' });
+    });
+    cases
+        .command('list')
+        .description('List security cases')
+        .option('--status <status>', 'Filter: open, resolved, all', 'open')
+        .option('--limit <n>', 'Max results', '20')
+        .option('--format <fmt>', 'Output format: table or json', 'table')
+        .action(listCases);
+    cases
+        .command('show')
+        .description('Show full case detail')
+        .argument('<id>', 'Case ID')
+        .option('--format <fmt>', 'Output format: table or json', 'table')
+        .action(showCase);
+    cases
+        .command('resolve')
+        .description('Resolve/close a security case')
+        .argument('<id>', 'Case ID')
+        .requiredOption('--resolution <value>', 'true_positive, false_positive, benign, duplicate')
+        .requiredOption('--root-cause <value>', 'user_initiated, misconfiguration, expected_behavior, actual_threat, testing, unknown')
+        .option('--comment <text>', 'Optional comment')
+        .action(resolveCase);
+}
+async function callApi(method, path, body) {
+    const creds = (0, config_1.loadCredentials)();
+    if (!hasValidCreds(creds)) {
+        console.error('Shield is not activated. Run: openclaw shield activate <KEY>');
+        return null;
+    }
+    const { callPlatformApi } = await Promise.resolve().then(() => __importStar(require('./rpc/client')));
+    const result = await callPlatformApi(buildConfig(creds), path, body, method);
+    if (!result.ok) {
+        console.error(result.error || 'Platform API error');
+        return null;
+    }
+    return result.data;
+}
+async function listCases(opts) {
+    const result = await callApi('GET', `/v1/agent/cases?status=${opts.status}&limit=${opts.limit}`);
+    if (!result)
+        return;
+    if (!result.cases) {
+        console.log('Platform unavailable or no cases found.');
+        return;
+    }
+    if (opts.format === 'json') {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (result.cases.length === 0) {
+        console.log('No open cases. \u2705');
+        return;
+    }
+    console.log(`Cases (${result.cases.length} of ${result.total}):\n`);
+    for (const c of result.cases) {
+        const sev = (c.severity || '').padEnd(8);
+        const time = new Date(c.created_at).toLocaleString();
+        console.log(`  [${sev}] ${c.id}`);
+        console.log(`           ${c.rule_title || c.rule_id}`);
+        console.log(`           ${c.summary || ''}`);
+        console.log(`           Created: ${time}  Events: ${c.event_count || 0}\n`);
+    }
+    if (result.has_more)
+        console.log('  Use --limit to see more.');
+}
+async function showCase(id, opts) {
+    const result = await callApi('GET', `/v1/agent/cases/${id}`);
+    if (!result)
+        return;
+    if (!result.id) {
+        console.error('Case not found.');
+        return;
+    }
+    if (opts.format === 'json') {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    console.log(`Case: ${result.id}`);
+    console.log(`Status: ${result.status}  Severity: ${result.severity}`);
+    console.log(`Rule: ${result.rule_title || result.rule_id}`);
+    console.log(`Summary: ${result.summary || '\u2014'}`);
+    console.log(`Created: ${new Date(result.created_at).toLocaleString()}`);
+    console.log(`Events: ${result.event_count || 0}`);
+    if (result.attribution) {
+        console.log(`\n${result.attribution}`);
+    }
+    if (result.rule) {
+        console.log(`\nRule: ${result.rule.description || '\u2014'}`);
+        if (result.rule.mitre_tactic)
+            console.log(`MITRE: ${result.rule.mitre_tactic} / ${result.rule.mitre_technique || '\u2014'}`);
+    }
+    if (result.playbook) {
+        console.log(`\nPlaybook: ${result.playbook.name || '\u2014'}`);
+        if (result.playbook.steps) {
+            for (const step of result.playbook.steps) {
+                console.log(`  \u2192 ${step}`);
+            }
+        }
+    }
+    if (result.events && result.events.length > 0) {
+        console.log(`\nEvents:`);
+        for (const e of result.events) {
+            console.log(`  ${new Date(e.timestamp).toLocaleTimeString()}  ${e.event_type}  ${e.summary || ''}`);
+        }
+    }
+    if (result.resolution) {
+        console.log(`\nResolution: ${result.resolution}  Root cause: ${result.root_cause}`);
+        if (result.comment)
+            console.log(`Comment: ${result.comment}`);
+    }
+}
+async function resolveCase(id, opts) {
+    const validResolutions = ['true_positive', 'false_positive', 'benign', 'duplicate'];
+    const validRootCauses = ['user_initiated', 'misconfiguration', 'expected_behavior', 'actual_threat', 'testing', 'unknown'];
+    if (!validResolutions.includes(opts.resolution)) {
+        console.error(`Invalid resolution: ${opts.resolution}\nValid: ${validResolutions.join(', ')}`);
+        return;
+    }
+    if (!validRootCauses.includes(opts.rootCause)) {
+        console.error(`Invalid root cause: ${opts.rootCause}\nValid: ${validRootCauses.join(', ')}`);
+        return;
+    }
+    const body = { resolution: opts.resolution, root_cause: opts.rootCause, comment: opts.comment };
+    const result = await callApi('POST', `/v1/agent/cases/${id}/resolve`, body);
+    if (!result)
+        return;
+    if (result.status === 'resolved') {
+        console.log(`\u2705 Case ${id} resolved as ${opts.resolution} (root cause: ${opts.rootCause})`);
+    }
+    else if (result.error) {
+        console.error(`\u274C ${result.error}`);
+    }
+    else {
+        console.log('Response:', JSON.stringify(result, null, 2));
+    }
+}

package/dist/src/config.d.ts

@@ -13,6 +13,8 @@ export interface Config {
     maxEvents: number;
     collectHostMetrics: boolean;
     redactionEnabled: boolean;
+    localEventBuffer: boolean;
+    localEventLimit: number;
     credentials: ShieldCredentials;
 }
 export declare const SHIELD_CONFIG_PATH: string;

package/dist/src/config.js

@@ -140,6 +140,8 @@ function loadConfig(overrides) {
         maxEvents: safeParseInt(process.env.MAX_EVENTS, 0),
         collectHostMetrics: overrides?.collectHostMetrics ?? (process.env.COLLECT_HOST_METRICS === 'true'),
         redactionEnabled: overrides?.redactionEnabled ?? (process.env.REDACTION_ENABLED !== 'false'),
+        localEventBuffer: process.env.SHIELD_LOCAL_EVENT_BUFFER !== 'false',
+        localEventLimit: safeParseInt(process.env.SHIELD_LOCAL_EVENT_LIMIT, 123),
         credentials,
     };
 }

package/dist/src/event-store.d.ts

@@ -0,0 +1,31 @@
+export interface EventSummary {
+    ts: string;
+    type: string;
+    tool: string;
+    summary: string;
+    session: string;
+    model: string;
+    redacted: boolean;
+}
+export interface EventStoreConfig {
+    filePath: string;
+    maxEvents: number;
+    maxAgeMs: number;
+}
+export declare function initEventStore(dataDir: string, opts?: Partial<Pick<EventStoreConfig, 'maxEvents' | 'maxAgeMs'>>): void;
+export declare function appendEvents(summaries: EventSummary[]): void;
+export declare function queryEvents(opts?: {
+    limit?: number;
+    type?: string;
+    sinceMs?: number;
+}): EventSummary[];
+export declare function summarizeEvents(sinceMs?: number): {
+    total: number;
+    byType: Record<string, number>;
+    byTool: Record<string, number>;
+    oldest: string | null;
+    newest: string | null;
+    redactedCount: number;
+};
+export declare function _resetForTesting(): void;
+export declare function _getConfigForTesting(): EventStoreConfig | null;

package/dist/src/event-store.js

@@ -0,0 +1,163 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initEventStore = initEventStore;
+exports.appendEvents = appendEvents;
+exports.queryEvents = queryEvents;
+exports.summarizeEvents = summarizeEvents;
+exports._resetForTesting = _resetForTesting;
+exports._getConfigForTesting = _getConfigForTesting;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const log = __importStar(require("./log"));
+const DEFAULT_MAX_EVENTS = 123;
+const DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+let _config = null;
+function initEventStore(dataDir, opts) {
+    const filePath = `${dataDir}/event-log.jsonl`;
+    const dir = (0, path_1.dirname)(filePath);
+    if (!(0, fs_1.existsSync)(dir))
+        (0, fs_1.mkdirSync)(dir, { recursive: true });
+    _config = {
+        filePath,
+        maxEvents: opts?.maxEvents ?? DEFAULT_MAX_EVENTS,
+        maxAgeMs: opts?.maxAgeMs ?? DEFAULT_MAX_AGE_MS,
+    };
+    log.info('event-store', `Initialized: ${filePath} (max ${_config.maxEvents} events, ${Math.round(_config.maxAgeMs / 3600000)}h retention)`);
+}
+function appendEvents(summaries) {
+    if (!_config)
+        return;
+    if (summaries.length === 0)
+        return;
+    try {
+        const lines = summaries.map(s => JSON.stringify(s)).join('\n') + '\n';
+        (0, fs_1.appendFileSync)(_config.filePath, lines);
+        trimIfNeeded();
+    }
+    catch (err) {
+        log.warn('event-store', `Failed to append ${summaries.length} events: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function queryEvents(opts) {
+    if (!_config)
+        return [];
+    const limit = opts?.limit ?? 20;
+    const events = readAll();
+    let filtered = events;
+    if (opts?.type) {
+        const t = opts.type.toUpperCase();
+        filtered = filtered.filter(e => e.type === t || e.tool === opts.type);
+    }
+    if (opts?.sinceMs) {
+        const cutoff = new Date(Date.now() - opts.sinceMs);
+        filtered = filtered.filter(e => new Date(e.ts) >= cutoff);
+    }
+    return filtered.slice(-limit);
+}
+function summarizeEvents(sinceMs) {
+    const events = sinceMs
+        ? queryEvents({ sinceMs, limit: 10000 })
+        : readAll();
+    const byType = {};
+    const byTool = {};
+    let redactedCount = 0;
+    for (const e of events) {
+        byType[e.type] = (byType[e.type] || 0) + 1;
+        byTool[e.tool] = (byTool[e.tool] || 0) + 1;
+        if (e.redacted)
+            redactedCount++;
+    }
+    return {
+        total: events.length,
+        byType,
+        byTool,
+        oldest: events.length > 0 ? events[0].ts : null,
+        newest: events.length > 0 ? events[events.length - 1].ts : null,
+        redactedCount,
+    };
+}
+function readAll() {
+    if (!_config || !(0, fs_1.existsSync)(_config.filePath))
+        return [];
+    try {
+        const raw = (0, fs_1.readFileSync)(_config.filePath, 'utf8');
+        return raw
+            .split('\n')
+            .filter(Boolean)
+            .map(line => {
+            try {
+                return JSON.parse(line);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((e) => e !== null);
+    }
+    catch (err) {
+        log.warn('event-store', `Failed to read events: ${err instanceof Error ? err.message : String(err)}`);
+        return [];
+    }
+}
+function trimIfNeeded() {
+    if (!_config)
+        return;
+    try {
+        let events = readAll();
+        const now = Date.now();
+        const before = events.length;
+        events = events.filter(e => now - new Date(e.ts).getTime() < _config.maxAgeMs);
+        if (events.length > _config.maxEvents) {
+            events = events.slice(-_config.maxEvents);
+        }
+        if (events.length < before) {
+            const lines = events.map(e => JSON.stringify(e)).join('\n') + (events.length > 0 ? '\n' : '');
+            const tmp = _config.filePath + '.tmp';
+            (0, fs_1.writeFileSync)(tmp, lines);
+            (0, fs_1.renameSync)(tmp, _config.filePath);
+            log.debug('event-store', `Trimmed ${before} → ${events.length} events`);
+        }
+    }
+    catch (err) {
+        log.warn('event-store', `Trim failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function _resetForTesting() {
+    _config = null;
+}
+function _getConfigForTesting() {
+    return _config;
+}

package/dist/src/index.js

@@ -33,6 +33,8 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
 const updater_1 = require("./updater");
 const config_1 = require("./config");
 const log = __importStar(require("./log"));
@@ -43,6 +45,9 @@ const redactor_1 = require("./redactor");
 const validator_1 = require("./validator");
 const fs_1 = require("fs");
 const version_1 = require("./version");
+const event_store_1 = require("./event-store");
+const case_monitor_1 = require("./case-monitor");
+const SHIELD_DATA_DIR = path.join(os.homedir(), '.openclaw', 'shield', 'data');
 let running = true;
 let lastTelemetryAt = 0;
 let consecutiveFailures = 0;
@@ -61,6 +66,10 @@ async function poll() {
     if (config.redactionEnabled) {
         (0, redactor_1.init)();
     }
+    (0, case_monitor_1.initCaseMonitor)(SHIELD_DATA_DIR);
+    if (config.localEventBuffer) {
+        (0, event_store_1.initEventStore)(SHIELD_DATA_DIR, { maxEvents: config.localEventLimit });
+    }
     log.info('bridge', `Starting — dryRun=${config.dryRun} poll=${config.pollIntervalMs}ms maxEvents=${config.maxEvents || 'unlimited'} redaction=${config.redactionEnabled} logLevel=${process.env.LOG_LEVEL || 'info'}`);
     const autoUpdateMode = process.env.SHIELD_AUTO_UPDATE ?? true;
     log.info('updater', `Startup update check (autoUpdate=${autoUpdateMode}, current=${version_1.VERSION})`);
@@ -70,8 +79,10 @@ async function poll() {
     }
     else if (startupUpdate.action === "updated") {
         log.info("updater", startupUpdate.message);
-        (0, updater_1.requestGatewayRestart)();
-        return;
+        const restarted = (0, updater_1.requestGatewayRestart)();
+        if (restarted)
+            return;
+        log.warn("updater", "Gateway restart failed — continuing with current version. Restart manually to load the update.");
     }
     else if (startupUpdate.action === "notify") {
         log.info("updater", startupUpdate.message);
@@ -139,9 +150,12 @@ async function poll() {
                 }
                 else if (updateResult.action === "updated") {
                     log.info("updater", updateResult.message);
-                    (0, updater_1.requestGatewayRestart)();
-                    running = false;
-                    break;
+                    const restarted = (0, updater_1.requestGatewayRestart)();
+                    if (restarted) {
+                        running = false;
+                        break;
+                    }
+                    log.warn("updater", "Gateway restart failed — continuing with current version. Restart manually to load the update.");
                 }
                 else if (updateResult.action === "rollback") {
                     log.warn("updater", updateResult.message);
@@ -178,6 +192,18 @@ async function poll() {
                         log.error('bridge', `Result: FAILED status=${r.statusCode} events=${r.eventCount} body=${r.body?.slice(0, 200)}`);
                     }
                 }
+                if (config.localEventBuffer && results.some(r => r.success)) {
+                    const summaries = envelopes.map(env => ({
+                        ts: env.event.timestamp,
+                        type: env.event.event_type || 'UNKNOWN',
+                        tool: env.event.tool_name || 'unknown',
+                        summary: env.event.tool_metadata?.["openclaw.display_summary"] || env.event.target?.command_line || env.event.tool_name || 'event',
+                        session: env.event.session_id || '?',
+                        model: env.event.model || '?',
+                        redacted: !!env.source?.plugin?.redaction_applied,
+                    }));
+                    (0, event_store_1.appendEvents)(summaries);
+                }
                 if (results.some(r => r.needsRegistration)) {
                     consecutiveFailures++;
                     registrationOk = false;
@@ -223,6 +249,18 @@ async function poll() {
             consecutiveFailures++;
             log.error('bridge', 'Poll error', err);
         }
+        try {
+            const creds = (0, config_1.loadCredentials)();
+            const platformConfig = {
+                apiUrl: config.platformApiUrl ?? null,
+                instanceId: creds?.instanceId || '',
+                hmacSecret: creds?.hmacSecret || '',
+            };
+            await (0, case_monitor_1.checkForNewCases)(platformConfig);
+        }
+        catch (err) {
+            log.debug('case-monitor', `Check error: ${err instanceof Error ? err.message : String(err)}`);
+        }
         if (!running)
             break;
         const interval = getBackoffInterval(config.pollIntervalMs);