n8nac 2.2.1 → 2.3.0-next.55

package/dist/services/config-service.js

@@ -145,6 +145,29 @@ export class ConfigService {
             description: input.description,
         });
     }
+    ensureManagedInstanceTarget(input) {
+        const managedInstanceId = cleanRequired(input.managedInstanceId, 'Managed instance ID');
+        const config = this.ensureV4WorkspaceConfig();
+        const managedInstance = config.environmentTargets.find((target) => {
+            return target.kind === 'managed-instance' && target.managedInstanceId === managedInstanceId;
+        });
+        if (managedInstance)
+            return managedInstance;
+        const existingNames = new Set(config.environmentTargets.map((target) => target.name.toLowerCase()));
+        const baseName = cleanRequired(input.name, 'Instance name');
+        let name = baseName;
+        let counter = 2;
+        while (existingNames.has(name.toLowerCase())) {
+            name = `${baseName} ${counter}`;
+            counter += 1;
+        }
+        return this.addInstanceTarget({
+            name,
+            id: input.id,
+            managedInstanceId,
+            description: input.description,
+        });
+    }
     updateInstanceTarget(nameOrId, patch) {
         const config = this.ensureV4WorkspaceConfig();
         const target = this.findInstanceTarget(config, nameOrId);
@@ -193,13 +216,21 @@ export class ConfigService {
             ...config.environments.map((item) => item.id),
         ]);
         this.assertUniqueName(name, config.environments, 'environment');
+        const syncSlug = this.uniqueEnvironmentSyncSlug(name, config.environments);
+        const workflowsPath = this.resolveInputWorkflowsPath({
+            workflowsPath: input.workflowsPath,
+            workflowDir: input.workflowDir,
+            syncFolder: input.syncFolder,
+            syncSlug,
+        }, config.environments, name);
         const environment = {
             id,
             name,
+            syncSlug,
             environmentTargetId: target.id,
             projectId: cleanOptional(input.projectId),
             projectName: cleanOptional(input.projectName),
-            syncFolder: cleanRequired(input.syncFolder, 'Sync folder'),
+            workflowsPath,
             folderSync: input.folderSync,
             customNodesPath: input.customNodesPath,
             description: input.description,
@@ -215,18 +246,30 @@ export class ConfigService {
     updateEnvironment(nameOrId, patch) {
         const config = this.ensureV4WorkspaceConfig();
         const environment = this.findEnvironment(config, nameOrId);
+        const currentTarget = this.findInstanceTarget(config, environment.environmentTargetId);
         const target = patch.environmentTarget ? this.findInstanceTarget(config, patch.environmentTarget) : undefined;
         const nextName = cleanOptional(patch.name) || environment.name;
         if (nextName.toLowerCase() !== environment.name.toLowerCase()) {
             this.assertUniqueName(nextName, config.environments.filter((item) => item.id !== environment.id), 'environment');
         }
+        const currentWorkflowsPath = cleanRequired(environment.workflowsPath, 'Workflows path');
+        const workflowsPathPatch = this.patchWorkflowsPath(environment, patch);
+        const workflowsPathChanged = workflowsPathPatch !== undefined
+            && this.resolveWorkspacePath(workflowsPathPatch) !== this.resolveWorkspacePath(currentWorkflowsPath);
+        if (workflowsPathChanged) {
+            this.migrateWorkflowsPath(currentWorkflowsPath, workflowsPathPatch);
+        }
+        const legacyWorkflowDir = workflowsPathChanged ? undefined : this.resolvePreservedLegacyWorkflowsPath(environment, currentTarget);
         const nextEnvironment = stripUndefined({
             ...environment,
             name: nextName,
+            workflowsPath: workflowsPathPatch ?? environment.workflowsPath,
+            legacyWorkflowDir,
+            workflowDir: undefined,
+            syncFolder: undefined,
             environmentTargetId: target?.id || environment.environmentTargetId,
             projectId: patch.projectId !== undefined ? cleanOptional(patch.projectId) : environment.projectId,
             projectName: patch.projectName !== undefined ? cleanOptional(patch.projectName) : environment.projectName,
-            syncFolder: patch.syncFolder !== undefined ? cleanRequired(patch.syncFolder, 'Sync folder') : environment.syncFolder,
             folderSync: patch.folderSync ?? environment.folderSync,
             customNodesPath: patch.customNodesPath ?? environment.customNodesPath,
             description: patch.description ?? environment.description,
@@ -288,17 +331,25 @@ export class ConfigService {
                 const identity = await this.resolveN8nIdentity(resolved.host, resolved.apiKey, undefined, resolved.instanceIdentifier || resolved.environmentTargetId).catch(() => undefined);
                 const instanceIdentifier = identity?.instanceIdentifier || resolved.instanceIdentifier;
                 const instanceUserIdentifier = identity?.instanceUserIdentifier || resolved.instanceUserIdentifier;
+                const workflowsPath = this.resolveEnvironmentWorkflowsPath(resolved.environment, {
+                    instanceIdentifier,
+                    instanceUserIdentifier,
+                    legacyInstanceIdentifier: resolved.environmentTarget.kind === 'external-instance'
+                        ? resolved.environmentTarget.instanceIdentifier
+                        : undefined,
+                    legacyInstanceUserIdentifier: resolved.environmentTarget.kind === 'external-instance'
+                        ? resolved.environmentTarget.instanceUserIdentifier
+                        : undefined,
+                    projectId: resolved.projectId,
+                    projectName: resolved.projectName,
+                });
                 return {
                     ...resolved,
+                    workflowsPath,
+                    syncFolder: workflowsPath,
                     instanceIdentifier,
                     instanceUserIdentifier,
-                    workflowDir: this.buildEnvironmentWorkflowDir({
-                        syncFolder: resolved.syncFolder,
-                        environmentId: resolved.environmentId,
-                        instanceIdentifier,
-                        instanceUserIdentifier,
-                        projectId: resolved.projectId,
-                    }),
+                    workflowDir: workflowsPath,
                 };
             }
             return resolved;
@@ -314,7 +365,6 @@ export class ConfigService {
         }
         const context = prepared.context;
         const apiKey = resolved.apiKey || context.apiKey;
-        const syncFolder = resolved.syncFolder;
         const projectId = resolved.projectId || context.projectId;
         const projectName = resolved.projectName || context.projectName;
         let instanceIdentifier = this.canonicalWorkflowInstanceIdentifier(context.n8nInstanceIdentifier)
@@ -328,6 +378,14 @@ export class ConfigService {
             instanceIdentifier = identity?.instanceIdentifier || instanceIdentifier;
             instanceUserIdentifier = identity?.instanceUserIdentifier || instanceUserIdentifier;
         }
+        const workflowsPath = this.resolveEnvironmentWorkflowsPath(resolved.environment, {
+            instanceIdentifier,
+            instanceUserIdentifier,
+            legacyInstanceIdentifier: resolved.instance.instanceIdentifier,
+            legacyInstanceUserIdentifier: resolved.instance.instanceUserIdentifier,
+            projectId,
+            projectName,
+        });
         return {
             ...resolved,
             host: context.host,
@@ -341,14 +399,9 @@ export class ConfigService {
             instanceUserIdentifier,
             projectId,
             projectName,
-            syncFolder,
-            workflowDir: this.buildEnvironmentWorkflowDir({
-                syncFolder,
-                environmentId: resolved.environmentId,
-                instanceIdentifier,
-                instanceUserIdentifier,
-                projectId,
-            }),
+            workflowsPath,
+            syncFolder: workflowsPath,
+            workflowDir: workflowsPath,
         };
     }
     listInstanceConfigs() {
@@ -577,6 +630,9 @@ export class ConfigService {
         const saved = this.manager.upsertInstance(input, {
             setActive: options.setActive,
         });
+        if (options.apiKey) {
+            this.manager.saveApiKey(saved.id, options.apiKey);
+        }
         if (workspaceConfigIsV4) {
             return this.toInstanceProfile(saved);
         }
@@ -756,6 +812,8 @@ export class ConfigService {
             syncFolder: asString(raw.syncFolder) || activeInstance?.syncFolder,
             projectId: asString(raw.projectId) || activeInstance?.projectId,
             projectName: asString(raw.projectName) || activeInstance?.projectName,
+            workflowsPath: asString(raw.workflowsPath) || activeInstance?.workflowsPath || asString(raw.workflowDir) || activeInstance?.workflowDir,
+            workflowDir: asString(raw.workflowDir) || activeInstance?.workflowDir || asString(raw.workflowsPath) || activeInstance?.workflowsPath,
             customNodesPath: asString(raw.customNodesPath) || activeInstance?.customNodesPath,
             folderSync: asBoolean(raw.folderSync) ?? activeInstance?.folderSync,
         });
@@ -828,6 +886,8 @@ export class ConfigService {
                 const environmentId = this.uniqueWorkspaceId(singleInstanceMigration ? 'default' : profile.id || legacy.id || environmentName, usedIds);
                 usedIds.push(environmentId);
                 const syncFolder = legacy.syncFolder || plan.workspace.syncFolder || DEFAULT_SYNC_FOLDER;
+                const syncSlug = this.createEnvironmentSyncSlug(environmentName);
+                const legacyWorkflowDir = legacy.workflowsPath || legacy.workflowDir || plan.workspace.workflowsPath || plan.workspace.workflowDir;
                 environmentTargets.push({
                     id: targetId,
                     name: targetName,
@@ -842,7 +902,10 @@ export class ConfigService {
                     environmentTargetId: targetId,
                     projectId: legacy.projectId || plan.workspace.projectId,
                     projectName: legacy.projectName || plan.workspace.projectName,
+                    workflowsPath: legacyWorkflowDir || path.join(syncFolder, syncSlug),
+                    syncSlug,
                     syncFolder,
+                    legacyWorkflowDir,
                     customNodesPath: legacy.customNodesPath || plan.workspace.customNodesPath,
                     folderSync: legacy.folderSync ?? plan.workspace.folderSync,
                 }));
@@ -1088,12 +1151,15 @@ export class ConfigService {
                     const environmentId = this.uniqueWorkspaceId(instance.id || environmentName, usedIds);
                     usedIds.push(environmentId);
                     const syncFolder = DEFAULT_SYNC_FOLDER;
+                    const syncSlug = this.createEnvironmentSyncSlug(environmentName);
                     existingEnvironment = stripUndefined({
                         id: environmentId,
                         name: environmentName,
                         environmentTargetId: targetId,
                         projectId: instance.defaultProject?.id || 'personal',
                         projectName: instance.defaultProject?.name || 'Personal',
+                        workflowsPath: path.join(syncFolder, syncSlug),
+                        syncSlug,
                         syncFolder,
                     });
                     environments.push(existingEnvironment);
@@ -1141,12 +1207,15 @@ export class ConfigService {
                     const environmentId = this.uniqueWorkspaceId(instance.id || environmentName, usedIds);
                     usedIds.push(environmentId);
                     const syncFolder = DEFAULT_SYNC_FOLDER;
+                    const syncSlug = this.createEnvironmentSyncSlug(environmentName);
                     existingEnvironment = stripUndefined({
                         id: environmentId,
                         name: environmentName,
                         environmentTargetId: existingTarget.id,
                         projectId: instance.defaultProject?.id || 'personal',
                         projectName: instance.defaultProject?.name || 'Personal',
+                        workflowsPath: path.join(syncFolder, syncSlug),
+                        syncSlug,
                         syncFolder,
                     });
                     environments.push(existingEnvironment);
@@ -1165,6 +1234,7 @@ export class ConfigService {
             const projectId = instance.defaultProject?.id || 'personal';
             const projectName = instance.defaultProject?.name || 'Personal';
             const syncFolder = DEFAULT_SYNC_FOLDER;
+            const syncSlug = this.createEnvironmentSyncSlug(environmentName);
             environmentTargets.push({
                 id: targetId,
                 name: targetName,
@@ -1179,6 +1249,8 @@ export class ConfigService {
                 environmentTargetId: targetId,
                 projectId,
                 projectName,
+                workflowsPath: path.join(syncFolder, syncSlug),
+                syncSlug,
                 syncFolder,
             }));
             if (apiKey)
@@ -1262,6 +1334,7 @@ export class ConfigService {
             name,
             host,
             syncFolder: asString(value.syncFolder) || asString(root.syncFolder),
+            workflowsPath: asString(value.workflowsPath) || asString(root.workflowsPath),
             projectId: asString(value.projectId) || asString(root.projectId),
             projectName: asString(value.projectName) || asString(root.projectName),
             instanceIdentifier: asString(value.instanceIdentifier) || asString(root.instanceIdentifier),
@@ -1291,6 +1364,30 @@ export class ConfigService {
         return asString(root.apiKey);
     }
     readLegacyStoredApiKey(instanceId, host) {
+        const readFromStore = (store) => {
+            const instanceApiKey = asString(store?.instanceProfiles?.[instanceId]);
+            if (instanceApiKey)
+                return instanceApiKey;
+            if (!host)
+                return undefined;
+            return asString(store?.hosts?.[this.normalizeHost(host)]);
+        };
+        for (const root of [process.env.XDG_CONFIG_HOME, process.env.N8N_MANAGER_HOME]) {
+            if (!root)
+                continue;
+            const filePath = path.join(root, 'n8nac-nodejs', 'credentials.json');
+            if (!fs.existsSync(filePath))
+                continue;
+            try {
+                const value = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+                const apiKey = readFromStore(value && typeof value === 'object' && !Array.isArray(value) ? value : undefined);
+                if (apiKey)
+                    return apiKey;
+            }
+            catch {
+                // Try the Conf-backed store below.
+            }
+        }
         try {
             const store = new Conf({
                 projectName: 'n8nac',
@@ -1298,13 +1395,8 @@ export class ConfigService {
                 configFileMode: 0o600,
             });
             const instanceProfiles = store.get('instanceProfiles');
-            const instanceApiKey = asString(instanceProfiles?.[instanceId]);
-            if (instanceApiKey)
-                return instanceApiKey;
-            if (!host)
-                return undefined;
             const hosts = store.get('hosts');
-            return asString(hosts?.[this.normalizeHost(host)]);
+            return readFromStore({ hosts, instanceProfiles });
         }
         catch {
             return undefined;
@@ -1403,8 +1495,8 @@ export class ConfigService {
         const rawInstanceTargets = rawTargets;
         const rawEnvironments = raw.environments;
         const environmentTargets = rawInstanceTargets.map((target, index) => this.sanitizeInstanceTarget(target, index));
-        const environments = rawEnvironments.map((environment, index) => this.sanitizeEnvironment(environment, index));
-        this.assertUniqueIdsAndNames(environmentTargets, 'instance target');
+        const environments = this.ensureEnvironmentWorkflowsPaths(rawEnvironments.map((environment, index) => this.sanitizeEnvironment(environment, index)));
+        this.assertUniqueIds(environmentTargets, 'instance target');
         this.assertUniqueIdsAndNames(environments, 'environment');
         const targetIds = new Set(environmentTargets.map((target) => target.id));
         for (const environment of environments) {
@@ -1454,8 +1546,9 @@ export class ConfigService {
                 name,
                 kind: 'external-instance',
                 url,
-                instanceIdentifier: this.canonicalWorkflowInstanceIdentifier(target.instanceIdentifier || target.instance?.instanceIdentifier),
-                instanceUserIdentifier: this.readStoredInstanceUserIdentifier(target.instanceUserIdentifier || target.instance?.instanceUserIdentifier || target.instanceIdentifier || target.instance?.instanceIdentifier),
+                instanceIdentifier: this.canonicalWorkflowInstanceIdentifier(target.instanceIdentifier || target.instance?.instanceIdentifier)
+                    || cleanOptional(target.instanceIdentifier || target.instance?.instanceIdentifier),
+                instanceUserIdentifier: this.readStoredInstanceUserIdentifier(target.instanceUserIdentifier || target.instance?.instanceUserIdentifier || target.instanceIdentifier || target.instance?.instanceIdentifier) || cleanOptional(target.instanceUserIdentifier || target.instance?.instanceUserIdentifier),
                 verification: target.verification || target.instance?.verification,
                 description: cleanOptional(target.description),
             });
@@ -1463,18 +1556,46 @@ export class ConfigService {
         throw new Error(`Invalid v4 workspace config: instance target "${name}" has unsupported kind "${String(target.kind)}".`);
     }
     assertUniqueIdsAndNames(items, label) {
-        const ids = new Set();
+        this.assertUniqueIds(items, label);
         const names = new Set();
         for (const item of items) {
-            if (ids.has(item.id))
-                throw new Error(`Invalid v4 workspace config: duplicate ${label} ID "${item.id}".`);
-            ids.add(item.id);
             const name = item.name.toLowerCase();
             if (names.has(name))
                 throw new Error(`Invalid v4 workspace config: duplicate ${label} name "${item.name}".`);
             names.add(name);
         }
     }
+    assertUniqueIds(items, label) {
+        const ids = new Set();
+        for (const item of items) {
+            if (ids.has(item.id))
+                throw new Error(`Invalid v4 workspace config: duplicate ${label} ID "${item.id}".`);
+            ids.add(item.id);
+        }
+    }
+    ensureEnvironmentWorkflowsPaths(environments) {
+        const usedSlugs = new Set();
+        const normalized = environments.map((environment) => {
+            const syncSlug = environment.syncSlug
+                ? this.createEnvironmentSyncSlug(environment.syncSlug)
+                : undefined;
+            if (syncSlug) {
+                const key = syncSlug.toLowerCase();
+                if (usedSlugs.has(key)) {
+                    throw new Error(`Invalid v4 workspace config: duplicate environment sync slug "${syncSlug}".`);
+                }
+                usedSlugs.add(key);
+            }
+            return { ...environment, syncSlug };
+        });
+        return normalized.map((environment) => {
+            const syncSlug = environment.syncSlug || this.uniqueEnvironmentSyncSlug(environment.name, [], usedSlugs);
+            usedSlugs.add(syncSlug.toLowerCase());
+            const workflowsPath = environment.workflowsPath
+                || this.resolveInputWorkflowsPath({ syncFolder: environment.syncFolder, syncSlug }, environments, environment.name);
+            return stripUndefined({ ...environment, syncSlug, workflowsPath, workflowDir: undefined });
+        });
+    }
     sanitizeEnvironment(environment, index) {
         if (!environment || typeof environment !== 'object') {
             throw new Error(`Invalid v4 workspace config: environment at index ${index} must be an object.`);
@@ -1482,16 +1603,20 @@ export class ConfigService {
         const id = cleanOptional(environment.id);
         const name = cleanOptional(environment.name) || id;
         const environmentTargetId = cleanOptional(environment.environmentTargetId) || cleanOptional(environment.instanceTargetId);
+        const workflowsPath = cleanOptional(environment.workflowsPath) || cleanOptional(environment.workflowDir);
         const syncFolder = cleanOptional(environment.syncFolder);
-        if (!id || !name || !environmentTargetId || !syncFolder) {
-            throw new Error(`Invalid v4 workspace config: environment at index ${index} needs id, name, environmentTargetId, and syncFolder.`);
+        if (!id || !name || !environmentTargetId || (!workflowsPath && !syncFolder)) {
+            throw new Error(`Invalid v4 workspace config: environment at index ${index} needs id, name, environmentTargetId, and workflowsPath.`);
         }
         return stripUndefined({
             id,
             name,
+            syncSlug: cleanOptional(environment.syncSlug),
+            legacyWorkflowDir: cleanOptional(environment.legacyWorkflowDir),
             environmentTargetId,
             projectId: cleanOptional(environment.projectId),
             projectName: cleanOptional(environment.projectName),
+            workflowsPath,
             syncFolder,
             folderSync: typeof environment.folderSync === 'boolean' ? environment.folderSync : undefined,
             customNodesPath: cleanOptional(environment.customNodesPath),
@@ -1510,14 +1635,18 @@ export class ConfigService {
         const environmentTargets = managedInstanceId
             ? [{ id: 'default-instance', name: 'Default Instance', kind: 'managed-instance', managedInstanceId }]
             : [];
+        const legacyWorkflowDir = overrides.workflowDir;
         const environments = managedInstanceId
             ? [stripUndefined({
                     id: 'default',
                     name: 'Default',
+                    syncSlug: this.createEnvironmentSyncSlug('Default'),
                     environmentTargetId: 'default-instance',
                     projectId: overrides.projectId,
                     projectName: overrides.projectName,
+                    workflowsPath: legacyWorkflowDir || path.join(overrides.syncFolder || DEFAULT_SYNC_FOLDER, this.createEnvironmentSyncSlug('Default')),
                     syncFolder: overrides.syncFolder || DEFAULT_SYNC_FOLDER,
+                    legacyWorkflowDir,
                     folderSync: overrides.folderSync,
                     customNodesPath: overrides.customNodesPath,
                 })]
@@ -1582,7 +1711,6 @@ export class ConfigService {
         return stripUndefined({ instanceIdentifier, instanceUserIdentifier });
     }
     resolveEnvironmentFromTarget(environment, target, source) {
-        const syncFolder = this.resolveWorkspacePath(environment.syncFolder);
         if (target.kind === 'managed-instance') {
             const instance = this.manager.getInstance(target.managedInstanceId);
             if (!instance)
@@ -1594,6 +1722,15 @@ export class ConfigService {
             const projectId = environment.projectId || instance.defaultProject?.id;
             const projectName = environment.projectName || instance.defaultProject?.name;
             const identity = this.resolveManagedEnvironmentIdentity(instance, host, apiKey);
+            const workflowsPath = this.resolveEnvironmentWorkflowsPath(environment, {
+                instanceIdentifier: identity.instanceIdentifier,
+                instanceUserIdentifier: identity.instanceUserIdentifier,
+                legacyInstanceIdentifier: instance.instanceIdentifier,
+                legacyInstanceUserIdentifier: instance.instanceUserIdentifier,
+                projectId,
+                projectName,
+            });
+            const syncFolder = workflowsPath;
             return {
                 environment,
                 environmentTarget: target,
@@ -1611,18 +1748,13 @@ export class ConfigService {
                 apiKeySource: envApiKey ? 'env' : globalApiKey ? 'global' : 'missing',
                 apiKeyAvailable: Boolean(apiKey),
                 accessStatus: this.deriveAccessStatus({ host, apiKey, projectId, projectName, verification: envApiKey ? undefined : instance.verification }),
+                workflowsPath,
                 syncFolder,
                 projectId,
                 projectName,
                 instanceIdentifier: identity.instanceIdentifier,
                 instanceUserIdentifier: identity.instanceUserIdentifier,
-                workflowDir: this.buildEnvironmentWorkflowDir({
-                    syncFolder,
-                    environmentId: environment.id,
-                    instanceIdentifier: identity.instanceIdentifier,
-                    instanceUserIdentifier: identity.instanceUserIdentifier,
-                    projectId,
-                }),
+                workflowDir: workflowsPath,
                 folderSync: environment.folderSync ?? false,
                 customNodesPath: environment.customNodesPath,
                 sources: {
@@ -1639,6 +1771,15 @@ export class ConfigService {
         const globalApiKey = this.getApiKey(host);
         const apiKey = envApiKey || workspaceApiKey || globalApiKey;
         const identity = this.resolveExternalEnvironmentIdentity(target, apiKey);
+        const workflowsPath = this.resolveEnvironmentWorkflowsPath(environment, {
+            instanceIdentifier: identity.instanceIdentifier,
+            instanceUserIdentifier: identity.instanceUserIdentifier,
+            legacyInstanceIdentifier: target.instanceIdentifier,
+            legacyInstanceUserIdentifier: target.instanceUserIdentifier,
+            projectId: environment.projectId,
+            projectName: environment.projectName,
+        });
+        const syncFolder = workflowsPath;
         return {
             environment,
             environmentTarget: target,
@@ -1654,18 +1795,13 @@ export class ConfigService {
             apiKeySource: envApiKey ? 'env' : workspaceApiKey ? 'workspace-local' : globalApiKey ? 'global' : 'missing',
             apiKeyAvailable: Boolean(apiKey),
             accessStatus: this.deriveAccessStatus({ host, apiKey, projectId: environment.projectId, projectName: environment.projectName, verification: target.verification }),
+            workflowsPath,
             syncFolder,
             projectId: environment.projectId,
             projectName: environment.projectName,
             instanceIdentifier: identity.instanceIdentifier,
             instanceUserIdentifier: identity.instanceUserIdentifier,
-            workflowDir: this.buildEnvironmentWorkflowDir({
-                syncFolder,
-                environmentId: environment.id,
-                instanceIdentifier: identity.instanceIdentifier,
-                instanceUserIdentifier: identity.instanceUserIdentifier,
-                projectId: environment.projectId,
-            }),
+            workflowDir: workflowsPath,
             folderSync: environment.folderSync ?? false,
             customNodesPath: environment.customNodesPath,
             sources: {
@@ -1681,8 +1817,10 @@ export class ConfigService {
             `N8NAC_ENV_${envVarSlug(environment.id)}_API_KEY`,
             `N8NAC_ENV_${envVarSlug(environment.name)}_API_KEY`,
             `N8NAC_TARGET_${envVarSlug(target.id)}_API_KEY`,
-            `N8NAC_TARGET_${envVarSlug(target.name)}_API_KEY`,
         ];
+        if (this.isUniqueInstanceTargetName(target)) {
+            candidates.push(`N8NAC_TARGET_${envVarSlug(target.name)}_API_KEY`);
+        }
         for (const key of candidates) {
             const value = process.env[key]?.trim().replace(/^['"]|['"]$/g, '');
             if (value)
@@ -1693,8 +1831,10 @@ export class ConfigService {
     readTargetEnvApiKey(target) {
         const candidates = [
             `N8NAC_TARGET_${envVarSlug(target.id)}_API_KEY`,
-            `N8NAC_TARGET_${envVarSlug(target.name)}_API_KEY`,
         ];
+        if (this.isUniqueInstanceTargetName(target)) {
+            candidates.push(`N8NAC_TARGET_${envVarSlug(target.name)}_API_KEY`);
+        }
         for (const key of candidates) {
             const value = process.env[key]?.trim().replace(/^["']|["']$/g, '');
             if (value)
@@ -1702,6 +1842,11 @@ export class ConfigService {
         }
         return undefined;
     }
+    isUniqueInstanceTargetName(target) {
+        const name = target.name.toLowerCase();
+        const config = this.ensureV4WorkspaceConfig();
+        return config.environmentTargets.filter((item) => item.name.toLowerCase() === name).length === 1;
+    }
     resolveExistingGlobalInstanceRef(managedInstanceId) {
         const cleaned = cleanRequired(managedInstanceId, 'Global instance reference');
         const instance = this.manager.getInstance(cleaned);
@@ -1713,12 +1858,13 @@ export class ConfigService {
     environmentToLocalConfig(environment) {
         return stripUndefined({
             host: environment.host,
-            syncFolder: environment.syncFolder,
+            workflowsPath: environment.workflowsPath,
+            workflowDir: environment.workflowsPath,
+            syncFolder: environment.workflowsPath,
             projectId: environment.projectId,
             projectName: environment.projectName,
             instanceIdentifier: environment.instanceIdentifier,
             instanceUserIdentifier: environment.instanceUserIdentifier,
-            workflowDir: environment.workflowDir,
             customNodesPath: environment.customNodesPath,
             folderSync: environment.folderSync,
         });
@@ -1740,7 +1886,8 @@ export class ConfigService {
             managedInstanceId: resolved.managedInstanceId,
             instanceName: resolved.activeInstanceName,
             url: resolved.sourceKind === 'external-instance' ? resolved.host : undefined,
-            workflowDir: resolved.workflowDir,
+            workflowsPathResolved: resolved.workflowsPath,
+            workflowDir: resolved.workflowsPath,
             instanceIdentifier: resolved.instanceIdentifier,
             instanceUserIdentifier: resolved.instanceUserIdentifier,
             apiKeyAvailable: resolved.apiKeyAvailable,
@@ -1809,12 +1956,13 @@ export class ConfigService {
             id: environment.activeInstanceId || environment.environmentTargetId,
             name: environment.activeInstanceName || environment.environmentTargetName,
             host: environment.host,
-            syncFolder: environment.syncFolder,
+            workflowsPath: environment.workflowsPath,
+            workflowDir: environment.workflowsPath,
+            syncFolder: environment.workflowsPath,
             projectId: environment.projectId,
             projectName: environment.projectName,
             instanceIdentifier: environment.instanceIdentifier,
             instanceUserIdentifier: environment.instanceUserIdentifier,
-            workflowDir: environment.workflowDir,
             customNodesPath: environment.customNodesPath,
             folderSync: environment.folderSync,
         });
@@ -1838,12 +1986,13 @@ export class ConfigService {
             host: environment.host,
             baseUrl: environment.host,
             apiKey: environment.apiKey,
-            syncFolder: environment.syncFolder,
+            workflowsPath: environment.workflowsPath,
+            workflowDir: environment.workflowsPath,
+            syncFolder: environment.workflowsPath,
             projectId: environment.projectId,
             projectName: environment.projectName,
             instanceIdentifier: environment.instanceIdentifier,
             instanceUserIdentifier: environment.instanceUserIdentifier,
-            workflowDir: environment.workflowDir,
             folderSync: environment.folderSync ?? false,
             customNodesPath: environment.customNodesPath,
             environmentId: environment.environmentId,
@@ -1868,6 +2017,22 @@ export class ConfigService {
             counter += 1;
         return `${base}-${counter}`;
     }
+    uniqueEnvironmentSyncSlug(baseName, environments, usedSlugs = new Set()) {
+        for (const environment of environments) {
+            if (environment.syncSlug)
+                usedSlugs.add(this.createEnvironmentSyncSlug(environment.syncSlug).toLowerCase());
+        }
+        const base = this.createEnvironmentSyncSlug(baseName);
+        if (!usedSlugs.has(base.toLowerCase()))
+            return base;
+        let counter = 2;
+        while (usedSlugs.has(`${base}-${counter}`.toLowerCase()))
+            counter += 1;
+        return `${base}-${counter}`;
+    }
+    createEnvironmentSyncSlug(value) {
+        return this.slugId(value);
+    }
     uniqueDisplayName(baseName, existingNames) {
         const base = cleanRequired(baseName, 'Name');
         let name = base;
@@ -2017,12 +2182,15 @@ export class ConfigService {
         return {
             ...this.toInstanceProfile(context.instance),
             host: context.host,
+            workflowsPath: context.workflowsPath
+                || context.workflowDir,
             syncFolder: context.syncFolder,
             projectId: context.projectId,
             projectName: context.projectName,
             instanceIdentifier,
             instanceUserIdentifier,
-            workflowDir: context.workflowDir
+            workflowDir: context.workflowsPath
+                || context.workflowDir
                 || this.buildWorkflowDir(context.syncFolder, instanceIdentifier, context.projectName),
             customNodesPath: context.customNodesPath,
             folderSync: context.folderSync,
@@ -2034,9 +2202,10 @@ export class ConfigService {
     toLocalConfig(profile) {
         if (!profile)
             return {};
-        const workflowDir = profile.workflowDir || this.buildWorkflowDir(profile.syncFolder, profile.instanceIdentifier, profile.projectName);
+        const workflowDir = profile.workflowsPath || profile.workflowDir || this.buildWorkflowDir(profile.syncFolder, profile.instanceIdentifier, profile.projectName);
         return stripUndefined({
             host: profile.host,
+            workflowsPath: profile.workflowsPath,
             syncFolder: profile.syncFolder,
             projectId: profile.projectId,
             projectName: profile.projectName,
@@ -2123,16 +2292,119 @@ export class ConfigService {
             ? path.join(syncFolder, instanceIdentifier, createProjectSlug(projectName))
             : undefined;
     }
-    buildEnvironmentWorkflowDir(input) {
-        if (!input.syncFolder || !input.environmentId || !input.instanceIdentifier || !input.instanceUserIdentifier || !input.projectId) {
+    resolveInputWorkflowsPath(input, environments, name) {
+        const explicit = cleanOptional(input.workflowsPath) || cleanOptional(input.workflowDir);
+        if (explicit)
+            return explicit;
+        const syncFolder = cleanOptional(input.syncFolder) || DEFAULT_SYNC_FOLDER;
+        const syncSlug = input.syncSlug || this.uniqueEnvironmentSyncSlug(name, environments);
+        return path.join(syncFolder, syncSlug);
+    }
+    patchWorkflowsPath(environment, patch) {
+        const explicit = patch.workflowsPath !== undefined
+            ? cleanRequired(patch.workflowsPath, 'Workflows path')
+            : patch.workflowDir !== undefined
+                ? cleanRequired(patch.workflowDir, 'Workflow directory')
+                : undefined;
+        if (explicit !== undefined)
+            return explicit;
+        if (patch.syncFolder === undefined)
             return undefined;
+        return this.resolveInputWorkflowsPath({
+            syncFolder: cleanRequired(patch.syncFolder, 'Sync folder'),
+            syncSlug: environment.syncSlug,
+        }, [], environment.name);
+    }
+    resolveEnvironmentWorkflowsPath(environment, identity = {}) {
+        const configured = this.resolveWorkspacePath(cleanRequired(environment.workflowsPath, 'Workflows path'));
+        if (fs.existsSync(configured))
+            return configured;
+        const configuredLegacyDir = environment.legacyWorkflowDir
+            ? this.resolveWorkspacePath(environment.legacyWorkflowDir)
+            : undefined;
+        if (configuredLegacyDir && fs.existsSync(configuredLegacyDir))
+            return configuredLegacyDir;
+        const legacy = this.getLegacyEnvironmentWorkflowDirs({
+            syncFolder: environment.syncFolder ? this.resolveWorkspacePath(environment.syncFolder) : undefined,
+            environmentId: environment.id,
+            instanceIdentifier: identity.instanceIdentifier,
+            instanceUserIdentifier: identity.instanceUserIdentifier,
+            legacyInstanceIdentifier: identity.legacyInstanceIdentifier,
+            legacyInstanceUserIdentifier: identity.legacyInstanceUserIdentifier,
+            projectId: identity.projectId,
+            projectName: identity.projectName,
+        }).find((directory) => fs.existsSync(directory));
+        return legacy || configured;
+    }
+    resolvePreservedLegacyWorkflowsPath(environment, target) {
+        const configured = this.resolveWorkspacePath(cleanRequired(environment.workflowsPath, 'Workflows path'));
+        const resolved = this.resolveEnvironmentFromTarget(environment, target, 'explicit');
+        const workflowsPath = resolved.workflowsPath;
+        if (!workflowsPath || workflowsPath === configured || !fs.existsSync(workflowsPath)) {
+            return environment.legacyWorkflowDir;
+        }
+        return path.isAbsolute(workflowsPath)
+            ? path.relative(this.workspaceRoot, workflowsPath)
+            : workflowsPath;
+    }
+    migrateWorkflowsPath(previousPath, nextPath) {
+        const previous = this.resolveWorkspacePath(previousPath);
+        const next = this.resolveWorkspacePath(nextPath);
+        if (previous === next || !fs.existsSync(previous))
+            return;
+        const relative = path.relative(previous, next);
+        const reverseRelative = path.relative(next, previous);
+        if (!relative || (!relative.startsWith('..') && !path.isAbsolute(relative)) || !reverseRelative || (!reverseRelative.startsWith('..') && !path.isAbsolute(reverseRelative))) {
+            throw new Error('Cannot migrate workflowsPath into itself or one of its child directories.');
         }
-        return path.join(input.syncFolder, createWorkflowDirNameV1({
-            environmentId: input.environmentId,
-            instanceIdentifier: input.instanceIdentifier,
-            instanceUserIdentifier: input.instanceUserIdentifier,
-            projectId: input.projectId,
-        }));
+        if (fs.existsSync(next) && !this.isDirectoryEmpty(next)) {
+            throw new Error(`Cannot migrate workflowsPath to "${nextPath}" because the destination is not empty.`);
+        }
+        fs.mkdirSync(path.dirname(next), { recursive: true });
+        if (fs.existsSync(next))
+            fs.rmSync(next, { recursive: true, force: true });
+        try {
+            fs.renameSync(previous, next);
+        }
+        catch (error) {
+            if (error?.code !== 'EXDEV')
+                throw error;
+            fs.cpSync(previous, next, { recursive: true, errorOnExist: false });
+            fs.rmSync(previous, { recursive: true, force: true });
+        }
+    }
+    isDirectoryEmpty(directory) {
+        try {
+            return fs.statSync(directory).isDirectory() && fs.readdirSync(directory).length === 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    getLegacyEnvironmentWorkflowDirs(input) {
+        const dirs = [];
+        if (!input.syncFolder)
+            return dirs;
+        if (input.environmentId && input.instanceIdentifier && input.instanceUserIdentifier && input.projectId) {
+            dirs.push(path.join(input.syncFolder, createWorkflowDirNameV1({
+                environmentId: input.environmentId,
+                instanceIdentifier: input.instanceIdentifier,
+                instanceUserIdentifier: input.instanceUserIdentifier,
+                projectId: input.projectId,
+            })));
+        }
+        if (input.environmentId && input.legacyInstanceIdentifier && input.legacyInstanceUserIdentifier && input.projectId) {
+            dirs.push(path.join(input.syncFolder, createWorkflowDirNameV1({
+                environmentId: input.environmentId,
+                instanceIdentifier: input.legacyInstanceIdentifier,
+                instanceUserIdentifier: input.legacyInstanceUserIdentifier,
+                projectId: input.projectId,
+            })));
+        }
+        if (input.instanceIdentifier && input.projectName) {
+            dirs.push(path.join(input.syncFolder, input.instanceIdentifier, createProjectSlug(input.projectName)));
+        }
+        return [...new Set(dirs)];
     }
     findConfigRoot(startDir) {
         let currentDir = path.resolve(startDir);