@portel/photon 1.25.0 → 1.26.0

package/dist/loader.js

@@ -1249,7 +1249,17 @@ export class PhotonLoader {
                         permissionHandler?.(request);
                     },
                 });
-                instance.channel = channelFn;
+                // Only inject if 'channel' is not already defined as a getter on the instance/prototype.
+                // Some photons define a private `get channel()` getter for their own internal use —
+                // attempting a plain assignment onto a getter-only property throws in strict mode.
+                const channelDescriptor = Object.getOwnPropertyDescriptor(instance, 'channel') ??
+                    Object.getOwnPropertyDescriptor(Object.getPrototypeOf(instance), 'channel');
+                const channelIsGetter = channelDescriptor?.get !== undefined;
+                if (!channelIsGetter) {
+                    instance.channel = channelFn;
+                }
+                // If the photon already has its own getter for 'channel', skip injection —
+                // the photon is using the name for its own purpose and likely calls this.emit() directly.
             }
             // Check @cli dependencies (required system CLI tools)
             if (tsContent) {
@@ -1266,7 +1276,7 @@ export class PhotonLoader {
                 this.wrapStatefulMethods(instance, tsContent);
             }
             // Extract tools, templates, and statics (with schema override support)
-            const { tools, templates, statics, settingsSchema, auth: extractedAuth, } = await this.extractTools(MCPClass, absolutePath);
+            const { tools, templates, statics, settingsSchema, auth: extractedAuth, httpRoutes: extractedHttpRoutes, } = await this.extractTools(MCPClass, absolutePath);
             // ═══ SETTINGS INJECTION ═══
             // If the photon declared `protected settings = { ... }`, inject persistence + proxy
             if (settingsSchema?.hasSettings &&
@@ -1318,6 +1328,8 @@ export class PhotonLoader {
                 result.stateful = true;
             if (extractedAuth)
                 result.auth = extractedAuth;
+            if (extractedHttpRoutes?.length)
+                result._httpRoutes = extractedHttpRoutes;
             // Store class constructor for static method access
             result.classConstructor = MCPClass;
             // Store settings schema for Beam UI
@@ -1621,7 +1633,7 @@ export class PhotonLoader {
         // Call lifecycle hook
         await this.invokeInitialize(instance, name, options);
         // Extract tools and metadata from embedded source (no disk I/O)
-        const { tools, templates, statics, settingsSchema, auth: extractedAuth, } = await this.extractTools(MCPClass, absolutePath, tsContent);
+        const { tools, templates, statics, settingsSchema, auth: extractedAuth, httpRoutes: extractedHttpRoutes, } = await this.extractTools(MCPClass, absolutePath, tsContent);
         // Settings injection
         if (settingsSchema?.hasSettings && instance.settings && typeof instance.settings === 'object') {
             const instanceName = options?.instanceName || 'default';
@@ -1653,6 +1665,8 @@ export class PhotonLoader {
             result.stateful = true;
         if (extractedAuth)
             result.auth = extractedAuth;
+        if (extractedHttpRoutes?.length)
+            result._httpRoutes = extractedHttpRoutes;
         result.classConstructor = MCPClass;
         if (settingsSchema?.hasSettings) {
             result.settingsSchema = settingsSchema;
@@ -1806,6 +1820,21 @@ export class PhotonLoader {
         }
         return cleaned;
     }
+    /**
+     * Extract @get and @post HTTP route declarations from photon source.
+     * Methods tagged with @get or @post are HTTP-only and must NOT appear as MCP tools.
+     */
+    extractHttpRoutesFromSource(source) {
+        const routes = [];
+        // Match JSDoc blocks that contain @get or @post followed by the async method name.
+        // Pattern: /** ... @get /path ... */ async methodName(
+        const routeRe = /\/\*\*[\s\S]*?@(get|post)\s+(\/[^\s*]*)[\s\S]*?\*\/\s*(?:async\s+)?(\w+)\s*\(/gi;
+        let m;
+        while ((m = routeRe.exec(source)) !== null) {
+            routes.push({ method: m[1].toUpperCase(), path: m[2], handler: m[3] });
+        }
+        return routes;
+    }
     /**
      * Extract tools, templates, and statics from a class
      */
@@ -1876,8 +1905,11 @@ export class PhotonLoader {
                     const extractor = new SchemaExtractor();
                     const source = sourceContent || (await readText(sourceFilePath));
                     const metadata = extractor.extractAllFromSource(source);
-                    // Filter by method names that exist in the class
-                    tools = metadata.tools.filter((t) => methodNames.includes(t.name));
+                    // Extract @get/@post HTTP routes from source (not in photon-core SchemaExtractor)
+                    const httpRoutesFromSource = this.extractHttpRoutesFromSource(source);
+                    const routeHandlerNames = new Set(httpRoutesFromSource.map((r) => r.handler));
+                    // Filter by method names that exist in the class; exclude HTTP-route methods from tools
+                    tools = metadata.tools.filter((t) => methodNames.includes(t.name) && !routeHandlerNames.has(t.name));
                     templates = metadata.templates.filter((t) => methodNames.includes(t.name));
                     statics = metadata.statics.filter((s) => methodNames.includes(s.name));
                     this.log(`Extracted ${tools.length} tools, ${templates.length} templates, ${statics.length} statics from source`);
@@ -1908,6 +1940,7 @@ export class PhotonLoader {
                         statics,
                         settingsSchema: metadata.settingsSchema,
                         auth: this.extractAuthTag(source),
+                        httpRoutes: httpRoutesFromSource.length ? httpRoutesFromSource : undefined,
                     };
                 }
                 throw jsonError;