@gen3/workspaces 0.12.71 → 0.12.72

package/dist/server/esm/server.js

@@ -1,6 +1,8 @@
 import { GEN3_API, GEN3_WORKSPACE_API, GEN3_FENCE_SERVICE, fetchFence, GEN3_COMMONS_NAME } from '@gen3/core';
 import nodePath from 'path';
 import fs from 'fs';
+import http from 'http';
+import https from 'https';
 import { getCookie } from 'cookies-next';
 import { GEN3_FENCE_API } from '@gen3/core/server';
 import { getAccessToken } from '@gen3/frontend/server';
@@ -11,6 +13,134 @@ process.env.GEN3_KERNEL_API || `${GEN3_API}/lw-workspace/proxy/jeg-panel/api`;
 process.env.JEG_GATEWAY_API || `${GEN3_API}/lw-workspace/proxy/jeg-panel/api`;
 const JEG_SERVICE_API = 'http://jupyter-enterprise-gateway.jupyter-pods.svc.cluster.local:8888';
 
+/**
+ * Shared HTTP proxy utility for server-side proxy handlers.
+ * Streams request body through and forwards response status + body.
+ *
+ * Also exports two token helpers used by the proxy factories:
+ *  - extractTokenFallback: minimal cookie/header extraction used when the host
+ *    app has not injected its own getToken (standalone / test use).
+ *  - decodeJwtClaims: base64url decode of the JWT payload for REMOTE_USER header.
+ *    Crypto verification is Ambassador's job — we only need the sub/username claim.
+ */ /**
+ * Minimal JWT extraction fallback — used only when the host app does not inject
+ * its own getToken. Prefers Authorization: Bearer, then access_token cookie.
+ * In gen3-vectis production this is never reached — getAccessToken is always wired.
+ */ function extractTokenFallback(req) {
+    const auth = req.headers['authorization'];
+    if (typeof auth === 'string' && auth.startsWith('Bearer ')) {
+        return auth.slice(7).trim() || null;
+    }
+    const cookie = req.headers['cookie'] ?? '';
+    const m = cookie.match(/(?:^|;\s*)access_token=([^;]+)/);
+    return m ? decodeURIComponent(m[1]).trim() || null : null;
+}
+/**
+ * Decode JWT payload claims without cryptographic verification.
+ * Ambassador has already verified the RS256 signature — we just need the sub claim
+ * to set the REMOTE_USER header for per-user isolation enforcement downstream.
+ */ // Maximum JWT string length accepted before base64 decoding.
+// GA4GH RAS Passport JWTs embed multiple signed Visa JWTs as claims, so the
+// outer passport can easily exceed 8 KiB (50 visas × ~2 KB each ≈ 136 KB encoded).
+// 512 KiB covers the most complex real-world passports while still guarding against
+// crafted JWTs designed to exhaust server memory.  Ambassador has already verified
+// the RS256 signature — this cap only defends the local base64/JSON decode step.
+const MAX_JWT_LENGTH = 524288; // 512 KiB
+function decodeJwtClaims(jwt) {
+    if (jwt.length > MAX_JWT_LENGTH) return null;
+    try {
+        const parts = jwt.split('.');
+        if (parts.length < 2) return null;
+        const padded = parts[1].replace(/-/g, '+').replace(/_/g, '/').padEnd(Math.ceil(parts[1].length / 4) * 4, '=');
+        return JSON.parse(Buffer.from(padded, 'base64').toString('utf8'));
+    } catch  {
+        return null;
+    }
+}
+async function createProxyRequest({ req, res, targetUrl, method, extraHeaders = {}, forwardBody = false }) {
+    const headers = {
+        ...extraHeaders
+    };
+    if (forwardBody && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
+        headers['Content-Type'] ??= 'application/json';
+    }
+    let body;
+    if (forwardBody && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
+        let buf;
+        try {
+            buf = await bufferBody(req);
+        } catch (err) {
+            const statusCode = err.statusCode ?? 400;
+            const msg = err instanceof Error ? err.message : 'Bad request';
+            res.status(statusCode).json({
+                error: msg
+            });
+            return;
+        }
+        // Node.js Buffer is a Uint8Array subclass; cast to silence DOM BodyInit mismatch
+        body = buf;
+        if (buf.length > 0) {
+            headers['Content-Length'] = String(buf.length);
+        }
+    }
+    let upRes;
+    try {
+        upRes = await fetch(targetUrl, {
+            method,
+            headers,
+            body,
+            signal: AbortSignal.timeout(30_000)
+        });
+    } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        res.status(502).json({
+            error: `Upstream unreachable: ${msg}`
+        });
+        return;
+    }
+    // Forward status and content-type
+    const contentType = upRes.headers.get('content-type') || 'application/json';
+    res.setHeader('Content-Type', contentType);
+    if (upRes.status === 204 || upRes.status === 304) {
+        res.status(upRes.status).end();
+        return;
+    }
+    // Do not forward raw upstream error bodies — they may contain stack traces or
+    // internal hostnames. Log them server-side (CloudWatch) and return a generic message.
+    if (upRes.status >= 500) {
+        const errBody = await upRes.text().catch(()=>'');
+        console.error('[proxy] upstream %d from %s: %s', upRes.status, targetUrl, errBody);
+        res.status(502).json({
+            error: 'Upstream service error.'
+        });
+        return;
+    }
+    const responseBody = await upRes.text();
+    res.status(upRes.status).send(responseBody);
+}
+// Maximum request body size accepted by the proxy (1 MiB).
+// Prevents memory exhaustion from oversized payloads before any business logic runs.
+const MAX_BODY_BYTES = 1 * 1024 * 1024;
+function bufferBody(req) {
+    return new Promise((resolve, reject)=>{
+        const chunks = [];
+        let total = 0;
+        req.on('data', (chunk)=>{
+            total += chunk.length;
+            if (total > MAX_BODY_BYTES) {
+                req.destroy();
+                reject(Object.assign(new Error('Request body too large'), {
+                    statusCode: 413
+                }));
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on('end', ()=>resolve(Buffer.concat(chunks)));
+        req.on('error', reject);
+    });
+}
+
 const MAX_FILE_SIZE_BYTES = 67108864; // 64 * 1024 * 1024
 // ---------- constants ----------
 const ALLOWED_TIERS = new Set([
@@ -36,6 +166,14 @@ const MIME_TYPES = {
     '.ipynb': 'application/json; charset=utf-8'
 };
 const DEFAULT_FULL_THEMES_URL = '/workspace-api/workspace-assets/remote/build/themes';
+/**
+ * First path segments that identify server extension REST APIs (not static assets).
+ * Requests whose first segment matches one of these are proxied to
+ * `serverExtensionProxyPath` when that option is configured for the remote tier.
+ */ const SERVER_EXTENSION_PREFIXES = new Set([
+    'module',
+    'server-proxy'
+]);
 const REMOTE_DISABLED_EXTENSIONS = [
     '@jupyterlite/services-extension:config-section-manager',
     '@jupyterlite/services-extension:default-drive',
@@ -176,6 +314,98 @@ function injectBranding(html, branding) {
     });
     return replaceTitle(result, branding);
 }
+// ---------- server-extension proxy ----------
+function readBody$2(req) {
+    return new Promise((resolve, reject)=>{
+        const chunks = [];
+        req.on('data', (chunk)=>chunks.push(chunk));
+        req.on('end', ()=>resolve(Buffer.concat(chunks)));
+        req.on('error', reject);
+    });
+}
+async function proxyServerExtension(req, res, targetUrl, getToken) {
+    const forwardHeaders = {};
+    for (const [key, value] of Object.entries(req.headers)){
+        if (!value) continue;
+        const lower = key.toLowerCase();
+        if (lower === 'host' || lower === 'content-length' || lower === 'transfer-encoding') continue;
+        forwardHeaders[key] = Array.isArray(value) ? value.join(',') : value;
+    }
+    // Inject identity headers so workspace-proxy auth passes.
+    // Direct server-side calls bypass nginx (which normally injects X-Gen3-User-ID /
+    // REMOTE_USER from the validated access_token), so we must add them explicitly.
+    // only add in production mode
+    // TODO: refactor this to handle development mode better
+    if (process.env.NODE_ENV === 'production') {
+        const jwt = getToken ? getToken(req) : extractTokenFallback(req);
+        if (jwt) {
+            const claims = decodeJwtClaims(jwt);
+            const rawUsername = claims?.sub ?? claims?.preferred_username ?? claims?.username;
+            if (typeof rawUsername === 'string') {
+                const safeUsername = rawUsername.replace(/[\r\n]/g, '');
+                const safeJwt = jwt.replace(/[\r\n]/g, '');
+                forwardHeaders['Authorization'] = `Bearer ${safeJwt}`;
+                forwardHeaders['REMOTE_USER'] = safeUsername;
+                forwardHeaders['X-Gen3-User-ID'] = safeUsername;
+            }
+        }
+    }
+    const method = (req.method || 'GET').toUpperCase();
+    let body;
+    if (![
+        'GET',
+        'HEAD'
+    ].includes(method)) {
+        try {
+            body = await readBody$2(req);
+        } catch  {
+            res.status(500).end('Failed to read request body');
+            return;
+        }
+        if (body?.length) {
+            forwardHeaders['content-length'] = String(body.length);
+        }
+    }
+    console.log('[workspace-assets] proxying extension API to', targetUrl);
+    await new Promise((resolve)=>{
+        const parsed = new URL(targetUrl);
+        const transport = parsed.protocol === 'https:' ? https : http;
+        const reqOptions = {
+            method,
+            hostname: parsed.hostname,
+            port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
+            path: parsed.pathname + parsed.search,
+            headers: forwardHeaders
+        };
+        const proxyReq = transport.request(reqOptions, (proxyRes)=>{
+            res.status(proxyRes.statusCode ?? 502);
+            const skip = new Set([
+                'transfer-encoding',
+                'content-length'
+            ]);
+            for (const [key, value] of Object.entries(proxyRes.headers)){
+                if (!skip.has(key.toLowerCase()) && value !== undefined) {
+                    res.setHeader(key, value);
+                }
+            }
+            proxyRes.pipe(res, {
+                end: true
+            });
+            proxyRes.on('end', resolve);
+        });
+        proxyReq.on('error', (err)=>{
+            console.error('[workspace-assets] extension proxy failed for', targetUrl, err.message);
+            if (!res.headersSent) {
+                res.status(502).end('Extension proxy unreachable');
+            }
+            resolve();
+        });
+        if (body?.length) {
+            proxyReq.write(body);
+        }
+        proxyReq.end();
+    });
+}
 // ---------- factory ----------
 function createWorkspaceAssetsHandler(options) {
     const gatewayBaseUrl = options?.gatewayBaseUrl ?? process.env.JUPYTER_GATEWAY_BASE_URL ?? '/api/workspace/gateway/';
@@ -191,6 +421,9 @@ function createWorkspaceAssetsHandler(options) {
         faviconUrl: options.faviconUrl,
         pageTitle: options.pageTitle
     } : undefined;
+    const serverExtensionProxyPath = options?.serverExtensionProxyPath;
+    const serverExtensionProxyBaseUrl = options?.serverExtensionProxyBaseUrl;
+    const getToken = options?.getToken;
     const remoteInjectionConfig = {
         gatewayBaseUrl,
         disabledExtensions,
@@ -249,6 +482,21 @@ function createWorkspaceAssetsHandler(options) {
             }
             safeSegments.push(nodePath.basename(seg));
         }
+        // Proxy server extension API calls (e.g. jupyterlmod /module/*, jupyter-server-proxy
+        // /server-proxy/*) to the configured upstream rather than attempting a static file
+        // lookup, which would always 404.
+        if (tier === 'remote' && serverExtensionProxyPath && safeSegments.length > 0 && SERVER_EXTENSION_PREFIXES.has(safeSegments[0])) {
+            const extensionPath = safeSegments.join('/');
+            const rawQuery = req.url?.split('?')[1];
+            const qs = rawQuery ? `?${rawQuery}` : '';
+            const proxyBase = serverExtensionProxyBaseUrl ?? (()=>{
+                const { proto, host } = resolveOrigin(req);
+                return `${proto}://${host}`;
+            })();
+            const targetUrl = `${proxyBase}${serverExtensionProxyPath}/${extensionPath}${qs}`;
+            console.log('[workspace-assets] proxying extension API to', targetUrl);
+            return proxyServerExtension(req, res, targetUrl, getToken);
+        }
         const allowedFiles = allowedFilesByTier[tier];
         const candidatePath = nodePath.resolve(tierRoot, ...safeSegments);
         const candidateIndex = nodePath.join(candidatePath, 'index.html');
@@ -402,134 +650,6 @@ function withJupyterWorkspaces(nextConfig, options) {
     };
 }
 
-/**
- * Shared HTTP proxy utility for server-side proxy handlers.
- * Streams request body through and forwards response status + body.
- *
- * Also exports two token helpers used by the proxy factories:
- *  - extractTokenFallback: minimal cookie/header extraction used when the host
- *    app has not injected its own getToken (standalone / test use).
- *  - decodeJwtClaims: base64url decode of the JWT payload for REMOTE_USER header.
- *    Crypto verification is Ambassador's job — we only need the sub/username claim.
- */ /**
- * Minimal JWT extraction fallback — used only when the host app does not inject
- * its own getToken. Prefers Authorization: Bearer, then access_token cookie.
- * In gen3-vectis production this is never reached — getAccessToken is always wired.
- */ function extractTokenFallback(req) {
-    const auth = req.headers['authorization'];
-    if (typeof auth === 'string' && auth.startsWith('Bearer ')) {
-        return auth.slice(7).trim() || null;
-    }
-    const cookie = req.headers['cookie'] ?? '';
-    const m = cookie.match(/(?:^|;\s*)access_token=([^;]+)/);
-    return m ? decodeURIComponent(m[1]).trim() || null : null;
-}
-/**
- * Decode JWT payload claims without cryptographic verification.
- * Ambassador has already verified the RS256 signature — we just need the sub claim
- * to set the REMOTE_USER header for per-user isolation enforcement downstream.
- */ // Maximum JWT string length accepted before base64 decoding.
-// GA4GH RAS Passport JWTs embed multiple signed Visa JWTs as claims, so the
-// outer passport can easily exceed 8 KiB (50 visas × ~2 KB each ≈ 136 KB encoded).
-// 512 KiB covers the most complex real-world passports while still guarding against
-// crafted JWTs designed to exhaust server memory.  Ambassador has already verified
-// the RS256 signature — this cap only defends the local base64/JSON decode step.
-const MAX_JWT_LENGTH = 524288; // 512 KiB
-function decodeJwtClaims(jwt) {
-    if (jwt.length > MAX_JWT_LENGTH) return null;
-    try {
-        const parts = jwt.split('.');
-        if (parts.length < 2) return null;
-        const padded = parts[1].replace(/-/g, '+').replace(/_/g, '/').padEnd(Math.ceil(parts[1].length / 4) * 4, '=');
-        return JSON.parse(Buffer.from(padded, 'base64').toString('utf8'));
-    } catch  {
-        return null;
-    }
-}
-async function createProxyRequest({ req, res, targetUrl, method, extraHeaders = {}, forwardBody = false }) {
-    const headers = {
-        ...extraHeaders
-    };
-    if (forwardBody && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
-        headers['Content-Type'] ??= 'application/json';
-    }
-    let body;
-    if (forwardBody && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
-        let buf;
-        try {
-            buf = await bufferBody(req);
-        } catch (err) {
-            const statusCode = err.statusCode ?? 400;
-            const msg = err instanceof Error ? err.message : 'Bad request';
-            res.status(statusCode).json({
-                error: msg
-            });
-            return;
-        }
-        // Node.js Buffer is a Uint8Array subclass; cast to silence DOM BodyInit mismatch
-        body = buf;
-        if (buf.length > 0) {
-            headers['Content-Length'] = String(buf.length);
-        }
-    }
-    let upRes;
-    try {
-        upRes = await fetch(targetUrl, {
-            method,
-            headers,
-            body,
-            signal: AbortSignal.timeout(30_000)
-        });
-    } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        res.status(502).json({
-            error: `Upstream unreachable: ${msg}`
-        });
-        return;
-    }
-    // Forward status and content-type
-    const contentType = upRes.headers.get('content-type') || 'application/json';
-    res.setHeader('Content-Type', contentType);
-    if (upRes.status === 204 || upRes.status === 304) {
-        res.status(upRes.status).end();
-        return;
-    }
-    // Do not forward raw upstream error bodies — they may contain stack traces or
-    // internal hostnames. Log them server-side (CloudWatch) and return a generic message.
-    if (upRes.status >= 500) {
-        const errBody = await upRes.text().catch(()=>'');
-        console.error('[proxy] upstream %d from %s: %s', upRes.status, targetUrl, errBody);
-        res.status(502).json({
-            error: 'Upstream service error.'
-        });
-        return;
-    }
-    const responseBody = await upRes.text();
-    res.status(upRes.status).send(responseBody);
-}
-// Maximum request body size accepted by the proxy (1 MiB).
-// Prevents memory exhaustion from oversized payloads before any business logic runs.
-const MAX_BODY_BYTES = 1 * 1024 * 1024;
-function bufferBody(req) {
-    return new Promise((resolve, reject)=>{
-        const chunks = [];
-        let total = 0;
-        req.on('data', (chunk)=>{
-            total += chunk.length;
-            if (total > MAX_BODY_BYTES) {
-                req.destroy();
-                reject(Object.assign(new Error('Request body too large'), {
-                    statusCode: 413
-                }));
-                return;
-            }
-            chunks.push(chunk);
-        });
-        req.on('end', ()=>resolve(Buffer.concat(chunks)));
-        req.on('error', reject);
-    });
-}
-
 /* ------------------------------------------------------------------ */ /*  Default billing sink — structured CloudWatch-compatible JSON log   */ /* ------------------------------------------------------------------ */ function defaultBillingSink(event) {
     // CloudWatch Logs Insights picks up structured JSON automatically
     process.stdout.write(JSON.stringify({
@@ -1057,7 +1177,16 @@ const DEFAULT_OPTIONS = {
     // launches/channels to the container; GPU kernel launches are gated (403)
     // with a message to use the Kernel Panel.
     remoteKernelsPath: '/lw-workspace/proxy/jeg-proxy',
-    // The remote tier attaches to a real kernel gateway, so JupyterLite's
+    // Proxy server extension REST calls (jupyterlmod /module/*, jupyter-server-proxy
+    // /server-proxy/*) to jeg-proxy. These calls originate from JupyterLab extensions
+    // in the remote build and resolve relative to the JupyterLite base URL, which points
+    // at this static-file handler — without a proxy they always 404.
+    serverExtensionProxyPath: '/lw-workspace/proxy',
+    // Optional internal k8s service base URL for the extension proxy. When set,
+    // proxy requests target this address directly instead of routing through the
+    // ingress (avoiding self-signed-cert issues). Readable from the JSON config
+    // file or the WORKSPACE_EXTENSION_PROXY_BASE_URL env var.
+    serverExtensionProxyBaseUrl: 'http://workspace-proxy-service:8080',
     // in-browser Pyodide kernel must not be offered alongside it.
     additionalDisabledExtensions: [
         '@jupyterlite/pyodide-kernel-extension:kernel'
@@ -1071,7 +1200,9 @@ const STRING_OPTIONS = [
     'faviconUrl',
     'pageTitle',
     'remoteKernelsPath',
-    'fullThemesUrl'
+    'fullThemesUrl',
+    'serverExtensionProxyPath',
+    'serverExtensionProxyBaseUrl'
 ];
 function configFilePath() {
     return nodePath.resolve(process.cwd(), CONFIG_ROOT, GEN3_COMMONS_NAME, CONFIG_FILENAME);