@serve.zone/gitops 3.1.1 → 32.1.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@serve.zone/gitops',
-    version: '3.1.1',
+    version: '32.1.0',
     description: 'GitOps management app for Gitea and GitLab - manage secrets, browse projects, view CI pipelines, and stream build logs'
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxvQkFBb0I7SUFDMUIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHdIQUF3SDtDQUN0SSxDQUFBIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxvQkFBb0I7SUFDMUIsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLHdIQUF3SDtDQUN0SSxDQUFBIn0=

package/dist_ts/cache/classes.cachedb.d.ts

@@ -5,7 +5,7 @@ export interface ICacheDbOptions {
     debug?: boolean;
 }
 /**
- * Singleton wrapper around LocalTsmDb + SmartdataDb.
+ * Singleton wrapper around SmartMongo's NoSQLDB memory server and SmartData.
  * Provides a managed MongoDB-compatible cache database.
  */
 export declare class CacheDb {

package/dist_ts/cache/classes.cachedb.js

@@ -1,7 +1,7 @@
 import * as plugins from '../plugins.js';
 import { logger } from '../logging.js';
 /**
- * Singleton wrapper around LocalTsmDb + SmartdataDb.
+ * Singleton wrapper around SmartMongo's NoSQLDB memory server and SmartData.
  * Provides a managed MongoDB-compatible cache database.
  */
 export class CacheDb {

package/dist_ts/classes/connectionmanager.d.ts

@@ -30,8 +30,20 @@ export declare class ConnectionManager {
      */
     private migrateTokenToKeychain;
     private migrateRegistryTokenToKeychain;
+    /**
+     * Connections stored before webhook verification existed carry no secret. Nothing in
+     * gitops can create the webhook at the provider (neither provider implementation nor
+     * the Gitea/GitLab clients expose a hooks endpoint), so the secret is minted here and
+     * the connection is marked 'unverified': its deliveries stay refused until an operator
+     * copies the secret into the provider's webhook configuration and confirms it.
+     */
+    private backfillWebhookSecret;
     private persistConnection;
     private removeConnection;
+    /**
+     * The shape handed to API callers: every secret is masked, never the real value.
+     */
+    private toPublicConnection;
     getConnections(): interfaces.data.IProviderConnection[];
     getConnection(id: string): interfaces.data.IProviderConnection | undefined;
     createConnection(name: string, providerType: interfaces.data.TProviderType, baseUrl: string, token: string, groupFilter?: string, registryUrl?: string, registryUsername?: string, registryToken?: string): Promise<interfaces.data.IProviderConnection>;
@@ -46,6 +58,35 @@ export declare class ConnectionManager {
     }): Promise<interfaces.data.IProviderConnection>;
     deleteConnection(id: string): Promise<void>;
     pauseConnection(id: string, paused: boolean): Promise<interfaces.data.IProviderConnection>;
+    /**
+     * Reveals the webhook secret to an already authenticated caller — the operator has to
+     * transfer it into the provider's webhook configuration by hand, because no provider
+     * API surface in this app creates webhooks.
+     */
+    /**
+     * A stored-but-unreadable secret is reported as such, so an operator sees a secret-store
+     * outage instead of a connection that appears to have lost its secret.
+     */
+    private assertWebhookSecretReadable;
+    getWebhookSecret(id: string): {
+        secret: string;
+        status: interfaces.data.TWebhookStatus;
+    };
+    /**
+     * Mints a fresh webhook secret. The provider still holds the previous one, so the
+     * connection goes back to 'unverified' until the new secret is confirmed.
+     */
+    rotateWebhookSecret(id: string): Promise<{
+        secret: string;
+        status: interfaces.data.TWebhookStatus;
+    }>;
+    /**
+     * Records that the provider side now holds the current secret; deliveries that carry a
+     * valid signature are accepted from here on.
+     */
+    confirmWebhookSecret(id: string): Promise<{
+        status: interfaces.data.TWebhookStatus;
+    }>;
     testConnection(id: string): Promise<{
         ok: boolean;
         error?: string;

package/dist_ts/classes/connectionmanager.js

@@ -5,6 +5,12 @@ const LEGACY_CONNECTIONS_FILE = './.nogit/connections.json';
 const CONNECTIONS_PREFIX = '/connections/';
 const KEYCHAIN_PREFIX = 'keychain:';
 const getRegistryTokenSecretId = (connectionId) => `${connectionId}:registry`;
+const getWebhookSecretId = (connectionId) => `${connectionId}:webhook`;
+/**
+ * Mints a webhook secret. 32 random bytes as hex: long enough that a delivery carrying
+ * it proves the sender was configured by us, short enough to paste into a provider UI.
+ */
+const mintWebhookSecret = () => plugins.crypto.randomBytes(32).toString('hex');
 /**
  * Manages provider connections — persists each connection as an
  * individual JSON file via StorageManager. Tokens are stored in
@@ -109,7 +115,25 @@ export class ConnectionManager {
                 else if (conn.registryToken && conn.registryToken !== '***') {
                     await this.migrateRegistryTokenToKeychain(conn);
                 }
+                if (conn.webhookSecret?.startsWith(KEYCHAIN_PREFIX)) {
+                    const webhookSecretId = conn.webhookSecret.substring(KEYCHAIN_PREFIX.length);
+                    const realWebhookSecret = await this.smartSecret.getSecret(webhookSecretId);
+                    if (realWebhookSecret) {
+                        conn.webhookSecret = realWebhookSecret;
+                    }
+                    else {
+                        // The sentinel proves a secret was stored under this id, so an empty read is a
+                        // keychain failure, not a missing secret. Minting a replacement here would
+                        // overwrite the operator's confirmed secret under the same id and lose it, so
+                        // the connection is flagged instead and its deliveries are refused by name.
+                        logger.warn(`Webhook secret for connection ${conn.id} is stored but unreadable — deliveries are ` +
+                            'refused until the secret store returns it again; the stored secret is left untouched');
+                        conn.webhookSecret = undefined;
+                        conn.webhookSecretUnreadable = true;
+                    }
+                }
                 this.connections.push(conn);
+                await this.backfillWebhookSecret(conn);
             }
         }
         if (this.connections.length > 0) {
@@ -150,6 +174,29 @@ export class ConnectionManager {
             logger.warn(`Failed to migrate registry token for ${conn.id} to keychain: ${err}`);
         }
     }
+    /**
+     * Connections stored before webhook verification existed carry no secret. Nothing in
+     * gitops can create the webhook at the provider (neither provider implementation nor
+     * the Gitea/GitLab clients expose a hooks endpoint), so the secret is minted here and
+     * the connection is marked 'unverified': its deliveries stay refused until an operator
+     * copies the secret into the provider's webhook configuration and confirms it.
+     */
+    async backfillWebhookSecret(conn) {
+        // A stored-but-unreadable secret is not a missing one. Minting here would write a new
+        // secret over the same keychain id and destroy confirmed operator material because of
+        // a transient read failure, so this connection is left exactly as it is on disk.
+        if (conn.webhookSecretUnreadable)
+            return;
+        if (conn.webhookSecret && conn.webhookStatus)
+            return;
+        if (!conn.webhookSecret) {
+            conn.webhookSecret = mintWebhookSecret();
+        }
+        conn.webhookStatus = 'unverified';
+        await this.persistConnection(conn);
+        logger.warn(`Connection "${conn.name}" had no webhook secret — minted one and marked the webhook unverified. ` +
+            'Webhook deliveries are refused until the secret is set at the provider and confirmed.');
+    }
     async persistConnection(conn) {
         // Store real token in keychain
         await this.smartSecret.setSecret(conn.id, conn.token);
@@ -159,25 +206,52 @@ export class ConnectionManager {
         else {
             await this.smartSecret.deleteSecret(getRegistryTokenSecretId(conn.id));
         }
+        // A connection whose secret is stored but unreadable keeps both its keychain entry and
+        // its sentinel: writing would replace material we could not read, deleting would throw
+        // it away. Every other persist path (status updates, health checks) runs through here,
+        // so this is where the stored secret survives a secret-store outage.
+        if (conn.webhookSecretUnreadable) {
+            // nothing to write — the stored secret and sentinel stay as they are
+        }
+        else if (conn.webhookSecret) {
+            await this.smartSecret.setSecret(getWebhookSecretId(conn.id), conn.webhookSecret);
+        }
+        else {
+            await this.smartSecret.deleteSecret(getWebhookSecretId(conn.id));
+        }
         // Save JSON with sentinel value
         const jsonConn = {
             ...conn,
             token: `${KEYCHAIN_PREFIX}${conn.id}`,
             registryToken: conn.registryToken ? `${KEYCHAIN_PREFIX}${getRegistryTokenSecretId(conn.id)}` : undefined,
+            webhookSecret: conn.webhookSecret || conn.webhookSecretUnreadable
+                ? `${KEYCHAIN_PREFIX}${getWebhookSecretId(conn.id)}`
+                : undefined,
+            // Runtime-only flag: it describes this process's view of the secret store, not the
+            // connection, and persisting it would outlive the outage that caused it.
+            webhookSecretUnreadable: undefined,
         };
         await this.storageManager.setJSON(`${CONNECTIONS_PREFIX}${conn.id}.json`, jsonConn);
     }
     async removeConnection(id) {
         await this.smartSecret.deleteSecret(id);
         await this.smartSecret.deleteSecret(getRegistryTokenSecretId(id));
+        await this.smartSecret.deleteSecret(getWebhookSecretId(id));
         await this.storageManager.delete(`${CONNECTIONS_PREFIX}${id}.json`);
     }
-    getConnections() {
-        return this.connections.map((c) => ({
-            ...c,
+    /**
+     * The shape handed to API callers: every secret is masked, never the real value.
+     */
+    toPublicConnection(conn) {
+        return {
+            ...conn,
             token: '***',
-            registryToken: c.registryToken ? '***' : undefined,
-        }));
+            registryToken: conn.registryToken ? '***' : undefined,
+            webhookSecret: conn.webhookSecret ? '***' : undefined,
+        };
+    }
+    getConnections() {
+        return this.connections.map((c) => this.toPublicConnection(c));
     }
     getConnection(id) {
         return this.connections.find((c) => c.id === id);
@@ -195,11 +269,15 @@ export class ConnectionManager {
             registryUrl: registryUrl || undefined,
             registryUsername: registryUsername || undefined,
             registryToken: registryToken || undefined,
+            // Minted with the connection so the operator can paste it into the provider's
+            // webhook form right away; no earlier provider state can hold a stale secret.
+            webhookSecret: mintWebhookSecret(),
+            webhookStatus: 'active',
         };
         this.connections.push(connection);
         await this.persistConnection(connection);
         logger.success(`Connection created: ${name} (${providerType})`);
-        return { ...connection, token: '***', registryToken: connection.registryToken ? '***' : undefined };
+        return this.toPublicConnection(connection);
     }
     async updateConnection(id, updates) {
         const conn = this.connections.find((c) => c.id === id);
@@ -222,7 +300,7 @@ export class ConnectionManager {
         if (updates.registryToken !== undefined)
             conn.registryToken = updates.registryToken || undefined;
         await this.persistConnection(conn);
-        return { ...conn, token: '***', registryToken: conn.registryToken ? '***' : undefined };
+        return this.toPublicConnection(conn);
     }
     async deleteConnection(id) {
         const idx = this.connections.findIndex((c) => c.id === id);
@@ -239,7 +317,63 @@ export class ConnectionManager {
         conn.status = paused ? 'paused' : 'disconnected';
         await this.persistConnection(conn);
         logger.info(`Connection ${paused ? 'paused' : 'resumed'}: ${conn.name}`);
-        return { ...conn, token: '***', registryToken: conn.registryToken ? '***' : undefined };
+        return this.toPublicConnection(conn);
+    }
+    /**
+     * Reveals the webhook secret to an already authenticated caller — the operator has to
+     * transfer it into the provider's webhook configuration by hand, because no provider
+     * API surface in this app creates webhooks.
+     */
+    /**
+     * A stored-but-unreadable secret is reported as such, so an operator sees a secret-store
+     * outage instead of a connection that appears to have lost its secret.
+     */
+    assertWebhookSecretReadable(conn) {
+        if (conn.webhookSecretUnreadable) {
+            throw new Error(`Webhook secret for connection ${conn.id} is stored but unreadable — the secret store did not return it`);
+        }
+    }
+    getWebhookSecret(id) {
+        const conn = this.connections.find((c) => c.id === id);
+        if (!conn)
+            throw new Error(`Connection not found: ${id}`);
+        this.assertWebhookSecretReadable(conn);
+        if (!conn.webhookSecret)
+            throw new Error(`Connection has no webhook secret: ${id}`);
+        return { secret: conn.webhookSecret, status: conn.webhookStatus ?? 'unverified' };
+    }
+    /**
+     * Mints a fresh webhook secret. The provider still holds the previous one, so the
+     * connection goes back to 'unverified' until the new secret is confirmed.
+     */
+    async rotateWebhookSecret(id) {
+        const conn = this.connections.find((c) => c.id === id);
+        if (!conn)
+            throw new Error(`Connection not found: ${id}`);
+        conn.webhookSecret = mintWebhookSecret();
+        conn.webhookStatus = 'unverified';
+        // Rotation is the operator's explicit decision to replace the stored secret, which is
+        // also the way out of an unreadable one — unlike the automatic backfill.
+        conn.webhookSecretUnreadable = undefined;
+        await this.persistConnection(conn);
+        logger.info(`Webhook secret rotated for connection "${conn.name}" — webhook is unverified again`);
+        return { secret: conn.webhookSecret, status: conn.webhookStatus };
+    }
+    /**
+     * Records that the provider side now holds the current secret; deliveries that carry a
+     * valid signature are accepted from here on.
+     */
+    async confirmWebhookSecret(id) {
+        const conn = this.connections.find((c) => c.id === id);
+        if (!conn)
+            throw new Error(`Connection not found: ${id}`);
+        this.assertWebhookSecretReadable(conn);
+        if (!conn.webhookSecret)
+            throw new Error(`Connection has no webhook secret: ${id}`);
+        conn.webhookStatus = 'active';
+        await this.persistConnection(conn);
+        logger.success(`Webhook confirmed for connection "${conn.name}"`);
+        return { status: conn.webhookStatus };
     }
     async testConnection(id) {
         const conn = this.connections.find((c) => c.id === id);
@@ -299,4 +433,4 @@ export class ConnectionManager {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connectionmanager.js","sourceRoot":"","sources":["../../../ts/classes/connectionmanager.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connectionmanager.js","sourceRoot":"","sources":["../../../ts/classes/connectionmanager.ts"],"names":[],"mappings":"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"}

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

@@ -1,7 +1,27 @@
 import * as plugins from '../../plugins.js';
 import type { OpsServer } from '../classes.opsserver.js';
+import * as interfaces from '../../../dist_ts_interfaces/index.js';
+/** Route pattern of the delivery endpoint. */
+export declare const webhookRoutePattern = "/webhook/:connectionId";
+/** The concrete delivery path an operator configures at the provider. */
+export declare const webhookDeliveryPath: (connectionIdArg: string) => string;
 export declare class WebhookHandler {
     private opsServerRef;
+    typedrouter: plugins.typedrequest.TypedRouter<interfaces.typedrequestInterfaces.ITypedRequest>;
     constructor(opsServerRef: OpsServer);
+    private get connectionManager();
+    private get actionLog();
+    /**
+     * Refuses a delivery. The refusal name is the whole answer — no payload is echoed and
+     * nothing about the presented or expected secret is logged.
+     */
+    private refuse;
+    private webhookSettingsFor;
+    /**
+     * Operator-facing side of the webhook: reveal, rotate and confirm the shared secret.
+     * Neither provider implementation creates webhooks through the API, so the secret is
+     * transferred into the provider's webhook configuration by hand.
+     */
+    private registerHandlers;
     registerRoutes(typedserver: plugins.typedserver.TypedServer): void;
 }

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

@@ -1,28 +1,146 @@
 import * as plugins from '../../plugins.js';
 import { logger } from '../../logging.js';
 import * as interfaces from '../../../dist_ts_interfaces/index.js';
+import { requireValidIdentity } from '../helpers/guards.js';
+import { checkWebhookConnection, readBoundedWebhookBody, verifyWebhookDelivery, webhookEventHeaderFor, webhookSecretHeaderFor, } from '../helpers/webhookverification.js';
+/** Route pattern of the delivery endpoint. */
+export const webhookRoutePattern = '/webhook/:connectionId';
+/** The concrete delivery path an operator configures at the provider. */
+export const webhookDeliveryPath = (connectionIdArg) => `/webhook/${connectionIdArg}`;
+/**
+ * HTTP status per refusal. Everything the caller could fix by presenting the right
+ * secret is a 401; the rest describes the request itself — except
+ * 'webhook-secret-unreadable', which is our own transient fault and is answered 503 so a
+ * provider retries instead of an operator rotating a secret that is still correct.
+ */
+const refusalStatusCodes = {
+    'webhook-connection-unknown': 404,
+    'webhook-connection-unverified': 401,
+    'webhook-secret-missing': 401,
+    'webhook-secret-unreadable': 503,
+    'webhook-length-missing': 411,
+    'webhook-body-too-large': 413,
+    'webhook-body-unreadable': 400,
+    'webhook-signature-missing': 401,
+    'webhook-signature-invalid': 401,
+};
 export class WebhookHandler {
     opsServerRef;
+    typedrouter = new plugins.typedrequest.TypedRouter();
     constructor(opsServerRef) {
         this.opsServerRef = opsServerRef;
+        this.opsServerRef.typedrouter.addTypedRouter(this.typedrouter);
+        this.registerHandlers();
+    }
+    get connectionManager() {
+        return this.opsServerRef.gitopsAppRef.connectionManager;
+    }
+    get actionLog() {
+        return this.opsServerRef.gitopsAppRef.actionLog;
+    }
+    /**
+     * Refuses a delivery. The refusal name is the whole answer — no payload is echoed and
+     * nothing about the presented or expected secret is logged.
+     */
+    refuse(refusalArg, connectionIdArg, connectionNameArg) {
+        const target = connectionNameArg
+            ? `connection ${connectionNameArg} (${connectionIdArg})`
+            : `connection ${connectionIdArg}`;
+        logger.warn(`Webhook refused: ${refusalArg} for ${target}`);
+        return new Response(JSON.stringify({ error: refusalArg }), {
+            status: refusalStatusCodes[refusalArg],
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
+    webhookSettingsFor(connectionIdArg) {
+        const connection = this.connectionManager.getConnection(connectionIdArg);
+        if (!connection) {
+            throw new plugins.typedrequest.TypedResponseError(`Connection not found: ${connectionIdArg}`);
+        }
+        const { secret, status } = this.connectionManager.getWebhookSecret(connectionIdArg);
+        return {
+            connectionId: connection.id,
+            providerType: connection.providerType,
+            deliveryPath: webhookDeliveryPath(connection.id),
+            headerName: webhookSecretHeaderFor(connection.providerType),
+            secret,
+            status,
+        };
+    }
+    /**
+     * Operator-facing side of the webhook: reveal, rotate and confirm the shared secret.
+     * Neither provider implementation creates webhooks through the API, so the secret is
+     * transferred into the provider's webhook configuration by hand.
+     */
+    registerHandlers() {
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('getWebhookSettings', async (dataArg) => {
+            await requireValidIdentity(this.opsServerRef.adminHandler, dataArg);
+            return { webhookSettings: this.webhookSettingsFor(dataArg.connectionId) };
+        }));
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('rotateWebhookSecret', async (dataArg) => {
+            await requireValidIdentity(this.opsServerRef.adminHandler, dataArg);
+            await this.connectionManager.rotateWebhookSecret(dataArg.connectionId);
+            const webhookSettings = this.webhookSettingsFor(dataArg.connectionId);
+            this.actionLog.append({
+                actionType: 'update',
+                entityType: 'connection',
+                entityId: dataArg.connectionId,
+                entityName: this.connectionManager.getConnection(dataArg.connectionId)?.name || dataArg.connectionId,
+                details: 'Rotated webhook secret — webhook is unverified until the new secret is set at the provider',
+                username: dataArg.identity.username,
+            });
+            return { webhookSettings };
+        }));
+        this.typedrouter.addTypedHandler(new plugins.typedrequest.TypedHandler('confirmWebhookSecret', async (dataArg) => {
+            await requireValidIdentity(this.opsServerRef.adminHandler, dataArg);
+            const result = await this.connectionManager.confirmWebhookSecret(dataArg.connectionId);
+            this.actionLog.append({
+                actionType: 'update',
+                entityType: 'connection',
+                entityId: dataArg.connectionId,
+                entityName: this.connectionManager.getConnection(dataArg.connectionId)?.name || dataArg.connectionId,
+                details: 'Confirmed the webhook secret is configured at the provider',
+                username: dataArg.identity.username,
+            });
+            return result;
+        }));
     }
     registerRoutes(typedserver) {
-        typedserver.addRoute('/webhook/:connectionId', 'POST', async (ctx) => {
+        typedserver.addRoute(webhookRoutePattern, 'POST', async (ctx) => {
             const connectionId = ctx.params.connectionId;
-            // Validate connection exists
-            const connection = this.opsServerRef.gitopsAppRef.connectionManager.getConnection(connectionId);
+            // The connection carries the secret, so it is resolved before any body work.
+            const connection = this.connectionManager.getConnection(connectionId);
             if (!connection) {
-                return new Response(JSON.stringify({ error: 'Connection not found' }), {
-                    status: 404,
-                    headers: { 'Content-Type': 'application/json' },
-                });
+                return this.refuse('webhook-connection-unknown', connectionId);
+            }
+            // Everything that does not need the body is decided before buffering it.
+            const precondition = checkWebhookConnection(connection);
+            if (precondition) {
+                return this.refuse(precondition, connectionId, connection.name);
+            }
+            // The raw bytes are what the provider signed; parsing and re-serializing would
+            // change key order and whitespace and invalidate every genuine signature. The body
+            // is read through the bounded reader rather than ctx.arrayBuffer(), which buffers
+            // whatever an unauthenticated caller sends.
+            const body = await readBoundedWebhookBody({
+                headers: ctx.headers,
+                body: () => ctx.request.body,
+            });
+            if (!body.ok) {
+                return this.refuse(body.refusal, connectionId, connection.name);
+            }
+            const verification = verifyWebhookDelivery({
+                connection,
+                headers: ctx.headers,
+                rawBody: body.rawBody,
+            });
+            if (!verification.ok) {
+                return this.refuse(verification.refusal, connectionId, connection.name);
             }
-            // 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})`);
+            // The provider is the one we have a connection with, never the one the caller claims.
+            const provider = connection.providerType;
+            const event = ctx.headers.get(webhookEventHeaderFor(provider)) || 'unknown';
+            logger.info(`Webhook accepted: ${provider}/${event} for connection ${connection.name} (${connectionId})`);
             // Broadcast to all connected frontends via TypedSocket
             try {
                 const typedsocket = this.opsServerRef.server.typedserver.typedsocket;
@@ -52,4 +170,4 @@ export class WebhookHandler {
         logger.info('WebhookHandler routes registered');
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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