@serve.zone/gitops 2.13.1

package/dist_ts/classes/managedsecrets.manager.js

@@ -0,0 +1,247 @@
+import * as plugins from '../plugins.js';
+import { logger } from '../logging.js';
+const MANAGED_SECRETS_PREFIX = '/managed-secrets/';
+const KEYCHAIN_PREFIX = 'keychain:';
+const KEYCHAIN_ID_PREFIX = 'gitops-msecret-';
+const SECRET_KEY_PREFIX = 'GITOPS_';
+export class ManagedSecretsManager {
+    storageManager;
+    smartSecret;
+    connectionManager;
+    secrets = [];
+    constructor(storageManager, smartSecret, connectionManager) {
+        this.storageManager = storageManager;
+        this.smartSecret = smartSecret;
+        this.connectionManager = connectionManager;
+    }
+    async init() {
+        await this.loadSecrets();
+    }
+    // ---- Storage helpers ----
+    keychainId(secretId) {
+        return `${KEYCHAIN_ID_PREFIX}${secretId}`;
+    }
+    prefixedKey(key) {
+        return `${SECRET_KEY_PREFIX}${key}`;
+    }
+    async loadSecrets() {
+        const keys = await this.storageManager.list(MANAGED_SECRETS_PREFIX);
+        this.secrets = [];
+        for (const key of keys) {
+            const stored = await this.storageManager.getJSON(key);
+            if (stored) {
+                this.secrets.push(stored);
+            }
+        }
+        if (this.secrets.length > 0) {
+            logger.info(`Loaded ${this.secrets.length} managed secret(s)`);
+        }
+    }
+    async persistSecret(stored, realValue) {
+        // Store real value in keychain
+        await this.smartSecret.setSecret(this.keychainId(stored.id), realValue);
+        // Save JSON with sentinel
+        const jsonStored = { ...stored, value: `${KEYCHAIN_PREFIX}${this.keychainId(stored.id)}` };
+        await this.storageManager.setJSON(`${MANAGED_SECRETS_PREFIX}${stored.id}.json`, jsonStored);
+        // Update in-memory sentinel too
+        stored.value = jsonStored.value;
+    }
+    async removeFromStorage(id) {
+        await this.smartSecret.deleteSecret(this.keychainId(id));
+        await this.storageManager.delete(`${MANAGED_SECRETS_PREFIX}${id}.json`);
+    }
+    async getSecretValue(id) {
+        return await this.smartSecret.getSecret(this.keychainId(id));
+    }
+    toApiModel(stored) {
+        return {
+            id: stored.id,
+            key: stored.key,
+            description: stored.description,
+            targets: stored.targets,
+            targetStatuses: stored.targetStatuses,
+            createdAt: stored.createdAt,
+            updatedAt: stored.updatedAt,
+            lastPushedAt: stored.lastPushedAt,
+        };
+    }
+    // ---- Push logic ----
+    async pushToTargets(stored, mode, targetsOverride) {
+        const targets = targetsOverride || stored.targets;
+        const value = mode === 'upsert' ? await this.getSecretValue(stored.id) : null;
+        const prefixedKey = this.prefixedKey(stored.key);
+        const results = [];
+        for (const target of targets) {
+            const status = {
+                connectionId: target.connectionId,
+                scope: target.scope,
+                scopeId: target.scopeId,
+                scopeName: target.scopeName,
+                status: 'pending',
+            };
+            try {
+                const provider = this.connectionManager.getProvider(target.connectionId);
+                if (mode === 'upsert') {
+                    // Try update first; if it fails, create
+                    try {
+                        if (target.scope === 'project') {
+                            await provider.updateProjectSecret(target.scopeId, prefixedKey, value);
+                        }
+                        else {
+                            await provider.updateGroupSecret(target.scopeId, prefixedKey, value);
+                        }
+                    }
+                    catch {
+                        // Secret doesn't exist yet — create it
+                        if (target.scope === 'project') {
+                            await provider.createProjectSecret(target.scopeId, prefixedKey, value);
+                        }
+                        else {
+                            await provider.createGroupSecret(target.scopeId, prefixedKey, value);
+                        }
+                    }
+                }
+                else {
+                    // mode === 'delete'
+                    try {
+                        if (target.scope === 'project') {
+                            await provider.deleteProjectSecret(target.scopeId, prefixedKey);
+                        }
+                        else {
+                            await provider.deleteGroupSecret(target.scopeId, prefixedKey);
+                        }
+                    }
+                    catch {
+                        // Secret may not exist on target — that's fine
+                    }
+                }
+                status.status = 'success';
+                status.lastPushedAt = Date.now();
+            }
+            catch (err) {
+                status.status = 'error';
+                status.error = err instanceof Error ? err.message : String(err);
+            }
+            results.push(status);
+        }
+        return results;
+    }
+    // ---- Public API ----
+    async getAll() {
+        return this.secrets.map((s) => this.toApiModel(s));
+    }
+    async getById(id) {
+        const stored = this.secrets.find((s) => s.id === id);
+        return stored ? this.toApiModel(stored) : null;
+    }
+    async create(key, value, description, targets) {
+        // Validate key
+        if (key.toUpperCase().startsWith(SECRET_KEY_PREFIX)) {
+            throw new Error(`Key must not start with ${SECRET_KEY_PREFIX} — the prefix is added automatically`);
+        }
+        if (this.secrets.some((s) => s.key === key)) {
+            throw new Error(`A managed secret with key "${key}" already exists`);
+        }
+        const now = Date.now();
+        const stored = {
+            id: crypto.randomUUID(),
+            key,
+            description,
+            value: '', // will be set by persistSecret
+            targets,
+            targetStatuses: [],
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.secrets.push(stored);
+        await this.persistSecret(stored, value);
+        // Push to all targets
+        const pushResults = await this.pushToTargets(stored, 'upsert');
+        stored.targetStatuses = pushResults;
+        stored.lastPushedAt = now;
+        stored.updatedAt = now;
+        await this.storageManager.setJSON(`${MANAGED_SECRETS_PREFIX}${stored.id}.json`, {
+            ...stored,
+            value: `${KEYCHAIN_PREFIX}${this.keychainId(stored.id)}`,
+        });
+        logger.info(`Created managed secret "${key}" with ${targets.length} target(s)`);
+        return { managedSecret: this.toApiModel(stored), pushResults };
+    }
+    async update(id, updates) {
+        const stored = this.secrets.find((s) => s.id === id);
+        if (!stored)
+            throw new Error(`Managed secret not found: ${id}`);
+        const now = Date.now();
+        // Update value in keychain if provided
+        if (updates.value !== undefined) {
+            await this.smartSecret.setSecret(this.keychainId(id), updates.value);
+        }
+        if (updates.description !== undefined) {
+            stored.description = updates.description;
+        }
+        // Handle target changes — delete from removed targets
+        let removedTargets = [];
+        if (updates.targets !== undefined) {
+            const oldTargets = stored.targets;
+            const newTargetKeys = new Set(updates.targets.map((t) => `${t.connectionId}:${t.scope}:${t.scopeId}`));
+            removedTargets = oldTargets.filter((t) => !newTargetKeys.has(`${t.connectionId}:${t.scope}:${t.scopeId}`));
+            stored.targets = updates.targets;
+        }
+        stored.updatedAt = now;
+        // Delete from removed targets
+        if (removedTargets.length > 0) {
+            await this.pushToTargets(stored, 'delete', removedTargets);
+        }
+        // Push to current targets
+        const pushResults = await this.pushToTargets(stored, 'upsert');
+        stored.targetStatuses = pushResults;
+        stored.lastPushedAt = now;
+        await this.storageManager.setJSON(`${MANAGED_SECRETS_PREFIX}${stored.id}.json`, {
+            ...stored,
+            value: `${KEYCHAIN_PREFIX}${this.keychainId(stored.id)}`,
+        });
+        logger.info(`Updated managed secret "${stored.key}"`);
+        return { managedSecret: this.toApiModel(stored), pushResults };
+    }
+    async delete(id) {
+        const stored = this.secrets.find((s) => s.id === id);
+        if (!stored)
+            throw new Error(`Managed secret not found: ${id}`);
+        // Best-effort: remove from all targets
+        const deleteResults = await this.pushToTargets(stored, 'delete');
+        // Remove from local storage regardless
+        const idx = this.secrets.indexOf(stored);
+        this.secrets.splice(idx, 1);
+        await this.removeFromStorage(id);
+        logger.info(`Deleted managed secret "${stored.key}"`);
+        return { ok: true, deleteResults };
+    }
+    async pushOne(id) {
+        const stored = this.secrets.find((s) => s.id === id);
+        if (!stored)
+            throw new Error(`Managed secret not found: ${id}`);
+        const now = Date.now();
+        const pushResults = await this.pushToTargets(stored, 'upsert');
+        stored.targetStatuses = pushResults;
+        stored.lastPushedAt = now;
+        stored.updatedAt = now;
+        await this.storageManager.setJSON(`${MANAGED_SECRETS_PREFIX}${stored.id}.json`, {
+            ...stored,
+            value: `${KEYCHAIN_PREFIX}${this.keychainId(stored.id)}`,
+        });
+        return { managedSecret: this.toApiModel(stored), pushResults };
+    }
+    async pushAll() {
+        const results = [];
+        for (const stored of this.secrets) {
+            const { pushResults } = await this.pushOne(stored.id);
+            results.push({
+                managedSecretId: stored.id,
+                key: stored.key,
+                pushResults,
+            });
+        }
+        return results;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"managedsecrets.manager.js","sourceRoot":"","sources":["../../../ts/classes/managedsecrets.manager.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes/syncmanager.d.ts

@@ -0,0 +1,189 @@
+import type * as interfaces from '../../dist_ts_interfaces/index.js';
+import type { ConnectionManager } from './connectionmanager.js';
+import type { ActionLog } from './actionlog.js';
+import type { StorageManager } from '../storage/index.js';
+/**
+ * Manages sync configurations and executes periodic git mirror operations.
+ * Each sync config defines a source → target connection mapping.
+ * Repos are mirrored using bare git repos stored on disk.
+ */
+export declare class SyncManager {
+    private storageManager;
+    private connectionManager;
+    private actionLog;
+    private configs;
+    private timers;
+    private runningSync;
+    private syncedGroupMeta;
+    private currentSyncConfig;
+    private avatarUploadCache;
+    private activeGitChildren;
+    private stopping;
+    private mirrorsPath;
+    constructor(storageManager: StorageManager, connectionManager: ConnectionManager, actionLog: ActionLog);
+    init(): Promise<void>;
+    stop(): Promise<void>;
+    getConfigs(): interfaces.data.ISyncConfig[];
+    getConfig(id: string): interfaces.data.ISyncConfig | undefined;
+    createConfig(data: {
+        name: string;
+        sourceConnectionId: string;
+        targetConnectionId: string;
+        targetGroupOffset?: string;
+        intervalMinutes?: number;
+        enforceDelete?: boolean;
+        enforceGroupDelete?: boolean;
+        addMirrorHint?: boolean;
+        useGroupAvatarsForProjects?: boolean;
+    }): Promise<interfaces.data.ISyncConfig>;
+    updateConfig(id: string, updates: {
+        name?: string;
+        targetGroupOffset?: string;
+        intervalMinutes?: number;
+        enforceDelete?: boolean;
+        enforceGroupDelete?: boolean;
+        addMirrorHint?: boolean;
+        useGroupAvatarsForProjects?: boolean;
+    }): Promise<interfaces.data.ISyncConfig>;
+    deleteConfig(id: string): Promise<void>;
+    pauseConfig(id: string, paused: boolean): Promise<interfaces.data.ISyncConfig>;
+    getRepoStatuses(syncConfigId: string): Promise<interfaces.data.ISyncRepoStatus[]>;
+    previewSync(configId: string): Promise<{
+        mappings: Array<{
+            sourceFullPath: string;
+            targetFullPath: string;
+        }>;
+        deletions: string[];
+        groupDeletions: string[];
+    }>;
+    executeSync(configId: string, force?: boolean): Promise<void>;
+    private syncRepo;
+    private ensureTargetExists;
+    private ensureGitLabTarget;
+    private ensureGiteaTarget;
+    private enforceDeleteStaleRepos;
+    private enforceDeleteStaleGroups;
+    /**
+     * Move a GitLab group to the obsolete group with a unique suffix.
+     * Transfers the entire group (including subgroups and projects).
+     */
+    private moveGroupToObsolete;
+    /**
+     * Move all repos in a Gitea org to obsolete, then delete the empty org.
+     * Gitea orgs can't be transferred, so we move repos individually.
+     */
+    private moveGiteaOrgToObsolete;
+    /**
+     * Returns true if the given full path belongs to an obsolete namespace.
+     * Matches path segments named "obsolete" or ending with "-obsolete".
+     */
+    private isObsoletePath;
+    private buildAuthUrl;
+    private computeRelativePath;
+    /**
+     * Reverse-map a target group path to the corresponding source group path.
+     * Returns null if the target path is part of the offset itself (not a source-derived group).
+     */
+    private reverseTargetGroupPath;
+    private computeTargetFullPath;
+    /**
+     * Validates that the sync config's targetGroupOffset is reachable
+     * by the target connection's groupFilter. Throws when enforceDelete
+     * is on and the offset is outside the filter scope.
+     */
+    private validateSyncConfig;
+    /**
+     * Download binary data (e.g. avatar image) with provider auth headers.
+     * Returns null on 404 or error.
+     */
+    private rawBinaryFetch;
+    /**
+     * Raw multipart call for avatar uploads (GitLab requires multipart FormData).
+     */
+    private rawMultipartCall;
+    /**
+     * Normalize visibility values between GitLab and Gitea.
+     * GitLab: "public" | "internal" | "private"
+     * Gitea:  "public" | "limited" | "private"
+     */
+    private normalizeVisibility;
+    /**
+     * Guess MIME type from binary content or URL for avatar uploads.
+     */
+    private guessAvatarMimeType;
+    /**
+     * Pre-push: ensure target's default_branch matches source so --prune won't delete it.
+     */
+    private syncDefaultBranchBeforePush;
+    /**
+     * Unprotect branches on the target that no longer exist in the source,
+     * so that git push --prune can delete them.
+     */
+    private unprotectStaleBranches;
+    /**
+     * Sync project metadata (description, visibility, topics, default_branch, avatar)
+     * from source to target after the git push.
+     */
+    private syncProjectMetadata;
+    /**
+     * Sync group/org metadata (description, visibility, avatar) from source to target.
+     */
+    private syncGroupMetadata;
+    private fetchProjectRaw;
+    private fetchGroupRaw;
+    private extractProjectMeta;
+    private extractGroupMeta;
+    private updateProjectMeta;
+    private updateGroupMeta;
+    private syncProjectAvatar;
+    private removeProjectAvatar;
+    private syncGroupAvatar;
+    private removeGroupAvatar;
+    private binaryEqual;
+    private hashBytes;
+    private uint8ArrayToBase64;
+    /**
+     * Raw HTTP call for API endpoints not supported by the client libraries.
+     */
+    private rawApiCall;
+    private generateSuffix;
+    /**
+     * Ensure an "obsolete" group/org exists under the target base path.
+     * Returns the obsolete group/org identifier needed for transfers.
+     */
+    private ensureObsoleteGroup;
+    /**
+     * Move a target repo to the "obsolete" group with a unique suffix.
+     * The project is also set to private.
+     */
+    private moveToObsolete;
+    /**
+     * Check whether the target remote in a bare mirror dir has unrelated history
+     * compared to the source (origin). Returns true if histories are completely disjoint.
+     */
+    private checkUnrelatedHistory;
+    private sanitizePath;
+    private dirExists;
+    /**
+     * Fetch all branch and tag SHAs from a repo via provider API.
+     * Returns null on any error (safe fallback to git-based comparison).
+     */
+    private listRefsViaProvider;
+    /**
+     * Compare refs between source and target via provider API (no git clone needed).
+     * Returns true (match), false (differ), or null (can't determine — fall through to git).
+     */
+    private refsMatchViaApi;
+    /**
+     * Compare local refs (source) with target remote refs.
+     * Returns true when all branches and tags are identical — no push needed.
+     */
+    private refsMatch;
+    private runGit;
+    private loadConfigs;
+    private persistConfig;
+    private updateRepoStatus;
+    private startTimer;
+    private stopTimer;
+    private waitForRunningSyncs;
+}