@xenosystem/agent-interface-ui 0.1.3

package/dist/stores/entitySettingsStore.js

@@ -0,0 +1,916 @@
+import { getAgentPlatformBridge } from '../platformBridge';
+import { create } from 'zustand';
+import { useWorkspaceStore } from './workspaceStore';
+import { useAgentChatStore } from './agentChatStore';
+import { useAuthStore } from './authStore';
+export const SETTINGS_SECTIONS = [
+    { id: 'general', label: 'General', icon: 'settings', availableFor: ['workspace', 'team', 'agent'] },
+    { id: 'directoryAccess', label: 'Directory Access', icon: 'folder', availableFor: ['workspace', 'team', 'agent'] },
+    { id: 'defaultAgentConfig', label: 'Default Agent Config', icon: 'cpu', availableFor: ['workspace', 'team'] },
+    { id: 'access', label: 'Access & Members', icon: 'users', availableFor: ['workspace', 'team', 'agent'] },
+    { id: 'resourceLimits', label: 'Resource Limits', icon: 'gauge', availableFor: ['workspace', 'team', 'agent'] },
+    { id: 'usage', label: 'Usage & Analytics', icon: 'barChart', availableFor: ['workspace', 'team', 'agent'] },
+    { id: 'integrations', label: 'Integrations', icon: 'plug', availableFor: ['workspace', 'team'] },
+    { id: 'environment', label: 'Environment & Secrets', icon: 'key', availableFor: ['workspace', 'team'] },
+    { id: 'notifications', label: 'Notifications', icon: 'bell', availableFor: ['workspace', 'team', 'agent'] },
+    { id: 'security', label: 'Security & Compliance', icon: 'shield', availableFor: ['workspace', 'team'] },
+    { id: 'exportBackup', label: 'Export & Backup', icon: 'download', availableFor: ['workspace', 'team'] },
+    { id: 'dangerZone', label: 'Danger Zone', icon: 'alertTriangle', availableFor: ['workspace', 'team', 'agent'] },
+];
+export function getSectionsForEntity(entityType) {
+    return SETTINGS_SECTIONS.filter(s => s.availableFor.includes(entityType));
+}
+// =============================================================================
+// MOCK DATA GENERATOR
+// =============================================================================
+function generateId() {
+    return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+}
+function generateMockSettings(entityId, entityType, entityName, extra) {
+    const now = new Date().toISOString();
+    const thirtyDaysAgo = new Date(Date.now() - 30 * 86400000).toISOString();
+    const owner = {
+        id: 'user_owner_1',
+        name: 'You',
+        email: 'you@example.com',
+        role: 'owner',
+        joinedAt: thirtyDaysAgo,
+    };
+    const members = [
+        owner,
+        { id: 'user_2', name: 'Alice Chen', email: 'alice@example.com', role: 'admin', joinedAt: thirtyDaysAgo },
+        { id: 'user_3', name: 'Bob Smith', email: 'bob@example.com', role: 'editor', joinedAt: now },
+    ];
+    const dailyUsage = Array.from({ length: 7 }, (_, i) => ({
+        label: ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'][i],
+        value: Math.floor(Math.random() * 50000) + 5000,
+    }));
+    const weeklyUsage = Array.from({ length: 4 }, (_, i) => ({
+        label: `Week ${i + 1}`,
+        value: Math.floor(Math.random() * 200000) + 50000,
+    }));
+    const monthlyUsage = Array.from({ length: 6 }, (_, i) => ({
+        label: ['Aug', 'Sep', 'Oct', 'Nov', 'Dec', 'Jan'][i],
+        value: Math.floor(Math.random() * 800000) + 100000,
+    }));
+    const workspaceQuotas = [
+        { label: 'Teams', current: 3, limit: 10, unit: 'teams' },
+        { label: 'Tokens / month', current: 425000, limit: 1000000, unit: 'tokens' },
+        { label: 'Storage', current: 2.4, limit: 10, unit: 'GB' },
+    ];
+    const teamQuotas = [
+        { label: 'Agents', current: 5, limit: 20, unit: 'agents' },
+        { label: 'Tokens / month', current: 180000, limit: 500000, unit: 'tokens' },
+    ];
+    const agentQuotas = [
+        { label: 'Tokens / month', current: 42000, limit: 100000, unit: 'tokens' },
+    ];
+    const quotas = entityType === 'workspace' ? workspaceQuotas : entityType === 'team' ? teamQuotas : agentQuotas;
+    return {
+        entityId,
+        entityType,
+        entityName,
+        workspaceId: extra?.workspaceId,
+        workspaceName: extra?.workspaceName,
+        teamId: extra?.teamId,
+        teamName: extra?.teamName,
+        general: {
+            name: entityName,
+            description: `A ${entityType} for managing AI operations.`,
+            icon: entityType === 'workspace' ? 'building' : entityType === 'team' ? 'users' : 'bot',
+            slug: entityName.toLowerCase().replace(/\s+/g, '-'),
+            createdAt: thirtyDaysAgo,
+            updatedAt: now,
+        },
+        defaultAgentConfig: entityType !== 'agent' ? {
+            defaultModel: 'claude-sonnet-4-6',
+            systemInstructions: 'You are a helpful AI assistant.',
+            enabledTools: ['web-search', 'code-execution', 'file-read'],
+            availableTools: ['web-search', 'code-execution', 'file-read', 'file-write', 'image-generation', 'data-analysis'],
+        } : undefined,
+        access: {
+            owner,
+            members: entityType === 'agent' ? [owner] : members,
+            pendingInvites: entityType === 'agent' ? [] : [
+                { id: 'inv_1', email: 'carol@example.com', role: 'viewer', sentAt: now, expiresAt: new Date(Date.now() + 7 * 86400000).toISOString() },
+            ],
+            publicAccess: false,
+            allowGuestViewing: false,
+        },
+        resourceLimits: {
+            quotas,
+            rateLimitRpm: entityType === 'workspace' ? 1000 : entityType === 'team' ? 500 : 100,
+            rateLimitTpd: entityType === 'workspace' ? 1000000 : entityType === 'team' ? 500000 : 100000,
+        },
+        usage: {
+            totalTokens: 425000,
+            totalCost: 12.50,
+            totalRequests: 1842,
+            dailyUsage,
+            weeklyUsage,
+            monthlyUsage,
+            costByModel: [
+                { model: 'Opus 4.5', cost: 8.20, tokens: 280000 },
+                { model: 'GPT 5.3 Codex', cost: 3.10, tokens: 105000 },
+                { model: 'Flash 3.0', cost: 1.20, tokens: 40000 },
+            ],
+            topAgents: [
+                { name: 'Code Reviewer', tokens: 120000, cost: 3.60 },
+                { name: 'Research Bot', tokens: 95000, cost: 2.85 },
+                { name: 'Doc Writer', tokens: 72000, cost: 2.16 },
+            ],
+        },
+        integrations: {
+            integrations: [
+                { id: 'int_1', type: 'github', name: 'GitHub', enabled: true, connectedAt: thirtyDaysAgo, status: 'connected' },
+                { id: 'int_2', type: 'slack', name: 'Slack', enabled: false, connectedAt: '', status: 'disconnected' },
+                { id: 'int_3', type: 'discord', name: 'Discord', enabled: false, connectedAt: '', status: 'disconnected' },
+                { id: 'int_4', type: 'webhook', name: 'Custom Webhook', enabled: true, connectedAt: thirtyDaysAgo, status: 'connected', config: { url: 'https://api.example.com/webhook' } },
+            ],
+            apiKeys: [
+                { id: 'key_1', name: 'Production Key', prefix: 'xk_prod_...a3f2', createdAt: thirtyDaysAgo, lastUsed: now },
+                { id: 'key_2', name: 'Development Key', prefix: 'xk_dev_...b1c4', createdAt: now, lastUsed: now },
+            ],
+            webhookEndpoints: [
+                { id: 'wh_1', url: 'https://api.example.com/webhook', events: ['agent.started', 'agent.completed'], enabled: true, secret: 'whsec_...x9y2', createdAt: thirtyDaysAgo },
+            ],
+        },
+        environment: {
+            variables: [
+                { id: 'env_1', key: 'API_BASE_URL', value: 'https://api.example.com', isSecret: false, updatedAt: now },
+                { id: 'env_2', key: 'DATABASE_URL', value: '••••••••••••', isSecret: true, updatedAt: thirtyDaysAgo },
+                { id: 'env_3', key: 'OPENAI_API_KEY', value: '••••••••••••', isSecret: true, updatedAt: thirtyDaysAgo },
+            ],
+        },
+        notifications: {
+            emailEnabled: true,
+            slackEnabled: false,
+            discordEnabled: false,
+            webhookEnabled: true,
+            rules: [
+                { id: 'rule_1', event: 'Agent Error', channel: 'email', enabled: true, description: 'Notify when an agent encounters an error' },
+                { id: 'rule_2', event: 'Task Completed', channel: 'webhook', enabled: true, description: 'Webhook on task completion' },
+                { id: 'rule_3', event: 'Quota Warning', channel: 'email', enabled: true, description: 'Alert when approaching usage limits' },
+            ],
+            digestFrequency: 'daily',
+        },
+        security: {
+            auditLog: [
+                { id: 'log_1', action: 'member.added', actor: 'You', target: 'Alice Chen', timestamp: now, details: 'Added as admin' },
+                { id: 'log_2', action: 'settings.updated', actor: 'You', target: 'General Settings', timestamp: thirtyDaysAgo, details: 'Updated workspace name' },
+                { id: 'log_3', action: 'agent.created', actor: 'Alice Chen', target: 'Code Reviewer', timestamp: thirtyDaysAgo, details: 'Created new agent' },
+                { id: 'log_4', action: 'apikey.created', actor: 'You', target: 'Production Key', timestamp: thirtyDaysAgo, details: 'Created API key' },
+                { id: 'log_5', action: 'member.role_changed', actor: 'You', target: 'Bob Smith', timestamp: now, details: 'Changed role to editor' },
+            ],
+            ipAllowlist: [],
+            require2FA: false,
+            requireApiKeyAuth: true,
+            sessionTimeout: 30,
+        },
+        exportBackup: {
+            autoBackupEnabled: true,
+            backupFrequency: 'weekly',
+            retentionDays: 30,
+            availableBackups: [
+                { id: 'bk_1', name: 'Auto Backup', size: '2.4 MB', createdAt: now, type: 'auto' },
+                { id: 'bk_2', name: 'Pre-migration Backup', size: '1.8 MB', createdAt: thirtyDaysAgo, type: 'manual' },
+            ],
+            availableExports: [
+                { format: 'json', label: 'JSON Export' },
+                { format: 'csv', label: 'CSV Export' },
+                { format: 'yaml', label: 'YAML Export' },
+            ],
+        },
+        dangerZone: {
+            canArchive: true,
+            canTransferOwnership: true,
+            canDelete: true,
+        },
+    };
+}
+function normalizeBackupFrequency(value, fallback) {
+    return value === 'daily' || value === 'weekly' || value === 'monthly' ? value : fallback;
+}
+// Async load real data for IPC-backed sections (export, usage, security)
+async function loadAsyncSectionData(entityId, entityType) {
+    const store = useEntitySettingsStore;
+    // Load real backup data
+    try {
+        const [backupList, backupSettings] = await Promise.all([
+            getAgentPlatformBridge()?.exportBackup?.listBackups?.(),
+            getAgentPlatformBridge()?.exportBackup?.getSettings?.(),
+        ]);
+        const current = store.getState().settings;
+        if (current?.entityId === entityId) {
+            const normalizedBackupFrequency = normalizeBackupFrequency(backupSettings?.settings?.frequency, current.exportBackup.backupFrequency);
+            store.setState({
+                settings: {
+                    ...current,
+                    exportBackup: {
+                        ...current.exportBackup,
+                        autoBackupEnabled: backupSettings?.settings?.autoBackupEnabled ?? current.exportBackup.autoBackupEnabled,
+                        backupFrequency: normalizedBackupFrequency,
+                        retentionDays: backupSettings?.settings?.retentionDays ?? current.exportBackup.retentionDays,
+                        availableBackups: (backupList?.backups || []).map((b) => ({
+                            id: b.id,
+                            name: b.name,
+                            size: formatBytes(b.size),
+                            createdAt: b.createdAt,
+                            type: 'manual',
+                        })),
+                    },
+                },
+            });
+        }
+    }
+    catch { /* silent */ }
+    // Load real usage data
+    try {
+        const [summary, byModel, topAgents] = await Promise.all([
+            getAgentPlatformBridge()?.usage?.summary?.(entityType, entityId, 'daily'),
+            getAgentPlatformBridge()?.usage?.byModel?.(),
+            getAgentPlatformBridge()?.usage?.topAgents?.(),
+        ]);
+        const current = store.getState().settings;
+        if (current?.entityId === entityId) {
+            const usageSummary = (summary || {});
+            const usageByModel = (byModel || {});
+            const usageTopAgents = (topAgents || {});
+            store.setState({
+                settings: {
+                    ...current,
+                    usage: {
+                        totalTokens: usageSummary.totalTokens ?? 0,
+                        totalCost: usageSummary.totalCost ?? 0,
+                        totalRequests: usageSummary.totalRequests ?? 0,
+                        dailyUsage: usageSummary.dataPoints || [],
+                        weeklyUsage: [],
+                        monthlyUsage: [],
+                        costByModel: usageByModel.costByModel || [],
+                        topAgents: usageTopAgents.topAgents || [],
+                    },
+                },
+            });
+        }
+    }
+    catch { /* silent */ }
+    // Load real audit log
+    try {
+        const result = await getAgentPlatformBridge()?.audit?.list?.(20);
+        const current = store.getState().settings;
+        if (current?.entityId === entityId) {
+            const auditEntries = (result || {}).entries || [];
+            store.setState({
+                settings: {
+                    ...current,
+                    security: {
+                        ...current.security,
+                        auditLog: auditEntries.map((e, i) => ({
+                            id: `audit_${i}`,
+                            action: e.action,
+                            actor: e.user || 'You',
+                            target: e.entity || '',
+                            timestamp: e.timestamp,
+                            details: e.details || '',
+                        })),
+                    },
+                },
+            });
+        }
+    }
+    catch { /* silent */ }
+}
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1048576)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / 1048576).toFixed(1)} MB`;
+}
+// Sync notifications from settings back to workspace store
+function syncNotificationsToWorkspaceStore(settings, notif) {
+    if (settings.entityType !== 'workspace')
+        return;
+    useWorkspaceStore.getState().updateWorkspace(settings.entityId, {
+        notifications: {
+            emailEnabled: notif.emailEnabled,
+            slackEnabled: notif.slackEnabled,
+            discordEnabled: notif.discordEnabled,
+            webhookEnabled: notif.webhookEnabled,
+            digestFrequency: notif.digestFrequency,
+            rules: notif.rules.map(r => ({ id: r.id, event: r.event, channel: r.channel, enabled: r.enabled })),
+        },
+    });
+}
+// Sync env vars from settings back to workspace store
+function syncEnvVarsToWorkspaceStore(settings, vars) {
+    const envVars = vars.map(v => ({ key: v.key, value: v.value, isSecret: v.isSecret }));
+    const ws = useWorkspaceStore.getState();
+    if (settings.entityType === 'workspace') {
+        ws.updateWorkspace(settings.entityId, { envVars });
+    }
+    else if (settings.entityType === 'team' && settings.workspaceId) {
+        ws.updateTeam(settings.workspaceId, settings.entityId, { envVars });
+    }
+}
+export const useEntitySettingsStore = create((set, get) => ({
+    settings: null,
+    activeSection: 'general',
+    isLoading: false,
+    isDirty: false,
+    loadSettings: (entityId, entityType, entityName, extra) => {
+        set({ isLoading: true });
+        // Start with mock structure, then overlay real data from workspace store
+        const settings = generateMockSettings(entityId, entityType, entityName, extra);
+        const wsStore = useWorkspaceStore.getState();
+        // Get current user from auth store for real owner info
+        const authUser = useAuthStore.getState().user;
+        if (entityType === 'workspace') {
+            const ws = wsStore.workspaces.find(w => w.id === entityId);
+            if (ws) {
+                // General — all real
+                const slug = ws.name.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
+                settings.general.name = ws.name;
+                settings.general.description = ws.description || '';
+                settings.general.slug = slug;
+                settings.general.icon = 'building';
+                settings.general.createdAt = ws.createdAt ? new Date(ws.createdAt).toISOString() : settings.general.createdAt;
+                settings.general.updatedAt = ws.updatedAt ? new Date(ws.updatedAt).toISOString() : settings.general.createdAt;
+                // Resource limits — real quotas from hierarchy
+                const teamCount = ws.teams.length;
+                const agentCount = ws.teams.reduce((sum, t) => sum + t.agents.length, 0);
+                settings.resourceLimits.quotas = [
+                    { label: 'Teams', current: teamCount, limit: 50, unit: 'teams' },
+                    { label: 'Agents', current: agentCount, limit: 200, unit: 'agents' },
+                    { label: 'Directories', current: ws.directories.length, limit: 100, unit: 'dirs' },
+                ];
+                settings.resourceLimits.rateLimitRpm = ws.rateLimits?.requestsPerMinute ?? 1000;
+                settings.resourceLimits.rateLimitTpd = ws.rateLimits?.tokensPerDay ?? 1000000;
+                // Environment
+                settings.environment = {
+                    variables: (ws.envVars || []).map((v, i) => ({
+                        id: `env_${i}`,
+                        ...v,
+                        updatedAt: new Date().toISOString(),
+                    })),
+                };
+                // Notifications
+                if (ws.notifications) {
+                    settings.notifications = {
+                        emailEnabled: ws.notifications.emailEnabled,
+                        slackEnabled: ws.notifications.slackEnabled,
+                        discordEnabled: ws.notifications.discordEnabled,
+                        webhookEnabled: ws.notifications.webhookEnabled,
+                        digestFrequency: ws.notifications.digestFrequency,
+                        rules: ws.notifications.rules.map(r => ({
+                            ...r,
+                            description: r.event,
+                        })),
+                    };
+                }
+                // Access — real current user as owner, no fake members
+                const ownerName = authUser?.display_name || authUser?.username || 'You';
+                const ownerEmail = authUser?.email || '';
+                settings.access = {
+                    owner: { id: 'self', name: ownerName, email: ownerEmail, role: 'owner', joinedAt: settings.general.createdAt },
+                    members: [{ id: 'self', name: ownerName, email: ownerEmail, role: 'owner', joinedAt: settings.general.createdAt }],
+                    pendingInvites: [],
+                    publicAccess: ws.access?.publicAccess ?? false,
+                    allowGuestViewing: ws.access?.allowGuestViewing ?? false,
+                };
+                // Security
+                if (ws.security) {
+                    settings.security.require2FA = ws.security.require2FA;
+                    settings.security.requireApiKeyAuth = ws.security.requireApiKeyAuth;
+                    settings.security.sessionTimeout = ws.security.sessionTimeout;
+                    settings.security.ipAllowlist = [...ws.security.ipAllowlist];
+                }
+                // Integrations — mark as not connected (no OAuth yet)
+                settings.integrations.integrations = settings.integrations.integrations.map(i => ({
+                    ...i, enabled: false, status: 'disconnected', connectedAt: '',
+                }));
+                settings.integrations.apiKeys = [];
+                settings.integrations.webhookEndpoints = [];
+            }
+        }
+        else if (entityType === 'team' && extra?.workspaceId) {
+            const ws = wsStore.workspaces.find(w => w.id === extra.workspaceId);
+            const team = ws?.teams.find(t => t.id === entityId);
+            if (team) {
+                settings.general.name = team.name;
+                settings.general.description = team.description || '';
+                settings.general.slug = team.name.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
+                settings.general.icon = 'users';
+                settings.resourceLimits.quotas = [
+                    { label: 'Agents', current: team.agents.length, limit: 50, unit: 'agents' },
+                ];
+                settings.resourceLimits.rateLimitRpm = team.rateLimits?.requestsPerMinute ?? 500;
+                settings.resourceLimits.rateLimitTpd = team.rateLimits?.tokensPerDay ?? 500000;
+                settings.environment = {
+                    variables: (team.envVars || []).map((v, i) => ({
+                        id: `env_${i}`,
+                        ...v,
+                        updatedAt: new Date().toISOString(),
+                    })),
+                };
+                // Real owner
+                const ownerName = authUser?.display_name || authUser?.username || 'You';
+                const ownerEmail = authUser?.email || '';
+                settings.access = {
+                    owner: { id: 'self', name: ownerName, email: ownerEmail, role: 'owner', joinedAt: settings.general.createdAt },
+                    members: [{ id: 'self', name: ownerName, email: ownerEmail, role: 'owner', joinedAt: settings.general.createdAt }],
+                    pendingInvites: [],
+                    publicAccess: false,
+                    allowGuestViewing: false,
+                };
+            }
+        }
+        else if (entityType === 'agent' && extra?.workspaceId && extra?.teamId) {
+            const ws = wsStore.workspaces.find(w => w.id === extra.workspaceId);
+            const team = ws?.teams.find(t => t.id === extra.teamId);
+            const agent = team?.agents.find(a => a.id === entityId);
+            if (agent) {
+                settings.general.name = agent.name;
+                settings.general.description = agent.description || '';
+                settings.general.slug = agent.name.toLowerCase().replace(/\s+/g, '-').replace(/[^a-z0-9-]/g, '');
+                settings.general.icon = 'bot';
+                settings.resourceLimits.quotas = [
+                    { label: 'Conversations', current: Object.values(useAgentChatStore.getState().conversations).filter(c => c.agentId === entityId).length, limit: 1000, unit: 'convs' },
+                ];
+                // Real owner
+                const ownerName = authUser?.display_name || authUser?.username || 'You';
+                const ownerEmail = authUser?.email || '';
+                settings.access = {
+                    owner: { id: 'self', name: ownerName, email: ownerEmail, role: 'owner', joinedAt: settings.general.createdAt },
+                    members: [{ id: 'self', name: ownerName, email: ownerEmail, role: 'owner', joinedAt: settings.general.createdAt }],
+                    pendingInvites: [],
+                    publicAccess: false,
+                    allowGuestViewing: false,
+                };
+                if (settings.defaultAgentConfig) {
+                    settings.defaultAgentConfig.defaultModel = agent.model || 'claude-sonnet-4-6';
+                    settings.defaultAgentConfig.systemInstructions = agent.systemPrompt || '';
+                    settings.defaultAgentConfig.enabledTools = agent.tools || ['web-search', 'code-execution', 'file-read'];
+                }
+                settings.resourceLimits.rateLimitRpm = agent.rateLimits?.requestsPerMinute ?? settings.resourceLimits.rateLimitRpm;
+                settings.resourceLimits.rateLimitTpd = agent.rateLimits?.tokensPerDay ?? settings.resourceLimits.rateLimitTpd;
+            }
+        }
+        set({ settings, isLoading: false, activeSection: 'general', isDirty: false });
+        // Async: load real data for IPC-backed sections
+        loadAsyncSectionData(entityId, entityType);
+    },
+    setActiveSection: (section) => set({ activeSection: section }),
+    clearSettings: () => set({ settings: null, activeSection: 'general', isDirty: false }),
+    updateGeneral: (updates) => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        set({
+            settings: { ...settings, general: { ...settings.general, ...updates, updatedAt: new Date().toISOString() } },
+            isDirty: true,
+        });
+        // Persist to workspace store
+        const ws = useWorkspaceStore.getState();
+        if (settings.entityType === 'workspace') {
+            ws.updateWorkspace(settings.entityId, {
+                name: updates.name || settings.general.name,
+                description: updates.description ?? settings.general.description,
+            });
+        }
+        else if (settings.entityType === 'team' && settings.workspaceId) {
+            ws.updateTeam(settings.workspaceId, settings.entityId, {
+                name: updates.name || settings.general.name,
+                description: updates.description ?? settings.general.description,
+            });
+        }
+        else if (settings.entityType === 'agent' && settings.workspaceId && settings.teamId) {
+            ws.updateAgent(settings.workspaceId, settings.teamId, settings.entityId, {
+                name: updates.name || settings.general.name,
+                description: updates.description ?? settings.general.description,
+            });
+        }
+    },
+    updateDefaultAgentConfig: (updates) => {
+        const { settings } = get();
+        if (!settings || !settings.defaultAgentConfig)
+            return;
+        set({
+            settings: { ...settings, defaultAgentConfig: { ...settings.defaultAgentConfig, ...updates } },
+            isDirty: true,
+        });
+        // Persist to workspace store — for agents, update model/prompt/tools
+        if (settings.entityType === 'agent' && settings.workspaceId && settings.teamId) {
+            const agentUpdates = {};
+            if (updates.defaultModel !== undefined)
+                agentUpdates.model = updates.defaultModel;
+            if (updates.systemInstructions !== undefined)
+                agentUpdates.systemPrompt = updates.systemInstructions;
+            if (updates.enabledTools !== undefined)
+                agentUpdates.tools = updates.enabledTools;
+            useWorkspaceStore.getState().updateAgent(settings.workspaceId, settings.teamId, settings.entityId, agentUpdates);
+        }
+    },
+    updateAccess: (updates) => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        set({
+            settings: { ...settings, access: { ...settings.access, ...updates } },
+            isDirty: true,
+        });
+        // Persist access settings to workspace store
+        if (settings.entityType === 'workspace') {
+            useWorkspaceStore.getState().updateWorkspace(settings.entityId, {
+                access: {
+                    publicAccess: updates.publicAccess ?? settings.access.publicAccess,
+                    allowGuestViewing: updates.allowGuestViewing ?? settings.access.allowGuestViewing,
+                },
+            });
+        }
+    },
+    updateResourceLimits: (updates) => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        set({
+            settings: { ...settings, resourceLimits: { ...settings.resourceLimits, ...updates } },
+            isDirty: true,
+        });
+        // Persist rate limits to workspace store
+        const rateLimits = {
+            requestsPerMinute: updates.rateLimitRpm ?? settings.resourceLimits.rateLimitRpm,
+            tokensPerDay: updates.rateLimitTpd ?? settings.resourceLimits.rateLimitTpd,
+        };
+        const ws = useWorkspaceStore.getState();
+        if (settings.entityType === 'workspace') {
+            ws.updateWorkspace(settings.entityId, { rateLimits });
+        }
+        else if (settings.entityType === 'team' && settings.workspaceId) {
+            ws.updateTeam(settings.workspaceId, settings.entityId, { rateLimits });
+        }
+        else if (settings.entityType === 'agent' && settings.workspaceId && settings.teamId) {
+            ws.updateAgent(settings.workspaceId, settings.teamId, settings.entityId, { rateLimits });
+        }
+    },
+    updateNotifications: (updates) => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        const merged = { ...settings.notifications, ...updates };
+        set({
+            settings: { ...settings, notifications: merged },
+            isDirty: true,
+        });
+        // Persist to workspace store
+        if (settings.entityType === 'workspace') {
+            useWorkspaceStore.getState().updateWorkspace(settings.entityId, {
+                notifications: {
+                    emailEnabled: merged.emailEnabled,
+                    slackEnabled: merged.slackEnabled,
+                    discordEnabled: merged.discordEnabled,
+                    webhookEnabled: merged.webhookEnabled,
+                    digestFrequency: merged.digestFrequency,
+                    rules: merged.rules.map(r => ({ id: r.id, event: r.event, channel: r.channel, enabled: r.enabled })),
+                },
+            });
+        }
+    },
+    updateSecurity: (updates) => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        const merged = { ...settings.security, ...updates };
+        set({
+            settings: { ...settings, security: merged },
+            isDirty: true,
+        });
+        // Persist security settings to workspace store
+        if (settings.entityType === 'workspace') {
+            useWorkspaceStore.getState().updateWorkspace(settings.entityId, {
+                security: {
+                    require2FA: merged.require2FA,
+                    requireApiKeyAuth: merged.requireApiKeyAuth,
+                    sessionTimeout: merged.sessionTimeout,
+                    ipAllowlist: [...merged.ipAllowlist],
+                },
+            });
+        }
+    },
+    updateExportBackup: (updates) => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        set({
+            settings: { ...settings, exportBackup: { ...settings.exportBackup, ...updates } },
+            isDirty: true,
+        });
+        // Persist backup settings
+        getAgentPlatformBridge()?.exportBackup?.updateSettings?.({
+            autoBackupEnabled: updates.autoBackupEnabled ?? settings.exportBackup.autoBackupEnabled,
+            frequency: updates.backupFrequency ?? settings.exportBackup.backupFrequency,
+            retentionDays: updates.retentionDays ?? settings.exportBackup.retentionDays,
+        }).catch(() => { });
+    },
+    addMember: (member) => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        const newMember = { ...member, id: `user_${generateId()}`, joinedAt: new Date().toISOString() };
+        set({
+            settings: { ...settings, access: { ...settings.access, members: [...settings.access.members, newMember] } },
+            isDirty: true,
+        });
+    },
+    removeMember: (memberId) => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        set({
+            settings: {
+                ...settings,
+                access: { ...settings.access, members: settings.access.members.filter(m => m.id !== memberId) },
+            },
+            isDirty: true,
+        });
+    },
+    updateMemberRole: (memberId, role) => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        set({
+            settings: {
+                ...settings,
+                access: {
+                    ...settings.access,
+                    members: settings.access.members.map(m => m.id === memberId ? { ...m, role } : m),
+                },
+            },
+            isDirty: true,
+        });
+    },
+    addIntegration: (integration) => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        const newInt = { ...integration, id: `int_${generateId()}` };
+        set({
+            settings: {
+                ...settings,
+                integrations: { ...settings.integrations, integrations: [...settings.integrations.integrations, newInt] },
+            },
+            isDirty: true,
+        });
+    },
+    removeIntegration: (integrationId) => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        set({
+            settings: {
+                ...settings,
+                integrations: {
+                    ...settings.integrations,
+                    integrations: settings.integrations.integrations.filter(i => i.id !== integrationId),
+                },
+            },
+            isDirty: true,
+        });
+    },
+    toggleIntegration: (integrationId) => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        set({
+            settings: {
+                ...settings,
+                integrations: {
+                    ...settings.integrations,
+                    integrations: settings.integrations.integrations.map(i => i.id === integrationId ? { ...i, enabled: !i.enabled, status: !i.enabled ? 'connected' : 'disconnected' } : i),
+                },
+            },
+            isDirty: true,
+        });
+    },
+    addEnvironmentVariable: (variable) => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        const newVar = { ...variable, id: `env_${generateId()}`, updatedAt: new Date().toISOString() };
+        const nextVars = [...settings.environment.variables, newVar];
+        set({
+            settings: { ...settings, environment: { variables: nextVars } },
+            isDirty: true,
+        });
+        syncEnvVarsToWorkspaceStore(settings, nextVars);
+    },
+    updateEnvironmentVariable: (variableId, updates) => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        const nextVars = settings.environment.variables.map(v => v.id === variableId ? { ...v, ...updates, updatedAt: new Date().toISOString() } : v);
+        set({
+            settings: { ...settings, environment: { variables: nextVars } },
+            isDirty: true,
+        });
+        syncEnvVarsToWorkspaceStore(settings, nextVars);
+    },
+    deleteEnvironmentVariable: (variableId) => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        const nextVars = settings.environment.variables.filter(v => v.id !== variableId);
+        set({
+            settings: { ...settings, environment: { variables: nextVars } },
+            isDirty: true,
+        });
+        syncEnvVarsToWorkspaceStore(settings, nextVars);
+    },
+    addNotificationRule: (rule) => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        const newRule = { ...rule, id: `rule_${generateId()}` };
+        const nextRules = [...settings.notifications.rules, newRule];
+        set({
+            settings: { ...settings, notifications: { ...settings.notifications, rules: nextRules } },
+            isDirty: true,
+        });
+        syncNotificationsToWorkspaceStore(settings, { ...settings.notifications, rules: nextRules });
+    },
+    updateNotificationRule: (ruleId, updates) => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        const nextRules = settings.notifications.rules.map(r => r.id === ruleId ? { ...r, ...updates } : r);
+        set({
+            settings: { ...settings, notifications: { ...settings.notifications, rules: nextRules } },
+            isDirty: true,
+        });
+        syncNotificationsToWorkspaceStore(settings, { ...settings.notifications, rules: nextRules });
+    },
+    deleteNotificationRule: (ruleId) => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        const nextRules = settings.notifications.rules.filter(r => r.id !== ruleId);
+        set({
+            settings: { ...settings, notifications: { ...settings.notifications, rules: nextRules } },
+            isDirty: true,
+        });
+        syncNotificationsToWorkspaceStore(settings, { ...settings.notifications, rules: nextRules });
+    },
+    addApiKey: (key) => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        const now = new Date().toISOString();
+        const newKey = { ...key, id: `key_${generateId()}`, createdAt: now, lastUsed: now };
+        set({
+            settings: {
+                ...settings,
+                integrations: { ...settings.integrations, apiKeys: [...settings.integrations.apiKeys, newKey] },
+            },
+            isDirty: true,
+        });
+    },
+    removeApiKey: (keyId) => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        set({
+            settings: {
+                ...settings,
+                integrations: { ...settings.integrations, apiKeys: settings.integrations.apiKeys.filter(k => k.id !== keyId) },
+            },
+            isDirty: true,
+        });
+    },
+    addWebhook: (webhook) => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        const newWh = { ...webhook, id: `wh_${generateId()}`, createdAt: new Date().toISOString() };
+        set({
+            settings: {
+                ...settings,
+                integrations: { ...settings.integrations, webhookEndpoints: [...settings.integrations.webhookEndpoints, newWh] },
+            },
+            isDirty: true,
+        });
+    },
+    removeWebhook: (webhookId) => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        set({
+            settings: {
+                ...settings,
+                integrations: {
+                    ...settings.integrations,
+                    webhookEndpoints: settings.integrations.webhookEndpoints.filter(w => w.id !== webhookId),
+                },
+            },
+            isDirty: true,
+        });
+    },
+    toggleWebhook: (webhookId) => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        set({
+            settings: {
+                ...settings,
+                integrations: {
+                    ...settings.integrations,
+                    webhookEndpoints: settings.integrations.webhookEndpoints.map(w => w.id === webhookId ? { ...w, enabled: !w.enabled } : w),
+                },
+            },
+            isDirty: true,
+        });
+    },
+    createBackup: async (name) => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        const result = await getAgentPlatformBridge()?.exportBackup?.createBackup?.(name);
+        if (result?.success && result.backup) {
+            const backup = result.backup;
+            const newBackup = {
+                id: backup.id || `backup_${Date.now()}`,
+                name: backup.name || name || 'Backup',
+                size: formatBytes(backup.size || 0),
+                createdAt: backup.createdAt || new Date().toISOString(),
+                type: 'manual',
+            };
+            set({
+                settings: {
+                    ...settings,
+                    exportBackup: {
+                        ...settings.exportBackup,
+                        availableBackups: [newBackup, ...settings.exportBackup.availableBackups],
+                    },
+                },
+            });
+        }
+    },
+    deleteBackup: async (backupId) => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        await getAgentPlatformBridge()?.exportBackup?.deleteBackup?.(backupId);
+        set({
+            settings: {
+                ...settings,
+                exportBackup: {
+                    ...settings.exportBackup,
+                    availableBackups: settings.exportBackup.availableBackups.filter(b => b.id !== backupId),
+                },
+            },
+        });
+    },
+    archiveEntity: () => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        const ws = useWorkspaceStore.getState();
+        if (settings.entityType === 'workspace') {
+            ws.archiveWorkspace(settings.entityId);
+        }
+    },
+    transferOwnership: (newOwnerId) => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        const newOwner = settings.access.members.find(m => m.id === newOwnerId);
+        if (!newOwner)
+            return;
+        set({
+            settings: {
+                ...settings,
+                access: {
+                    ...settings.access,
+                    owner: { ...newOwner, role: 'owner' },
+                    members: settings.access.members.map(m => m.id === newOwnerId ? { ...m, role: 'owner' } : m.id === settings.access.owner.id ? { ...m, role: 'admin' } : m),
+                },
+            },
+            isDirty: true,
+        });
+    },
+    deleteEntity: () => {
+        const { settings } = get();
+        if (!settings)
+            return;
+        const ws = useWorkspaceStore.getState();
+        if (settings.entityType === 'workspace') {
+            ws.deleteWorkspace(settings.entityId);
+        }
+        else if (settings.entityType === 'team' && settings.workspaceId) {
+            ws.deleteTeam(settings.workspaceId, settings.entityId);
+        }
+        else if (settings.entityType === 'agent' && settings.workspaceId && settings.teamId) {
+            ws.deleteAgent(settings.workspaceId, settings.teamId, settings.entityId);
+        }
+    },
+}));
+//# sourceMappingURL=entitySettingsStore.js.map