redhat-developer
diff --git a/‎src/devfile-registry/devfileRegistryWrapper.ts‎
Lines changed: 275 additions & 2 deletions b/‎src/devfile-registry/devfileRegistryWrapper.ts‎
Lines changed: 275 additions & 2 deletions
@@ -10,6 +10,68 @@ import { OdoPreference } from '../odo/odoPreference';
 import { ExecutionContext } from '../util/utils';
 import { DevfileData, DevfileInfo } from './devfileInfo';
 
+// Extension ID is used for cache directory naming
+// Using a constant allows easy updates if extension name changes
+const EXTENSION_CACHE_DIR = 'vs-openshift-tools';
+
+/**
+ * Get the base directory for devfile registry cache.
+ * Can be overridden via VSCODE_OPENSHIFT_CACHE_ROOT environment variable.
+ * Default: ~/.local/state/vs-openshift-tools/devfile-registry-cache
+ *
+ * Returns null if cache directory cannot be created or accessed.
+ */
+async function getDevfileCacheBaseDir(): Promise<string | null> {
+    const os = require('os');
+    const path = require('path');
+
+    // Get cache root - can be overridden via environment variable
+    // This allows the same env var to be used by tools.ts and other cache consumers
+    const cacheRoot = process.env.VSCODE_OPENSHIFT_CACHE_ROOT ||
+        path.join(os.homedir(), '.local', 'state');
+
+    const cacheDir = path.join(
+        cacheRoot,
+        EXTENSION_CACHE_DIR,
+        'devfile-registry-cache'
+    );
+
+    // Validate cache directory
+    try {
+        const fs = await import('fs/promises');
+
+        // Try to create the directory if it doesn't exist
+        await fs.mkdir(cacheDir, { recursive: true });
+
+        // Check if it's actually a directory
+        const stats = await fs.stat(cacheDir);
+        if (!stats.isDirectory()) {
+            // Path exists but is a file, not a directory - try fallback
+            const fallback = path.join(os.tmpdir(), EXTENSION_CACHE_DIR, 'devfile-registry-cache');
+            await fs.mkdir(fallback, { recursive: true });
+            return fallback;
+        }
+
+        // Test write permissions by creating a temporary test file
+        const testFile = path.join(cacheDir, '.write-test');
+        await fs.writeFile(testFile, '', 'utf-8');
+        await fs.unlink(testFile);
+
+        return cacheDir;
+    } catch (error) {
+        // Try fallback to temp directory
+        try {
+            const fallback = path.join(os.tmpdir(), EXTENSION_CACHE_DIR, 'devfile-registry-cache');
+            const fs = await import('fs/promises');
+            await fs.mkdir(fallback, { recursive: true });
+            return fallback;
+        } catch {
+            // No cache available - return null
+            return null;
+        }
+    }
+}
+
 export const DEVFILE_VERSION_LATEST: string = 'latest';
 
 /**
@@ -19,6 +81,7 @@ export class DevfileRegistry {
     private static instance: DevfileRegistry;
 
     private executionContext: ExecutionContext = new ExecutionContext();
+    private cacheWarningShown: boolean = false;
 
     public static get Instance(): DevfileRegistry {
         if (!DevfileRegistry.instance) {
@@ -157,7 +220,8 @@ export class DevfileRegistry {
             const options = { signal, timeout };
             let result: string = '';
             request(url, options, (response) => {
-                if (response.statusCode < 500) {
+                // Only accept 2xx status codes as success
+                if (response.statusCode >= 200 && response.statusCode < 300) {
                     response.on('data', (d) => {
                         result = result.concat(d);
                     });
@@ -170,7 +234,7 @@ export class DevfileRegistry {
                         }
                     });
                 } else {
-                    reject(new Error(`Connect error: ${response.statusMessage}`));
+                    reject(new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`));
                 }
             }).on('error', (e) => {
                 reject(new Error(`Connect error: ${e}`));
@@ -180,6 +244,215 @@ export class DevfileRegistry {
         });
     }
 
+    /**
+     * Download extra stack files (Dockerfile, Kubernetes manifests, etc.) referenced in the devfile.
+     * These files are stored in the devfile registry GitHub repository alongside the devfile.
+     *
+     * Files are cached in the filesystem to avoid repeated downloads.
+     *
+     * @param registryUrl Devfile Registry URL
+     * @param stackName Stack name (e.g., 'go', 'nodejs')
+     * @param version Stack version (e.g., '2.6.0')
+     * @param resolvedDevfile The resolved devfile (with parents merged)
+     * @param projectPath The project path where files should be written
+     * @returns Promise that resolves when all files are downloaded and written
+     * @throws Error if any file download or write fails
+     */
+    public async downloadStackExtraFiles(
+        registryUrl: string,
+        stackName: string,
+        version: string,
+        resolvedDevfile: any,
+        projectPath: string
+    ): Promise<void> {
+        const uriPaths = this.extractUriPaths(resolvedDevfile);
+
+        if (uriPaths.length === 0) {
+            return;
+        }
+
+        // Download and write each file, collecting any errors
+        const results = await Promise.allSettled(
+            uriPaths.map(async (uriPath) => {
+                const content = await this.getStackFile(registryUrl, stackName, version, uriPath);
+                if (!content) {
+                    throw new Error(`Failed to download ${uriPath} from ${stackName}:${version}`);
+                }
+                await this.writeStackFile(projectPath, uriPath, content);
+                return uriPath;
+            })
+        );
+
+        // Check for failures and report them
+        const failures = results.filter((r): r is PromiseRejectedResult => r.status === 'rejected');
+        if (failures.length > 0) {
+            const errorMessages = failures.map(f => f.reason?.message || String(f.reason)).join('; ');
+            throw new Error(`Failed to download ${failures.length} file(s): ${errorMessages}`);
+        }
+    }
+
+    /**
+     * Extract all URI paths from devfile components (dockerfile.uri, kubernetes.uri, etc.)
+     */
+    private extractUriPaths(devfile: any): string[] {
+        const uriPaths: string[] = [];
+
+        if (!devfile.components) {
+            return uriPaths;
+        }
+
+        for (const component of devfile.components) {
+            // Check for dockerfile uri in image components
+            if (component.image?.dockerfile?.uri) {
+                uriPaths.push(component.image.dockerfile.uri);
+            }
+
+            // Check for kubernetes/openshift uri
+            if (component.kubernetes?.uri) {
+                uriPaths.push(component.kubernetes.uri);
+            }
+
+            if (component.openshift?.uri) {
+                uriPaths.push(component.openshift.uri);
+            }
+        }
+
+        return uriPaths;
+    }
+
+    /**
+     * Get a stack file from cache or download from GitHub registry repository
+     * @throws Error if download fails
+     */
+    private async getStackFile(
+        registryUrl: string,
+        stackName: string,
+        version: string,
+        uriPath: string
+    ): Promise<string | null> {
+        const cacheKey = ExecutionContext.key(`stack-file:${registryUrl}:${stackName}:${version}:${uriPath}`);
+
+        // Check memory cache first
+        if (this.executionContext && this.executionContext.has(cacheKey)) {
+            return this.executionContext.get(cacheKey);
+        }
+
+        // Check filesystem cache
+        const cachedContent = await this.getFromFileCache(stackName, version, uriPath);
+        if (cachedContent) {
+            this.executionContext.set(cacheKey, cachedContent);
+            return cachedContent;
+        }
+
+        // Download from GitHub registry repository
+        try {
+            const content = await this.downloadFromRegistryRepo(stackName, version, uriPath);
+
+            // Cache in memory and filesystem
+            this.executionContext.set(cacheKey, content);
+            await this.saveToFileCache(stackName, version, uriPath, content);
+
+            return content;
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to download ${uriPath}: ${errorMessage}`);
+        }
+    }
+
+    /**
+     * Download a file from the devfile registry GitHub repository
+     */
+    private async downloadFromRegistryRepo(
+        stackName: string,
+        version: string,
+        uriPath: string
+    ): Promise<string> {
+        const url = `https://raw.githubusercontent.com/devfile/registry/main/stacks/${stackName}/${version}/${uriPath}`;
+        return DevfileRegistry._get(url);
+    }
+
+    /**
+     * Get cached file content from filesystem.
+     * Cache location can be overridden via VSCODE_OPENSHIFT_CACHE_ROOT env var.
+     * Default: ~/.local/state/vs-openshift-tools/devfile-registry-cache
+     */
+    private async getFromFileCache(
+        stackName: string,
+        version: string,
+        uriPath: string
+    ): Promise<string | null> {
+        try {
+            const fs = await import('fs/promises');
+            const path = await import('path');
+
+            const cacheBaseDir = await getDevfileCacheBaseDir();
+            if (!cacheBaseDir) {
+                // Warn user once that caching is unavailable
+                if (!this.cacheWarningShown) {
+                    this.cacheWarningShown = true;
+                    // eslint-disable-next-line no-console
+                    console.warn('[vscode-openshift-tools] Devfile registry cache is unavailable. Files will be downloaded without caching. Set VSCODE_OPENSHIFT_CACHE_ROOT to a writable directory to enable caching.');
+                }
+                return null;
+            }
+
+            const cacheDir = path.join(cacheBaseDir, stackName, version);
+            const filePath = path.join(cacheDir, uriPath);
+
+            const content = await fs.readFile(filePath, 'utf-8');
+            return content;
+        } catch {
+            return null;
+        }
+    }
+
+    /**
+     * Save file content to filesystem cache.
+     * Cache location can be overridden via VSCODE_OPENSHIFT_CACHE_ROOT env var.
+     * Default: ~/.local/state/vs-openshift-tools/devfile-registry-cache
+     */
+    private async saveToFileCache(
+        stackName: string,
+        version: string,
+        uriPath: string,
+        content: string
+    ): Promise<void> {
+        try {
+            const fs = await import('fs/promises');
+            const path = await import('path');
+
+            const cacheBaseDir = await getDevfileCacheBaseDir();
+            if (!cacheBaseDir) {
+                // No cache available - silently skip (warning already shown in getFromFileCache)
+                return;
+            }
+
+            const cacheDir = path.join(cacheBaseDir, stackName, version);
+            const filePath = path.join(cacheDir, uriPath);
+
+            await fs.mkdir(path.dirname(filePath), { recursive: true });
+            await fs.writeFile(filePath, content, 'utf-8');
+        } catch {
+            // Ignore cache write errors - cache is optional
+        }
+    }
+
+    /**
+     * Write a stack file to the project directory
+     */
+    private async writeStackFile(
+        projectPath: string,
+        uriPath: string,
+        content: string
+    ): Promise<void> {
+        const fs = await import('fs/promises');
+        const path = await import('path');
+
+        const fullPath = path.join(projectPath, uriPath);
+        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+        await fs.writeFile(fullPath, content, 'utf-8');
+    }
+
     /**
      * Clears the Execution context as well as all cached data
      */