@atom8n/n8n 2.4.7 → 2.5.1

package/dist/modules/source-control.ee/source-control-preferences.service.ee.d.ts

@@ -0,0 +1,46 @@
+import { Logger } from '@n8n/backend-common';
+import { SettingsRepository } from '@n8n/db';
+import type { ValidationError } from 'class-validator';
+import { Cipher, InstanceSettings } from 'n8n-core';
+import { SourceControlConfig } from './source-control.config';
+import type { KeyPairType } from './types/key-pair-type';
+import { SourceControlPreferences } from './types/source-control-preferences';
+export declare class SourceControlPreferencesService {
+    private readonly instanceSettings;
+    private readonly logger;
+    private readonly cipher;
+    private readonly settingsRepository;
+    private readonly sourceControlConfig;
+    private _sourceControlPreferences;
+    readonly sshKeyName: string;
+    readonly sshFolder: string;
+    readonly gitFolder: string;
+    constructor(instanceSettings: InstanceSettings, logger: Logger, cipher: Cipher, settingsRepository: SettingsRepository, sourceControlConfig: SourceControlConfig);
+    get sourceControlPreferences(): SourceControlPreferences;
+    set sourceControlPreferences(preferences: Partial<SourceControlPreferences>);
+    isSourceControlSetup(): string | false;
+    private getKeyPairFromDatabase;
+    private getPrivateKeyFromDatabase;
+    private getPublicKeyFromDatabase;
+    private getHttpsCredentialsFromDatabase;
+    getDecryptedHttpsCredentials(): Promise<{
+        username: string;
+        password: string;
+    }>;
+    saveHttpsCredentials(username: string, password: string): Promise<void>;
+    deleteHttpsCredentials(): Promise<void>;
+    getPrivateKeyPath(): Promise<string>;
+    getPublicKey(): Promise<string>;
+    deleteKeyPair(): Promise<void>;
+    resetKnownHosts(): Promise<void>;
+    generateAndSaveKeyPair(keyPairType?: KeyPairType): Promise<SourceControlPreferences>;
+    isBranchReadOnly(): boolean;
+    isSourceControlConnected(): boolean;
+    isSourceControlLicensedAndEnabled(): boolean;
+    getBranchName(): string;
+    getPreferences(): SourceControlPreferences;
+    validateSourceControlPreferences(preferences: Partial<SourceControlPreferences>, allowMissingProperties?: boolean): Promise<ValidationError[]>;
+    setPreferences(preferences: Partial<SourceControlPreferences>, saveToDb?: boolean, broadcastReload?: boolean): Promise<SourceControlPreferences>;
+    private broadcastReloadSourceControlConfiguration;
+    loadFromDbAndApplySourceControlPreferences(): Promise<SourceControlPreferences | undefined>;
+}

package/dist/modules/source-control.ee/source-control-preferences.service.ee.js

@@ -0,0 +1,309 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceControlPreferencesService = void 0;
+const backend_common_1 = require("@n8n/backend-common");
+const db_1 = require("@n8n/db");
+const di_1 = require("@n8n/di");
+const class_validator_1 = require("class-validator");
+const promises_1 = require("fs/promises");
+const n8n_core_1 = require("n8n-core");
+const n8n_workflow_1 = require("n8n-workflow");
+const promises_2 = require("node:fs/promises");
+const path = __importStar(require("path"));
+const constants_1 = require("./constants");
+const source_control_helper_ee_1 = require("./source-control-helper.ee");
+const source_control_config_1 = require("./source-control.config");
+const source_control_preferences_1 = require("./types/source-control-preferences");
+let SourceControlPreferencesService = class SourceControlPreferencesService {
+    constructor(instanceSettings, logger, cipher, settingsRepository, sourceControlConfig) {
+        this.instanceSettings = instanceSettings;
+        this.logger = logger;
+        this.cipher = cipher;
+        this.settingsRepository = settingsRepository;
+        this.sourceControlConfig = sourceControlConfig;
+        this._sourceControlPreferences = new source_control_preferences_1.SourceControlPreferences();
+        this.sshFolder = path.join(instanceSettings.n8nFolder, constants_1.SOURCE_CONTROL_SSH_FOLDER);
+        this.gitFolder = path.join(instanceSettings.n8nFolder, constants_1.SOURCE_CONTROL_GIT_FOLDER);
+        this.sshKeyName = path.join(this.sshFolder, constants_1.SOURCE_CONTROL_SSH_KEY_NAME);
+    }
+    get sourceControlPreferences() {
+        return {
+            ...this._sourceControlPreferences,
+            connected: this._sourceControlPreferences.connected ?? false,
+        };
+    }
+    set sourceControlPreferences(preferences) {
+        this._sourceControlPreferences = source_control_preferences_1.SourceControlPreferences.merge(preferences, this._sourceControlPreferences);
+    }
+    isSourceControlSetup() {
+        return (this.isSourceControlLicensedAndEnabled() &&
+            this.getPreferences().repositoryUrl &&
+            this.getPreferences().branchName);
+    }
+    async getKeyPairFromDatabase() {
+        const dbSetting = await this.settingsRepository.findByKey('features.sourceControl.sshKeys');
+        if (!dbSetting?.value)
+            return null;
+        return (0, n8n_workflow_1.jsonParse)(dbSetting.value, { fallbackValue: null });
+    }
+    async getPrivateKeyFromDatabase() {
+        const dbKeyPair = await this.getKeyPairFromDatabase();
+        if (!dbKeyPair)
+            throw new n8n_workflow_1.UnexpectedError('Failed to find key pair in database');
+        return this.cipher.decrypt(dbKeyPair.encryptedPrivateKey);
+    }
+    async getPublicKeyFromDatabase() {
+        const dbKeyPair = await this.getKeyPairFromDatabase();
+        if (!dbKeyPair)
+            throw new n8n_workflow_1.UnexpectedError('Failed to find key pair in database');
+        return dbKeyPair.publicKey;
+    }
+    async getHttpsCredentialsFromDatabase() {
+        const dbSetting = await this.settingsRepository.findByKey('features.sourceControl.httpsCredentials');
+        if (!dbSetting?.value)
+            throw new n8n_workflow_1.UnexpectedError('No credentials found for https connection');
+        return (0, n8n_workflow_1.jsonParse)(dbSetting.value);
+    }
+    async getDecryptedHttpsCredentials() {
+        const credentials = await this.getHttpsCredentialsFromDatabase();
+        return {
+            username: this.cipher.decrypt(credentials.encryptedUsername),
+            password: this.cipher.decrypt(credentials.encryptedPassword),
+        };
+    }
+    async saveHttpsCredentials(username, password) {
+        try {
+            await this.settingsRepository.save({
+                key: 'features.sourceControl.httpsCredentials',
+                value: JSON.stringify({
+                    encryptedUsername: this.cipher.encrypt(username),
+                    encryptedPassword: this.cipher.encrypt(password),
+                }),
+                loadOnStartup: true,
+            });
+        }
+        catch (error) {
+            throw new n8n_workflow_1.UnexpectedError('Failed to save HTTPS credentials to database', { cause: error });
+        }
+    }
+    async deleteHttpsCredentials() {
+        try {
+            await this.settingsRepository.delete({ key: 'features.sourceControl.httpsCredentials' });
+        }
+        catch (error) {
+            this.logger.error('Failed to delete HTTPS credentials from database', { error });
+        }
+    }
+    async getPrivateKeyPath() {
+        const dbPrivateKey = await this.getPrivateKeyFromDatabase();
+        const tempFilePath = path.join(this.instanceSettings.n8nFolder, 'ssh_private_key_temp');
+        const normalizedKey = dbPrivateKey.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+        try {
+            await (0, promises_1.rm)(tempFilePath, { force: true });
+            await (0, promises_2.writeFile)(tempFilePath, normalizedKey, { mode: 0o600 });
+        }
+        catch (error) {
+            this.logger.error('Failed to write SSH private key to temp file', {
+                tempFilePath,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw new n8n_workflow_1.UnexpectedError('Failed to create SSH private key file', { cause: error });
+        }
+        return tempFilePath;
+    }
+    async getPublicKey() {
+        try {
+            const dbPublicKey = await this.getPublicKeyFromDatabase();
+            if (dbPublicKey)
+                return dbPublicKey;
+            return await (0, promises_2.readFile)(this.sshKeyName + '.pub', { encoding: 'utf8' });
+        }
+        catch (e) {
+            const error = e instanceof Error ? e : new Error(`${e}`);
+            this.logger.error(`Failed to read SSH public key: ${error.message}`);
+        }
+        return '';
+    }
+    async deleteKeyPair() {
+        try {
+            await (0, promises_1.rm)(this.sshFolder, { recursive: true });
+            await this.settingsRepository.delete({ key: 'features.sourceControl.sshKeys' });
+        }
+        catch (e) {
+            const error = e instanceof Error ? e : new Error(`${e}`);
+            this.logger.error(`Failed to delete SSH key pair: ${error.message}`);
+        }
+    }
+    async resetKnownHosts() {
+        const knownHostsPath = path.join(this.sshFolder, 'known_hosts');
+        try {
+            await (0, promises_1.rm)(knownHostsPath, { force: true });
+            this.logger.debug('Cleared SSH known_hosts file');
+        }
+        catch (error) {
+            this.logger.warn('Failed to clear known_hosts file', { error });
+        }
+    }
+    async generateAndSaveKeyPair(keyPairType) {
+        if (!keyPairType) {
+            keyPairType =
+                this.getPreferences().keyGeneratorType ?? this.sourceControlConfig.defaultKeyPairType;
+        }
+        const keyPair = await (0, source_control_helper_ee_1.generateSshKeyPair)(keyPairType);
+        try {
+            await this.settingsRepository.save({
+                key: 'features.sourceControl.sshKeys',
+                value: JSON.stringify({
+                    encryptedPrivateKey: this.cipher.encrypt(keyPair.privateKey),
+                    publicKey: keyPair.publicKey,
+                }),
+                loadOnStartup: true,
+            });
+        }
+        catch (error) {
+            throw new n8n_workflow_1.UnexpectedError('Failed to write key pair to database', { cause: error });
+        }
+        if (keyPairType !== this.getPreferences().keyGeneratorType) {
+            await this.setPreferences({ keyGeneratorType: keyPairType });
+        }
+        return this.getPreferences();
+    }
+    isBranchReadOnly() {
+        return this._sourceControlPreferences.branchReadOnly;
+    }
+    isSourceControlConnected() {
+        return this.sourceControlPreferences.connected;
+    }
+    isSourceControlLicensedAndEnabled() {
+        return this.isSourceControlConnected() && (0, source_control_helper_ee_1.isSourceControlLicensed)();
+    }
+    getBranchName() {
+        return this.sourceControlPreferences.branchName;
+    }
+    getPreferences() {
+        return this.sourceControlPreferences;
+    }
+    async validateSourceControlPreferences(preferences, allowMissingProperties = true) {
+        const preferencesObject = new source_control_preferences_1.SourceControlPreferences(preferences);
+        const validationResult = await (0, class_validator_1.validate)(preferencesObject, {
+            forbidUnknownValues: false,
+            skipMissingProperties: allowMissingProperties,
+            stopAtFirstError: false,
+            validationError: { target: false },
+        });
+        if (validationResult.length > 0) {
+            throw new n8n_workflow_1.UnexpectedError('Invalid source control preferences', {
+                extra: { preferences: validationResult },
+            });
+        }
+        return validationResult;
+    }
+    async setPreferences(preferences, saveToDb = true, broadcastReload = true) {
+        const noKeyPair = (await this.getKeyPairFromDatabase()) === null;
+        if (noKeyPair &&
+            (preferences.connectionType === 'ssh' || preferences.connectionType === undefined)) {
+            await this.generateAndSaveKeyPair();
+        }
+        const sanitizedPreferences = { ...preferences };
+        if (preferences.httpsUsername && preferences.httpsPassword) {
+            await this.saveHttpsCredentials(preferences.httpsUsername, preferences.httpsPassword);
+        }
+        delete sanitizedPreferences.httpsUsername;
+        delete sanitizedPreferences.httpsPassword;
+        this.sourceControlPreferences = sanitizedPreferences;
+        if (saveToDb) {
+            const settingsValue = JSON.stringify(this._sourceControlPreferences);
+            try {
+                await this.settingsRepository.save({
+                    key: constants_1.SOURCE_CONTROL_PREFERENCES_DB_KEY,
+                    value: settingsValue,
+                    loadOnStartup: true,
+                }, { transaction: false });
+            }
+            catch (error) {
+                throw new n8n_workflow_1.UnexpectedError('Failed to save source control preferences', { cause: error });
+            }
+            if (broadcastReload) {
+                await this.broadcastReloadSourceControlConfiguration();
+            }
+        }
+        return this.sourceControlPreferences;
+    }
+    async broadcastReloadSourceControlConfiguration() {
+        if (this.instanceSettings.isMultiMain) {
+            const { Publisher } = await Promise.resolve().then(() => __importStar(require('../../scaling/pubsub/publisher.service')));
+            await di_1.Container.get(Publisher).publishCommand({ command: 'reload-source-control-config' });
+            this.logger.debug('Broadcasting source control configuration reload to other main instances');
+        }
+    }
+    async loadFromDbAndApplySourceControlPreferences() {
+        const loadedPreferences = await this.settingsRepository.findOne({
+            where: { key: constants_1.SOURCE_CONTROL_PREFERENCES_DB_KEY },
+        });
+        if (loadedPreferences) {
+            try {
+                const preferences = (0, n8n_workflow_1.jsonParse)(loadedPreferences.value);
+                if (preferences) {
+                    await this.setPreferences(preferences, false, false);
+                    return preferences;
+                }
+            }
+            catch (error) {
+                this.logger.warn(`Could not parse Source Control settings from database: ${error.message}`);
+            }
+        }
+        await this.setPreferences(new source_control_preferences_1.SourceControlPreferences(), true, false);
+        return this.sourceControlPreferences;
+    }
+};
+exports.SourceControlPreferencesService = SourceControlPreferencesService;
+exports.SourceControlPreferencesService = SourceControlPreferencesService = __decorate([
+    (0, di_1.Service)(),
+    __metadata("design:paramtypes", [n8n_core_1.InstanceSettings,
+        backend_common_1.Logger,
+        n8n_core_1.Cipher,
+        db_1.SettingsRepository,
+        source_control_config_1.SourceControlConfig])
+], SourceControlPreferencesService);

package/dist/modules/source-control.ee/source-control-resource-helper.d.ts

@@ -0,0 +1,4 @@
+import type { SourceControlledFile } from '@n8n/api-types';
+export declare function filterByType(files: SourceControlledFile[], resourceType: SourceControlledFile['type']): SourceControlledFile[];
+export declare function getDeletedResources(files: SourceControlledFile[], resourceType: SourceControlledFile['type']): SourceControlledFile[];
+export declare function getNonDeletedResources(files: SourceControlledFile[], resourceType: SourceControlledFile['type']): SourceControlledFile[];

package/dist/modules/source-control.ee/source-control-resource-helper.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterByType = filterByType;
+exports.getDeletedResources = getDeletedResources;
+exports.getNonDeletedResources = getNonDeletedResources;
+function filterByType(files, resourceType) {
+    return files.filter((file) => file.type === resourceType);
+}
+function filterByStatus(files, resourceType, status) {
+    return filterByType(files, resourceType).filter((file) => file.status === status);
+}
+function filterByStatusExcluding(files, resourceType, status) {
+    return filterByType(files, resourceType).filter((file) => file.status !== status);
+}
+function getDeletedResources(files, resourceType) {
+    return filterByStatus(files, resourceType, 'deleted');
+}
+function getNonDeletedResources(files, resourceType) {
+    return filterByStatusExcluding(files, resourceType, 'deleted');
+}

package/dist/modules/source-control.ee/source-control-scoped.service.d.ts

@@ -0,0 +1,17 @@
+import { ProjectRepository, WorkflowRepository } from '@n8n/db';
+import { type AuthenticatedRequest, type CredentialsEntity, type Folder, type Project, type WorkflowEntity, type WorkflowTagMapping } from '@n8n/db';
+import type { FindOptionsWhere } from '@n8n/typeorm';
+import { SourceControlContext } from './types/source-control-context';
+export declare class SourceControlScopedService {
+    private readonly projectRepository;
+    private readonly workflowRepository;
+    constructor(projectRepository: ProjectRepository, workflowRepository: WorkflowRepository);
+    ensureIsAllowedToPush(req: AuthenticatedRequest): Promise<void>;
+    getAuthorizedProjectsFromContext(context: SourceControlContext): Promise<Project[]>;
+    getWorkflowsInAdminProjectsFromContext(context: SourceControlContext, id?: string): Promise<WorkflowEntity[] | undefined>;
+    getProjectsWithPushScopeByContextFilter(context: SourceControlContext): FindOptionsWhere<Project> | undefined;
+    getFoldersInAdminProjectsFromContextFilter(context: SourceControlContext): FindOptionsWhere<Folder>;
+    getWorkflowsInAdminProjectsFromContextFilter(context: SourceControlContext): FindOptionsWhere<WorkflowEntity>;
+    getCredentialsInAdminProjectsFromContextFilter(context: SourceControlContext): FindOptionsWhere<CredentialsEntity>;
+    getWorkflowTagMappingInAdminProjectsFromContextFilter(context: SourceControlContext): FindOptionsWhere<WorkflowTagMapping>;
+}

package/dist/modules/source-control.ee/source-control-scoped.service.js

@@ -0,0 +1,134 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceControlScopedService = void 0;
+const db_1 = require("@n8n/db");
+const di_1 = require("@n8n/di");
+const permissions_1 = require("@n8n/permissions");
+const source_control_context_1 = require("./types/source-control-context");
+const forbidden_error_1 = require("../../errors/response-errors/forbidden.error");
+let SourceControlScopedService = class SourceControlScopedService {
+    constructor(projectRepository, workflowRepository) {
+        this.projectRepository = projectRepository;
+        this.workflowRepository = workflowRepository;
+    }
+    async ensureIsAllowedToPush(req) {
+        if ((0, permissions_1.hasGlobalScope)(req.user, 'sourceControl:push')) {
+            return;
+        }
+        const ctx = new source_control_context_1.SourceControlContext(req.user);
+        const projectsWithAdminAccess = await this.getAuthorizedProjectsFromContext(ctx);
+        if (projectsWithAdminAccess?.length === 0) {
+            throw new forbidden_error_1.ForbiddenError('You are not allowed to push changes');
+        }
+    }
+    async getAuthorizedProjectsFromContext(context) {
+        if (context.hasAccessToAllProjects()) {
+            return await this.projectRepository.find({
+                relations: {
+                    projectRelations: {
+                        user: true,
+                        role: true,
+                    },
+                },
+            });
+        }
+        return await this.projectRepository.find({
+            relations: {
+                projectRelations: {
+                    user: true,
+                    role: true,
+                },
+            },
+            select: {
+                id: true,
+                name: true,
+                type: true,
+            },
+            where: this.getProjectsWithPushScopeByContextFilter(context),
+        });
+    }
+    async getWorkflowsInAdminProjectsFromContext(context, id) {
+        if (context.hasAccessToAllProjects()) {
+            return;
+        }
+        const where = this.getWorkflowsInAdminProjectsFromContextFilter(context);
+        if (id) {
+            where.id = id;
+        }
+        return await this.workflowRepository.find({
+            select: {
+                id: true,
+            },
+            where,
+        });
+    }
+    getProjectsWithPushScopeByContextFilter(context) {
+        if (context.hasAccessToAllProjects()) {
+            return;
+        }
+        return {
+            type: 'team',
+            projectRelations: {
+                role: {
+                    scopes: {
+                        slug: 'sourceControl:push',
+                    },
+                },
+                userId: context.user.id,
+            },
+        };
+    }
+    getFoldersInAdminProjectsFromContextFilter(context) {
+        if (context.hasAccessToAllProjects()) {
+            return {};
+        }
+        return {
+            homeProject: this.getProjectsWithPushScopeByContextFilter(context),
+        };
+    }
+    getWorkflowsInAdminProjectsFromContextFilter(context) {
+        if (context.hasAccessToAllProjects()) {
+            return {};
+        }
+        return {
+            shared: {
+                role: 'workflow:owner',
+                project: this.getProjectsWithPushScopeByContextFilter(context),
+            },
+        };
+    }
+    getCredentialsInAdminProjectsFromContextFilter(context) {
+        if (context.hasAccessToAllProjects()) {
+            return {};
+        }
+        return {
+            shared: {
+                role: 'credential:owner',
+                project: this.getProjectsWithPushScopeByContextFilter(context),
+            },
+        };
+    }
+    getWorkflowTagMappingInAdminProjectsFromContextFilter(context) {
+        if (context.hasAccessToAllProjects()) {
+            return {};
+        }
+        return {
+            workflows: this.getWorkflowsInAdminProjectsFromContextFilter(context),
+        };
+    }
+};
+exports.SourceControlScopedService = SourceControlScopedService;
+exports.SourceControlScopedService = SourceControlScopedService = __decorate([
+    (0, di_1.Service)(),
+    __metadata("design:paramtypes", [db_1.ProjectRepository,
+        db_1.WorkflowRepository])
+], SourceControlScopedService);

package/dist/modules/source-control.ee/source-control-status.service.ee.d.ts

@@ -0,0 +1,90 @@
+import { Logger } from '@n8n/backend-common';
+import { FolderRepository, type TagEntity, TagRepository, type User } from '@n8n/db';
+import { EventService } from '../../events/event.service';
+import { SourceControlGitService } from './source-control-git.service.ee';
+import { SourceControlImportService } from './source-control-import.service.ee';
+import { SourceControlPreferencesService } from './source-control-preferences.service.ee';
+import type { StatusExportableCredential } from './types/exportable-credential';
+import type { ExportableFolder } from './types/exportable-folders';
+import type { ExportableProjectWithFileName } from './types/exportable-project';
+import { ExportableVariable } from './types/exportable-variable';
+import type { SourceControlGetStatus } from './types/source-control-get-status';
+import type { SourceControlWorkflowVersionId } from './types/source-control-workflow-version-id';
+export declare class SourceControlStatusService {
+    private readonly logger;
+    private readonly gitService;
+    private readonly sourceControlImportService;
+    private readonly sourceControlPreferencesService;
+    private readonly tagRepository;
+    private readonly folderRepository;
+    private readonly eventService;
+    constructor(logger: Logger, gitService: SourceControlGitService, sourceControlImportService: SourceControlImportService, sourceControlPreferencesService: SourceControlPreferencesService, tagRepository: TagRepository, folderRepository: FolderRepository, eventService: EventService);
+    private get gitFolder();
+    getStatus(user: User, options: SourceControlGetStatus): Promise<{
+        status: "unknown" | "new" | "modified" | "deleted" | "created" | "renamed" | "conflicted" | "ignored" | "staged";
+        type: "tags" | "project" | "credential" | "file" | "workflow" | "variables" | "folders";
+        id: string;
+        name: string;
+        updatedAt: string;
+        file: string;
+        location: "local" | "remote";
+        conflict: boolean;
+        pushed?: boolean | undefined;
+        owner?: {
+            type: "personal" | "team";
+            projectId: string;
+            projectName: string;
+        } | undefined;
+    }[] | {
+        wfRemoteVersionIds: SourceControlWorkflowVersionId[];
+        wfLocalVersionIds: SourceControlWorkflowVersionId[];
+        wfMissingInLocal: SourceControlWorkflowVersionId[];
+        wfMissingInRemote: SourceControlWorkflowVersionId[];
+        wfModifiedInEither: SourceControlWorkflowVersionId[];
+        credMissingInLocal: StatusExportableCredential[];
+        credMissingInRemote: StatusExportableCredential[];
+        credModifiedInEither: StatusExportableCredential[];
+        varMissingInLocal: ExportableVariable[];
+        varMissingInRemote: import("@n8n/db").Variables[];
+        varModifiedInEither: ExportableVariable[];
+        tagsMissingInLocal: TagEntity[];
+        tagsMissingInRemote: TagEntity[];
+        tagsModifiedInEither: TagEntity[];
+        mappingsMissingInLocal: import("@n8n/db").WorkflowTagMapping[];
+        mappingsMissingInRemote: import("@n8n/db").WorkflowTagMapping[];
+        foldersMissingInLocal: ExportableFolder[];
+        foldersMissingInRemote: ExportableFolder[];
+        foldersModifiedInEither: ExportableFolder[];
+        projectsRemote: ExportableProjectWithFileName[];
+        projectsLocal: ExportableProjectWithFileName[];
+        projectsMissingInLocal: ExportableProjectWithFileName[];
+        projectsMissingInRemote: ExportableProjectWithFileName[];
+        projectsModifiedInEither: ExportableProjectWithFileName[];
+        sourceControlledFiles: {
+            status: "unknown" | "new" | "modified" | "deleted" | "created" | "renamed" | "conflicted" | "ignored" | "staged";
+            type: "tags" | "project" | "credential" | "file" | "workflow" | "variables" | "folders";
+            id: string;
+            name: string;
+            updatedAt: string;
+            file: string;
+            location: "local" | "remote";
+            conflict: boolean;
+            pushed?: boolean | undefined;
+            owner?: {
+                type: "personal" | "team";
+                projectId: string;
+                projectName: string;
+            } | undefined;
+        }[];
+    }>;
+    private resetWorkfolder;
+    private getStatusWorkflows;
+    private getStatusCredentials;
+    private getStatusVariables;
+    private getStatusTagsMappings;
+    private getStatusFoldersMapping;
+    private getStatusProjects;
+    private areVariablesEqual;
+    private isProjectModified;
+    private isProjectIconModified;
+}