@4onstudios/iris-agent 0.1.0

package/dist/api/core/library/runtimeEventBus.js

@@ -0,0 +1,78 @@
+class RuntimeEventBus {
+    listeners = new Map();
+    buffer = new Map();
+    eventHistory = [];
+    maxHistorySize = 100;
+    subscribe(event, listener) {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, new Set());
+        }
+        this.listeners.get(event).add(listener);
+        if (this.buffer.has(event)) {
+            try {
+                listener(this.buffer.get(event));
+            }
+            catch (error) {
+                console.error(`Error in buffered event delivery for ${event}:`, error);
+            }
+        }
+        return () => {
+            const listeners = this.listeners.get(event);
+            if (listeners) {
+                listeners.delete(listener);
+                if (listeners.size === 0) {
+                    this.listeners.delete(event);
+                }
+            }
+        };
+    }
+    emit(event, data = undefined) {
+        this.trackEvent(event, data);
+        const listeners = this.listeners.get(event);
+        if (!listeners || listeners.size === 0) {
+            this.buffer.set(event, data);
+            return;
+        }
+        this.buffer.delete(event);
+        listeners.forEach((listener) => {
+            try {
+                listener(data);
+            }
+            catch (error) {
+                console.error(`Error in listener for event ${event}:`, error);
+            }
+        });
+    }
+    trackEvent(event, data) {
+        this.eventHistory.push({
+            event,
+            timestamp: Date.now(),
+            dataSize: data ? JSON.stringify(data).length : 0,
+        });
+        if (this.eventHistory.length > this.maxHistorySize) {
+            this.eventHistory.shift();
+        }
+    }
+    getStatistics() {
+        const stats = {};
+        this.eventHistory.forEach(({ event }) => {
+            stats[event] = (stats[event] || 0) + 1;
+        });
+        return stats;
+    }
+    clear() {
+        this.listeners.clear();
+        this.buffer.clear();
+    }
+}
+export const runtimeEventBus = new RuntimeEventBus();
+export const RuntimeEvents = {
+    FILE_OPEN: "file:open",
+    CODE_CHANGE: "code:change",
+    CONTEXT_UPDATE: "kg:context:update",
+    CONTEXT_QUERY: "kg:context:query",
+    TOKEN_USAGE: "kg:token:usage",
+    CACHE_HIT: "kg:cache:hit",
+    CACHE_MISS: "kg:cache:miss",
+};
+export default RuntimeEventBus;

package/dist/api/core/library/safetyMiddleware.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Safety Middleware for LLM Requests
+ * Detects and redacts PII and secrets before passing to LLM providers
+ */
+type SafetyPattern = {
+    name: string;
+    regex: RegExp;
+};
+type Redaction = {
+    type: string;
+    value: string;
+    position: number;
+    length: number;
+};
+export type SafetyMessage = {
+    role: string;
+    content: string;
+    [key: string]: unknown;
+};
+export type SafetyRequest = {
+    messages: SafetyMessage[];
+    metadata?: Record<string, unknown>;
+    [key: string]: unknown;
+};
+type AuditEvent = {
+    timestamp: string;
+    redactionCount: number;
+    redactionTypes: string[];
+    hasSecrets: boolean;
+    hasPII: boolean;
+    processingTime?: number;
+};
+type BlockEvent = {
+    reason: string;
+    timestamp: string;
+    redactionCount: number;
+    redactionTypes: string[];
+};
+type SafetyOptions = {
+    blockOnSecrets?: boolean;
+    blockOnPII?: boolean;
+    onAudit?: ((event: AuditEvent) => void) | null;
+    onBlock?: ((event: BlockEvent) => void) | null;
+};
+export declare const PII_PATTERNS: SafetyPattern[];
+export declare const SECRET_PATTERNS: SafetyPattern[];
+/**
+ * Redact sensitive information from text
+ * @param {string} text - Text to scan and redact
+ * @returns {{ output: string, redactions: Array<{type: string, value: string, position: number}> }}
+ */
+export declare function redact(text: string): {
+    output: string;
+    redactions: Redaction[];
+};
+/**
+ * Redact sensitive information from messages array
+ * @param {Array<{role: string, content: string}>} messages
+ * @returns {{safeMessages: Array, totalRedactions: Array}}
+ */
+export declare function redactMessages(messages: SafetyMessage[]): {
+    safeMessages: {
+        content: string;
+        role: string;
+    }[];
+    totalRedactions: {
+        messageIndex: number;
+        role: string;
+        redactions: Redaction[];
+    }[];
+};
+/**
+ * Higher-order function to wrap LLM handlers with safety middleware
+ * @param {Function} handler - Original LLM handler function
+ * @param {Object} options - Configuration options
+ * @param {boolean} options.blockOnSecrets - Block requests containing secrets
+ * @param {boolean} options.blockOnPII - Block requests containing PII
+ * @param {Function} options.onAudit - Audit callback function
+ * @param {Function} options.onBlock - Called when request is blocked
+ * @returns {Function} - Wrapped handler function
+ */
+export declare function withSafetyMiddleware(handler: (req: SafetyRequest) => Promise<unknown>, options?: SafetyOptions): (req: SafetyRequest) => Promise<unknown>;
+/**
+ * Create a safe LLM wrapper with default audit logging
+ * @param {Function} handler - Original LLM handler
+ * @param {Object} options - Options
+ * @returns {Function} - Safe wrapped handler
+ */
+export declare function createSafeLLM(handler: (req: SafetyRequest) => Promise<unknown>, options?: SafetyOptions): (req: SafetyRequest) => Promise<unknown>;
+declare const _default: {
+    redact: typeof redact;
+    redactMessages: typeof redactMessages;
+    withSafetyMiddleware: typeof withSafetyMiddleware;
+    createSafeLLM: typeof createSafeLLM;
+    PII_PATTERNS: SafetyPattern[];
+    SECRET_PATTERNS: SafetyPattern[];
+};
+export default _default;

package/dist/api/core/library/safetyMiddleware.js

@@ -0,0 +1,215 @@
+/**
+ * Safety Middleware for LLM Requests
+ * Detects and redacts PII and secrets before passing to LLM providers
+ */
+// PII Patterns - can be upgraded with stronger libraries like zod-validation or microsoft-presidio
+export const PII_PATTERNS = [
+    { name: "email", regex: /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi },
+    { name: "phone", regex: /\b\d{3}[-.\s]?\d{3}[-.\s]?\d{4}\b/g },
+    { name: "credit_card", regex: /\b\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}\b/g },
+    { name: "ssn", regex: /\b\d{3}-\d{2}-\d{4}\b/g },
+    { name: "ip_address", regex: /\b(?:\d{1,3}\.){3}\d{1,3}\b/g },
+];
+// Secret Patterns - API keys, tokens, etc.
+export const SECRET_PATTERNS = [
+    { name: "openai_key", regex: /sk-[a-zA-Z0-9]{20,}/g },
+    { name: "anthropic_key", regex: /sk-ant-[a-zA-Z0-9-_]{20,}/g },
+    { name: "aws_key", regex: /AKIA[0-9A-Z]{16}/g },
+    {
+        name: "aws_secret",
+        regex: /(?:aws_secret_access_key|AWS_SECRET_ACCESS_KEY)\s*[:=]\s*['"]?([A-Za-z0-9/+=]{40})['"]?/g,
+    },
+    { name: "jwt", regex: /eyJ[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+/g },
+    { name: "github_token", regex: /gh[pousr]_[A-Za-z0-9_]{36,}/g },
+    { name: "stripe_key", regex: /sk_(live|test)_[0-9a-zA-Z]{24,}/g },
+    { name: "huggingface_key", regex: /hf_[a-zA-Z0-9]{20,}/g },
+];
+/**
+ * Redact sensitive information from text
+ * @param {string} text - Text to scan and redact
+ * @returns {{ output: string, redactions: Array<{type: string, value: string, position: number}> }}
+ */
+export function redact(text) {
+    if (!text || typeof text !== "string") {
+        return { output: text, redactions: [] };
+    }
+    let redactions = [];
+    let output = text;
+    const allPatterns = [...PII_PATTERNS, ...SECRET_PATTERNS];
+    for (const pattern of allPatterns) {
+        const matches = [
+            ...text.matchAll(new RegExp(pattern.regex.source, pattern.regex.flags)),
+        ];
+        for (const match of matches) {
+            const originalValue = match[0];
+            const position = match.index;
+            redactions.push({
+                type: pattern.name,
+                value: originalValue,
+                position: position,
+                length: originalValue.length,
+            });
+        }
+    }
+    // Sort by position to replace from end to start (prevents offset issues)
+    redactions.sort((a, b) => b.position - a.position);
+    // Replace all matches
+    for (const redaction of redactions) {
+        const placeholder = `[REDACTED:${redaction.type}]`;
+        output =
+            output.substring(0, redaction.position) +
+                placeholder +
+                output.substring(redaction.position + redaction.length);
+    }
+    // Reverse to chronological order for logging
+    redactions.reverse();
+    return { output, redactions };
+}
+/**
+ * Redact sensitive information from messages array
+ * @param {Array<{role: string, content: string}>} messages
+ * @returns {{safeMessages: Array, totalRedactions: Array}}
+ */
+export function redactMessages(messages) {
+    let totalRedactions = [];
+    const safeMessages = messages.map((msg, index) => {
+        const { output, redactions } = redact(msg.content);
+        if (redactions.length > 0) {
+            totalRedactions.push({
+                messageIndex: index,
+                role: msg.role,
+                redactions: redactions,
+            });
+        }
+        return { ...msg, content: output };
+    });
+    return { safeMessages, totalRedactions };
+}
+/**
+ * Higher-order function to wrap LLM handlers with safety middleware
+ * @param {Function} handler - Original LLM handler function
+ * @param {Object} options - Configuration options
+ * @param {boolean} options.blockOnSecrets - Block requests containing secrets
+ * @param {boolean} options.blockOnPII - Block requests containing PII
+ * @param {Function} options.onAudit - Audit callback function
+ * @param {Function} options.onBlock - Called when request is blocked
+ * @returns {Function} - Wrapped handler function
+ */
+export function withSafetyMiddleware(
+// eslint-disable-next-line no-unused-vars
+handler, options = {}) {
+    const { blockOnSecrets = false, blockOnPII = false, onAudit = null, onBlock = null, } = options;
+    return async (req) => {
+        const startTime = Date.now();
+        let totalRedactions = [];
+        // Redact messages
+        const safeMessages = req.messages.map((msg) => {
+            const { output, redactions } = redact(msg.content);
+            totalRedactions.push(...redactions);
+            return { ...msg, content: output };
+        });
+        // Check for blocking conditions
+        const secretTypes = [
+            "openai_key",
+            "anthropic_key",
+            "aws_key",
+            "aws_secret",
+            "jwt",
+            "github_token",
+            "stripe_key",
+            "huggingface_key",
+        ];
+        const piiTypes = ["email", "phone", "credit_card", "ssn", "ip_address"];
+        const hasSecrets = totalRedactions.some((r) => secretTypes.includes(r.type));
+        const hasPII = totalRedactions.some((r) => piiTypes.includes(r.type));
+        // 🚨 Fail-closed if secrets detected
+        if (blockOnSecrets && hasSecrets) {
+            const error = new Error("Request blocked: secrets detected in prompt");
+            error.code = "SECURITY_BLOCK_SECRETS";
+            error.redactionTypes = [...new Set(totalRedactions.map((r) => r.type))];
+            if (onBlock) {
+                onBlock({
+                    reason: "secrets_detected",
+                    timestamp: new Date().toISOString(),
+                    redactionCount: totalRedactions.length,
+                    redactionTypes: error.redactionTypes,
+                });
+            }
+            throw error;
+        }
+        // 🚨 Fail-closed if PII detected
+        if (blockOnPII && hasPII) {
+            const error = new Error("Request blocked: PII detected in prompt");
+            error.code = "SECURITY_BLOCK_PII";
+            error.redactionTypes = [...new Set(totalRedactions.map((r) => r.type))];
+            if (onBlock) {
+                onBlock({
+                    reason: "pii_detected",
+                    timestamp: new Date().toISOString(),
+                    redactionCount: totalRedactions.length,
+                    redactionTypes: error.redactionTypes,
+                });
+            }
+            throw error;
+        }
+        // 🔍 Audit (no raw PII/secrets logged!)
+        if (onAudit && totalRedactions.length > 0) {
+            onAudit({
+                timestamp: new Date().toISOString(),
+                redactionCount: totalRedactions.length,
+                redactionTypes: [...new Set(totalRedactions.map((r) => r.type))],
+                hasSecrets,
+                hasPII,
+                processingTime: Date.now() - startTime,
+            });
+        }
+        // Call the wrapped handler with safe messages
+        const response = await handler({
+            ...req,
+            messages: safeMessages,
+            metadata: {
+                ...req.metadata,
+                redacted: totalRedactions.length > 0,
+                redactionCount: totalRedactions.length,
+            },
+        });
+        return response;
+    };
+}
+/**
+ * Create a safe LLM wrapper with default audit logging
+ * @param {Function} handler - Original LLM handler
+ * @param {Object} options - Options
+ * @returns {Function} - Safe wrapped handler
+ */
+export function createSafeLLM(
+// eslint-disable-next-line no-unused-vars
+handler, options = {}) {
+    const defaultAudit = (event) => {
+        if (event.redactionCount > 0) {
+            console.warn("[Safety Middleware]", {
+                redacted: event.redactionCount,
+                types: event.redactionTypes,
+                time: event.timestamp,
+            });
+        }
+    };
+    return withSafetyMiddleware(handler, {
+        blockOnSecrets: true,
+        blockOnPII: false,
+        onAudit: options.onAudit || defaultAudit,
+        onBlock: options.onBlock ||
+            ((event) => {
+                console.error("[Safety Middleware] BLOCKED:", event);
+            }),
+        ...options,
+    });
+}
+export default {
+    redact,
+    redactMessages,
+    withSafetyMiddleware,
+    createSafeLLM,
+    PII_PATTERNS,
+    SECRET_PATTERNS,
+};

package/dist/api/core/library/tauri.d.ts

@@ -0,0 +1,71 @@
+type FileSystemOptions = {
+    recursive?: boolean;
+};
+type DialogOpenOptions = {
+    directory?: boolean;
+    multiple?: boolean;
+    title?: string;
+    defaultPath?: string;
+    recursive?: boolean;
+    canCreateDirectories?: boolean;
+    fileAccessMode?: "copy" | "scoped";
+};
+type FileSystemApi = {
+    readFile: (path: string) => Promise<string>;
+    writeFile: (path: string, content: string) => Promise<void>;
+    readDir: (path: string, options?: FileSystemOptions) => Promise<any>;
+    exists: (path: string) => Promise<boolean>;
+    mkdir: (path: string, options?: FileSystemOptions) => Promise<any>;
+    remove: (path: string, options?: FileSystemOptions) => Promise<any>;
+    rename: (oldPath: string, newPath: string) => Promise<any>;
+};
+type DialogApi = {
+    open: (options?: DialogOpenOptions) => Promise<any>;
+    save: (options?: Record<string, unknown>) => Promise<any>;
+    message: (message: string, options?: Record<string, unknown>) => Promise<any>;
+    confirm: (message: string, options?: Record<string, unknown>) => Promise<any>;
+};
+type ShellApi = {
+    open: (url: string) => Promise<any>;
+};
+type ClipboardApi = {
+    writeText: (text: unknown) => Promise<boolean>;
+    readText: () => Promise<string>;
+};
+type NotificationsApi = {
+    send: (title: string, body?: string) => Promise<any>;
+    requestPermission: () => Promise<"granted" | "denied" | NotificationPermission>;
+};
+export declare const isTauri: () => boolean;
+/**
+ * File system operations.
+ */
+export declare const fileSystem: FileSystemApi;
+/**
+ * Dialog operations.
+ */
+export declare const dialog: DialogApi;
+export declare const tauriPath: {
+    homeDir: () => Promise<any>;
+};
+/**
+ * Shell operations.
+ */
+export declare const shell: ShellApi;
+/**
+ * Clipboard operations.
+ */
+export declare const clipboard: ClipboardApi;
+/**
+ * Notifications.
+ */
+export declare const notifications: NotificationsApi;
+declare const _default: {
+    isTauri: () => boolean;
+    fileSystem: FileSystemApi;
+    dialog: DialogApi;
+    shell: ShellApi;
+    clipboard: ClipboardApi;
+    notifications: NotificationsApi;
+};
+export default _default;

package/dist/api/core/library/tauri.js

@@ -0,0 +1,222 @@
+/**
+ * Tauri integration utilities.
+ */
+import { tauriImport } from "./tauriImport.js";
+export const isTauri = () => {
+    if (typeof window === "undefined") {
+        return false;
+    }
+    // In Node.js backend service, Tauri is never available
+    if (typeof window === "undefined") {
+        return false;
+    }
+    const hostname = window.location?.hostname || "";
+    const protocol = window.location?.protocol || "";
+    const userAgent = window.navigator?.userAgent || "";
+    return (window.__TAURI__ !== undefined ||
+        window.__TAURI_IPC__ !== undefined ||
+        hostname === "tauri.localhost" ||
+        hostname.endsWith(".tauri.localhost") ||
+        protocol === "tauri:" ||
+        /\bTauri\b/i.test(userAgent));
+};
+/**
+ * File system operations.
+ */
+export const fileSystem = {
+    readFile: async (path) => {
+        if (!isTauri()) {
+            throw new Error("File system operations only available in desktop app");
+        }
+        const { readTextFile } = await tauriImport("@tauri-apps/api/fs");
+        return await readTextFile(path);
+    },
+    writeFile: async (path, content) => {
+        if (!isTauri()) {
+            throw new Error("File system operations only available in desktop app");
+        }
+        const { writeTextFile } = await tauriImport("@tauri-apps/api/fs");
+        return await writeTextFile(path, content);
+    },
+    readDir: async (path, options = {}) => {
+        if (!isTauri()) {
+            throw new Error("File system operations only available in desktop app");
+        }
+        const { readDir } = await tauriImport("@tauri-apps/api/fs");
+        return await readDir(path, options);
+    },
+    exists: async (path) => {
+        if (!isTauri())
+            return false;
+        const { exists } = await tauriImport("@tauri-apps/api/fs");
+        return await exists(path);
+    },
+    mkdir: async (path, options = {}) => {
+        if (!isTauri()) {
+            throw new Error("File system operations only available in desktop app");
+        }
+        const { mkdir } = await tauriImport("@tauri-apps/api/fs");
+        return await mkdir(path, options);
+    },
+    remove: async (path, options = {}) => {
+        if (!isTauri()) {
+            throw new Error("File system operations only available in desktop app");
+        }
+        const { remove } = await tauriImport("@tauri-apps/api/fs");
+        return await remove(path, options);
+    },
+    rename: async (oldPath, newPath) => {
+        if (!isTauri()) {
+            throw new Error("File system operations only available in desktop app");
+        }
+        const { rename } = await tauriImport("@tauri-apps/api/fs");
+        return await rename(oldPath, newPath);
+    },
+};
+/**
+ * Dialog operations.
+ */
+export const dialog = {
+    open: async (options = {}) => {
+        if (!isTauri()) {
+            return new Promise((resolve) => {
+                const input = document.createElement("input");
+                input.type = "file";
+                if (options.directory) {
+                    input.webkitdirectory = true;
+                    input.setAttribute("directory", "");
+                }
+                input.multiple = options.multiple || false;
+                input.onchange = (e) => {
+                    const target = e.target;
+                    const files = Array.from(target?.files || []);
+                    resolve(files.length === 1 && !options.multiple ? files[0] : files);
+                };
+                input.click();
+            });
+        }
+        const { open } = await tauriImport("@tauri-apps/api/dialog");
+        return await open(options);
+    },
+    save: async (options = {}) => {
+        if (!isTauri()) {
+            throw new Error("Save dialog only available in desktop app");
+        }
+        const { save } = await tauriImport("@tauri-apps/api/dialog");
+        return await save(options);
+    },
+    message: async (message, options = {}) => {
+        if (!isTauri()) {
+            alert(message);
+            return;
+        }
+        const { message: showMessage } = await tauriImport("@tauri-apps/api/dialog");
+        return await showMessage(message, options);
+    },
+    confirm: async (message, options = {}) => {
+        if (!isTauri()) {
+            return confirm(message);
+        }
+        const { confirm: showConfirm } = await tauriImport("@tauri-apps/api/dialog");
+        return await showConfirm(message, options);
+    },
+};
+export const tauriPath = {
+    homeDir: async () => {
+        if (!isTauri()) {
+            return null;
+        }
+        const { homeDir } = await tauriImport("@tauri-apps/api/path");
+        return await homeDir();
+    },
+};
+/**
+ * Shell operations.
+ */
+export const shell = {
+    open: async (url) => {
+        if (!isTauri()) {
+            window.open(url, "_blank");
+            return;
+        }
+        const { open } = await tauriImport("@tauri-apps/api/shell");
+        return await open(url);
+    },
+};
+/**
+ * Clipboard operations.
+ */
+export const clipboard = {
+    writeText: async (text) => {
+        const value = typeof text === "string" ? text : String(text ?? "");
+        // 1) Prefer native Tauri clipboard in desktop builds.
+        if (isTauri()) {
+            try {
+                const { writeText } = await tauriImport("@tauri-apps/api/clipboard");
+                await writeText(value);
+                return true;
+            }
+            catch (error) {
+                console.warn("Tauri clipboard write failed, trying web fallback", error);
+            }
+        }
+        // 2) Standard async clipboard API.
+        try {
+            if (typeof navigator !== "undefined" && navigator.clipboard?.writeText) {
+                await navigator.clipboard.writeText(value);
+                return true;
+            }
+        }
+        catch (error) {
+            console.warn("navigator.clipboard.writeText failed", error);
+        }
+        throw new Error("Clipboard write is unavailable in this environment");
+    },
+    readText: async () => {
+        if (!isTauri()) {
+            if (navigator.clipboard) {
+                return await navigator.clipboard.readText();
+            }
+            return "";
+        }
+        const { readText } = await tauriImport("@tauri-apps/api/clipboard");
+        return await readText();
+    },
+};
+/**
+ * Notifications.
+ */
+export const notifications = {
+    send: async (title, body) => {
+        if (!isTauri()) {
+            if ("Notification" in window && Notification.permission === "granted") {
+                new Notification(title, { body });
+            }
+            return;
+        }
+        const { sendNotification } = await tauriImport("@tauri-apps/api/notification");
+        return await sendNotification({ title, body });
+    },
+    requestPermission: async () => {
+        if (!isTauri()) {
+            if ("Notification" in window) {
+                return await Notification.requestPermission();
+            }
+            return "denied";
+        }
+        const { isPermissionGranted, requestPermission } = await tauriImport("@tauri-apps/api/notification");
+        let permission = await isPermissionGranted();
+        if (!permission) {
+            permission = await requestPermission();
+        }
+        return permission ? "granted" : "denied";
+    },
+};
+export default {
+    isTauri,
+    fileSystem,
+    dialog,
+    shell,
+    clipboard,
+    notifications,
+};

package/dist/api/core/library/tauriImport.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Stub implementation for backend service
+ * Tauri modules are not available in Node.js backend
+ */
+export declare const tauriImport: (moduleName: string) => Promise<any>;

package/dist/api/core/library/tauriImport.js

@@ -0,0 +1,7 @@
+/**
+ * Stub implementation for backend service
+ * Tauri modules are not available in Node.js backend
+ */
+export const tauriImport = (moduleName) => {
+    return Promise.reject(new Error(`Tauri module '${moduleName}' not available in backend service`));
+};