@dollhousemcp/mcp-server 1.3.0

package/dist/src/persona/export-import/PersonaExporter.js

@@ -0,0 +1,99 @@
+/**
+ * Persona export functionality
+ */
+import { isDefaultPersona } from '../../constants/defaultPersonas.js';
+import { MAX_PERSONA_SIZE } from '../../constants/limits.js';
+export class PersonaExporter {
+    currentUser;
+    constructor(currentUser) {
+        this.currentUser = currentUser;
+    }
+    /**
+     * Export a single persona to JSON format
+     */
+    exportPersona(persona) {
+        // Check size limit
+        const size = JSON.stringify(persona).length;
+        if (size > MAX_PERSONA_SIZE) {
+            throw new Error(`Persona too large (${Math.round(size / 1024)}KB). Maximum size is ${Math.round(MAX_PERSONA_SIZE / 1024)}KB`);
+        }
+        return {
+            metadata: persona.metadata,
+            content: persona.content,
+            filename: persona.filename,
+            exportedAt: new Date().toISOString(),
+            exportedBy: this.currentUser || undefined
+        };
+    }
+    /**
+     * Export multiple personas to a bundle
+     */
+    exportBundle(personas, includeDefaults = true) {
+        const filteredPersonas = includeDefaults
+            ? personas
+            : personas.filter(p => !isDefaultPersona(p.filename));
+        return {
+            version: '1.0.0',
+            exportedAt: new Date().toISOString(),
+            exportedBy: this.currentUser || undefined,
+            personaCount: filteredPersonas.length,
+            personas: filteredPersonas.map(p => this.exportPersona(p))
+        };
+    }
+    /**
+     * Convert export to base64 for easy sharing
+     */
+    toBase64(data) {
+        const json = JSON.stringify(data, null, 2);
+        return Buffer.from(json).toString('base64');
+    }
+    /**
+     * Format export result for display
+     */
+    formatExportResult(persona, base64) {
+        return `✅ Successfully exported "${persona.metadata.name}"
+
+📦 Export Details:
+- Filename: ${persona.filename}
+- Version: ${persona.metadata.version || '1.0'}
+- Author: ${persona.metadata.author || 'unknown'}
+- Size: ${base64.length} characters (base64)
+
+📋 Export Data (Copy this to share):
+\`\`\`
+${base64}
+\`\`\`
+
+💡 To import this persona:
+- Use: import_persona "<paste the base64 data here>"
+- Or save to a file and use: import_persona "/path/to/file.json"`;
+    }
+    /**
+     * Format bundle export result
+     */
+    formatBundleResult(bundle, base64) {
+        const personaList = bundle.personas
+            .map(p => `  - ${p.metadata.name} (${p.filename})`)
+            .join('\n');
+        return `✅ Successfully exported ${bundle.personaCount} personas
+
+📦 Bundle Details:
+- Export Version: ${bundle.version}
+- Exported At: ${new Date(bundle.exportedAt).toLocaleString()}
+- Exported By: ${bundle.exportedBy || 'anonymous'}
+- Total Size: ${base64.length} characters (base64)
+
+📋 Personas Included:
+${personaList}
+
+💾 Export Data (Copy this to share):
+\`\`\`
+${base64}
+\`\`\`
+
+💡 To import this bundle:
+- Use: import_persona "<paste the base64 data here>"
+- Or save to a file and use: import_persona "/path/to/bundle.json"`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUGVyc29uYUV4cG9ydGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3BlcnNvbmEvZXhwb3J0LWltcG9ydC9QZXJzb25hRXhwb3J0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFJSCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxvQ0FBb0MsQ0FBQztBQUN0RSxPQUFPLEVBQUUsZ0JBQWdCLEVBQTRDLE1BQU0sMkJBQTJCLENBQUM7QUFrQnZHLE1BQU0sT0FBTyxlQUFlO0lBRWhCO0lBRFYsWUFDVSxXQUEwQjtRQUExQixnQkFBVyxHQUFYLFdBQVcsQ0FBZTtJQUNqQyxDQUFDO0lBRUo7O09BRUc7SUFDSCxhQUFhLENBQUMsT0FBZ0I7UUFDNUIsbUJBQW1CO1FBQ25CLE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLENBQUMsTUFBTSxDQUFDO1FBQzVDLElBQUksSUFBSSxHQUFHLGdCQUFnQixFQUFFLENBQUM7WUFDNUIsTUFBTSxJQUFJLEtBQUssQ0FBQyxzQkFBc0IsSUFBSSxDQUFDLEtBQUssQ0FBQyxJQUFJLEdBQUMsSUFBSSxDQUFDLHdCQUF3QixJQUFJLENBQUMsS0FBSyxDQUFDLGdCQUFnQixHQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUM1SCxDQUFDO1FBRUQsT0FBTztZQUNMLFFBQVEsRUFBRSxPQUFPLENBQUMsUUFBUTtZQUMxQixPQUFPLEVBQUUsT0FBTyxDQUFDLE9BQU87WUFDeEIsUUFBUSxFQUFFLE9BQU8sQ0FBQyxRQUFRO1lBQzFCLFVBQVUsRUFBRSxJQUFJLElBQUksRUFBRSxDQUFDLFdBQVcsRUFBRTtZQUNwQyxVQUFVLEVBQUUsSUFBSSxDQUFDLFdBQVcsSUFBSSxTQUFTO1NBQzFDLENBQUM7SUFDSixDQUFDO0lBRUQ7O09BRUc7SUFDSCxZQUFZLENBQUMsUUFBbUIsRUFBRSxrQkFBMkIsSUFBSTtRQUMvRCxNQUFNLGdCQUFnQixHQUFHLGVBQWU7WUFDdEMsQ0FBQyxDQUFDLFFBQVE7WUFDVixDQUFDLENBQUMsUUFBUSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsZ0JBQWdCLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUM7UUFFeEQsT0FBTztZQUNMLE9BQU8sRUFBRSxPQUFPO1lBQ2hCLFVBQVUsRUFBRSxJQUFJLElBQUksRUFBRSxDQUFDLFdBQVcsRUFBRTtZQUNwQyxVQUFVLEVBQUUsSUFBSSxDQUFDLFdBQVcsSUFBSSxTQUFTO1lBQ3pDLFlBQVksRUFBRSxnQkFBZ0IsQ0FBQyxNQUFNO1lBQ3JDLFFBQVEsRUFBRSxnQkFBZ0IsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDLENBQUMsQ0FBQyxDQUFDO1NBQzNELENBQUM7SUFDSixDQUFDO0lBRUQ7O09BRUc7SUFDSCxRQUFRLENBQUMsSUFBb0M7UUFDM0MsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLEVBQUUsSUFBSSxFQUFFLENBQUMsQ0FBQyxDQUFDO1FBQzNDLE9BQU8sTUFBTSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDOUMsQ0FBQztJQUVEOztPQUVHO0lBQ0gsa0JBQWtCLENBQUMsT0FBZ0IsRUFBRSxNQUFjO1FBQ2pELE9BQU8sNEJBQTRCLE9BQU8sQ0FBQyxRQUFRLENBQUMsSUFBSTs7O2NBRzlDLE9BQU8sQ0FBQyxRQUFRO2FBQ2pCLE9BQU8sQ0FBQyxRQUFRLENBQUMsT0FBTyxJQUFJLEtBQUs7WUFDbEMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxNQUFNLElBQUksU0FBUztVQUN0QyxNQUFNLENBQUMsTUFBTTs7OztFQUlyQixNQUFNOzs7OztpRUFLeUQsQ0FBQztJQUNoRSxDQUFDO0lBRUQ7O09BRUc7SUFDSCxrQkFBa0IsQ0FBQyxNQUFvQixFQUFFLE1BQWM7UUFDckQsTUFBTSxXQUFXLEdBQUcsTUFBTSxDQUFDLFFBQVE7YUFDaEMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsT0FBTyxDQUFDLENBQUMsUUFBUSxDQUFDLElBQUksS0FBSyxDQUFDLENBQUMsUUFBUSxHQUFHLENBQUM7YUFDbEQsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBRWQsT0FBTywyQkFBMkIsTUFBTSxDQUFDLFlBQVk7OztvQkFHckMsTUFBTSxDQUFDLE9BQU87aUJBQ2pCLElBQUksSUFBSSxDQUFDLE1BQU0sQ0FBQyxVQUFVLENBQUMsQ0FBQyxjQUFjLEVBQUU7aUJBQzVDLE1BQU0sQ0FBQyxVQUFVLElBQUksV0FBVztnQkFDakMsTUFBTSxDQUFDLE1BQU07OztFQUczQixXQUFXOzs7O0VBSVgsTUFBTTs7Ozs7bUVBSzJELENBQUM7SUFDbEUsQ0FBQztDQUVGIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBQZXJzb25hIGV4cG9ydCBmdW5jdGlvbmFsaXR5XG4gKi9cblxuaW1wb3J0IHsgUGVyc29uYSB9IGZyb20gJy4uLy4uL3R5cGVzL3BlcnNvbmEuanMnO1xuaW1wb3J0IHsgbG9nZ2VyIH0gZnJvbSAnLi4vLi4vdXRpbHMvbG9nZ2VyLmpzJztcbmltcG9ydCB7IGlzRGVmYXVsdFBlcnNvbmEgfSBmcm9tICcuLi8uLi9jb25zdGFudHMvZGVmYXVsdFBlcnNvbmFzLmpzJztcbmltcG9ydCB7IE1BWF9QRVJTT05BX1NJWkUsIE1BWF9CVU5ETEVfU0laRSwgTUFYX1BFUlNPTkFTX1BFUl9CVU5ETEUgfSBmcm9tICcuLi8uLi9jb25zdGFudHMvbGltaXRzLmpzJztcblxuZXhwb3J0IGludGVyZmFjZSBFeHBvcnRlZFBlcnNvbmEge1xuICBtZXRhZGF0YTogYW55O1xuICBjb250ZW50OiBzdHJpbmc7XG4gIGZpbGVuYW1lOiBzdHJpbmc7XG4gIGV4cG9ydGVkQXQ6IHN0cmluZztcbiAgZXhwb3J0ZWRCeT86IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBFeHBvcnRCdW5kbGUge1xuICB2ZXJzaW9uOiBzdHJpbmc7XG4gIGV4cG9ydGVkQXQ6IHN0cmluZztcbiAgZXhwb3J0ZWRCeT86IHN0cmluZztcbiAgcGVyc29uYUNvdW50OiBudW1iZXI7XG4gIHBlcnNvbmFzOiBFeHBvcnRlZFBlcnNvbmFbXTtcbn1cblxuZXhwb3J0IGNsYXNzIFBlcnNvbmFFeHBvcnRlciB7XG4gIGNvbnN0cnVjdG9yKFxuICAgIHByaXZhdGUgY3VycmVudFVzZXI6IHN0cmluZyB8IG51bGxcbiAgKSB7fVxuXG4gIC8qKlxuICAgKiBFeHBvcnQgYSBzaW5nbGUgcGVyc29uYSB0byBKU09OIGZvcm1hdFxuICAgKi9cbiAgZXhwb3J0UGVyc29uYShwZXJzb25hOiBQZXJzb25hKTogRXhwb3J0ZWRQZXJzb25hIHtcbiAgICAvLyBDaGVjayBzaXplIGxpbWl0XG4gICAgY29uc3Qgc2l6ZSA9IEpTT04uc3RyaW5naWZ5KHBlcnNvbmEpLmxlbmd0aDtcbiAgICBpZiAoc2l6ZSA+IE1BWF9QRVJTT05BX1NJWkUpIHtcbiAgICAgIHRocm93IG5ldyBFcnJvcihgUGVyc29uYSB0b28gbGFyZ2UgKCR7TWF0aC5yb3VuZChzaXplLzEwMjQpfUtCKS4gTWF4aW11bSBzaXplIGlzICR7TWF0aC5yb3VuZChNQVhfUEVSU09OQV9TSVpFLzEwMjQpfUtCYCk7XG4gICAgfVxuICAgIFxuICAgIHJldHVybiB7XG4gICAgICBtZXRhZGF0YTogcGVyc29uYS5tZXRhZGF0YSxcbiAgICAgIGNvbnRlbnQ6IHBlcnNvbmEuY29udGVudCxcbiAgICAgIGZpbGVuYW1lOiBwZXJzb25hLmZpbGVuYW1lLFxuICAgICAgZXhwb3J0ZWRBdDogbmV3IERhdGUoKS50b0lTT1N0cmluZygpLFxuICAgICAgZXhwb3J0ZWRCeTogdGhpcy5jdXJyZW50VXNlciB8fCB1bmRlZmluZWRcbiAgICB9O1xuICB9XG5cbiAgLyoqXG4gICAqIEV4cG9ydCBtdWx0aXBsZSBwZXJzb25hcyB0byBhIGJ1bmRsZVxuICAgKi9cbiAgZXhwb3J0QnVuZGxlKHBlcnNvbmFzOiBQZXJzb25hW10sIGluY2x1ZGVEZWZhdWx0czogYm9vbGVhbiA9IHRydWUpOiBFeHBvcnRCdW5kbGUge1xuICAgIGNvbnN0IGZpbHRlcmVkUGVyc29uYXMgPSBpbmNsdWRlRGVmYXVsdHMgXG4gICAgICA/IHBlcnNvbmFzIFxuICAgICAgOiBwZXJzb25hcy5maWx0ZXIocCA9PiAhaXNEZWZhdWx0UGVyc29uYShwLmZpbGVuYW1lKSk7XG5cbiAgICByZXR1cm4ge1xuICAgICAgdmVyc2lvbjogJzEuMC4wJyxcbiAgICAgIGV4cG9ydGVkQXQ6IG5ldyBEYXRlKCkudG9JU09TdHJpbmcoKSxcbiAgICAgIGV4cG9ydGVkQnk6IHRoaXMuY3VycmVudFVzZXIgfHwgdW5kZWZpbmVkLFxuICAgICAgcGVyc29uYUNvdW50OiBmaWx0ZXJlZFBlcnNvbmFzLmxlbmd0aCxcbiAgICAgIHBlcnNvbmFzOiBmaWx0ZXJlZFBlcnNvbmFzLm1hcChwID0+IHRoaXMuZXhwb3J0UGVyc29uYShwKSlcbiAgICB9O1xuICB9XG5cbiAgLyoqXG4gICAqIENvbnZlcnQgZXhwb3J0IHRvIGJhc2U2NCBmb3IgZWFzeSBzaGFyaW5nXG4gICAqL1xuICB0b0Jhc2U2NChkYXRhOiBFeHBvcnRlZFBlcnNvbmEgfCBFeHBvcnRCdW5kbGUpOiBzdHJpbmcge1xuICAgIGNvbnN0IGpzb24gPSBKU09OLnN0cmluZ2lmeShkYXRhLCBudWxsLCAyKTtcbiAgICByZXR1cm4gQnVmZmVyLmZyb20oanNvbikudG9TdHJpbmcoJ2Jhc2U2NCcpO1xuICB9XG5cbiAgLyoqXG4gICAqIEZvcm1hdCBleHBvcnQgcmVzdWx0IGZvciBkaXNwbGF5XG4gICAqL1xuICBmb3JtYXRFeHBvcnRSZXN1bHQocGVyc29uYTogUGVyc29uYSwgYmFzZTY0OiBzdHJpbmcpOiBzdHJpbmcge1xuICAgIHJldHVybiBg4pyFIFN1Y2Nlc3NmdWxseSBleHBvcnRlZCBcIiR7cGVyc29uYS5tZXRhZGF0YS5uYW1lfVwiXG5cbvCfk6YgRXhwb3J0IERldGFpbHM6XG4tIEZpbGVuYW1lOiAke3BlcnNvbmEuZmlsZW5hbWV9XG4tIFZlcnNpb246ICR7cGVyc29uYS5tZXRhZGF0YS52ZXJzaW9uIHx8ICcxLjAnfVxuLSBBdXRob3I6ICR7cGVyc29uYS5tZXRhZGF0YS5hdXRob3IgfHwgJ3Vua25vd24nfVxuLSBTaXplOiAke2Jhc2U2NC5sZW5ndGh9IGNoYXJhY3RlcnMgKGJhc2U2NClcblxu8J+TiyBFeHBvcnQgRGF0YSAoQ29weSB0aGlzIHRvIHNoYXJlKTpcblxcYFxcYFxcYFxuJHtiYXNlNjR9XG5cXGBcXGBcXGBcblxu8J+SoSBUbyBpbXBvcnQgdGhpcyBwZXJzb25hOlxuLSBVc2U6IGltcG9ydF9wZXJzb25hIFwiPHBhc3RlIHRoZSBiYXNlNjQgZGF0YSBoZXJlPlwiXG4tIE9yIHNhdmUgdG8gYSBmaWxlIGFuZCB1c2U6IGltcG9ydF9wZXJzb25hIFwiL3BhdGgvdG8vZmlsZS5qc29uXCJgO1xuICB9XG5cbiAgLyoqXG4gICAqIEZvcm1hdCBidW5kbGUgZXhwb3J0IHJlc3VsdFxuICAgKi9cbiAgZm9ybWF0QnVuZGxlUmVzdWx0KGJ1bmRsZTogRXhwb3J0QnVuZGxlLCBiYXNlNjQ6IHN0cmluZyk6IHN0cmluZyB7XG4gICAgY29uc3QgcGVyc29uYUxpc3QgPSBidW5kbGUucGVyc29uYXNcbiAgICAgIC5tYXAocCA9PiBgICAtICR7cC5tZXRhZGF0YS5uYW1lfSAoJHtwLmZpbGVuYW1lfSlgKVxuICAgICAgLmpvaW4oJ1xcbicpO1xuXG4gICAgcmV0dXJuIGDinIUgU3VjY2Vzc2Z1bGx5IGV4cG9ydGVkICR7YnVuZGxlLnBlcnNvbmFDb3VudH0gcGVyc29uYXNcblxu8J+TpiBCdW5kbGUgRGV0YWlsczpcbi0gRXhwb3J0IFZlcnNpb246ICR7YnVuZGxlLnZlcnNpb259XG4tIEV4cG9ydGVkIEF0OiAke25ldyBEYXRlKGJ1bmRsZS5leHBvcnRlZEF0KS50b0xvY2FsZVN0cmluZygpfVxuLSBFeHBvcnRlZCBCeTogJHtidW5kbGUuZXhwb3J0ZWRCeSB8fCAnYW5vbnltb3VzJ31cbi0gVG90YWwgU2l6ZTogJHtiYXNlNjQubGVuZ3RofSBjaGFyYWN0ZXJzIChiYXNlNjQpXG5cbvCfk4sgUGVyc29uYXMgSW5jbHVkZWQ6XG4ke3BlcnNvbmFMaXN0fVxuXG7wn5K+IEV4cG9ydCBEYXRhIChDb3B5IHRoaXMgdG8gc2hhcmUpOlxuXFxgXFxgXFxgXG4ke2Jhc2U2NH1cblxcYFxcYFxcYFxuXG7wn5KhIFRvIGltcG9ydCB0aGlzIGJ1bmRsZTpcbi0gVXNlOiBpbXBvcnRfcGVyc29uYSBcIjxwYXN0ZSB0aGUgYmFzZTY0IGRhdGEgaGVyZT5cIlxuLSBPciBzYXZlIHRvIGEgZmlsZSBhbmQgdXNlOiBpbXBvcnRfcGVyc29uYSBcIi9wYXRoL3RvL2J1bmRsZS5qc29uXCJgO1xuICB9XG5cbn0iXX0=

package/dist/src/persona/export-import/PersonaImporter.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Persona import functionality with validation
+ */
+import { Persona } from '../../types/persona.js';
+export interface ImportResult {
+    success: boolean;
+    message: string;
+    persona?: Persona;
+    filename?: string;
+    conflicts?: string[];
+}
+export declare class PersonaImporter {
+    private personasDir;
+    private currentUser;
+    constructor(personasDir: string, currentUser: string | null);
+    /**
+     * Import a persona from various sources
+     */
+    importPersona(source: string, existingPersonas: Map<string, Persona>, overwrite?: boolean): Promise<ImportResult>;
+    /**
+     * Import from file path
+     */
+    private importFromFile;
+    /**
+     * Import from base64 string
+     */
+    private importFromBase64;
+    /**
+     * Import from raw markdown content
+     */
+    private importFromMarkdown;
+    /**
+     * Import a bundle of personas
+     */
+    private importBundle;
+    /**
+     * Create persona from exported data
+     */
+    private createPersonaFromExport;
+    /**
+     * Validate and enrich metadata
+     */
+    private validateAndEnrichMetadata;
+    /**
+     * Find conflicts with existing personas
+     */
+    private findConflicts;
+    /**
+     * Check if string is base64
+     */
+    private isBase64;
+    /**
+     * Type guard for ExportedPersona
+     */
+    private isExportedPersona;
+    /**
+     * Type guard for ExportBundle
+     */
+    private isExportBundle;
+    /**
+     * Format bundle import results
+     */
+    private formatBundleImportResult;
+}
+//# sourceMappingURL=PersonaImporter.d.ts.map

package/dist/src/persona/export-import/PersonaImporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersonaImporter.d.ts","sourceRoot":"","sources":["../../../../src/persona/export-import/PersonaImporter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAKH,OAAO,EAAE,OAAO,EAAmB,MAAM,wBAAwB,CAAC;AASlE,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,qBAAa,eAAe;IAExB,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,WAAW;gBADX,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GAAG,IAAI;IAGpC;;OAEG;IACG,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS,UAAQ,GAAG,OAAO,CAAC,YAAY,CAAC;IA+CrH;;OAEG;YACW,cAAc;IA+B5B;;OAEG;YACW,gBAAgB;IAgB9B;;OAEG;YACW,kBAAkB;IAmChC;;OAEG;YACW,YAAY;IA4B1B;;OAEG;YACW,uBAAuB;IA8DrC;;OAEG;YACW,yBAAyB;IAuBvC;;OAEG;IACH,OAAO,CAAC,aAAa;IAYrB;;OAEG;IACH,OAAO,CAAC,QAAQ;IAQhB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAOzB;;OAEG;IACH,OAAO,CAAC,cAAc;IAOtB;;OAEG;IACH,OAAO,CAAC,wBAAwB;CAejC"}

package/dist/src/persona/export-import/PersonaImporter.js

@@ -0,0 +1,313 @@
+/**
+ * Persona import functionality with validation
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import matter from 'gray-matter';
+import { SecureYamlParser } from '../../security/secureYamlParser.js';
+import { ContentValidator } from '../../security/contentValidator.js';
+import { validateFilename, validatePath, validateContentSize } from '../../security/InputValidator.js';
+import { FileLockManager } from '../../security/fileLockManager.js';
+import { generateUniqueId } from '../../utils/filesystem.js';
+import { logger } from '../../utils/logger.js';
+export class PersonaImporter {
+    personasDir;
+    currentUser;
+    constructor(personasDir, currentUser) {
+        this.personasDir = personasDir;
+        this.currentUser = currentUser;
+    }
+    /**
+     * Import a persona from various sources
+     */
+    async importPersona(source, existingPersonas, overwrite = false) {
+        try {
+            // Determine source type
+            let personaData = null;
+            // Check if it's a file path
+            if (source.startsWith('/') || source.startsWith('./') || source.endsWith('.md') || source.endsWith('.json')) {
+                personaData = await this.importFromFile(source);
+            }
+            // Check if it's base64 encoded
+            else if (this.isBase64(source)) {
+                personaData = await this.importFromBase64(source);
+            }
+            // Try parsing as JSON directly
+            else {
+                try {
+                    const parsed = JSON.parse(source);
+                    if (this.isExportBundle(parsed)) {
+                        return this.importBundle(parsed, existingPersonas, overwrite);
+                    }
+                    else if (this.isExportedPersona(parsed)) {
+                        personaData = parsed;
+                    }
+                }
+                catch {
+                    // Not JSON, might be raw markdown
+                    return this.importFromMarkdown(source, existingPersonas, overwrite);
+                }
+            }
+            if (!personaData) {
+                return {
+                    success: false,
+                    message: "Could not parse import source. Please provide a file path, JSON string, or base64 encoded data."
+                };
+            }
+            // Validate and create persona
+            return await this.createPersonaFromExport(personaData, existingPersonas, overwrite);
+        }
+        catch (error) {
+            logger.error('Import error', error);
+            return {
+                success: false,
+                message: `Import failed: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    /**
+     * Import from file path
+     */
+    async importFromFile(filePath) {
+        try {
+            // Validate path
+            const validatedPath = validatePath(filePath);
+            const content = await fs.readFile(validatedPath, 'utf-8');
+            if (filePath.endsWith('.json')) {
+                const parsed = JSON.parse(content);
+                if (this.isExportedPersona(parsed)) {
+                    return parsed;
+                }
+                else if (this.isExportBundle(parsed)) {
+                    throw new Error("This is a bundle file. It will be imported as multiple personas.");
+                }
+            }
+            else if (filePath.endsWith('.md')) {
+                // Parse markdown file
+                const { data, content: mdContent } = matter(content);
+                const filename = path.basename(filePath);
+                return {
+                    metadata: data,
+                    content: mdContent,
+                    filename: filename,
+                    exportedAt: new Date().toISOString()
+                };
+            }
+        }
+        catch (error) {
+            logger.error('File import error', error);
+            throw error;
+        }
+        return null;
+    }
+    /**
+     * Import from base64 string
+     */
+    async importFromBase64(base64) {
+        try {
+            const json = Buffer.from(base64, 'base64').toString('utf-8');
+            const parsed = JSON.parse(json);
+            if (this.isExportedPersona(parsed)) {
+                return parsed;
+            }
+            else if (this.isExportBundle(parsed)) {
+                throw new Error("This is a bundle. It will be imported as multiple personas.");
+            }
+        }
+        catch (error) {
+            logger.error('Base64 import error', error);
+        }
+        return null;
+    }
+    /**
+     * Import from raw markdown content
+     */
+    async importFromMarkdown(content, existingPersonas, overwrite) {
+        try {
+            // Validate content size
+            validateContentSize(content, 100 * 1024); // 100KB limit
+            // Try to parse as markdown with frontmatter
+            const { data, content: mdContent } = matter(content);
+            if (!data.name || !data.description) {
+                return {
+                    success: false,
+                    message: "Invalid persona format. Must include name and description in YAML frontmatter."
+                };
+            }
+            const metadata = data;
+            const filename = `${metadata.name.toLowerCase().replace(/\s+/g, '-')}.md`;
+            const exportedPersona = {
+                metadata,
+                content: mdContent,
+                filename,
+                exportedAt: new Date().toISOString(),
+                exportedBy: this.currentUser || undefined
+            };
+            return await this.createPersonaFromExport(exportedPersona, existingPersonas, overwrite);
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to parse markdown: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    /**
+     * Import a bundle of personas
+     */
+    async importBundle(bundle, existingPersonas, overwrite) {
+        const results = {
+            success: true,
+            imported: [],
+            failed: [],
+            conflicts: []
+        };
+        for (const personaData of bundle.personas) {
+            const result = await this.createPersonaFromExport(personaData, existingPersonas, overwrite);
+            if (result.success) {
+                results.imported.push(personaData.metadata.name);
+            }
+            else {
+                results.failed.push(`${personaData.metadata.name}: ${result.message}`);
+                if (result.conflicts) {
+                    results.conflicts.push(...result.conflicts);
+                }
+            }
+        }
+        return {
+            success: results.failed.length === 0,
+            message: this.formatBundleImportResult(results),
+            conflicts: results.conflicts.length > 0 ? results.conflicts : undefined
+        };
+    }
+    /**
+     * Create persona from exported data
+     */
+    async createPersonaFromExport(exportData, existingPersonas, overwrite) {
+        try {
+            // Validate metadata
+            const metadata = await this.validateAndEnrichMetadata(exportData.metadata);
+            // Validate content
+            const validationResult = ContentValidator.validateAndSanitize(exportData.content);
+            if (!validationResult.isValid && validationResult.severity === 'critical') {
+                throw new Error(`Critical security threat detected: ${validationResult.detectedPatterns?.join(', ')}`);
+            }
+            const sanitizedContent = validationResult.sanitizedContent || exportData.content;
+            // Generate safe filename
+            let filename = validateFilename(exportData.filename || `${metadata.name.toLowerCase().replace(/\s+/g, '-')}.md`);
+            // Check for conflicts
+            const conflicts = this.findConflicts(metadata.name, filename, existingPersonas);
+            if (conflicts.length > 0 && !overwrite) {
+                return {
+                    success: false,
+                    message: `Persona already exists: ${conflicts.join(', ')}. Use overwrite=true to replace.`,
+                    conflicts
+                };
+            }
+            // Create the persona file
+            const personaPath = path.join(this.personasDir, filename);
+            const fileContent = matter.stringify(sanitizedContent, metadata);
+            // Use file locking to prevent race conditions
+            await FileLockManager.withLock(`persona:${metadata.name}`, async () => {
+                await FileLockManager.atomicWriteFile(personaPath, fileContent);
+            });
+            // Create persona object
+            const persona = {
+                metadata,
+                content: sanitizedContent,
+                filename,
+                unique_id: metadata.unique_id
+            };
+            return {
+                success: true,
+                message: `Successfully imported "${metadata.name}"`,
+                persona,
+                filename
+            };
+        }
+        catch (error) {
+            logger.error('Create persona error', error);
+            return {
+                success: false,
+                message: `Failed to create persona: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+    /**
+     * Validate and enrich metadata
+     */
+    async validateAndEnrichMetadata(metadata) {
+        // Ensure required fields
+        if (!metadata.name || !metadata.description) {
+            throw new Error("Missing required fields: name and description");
+        }
+        // Generate unique_id if missing
+        if (!metadata.unique_id) {
+            metadata.unique_id = generateUniqueId(metadata.name, this.currentUser || 'imported');
+        }
+        // Set defaults
+        metadata.version = metadata.version || '1.0';
+        metadata.author = metadata.author || this.currentUser || 'imported';
+        metadata.category = metadata.category || 'custom';
+        metadata.created_date = metadata.created_date || new Date().toISOString();
+        // Validate with YAML parser for security
+        const validated = await SecureYamlParser.parse(matter.stringify('', metadata));
+        return validated.data;
+    }
+    /**
+     * Find conflicts with existing personas
+     */
+    findConflicts(name, filename, existingPersonas) {
+        const conflicts = [];
+        for (const [key, persona] of existingPersonas) {
+            if (persona.metadata.name === name || persona.filename === filename) {
+                conflicts.push(key);
+            }
+        }
+        return conflicts;
+    }
+    /**
+     * Check if string is base64
+     */
+    isBase64(str) {
+        // Check length is multiple of 4
+        if (str.length % 4 !== 0)
+            return false;
+        // Check for valid base64 characters and padding
+        return /^[A-Za-z0-9+/]*={0,2}$/.test(str);
+    }
+    /**
+     * Type guard for ExportedPersona
+     */
+    isExportedPersona(obj) {
+        return obj &&
+            typeof obj.metadata === 'object' &&
+            typeof obj.content === 'string' &&
+            typeof obj.filename === 'string';
+    }
+    /**
+     * Type guard for ExportBundle
+     */
+    isExportBundle(obj) {
+        return obj &&
+            typeof obj.version === 'string' &&
+            Array.isArray(obj.personas) &&
+            typeof obj.personaCount === 'number';
+    }
+    /**
+     * Format bundle import results
+     */
+    formatBundleImportResult(results) {
+        let message = `Bundle Import Summary:\n`;
+        message += `✅ Successfully imported: ${results.imported.length} personas\n`;
+        if (results.imported.length > 0) {
+            message += `Imported:\n${results.imported.map((n) => `  - ${n}`).join('\n')}\n`;
+        }
+        if (results.failed.length > 0) {
+            message += `\n❌ Failed: ${results.failed.length} personas\n`;
+            message += `Errors:\n${results.failed.map((e) => `  - ${e}`).join('\n')}`;
+        }
+        return message;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PersonaImporter.js","sourceRoot":"","sources":["../../../../src/persona/export-import/PersonaImporter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Persona import functionality with validation\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport matter from 'gray-matter';\nimport { Persona, PersonaMetadata } from '../../types/persona.js';\nimport { ExportedPersona, ExportBundle } from './PersonaExporter.js';\nimport { SecureYamlParser } from '../../security/secureYamlParser.js';\nimport { ContentValidator } from '../../security/contentValidator.js';\nimport { validateFilename, validatePath, sanitizeInput, validateContentSize } from '../../security/InputValidator.js';\nimport { FileLockManager } from '../../security/fileLockManager.js';\nimport { generateUniqueId } from '../../utils/filesystem.js';\nimport { logger } from '../../utils/logger.js';\n\nexport interface ImportResult {\n  success: boolean;\n  message: string;\n  persona?: Persona;\n  filename?: string;\n  conflicts?: string[];\n}\n\nexport class PersonaImporter {\n  constructor(\n    private personasDir: string,\n    private currentUser: string | null\n  ) {}\n\n  /**\n   * Import a persona from various sources\n   */\n  async importPersona(source: string, existingPersonas: Map<string, Persona>, overwrite = false): Promise<ImportResult> {\n    try {\n      // Determine source type\n      let personaData: ExportedPersona | null = null;\n\n      // Check if it's a file path\n      if (source.startsWith('/') || source.startsWith('./') || source.endsWith('.md') || source.endsWith('.json')) {\n        personaData = await this.importFromFile(source);\n      } \n      // Check if it's base64 encoded\n      else if (this.isBase64(source)) {\n        personaData = await this.importFromBase64(source);\n      }\n      // Try parsing as JSON directly\n      else {\n        try {\n          const parsed = JSON.parse(source);\n          if (this.isExportBundle(parsed)) {\n            return this.importBundle(parsed, existingPersonas, overwrite);\n          } else if (this.isExportedPersona(parsed)) {\n            personaData = parsed;\n          }\n        } catch {\n          // Not JSON, might be raw markdown\n          return this.importFromMarkdown(source, existingPersonas, overwrite);\n        }\n      }\n\n      if (!personaData) {\n        return {\n          success: false,\n          message: \"Could not parse import source. Please provide a file path, JSON string, or base64 encoded data.\"\n        };\n      }\n\n      // Validate and create persona\n      return await this.createPersonaFromExport(personaData, existingPersonas, overwrite);\n\n    } catch (error) {\n      logger.error('Import error', error);\n      return {\n        success: false,\n        message: `Import failed: ${error instanceof Error ? error.message : String(error)}`\n      };\n    }\n  }\n\n  /**\n   * Import from file path\n   */\n  private async importFromFile(filePath: string): Promise<ExportedPersona | null> {\n    try {\n      // Validate path\n      const validatedPath = validatePath(filePath);\n      const content = await fs.readFile(validatedPath, 'utf-8');\n\n      if (filePath.endsWith('.json')) {\n        const parsed = JSON.parse(content);\n        if (this.isExportedPersona(parsed)) {\n          return parsed;\n        } else if (this.isExportBundle(parsed)) {\n          throw new Error(\"This is a bundle file. It will be imported as multiple personas.\");\n        }\n      } else if (filePath.endsWith('.md')) {\n        // Parse markdown file\n        const { data, content: mdContent } = matter(content);\n        const filename = path.basename(filePath);\n        return {\n          metadata: data as PersonaMetadata,\n          content: mdContent,\n          filename: filename,\n          exportedAt: new Date().toISOString()\n        };\n      }\n    } catch (error) {\n      logger.error('File import error', error);\n      throw error;\n    }\n    return null;\n  }\n\n  /**\n   * Import from base64 string\n   */\n  private async importFromBase64(base64: string): Promise<ExportedPersona | null> {\n    try {\n      const json = Buffer.from(base64, 'base64').toString('utf-8');\n      const parsed = JSON.parse(json);\n      \n      if (this.isExportedPersona(parsed)) {\n        return parsed;\n      } else if (this.isExportBundle(parsed)) {\n        throw new Error(\"This is a bundle. It will be imported as multiple personas.\");\n      }\n    } catch (error) {\n      logger.error('Base64 import error', error);\n    }\n    return null;\n  }\n\n  /**\n   * Import from raw markdown content\n   */\n  private async importFromMarkdown(content: string, existingPersonas: Map<string, Persona>, overwrite: boolean): Promise<ImportResult> {\n    try {\n      // Validate content size\n      validateContentSize(content, 100 * 1024); // 100KB limit\n\n      // Try to parse as markdown with frontmatter\n      const { data, content: mdContent } = matter(content);\n      \n      if (!data.name || !data.description) {\n        return {\n          success: false,\n          message: \"Invalid persona format. Must include name and description in YAML frontmatter.\"\n        };\n      }\n\n      const metadata = data as PersonaMetadata;\n      const filename = `${metadata.name.toLowerCase().replace(/\\s+/g, '-')}.md`;\n\n      const exportedPersona: ExportedPersona = {\n        metadata,\n        content: mdContent,\n        filename,\n        exportedAt: new Date().toISOString(),\n        exportedBy: this.currentUser || undefined\n      };\n\n      return await this.createPersonaFromExport(exportedPersona, existingPersonas, overwrite);\n    } catch (error) {\n      return {\n        success: false,\n        message: `Failed to parse markdown: ${error instanceof Error ? error.message : String(error)}`\n      };\n    }\n  }\n\n  /**\n   * Import a bundle of personas\n   */\n  private async importBundle(bundle: ExportBundle, existingPersonas: Map<string, Persona>, overwrite: boolean): Promise<ImportResult> {\n    const results = {\n      success: true,\n      imported: [] as string[],\n      failed: [] as string[],\n      conflicts: [] as string[]\n    };\n\n    for (const personaData of bundle.personas) {\n      const result = await this.createPersonaFromExport(personaData, existingPersonas, overwrite);\n      \n      if (result.success) {\n        results.imported.push(personaData.metadata.name);\n      } else {\n        results.failed.push(`${personaData.metadata.name}: ${result.message}`);\n        if (result.conflicts) {\n          results.conflicts.push(...result.conflicts);\n        }\n      }\n    }\n\n    return {\n      success: results.failed.length === 0,\n      message: this.formatBundleImportResult(results),\n      conflicts: results.conflicts.length > 0 ? results.conflicts : undefined\n    };\n  }\n\n  /**\n   * Create persona from exported data\n   */\n  private async createPersonaFromExport(\n    exportData: ExportedPersona, \n    existingPersonas: Map<string, Persona>, \n    overwrite: boolean\n  ): Promise<ImportResult> {\n    try {\n      // Validate metadata\n      const metadata = await this.validateAndEnrichMetadata(exportData.metadata);\n      \n      // Validate content\n      const validationResult = ContentValidator.validateAndSanitize(exportData.content);\n      if (!validationResult.isValid && validationResult.severity === 'critical') {\n        throw new Error(`Critical security threat detected: ${validationResult.detectedPatterns?.join(', ')}`);\n      }\n      const sanitizedContent = validationResult.sanitizedContent || exportData.content;\n\n      // Generate safe filename\n      let filename = validateFilename(exportData.filename || `${metadata.name.toLowerCase().replace(/\\s+/g, '-')}.md`);\n      \n      // Check for conflicts\n      const conflicts = this.findConflicts(metadata.name, filename, existingPersonas);\n      if (conflicts.length > 0 && !overwrite) {\n        return {\n          success: false,\n          message: `Persona already exists: ${conflicts.join(', ')}. Use overwrite=true to replace.`,\n          conflicts\n        };\n      }\n\n      // Create the persona file\n      const personaPath = path.join(this.personasDir, filename);\n      const fileContent = matter.stringify(sanitizedContent, metadata);\n      \n      // Use file locking to prevent race conditions\n      await FileLockManager.withLock(`persona:${metadata.name}`, async () => {\n        await FileLockManager.atomicWriteFile(personaPath, fileContent);\n      });\n\n      // Create persona object\n      const persona: Persona = {\n        metadata,\n        content: sanitizedContent,\n        filename,\n        unique_id: metadata.unique_id!\n      };\n\n      return {\n        success: true,\n        message: `Successfully imported \"${metadata.name}\"`,\n        persona,\n        filename\n      };\n\n    } catch (error) {\n      logger.error('Create persona error', error);\n      return {\n        success: false,\n        message: `Failed to create persona: ${error instanceof Error ? error.message : String(error)}`\n      };\n    }\n  }\n\n  /**\n   * Validate and enrich metadata\n   */\n  private async validateAndEnrichMetadata(metadata: any): Promise<PersonaMetadata> {\n    // Ensure required fields\n    if (!metadata.name || !metadata.description) {\n      throw new Error(\"Missing required fields: name and description\");\n    }\n\n    // Generate unique_id if missing\n    if (!metadata.unique_id) {\n      metadata.unique_id = generateUniqueId(metadata.name, this.currentUser || 'imported');\n    }\n\n    // Set defaults\n    metadata.version = metadata.version || '1.0';\n    metadata.author = metadata.author || this.currentUser || 'imported';\n    metadata.category = metadata.category || 'custom';\n    metadata.created_date = metadata.created_date || new Date().toISOString();\n\n    // Validate with YAML parser for security\n    const validated = await SecureYamlParser.parse(matter.stringify('', metadata));\n\n    return validated.data as PersonaMetadata;\n  }\n\n  /**\n   * Find conflicts with existing personas\n   */\n  private findConflicts(name: string, filename: string, existingPersonas: Map<string, Persona>): string[] {\n    const conflicts: string[] = [];\n\n    for (const [key, persona] of existingPersonas) {\n      if (persona.metadata.name === name || persona.filename === filename) {\n        conflicts.push(key);\n      }\n    }\n\n    return conflicts;\n  }\n\n  /**\n   * Check if string is base64\n   */\n  private isBase64(str: string): boolean {\n    // Check length is multiple of 4\n    if (str.length % 4 !== 0) return false;\n    \n    // Check for valid base64 characters and padding\n    return /^[A-Za-z0-9+/]*={0,2}$/.test(str);\n  }\n\n  /**\n   * Type guard for ExportedPersona\n   */\n  private isExportedPersona(obj: any): obj is ExportedPersona {\n    return obj && \n      typeof obj.metadata === 'object' &&\n      typeof obj.content === 'string' &&\n      typeof obj.filename === 'string';\n  }\n\n  /**\n   * Type guard for ExportBundle\n   */\n  private isExportBundle(obj: any): obj is ExportBundle {\n    return obj &&\n      typeof obj.version === 'string' &&\n      Array.isArray(obj.personas) &&\n      typeof obj.personaCount === 'number';\n  }\n\n  /**\n   * Format bundle import results\n   */\n  private formatBundleImportResult(results: any): string {\n    let message = `Bundle Import Summary:\\n`;\n    message += `✅ Successfully imported: ${results.imported.length} personas\\n`;\n    \n    if (results.imported.length > 0) {\n      message += `Imported:\\n${results.imported.map((n: string) => `  - ${n}`).join('\\n')}\\n`;\n    }\n\n    if (results.failed.length > 0) {\n      message += `\\n❌ Failed: ${results.failed.length} personas\\n`;\n      message += `Errors:\\n${results.failed.map((e: string) => `  - ${e}`).join('\\n')}`;\n    }\n\n    return message;\n  }\n}"]}

package/dist/src/persona/export-import/PersonaSharer.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Persona sharing functionality via URLs
+ */
+import { Persona } from '../../types/persona.js';
+import { GitHubClient } from '../../marketplace/GitHubClient.js';
+export interface ShareResult {
+    success: boolean;
+    url?: string;
+    gistId?: string;
+    expiresAt?: string;
+    message: string;
+}
+export declare class PersonaSharer {
+    private githubClient;
+    private currentUser;
+    private exporter;
+    private githubRateLimiter;
+    constructor(githubClient: GitHubClient, currentUser: string | null);
+    /**
+     * Share a persona via GitHub Gist
+     */
+    sharePersona(persona: Persona, expiryDays?: number): Promise<ShareResult>;
+    /**
+     * Import a persona from a share URL
+     */
+    importFromUrl(url: string): Promise<{
+        success: boolean;
+        data?: any;
+        message: string;
+    }>;
+    /**
+     * Create a GitHub Gist
+     */
+    private createGist;
+    /**
+     * Create a base64 URL (fallback)
+     */
+    private createBase64Url;
+    /**
+     * Import from GitHub Gist
+     */
+    private importFromGist;
+    /**
+     * Validate URL for security (prevent SSRF attacks)
+     */
+    private validateShareUrl;
+    /**
+     * Import from base64 URL
+     */
+    private importFromBase64Url;
+    /**
+     * Extract Gist ID from GitHub URL
+     */
+    private extractGistId;
+    /**
+     * Format share success message
+     */
+    private formatShareSuccess;
+}
+//# sourceMappingURL=PersonaSharer.d.ts.map

package/dist/src/persona/export-import/PersonaSharer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersonaSharer.d.ts","sourceRoot":"","sources":["../../../../src/persona/export-import/PersonaSharer.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAEjD,OAAO,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAKjE,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,aAAa;IAKtB,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,WAAW;IALrB,OAAO,CAAC,QAAQ,CAAkB;IAClC,OAAO,CAAC,iBAAiB,CAAc;gBAG7B,YAAY,EAAE,YAAY,EAC1B,WAAW,EAAE,MAAM,GAAG,IAAI;IAcpC;;OAEG;IACG,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,GAAE,MAAU,GAAG,OAAO,CAAC,WAAW,CAAC;IAuDlF;;OAEG;IACG,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,GAAG,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IA+D5F;;OAEG;YACW,UAAU;IAqExB;;OAEG;IACH,OAAO,CAAC,eAAe;IAYvB;;OAEG;YACW,cAAc;IAuE5B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IA4BxB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAiC3B;;OAEG;IACH,OAAO,CAAC,aAAa;IAKrB;;OAEG;IACH,OAAO,CAAC,kBAAkB;CAkB3B"}