@serve.zone/gitops 2.13.1

package/dist_ts/opsserver/handlers/sync.handler.js

@@ -0,0 +1,166 @@
+import * as plugins from '../../plugins.js';
+import * as interfaces from '../../../dist_ts_interfaces/index.js';
+import { requireValidIdentity } from '../helpers/guards.js';
+import { logger } from '../../logging.js';
+export class SyncHandler {
+    opsServerRef;
+    typedrouter = new plugins.typedrequest.TypedRouter();
+    constructor(opsServerRef) {
+        this.opsServerRef = opsServerRef;
+        this.opsServerRef.typedrouter.addTypedRouter(this.typedrouter);
+        this.registerHandlers();
+        this.setupBroadcast();
+    }
+    /**
+     * Wire up the logger's broadcast function to push sync log entries
+     * to all connected frontends via TypedSocket.
+     */
+    setupBroadcast() {
+        logger.setBroadcastFn((entry) => {
+            try {
+                const typedsocket = this.opsServerRef.server?.typedserver?.typedsocket;
+                if (!typedsocket)
+                    return;
+                typedsocket.findAllTargetConnectionsByTag('syncLogClient').then((connections) => {
+                    for (const conn of connections) {
+                        typedsocket
+                            .createTypedRequest('pushSyncLog', conn)
+                            .fire({ entry })
+                            .catch(() => { });
+                    }
+                }).catch(() => { });
+            }
+            catch {
+                // Server may not be ready yet — ignore
+            }
+        });
+    }
+    get syncManager() {
+        return this.opsServerRef.gitopsAppRef.syncManager;
+    }
+    get actionLog() {
+        return this.opsServerRef.gitopsAppRef.actionLog;
+    }
+    registerHandlers() {
+        // Get all sync configs
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getSyncConfigs', async (dataArg) => {
+            await requireValidIdentity(this.opsServerRef.adminHandler, dataArg);
+            return { configs: this.syncManager.getConfigs() };
+        }));
+        // Create sync config
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('createSyncConfig', async (dataArg) => {
+            await requireValidIdentity(this.opsServerRef.adminHandler, dataArg);
+            const config = await this.syncManager.createConfig({
+                name: dataArg.name,
+                sourceConnectionId: dataArg.sourceConnectionId,
+                targetConnectionId: dataArg.targetConnectionId,
+                targetGroupOffset: dataArg.targetGroupOffset,
+                intervalMinutes: dataArg.intervalMinutes,
+                enforceDelete: dataArg.enforceDelete,
+                enforceGroupDelete: dataArg.enforceGroupDelete,
+                addMirrorHint: dataArg.addMirrorHint,
+                useGroupAvatarsForProjects: dataArg.useGroupAvatarsForProjects,
+            });
+            this.actionLog.append({
+                actionType: 'create',
+                entityType: 'sync',
+                entityId: config.id,
+                entityName: config.name,
+                details: `Created sync config "${config.name}" (${config.intervalMinutes}m interval)`,
+                username: dataArg.identity.username,
+            });
+            return { config };
+        }));
+        // Update sync config
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('updateSyncConfig', async (dataArg) => {
+            await requireValidIdentity(this.opsServerRef.adminHandler, dataArg);
+            const config = await this.syncManager.updateConfig(dataArg.syncConfigId, {
+                name: dataArg.name,
+                targetGroupOffset: dataArg.targetGroupOffset,
+                intervalMinutes: dataArg.intervalMinutes,
+                enforceDelete: dataArg.enforceDelete,
+                enforceGroupDelete: dataArg.enforceGroupDelete,
+                addMirrorHint: dataArg.addMirrorHint,
+                useGroupAvatarsForProjects: dataArg.useGroupAvatarsForProjects,
+            });
+            this.actionLog.append({
+                actionType: 'update',
+                entityType: 'sync',
+                entityId: config.id,
+                entityName: config.name,
+                details: `Updated sync config "${config.name}"`,
+                username: dataArg.identity.username,
+            });
+            return { config };
+        }));
+        // Delete sync config
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('deleteSyncConfig', async (dataArg) => {
+            await requireValidIdentity(this.opsServerRef.adminHandler, dataArg);
+            const config = this.syncManager.getConfig(dataArg.syncConfigId);
+            await this.syncManager.deleteConfig(dataArg.syncConfigId);
+            this.actionLog.append({
+                actionType: 'delete',
+                entityType: 'sync',
+                entityId: dataArg.syncConfigId,
+                entityName: config?.name || dataArg.syncConfigId,
+                details: `Deleted sync config "${config?.name || dataArg.syncConfigId}"`,
+                username: dataArg.identity.username,
+            });
+            return { ok: true };
+        }));
+        // Pause/resume sync config
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('pauseSyncConfig', async (dataArg) => {
+            await requireValidIdentity(this.opsServerRef.adminHandler, dataArg);
+            const config = await this.syncManager.pauseConfig(dataArg.syncConfigId, dataArg.paused);
+            this.actionLog.append({
+                actionType: dataArg.paused ? 'pause' : 'resume',
+                entityType: 'sync',
+                entityId: config.id,
+                entityName: config.name,
+                details: `${dataArg.paused ? 'Paused' : 'Resumed'} sync config "${config.name}"`,
+                username: dataArg.identity.username,
+            });
+            return { config };
+        }));
+        // Trigger sync manually
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('triggerSync', async (dataArg) => {
+            await requireValidIdentity(this.opsServerRef.adminHandler, dataArg);
+            const config = this.syncManager.getConfig(dataArg.syncConfigId);
+            if (!config) {
+                return { ok: false, message: 'Sync config not found' };
+            }
+            // Fire and forget — force=true bypasses paused check for manual triggers
+            this.syncManager.executeSync(dataArg.syncConfigId, true).catch((err) => {
+                console.error(`Manual sync trigger failed: ${err}`);
+            });
+            this.actionLog.append({
+                actionType: 'sync',
+                entityType: 'sync',
+                entityId: config.id,
+                entityName: config.name,
+                details: `Manually triggered sync "${config.name}"`,
+                username: dataArg.identity.username,
+            });
+            return { ok: true, message: 'Sync triggered' };
+        }));
+        // Preview sync (dry run — shows source → target mappings)
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('previewSync', async (dataArg) => {
+            await requireValidIdentity(this.opsServerRef.adminHandler, dataArg);
+            const result = await this.syncManager.previewSync(dataArg.syncConfigId);
+            return { mappings: result.mappings, deletions: result.deletions, groupDeletions: result.groupDeletions };
+        }));
+        // Get repo statuses for a sync config
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getSyncRepoStatuses', async (dataArg) => {
+            await requireValidIdentity(this.opsServerRef.adminHandler, dataArg);
+            const statuses = await this.syncManager.getRepoStatuses(dataArg.syncConfigId);
+            return { statuses };
+        }));
+        // Get recent sync log entries
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getSyncLogs', async (dataArg) => {
+            await requireValidIdentity(this.opsServerRef.adminHandler, dataArg);
+            const logs = logger.getSyncLogs(dataArg.limit || 200);
+            return { logs };
+        }));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sync.handler.js","sourceRoot":"","sources":["../../../../ts/opsserver/handlers/sync.handler.ts"],"names":[],"mappings":"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"}

package/dist_ts/opsserver/handlers/webhook.handler.d.ts

@@ -0,0 +1,7 @@
+import * as plugins from '../../plugins.js';
+import type { OpsServer } from '../classes.opsserver.js';
+export declare class WebhookHandler {
+    private opsServerRef;
+    constructor(opsServerRef: OpsServer);
+    registerRoutes(typedserver: plugins.typedserver.TypedServer): void;
+}

package/dist_ts/opsserver/handlers/webhook.handler.js

@@ -0,0 +1,55 @@
+import * as plugins from '../../plugins.js';
+import { logger } from '../../logging.js';
+import * as interfaces from '../../../dist_ts_interfaces/index.js';
+export class WebhookHandler {
+    opsServerRef;
+    constructor(opsServerRef) {
+        this.opsServerRef = opsServerRef;
+    }
+    registerRoutes(typedserver) {
+        typedserver.addRoute('/webhook/:connectionId', 'POST', async (ctx) => {
+            const connectionId = ctx.params.connectionId;
+            // Validate connection exists
+            const connection = this.opsServerRef.gitopsAppRef.connectionManager.getConnection(connectionId);
+            if (!connection) {
+                return new Response(JSON.stringify({ error: 'Connection not found' }), {
+                    status: 404,
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+            // Parse event type from provider-specific headers
+            const giteaEvent = ctx.headers.get('X-Gitea-Event');
+            const gitlabEvent = ctx.headers.get('X-Gitlab-Event');
+            const event = giteaEvent || gitlabEvent || 'unknown';
+            const provider = giteaEvent ? 'gitea' : gitlabEvent ? 'gitlab' : 'unknown';
+            logger.info(`Webhook received: ${provider}/${event} for connection ${connection.name} (${connectionId})`);
+            // Broadcast to all connected frontends via TypedSocket
+            try {
+                const typedsocket = this.opsServerRef.server.typedserver.typedsocket;
+                if (typedsocket) {
+                    const connections = await typedsocket.findAllTargetConnectionsByTag('syncLogClient');
+                    for (const conn of connections) {
+                        const req = typedsocket.createTypedRequest('webhookNotification', conn);
+                        req.fire({
+                            connectionId,
+                            provider,
+                            event,
+                            timestamp: Date.now(),
+                        }).catch((err) => {
+                            logger.warn(`Failed to notify client: ${err.message || err}`);
+                        });
+                    }
+                }
+            }
+            catch (err) {
+                logger.warn(`Failed to broadcast webhook event: ${err.message || err}`);
+            }
+            return new Response(JSON.stringify({ ok: true }), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+            });
+        });
+        logger.info('WebhookHandler routes registered');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/opsserver/helpers/guards.d.ts

@@ -0,0 +1,5 @@
+import type { AdminHandler } from '../handlers/admin.handler.js';
+import * as interfaces from '../../../dist_ts_interfaces/index.js';
+export declare function requireValidIdentity<T extends {
+    identity?: interfaces.data.IIdentity;
+}>(adminHandler: AdminHandler, dataArg: T): Promise<void>;

package/dist_ts/opsserver/helpers/guards.js

@@ -0,0 +1,12 @@
+import * as plugins from '../../plugins.js';
+import * as interfaces from '../../../dist_ts_interfaces/index.js';
+export async function requireValidIdentity(adminHandler, dataArg) {
+    if (!dataArg.identity) {
+        throw new plugins.typedrequest.TypedResponseError('No identity provided');
+    }
+    const passed = await adminHandler.validIdentityGuard.exec({ identity: dataArg.identity });
+    if (!passed) {
+        throw new plugins.typedrequest.TypedResponseError('Valid identity required');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ3VhcmRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vdHMvb3Bzc2VydmVyL2hlbHBlcnMvZ3VhcmRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sa0JBQWtCLENBQUM7QUFFNUMsT0FBTyxLQUFLLFVBQVUsTUFBTSxpQ0FBaUMsQ0FBQztBQUU5RCxNQUFNLENBQUMsS0FBSyxVQUFVLG9CQUFvQixDQUN4QyxZQUEwQixFQUMxQixPQUFVO0lBRVYsSUFBSSxDQUFDLE9BQU8sQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUN0QixNQUFNLElBQUksT0FBTyxDQUFDLFlBQVksQ0FBQyxrQkFBa0IsQ0FBQyxzQkFBc0IsQ0FBQyxDQUFDO0lBQzVFLENBQUM7SUFDRCxNQUFNLE1BQU0sR0FBRyxNQUFNLFlBQVksQ0FBQyxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsRUFBRSxRQUFRLEVBQUUsT0FBTyxDQUFDLFFBQVEsRUFBRSxDQUFDLENBQUM7SUFDMUYsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO1FBQ1osTUFBTSxJQUFJLE9BQU8sQ0FBQyxZQUFZLENBQUMsa0JBQWtCLENBQUMseUJBQXlCLENBQUMsQ0FBQztJQUMvRSxDQUFDO0FBQ0gsQ0FBQyJ9

package/dist_ts/opsserver/index.d.ts

@@ -0,0 +1 @@
+export { OpsServer } from './classes.opsserver.js';

package/dist_ts/opsserver/index.js

@@ -0,0 +1,2 @@
+export { OpsServer } from './classes.opsserver.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9vcHNzZXJ2ZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLHdCQUF3QixDQUFDIn0=

package/dist_ts/paths.d.ts

@@ -0,0 +1,9 @@
+export interface IGitopsPaths {
+    gitopsHomeDir: string;
+    defaultStoragePath: string;
+    defaultTsmDbPath: string;
+}
+/**
+ * Resolve gitops paths. Accepts optional baseDir for test isolation.
+ */
+export declare function resolvePaths(baseDir?: string): IGitopsPaths;

package/dist_ts/paths.js

@@ -0,0 +1,13 @@
+import * as plugins from './plugins.js';
+/**
+ * Resolve gitops paths. Accepts optional baseDir for test isolation.
+ */
+export function resolvePaths(baseDir) {
+    const home = baseDir ?? plugins.path.join(process.env.HOME ?? '/tmp', '.serve.zone', 'gitops');
+    return {
+        gitopsHomeDir: home,
+        defaultStoragePath: plugins.path.join(home, 'storage'),
+        defaultTsmDbPath: plugins.path.join(home, 'tsmdb'),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF0aHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9wYXRocy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQVF4Qzs7R0FFRztBQUNILE1BQU0sVUFBVSxZQUFZLENBQUMsT0FBZ0I7SUFDM0MsTUFBTSxJQUFJLEdBQUcsT0FBTyxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsSUFBSSxJQUFJLE1BQU0sRUFBRSxhQUFhLEVBQUUsUUFBUSxDQUFDLENBQUM7SUFDL0YsT0FBTztRQUNMLGFBQWEsRUFBRSxJQUFJO1FBQ25CLGtCQUFrQixFQUFFLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksRUFBRSxTQUFTLENBQUM7UUFDdEQsZ0JBQWdCLEVBQUUsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLE9BQU8sQ0FBQztLQUNuRCxDQUFDO0FBQ0osQ0FBQyJ9

package/dist_ts/plugins.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Centralized dependency imports for GitOps
+ */
+import * as path from 'node:path';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as nodeUrl from 'node:url';
+import * as childProcess from 'node:child_process';
+import { Buffer } from 'node:buffer';
+export { path, fs, os, nodeUrl, childProcess, Buffer };
+import * as typedrequest from '@api.global/typedrequest';
+import * as typedserver from '@api.global/typedserver';
+export { typedrequest, typedserver };
+import * as smartguard from '@push.rocks/smartguard';
+import * as smartjwt from '@push.rocks/smartjwt';
+export { smartguard, smartjwt };
+import * as giteaClient from '@apiclient.xyz/gitea';
+import * as gitlabClient from '@apiclient.xyz/gitlab';
+import * as bookstackClient from '@apiclient.xyz/bookstack';
+export { giteaClient, gitlabClient, bookstackClient };
+import * as smartmongo from '@push.rocks/smartmongo';
+import * as smartdata from '@push.rocks/smartdata';
+export { smartmongo, smartdata };
+import * as smartsecret from '@push.rocks/smartsecret';
+export { smartsecret };

package/dist_ts/plugins.js

@@ -0,0 +1,32 @@
+/**
+ * Centralized dependency imports for GitOps
+ */
+// Node native scope
+import * as path from 'node:path';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as nodeUrl from 'node:url';
+import * as childProcess from 'node:child_process';
+import { Buffer } from 'node:buffer';
+export { path, fs, os, nodeUrl, childProcess, Buffer };
+// TypedRequest/TypedServer infrastructure
+import * as typedrequest from '@api.global/typedrequest';
+import * as typedserver from '@api.global/typedserver';
+export { typedrequest, typedserver };
+// Auth & Guards
+import * as smartguard from '@push.rocks/smartguard';
+import * as smartjwt from '@push.rocks/smartjwt';
+export { smartguard, smartjwt };
+// API Clients
+import * as giteaClient from '@apiclient.xyz/gitea';
+import * as gitlabClient from '@apiclient.xyz/gitlab';
+import * as bookstackClient from '@apiclient.xyz/bookstack';
+export { giteaClient, gitlabClient, bookstackClient };
+// Database
+import * as smartmongo from '@push.rocks/smartmongo';
+import * as smartdata from '@push.rocks/smartdata';
+export { smartmongo, smartdata };
+// Secrets
+import * as smartsecret from '@push.rocks/smartsecret';
+export { smartsecret };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxvQkFBb0I7QUFDcEIsT0FBTyxLQUFLLElBQUksTUFBTSxXQUFXLENBQUM7QUFDbEMsT0FBTyxLQUFLLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUN2QyxPQUFPLEtBQUssRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUM5QixPQUFPLEtBQUssT0FBTyxNQUFNLFVBQVUsQ0FBQztBQUNwQyxPQUFPLEtBQUssWUFBWSxNQUFNLG9CQUFvQixDQUFDO0FBQ25ELE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFFckMsT0FBTyxFQUFFLElBQUksRUFBRSxFQUFFLEVBQUUsRUFBRSxFQUFFLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxFQUFFLENBQUM7QUFFdkQsMENBQTBDO0FBQzFDLE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLFdBQVcsTUFBTSx5QkFBeUIsQ0FBQztBQUN2RCxPQUFPLEVBQUUsWUFBWSxFQUFFLFdBQVcsRUFBRSxDQUFDO0FBRXJDLGdCQUFnQjtBQUNoQixPQUFPLEtBQUssVUFBVSxNQUFNLHdCQUF3QixDQUFDO0FBQ3JELE9BQU8sS0FBSyxRQUFRLE1BQU0sc0JBQXNCLENBQUM7QUFDakQsT0FBTyxFQUFFLFVBQVUsRUFBRSxRQUFRLEVBQUUsQ0FBQztBQUVoQyxjQUFjO0FBQ2QsT0FBTyxLQUFLLFdBQVcsTUFBTSxzQkFBc0IsQ0FBQztBQUNwRCxPQUFPLEtBQUssWUFBWSxNQUFNLHVCQUF1QixDQUFDO0FBQ3RELE9BQU8sS0FBSyxlQUFlLE1BQU0sMEJBQTBCLENBQUM7QUFDNUQsT0FBTyxFQUFFLFdBQVcsRUFBRSxZQUFZLEVBQUUsZUFBZSxFQUFFLENBQUM7QUFFdEQsV0FBVztBQUNYLE9BQU8sS0FBSyxVQUFVLE1BQU0sd0JBQXdCLENBQUM7QUFDckQsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEVBQUUsVUFBVSxFQUFFLFNBQVMsRUFBRSxDQUFDO0FBRWpDLFVBQVU7QUFDVixPQUFPLEtBQUssV0FBVyxNQUFNLHlCQUF5QixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxXQUFXLEVBQUUsQ0FBQyJ9

package/dist_ts/providers/classes.baseprovider.d.ts

@@ -0,0 +1,51 @@
+import type * as interfaces from '../../dist_ts_interfaces/index.js';
+export interface ITestConnectionResult {
+    ok: boolean;
+    error?: string;
+}
+export interface IListOptions {
+    search?: string;
+    page?: number;
+    perPage?: number;
+}
+export interface IPipelineListOptions extends IListOptions {
+    status?: string;
+    ref?: string;
+    source?: string;
+}
+/**
+ * Abstract base class for Git provider implementations.
+ * Subclasses implement Gitea API v1 or GitLab API v4.
+ */
+export declare abstract class BaseProvider {
+    readonly connectionId: string;
+    readonly baseUrl: string;
+    protected readonly token: string;
+    readonly groupFilterId?: string;
+    constructor(connectionId: string, baseUrl: string, token: string, groupFilterId?: string);
+    abstract testConnection(): Promise<ITestConnectionResult>;
+    abstract getProjects(opts?: IListOptions): Promise<interfaces.data.IProject[]>;
+    abstract getGroups(opts?: IListOptions): Promise<interfaces.data.IGroup[]>;
+    abstract getGroupProjects(groupId: string, opts?: IListOptions): Promise<interfaces.data.IProject[]>;
+    abstract getProjectSecrets(projectId: string): Promise<interfaces.data.ISecret[]>;
+    abstract createProjectSecret(projectId: string, key: string, value: string): Promise<interfaces.data.ISecret>;
+    abstract updateProjectSecret(projectId: string, key: string, value: string): Promise<interfaces.data.ISecret>;
+    abstract deleteProjectSecret(projectId: string, key: string): Promise<void>;
+    abstract getGroupSecrets(groupId: string): Promise<interfaces.data.ISecret[]>;
+    abstract createGroupSecret(groupId: string, key: string, value: string): Promise<interfaces.data.ISecret>;
+    abstract updateGroupSecret(groupId: string, key: string, value: string): Promise<interfaces.data.ISecret>;
+    abstract deleteGroupSecret(groupId: string, key: string): Promise<void>;
+    abstract getBranches(projectFullPath: string, opts?: IListOptions): Promise<interfaces.data.IBranch[]>;
+    abstract getTags(projectFullPath: string, opts?: IListOptions): Promise<interfaces.data.ITag[]>;
+    abstract getPipelines(projectId: string, opts?: IPipelineListOptions): Promise<interfaces.data.IPipeline[]>;
+    abstract getPipelineJobs(projectId: string, pipelineId: string): Promise<interfaces.data.IPipelineJob[]>;
+    abstract getJobLog(projectId: string, jobId: string): Promise<string>;
+    abstract retryPipeline(projectId: string, pipelineId: string): Promise<void>;
+    abstract cancelPipeline(projectId: string, pipelineId: string): Promise<void>;
+    abstract getFileContent(projectFullPath: string, filePath: string, ref?: string): Promise<string | null>;
+    abstract getDirectoryContents(projectFullPath: string, dirPath: string, ref?: string): Promise<{
+        name: string;
+        path: string;
+        type: string;
+    }[] | null>;
+}

package/dist_ts/providers/classes.baseprovider.js

@@ -0,0 +1,17 @@
+/**
+ * Abstract base class for Git provider implementations.
+ * Subclasses implement Gitea API v1 or GitLab API v4.
+ */
+export class BaseProvider {
+    connectionId;
+    baseUrl;
+    token;
+    groupFilterId;
+    constructor(connectionId, baseUrl, token, groupFilterId) {
+        this.connectionId = connectionId;
+        this.baseUrl = baseUrl;
+        this.token = token;
+        this.groupFilterId = groupFilterId;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5iYXNlcHJvdmlkZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9wcm92aWRlcnMvY2xhc3Nlcy5iYXNlcHJvdmlkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBbUJBOzs7R0FHRztBQUNILE1BQU0sT0FBZ0IsWUFBWTtJQUlkO0lBQ0E7SUFDRztJQUxMLGFBQWEsQ0FBVTtJQUV2QyxZQUNrQixZQUFvQixFQUNwQixPQUFlLEVBQ1osS0FBYSxFQUNoQyxhQUFzQjtRQUhOLGlCQUFZLEdBQVosWUFBWSxDQUFRO1FBQ3BCLFlBQU8sR0FBUCxPQUFPLENBQVE7UUFDWixVQUFLLEdBQUwsS0FBSyxDQUFRO1FBR2hDLElBQUksQ0FBQyxhQUFhLEdBQUcsYUFBYSxDQUFDO0lBQ3JDLENBQUM7Q0FpRUYifQ==

package/dist_ts/providers/classes.giteaprovider.d.ts

@@ -0,0 +1,40 @@
+import type * as interfaces from '../../dist_ts_interfaces/index.js';
+import { BaseProvider, type ITestConnectionResult, type IListOptions, type IPipelineListOptions } from './classes.baseprovider.js';
+/**
+ * Gitea API v1 provider implementation
+ */
+export declare class GiteaProvider extends BaseProvider {
+    private client;
+    constructor(connectionId: string, baseUrl: string, token: string, groupFilterId?: string);
+    testConnection(): Promise<ITestConnectionResult>;
+    getProjects(opts?: IListOptions): Promise<interfaces.data.IProject[]>;
+    getGroups(opts?: IListOptions): Promise<interfaces.data.IGroup[]>;
+    getGroupProjects(groupId: string, opts?: IListOptions): Promise<interfaces.data.IProject[]>;
+    getBranches(projectFullPath: string, opts?: IListOptions): Promise<interfaces.data.IBranch[]>;
+    getTags(projectFullPath: string, opts?: IListOptions): Promise<interfaces.data.ITag[]>;
+    getProjectSecrets(projectId: string): Promise<interfaces.data.ISecret[]>;
+    createProjectSecret(projectId: string, key: string, value: string): Promise<interfaces.data.ISecret>;
+    updateProjectSecret(projectId: string, key: string, value: string): Promise<interfaces.data.ISecret>;
+    deleteProjectSecret(projectId: string, key: string): Promise<void>;
+    getGroupSecrets(groupId: string): Promise<interfaces.data.ISecret[]>;
+    createGroupSecret(groupId: string, key: string, value: string): Promise<interfaces.data.ISecret>;
+    updateGroupSecret(groupId: string, key: string, value: string): Promise<interfaces.data.ISecret>;
+    deleteGroupSecret(groupId: string, key: string): Promise<void>;
+    getPipelines(projectId: string, opts?: IPipelineListOptions): Promise<interfaces.data.IPipeline[]>;
+    getPipelineJobs(projectId: string, pipelineId: string): Promise<interfaces.data.IPipelineJob[]>;
+    getJobLog(projectId: string, jobId: string): Promise<string>;
+    retryPipeline(projectId: string, pipelineId: string): Promise<void>;
+    cancelPipeline(_projectId: string, _pipelineId: string): Promise<void>;
+    getFileContent(projectFullPath: string, filePath: string, ref?: string): Promise<string | null>;
+    getDirectoryContents(projectFullPath: string, dirPath: string, ref?: string): Promise<{
+        name: string;
+        path: string;
+        type: string;
+    }[] | null>;
+    private mapProject;
+    private mapGroup;
+    private mapSecret;
+    private mapPipeline;
+    private mapJob;
+    private mapStatus;
+}