n8nac 2.3.4 → 2.3.6

package/dist/services/config-service.js

@@ -1,83 +1,48 @@
 import fs from 'fs';
 import path from 'path';
-import Conf from 'conf';
 import { N8nConfigurationService, N8nRuntimeOrchestrator, } from '@n8n-as-code/n8n-manager-core';
-import { N8nApiClient, createCanonicalInstanceIdentifier, createInstanceIdentifier, createInstanceUserIdentifier, createProjectSlug, createWorkflowDirNameV1, isCanonicalInstanceIdentifier, isCanonicalInstanceUserIdentifier, isCanonicalUserInstanceIdentifier, resolveInstanceIdentifier, resolveN8nIdentity as resolveN8nIdentityFromApi } from '../core/index.js';
+import { N8nApiClient, createCanonicalInstanceIdentifier, createInstanceIdentifier, createInstanceUserIdentifier, isCanonicalInstanceIdentifier, isCanonicalInstanceUserIdentifier, isCanonicalUserInstanceIdentifier, resolveInstanceIdentifier, resolveN8nIdentity as resolveN8nIdentityFromApi } from '../core/index.js';
 const DEFAULT_SYNC_FOLDER = 'workflows';
 export class ConfigService {
     manager;
     runtime;
     workspaceRoot;
     constructor(workspaceRoot) {
-        this.workspaceRoot = workspaceRoot ? path.resolve(workspaceRoot) : this.findConfigRoot(process.cwd());
+        const testWorkspaceRoot = process.env.NODE_ENV === 'test'
+            ? process.env.N8NAC_TEST_WORKSPACE_ROOT?.trim()
+            : undefined;
+        this.workspaceRoot = workspaceRoot ? path.resolve(workspaceRoot) : testWorkspaceRoot ? path.resolve(testWorkspaceRoot) : this.findConfigRoot(process.cwd());
         this.manager = new N8nConfigurationService();
         this.runtime = new N8nRuntimeOrchestrator({ configuration: this.manager });
     }
     getLocalConfig(environmentNameOrId) {
         try {
-            if (environmentNameOrId || this.isWorkspaceConfigV4()) {
-                return this.environmentToLocalConfig(this.resolveEnvironment(environmentNameOrId));
-            }
-            return this.contextToLocalConfig(this.resolveWorkspaceContext());
+            return this.environmentToLocalConfig(this.resolveEnvironment(environmentNameOrId));
         }
         catch {
-            try {
-                return this.contextToLocalConfig(this.resolveWorkspaceContext());
-            }
-            catch {
-                return {};
-            }
+            return {};
         }
     }
     getWorkspaceConfig() {
-        const legacyPlan = this.detectLegacyWorkspaceConfig();
-        if (legacyPlan) {
-            throw new Error(`Unsupported legacy n8n workspace config at ${legacyPlan.configPath}. ` +
-                'Run `n8nac workspace migrate --json` to inspect it, then `n8nac workspace migrate --write` to migrate it after confirmation.');
-        }
         const persisted = this.readWorkspaceConfigFile();
-        if (persisted.version === 4) {
-            const instances = this.listInstances();
-            const effective = tryResolve(() => this.resolveEnvironment());
-            const environmentTargets = persisted.environmentTargets.map((target) => this.environmentTargetToSnapshot(target));
-            const environments = persisted.environments.map((environment) => this.environmentToSnapshot(environment));
-            return {
-                version: 4,
-                activeEnvironmentId: persisted.activeEnvironmentId,
-                activeInstanceId: effective?.activeInstanceId,
-                activeEnvironment: effective?.environment,
-                environmentTargets,
-                environments,
-                instances,
-                ...(effective ? this.environmentToLocalConfig(effective) : {}),
-                sourceKind: effective?.sourceKind,
-                environmentTargetId: effective?.environmentTargetId,
-                environmentTargetName: effective?.environmentTargetName,
-                apiKeyAvailable: effective?.apiKeyAvailable,
-                credentialSource: effective?.apiKeySource,
-            };
-        }
-        const overrides = this.manager.readWorkspaceOverrides(this.workspaceRoot);
         const instances = this.listInstances();
-        const effective = tryResolve(() => this.resolveWorkspaceContext());
-        const activeInstanceId = effective?.activeInstanceId || overrides.activeInstanceId || this.manager.getGlobalConfig().activeInstanceId;
-        const active = activeInstanceId ? instances.find((instance) => instance.id === activeInstanceId) : undefined;
-        const activeProfile = effective ? this.contextToInstanceProfile(effective) : active;
-        const resolvedSyncFolder = overrides.syncFolder || effective?.syncFolder;
-        const resolvedProjectName = overrides.projectName || activeProfile?.projectName;
+        const effective = tryResolve(() => this.resolveEnvironment());
+        const environmentTargets = persisted.environmentTargets.map((target) => this.environmentTargetToSnapshot(target));
+        const environments = persisted.environments.map((environment) => this.environmentToSnapshot(environment));
         return {
-            version: 3,
-            activeInstanceId,
+            version: 4,
+            activeEnvironmentId: persisted.activeEnvironmentId,
+            activeInstanceId: effective?.activeInstanceId,
+            activeEnvironment: effective?.environment,
+            environmentTargets,
+            environments,
             instances,
-            ...this.toLocalConfig({
-                ...activeProfile,
-                syncFolder: resolvedSyncFolder,
-                projectId: overrides.projectId || activeProfile?.projectId,
-                projectName: resolvedProjectName,
-                folderSync: overrides.folderSync ?? activeProfile?.folderSync,
-                customNodesPath: overrides.customNodesPath || activeProfile?.customNodesPath,
-                workflowDir: undefined,
-            }),
+            ...(effective ? this.environmentToLocalConfig(effective) : {}),
+            sourceKind: effective?.sourceKind,
+            environmentTargetId: effective?.environmentTargetId,
+            environmentTargetName: effective?.environmentTargetName,
+            apiKeyAvailable: effective?.apiKeyAvailable,
+            credentialSource: effective?.apiKeySource,
         };
     }
     listInstanceTargets() {
@@ -259,12 +224,11 @@ export class ConfigService {
         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,
+            legacyWorkflowDir: undefined,
             workflowDir: undefined,
             syncFolder: undefined,
             environmentTargetId: target?.id || environment.environmentTargetId,
@@ -311,8 +275,7 @@ export class ConfigService {
         return this.findInstanceTarget(this.ensureV4WorkspaceConfig(), nameOrId);
     }
     resolveEnvironment(environmentNameOrId) {
-        const persisted = this.readWorkspaceConfigFile();
-        const config = persisted.version === 4 ? persisted : this.v3ToV4WorkspaceConfig();
+        const config = this.readWorkspaceConfigFile();
         if (config.environments.length === 0) {
             throw new Error('No workspace environment is configured. Run `n8nac env add` first.');
         }
@@ -322,7 +285,7 @@ export class ConfigService {
                 ? this.findEnvironment(config, config.activeEnvironmentId)
                 : config.environments[0];
         const target = this.findInstanceTarget(config, environment.environmentTargetId);
-        return this.resolveEnvironmentFromTarget(environment, target, environmentNameOrId ? 'explicit' : config.activeEnvironmentId ? 'workspace-default' : persisted.version === 4 ? 'workspace-default' : 'legacy');
+        return this.resolveEnvironmentFromTarget(environment, target, environmentNameOrId ? 'explicit' : 'workspace-default');
     }
     async prepareEnvironment(environmentNameOrId) {
         const resolved = this.resolveEnvironment(environmentNameOrId);
@@ -331,18 +294,7 @@ 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,
-                });
+                const workflowsPath = this.resolveEnvironmentWorkflowsPath(resolved.environment);
                 return {
                     ...resolved,
                     workflowsPath,
@@ -378,14 +330,7 @@ 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,
-        });
+        const workflowsPath = this.resolveEnvironmentWorkflowsPath(resolved.environment);
         return {
             ...resolved,
             host: context.host,
@@ -408,8 +353,7 @@ export class ConfigService {
         return this.listInstances();
     }
     listInstances() {
-        const overrides = this.isWorkspaceConfigV4() ? undefined : tryResolve(() => this.manager.readWorkspaceOverrides(this.workspaceRoot));
-        return this.manager.listInstances().map((instance) => this.toInstanceProfile(instance, overrides));
+        return this.manager.listInstances().map((instance) => this.toInstanceProfile(instance));
     }
     getInstanceConfig(instanceId) {
         return this.listInstances().find((instance) => instance.id === instanceId);
@@ -425,55 +369,38 @@ export class ConfigService {
         if (effective?.sourceKind === 'managed-instance' && effective.activeInstanceId) {
             return this.getInstanceConfig(effective.activeInstanceId);
         }
-        const legacy = tryResolve(() => this.resolveWorkspaceContext());
-        return legacy ? this.contextToInstanceProfile(legacy) : undefined;
+        return undefined;
     }
     getEffectiveInstanceConfig(instanceId) {
         if (instanceId) {
-            const effective = tryResolve(() => this.resolveWorkspaceContext(instanceId));
-            return effective ? this.contextToInstanceProfile(effective) : undefined;
+            const instance = this.manager.getInstance(instanceId);
+            return instance ? this.toInstanceProfile(instance) : undefined;
         }
-        if (this.isWorkspaceConfigV4()) {
-            const environment = tryResolve(() => this.resolveEnvironment());
-            if (environment)
-                return this.environmentToInstanceProfile(environment);
-        }
-        const effective = tryResolve(() => this.resolveWorkspaceContext());
-        return effective ? this.contextToInstanceProfile(effective) : undefined;
+        const environment = tryResolve(() => this.resolveEnvironment());
+        return environment ? this.environmentToInstanceProfile(environment) : undefined;
     }
     getEffectiveContext(instanceId) {
-        if (!instanceId && this.isWorkspaceConfigV4()) {
-            return this.resolvedEnvironmentToEffectiveContext(tryResolve(() => this.resolveEnvironment()));
+        if (instanceId) {
+            throw new Error('Explicit instance context is not supported with V4 workspace environments. Resolve a workspace environment instead.');
         }
-        return tryResolve(() => this.resolveWorkspaceContext(instanceId));
+        return this.resolvedEnvironmentToEffectiveContext(tryResolve(() => this.resolveEnvironment()));
     }
     async prepareWorkspaceContext(input) {
-        const instanceId = typeof input === 'string' ? input : input?.instanceId;
-        const environment = typeof input === 'string' ? undefined : input?.environment;
-        const consumer = typeof input === 'string' ? 'cli' : input?.consumer === 'vscode' ? 'vscode' : 'cli';
-        if (environment || (!instanceId && this.isWorkspaceConfigV4())) {
-            return this.resolvedEnvironmentToEffectiveContext(await this.prepareEnvironment(environment));
+        const environment = typeof input === 'string' ? input : input?.environment;
+        if (typeof input === 'object' && input?.instanceId) {
+            throw new Error('Explicit instance context is not supported with V4 workspace environments. Resolve a workspace environment instead.');
         }
-        const prepared = await this.runtime.prepareEffectiveContext({
-            workspaceRoot: this.workspaceRoot,
-            instanceId,
-            syncFolderDefault: 'workspace',
-            consumer,
-            autoStart: true,
-        });
-        if (prepared.runtime.blocked) {
-            throw new Error(prepared.runtime.blocked.message);
+        if (typeof input === 'object' && input?.consumer && input.consumer !== 'cli') {
+            throw new Error(`Unsupported workspace context consumer: ${input.consumer}`);
         }
-        return {
-            ...prepared.context,
-        };
+        return this.resolvedEnvironmentToEffectiveContext(await this.prepareEnvironment(environment));
     }
     getCurrentInstanceConfigId() {
         return this.getActiveInstanceId();
     }
     getActiveInstanceId() {
         const environment = tryResolve(() => this.resolveEnvironment());
-        return environment?.activeInstanceId || this.getActiveInstance()?.id || this.manager.getGlobalConfig().activeInstanceId;
+        return environment?.activeInstanceId;
     }
     getCurrentInstance() {
         return this.getActiveInstance();
@@ -609,10 +536,6 @@ export class ConfigService {
         };
     }
     saveLocalConfig(config, options = {}) {
-        const workspaceConfigIsV4 = this.isWorkspaceConfigV4();
-        if (workspaceConfigIsV4) {
-            this.assertNoLegacyWorkspaceFields(config);
-        }
         const current = (options.createNew ? undefined : (options.instanceId ? this.manager.getInstance(options.instanceId) : this.manager.getGlobalActiveInstance()));
         const host = this.resolveStoredBaseUrl(current, config.host);
         const input = {
@@ -633,11 +556,7 @@ export class ConfigService {
         if (options.apiKey) {
             this.manager.saveApiKey(saved.id, options.apiKey);
         }
-        if (workspaceConfigIsV4) {
-            return this.toInstanceProfile(saved);
-        }
-        this.writeWorkspaceFields(saved.id, config, options.setActive !== false);
-        return this.toInstanceProfile(saved, this.manager.readWorkspaceOverrides(this.workspaceRoot));
+        return this.toInstanceProfile(saved);
     }
     saveInstanceProfile(profile, options = {}) {
         return this.saveLocalConfig(profile, {
@@ -796,677 +715,21 @@ export class ConfigService {
     getWorkspaceRoot() {
         return this.workspaceRoot;
     }
-    detectLegacyWorkspaceConfig() {
-        const configPath = this.getInstanceConfigPath();
-        const raw = this.readRawWorkspaceConfig(configPath);
-        if (!raw || !this.isLegacyWorkspaceConfig(raw)) {
-            return undefined;
-        }
-        const instances = this.readLegacyInstances(raw);
-        const requestedActiveInstanceId = asString(raw.activeInstanceId);
-        const activeInstance = requestedActiveInstanceId
-            ? (instances.find((instance) => instance.id === requestedActiveInstanceId) || instances[0])
-            : instances[0];
-        const activeInstanceId = activeInstance?.id;
-        const workspace = stripUndefined({
-            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,
-        });
-        const warnings = [
-            'Global n8n instances and API keys now live in n8n-manager, not in n8nac-config.json.',
-            'n8nac-config.json will keep workspace environments after migration.',
-            requestedActiveInstanceId && requestedActiveInstanceId !== activeInstanceId
-                ? `Legacy active instance "${requestedActiveInstanceId}" was not found; migration will use ${activeInstanceId ? `"${activeInstanceId}"` : 'no pinned instance'} instead.`
-                : undefined,
-            instances.some((instance) => instance.hasApiKey)
-                ? 'Embedded API keys found: --write will move them into the local n8n-manager secret store.'
-                : 'No externalInstance API keys found: you may need to run n8n-manager auth set after migration.',
-        ].filter(Boolean);
-        return {
-            status: 'legacy-detected',
-            configPath,
-            version: typeof raw.version === 'number' ? raw.version : undefined,
-            activeInstanceId,
-            instances,
-            workspace,
-            warnings,
-        };
-    }
-    migrateLegacyWorkspaceConfig(options = {}) {
-        const plan = this.detectLegacyWorkspaceConfig();
-        const configPath = this.getInstanceConfigPath();
-        if (!plan) {
-            return { status: 'not-needed', configPath };
-        }
-        if (!options.write) {
-            return { status: 'dry-run', plan };
-        }
-        const backupPath = this.createLegacyConfigBackup(configPath);
-        const rawLegacyConfig = this.readRawWorkspaceConfig(configPath) || {};
-        const migratedInstances = [];
-        const migratedPairs = [];
-        for (const legacyInstance of plan.instances) {
-            const apiKey = this.readLegacyApiKey(legacyInstance.id, rawLegacyConfig)
-                || this.readLegacyStoredApiKey(legacyInstance.id, legacyInstance.host);
-            const saved = this.saveLocalConfig({
-                host: legacyInstance.host,
-                syncFolder: legacyInstance.syncFolder || plan.workspace.syncFolder,
-                projectId: legacyInstance.projectId || plan.workspace.projectId,
-                projectName: legacyInstance.projectName || plan.workspace.projectName,
-                instanceIdentifier: legacyInstance.instanceIdentifier,
-                customNodesPath: legacyInstance.customNodesPath || plan.workspace.customNodesPath,
-                folderSync: legacyInstance.folderSync ?? plan.workspace.folderSync,
-            }, {
-                instanceId: legacyInstance.id,
-                instanceName: legacyInstance.name,
-                setActive: legacyInstance.id === plan.activeInstanceId,
-                apiKey,
-            });
-            migratedInstances.push(saved);
-            migratedPairs.push({ legacy: legacyInstance, profile: saved });
-        }
-        if (migratedPairs.length > 0) {
-            const usedIds = [];
-            const targetNames = new Set();
-            const environmentNames = new Set();
-            const environmentTargets = [];
-            const environments = [];
-            for (const { legacy, profile } of migratedPairs) {
-                const baseName = profile.name || legacy.name || profile.host || legacy.id;
-                const singleInstanceMigration = migratedPairs.length === 1;
-                const targetName = this.uniqueDisplayName(baseName, targetNames);
-                const environmentName = this.uniqueDisplayName(singleInstanceMigration ? 'Default' : baseName, environmentNames);
-                const targetId = this.uniqueWorkspaceId(singleInstanceMigration ? 'default-instance' : `${profile.id || legacy.id || targetName}-instance`, usedIds);
-                usedIds.push(targetId);
-                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,
-                    kind: 'external-instance',
-                    url: cleanRequired(profile.host || legacy.host, 'Legacy instance URL'),
-                    instanceIdentifier: profile.instanceIdentifier || legacy.instanceIdentifier,
-                    verification: legacy.verification,
-                });
-                environments.push(stripUndefined({
-                    id: environmentId,
-                    name: environmentName,
-                    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,
-                }));
-            }
-            const activePair = migratedPairs.find(({ legacy }) => legacy.id === plan.activeInstanceId) || migratedPairs[0];
-            const activeEnvironmentId = environments[migratedPairs.indexOf(activePair)]?.id || environments[0]?.id;
-            this.writeWorkspaceConfigV4({
-                version: 4,
-                activeEnvironmentId,
-                environmentTargets,
-                environments,
-            });
-        }
-        else {
-            this.manager.writeWorkspaceOverrides(this.workspaceRoot, stripUndefined({
-                version: 3,
-                syncFolder: plan.workspace.syncFolder,
-                projectId: plan.workspace.projectId,
-                projectName: plan.workspace.projectName,
-                customNodesPath: plan.workspace.customNodesPath,
-                folderSync: plan.workspace.folderSync,
-            }));
-        }
-        return { status: 'migrated', plan, backupPath, instances: migratedInstances };
-    }
-    detectWorkspaceMigration() {
-        const configPath = this.getInstanceConfigPath();
-        const legacyMigration = this.detectLegacyWorkspaceConfig();
-        const globalInstancesMigration = this.detectGlobalInstancesMigration();
-        if (!legacyMigration && !globalInstancesMigration)
-            return undefined;
-        return {
-            status: 'migration-required',
-            configPath,
-            legacyMigration,
-            globalInstancesMigration,
-            warnings: [
-                ...(legacyMigration?.warnings || []),
-                ...(globalInstancesMigration?.warnings || []),
-            ],
-        };
-    }
-    migrateWorkspaceConfiguration(options = {}) {
-        const initialPlan = this.detectWorkspaceMigration();
-        const configPath = this.getInstanceConfigPath();
-        if (!initialPlan)
-            return { status: 'not-needed', configPath };
-        if (!options.write)
-            return { status: 'dry-run', plan: initialPlan };
-        const snapshot = this.createWorkspaceMigrationSnapshot();
-        try {
-            let legacyMigration;
-            if (initialPlan.legacyMigration) {
-                const legacyResult = this.migrateLegacyWorkspaceConfig({ write: true });
-                if (legacyResult.status === 'migrated') {
-                    legacyMigration = legacyResult;
-                    this.preserveWorkspaceMigrationApiKeyFallback(options.legacyApiKeyFallback, legacyResult.instances);
-                }
-            }
-            const currentGlobalPlan = this.detectGlobalInstancesMigration();
-            let globalInstancesMigration;
-            if (currentGlobalPlan) {
-                const globalResult = this.migrateGlobalInstancesToEnvironments({ write: true });
-                if (globalResult.status === 'migrated') {
-                    globalInstancesMigration = globalResult;
-                }
-            }
-            const remainingPlan = this.detectWorkspaceMigration();
-            if (remainingPlan) {
-                throw new Error(this.formatIncompleteWorkspaceMigrationError(remainingPlan));
-            }
-            return {
-                status: 'migrated',
-                plan: initialPlan,
-                legacyMigration,
-                globalInstancesMigration,
-                backupPath: legacyMigration?.backupPath,
-                migratedEnvironmentIds: globalInstancesMigration?.migratedEnvironmentIds || [],
-                deletedGlobalInstanceIds: globalInstancesMigration?.deletedGlobalInstanceIds || [],
-            };
-        }
-        catch (error) {
-            this.restoreWorkspaceMigrationSnapshot(snapshot);
-            throw error;
-        }
-    }
-    toWorkspaceMigrationReport(result) {
-        if (result.status === 'not-needed') {
-            return {
-                status: result.status,
-                configPath: result.configPath,
-                required: false,
-                operations: [],
-                warnings: [],
-            };
-        }
-        return {
-            status: result.status,
-            configPath: result.plan.configPath,
-            required: result.status === 'dry-run',
-            operations: this.workspaceMigrationPlanToOperations(result.plan),
-            warnings: result.plan.warnings,
-            nextCommand: result.status === 'dry-run' ? 'n8nac workspace migrate --json' : undefined,
-            applyCommand: result.status === 'dry-run' ? 'n8nac workspace migrate --write' : undefined,
-            backupPath: result.status === 'migrated' ? result.backupPath : undefined,
-            migratedEnvironmentIds: result.status === 'migrated' ? result.migratedEnvironmentIds : undefined,
-            deletedGlobalInstanceIds: result.status === 'migrated' ? result.deletedGlobalInstanceIds : undefined,
-        };
-    }
-    workspaceMigrationPlanToReport(plan) {
-        return {
-            status: 'dry-run',
-            configPath: plan.configPath,
-            required: true,
-            operations: this.workspaceMigrationPlanToOperations(plan),
-            warnings: plan.warnings,
-            nextCommand: 'n8nac workspace migrate --json',
-            applyCommand: 'n8nac workspace migrate --write',
-        };
-    }
-    workspaceMigrationPlanToOperations(plan) {
-        const operations = [];
-        if (plan.legacyMigration) {
-            operations.push({
-                id: 'legacy-workspace-config',
-                label: 'Legacy workspace config',
-                description: 'Convert legacy n8nac workspace config into workspace environments and local n8n-manager secrets.',
-                instanceCount: plan.legacyMigration.instances.length,
-                instances: plan.legacyMigration.instances.map((instance) => stripUndefined({
-                    id: instance.id,
-                    name: instance.name,
-                    kind: 'legacy-workspace-instance',
-                    url: instance.host,
-                    projectId: instance.projectId,
-                    projectName: instance.projectName,
-                    apiKeyAvailable: instance.hasApiKey,
-                })),
-                warnings: plan.legacyMigration.warnings,
-            });
-        }
-        if (plan.globalInstancesMigration) {
-            operations.push({
-                id: 'global-instances',
-                label: 'Global/v2 instances',
-                description: 'Attach managed instances to this workspace and copy external global instances into workspace environments.',
-                instanceCount: plan.globalInstancesMigration.instances.length,
-                instances: plan.globalInstancesMigration.instances.map((instance) => stripUndefined({
-                    id: instance.id,
-                    name: instance.name,
-                    kind: instance.mode,
-                    url: instance.url,
-                    projectId: instance.projectId,
-                    projectName: instance.projectName,
-                    apiKeyAvailable: instance.apiKeyAvailable,
-                })),
-                warnings: plan.globalInstancesMigration.warnings,
-            });
-        }
-        return operations;
-    }
-    detectGlobalInstancesMigration() {
-        const configPath = this.getInstanceConfigPath();
-        const global = this.manager.getGlobalConfig();
-        const workspace = this.readWorkspaceConfigFileSafe();
-        const environmentTargetIds = new Set(workspace.environments.map((environment) => environment.environmentTargetId));
-        const instances = global.instances
-            .filter((instance) => {
-            if (this.getGlobalExternalInstanceUrl(instance))
-                return true;
-            if (instance.mode !== 'managed-local-docker')
-                return false;
-            const migratedTarget = workspace.environmentTargets.find((target) => {
-                return target.kind === 'managed-instance'
-                    && target.managedInstanceId === instance.id
-                    && environmentTargetIds.has(target.id);
-            });
-            return !migratedTarget
-                && instance.metadata?.n8nacWorkspaceEnvironmentModel !== 'v4';
-        })
-            .map((instance) => stripUndefined({
-            id: instance.id,
-            name: instance.name || this.getGlobalExternalInstanceUrl(instance) || instance.id,
-            mode: instance.mode === 'managed-local-docker' ? 'managed-instance' : 'external-instance',
-            url: this.getGlobalExternalInstanceUrl(instance) || '',
-            projectId: instance.defaultProject?.id,
-            projectName: instance.defaultProject?.name,
-            apiKeyAvailable: Boolean(this.manager.getApiKey(instance.id)),
-        }));
-        if (!instances.length)
-            return undefined;
-        return {
-            status: 'global-instances-detected',
-            configPath,
-            activeInstanceId: global.activeInstanceId,
-            instances,
-            warnings: [
-                'Global n8n instances belong to the previous v2 workspace model.',
-                'Migration will copy external instances into this workspace as environments, move API keys to workspace target secrets, then remove the old external global instance entries.',
-                'Managed instances will be added to this workspace as environments and will stay global.',
-            ],
-        };
-    }
-    migrateGlobalInstancesToEnvironments(options = {}) {
-        const plan = this.detectGlobalInstancesMigration();
-        const configPath = this.getInstanceConfigPath();
-        if (!plan)
-            return { status: 'not-needed', configPath };
-        if (!options.write)
-            return { status: 'dry-run', plan };
-        const current = this.readWorkspaceConfigFileSafe();
-        const usedIds = [
-            ...current.environmentTargets.map((item) => item.id),
-            ...current.environments.map((item) => item.id),
-        ];
-        const targetNames = new Set(current.environmentTargets.map((item) => item.name));
-        const environmentNames = new Set(current.environments.map((item) => item.name));
-        const environmentTargets = [...current.environmentTargets];
-        const environments = [...current.environments];
-        const migratedEnvironmentIds = [];
-        const deletedGlobalInstanceIds = [];
-        let activeMigratedEnvironmentId;
-        for (const item of plan.instances) {
-            const instance = this.manager.getInstance(item.id);
-            if (!instance)
-                continue;
-            if (instance.mode === 'managed-local-docker') {
-                const existingTarget = environmentTargets.find((target) => target.kind === 'managed-instance' && target.managedInstanceId === instance.id);
-                let targetId = existingTarget?.id;
-                if (!targetId) {
-                    const targetName = this.uniqueDisplayName(instance.name || instance.id, targetNames);
-                    targetId = this.uniqueWorkspaceId(instance.id, usedIds);
-                    usedIds.push(targetId);
-                    environmentTargets.push({
-                        id: targetId,
-                        name: targetName,
-                        kind: 'managed-instance',
-                        managedInstanceId: instance.id,
-                    });
-                }
-                let existingEnvironment = environments.find((environment) => environment.environmentTargetId === targetId);
-                if (!existingEnvironment) {
-                    const environmentName = this.uniqueDisplayName(instance.name || instance.id, environmentNames);
-                    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);
-                    migratedEnvironmentIds.push(environmentId);
-                }
-                if (instance.id === plan.activeInstanceId)
-                    activeMigratedEnvironmentId = existingEnvironment.id;
-                this.manager.upsertInstance({
-                    id: instance.id,
-                    metadata: {
-                        ...(instance.metadata ?? {}),
-                        n8nacWorkspaceEnvironmentModel: 'v4',
-                    },
-                }, { setActive: false });
-                continue;
-            }
-            const externalUrl = this.getGlobalExternalInstanceUrl(instance);
-            if (!externalUrl)
-                continue;
-            const apiKey = this.manager.getApiKey(instance.id);
-            const normalizedBaseUrl = this.normalizeHost(externalUrl);
-            const existingTargetIndex = environmentTargets.findIndex((target) => {
-                if (target.kind === 'managed-instance')
-                    return target.managedInstanceId === instance.id;
-                return this.normalizeHost(target.url) === normalizedBaseUrl;
-            });
-            if (existingTargetIndex >= 0) {
-                const existingTarget = environmentTargets[existingTargetIndex];
-                if (existingTarget.kind === 'managed-instance') {
-                    environmentTargets[existingTargetIndex] = {
-                        id: existingTarget.id,
-                        name: existingTarget.name,
-                        kind: 'external-instance',
-                        url: externalUrl,
-                        instanceIdentifier: instance.instanceIdentifier,
-                        verification: instance.verification,
-                        description: existingTarget.description,
-                    };
-                }
-                if (apiKey)
-                    this.manager.saveApiKey(existingTarget.id, apiKey);
-                let existingEnvironment = environments.find((environment) => environment.environmentTargetId === existingTarget.id);
-                if (!existingEnvironment) {
-                    const environmentName = this.uniqueDisplayName(instance.name || externalUrl || instance.id, environmentNames);
-                    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);
-                    migratedEnvironmentIds.push(environmentId);
-                }
-                if (instance.id === plan.activeInstanceId)
-                    activeMigratedEnvironmentId = existingEnvironment.id;
-                continue;
-            }
-            const targetName = this.uniqueDisplayName(instance.name || externalUrl || instance.id, targetNames);
-            const environmentName = this.uniqueDisplayName(instance.name || externalUrl || instance.id, environmentNames);
-            const targetId = this.uniqueWorkspaceId(`${instance.id}-instance`, usedIds);
-            usedIds.push(targetId);
-            const environmentId = this.uniqueWorkspaceId(instance.id || environmentName, usedIds);
-            usedIds.push(environmentId);
-            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,
-                kind: 'external-instance',
-                url: externalUrl,
-                instanceIdentifier: instance.instanceIdentifier,
-                verification: instance.verification,
-            });
-            environments.push(stripUndefined({
-                id: environmentId,
-                name: environmentName,
-                environmentTargetId: targetId,
-                projectId,
-                projectName,
-                workflowsPath: path.join(syncFolder, syncSlug),
-                syncSlug,
-                syncFolder,
-            }));
-            if (apiKey)
-                this.manager.saveApiKey(targetId, apiKey);
-            migratedEnvironmentIds.push(environmentId);
-            if (instance.id === plan.activeInstanceId)
-                activeMigratedEnvironmentId = environmentId;
-        }
-        const activeEnvironmentId = current.activeEnvironmentId
-            || activeMigratedEnvironmentId
-            || migratedEnvironmentIds[0]
-            || environments[0]?.id;
-        this.writeWorkspaceConfigV4(stripUndefined({
-            version: 4,
-            activeEnvironmentId,
-            environmentTargets,
-            environments,
-        }));
-        for (const item of plan.instances) {
-            const instance = this.manager.getInstance(item.id);
-            if (instance && this.getGlobalExternalInstanceUrl(instance)) {
-                this.manager.deleteInstance(item.id);
-                deletedGlobalInstanceIds.push(item.id);
-            }
-        }
-        return { status: 'migrated', plan, migratedEnvironmentIds, deletedGlobalInstanceIds };
-    }
     resolveWorkspacePath(targetPath) {
         return path.isAbsolute(targetPath)
             ? targetPath
             : path.resolve(this.workspaceRoot, targetPath);
     }
-    readRawWorkspaceConfig(configPath) {
-        if (!fs.existsSync(configPath)) {
-            return undefined;
-        }
-        try {
-            const value = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-            return value && typeof value === 'object' && !Array.isArray(value)
-                ? value
-                : undefined;
-        }
-        catch {
-            return undefined;
-        }
-    }
-    isLegacyWorkspaceConfig(raw) {
-        if (raw.version === 1 || raw.version === 2)
-            return true;
-        if (Array.isArray(raw.instances))
-            return true;
-        if (typeof raw.apiKey === 'string')
-            return true;
-        return false;
-    }
-    readLegacyInstances(raw) {
-        const rawInstances = Array.isArray(raw.instances) ? raw.instances : [];
-        if (rawInstances.length > 0) {
-            return rawInstances
-                .map((candidate, index) => this.toLegacyInstance(candidate, raw, index, false))
-                .filter((instance) => Boolean(instance));
-        }
-        const candidates = this.hasRootLegacyInstance(raw) ? [raw] : [];
-        return candidates
-            .map((candidate, index) => this.toLegacyInstance(candidate, raw, index, true))
-            .filter((instance) => Boolean(instance));
-    }
-    hasRootLegacyInstance(raw) {
-        return Boolean(asString(raw.host) || asString(raw.url) || asString(raw.baseUrl));
-    }
-    toLegacyInstance(candidate, root, index, useRootActiveInstanceId) {
-        if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
-            return undefined;
-        }
-        const value = candidate;
-        const id = asString(value.id) || (useRootActiveInstanceId ? asString(root.activeInstanceId) : undefined) || `legacy-${index + 1}`;
-        const host = asString(value.host) || asString(value.url) || asString(value.baseUrl) || asString(root.host) || asString(root.url) || asString(root.baseUrl);
-        const name = asString(value.name) || host || id;
-        return stripUndefined({
-            id,
-            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),
-            workflowDir: asString(value.workflowDir) || asString(root.workflowDir),
-            verification: value.verification && typeof value.verification === 'object' && !Array.isArray(value.verification)
-                ? value.verification
-                : undefined,
-            customNodesPath: asString(value.customNodesPath) || asString(root.customNodesPath),
-            folderSync: asBoolean(value.folderSync) ?? asBoolean(root.folderSync),
-            hasApiKey: Boolean(asString(value.apiKey) || asString(root.apiKey)),
-        });
-    }
-    readLegacyApiKey(instanceId, root) {
-        const instances = Array.isArray(root.instances) ? root.instances : [];
-        const match = instances.find((candidate) => {
-            return candidate && typeof candidate === 'object' && !Array.isArray(candidate)
-                && asString(candidate.id) === instanceId;
-        });
-        if (match) {
-            return asString(match.apiKey) || asString(root.apiKey);
-        }
-        const syntheticIndex = this.syntheticLegacyIndex(instanceId);
-        const syntheticMatch = syntheticIndex !== undefined ? instances[syntheticIndex] : undefined;
-        if (syntheticMatch && typeof syntheticMatch === 'object' && !Array.isArray(syntheticMatch)) {
-            return asString(syntheticMatch.apiKey) || asString(root.apiKey);
-        }
-        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',
-                configName: 'credentials',
-                configFileMode: 0o600,
-            });
-            const instanceProfiles = store.get('instanceProfiles');
-            const hosts = store.get('hosts');
-            return readFromStore({ hosts, instanceProfiles });
-        }
-        catch {
-            return undefined;
-        }
-    }
-    syntheticLegacyIndex(instanceId) {
-        const match = instanceId.match(/^legacy-(\d+)$/);
-        if (!match)
-            return undefined;
-        const index = Number.parseInt(match[1], 10) - 1;
-        return Number.isSafeInteger(index) && index >= 0 ? index : undefined;
-    }
-    createLegacyConfigBackup(configPath) {
-        const timestamp = new Date().toISOString().replace(/[-:]/g, '').replace(/\..*$/, '').replace('T', '-');
-        const backupPath = path.join(path.dirname(configPath), `n8nac-config.v1-backup-${timestamp}.json`);
-        fs.copyFileSync(configPath, backupPath);
-        return backupPath;
-    }
-    createWorkspaceMigrationSnapshot() {
-        const managerPaths = this.manager;
-        const paths = [
-            this.getInstanceConfigPath(),
-            managerPaths.instancesPath,
-            managerPaths.secretsPath,
-        ].filter((value) => Boolean(value));
-        return paths.map((filePath) => ({
-            path: filePath,
-            content: fs.existsSync(filePath) ? fs.readFileSync(filePath) : undefined,
-        }));
-    }
-    restoreWorkspaceMigrationSnapshot(snapshot) {
-        for (const entry of snapshot) {
-            if (entry.content === undefined) {
-                fs.rmSync(entry.path, { force: true });
-                continue;
-            }
-            fs.mkdirSync(path.dirname(entry.path), { recursive: true });
-            fs.writeFileSync(entry.path, entry.content);
-        }
-    }
-    formatIncompleteWorkspaceMigrationError(plan) {
-        const legacyCount = plan.legacyMigration?.instances.length || 0;
-        const globalCount = plan.globalInstancesMigration?.instances.length || 0;
-        return [
-            'Workspace migration did not complete atomically; all migration file changes were rolled back.',
-            `Remaining legacy migration items: ${legacyCount}`,
-            `Remaining global/v2 migration items: ${globalCount}`,
-            'Run `n8nac workspace migrate --json` to inspect the remaining plan before retrying.',
-        ].join(' ');
-    }
     readWorkspaceConfigFile() {
         const configPath = this.getInstanceConfigPath();
         if (!fs.existsSync(configPath))
-            return { version: 3 };
+            return { version: 4, environmentTargets: [], environments: [] };
         const raw = JSON.parse(fs.readFileSync(configPath, 'utf8'));
         if (raw?.version === 4) {
             return this.sanitizeV4Config(raw);
         }
-        if (raw?.version !== undefined && raw.version !== 3) {
-            throw new Error(`Unsupported legacy n8n workspace config version: ${raw.version}`);
-        }
-        return { version: 3 };
-    }
-    readWorkspaceConfigFileSafe() {
-        try {
-            return this.ensureV4WorkspaceConfig();
-        }
-        catch {
-            return { version: 4, environmentTargets: [], environments: [] };
-        }
+        const version = raw?.version === undefined ? 'missing' : String(raw.version);
+        throw new Error(`Unsupported n8nac workspace config version: ${version}. Recreate a V4 workspace environment with \`n8nac env add <name> --base-url <url> --workflows-path workflows/<name>\`.`);
     }
     isWorkspaceConfigV4() {
         const configPath = this.getInstanceConfigPath();
@@ -1476,13 +739,10 @@ export class ConfigService {
         return raw?.version === 4;
     }
     assertLegacyWorkspaceOverridesWritable() {
-        if (this.isWorkspaceConfigV4()) {
-            throw new Error('This workspace uses v4 environments. Use `n8nac instance-target ...` and `n8nac env ...` instead of legacy workspace singleton commands.');
-        }
+        throw new Error('Legacy workspace singleton commands are not supported. Use `n8nac env ...` with V4 workspace environments.');
     }
     ensureV4WorkspaceConfig() {
-        const config = this.readWorkspaceConfigFile();
-        return config.version === 4 ? config : this.v3ToV4WorkspaceConfig();
+        return this.readWorkspaceConfigFile();
     }
     sanitizeV4Config(raw) {
         const rawTargets = Array.isArray(raw.environmentTargets) ? raw.environmentTargets : raw.instanceTargets;
@@ -1623,41 +883,6 @@ export class ConfigService {
             description: cleanOptional(environment.description),
         });
     }
-    v3ToV4WorkspaceConfig() {
-        const overrides = tryResolve(() => this.manager.readWorkspaceOverrides(this.workspaceRoot)) || { version: 3 };
-        const hasWorkspaceOverrides = Boolean(overrides.activeInstanceId
-            || overrides.syncFolder
-            || overrides.projectId
-            || overrides.projectName
-            || overrides.folderSync !== undefined
-            || overrides.customNodesPath);
-        const managedInstanceId = hasWorkspaceOverrides ? (overrides.activeInstanceId || this.manager.getGlobalConfig().activeInstanceId) : undefined;
-        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,
-                })]
-            : [];
-        return {
-            version: 4,
-            activeEnvironmentId: environments[0]?.id,
-            environmentTargets,
-            environments,
-        };
-    }
     writeWorkspaceConfigV4(config) {
         const configPath = this.getInstanceConfigPath();
         const sanitized = this.sanitizeV4Config({ ...config, version: 4 });
@@ -1722,14 +947,7 @@ 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 workflowsPath = this.resolveEnvironmentWorkflowsPath(environment);
             const syncFolder = workflowsPath;
             return {
                 environment,
@@ -1771,14 +989,7 @@ 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 workflowsPath = this.resolveEnvironmentWorkflowsPath(environment);
         const syncFolder = workflowsPath;
         return {
             environment,
@@ -2125,18 +1336,6 @@ export class ConfigService {
             instanceSeed,
         });
     }
-    writeWorkspaceFields(instanceId, config, setActive) {
-        const current = tryResolve(() => this.manager.readWorkspaceOverrides(this.workspaceRoot)) || { version: 3 };
-        this.manager.writeWorkspaceOverrides(this.workspaceRoot, {
-            ...current,
-            activeInstanceId: setActive ? instanceId : current.activeInstanceId,
-            syncFolder: config.syncFolder || current.syncFolder,
-            projectId: config.projectId || current.projectId,
-            projectName: config.projectName || current.projectName,
-            folderSync: config.folderSync ?? current.folderSync,
-            customNodesPath: config.customNodesPath || current.customNodesPath,
-        });
-    }
     assertNoLegacyWorkspaceFields(config) {
         const fields = [
             config.syncFolder ? 'syncFolder' : undefined,
@@ -2149,16 +1348,6 @@ export class ConfigService {
             throw new Error(`This workspace uses v4 environments. Configure ${fields.join(', ')} with \`n8nac env ...\` instead of legacy workspace fields.`);
         }
     }
-    resolveWorkspaceContext(instanceId) {
-        const context = this.manager.resolveEffectiveContext({
-            workspaceRoot: this.workspaceRoot,
-            instanceId,
-            syncFolderDefault: 'workspace',
-        });
-        return {
-            ...context,
-        };
-    }
     toInstanceProfile(instance, overrides) {
         return {
             id: instance.id,
@@ -2175,47 +1364,6 @@ export class ConfigService {
             verification: instance.verification,
         };
     }
-    contextToInstanceProfile(context) {
-        const instanceIdentifier = context.instanceIdentifier;
-        const instanceUserIdentifier = this.canonicalInstanceUserIdentifier(context.instanceUserIdentifier)
-            || this.readStoredInstanceUserIdentifier(context.instanceIdentifier);
-        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.workflowsPath
-                || context.workflowDir
-                || this.buildWorkflowDir(context.syncFolder, instanceIdentifier, context.projectName),
-            customNodesPath: context.customNodesPath,
-            folderSync: context.folderSync,
-        };
-    }
-    contextToLocalConfig(context) {
-        return this.toLocalConfig(this.contextToInstanceProfile(context));
-    }
-    toLocalConfig(profile) {
-        if (!profile)
-            return {};
-        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,
-            instanceIdentifier: profile.instanceIdentifier,
-            instanceUserIdentifier: profile.instanceUserIdentifier,
-            workflowDir,
-            customNodesPath: profile.customNodesPath,
-            folderSync: profile.folderSync,
-        });
-    }
     async verifyConnection(host, apiKey, client) {
         try {
             const resolvedClient = client ?? new N8nApiClient({ host, apiKey });
@@ -2249,34 +1397,6 @@ export class ConfigService {
             return host.replace(/\/$/, '');
         }
     }
-    getGlobalExternalInstanceUrl(instance) {
-        if (instance.mode === 'managed-local-docker' || instance.mode === 'generation-only')
-            return undefined;
-        const mode = String(instance.mode);
-        if (mode !== 'existing' && mode !== 'external-instance')
-            return undefined;
-        const compatibilityUrl = instance.url;
-        return cleanOptional(instance.baseUrl) || cleanOptional(compatibilityUrl);
-    }
-    preserveWorkspaceMigrationApiKeyFallback(fallback, migratedInstances) {
-        const apiKey = fallback?.apiKey?.trim();
-        if (!apiKey)
-            return;
-        const environment = this.resolveEnvironment();
-        const environmentHost = this.normalizeHost(environment.host || '');
-        if (!environmentHost)
-            return;
-        if (fallback?.host && this.normalizeHost(fallback.host) !== environmentHost)
-            return;
-        const migratedInstance = migratedInstances.find((instance) => this.normalizeHost(instance.host || '') === environmentHost);
-        this.saveLocalConfig({ host: environmentHost }, {
-            instanceId: migratedInstance?.id,
-            instanceName: environment.activeInstanceName || environment.environmentTargetName,
-            createNew: !migratedInstance?.id,
-            setActive: false,
-            apiKey,
-        });
-    }
     resolveStoredBaseUrl(current, requestedHost) {
         const host = requestedHost || current?.baseUrl;
         if (current?.baseUrl
@@ -2287,11 +1407,6 @@ export class ConfigService {
         }
         return host;
     }
-    buildWorkflowDir(syncFolder, instanceIdentifier, projectName) {
-        return syncFolder && instanceIdentifier && projectName
-            ? path.join(syncFolder, instanceIdentifier, createProjectSlug(projectName))
-            : undefined;
-    }
     resolveInputWorkflowsPath(input, environments, name) {
         const explicit = cleanOptional(input.workflowsPath) || cleanOptional(input.workflowDir);
         if (explicit)
@@ -2315,37 +1430,8 @@ export class ConfigService {
             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;
+    resolveEnvironmentWorkflowsPath(environment) {
+        return this.resolveWorkspacePath(cleanRequired(environment.workflowsPath, 'Workflows path'));
     }
     migrateWorkflowsPath(previousPath, nextPath) {
         const previous = this.resolveWorkspacePath(previousPath);
@@ -2381,31 +1467,6 @@ export class ConfigService {
             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);
         while (true) {