@serve.zone/gitops 2.13.1

package/ts/index.ts

@@ -0,0 +1,37 @@
+/**
+ * Main exports and CLI entry point for GitOps
+ */
+
+export { GitopsApp } from './classes/gitopsapp.js';
+export { logger } from './logging.js';
+
+import { GitopsApp } from './classes/gitopsapp.js';
+import { logger } from './logging.js';
+
+export async function runCli(): Promise<void> {
+  const args = process.argv.slice(2);
+  const command = args[0] || 'server';
+
+  switch (command) {
+    case 'server': {
+      const port = parseInt(process.env.GITOPS_PORT || '3000', 10);
+      const app = new GitopsApp();
+      await app.start(port);
+
+      // Handle graceful shutdown
+      const shutdown = async () => {
+        logger.info('Shutting down...');
+        await app.stop();
+        process.exit(0);
+      };
+
+      process.once('SIGINT', shutdown);
+      process.once('SIGTERM', shutdown);
+      break;
+    }
+    default:
+      logger.error(`Unknown command: ${command}`);
+      logger.info('Usage: gitops [server]');
+      process.exit(1);
+  }
+}

package/ts/logging.ts

@@ -0,0 +1,162 @@
+/**
+ * Logging utilities for GitOps
+ */
+
+import type { ISyncLogEntry } from '../ts_interfaces/data/sync.js';
+import type { IJobLogEntry } from '../ts_interfaces/data/job.js';
+
+type LogLevel = 'info' | 'success' | 'warn' | 'error' | 'debug';
+
+const SYNC_LOG_MAX = 500;
+const JOB_LOG_MAX = 500;
+
+class Logger {
+  private debugMode = false;
+  private syncLogBuffer: ISyncLogEntry[] = [];
+  private broadcastFn?: (entry: ISyncLogEntry) => void;
+  private jobLogBuffer: IJobLogEntry[] = [];
+  private jobBroadcastFn?: (entry: IJobLogEntry) => void;
+
+  constructor() {
+    this.debugMode = process.argv.includes('--debug') || process.env.DEBUG === 'true';
+  }
+
+  /**
+   * Set the broadcast function used to push sync log entries to connected clients.
+   */
+  setBroadcastFn(fn: (entry: ISyncLogEntry) => void): void {
+    this.broadcastFn = fn;
+  }
+
+  /**
+   * Log a sync-related message to both the console and the ring buffer.
+   * Also broadcasts to connected frontends via TypedSocket if available.
+   */
+  syncLog(level: ISyncLogEntry['level'], message: string, source?: string): void {
+    // Also log to console
+    this.log(level, message);
+
+    const entry: ISyncLogEntry = {
+      timestamp: Date.now(),
+      level,
+      message,
+      source,
+    };
+
+    this.syncLogBuffer.push(entry);
+    if (this.syncLogBuffer.length > SYNC_LOG_MAX) {
+      this.syncLogBuffer.splice(0, this.syncLogBuffer.length - SYNC_LOG_MAX);
+    }
+
+    if (this.broadcastFn) {
+      this.broadcastFn(entry);
+    }
+  }
+
+  /**
+   * Get recent sync log entries.
+   */
+  getSyncLogs(limit = 100): ISyncLogEntry[] {
+    return this.syncLogBuffer.slice(-limit);
+  }
+
+  /**
+   * Set the broadcast function used to push job log entries to connected clients.
+   */
+  setJobBroadcastFn(fn: (entry: IJobLogEntry) => void): void {
+    this.jobBroadcastFn = fn;
+  }
+
+  /**
+   * Log a job-related message to both the console and the ring buffer.
+   * Also broadcasts to connected frontends via TypedSocket if available.
+   */
+  jobLog(level: IJobLogEntry['level'], message: string, source?: string): void {
+    this.log(level, message);
+
+    const entry: IJobLogEntry = {
+      timestamp: Date.now(),
+      level,
+      message,
+      source,
+    };
+
+    this.jobLogBuffer.push(entry);
+    if (this.jobLogBuffer.length > JOB_LOG_MAX) {
+      this.jobLogBuffer.splice(0, this.jobLogBuffer.length - JOB_LOG_MAX);
+    }
+
+    if (this.jobBroadcastFn) {
+      this.jobBroadcastFn(entry);
+    }
+  }
+
+  /**
+   * Get recent job log entries.
+   */
+  getJobLogs(limit = 100): IJobLogEntry[] {
+    return this.jobLogBuffer.slice(-limit);
+  }
+
+  log(level: LogLevel, message: string, ...args: unknown[]): void {
+    const prefix = this.getPrefix(level);
+    const formattedMessage = `${prefix} ${message}`;
+
+    switch (level) {
+      case 'error':
+        console.error(formattedMessage, ...args);
+        break;
+      case 'warn':
+        console.warn(formattedMessage, ...args);
+        break;
+      case 'debug':
+        if (this.debugMode) {
+          console.log(formattedMessage, ...args);
+        }
+        break;
+      default:
+        console.log(formattedMessage, ...args);
+    }
+  }
+
+  info(message: string, ...args: unknown[]): void {
+    this.log('info', message, ...args);
+  }
+
+  success(message: string, ...args: unknown[]): void {
+    this.log('success', message, ...args);
+  }
+
+  warn(message: string, ...args: unknown[]): void {
+    this.log('warn', message, ...args);
+  }
+
+  error(message: string, ...args: unknown[]): void {
+    this.log('error', message, ...args);
+  }
+
+  debug(message: string, ...args: unknown[]): void {
+    this.log('debug', message, ...args);
+  }
+
+  private getPrefix(level: LogLevel): string {
+    const colors: Record<LogLevel, string> = {
+      info: '\x1b[36m',
+      success: '\x1b[32m',
+      warn: '\x1b[33m',
+      error: '\x1b[31m',
+      debug: '\x1b[90m',
+    };
+    const reset = '\x1b[0m';
+    const icons: Record<LogLevel, string> = {
+      info: 'i',
+      success: '+',
+      warn: '!',
+      error: 'x',
+      debug: '*',
+    };
+    return `${colors[level]}[${icons[level]}]${reset}`;
+  }
+}
+
+export const logger = new Logger();

package/ts/opsserver/classes.opsserver.ts

@@ -0,0 +1,86 @@
+import * as plugins from '../plugins.js';
+import { logger } from '../logging.js';
+import type { GitopsApp } from '../classes/gitopsapp.js';
+import * as handlers from './handlers/index.js';
+
+const distServeDir = plugins.path.join(
+  plugins.path.dirname(plugins.nodeUrl.fileURLToPath(import.meta.url)),
+  '../../dist_serve',
+);
+
+export class OpsServer {
+  public gitopsAppRef: GitopsApp;
+  public typedrouter = new plugins.typedrequest.TypedRouter();
+  public server!: plugins.typedserver.utilityservers.UtilityWebsiteServer;
+
+  // Handler instances
+  public adminHandler!: handlers.AdminHandler;
+  public connectionsHandler!: handlers.ConnectionsHandler;
+  public projectsHandler!: handlers.ProjectsHandler;
+  public groupsHandler!: handlers.GroupsHandler;
+  public secretsHandler!: handlers.SecretsHandler;
+  public pipelinesHandler!: handlers.PipelinesHandler;
+  public logsHandler!: handlers.LogsHandler;
+  public webhookHandler!: handlers.WebhookHandler;
+  public actionsHandler!: handlers.ActionsHandler;
+  public actionLogHandler!: handlers.ActionLogHandler;
+  public syncHandler!: handlers.SyncHandler;
+  public managedSecretsHandler!: handlers.ManagedSecretsHandler;
+  public jobsHandler!: handlers.JobsHandler;
+
+  constructor(gitopsAppRef: GitopsApp) {
+    this.gitopsAppRef = gitopsAppRef;
+  }
+
+  public async start(port = 3000) {
+    // Create webhook handler before server so routes register via addCustomRoutes
+    this.webhookHandler = new handlers.WebhookHandler(this);
+
+    this.server = new plugins.typedserver.utilityservers.UtilityWebsiteServer({
+      domain: 'localhost',
+      feedMetadata: undefined,
+      serveDir: distServeDir,
+      noCache: true,
+      addCustomRoutes: async (typedserver) => {
+        this.webhookHandler.registerRoutes(typedserver);
+      },
+    });
+
+    // Chain typedrouters
+    this.server.typedrouter.addTypedRouter(this.typedrouter);
+
+    // Set up all handlers
+    await this.setupHandlers();
+
+    await this.server.start(port);
+    logger.success(`OpsServer started on http://localhost:${port}`);
+  }
+
+  private async setupHandlers(): Promise<void> {
+    // AdminHandler requires async initialization for JWT key generation
+    this.adminHandler = new handlers.AdminHandler(this);
+    await this.adminHandler.initialize();
+
+    // All other handlers self-register in their constructors
+    this.connectionsHandler = new handlers.ConnectionsHandler(this);
+    this.projectsHandler = new handlers.ProjectsHandler(this);
+    this.groupsHandler = new handlers.GroupsHandler(this);
+    this.secretsHandler = new handlers.SecretsHandler(this);
+    this.pipelinesHandler = new handlers.PipelinesHandler(this);
+    this.logsHandler = new handlers.LogsHandler(this);
+    this.actionsHandler = new handlers.ActionsHandler(this);
+    this.actionLogHandler = new handlers.ActionLogHandler(this);
+    this.syncHandler = new handlers.SyncHandler(this);
+    this.managedSecretsHandler = new handlers.ManagedSecretsHandler(this);
+    this.jobsHandler = new handlers.JobsHandler(this);
+
+    logger.success('OpsServer TypedRequest handlers initialized');
+  }
+
+  public async stop() {
+    if (this.server) {
+      await this.server.stop();
+      logger.success('OpsServer stopped');
+    }
+  }
+}

package/ts/opsserver/handlers/actionlog.handler.ts

@@ -0,0 +1,30 @@
+import * as plugins from '../../plugins.js';
+import type { OpsServer } from '../classes.opsserver.js';
+import * as interfaces from '../../../ts_interfaces/index.js';
+import { requireValidIdentity } from '../helpers/guards.js';
+
+export class ActionLogHandler {
+  public typedrouter = new plugins.typedrequest.TypedRouter();
+
+  constructor(private opsServerRef: OpsServer) {
+    this.opsServerRef.typedrouter.addTypedRouter(this.typedrouter);
+    this.registerHandlers();
+  }
+
+  private registerHandlers(): void {
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_GetActionLog>(
+        'getActionLog',
+        async (dataArg) => {
+          await requireValidIdentity(this.opsServerRef.adminHandler, dataArg);
+          const result = await this.opsServerRef.gitopsAppRef.actionLog.query({
+            limit: dataArg.limit,
+            offset: dataArg.offset,
+            entityType: dataArg.entityType,
+          });
+          return result;
+        },
+      ),
+    );
+  }
+}

package/ts/opsserver/handlers/actions.handler.ts

@@ -0,0 +1,50 @@
+import * as plugins from '../../plugins.js';
+import type { OpsServer } from '../classes.opsserver.js';
+import * as interfaces from '../../../ts_interfaces/index.js';
+import { requireValidIdentity } from '../helpers/guards.js';
+
+export class ActionsHandler {
+  public typedrouter = new plugins.typedrequest.TypedRouter();
+
+  constructor(private opsServerRef: OpsServer) {
+    this.opsServerRef.typedrouter.addTypedRouter(this.typedrouter);
+    this.registerHandlers();
+  }
+
+  private registerHandlers(): void {
+    // Force scan secrets
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_ForceScanSecrets>(
+        'forceScanSecrets',
+        async (dataArg) => {
+          await requireValidIdentity(this.opsServerRef.adminHandler, dataArg);
+          const scanService = this.opsServerRef.gitopsAppRef.secretsScanService;
+          const result = await scanService.fullScan();
+          return {
+            ok: true,
+            connectionsScanned: result.connectionsScanned,
+            secretsFound: result.secretsFound,
+            errors: result.errors,
+            durationMs: result.durationMs,
+          };
+        },
+      ),
+    );
+
+    // Get scan status
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_GetScanStatus>(
+        'getScanStatus',
+        async (dataArg) => {
+          await requireValidIdentity(this.opsServerRef.adminHandler, dataArg);
+          const scanService = this.opsServerRef.gitopsAppRef.secretsScanService;
+          return {
+            lastScanTimestamp: scanService.lastScanTimestamp,
+            isScanning: scanService.isScanning,
+            lastResult: scanService.lastScanResult,
+          };
+        },
+      ),
+    );
+  }
+}

package/ts/opsserver/handlers/admin.handler.ts

@@ -0,0 +1,122 @@
+import * as plugins from '../../plugins.js';
+import { logger } from '../../logging.js';
+import type { OpsServer } from '../classes.opsserver.js';
+import * as interfaces from '../../../ts_interfaces/index.js';
+
+export interface IJwtData {
+  userId: string;
+  status: 'loggedIn' | 'loggedOut';
+  expiresAt: number;
+}
+
+export class AdminHandler {
+  public typedrouter = new plugins.typedrequest.TypedRouter();
+  public smartjwtInstance!: plugins.smartjwt.SmartJwt<IJwtData>;
+
+  constructor(private opsServerRef: OpsServer) {
+    this.opsServerRef.typedrouter.addTypedRouter(this.typedrouter);
+  }
+
+  public async initialize(): Promise<void> {
+    this.smartjwtInstance = new plugins.smartjwt.SmartJwt();
+    await this.smartjwtInstance.init();
+    await this.smartjwtInstance.createNewKeyPair();
+    this.registerHandlers();
+  }
+
+  private registerHandlers(): void {
+    // Login
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_AdminLogin>(
+        'adminLogin',
+        async (dataArg) => {
+          const expectedUsername = process.env.GITOPS_ADMIN_USERNAME || 'admin';
+          const expectedPassword = process.env.GITOPS_ADMIN_PASSWORD || 'admin';
+
+          if (dataArg.username !== expectedUsername || dataArg.password !== expectedPassword) {
+            throw new plugins.typedrequest.TypedResponseError('Invalid credentials');
+          }
+
+          const expiresAt = Date.now() + 24 * 3600 * 1000;
+          const userId = 'admin';
+          const jwt = await this.smartjwtInstance.createJWT({
+            userId,
+            status: 'loggedIn',
+            expiresAt,
+          });
+
+          logger.info(`User logged in: ${dataArg.username}`);
+
+          return {
+            identity: {
+              jwt,
+              userId,
+              username: dataArg.username,
+              expiresAt,
+              role: 'admin' as const,
+            },
+          };
+        },
+      ),
+    );
+
+    // Logout
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_AdminLogout>(
+        'adminLogout',
+        async (_dataArg) => {
+          return { ok: true };
+        },
+      ),
+    );
+
+    // Verify Identity
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_VerifyIdentity>(
+        'verifyIdentity',
+        async (dataArg) => {
+          if (!dataArg.identity?.jwt) {
+            return { valid: false };
+          }
+          try {
+            const jwtData = await this.smartjwtInstance.verifyJWTAndGetData(dataArg.identity.jwt);
+            if (jwtData.expiresAt < Date.now()) return { valid: false };
+            if (jwtData.status !== 'loggedIn') return { valid: false };
+            return {
+              valid: true,
+              identity: {
+                jwt: dataArg.identity.jwt,
+                userId: jwtData.userId,
+                username: dataArg.identity.username,
+                expiresAt: jwtData.expiresAt,
+                role: dataArg.identity.role,
+              },
+            };
+          } catch {
+            return { valid: false };
+          }
+        },
+      ),
+    );
+  }
+
+  // Guard for valid identity
+  public validIdentityGuard = new plugins.smartguard.Guard<{
+    identity: interfaces.data.IIdentity;
+  }>(
+    async (dataArg) => {
+      if (!dataArg.identity?.jwt) return false;
+      try {
+        const jwtData = await this.smartjwtInstance.verifyJWTAndGetData(dataArg.identity.jwt);
+        if (jwtData.expiresAt < Date.now()) return false;
+        if (jwtData.status !== 'loggedIn') return false;
+        if (dataArg.identity.expiresAt !== jwtData.expiresAt) return false;
+        if (dataArg.identity.userId !== jwtData.userId) return false;
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    { failedHint: 'identity is not valid', name: 'validIdentityGuard' },
+  );
+}

package/ts/opsserver/handlers/connections.handler.ts

@@ -0,0 +1,162 @@
+import * as plugins from '../../plugins.js';
+import type { OpsServer } from '../classes.opsserver.js';
+import * as interfaces from '../../../ts_interfaces/index.js';
+import { requireValidIdentity } from '../helpers/guards.js';
+
+export class ConnectionsHandler {
+  public typedrouter = new plugins.typedrequest.TypedRouter();
+
+  constructor(private opsServerRef: OpsServer) {
+    this.opsServerRef.typedrouter.addTypedRouter(this.typedrouter);
+    this.registerHandlers();
+  }
+
+  private get actionLog() {
+    return this.opsServerRef.gitopsAppRef.actionLog;
+  }
+
+  private registerHandlers(): void {
+    // Get all connections
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_GetConnections>(
+        'getConnections',
+        async (dataArg) => {
+          await requireValidIdentity(this.opsServerRef.adminHandler, dataArg);
+          const connections = this.opsServerRef.gitopsAppRef.connectionManager.getConnections();
+          return { connections };
+        },
+      ),
+    );
+
+    // Create connection
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_CreateConnection>(
+        'createConnection',
+        async (dataArg) => {
+          await requireValidIdentity(this.opsServerRef.adminHandler, dataArg);
+          const connection = await this.opsServerRef.gitopsAppRef.connectionManager.createConnection(
+            dataArg.name,
+            dataArg.providerType,
+            dataArg.baseUrl,
+            dataArg.token,
+            dataArg.groupFilter,
+          );
+          this.actionLog.append({
+            actionType: 'create',
+            entityType: 'connection',
+            entityId: connection.id,
+            entityName: connection.name,
+            details: `Created ${dataArg.providerType} connection "${dataArg.name}" (${dataArg.baseUrl})`,
+            username: dataArg.identity.username,
+          });
+          return { connection };
+        },
+      ),
+    );
+
+    // Update connection
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_UpdateConnection>(
+        'updateConnection',
+        async (dataArg) => {
+          await requireValidIdentity(this.opsServerRef.adminHandler, dataArg);
+          const connection = await this.opsServerRef.gitopsAppRef.connectionManager.updateConnection(
+            dataArg.connectionId,
+            {
+              name: dataArg.name,
+              baseUrl: dataArg.baseUrl,
+              token: dataArg.token,
+              groupFilter: dataArg.groupFilter,
+            },
+          );
+          const fields = [
+            dataArg.name && 'name',
+            dataArg.baseUrl && 'baseUrl',
+            dataArg.token && 'token',
+            dataArg.groupFilter !== undefined && 'groupFilter',
+          ].filter(Boolean).join(', ');
+          this.actionLog.append({
+            actionType: 'update',
+            entityType: 'connection',
+            entityId: dataArg.connectionId,
+            entityName: connection.name,
+            details: `Updated connection "${connection.name}" (fields: ${fields})`,
+            username: dataArg.identity.username,
+          });
+          return { connection };
+        },
+      ),
+    );
+
+    // Pause/resume connection
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_PauseConnection>(
+        'pauseConnection',
+        async (dataArg) => {
+          await requireValidIdentity(this.opsServerRef.adminHandler, dataArg);
+          const connection = await this.opsServerRef.gitopsAppRef.connectionManager.pauseConnection(
+            dataArg.connectionId,
+            dataArg.paused,
+          );
+          this.actionLog.append({
+            actionType: dataArg.paused ? 'pause' : 'resume',
+            entityType: 'connection',
+            entityId: dataArg.connectionId,
+            entityName: connection.name,
+            details: `${dataArg.paused ? 'Paused' : 'Resumed'} connection "${connection.name}"`,
+            username: dataArg.identity.username,
+          });
+          return { connection };
+        },
+      ),
+    );
+
+    // Test connection
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_TestConnection>(
+        'testConnection',
+        async (dataArg) => {
+          await requireValidIdentity(this.opsServerRef.adminHandler, dataArg);
+          const result = await this.opsServerRef.gitopsAppRef.connectionManager.testConnection(
+            dataArg.connectionId,
+          );
+          const conn = this.opsServerRef.gitopsAppRef.connectionManager.getConnections()
+            .find((c) => c.id === dataArg.connectionId);
+          this.actionLog.append({
+            actionType: 'test',
+            entityType: 'connection',
+            entityId: dataArg.connectionId,
+            entityName: conn?.name || dataArg.connectionId,
+            details: `Tested connection: ${result.ok ? 'success' : `failed — ${result.error || 'unknown error'}`}`,
+            username: dataArg.identity.username,
+          });
+          return result;
+        },
+      ),
+    );
+
+    // Delete connection
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_DeleteConnection>(
+        'deleteConnection',
+        async (dataArg) => {
+          await requireValidIdentity(this.opsServerRef.adminHandler, dataArg);
+          const conn = this.opsServerRef.gitopsAppRef.connectionManager.getConnections()
+            .find((c) => c.id === dataArg.connectionId);
+          await this.opsServerRef.gitopsAppRef.connectionManager.deleteConnection(
+            dataArg.connectionId,
+          );
+          this.actionLog.append({
+            actionType: 'delete',
+            entityType: 'connection',
+            entityId: dataArg.connectionId,
+            entityName: conn?.name || dataArg.connectionId,
+            details: `Deleted connection "${conn?.name || dataArg.connectionId}"`,
+            username: dataArg.identity.username,
+          });
+          return { ok: true };
+        },
+      ),
+    );
+  }
+}

package/ts/opsserver/handlers/groups.handler.ts

@@ -0,0 +1,32 @@
+import * as plugins from '../../plugins.js';
+import type { OpsServer } from '../classes.opsserver.js';
+import * as interfaces from '../../../ts_interfaces/index.js';
+import { requireValidIdentity } from '../helpers/guards.js';
+
+export class GroupsHandler {
+  public typedrouter = new plugins.typedrequest.TypedRouter();
+
+  constructor(private opsServerRef: OpsServer) {
+    this.opsServerRef.typedrouter.addTypedRouter(this.typedrouter);
+    this.registerHandlers();
+  }
+
+  private registerHandlers(): void {
+    this.typedrouter.addTypedHandler(
+      new plugins.typedrequest.TypedHandler<interfaces.requests.IReq_GetGroups>(
+        'getGroups',
+        async (dataArg) => {
+          await requireValidIdentity(this.opsServerRef.adminHandler, dataArg);
+          const provider = this.opsServerRef.gitopsAppRef.connectionManager.getProvider(
+            dataArg.connectionId,
+          );
+          const groups = await provider.getGroups({
+            search: dataArg.search,
+            page: dataArg.page,
+          });
+          return { groups };
+        },
+      ),
+    );
+  }
+}