@portel/photon 1.32.6 → 1.33.1

package/dist/server.js

@@ -26,11 +26,27 @@ import { pingDaemon } from './daemon/client.js';
 import { ensureDaemon } from './daemon/manager.js';
 import { ChannelManager, } from './channel-manager.js';
 import { PhotonDocExtractor } from './photon-doc-extractor.js';
-import { isLocalRequest, readBody, setSecurityHeaders, getCorsOrigin } from './shared/security.js';
+import { isLocalRequest, setSecurityHeaders, getCorsOrigin } from './shared/security.js';
 import { audit } from './shared/audit.js';
 import { TaskExecutor } from './task-executor.js';
 import { CapabilityNegotiator } from './capability-negotiator.js';
 import { ResourceServer, SubscriptionRegistry, } from './resource-server.js';
+import { verifyPhotonAuthToken } from './auth/mcp-jwt.js';
+import { loadPhotonAuth } from './cli/commands/auth.js';
+let cachedJwtProfile = null;
+async function loadJwtProfile(name) {
+    if (cachedJwtProfile && cachedJwtProfile.name === name) {
+        return { issuer: cachedJwtProfile.issuer, jwks: cachedJwtProfile.jwks };
+    }
+    try {
+        const loaded = await loadPhotonAuth(name);
+        cachedJwtProfile = { name, issuer: loaded.issuer.issuer, jwks: loaded.jwks };
+        return { issuer: loaded.issuer.issuer, jwks: loaded.jwks };
+    }
+    catch {
+        return null;
+    }
+}
 export class HotReloadDisabledError extends Error {
     constructor(message) {
         super(message);
@@ -209,6 +225,38 @@ function findFreePort(preferred = 0) {
         srv.on('error', reject);
     });
 }
+function localMcpAuthMode() {
+    return process.env.PHOTON_MCP_AUTH_MODE || (process.env.PHOTON_MCP_BEARER ? 'bearer' : 'legacy');
+}
+function authHeaderToken(req) {
+    const header = req.headers.authorization ?? '';
+    const match = Array.isArray(header)
+        ? header[0]?.match(/^Bearer\s+(.+)$/i)
+        : header.match(/^Bearer\s+(.+)$/i);
+    return match ? match[1].trim() : null;
+}
+function unauthorizedJson(res, id, status, code, message, reason, wwwAuthenticate, corsOrigin) {
+    const headers = {
+        'Content-Type': 'application/json',
+        'WWW-Authenticate': wwwAuthenticate,
+    };
+    if (corsOrigin)
+        headers['Access-Control-Allow-Origin'] = corsOrigin;
+    res.writeHead(status, headers);
+    res.end(JSON.stringify({
+        jsonrpc: '2.0',
+        id: id ?? null,
+        error: { code, message, data: { reason } },
+    }));
+}
+function mcpTokenMatches(actual, expected) {
+    if (!actual || !expected)
+        return false;
+    const actualBytes = Buffer.from(actual);
+    const expectedBytes = Buffer.from(expected);
+    return (actualBytes.length === expectedBytes.length &&
+        crypto.timingSafeEqual(actualBytes, expectedBytes));
+}
 class BeamCompatTransport {
     photonName;
     photonMeta;
@@ -220,6 +268,8 @@ class BeamCompatTransport {
     pendingResponse = null;
     /** Sub-photons whose tools are injected into tools/list alongside the main photon. */
     subPhotons = [];
+    /** Main photon tools, mirrored so auth can enforce scopes before dispatch. */
+    mainTools = [];
     /** Callback to execute a tool on a sub-photon by name. */
     subPhotonExecutor;
     constructor(photonName, photonMeta) {
@@ -300,6 +350,18 @@ class BeamCompatTransport {
             this.sseResponse.write(`event: message\nid: ${id}\ndata: ${JSON.stringify(message)}\n\n`);
         }
     }
+    requiredScopesForTool(fullToolName) {
+        const slashIdx = fullToolName.indexOf('/');
+        const targetPhoton = slashIdx === -1 ? this.photonName : fullToolName.slice(0, slashIdx);
+        const methodName = slashIdx === -1 ? fullToolName : fullToolName.slice(slashIdx + 1);
+        const tools = targetPhoton === this.photonName
+            ? this.mainTools
+            : this.subPhotons.find((sub) => sub.name === targetPhoton)?.tools;
+        const scopes = tools?.find((tool) => tool.name === methodName)?.scopes;
+        return Array.isArray(scopes)
+            ? scopes.filter((scope) => typeof scope === 'string')
+            : [];
+    }
     async handleHTTP(req, res, url) {
         const corsOrigin = getCorsOrigin(req);
         // GET — open SSE stream for server-to-client notifications
@@ -357,6 +419,66 @@ class BeamCompatTransport {
                 res.end(JSON.stringify({ error: 'Invalid JSON' }));
                 return;
             }
+            const authMode = localMcpAuthMode();
+            const dispatchesUserCode = parsed?.method === 'tools/call';
+            const requiredScopes = dispatchesUserCode && typeof parsed?.params?.name === 'string'
+                ? this.requiredScopesForTool(parsed.params.name)
+                : [];
+            let jwtClaims;
+            if (dispatchesUserCode && authMode === 'jwt') {
+                let jwks = null;
+                let issuer;
+                const profileName = process.env.PHOTON_MCP_JWT_PROFILE;
+                if (profileName) {
+                    const profile = await loadJwtProfile(profileName);
+                    if (profile) {
+                        issuer = profile.issuer;
+                        jwks = profile.jwks;
+                    }
+                }
+                else {
+                    try {
+                        jwks = process.env.PHOTON_MCP_JWT_JWKS
+                            ? JSON.parse(process.env.PHOTON_MCP_JWT_JWKS)
+                            : null;
+                    }
+                    catch {
+                        jwks = null;
+                    }
+                    issuer = process.env.PHOTON_MCP_JWT_ISSUER;
+                }
+                const audience = process.env.PHOTON_MCP_JWT_AUDIENCE;
+                if (!issuer || !audience || !jwks) {
+                    unauthorizedJson(res, parsed.id, 401, -32001, 'Unauthorized', 'missing_token', 'Bearer realm="photon", error="invalid_token"', corsOrigin);
+                    return;
+                }
+                const result = verifyPhotonAuthToken(authHeaderToken(req), {
+                    issuer,
+                    audience,
+                    jwks,
+                    requiredScopes,
+                });
+                if (!result.ok) {
+                    const insufficientScope = result.reason === 'insufficient_scope';
+                    unauthorizedJson(res, parsed.id, insufficientScope ? 403 : 401, insufficientScope ? -32003 : -32001, insufficientScope ? 'Forbidden' : 'Unauthorized', result.reason, insufficientScope
+                        ? `Bearer realm="photon", error="insufficient_scope", scope="${requiredScopes.join(' ')}"`
+                        : 'Bearer realm="photon", error="invalid_token"', corsOrigin);
+                    return;
+                }
+                jwtClaims = result.claims;
+            }
+            else if (dispatchesUserCode && authMode === 'bearer') {
+                const expected = process.env.PHOTON_MCP_BEARER;
+                const token = authHeaderToken(req);
+                if (!mcpTokenMatches(token, expected)) {
+                    unauthorizedJson(res, parsed.id, 401, -32001, 'Unauthorized', !expected
+                        ? 'Authorization: Bearer <token> header missing'
+                        : token
+                            ? 'bearer token does not match PHOTON_MCP_BEARER'
+                            : 'Authorization: Bearer <token> header missing', 'Bearer realm="photon"', corsOrigin);
+                    return;
+                }
+            }
             // Transform incoming tools/call: strip photonName/ prefix from tool name
             // and route sub-photon calls directly
             if (parsed.method === 'tools/call' && parsed.params?.name) {
@@ -411,11 +533,16 @@ class BeamCompatTransport {
             // claims ride on the SDK's MessageExtraInfo.authInfo.extra, which
             // the protocol layer propagates to setRequestHandler's `extra` arg.
             const { extractClaimsFromHeaders } = await import('./shared/extract-claims.js');
-            const claims = extractClaimsFromHeaders(req.headers);
+            const claims = jwtClaims ?? extractClaimsFromHeaders(req.headers);
             const messageExtra = claims
                 ? {
                     sessionId: this.sessionId,
-                    authInfo: { token: '', clientId: '', scopes: [], extra: claims },
+                    authInfo: {
+                        token: '',
+                        clientId: typeof claims.client_id === 'string' ? claims.client_id : '',
+                        scopes: typeof claims.scope === 'string' ? claims.scope.split(/\s+/) : [],
+                        extra: claims,
+                    },
                 }
                 : { sessionId: this.sessionId };
             // Notifications have no id — fire-and-forget
@@ -1045,6 +1172,8 @@ export class PhotonServer {
                 toolDef['x-output-format'] = schema.outputFormat;
             if (schema.layoutHints)
                 toolDef['x-layout-hints'] = schema.layoutHints;
+            if (schema.scopes)
+                toolDef.scopes = schema.scopes;
             if (schema.buttonLabel)
                 toolDef['x-button-label'] = schema.buttonLabel;
             if (schema.icon)
@@ -1307,11 +1436,22 @@ export class PhotonServer {
         const tool = targetMcp.tools.find((t) => t.name === toolName);
         const outputFormat = tool?.outputFormat;
         const startTime = Date.now();
+        const claims = extra?.authInfo?.extra;
+        const caller = claims && typeof claims.sub === 'string'
+            ? {
+                id: claims.sub,
+                name: typeof claims.name === 'string' ? claims.name : undefined,
+                anonymous: false,
+                scope: typeof claims.scope === 'string' ? claims.scope : undefined,
+                claims,
+            }
+            : undefined;
         const result = await this.loader.executeTool(targetMcp, toolName, args || {}, {
             inputProvider,
             outputHandler,
             samplingProvider,
             roots: this.rootsByServer.get(ctx.server),
+            caller,
         });
         const durationMs = Date.now() - startTime;
         const transport = this.options.transport || 'stdio';
@@ -2234,23 +2374,51 @@ export class PhotonServer {
         if (!ui?.resolvedPath)
             return false;
         try {
-            let content;
-            if (ui.resolvedPath.endsWith('.tsx')) {
-                const { compileTsxCached } = await import('./tsx-compiler.js');
-                content = await compileTsxCached(ui.resolvedPath);
-            }
-            else {
-                content = await readText(ui.resolvedPath);
+            // Non-.tsx assets: serve the file as-is (unchanged behaviour).
+            if (!ui.resolvedPath.endsWith('.tsx')) {
+                const content = await readText(ui.resolvedPath);
+                const uiHeaders = { 'Content-Type': 'text/html' };
+                if (corsOrigin)
+                    uiHeaders['Access-Control-Allow-Origin'] = corsOrigin;
+                if (detectIsolationMode(req) === 'standalone') {
+                    uiHeaders['Cross-Origin-Opener-Policy'] = 'same-origin';
+                    uiHeaders['Cross-Origin-Embedder-Policy'] = 'require-corp';
+                }
+                res.writeHead(200, uiHeaders);
+                res.end(content);
+                return true;
+            }
+            const { compileTsxCached, tsxHttpResponse } = await import('./tsx-compiler.js');
+            const compiled = await compileTsxCached(ui.resolvedPath);
+            // This mount doubles as the SPA fallback (any unmatched GET), so the
+            // browser's relative `./<hash>.js` request may arrive at an arbitrary
+            // depth. The hashed filename is unique, so match it by basename to
+            // serve the immutable bundle; everything else gets the shell.
+            const reqPath = (req.url ?? '').split('?')[0];
+            const lastSeg = decodeURIComponent(reqPath.slice(reqPath.lastIndexOf('/') + 1));
+            const restPath = compiled.jsFileName && lastSeg === compiled.jsFileName ? lastSeg : '';
+            const r = tsxHttpResponse(compiled, restPath);
+            // Cheap revalidation: 304 when the shell hash is unchanged.
+            const inm = req.headers['if-none-match'];
+            if (r.headers['ETag'] && inm && inm === r.headers['ETag']) {
+                const notMod = { ETag: r.headers['ETag'] };
+                if (corsOrigin)
+                    notMod['Access-Control-Allow-Origin'] = corsOrigin;
+                res.writeHead(304, notMod);
+                res.end();
+                return true;
             }
-            const uiHeaders = { 'Content-Type': 'text/html' };
+            const uiHeaders = { ...r.headers };
             if (corsOrigin)
                 uiHeaders['Access-Control-Allow-Origin'] = corsOrigin;
-            if (detectIsolationMode(req) === 'standalone') {
+            if (!restPath && detectIsolationMode(req) === 'standalone') {
                 uiHeaders['Cross-Origin-Opener-Policy'] = 'same-origin';
                 uiHeaders['Cross-Origin-Embedder-Policy'] = 'require-corp';
             }
-            res.writeHead(200, uiHeaders);
-            res.end(content);
+            if (restPath)
+                uiHeaders['Cross-Origin-Resource-Policy'] = 'same-origin';
+            res.writeHead(r.status, uiHeaders);
+            res.end(r.body);
             return true;
         }
         catch {
@@ -2285,6 +2453,12 @@ export class PhotonServer {
             });
             this.capabilityNegotiator.interceptTransportForRawCapabilities(beamTransport, this.server, (msg) => this.channelManager.interceptPermissionRequest(msg));
             await this.server.connect(beamTransport);
+            beamTransport.mainTools = (this.mcp?.tools || [])
+                .filter((t) => !t.internal)
+                .map((t) => ({
+                name: t.name,
+                scopes: Array.isArray(t.scopes) ? t.scopes : [],
+            }));
             // Wire sub-photons: collect all loaded photons except the main one
             const mainName = this.mcp?.name || 'photon';
             const allLoaded = this.loader.getLoadedPhotons();
@@ -2308,6 +2482,7 @@ export class PhotonServer {
                         name: t.name,
                         description: t.description || '',
                         inputSchema: t.inputSchema,
+                        ...(Array.isArray(t.scopes) ? { scopes: t.scopes } : {}),
                         ...(linkedUI ? { linkedUi: linkedUI.id } : {}),
                     };
                 });
@@ -2437,30 +2612,6 @@ export class PhotonServer {
                         }
                         return;
                     }
-                    // API: List tools (for compatibility, now returns current photon)
-                    if (req.method === 'GET' && url.pathname === '/api/tools') {
-                        const toolHeaders = { 'Content-Type': 'application/json' };
-                        if (corsOrigin)
-                            toolHeaders['Access-Control-Allow-Origin'] = corsOrigin;
-                        res.writeHead(200, toolHeaders);
-                        const tools = this.mcp?.tools.map((tool) => {
-                            const linkedUI = this.mcp?.assets?.ui.find((u) => u.linkedTool === tool.name || u.linkedTools?.includes(tool.name));
-                            return {
-                                name: tool.name,
-                                description: tool.description,
-                                inputSchema: JSON.parse(JSON.stringify(tool.inputSchema)),
-                                ui: linkedUI
-                                    ? { id: linkedUI.id, uri: `ui://${this.mcp.name}/${linkedUI.id}` }
-                                    : null,
-                            };
-                        }) || [];
-                        // Resolve @choice-from fields
-                        for (const tool of tools) {
-                            await this.resolveChoiceFromFields(tool);
-                        }
-                        res.end(JSON.stringify({ tools }));
-                        return;
-                    }
                     if (req.method === 'GET' && url.pathname === '/api/status') {
                         const statusHeaders = { 'Content-Type': 'application/json' };
                         if (corsOrigin)
@@ -2474,147 +2625,6 @@ export class PhotonServer {
                         return;
                     }
                 }
-                // API: Call tool
-                if (req.method === 'POST' && url.pathname === '/api/call') {
-                    // Security: restrict CORS to localhost and require local request
-                    if (corsOrigin)
-                        res.setHeader('Access-Control-Allow-Origin', corsOrigin);
-                    res.setHeader('Content-Type', 'application/json');
-                    if (!isLocalRequest(req)) {
-                        res.writeHead(403);
-                        res.end(JSON.stringify({ success: false, error: 'Forbidden: non-local request' }));
-                        return;
-                    }
-                    if (!this.mcp) {
-                        res.writeHead(503);
-                        res.end(JSON.stringify({ success: false, error: 'Photon not loaded' }));
-                        return;
-                    }
-                    try {
-                        const body = await readBody(req);
-                        const { tool, args } = JSON.parse(body);
-                        const result = await this.loader.executeTool(this.mcp, tool, args || {});
-                        const isStateful = result && typeof result === 'object' && result._stateful === true;
-                        res.writeHead(200);
-                        res.end(JSON.stringify({
-                            success: true,
-                            data: isStateful ? result.result : result,
-                        }));
-                    }
-                    catch (error) {
-                        const status = error.message?.includes('too large') ? 413 : 500;
-                        res.writeHead(status);
-                        res.end(JSON.stringify({ success: false, error: getErrorMessage(error) }));
-                    }
-                    return;
-                }
-                // API: Call tool with streaming progress (SSE)
-                if (req.method === 'POST' && url.pathname === '/api/call-stream') {
-                    if (corsOrigin)
-                        res.setHeader('Access-Control-Allow-Origin', corsOrigin);
-                    res.setHeader('Content-Type', 'text/event-stream');
-                    res.setHeader('Cache-Control', 'no-cache');
-                    res.setHeader('Connection', 'keep-alive');
-                    if (!this.mcp) {
-                        res.writeHead(503, { 'Content-Type': 'application/json' });
-                        res.end(JSON.stringify({ success: false, error: 'Photon not loaded' }));
-                        return;
-                    }
-                    let body = '';
-                    req.on('data', (chunk) => (body += chunk));
-                    req.on('end', () => {
-                        void (async () => {
-                            let requestId = `run_${Date.now()}`;
-                            const sendMessage = (message) => {
-                                res.write(`event: message\ndata: ${JSON.stringify(message)}\n\n`);
-                            };
-                            try {
-                                const payload = JSON.parse(body || '{}');
-                                const tool = payload.tool;
-                                if (!tool) {
-                                    throw new Error('Tool name is required');
-                                }
-                                const args = payload.args || {};
-                                const progressToken = payload.progressToken ?? `progress_${Date.now()}`;
-                                requestId = payload.requestId || requestId;
-                                const sendNotification = (method, params) => {
-                                    sendMessage({ jsonrpc: '2.0', method, params });
-                                };
-                                const reportProgress = (emit) => {
-                                    const rawValue = typeof emit?.value === 'number' ? emit.value : 0;
-                                    const percent = rawValue <= 1 ? rawValue * 100 : rawValue;
-                                    const payload = emit?.value ?? emit?.data;
-                                    sendNotification('notifications/progress', {
-                                        progressToken,
-                                        progress: percent,
-                                        total: 100,
-                                        message: emit?.message || null,
-                                        ...(payload !== undefined && typeof payload !== 'number'
-                                            ? { data: payload }
-                                            : {}),
-                                    });
-                                };
-                                const outputHandler = (emit) => {
-                                    if (!emit)
-                                        return;
-                                    if (emit.emit === 'progress') {
-                                        reportProgress(emit);
-                                    }
-                                    else if (emit.emit === 'status') {
-                                        sendNotification('notifications/status', {
-                                            type: emit.type || 'info',
-                                            message: emit.message || '',
-                                        });
-                                    }
-                                    else if (emit.emit === 'render') {
-                                        sendNotification('notifications/render', {
-                                            format: emit.format,
-                                            value: emit.value,
-                                        });
-                                    }
-                                    else if (emit.emit === 'render:clear') {
-                                        sendNotification('notifications/render', { clear: true });
-                                    }
-                                    else {
-                                        sendNotification('notifications/emit', { event: emit });
-                                    }
-                                    // Forward channel events to daemon for cross-process pub/sub
-                                    this.channelManager.publishIfChannel(emit);
-                                };
-                                sendNotification('notifications/status', {
-                                    type: 'info',
-                                    message: `Starting ${tool}`,
-                                });
-                                const result = await this.loader.executeTool(this.mcp, tool, args, {
-                                    outputHandler,
-                                });
-                                const isStateful = result && typeof result === 'object' && result._stateful === true;
-                                sendMessage({
-                                    jsonrpc: '2.0',
-                                    id: requestId,
-                                    result: {
-                                        success: true,
-                                        data: isStateful ? result.result : result,
-                                    },
-                                });
-                                res.end();
-                            }
-                            catch (error) {
-                                const message = getErrorMessage(error);
-                                const errorPayload = {
-                                    jsonrpc: '2.0',
-                                    error: { code: -32000, message },
-                                };
-                                if (requestId) {
-                                    errorPayload.id = requestId;
-                                }
-                                sendMessage(errorPayload);
-                                res.end();
-                            }
-                        })();
-                    });
-                    return;
-                }
                 // API: Get UI template (and directory-style siblings for SPA bundles).
                 //
                 // Two shapes:
@@ -2657,14 +2667,31 @@ export class PhotonServer {
                         }
                         if (ui?.resolvedPath) {
                             try {
-                                let content;
                                 if (ui.resolvedPath.endsWith('.tsx')) {
-                                    const { compileTsxCached } = await import('./tsx-compiler.js');
-                                    content = await compileTsxCached(ui.resolvedPath);
-                                }
-                                else {
-                                    content = await readText(ui.resolvedPath);
+                                    const { compileTsxCached, tsxHttpResponse } = await import('./tsx-compiler.js');
+                                    const compiled = await compileTsxCached(ui.resolvedPath);
+                                    const r = tsxHttpResponse(compiled, '');
+                                    const inm = req.headers['if-none-match'];
+                                    if (r.headers['ETag'] && inm && inm === r.headers['ETag']) {
+                                        const notMod = { ETag: r.headers['ETag'] };
+                                        if (corsOrigin)
+                                            notMod['Access-Control-Allow-Origin'] = corsOrigin;
+                                        res.writeHead(304, notMod);
+                                        res.end();
+                                        return;
+                                    }
+                                    const tsxHeaders = { ...r.headers };
+                                    if (corsOrigin)
+                                        tsxHeaders['Access-Control-Allow-Origin'] = corsOrigin;
+                                    if (detectIsolationMode(req) === 'standalone') {
+                                        tsxHeaders['Cross-Origin-Opener-Policy'] = 'same-origin';
+                                        tsxHeaders['Cross-Origin-Embedder-Policy'] = 'require-corp';
+                                    }
+                                    res.writeHead(r.status, tsxHeaders);
+                                    res.end(r.body);
+                                    return;
                                 }
+                                const content = await readText(ui.resolvedPath);
                                 const uiHeaders = { 'Content-Type': 'text/html' };
                                 if (corsOrigin)
                                     uiHeaders['Access-Control-Allow-Origin'] = corsOrigin;
@@ -2688,6 +2715,25 @@ export class PhotonServer {
                         res.writeHead(404).end('UI not found');
                         return;
                     }
+                    // Compiled .tsx bundle: the shell references `./<base>.<hash>.js`,
+                    // which lands here as a sub-path. Serve it from the compile cache
+                    // with an immutable cache policy (the hash is the cache key).
+                    if (ui?.resolvedPath?.endsWith('.tsx')) {
+                        const { compileTsxCached, tsxHttpResponse } = await import('./tsx-compiler.js');
+                        const compiled = await compileTsxCached(ui.resolvedPath);
+                        const r = tsxHttpResponse(compiled, restPath);
+                        if (r.status === 200) {
+                            const jsHeaders = { ...r.headers };
+                            if (corsOrigin)
+                                jsHeaders['Access-Control-Allow-Origin'] = corsOrigin;
+                            jsHeaders['Cross-Origin-Resource-Policy'] = 'same-origin';
+                            res.writeHead(200, jsHeaders);
+                            res.end(r.body);
+                            return;
+                        }
+                        // Not the bundle (e.g. a static sibling shipped beside the .tsx) —
+                        // fall through to filesystem resolution below.
+                    }
                     // Sub-path: directory-style sibling resolution. Try the filesystem
                     // first (dev mode), then the embedded asset tree (compiled binary).
                     if (ui?.resolvedPath) {