averecion-lite 1.3.0

package/dist/log-watcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-watcher.d.ts","sourceRoot":"","sources":["../log-watcher.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AA6CtC,qBAAa,UAAW,SAAQ,YAAY;IAC1C,OAAO,CAAC,WAAW,CAAuB;IAC1C,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,UAAU,CAAgC;IAClD,OAAO,CAAC,YAAY,CAA+B;;IAMnD,KAAK,IAAI,IAAI;IAUb,IAAI,IAAI,IAAI;IAWZ,OAAO,CAAC,iBAAiB;IAOzB,OAAO,CAAC,eAAe;IAWvB,OAAO,CAAC,SAAS;IAqCjB,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,YAAY;IA+BpB,OAAO,CAAC,WAAW;IAWnB,OAAO,CAAC,YAAY;IAmHpB,OAAO,CAAC,eAAe;IAuCvB,OAAO,CAAC,eAAe;IA6BvB,OAAO,CAAC,aAAa;IAgBrB,OAAO,CAAC,gBAAgB;CAWzB;AAID,wBAAgB,eAAe,IAAI,UAAU,CAM5C;AAED,wBAAgB,cAAc,IAAI,IAAI,CAKrC;AAED,wBAAgB,aAAa,IAAI,UAAU,GAAG,IAAI,CAEjD"}

package/dist/log-watcher.js

@@ -0,0 +1,397 @@
+"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.LogWatcher = void 0;
+exports.startLogWatcher = startLogWatcher;
+exports.stopLogWatcher = stopLogWatcher;
+exports.getLogWatcher = getLogWatcher;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const events_1 = require("events");
+const storage_1 = require("./storage");
+const CLAWDBOT_LOG_DIR = "/tmp/clawdbot";
+const DANGEROUS_PATTERNS = [
+    { pattern: /rm\s+-rf?\s+\//, reason: "Dangerous rm command (root delete)" },
+    { pattern: /rm\s+-rf?\s+~/, reason: "Dangerous rm command (home delete)" },
+    { pattern: /:\(\)\s*{\s*:\|:&\s*};:/, reason: "Fork bomb detected" },
+    { pattern: /mkfs\./, reason: "Filesystem format command" },
+    { pattern: /dd\s+if=.*of=\/dev/, reason: "Dangerous dd to device" },
+    { pattern: />\s*\/dev\/sd[a-z]/, reason: "Direct write to block device" },
+    { pattern: /curl.*\|\s*(ba)?sh/, reason: "Curl pipe to shell" },
+    { pattern: /wget.*\|\s*(ba)?sh/, reason: "Wget pipe to shell" },
+    { pattern: /chmod\s+777/, reason: "Insecure permissions (777)" },
+    { pattern: /sudo\s+su/, reason: "Privilege escalation" },
+];
+const INJECTION_PATTERNS = [
+    { pattern: /ignore\s+(all\s+)?(previous|prior|above)\s+(instructions?|prompts?)/i, reason: "Prompt injection: ignore instructions" },
+    { pattern: /disregard\s+(all\s+)?(previous|prior|above)/i, reason: "Prompt injection: disregard" },
+    { pattern: /you\s+are\s+now\s+(a|an)\s+/i, reason: "Prompt injection: role override" },
+    { pattern: /jailbreak/i, reason: "Prompt injection: jailbreak attempt" },
+    { pattern: /DAN\s*mode/i, reason: "Prompt injection: DAN mode" },
+    { pattern: /pretend\s+(you'?re?|to\s+be)\s+/i, reason: "Prompt injection: pretend" },
+    { pattern: /bypass\s+(your\s+)?(restrictions?|rules?|guidelines?)/i, reason: "Prompt injection: bypass" },
+];
+class LogWatcher extends events_1.EventEmitter {
+    watchedFile = null;
+    watcher = null;
+    filePosition = 0;
+    activeRuns = new Map();
+    pollInterval = null;
+    constructor() {
+        super();
+    }
+    start() {
+        const logFile = this.getCurrentLogFile();
+        if (!logFile) {
+            console.log("[LogWatcher] ClawdBot log directory not found, will poll for it...");
+            this.pollInterval = setInterval(() => this.checkForLogFile(), 5000);
+            return;
+        }
+        this.watchFile(logFile);
+    }
+    stop() {
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+        if (this.pollInterval) {
+            clearInterval(this.pollInterval);
+            this.pollInterval = null;
+        }
+    }
+    getCurrentLogFile() {
+        if (!fs.existsSync(CLAWDBOT_LOG_DIR))
+            return null;
+        const today = new Date().toISOString().split("T")[0];
+        const logFile = path.join(CLAWDBOT_LOG_DIR, `clawdbot-${today}.log`);
+        return fs.existsSync(logFile) ? logFile : null;
+    }
+    checkForLogFile() {
+        const logFile = this.getCurrentLogFile();
+        if (logFile) {
+            if (this.pollInterval) {
+                clearInterval(this.pollInterval);
+                this.pollInterval = null;
+            }
+            this.watchFile(logFile);
+        }
+    }
+    watchFile(logFile) {
+        if (this.watchedFile === logFile)
+            return;
+        if (this.watcher) {
+            this.watcher.close();
+        }
+        this.watchedFile = logFile;
+        this.filePosition = fs.existsSync(logFile) ? fs.statSync(logFile).size : 0;
+        console.log(`[LogWatcher] Watching ${logFile} from position ${this.filePosition}`);
+        try {
+            this.watcher = fs.watch(logFile, (eventType) => {
+                if (eventType === "change") {
+                    this.readNewLines();
+                }
+            });
+            this.watcher.on("error", (err) => {
+                console.error("[LogWatcher] Watch error:", err);
+                this.scheduleRewatch();
+            });
+            setInterval(() => {
+                const currentLogFile = this.getCurrentLogFile();
+                if (currentLogFile && currentLogFile !== this.watchedFile) {
+                    console.log("[LogWatcher] Log file rotated, switching to new file");
+                    this.watchFile(currentLogFile);
+                }
+            }, 60000);
+        }
+        catch (err) {
+            console.error("[LogWatcher] Failed to watch file:", err);
+            this.scheduleRewatch();
+        }
+    }
+    scheduleRewatch() {
+        setTimeout(() => {
+            const logFile = this.getCurrentLogFile();
+            if (logFile)
+                this.watchFile(logFile);
+        }, 5000);
+    }
+    readNewLines() {
+        if (!this.watchedFile)
+            return;
+        try {
+            const stat = fs.statSync(this.watchedFile);
+            if (stat.size < this.filePosition) {
+                console.log("[LogWatcher] Log file truncated or rotated, resetting position");
+                this.filePosition = 0;
+            }
+            if (stat.size <= this.filePosition)
+                return;
+            const fd = fs.openSync(this.watchedFile, "r");
+            const buffer = Buffer.alloc(stat.size - this.filePosition);
+            fs.readSync(fd, buffer, 0, buffer.length, this.filePosition);
+            fs.closeSync(fd);
+            this.filePosition = stat.size;
+            const lines = buffer.toString("utf-8").split("\n");
+            for (const line of lines) {
+                if (line.trim()) {
+                    this.processLine(line);
+                }
+            }
+        }
+        catch (err) {
+            console.error("[LogWatcher] Error reading file:", err);
+        }
+    }
+    processLine(line) {
+        try {
+            const parsed = this.parseLogLine(line);
+            if (!parsed)
+                return;
+            if (parsed.toolEvent) {
+                this.handleToolEvent(parsed.toolEvent);
+            }
+        }
+        catch { }
+    }
+    parseLogLine(line) {
+        try {
+            const json = JSON.parse(line);
+            const meta = json._meta || {};
+            const timestamp = meta.date ? new Date(meta.date) : new Date();
+            const logLevel = meta.logLevelName || "INFO";
+            let subsystem = "";
+            let message = "";
+            if (typeof json["0"] === "string") {
+                try {
+                    const parsed = JSON.parse(json["0"]);
+                    subsystem = parsed.subsystem || "";
+                }
+                catch {
+                    subsystem = json["0"];
+                }
+            }
+            if (typeof json["1"] === "string") {
+                message = json["1"];
+            }
+            let toolEvent;
+            if (subsystem.includes("agent/embedded") && message) {
+                const startMatch = message.match(/embedded run tool start: runId=(\S+) tool=(\S+) toolCallId=(\S+)/);
+                if (startMatch) {
+                    toolEvent = {
+                        runId: startMatch[1],
+                        tool: startMatch[2],
+                        toolCallId: startMatch[3],
+                        phase: "start",
+                        timestamp,
+                        args: this.extractToolArgs(json),
+                    };
+                }
+                const endMatch = message.match(/embedded run tool end: runId=(\S+) tool=(\S+) toolCallId=(\S+)/);
+                if (endMatch) {
+                    toolEvent = {
+                        runId: endMatch[1],
+                        tool: endMatch[2],
+                        toolCallId: endMatch[3],
+                        phase: "end",
+                        timestamp,
+                    };
+                }
+                // Fallback: detect agent run start/done events (newer ClawdBot versions)
+                if (!toolEvent) {
+                    const runStartMatch = message.match(/embedded run start: runId=(\S+)/);
+                    if (runStartMatch) {
+                        toolEvent = {
+                            runId: runStartMatch[1],
+                            tool: "agent-run",
+                            toolCallId: `run-${runStartMatch[1]}`,
+                            phase: "start",
+                            timestamp,
+                            args: this.extractToolArgs(json),
+                        };
+                    }
+                    const runDoneMatch = message.match(/embedded run done: runId=(\S+)/);
+                    if (runDoneMatch) {
+                        toolEvent = {
+                            runId: runDoneMatch[1],
+                            tool: "agent-run",
+                            toolCallId: `run-${runDoneMatch[1]}`,
+                            phase: "end",
+                            timestamp,
+                        };
+                    }
+                }
+            }
+            // Check web-auto-reply for response content (contains actual command output)
+            if (!toolEvent && message && typeof json["1"] === "object") {
+                const data = json["1"];
+                if (data.text && typeof data.text === "string") {
+                    const text = data.text;
+                    // Check for shell output patterns (code blocks with command output)
+                    if (text.includes("```") && (text.includes("stanchat") || text.includes("drwx") || text.includes("total "))) {
+                        toolEvent = {
+                            runId: `reply-${Date.now()}`,
+                            tool: "exec",
+                            toolCallId: `exec-${Date.now()}`,
+                            phase: "start",
+                            timestamp,
+                            args: { output: text, command: "shell command" },
+                        };
+                    }
+                }
+            }
+            if (!toolEvent && message) {
+                const altStartMatch = message.match(/tool_call.*?name["\s:]+([^"\s,]+).*?id["\s:]+([^"\s,]+)/i);
+                if (altStartMatch) {
+                    toolEvent = {
+                        runId: `alt-${Date.now()}`,
+                        tool: altStartMatch[1],
+                        toolCallId: altStartMatch[2],
+                        phase: "start",
+                        timestamp,
+                        args: this.extractToolArgs(json),
+                    };
+                }
+            }
+            return { subsystem, message, timestamp, logLevel, toolEvent };
+        }
+        catch {
+            return null;
+        }
+    }
+    extractToolArgs(json) {
+        const args = {};
+        for (const key of Object.keys(json)) {
+            if (key === "_meta")
+                continue;
+            const val = json[key];
+            if (typeof val === "string") {
+                try {
+                    const parsed = JSON.parse(val);
+                    if (parsed && typeof parsed === "object") {
+                        if (parsed.args || parsed.arguments || parsed.input || parsed.command) {
+                            Object.assign(args, parsed.args || parsed.arguments || parsed.input || { command: parsed.command });
+                        }
+                        if (parsed.tool_input) {
+                            Object.assign(args, typeof parsed.tool_input === "string" ? { raw: parsed.tool_input } : parsed.tool_input);
+                        }
+                    }
+                }
+                catch { }
+                if (val.includes("rm ") || val.includes("curl ") || val.includes("wget ") ||
+                    val.includes("chmod ") || val.includes("sudo ") || val.includes("dd ")) {
+                    args.command = val;
+                }
+                if (/ignore\s+(previous|prior)/i.test(val) || /jailbreak/i.test(val) ||
+                    /you\s+are\s+now/i.test(val) || /bypass/i.test(val)) {
+                    args.suspiciousText = val;
+                }
+            }
+            else if (val && typeof val === "object") {
+                const obj = val;
+                if (obj.command)
+                    args.command = obj.command;
+                if (obj.input)
+                    args.input = obj.input;
+                if (obj.args)
+                    Object.assign(args, obj.args);
+            }
+        }
+        return args;
+    }
+    handleToolEvent(event) {
+        if (event.phase === "start") {
+            this.activeRuns.set(event.toolCallId, event);
+            const dangerAnalysis = this.analyzeDanger(event);
+            const injectionAnalysis = this.analyzeInjection(event);
+            const actionEvent = {
+                ts: event.timestamp.toISOString(),
+                tool: event.tool,
+                decision: dangerAnalysis.dangerous || injectionAnalysis.detected ? "blocked" : "approved",
+                reason: dangerAnalysis.reason || injectionAnalysis.reason || `Tool executed: ${event.tool}`,
+                egress: [],
+            };
+            (0, storage_1.appendEvent)(actionEvent);
+            this.emit("toolEvent", { ...event, analysis: { danger: dangerAnalysis, injection: injectionAnalysis }, actionEvent });
+            console.log(`🛡️ [LogWatcher] Tool: ${event.tool} | ${dangerAnalysis.dangerous ? "⚠️ DANGER" : injectionAnalysis.detected ? "🔴 INJECTION" : "✓ OK"}`);
+        }
+        else if (event.phase === "end") {
+            const startEvent = this.activeRuns.get(event.toolCallId);
+            if (startEvent) {
+                const duration = event.timestamp.getTime() - startEvent.timestamp.getTime();
+                this.emit("toolComplete", { ...event, duration });
+                this.activeRuns.delete(event.toolCallId);
+            }
+        }
+    }
+    analyzeDanger(event) {
+        if (event.tool !== "exec") {
+            return { dangerous: false, reason: "" };
+        }
+        const argsStr = JSON.stringify(event.args || {}).toLowerCase();
+        for (const { pattern, reason } of DANGEROUS_PATTERNS) {
+            if (pattern.test(argsStr)) {
+                return { dangerous: true, reason };
+            }
+        }
+        return { dangerous: false, reason: "" };
+    }
+    analyzeInjection(event) {
+        const argsStr = JSON.stringify(event.args || {});
+        for (const { pattern, reason } of INJECTION_PATTERNS) {
+            if (pattern.test(argsStr)) {
+                return { detected: true, reason };
+            }
+        }
+        return { detected: false, reason: "" };
+    }
+}
+exports.LogWatcher = LogWatcher;
+let watcher = null;
+function startLogWatcher() {
+    if (!watcher) {
+        watcher = new LogWatcher();
+        watcher.start();
+    }
+    return watcher;
+}
+function stopLogWatcher() {
+    if (watcher) {
+        watcher.stop();
+        watcher = null;
+    }
+}
+function getLogWatcher() {
+    return watcher;
+}

package/dist/metrics.d.ts

@@ -0,0 +1,53 @@
+import { ActionEvent } from "./storage";
+export interface LiteMetrics {
+    window: string;
+    kpis: {
+        approved: number;
+        blocked: number;
+        manualApproved: number;
+        highRiskIntercepts: number;
+        promptInjectionDetected: number;
+    };
+    egressTop: {
+        host: string;
+        calls: number;
+    }[];
+    skills: {
+        trusted: number;
+        unknownBlocked: number;
+        outdated: number;
+    };
+    instance: {
+        reverseProxyHardened: boolean;
+        dashboardLocalOnly: boolean;
+        secretsEnvOnly: boolean;
+    };
+    timeline: {
+        hours: string[];
+        approved: number[];
+        blocked: number[];
+    };
+    cost: {
+        inputTokens: number[];
+        outputTokens: number[];
+        estimatedUSD: number[];
+    };
+    lastActions: ActionEvent[];
+    config: {
+        enabled: boolean;
+        showMode: boolean;
+        showModeActionsRemaining: number;
+        protectionLevel: string;
+    } | null;
+    pendingApprovals: {
+        id: string;
+        tool: string;
+        reason: string;
+        createdAt: string;
+    }[];
+}
+declare const session: Record<string, number>;
+export declare function incrementMetric(k: keyof typeof session): void;
+export declare function getMetrics(hoursBack?: number): LiteMetrics;
+export {};
+//# sourceMappingURL=metrics.d.ts.map

package/dist/metrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.d.ts","sourceRoot":"","sources":["../metrics.ts"],"names":[],"mappings":"AAAA,OAAO,EAA4B,WAAW,EAAkC,MAAM,WAAW,CAAC;AAElG,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAC;QAAC,uBAAuB,EAAE,MAAM,CAAA;KAAE,CAAC;IACjI,SAAS,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC7C,MAAM,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IACtE,QAAQ,EAAE;QAAE,oBAAoB,EAAE,OAAO,CAAC;QAAC,kBAAkB,EAAE,OAAO,CAAC;QAAC,cAAc,EAAE,OAAO,CAAA;KAAE,CAAC;IAClG,QAAQ,EAAE;QAAE,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IACrE,IAAI,EAAE;QAAE,WAAW,EAAE,MAAM,EAAE,CAAC;QAAC,YAAY,EAAE,MAAM,EAAE,CAAC;QAAC,YAAY,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAChF,WAAW,EAAE,WAAW,EAAE,CAAC;IAC3B,MAAM,EAAE;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAC;QAAC,wBAAwB,EAAE,MAAM,CAAC;QAAC,eAAe,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAClH,gBAAgB,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CACrF;AAED,QAAA,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAqG,CAAC;AAC1I,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,OAAO,OAAO,QAAmB;AAE1E,wBAAgB,UAAU,CAAC,SAAS,SAAK,GAAG,WAAW,CA0CtD"}

package/dist/metrics.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.incrementMetric = incrementMetric;
+exports.getMetrics = getMetrics;
+const storage_1 = require("./storage");
+const session = { approved: 0, blocked: 0, manualApproved: 0, highRiskIntercepts: 0, promptInjectionDetected: 0 };
+function incrementMetric(k) { session[k]++; }
+function getMetrics(hoursBack = 24) {
+    const events = (0, storage_1.getEvents)(hoursBack);
+    const kpis = { approved: 0, blocked: 0, manualApproved: 0, highRiskIntercepts: 0, promptInjectionDetected: 0 };
+    const egressCounts = {};
+    const trusted = new Set(), unknownBlocked = new Set();
+    for (const e of events) {
+        if (e.decision === "approved")
+            kpis.approved++;
+        else if (e.decision === "blocked")
+            kpis.blocked++;
+        else if (e.decision === "manual") {
+            kpis.manualApproved++;
+            kpis.approved++;
+        }
+        if (e.reason.includes("highRisk"))
+            kpis.highRiskIntercepts++;
+        if (e.reason.includes("promptInjection"))
+            kpis.promptInjectionDetected++;
+        if (e.decision !== "blocked")
+            trusted.add(e.tool);
+        if (e.decision === "blocked" && e.reason === "unknownSkill")
+            unknownBlocked.add(e.tool);
+        for (const h of e.egress || [])
+            egressCounts[h] = (egressCounts[h] || 0) + 1;
+    }
+    const hours = [], approved = [], blocked = [];
+    const inputTokens = [], outputTokens = [], estimatedUSD = [];
+    const now = Date.now();
+    for (let i = 23; i >= 0; i--) {
+        const start = new Date(now - i * 3600000);
+        start.setMinutes(0, 0, 0);
+        const end = new Date(start.getTime() + 3600000);
+        hours.push(start.toISOString().slice(11, 16));
+        const hourEvents = events.filter(e => { const t = new Date(e.ts); return t >= start && t < end; });
+        approved.push(hourEvents.filter(e => e.decision !== "blocked").length);
+        blocked.push(hourEvents.filter(e => e.decision === "blocked").length);
+        inputTokens.push(hourEvents.reduce((s, e) => s + (e.inputTokens || 0), 0));
+        outputTokens.push(hourEvents.reduce((s, e) => s + (e.outputTokens || 0), 0));
+        estimatedUSD.push(hourEvents.reduce((s, e) => s + (e.estimatedUSD || 0), 0));
+    }
+    return {
+        window: `${hoursBack}h`, kpis,
+        egressTop: Object.entries(egressCounts).map(([host, calls]) => ({ host, calls })).sort((a, b) => b.calls - a.calls).slice(0, 5),
+        skills: { trusted: trusted.size, unknownBlocked: unknownBlocked.size, outdated: 0 },
+        instance: { reverseProxyHardened: true, dashboardLocalOnly: true, secretsEnvOnly: !!process.env.LITE_ADAPTER_SECRET },
+        timeline: { hours, approved, blocked }, cost: { inputTokens, outputTokens, estimatedUSD },
+        lastActions: (0, storage_1.getLastEvents)(10),
+        config: (0, storage_1.getConfig)(),
+        pendingApprovals: (0, storage_1.getPendingApprovals)()
+    };
+}

package/dist/policy.d.ts

@@ -0,0 +1,11 @@
+export interface LitePolicy {
+    allowedSkills: string[];
+    highRiskActions: string[];
+    blockUnknownSkills: boolean;
+}
+export declare function loadPolicy(policyPath?: string): LitePolicy;
+export declare function classifyAction(skill: string): {
+    decision: "approved" | "blocked" | "requires_confirmation";
+    reason: string;
+};
+//# sourceMappingURL=policy.d.ts.map

package/dist/policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../policy.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,UAAU;IACzB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,kBAAkB,EAAE,OAAO,CAAC;CAC7B;AAID,wBAAgB,UAAU,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,UAAU,CAS1D;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG;IAAE,QAAQ,EAAE,UAAU,GAAG,SAAS,GAAG,uBAAuB,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAM5H"}

package/dist/policy.js

@@ -0,0 +1,60 @@
+"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.loadPolicy = loadPolicy;
+exports.classifyAction = classifyAction;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+let policy = null;
+function loadPolicy(policyPath) {
+    if (policy)
+        return policy;
+    const filePath = policyPath || process.env.LITE_POLICY_PATH || path.join(__dirname, "lite-policy.json");
+    try {
+        policy = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        policy = { allowedSkills: ["email.send", "calendar.create", "web.get", "file.read"], highRiskActions: ["shell.exec", "file.write", "network.post", "delete.*", "wallet.tx"], blockUnknownSkills: true };
+    }
+    return policy;
+}
+function classifyAction(skill) {
+    const p = loadPolicy();
+    if (p.allowedSkills.includes(skill))
+        return { decision: "approved", reason: "allowlist" };
+    if (p.highRiskActions.some(pat => pat.includes("*") ? new RegExp("^" + pat.replace(/\*/g, ".*") + "$").test(skill) : pat === skill))
+        return { decision: "requires_confirmation", reason: "highRisk" };
+    return p.blockUnknownSkills ? { decision: "blocked", reason: "unknownSkill" } : { decision: "approved", reason: "defaultAllow" };
+}

package/dist/server.d.ts

@@ -0,0 +1,3 @@
+export declare function startServer(port?: number, host?: string): Promise<void>;
+export declare function stopServer(): Promise<void>;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../server.ts"],"names":[],"mappings":"AAsCA,wBAAsB,WAAW,CAAC,IAAI,SAAO,EAAE,IAAI,SAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAwI9E;AAED,wBAAsB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAiBhD"}