@serve.zone/dcrouter 2.12.4

package/ts_interfaces/requests/stats.ts

@@ -0,0 +1,162 @@
+import * as plugins from '../plugins.js';
+import * as authInterfaces from '../data/auth.js';
+import * as statsInterfaces from '../data/stats.js';
+
+// Server Statistics
+export interface IReq_GetServerStatistics extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_GetServerStatistics
+> {
+  method: 'getServerStatistics';
+  request: {
+    identity?: authInterfaces.IIdentity;
+    includeHistory?: boolean;
+    timeRange?: '1h' | '6h' | '24h' | '7d' | '30d';
+  };
+  response: {
+    stats: statsInterfaces.IServerStats;
+    history?: Array<{
+      timestamp: number;
+      value: number;
+    }>;
+  };
+}
+
+// Email Statistics
+export interface IReq_GetEmailStatistics extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_GetEmailStatistics
+> {
+  method: 'getEmailStatistics';
+  request: {
+    identity?: authInterfaces.IIdentity;
+    timeRange?: '1h' | '6h' | '24h' | '7d' | '30d';
+    domain?: string;
+    includeDetails?: boolean;
+  };
+  response: {
+    stats: statsInterfaces.IEmailStats;
+    domainBreakdown?: {
+      [domain: string]: statsInterfaces.IEmailStats;
+    };
+  };
+}
+
+// DNS Statistics
+export interface IReq_GetDnsStatistics extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_GetDnsStatistics
+> {
+  method: 'getDnsStatistics';
+  request: {
+    identity?: authInterfaces.IIdentity;
+    timeRange?: '1h' | '6h' | '24h' | '7d' | '30d';
+    domain?: string;
+    includeQueryTypes?: boolean;
+  };
+  response: {
+    stats: statsInterfaces.IDnsStats;
+    domainBreakdown?: {
+      [domain: string]: statsInterfaces.IDnsStats;
+    };
+  };
+}
+
+// Rate Limit Status
+export interface IReq_GetRateLimitStatus extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_GetRateLimitStatus
+> {
+  method: 'getRateLimitStatus';
+  request: {
+    identity?: authInterfaces.IIdentity;
+    domain?: string;
+    ip?: string;
+    includeBlocked?: boolean;
+  };
+  response: {
+    limits: statsInterfaces.IRateLimitInfo[];
+    globalLimit?: {
+      current: number;
+      limit: number;
+      remaining: number;
+    };
+  };
+}
+
+// Security Metrics
+export interface IReq_GetSecurityMetrics extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_GetSecurityMetrics
+> {
+  method: 'getSecurityMetrics';
+  request: {
+    identity?: authInterfaces.IIdentity;
+    timeRange?: '1h' | '6h' | '24h' | '7d' | '30d';
+    includeDetails?: boolean;
+  };
+  response: {
+    metrics: statsInterfaces.ISecurityMetrics;
+    trends?: {
+      spam: Array<{ timestamp: number; value: number }>;
+      malware: Array<{ timestamp: number; value: number }>;
+      phishing: Array<{ timestamp: number; value: number }>;
+    };
+  };
+}
+
+// Active Connections
+export interface IReq_GetActiveConnections extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_GetActiveConnections
+> {
+  method: 'getActiveConnections';
+  request: {
+    identity?: authInterfaces.IIdentity;
+    protocol?: 'smtp' | 'smtps' | 'http' | 'https';
+    state?: string;
+  };
+  response: {
+    connections: statsInterfaces.IConnectionInfo[];
+    summary: {
+      total: number;
+      byProtocol: {
+        [protocol: string]: number;
+      };
+      byState: {
+        [state: string]: number;
+      };
+    };
+  };
+}
+
+// Queue Status
+export interface IReq_GetQueueStatus extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_GetQueueStatus
+> {
+  method: 'getQueueStatus';
+  request: {
+    identity?: authInterfaces.IIdentity;
+    queueName?: string;
+  };
+  response: {
+    queues: statsInterfaces.IQueueStatus[];
+    totalItems: number;
+  };
+}
+
+// Health Check
+export interface IReq_GetHealthStatus extends plugins.typedrequestInterfaces.implementsTR<
+  plugins.typedrequestInterfaces.ITypedRequest,
+  IReq_GetHealthStatus
+> {
+  method: 'getHealthStatus';
+  request: {
+    identity?: authInterfaces.IIdentity;
+    detailed?: boolean;
+  };
+  response: {
+    health: statsInterfaces.IHealthStatus;
+  };
+}

package/ts_interfaces/tspublish.json

@@ -0,0 +1,3 @@
+{
+  "order": 1
+}

package/ts_web/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@serve.zone/platformservice',
+  version: '2.12.0',
+  description: 'A multifaceted platform service handling mail, SMS, letter delivery, and AI services.'
+}

package/ts_web/appstate.ts

@@ -0,0 +1,361 @@
+import * as plugins from './plugins.js';
+import * as interfaces from '../dist_ts_interfaces/index.js';
+
+// Create main app state instance
+export const appState = new plugins.domtools.plugins.smartstate.Smartstate();
+
+// Define state interfaces
+export interface ILoginState {
+  identity: interfaces.data.IIdentity | null;
+  isLoggedIn: boolean;
+}
+
+export interface IStatsState {
+  serverStats: interfaces.data.IServerStats | null;
+  emailStats: interfaces.data.IEmailStats | null;
+  dnsStats: interfaces.data.IDnsStats | null;
+  securityMetrics: interfaces.data.ISecurityMetrics | null;
+  lastUpdated: number;
+  isLoading: boolean;
+  error: string | null;
+}
+
+export interface IConfigState {
+  config: any | null;
+  isLoading: boolean;
+  error: string | null;
+}
+
+export interface IUiState {
+  activeView: string;
+  sidebarCollapsed: boolean;
+  autoRefresh: boolean;
+  refreshInterval: number; // milliseconds
+  theme: 'light' | 'dark';
+}
+
+export interface ILogState {
+  recentLogs: interfaces.data.ILogEntry[];
+  isStreaming: boolean;
+  filters: {
+    level?: string[];
+    category?: string[];
+  };
+}
+
+// Create state parts with appropriate persistence
+export const loginStatePart = await appState.getStatePart<ILoginState>(
+  'login',
+  {
+    identity: null,
+    isLoggedIn: false,
+  },
+  'soft' // Login state persists across sessions
+);
+
+export const statsStatePart = await appState.getStatePart<IStatsState>(
+  'stats',
+  {
+    serverStats: null,
+    emailStats: null,
+    dnsStats: null,
+    securityMetrics: null,
+    lastUpdated: 0,
+    isLoading: false,
+    error: null,
+  },
+  'soft' // Stats are cached but not persisted
+);
+
+export const configStatePart = await appState.getStatePart<IConfigState>(
+  'config',
+  {
+    config: null,
+    isLoading: false,
+    error: null,
+  }
+);
+
+export const uiStatePart = await appState.getStatePart<IUiState>(
+  'ui',
+  {
+    activeView: 'dashboard',
+    sidebarCollapsed: false,
+    autoRefresh: true,
+    refreshInterval: 30000, // 30 seconds
+    theme: 'light',
+  },
+);
+
+export const logStatePart = await appState.getStatePart<ILogState>(
+  'logs',
+  {
+    recentLogs: [],
+    isStreaming: false,
+    filters: {},
+  },
+  'soft'
+);
+
+// Actions for state management
+interface IActionContext {
+  identity: interfaces.data.IIdentity | null;
+}
+
+const getActionContext = (): IActionContext => {
+  return {
+    identity: loginStatePart.getState().identity,
+  };
+};
+
+// Login Action
+export const loginAction = loginStatePart.createAction<{
+  username: string;
+  password: string;
+}>(async (statePartArg, dataArg) => {
+  const typedRequest = new plugins.domtools.plugins.typedrequest.TypedRequest<
+    interfaces.requests.IReq_AdminLoginWithUsernameAndPassword
+  >('/typedrequest', 'adminLoginWithUsernameAndPassword');
+
+  try {
+    const response = await typedRequest.fire({
+      username: dataArg.username,
+      password: dataArg.password,
+    });
+
+    if (response.identity) {
+      return {
+        identity: response.identity,
+        isLoggedIn: true,
+      };
+    }
+    return statePartArg.getState();
+  } catch (error) {
+    console.error('Login failed:', error);
+    return statePartArg.getState();
+  }
+});
+
+// Logout Action
+export const logoutAction = loginStatePart.createAction(async (statePartArg) => {
+  const context = getActionContext();
+  if (!context.identity) return statePartArg.getState();
+
+  const typedRequest = new plugins.domtools.plugins.typedrequest.TypedRequest<
+    interfaces.requests.IReq_AdminLogout
+  >('/typedrequest', 'adminLogout');
+
+  try {
+    await typedRequest.fire({
+      identity: context.identity,
+    });
+  } catch (error) {
+    console.error('Logout error:', error);
+  }
+
+  // Clear login state regardless
+  return {
+    identity: null,
+    isLoggedIn: false,
+  };
+});
+
+// Fetch All Stats Action
+export const fetchAllStatsAction = statsStatePart.createAction(async (statePartArg) => {
+  const context = getActionContext();
+  
+  const currentState = statePartArg.getState();
+
+  try {
+    // Fetch server stats
+    const serverStatsRequest = new plugins.domtools.plugins.typedrequest.TypedRequest<
+      interfaces.requests.IReq_GetServerStatistics
+    >('/typedrequest', 'getServerStatistics');
+    
+    const serverStatsResponse = await serverStatsRequest.fire({
+      identity: context.identity,
+      includeHistory: false,
+    });
+
+    // Fetch email stats
+    const emailStatsRequest = new plugins.domtools.plugins.typedrequest.TypedRequest<
+      interfaces.requests.IReq_GetEmailStatistics
+    >('/typedrequest', 'getEmailStatistics');
+    
+    const emailStatsResponse = await emailStatsRequest.fire({
+      identity: context.identity,
+    });
+
+    // Fetch DNS stats
+    const dnsStatsRequest = new plugins.domtools.plugins.typedrequest.TypedRequest<
+      interfaces.requests.IReq_GetDnsStatistics
+    >('/typedrequest', 'getDnsStatistics');
+    
+    const dnsStatsResponse = await dnsStatsRequest.fire({
+      identity: context.identity,
+    });
+
+    // Fetch security metrics
+    const securityRequest = new plugins.domtools.plugins.typedrequest.TypedRequest<
+      interfaces.requests.IReq_GetSecurityMetrics
+    >('/typedrequest', 'getSecurityMetrics');
+    
+    const securityResponse = await securityRequest.fire({
+      identity: context.identity,
+    });
+
+    // Update state with all stats
+    return {
+      serverStats: serverStatsResponse.stats,
+      emailStats: emailStatsResponse.stats,
+      dnsStats: dnsStatsResponse.stats,
+      securityMetrics: securityResponse.metrics,
+      lastUpdated: Date.now(),
+      isLoading: false,
+      error: null,
+    };
+  } catch (error) {
+    return {
+      ...currentState,
+      isLoading: false,
+      error: error.message || 'Failed to fetch statistics',
+    };
+  }
+});
+
+// Fetch Configuration Action
+export const fetchConfigurationAction = configStatePart.createAction(async (statePartArg) => {
+  const context = getActionContext();
+  
+  const currentState = statePartArg.getState();
+
+  try {
+    const configRequest = new plugins.domtools.plugins.typedrequest.TypedRequest<
+      interfaces.requests.IReq_GetConfiguration
+    >('/typedrequest', 'getConfiguration');
+    
+    const response = await configRequest.fire({
+      identity: context.identity,
+    });
+
+    return {
+      config: response.config,
+      isLoading: false,
+      error: null,
+    };
+  } catch (error) {
+    return {
+      ...currentState,
+      isLoading: false,
+      error: error.message || 'Failed to fetch configuration',
+    };
+  }
+});
+
+// Update Configuration Action
+export const updateConfigurationAction = configStatePart.createAction<{
+  section: string;
+  config: any;
+}>(async (statePartArg, dataArg) => {
+  const context = getActionContext();
+  if (!context.identity) {
+    throw new Error('Must be logged in to update configuration');
+  }
+
+  const updateRequest = new plugins.domtools.plugins.typedrequest.TypedRequest<
+    interfaces.requests.IReq_UpdateConfiguration
+  >('/typedrequest', 'updateConfiguration');
+
+  const response = await updateRequest.fire({
+    identity: context.identity,
+    section: dataArg.section,
+    config: dataArg.config,
+  });
+
+  if (response.updated) {
+    // Refresh configuration
+    await configStatePart.dispatchAction(fetchConfigurationAction, null);
+    return statePartArg.getState();
+  }
+
+  return statePartArg.getState();
+});
+
+// Fetch Recent Logs Action
+export const fetchRecentLogsAction = logStatePart.createAction<{
+  limit?: number;
+  level?: 'debug' | 'info' | 'warn' | 'error';
+  category?: 'smtp' | 'dns' | 'security' | 'system' | 'email';
+}>(async (statePartArg, dataArg) => {
+  const context = getActionContext();
+
+  const logsRequest = new plugins.domtools.plugins.typedrequest.TypedRequest<
+    interfaces.requests.IReq_GetRecentLogs
+  >('/typedrequest', 'getRecentLogs');
+
+  const response = await logsRequest.fire({
+    identity: context.identity,
+    limit: dataArg.limit || 100,
+    level: dataArg.level,
+    category: dataArg.category,
+  });
+
+  return {
+    ...statePartArg.getState(),
+    recentLogs: response.logs,
+  };
+});
+
+// Toggle Auto Refresh Action
+export const toggleAutoRefreshAction = uiStatePart.createAction(async (statePartArg) => {
+  const currentState = statePartArg.getState();
+  return {
+    ...currentState,
+    autoRefresh: !currentState.autoRefresh,
+  };
+});
+
+// Set Active View Action
+export const setActiveViewAction = uiStatePart.createAction<string>(async (statePartArg, viewName) => {
+  const currentState = statePartArg.getState();
+  return {
+    ...currentState,
+    activeView: viewName,
+  };
+});
+
+// Initialize auto-refresh
+let refreshInterval: NodeJS.Timeout | null = null;
+
+// Initialize auto-refresh when UI state is ready
+(() => {
+  const startAutoRefresh = () => {
+    const uiState = uiStatePart.getState();
+    if (uiState.autoRefresh && loginStatePart.getState().isLoggedIn) {
+      refreshInterval = setInterval(() => {
+        statsStatePart.dispatchAction(fetchAllStatsAction, null);
+      }, uiState.refreshInterval);
+    }
+  };
+
+  const stopAutoRefresh = () => {
+    if (refreshInterval) {
+      clearInterval(refreshInterval);
+      refreshInterval = null;
+    }
+  };
+
+  // Watch for changes
+  uiStatePart.state.subscribe(() => {
+    stopAutoRefresh();
+    startAutoRefresh();
+  });
+
+  loginStatePart.state.subscribe(() => {
+    stopAutoRefresh();
+    startAutoRefresh();
+  });
+
+  // Initial start
+  startAutoRefresh();
+})();

package/ts_web/elements/index.ts

@@ -0,0 +1,7 @@
+export * from './ops-dashboard.js';
+export * from './ops-view-overview.js';
+export * from './ops-view-stats.js';
+export * from './ops-view-logs.js';
+export * from './ops-view-config.js';
+export * from './ops-view-security.js';
+export * from './shared/index.js';

package/ts_web/elements/ops-dashboard.ts

@@ -0,0 +1,165 @@
+import * as plugins from '../plugins.js';
+import * as appstate from '../appstate.js';
+
+import {
+  DeesElement,
+  css,
+  cssManager,
+  customElement,
+  html,
+  state,
+  type TemplateResult
+} from '@design.estate/dees-element';
+
+// Import view components
+import { OpsViewOverview } from './ops-view-overview.js';
+import { OpsViewStats } from './ops-view-stats.js';
+import { OpsViewLogs } from './ops-view-logs.js';
+import { OpsViewConfig } from './ops-view-config.js';
+import { OpsViewSecurity } from './ops-view-security.js';
+
+@customElement('ops-dashboard')
+export class OpsDashboard extends DeesElement {
+  @state() private loginState: appstate.ILoginState = {
+    identity: null,
+    isLoggedIn: false,
+  };
+  
+  @state() private uiState: appstate.IUiState = {
+    activeView: 'dashboard',
+    sidebarCollapsed: false,
+    autoRefresh: true,
+    refreshInterval: 30000,
+    theme: 'light',
+  };
+
+  constructor() {
+    super();
+    document.title = 'DCRouter OpsServer';
+    
+    // Subscribe to login state
+    const loginSubscription = appstate.loginStatePart
+      .select((stateArg) => stateArg)
+      .subscribe((loginState) => {
+        this.loginState = loginState;
+        // Trigger data fetch when logged in
+        if (loginState.isLoggedIn) {
+          appstate.statsStatePart.dispatchAction(appstate.fetchAllStatsAction, null);
+          appstate.configStatePart.dispatchAction(appstate.fetchConfigurationAction, null);
+        }
+      });
+    this.rxSubscriptions.push(loginSubscription);
+    
+    // Subscribe to UI state
+    const uiSubscription = appstate.uiStatePart
+      .select((stateArg) => stateArg)
+      .subscribe((uiState) => {
+        this.uiState = uiState;
+      });
+    this.rxSubscriptions.push(uiSubscription);
+  }
+
+  public static styles = [
+    cssManager.defaultStyles,
+    css`
+      .maincontainer {
+        position: relative;
+        width: 100vw;
+        height: 100vh;
+      }
+    `,
+  ];
+
+  public render(): TemplateResult {
+    return html`
+      <div class="maincontainer">
+        <dees-simple-login 
+          name="DCRouter OpsServer"
+        >
+          <dees-simple-appdash 
+            name="DCRouter OpsServer"
+            .viewTabs=${[
+              {
+                name: 'Overview',
+                element: OpsViewOverview,
+              },
+              {
+                name: 'Statistics',
+                element: OpsViewStats,
+              },
+              {
+                name: 'Logs',
+                element: OpsViewLogs,
+              },
+              {
+                name: 'Configuration',
+                element: OpsViewConfig,
+              },
+              {
+                name: 'Security',
+                element: OpsViewSecurity,
+              },
+            ]}
+            .userMenuItems=${[
+              {
+                name: 'Logout',
+                action: async () => {
+                  await appstate.loginStatePart.dispatchAction(appstate.logoutAction, null);
+                },
+              },
+            ]}
+          >
+          </dees-simple-appdash>
+        </dees-simple-login>
+      </div>
+    `;
+  }
+
+  public async firstUpdated() {
+    const simpleLogin = this.shadowRoot.querySelector('dees-simple-login');
+    simpleLogin.addEventListener('login', (e: CustomEvent) => {
+      console.log(e.detail);
+      this.login(e.detail.data.username, e.detail.data.password);
+    });
+
+    // Handle initial state
+    const loginState = appstate.loginStatePart.getState();
+    console.log('Initial login state:', loginState);
+    if (loginState.identity) {
+      this.loginState = loginState;
+      await simpleLogin.switchToSlottedContent();
+      await appstate.statsStatePart.dispatchAction(appstate.fetchAllStatsAction, null);
+      await appstate.configStatePart.dispatchAction(appstate.fetchConfigurationAction, null);
+    }
+  }
+
+  private async login(username: string, password: string) {
+    const domtools = await this.domtoolsPromise;
+    console.log(`Attempting to login...`);
+    const simpleLogin = this.shadowRoot.querySelector('dees-simple-login');
+    const form = simpleLogin.shadowRoot.querySelector('dees-form');
+    form.setStatus('pending', 'Logging in...');
+    
+    const state = await appstate.loginStatePart.dispatchAction(appstate.loginAction, {
+      username,
+      password,
+    });
+    
+    if (state.identity) {
+      console.log('Login successful');
+      this.loginState = state;
+      form.setStatus('success', 'Logged in!');
+      await simpleLogin.switchToSlottedContent();
+      await appstate.statsStatePart.dispatchAction(appstate.fetchAllStatsAction, null);
+      await appstate.configStatePart.dispatchAction(appstate.fetchConfigurationAction, null);
+    } else {
+      form.setStatus('error', 'Login failed!');
+      await domtools.convenience.smartdelay.delayFor(2000);
+      form.reset();
+    }
+  }
+
+  private async logout() {
+    await appstate.loginStatePart.dispatchAction(appstate.logoutAction, null);
+  }
+}