@portel/photon 1.34.2 → 1.35.0

package/dist/loader.js

@@ -6,6 +6,7 @@
 import * as fs from 'fs/promises';
 import { realpathSync, existsSync, mkdirSync, symlinkSync, readFileSync, statSync, } from 'fs';
 import { readText, readJSON, writeText, writeJSON } from './shared/io.js';
+import { qualifyChannel, circuitKey, preloadedCacheKey, instanceCacheKey, } from './shared/identity.js';
 import { parseCfBindings } from './cf-bindings-parser.js';
 import { CFLocalRuntime, mergeBindings } from './runtime/cf-local.js';
 import { scanCfUsage } from './cf-usage-scanner.js';
@@ -43,7 +44,7 @@ executionContext,
 // Lock helper
 withLock as withLockHelper, 
 // Middleware system
-builtinRegistry, MiddlewareRegistry, buildMiddlewareChain, getCacheDir, } from '@portel/photon-core';
+builtinRegistry, MiddlewareRegistry, buildMiddlewareChain, getCacheDir, getPhotonDataDir, } from '@portel/photon-core';
 import { getDefaultContext } from './context.js';
 import { getInstanceStatePath } from './context-store.js';
 import { ContextRegistry, RepeatDetector, assembleSampleParams, } from './sample-augmenter.js';
@@ -235,10 +236,14 @@ function injectEmitHelpers(instance) {
         instance.log = (message, opts = {}) => emit({ emit: 'log', message, level: opts.level ?? 'info', data: opts.data });
     }
     if (!('status' in instance)) {
-        instance.status = (message) => emit({ emit: 'status', message });
+        instance.status = (message, value) => emit(typeof message === 'string'
+            ? { emit: 'status', message, ...(value !== undefined && { value }) }
+            : { emit: 'status', ...message });
     }
     if (!('progress' in instance)) {
-        instance.progress = (value, message) => emit({ emit: 'progress', value, message });
+        instance.progress = (value, message, meta) => emit(typeof value === 'number'
+            ? { emit: 'progress', value, ...(message && { message }), ...(meta && { meta }) }
+            : { emit: 'progress', ...value });
     }
     if (!('thinking' in instance)) {
         instance.thinking = (active = true) => emit({ emit: 'thinking', active });
@@ -389,6 +394,28 @@ function injectResourceNotifier(instance, notifier) {
         }
     };
 }
+/**
+ * Formats @portel/cli's formatOutput can render directly. Anything else
+ * (gauge, stack, chart:*, ...) would hit formatDataWithHint's switch with
+ * no matching case and silently drop the data — fall back to auto-detect
+ * instead so the value always stays visible.
+ */
+const CLI_BASE_FORMATS = new Set([
+    'primitive',
+    'list',
+    'table',
+    'tree',
+    'card',
+    'tabs',
+    'accordion',
+    'none',
+    'json',
+    'markdown',
+    'yaml',
+    'xml',
+    'html',
+    'code',
+]);
 /**
  * Render a formatted value in the CLI using @portel/cli's formatOutput.
  * Uses clear-and-replace semantics — each call overwrites the previous render.
@@ -406,9 +433,10 @@ function renderCLIFormat(format, value) {
             }
             return;
         }
+        const safeFormat = CLI_BASE_FORMATS.has(format) || format.startsWith('code:') ? format : undefined;
         // Use the eagerly-imported formatter — synchronous, so line counting works
         cliRenderZone.render(() => {
-            cliFormatOutput(value, format);
+            cliFormatOutput(value, safeFormat);
         });
     }
     catch {
@@ -1234,7 +1262,7 @@ export class PhotonLoader {
                 if (caps.size > 0) {
                     this.log(`🔍 Detected capabilities for ${name}: ${[...caps].join(', ')}`);
                 }
-                this.injectPathHelpers(instance, tsContent);
+                this.injectPathHelpers(instance);
                 // Always-inject emit + its helpers (render/toast/log/status/progress/
                 // thinking). The injection is a pure closure — zero cost if unused.
                 // Dropping the capability-detection gate means typed-access patterns
@@ -1254,7 +1282,7 @@ export class PhotonLoader {
                         // Also publish to channel broker if channel is specified
                         if (data && typeof data.channel === 'string') {
                             // Auto-prefix channel with photon name if not already namespaced
-                            const channel = data.channel.includes(':') ? data.channel : `${name}:${data.channel}`;
+                            const channel = qualifyChannel(name, data.channel);
                             import('@portel/photon-core')
                                 .then(({ getBroker }) => {
                                 const broker = getBroker();
@@ -1862,10 +1890,7 @@ export class PhotonLoader {
         }
         // Detect and inject capabilities for plain classes
         if (tsContent && typeof instance.executeTool !== 'function') {
-            const caps = detectCapabilities(tsContent);
-            if (detectEmitHelperUsage(tsContent))
-                caps.add('emit');
-            this.injectPathHelpers(instance, tsContent);
+            this.injectPathHelpers(instance);
             // Always-inject emit (see primary path). User-defined wins.
             if (!instance.emit) {
                 instance.emit = (data) => {
@@ -1878,7 +1903,7 @@ export class PhotonLoader {
                     if (handler)
                         handler(emitData);
                     if (data && typeof data.channel === 'string') {
-                        const channel = data.channel.includes(':') ? data.channel : `${name}:${data.channel}`;
+                        const channel = qualifyChannel(name, data.channel);
                         import('@portel/photon-core')
                             .then(({ getBroker }) => {
                             getBroker()
@@ -2129,12 +2154,28 @@ export class PhotonLoader {
             return explicitScopes;
         return [`${tool.name}:${tool.readOnlyHint ? 'read' : 'write'}`];
     }
+    /**
+     * Drop circuit-breaker state for every instance/tool of a photon.
+     * Called on hot reload so the reloaded code starts with closed circuits
+     * and long-running daemons don't accumulate entries for retired versions.
+     */
+    clearCircuitState(photonName) {
+        const prefix = `${photonName}:`;
+        for (const key of this.circuitHealthTracker.keys()) {
+            if (key.startsWith(prefix))
+                this.circuitHealthTracker.delete(key);
+        }
+    }
     /**
      * Reload a Photon MCP file (for hot reload)
      */
     async reloadFile(filePath, options) {
         // Invalidate the cache for this file
         const absolutePath = path.resolve(filePath);
+        this.clearCircuitState(path
+            .basename(absolutePath)
+            .replace(/\.photon\.(ts|js|mjs)$/, '')
+            .replace(/\.(ts|js|mjs)$/, ''));
         if (absolutePath.endsWith('.ts')) {
             // Clear the compiled cache
             const tsContent = await readText(absolutePath);
@@ -2807,9 +2848,7 @@ export class PhotonLoader {
                     this.log(`  ⚠️ Skipping stub dependency: ${dep.name} (module failed to load)`);
                     return undefined;
                 }
-                const cacheKey = dep.instanceName
-                    ? `preloaded:${dep.name}::${dep.instanceName}`
-                    : `preloaded:${dep.name}`;
+                const cacheKey = preloadedCacheKey(dep.name, dep.instanceName);
                 if (this.loadedPhotons.has(cacheKey)) {
                     return this.loadedPhotons.get(cacheKey).instance;
                 }
@@ -2823,7 +2862,7 @@ export class PhotonLoader {
         const resolvedPath = await this.resolvePhotonPath(dep, currentPhotonPath);
         await this.materializeSiblingDependencySymlink(dep, currentPhotonPath, resolvedPath);
         // Cache key includes instance name to allow multiple instances of the same photon
-        const cacheKey = dep.instanceName ? `${resolvedPath}::${dep.instanceName}` : resolvedPath;
+        const cacheKey = instanceCacheKey(resolvedPath, dep.instanceName);
         // Check cache
         if (this.loadedPhotons.has(cacheKey)) {
             return this.loadedPhotons.get(cacheKey).instance;
@@ -3368,7 +3407,7 @@ Run: photon mcp ${mcpName} --config
         handlerOverrides.set('circuitBreaker', (config, _state) => {
             const tracker = this.circuitHealthTracker;
             return async (ctx, next) => {
-                const key = `${ctx.photon}:${ctx.instance}:${ctx.tool}`;
+                const key = circuitKey(ctx.photon, ctx.instance, ctx.tool);
                 let circuit = tracker.get(key);
                 if (!circuit) {
                     circuit = { failures: 0, state: 'closed', openedAt: 0 };
@@ -3399,7 +3438,7 @@ Run: photon mcp ${mcpName} --config
                                 channel: `${ctx.photon}:circuits`,
                                 event: 'state-change',
                                 data: {
-                                    key: `${ctx.photon}:${ctx.instance}:${ctx.tool}`,
+                                    key: circuitKey(ctx.photon, ctx.instance, ctx.tool),
                                     from,
                                     to,
                                     timestamp: Date.now(),
@@ -4030,6 +4069,7 @@ Run: photon mcp ${mcpName} --config
      */
     createInputProvider() {
         return async (ask) => {
+            this.progressRenderer.done();
             switch (ask.ask) {
                 case 'text':
                 case 'password':
@@ -4037,9 +4077,52 @@ Run: photon mcp ${mcpName} --config
                 case 'confirm':
                     return await elicitConfirm(ask.message);
                 case 'select': {
-                    const options = (ask.options || []).map((o) => typeof o === 'string' ? o : o.label);
-                    const result = await elicitPrompt(`${ask.message}\nOptions: ${options.join(', ')}`);
-                    return result;
+                    const options = (ask.options || []).map((o) => {
+                        if (typeof o === 'string')
+                            return { value: o, label: o };
+                        return { value: o.value ?? o.label, label: o.label };
+                    });
+                    // Print choices clearly as a numbered list
+                    let msg = `${ask.message}\n`;
+                    options.forEach((opt, idx) => {
+                        msg += `  [${idx + 1}] ${opt.label}\n`;
+                    });
+                    msg += ask.multi
+                        ? `Select option(s) (comma-separated numbers or names): `
+                        : `Select an option (number or name): `;
+                    const result = await elicitPrompt(msg);
+                    if (!result)
+                        return ask.multi ? [] : null;
+                    // Parse and match the user selection
+                    if (ask.multi) {
+                        const parts = result.split(',').map((s) => s.trim().toLowerCase());
+                        const selected = [];
+                        for (const part of parts) {
+                            const idx = parseInt(part, 10) - 1;
+                            if (idx >= 0 && idx < options.length) {
+                                selected.push(options[idx].value);
+                            }
+                            else {
+                                const match = options.find((o) => o.label.toLowerCase() === part ||
+                                    o.value.toString().toLowerCase() === part ||
+                                    o.label.toLowerCase().includes(part));
+                                if (match)
+                                    selected.push(match.value);
+                            }
+                        }
+                        return selected;
+                    }
+                    else {
+                        const part = result.trim().toLowerCase();
+                        const idx = parseInt(part, 10) - 1;
+                        if (idx >= 0 && idx < options.length) {
+                            return options[idx].value;
+                        }
+                        const match = options.find((o) => o.label.toLowerCase() === part ||
+                            o.value.toString().toLowerCase() === part ||
+                            o.label.toLowerCase().includes(part));
+                        return match ? match.value : result;
+                    }
                 }
                 case 'number': {
                     const result = await elicitPrompt(ask.message, ask.default?.toString());
@@ -4483,24 +4566,32 @@ Run: photon mcp ${mcpName} --config
     /**
      * Inject Photon path helpers for plain classes that use them without extending Photon.
      */
-    injectPathHelpers(instance, source) {
-        if (!source) {
-            return;
-        }
-        if (/this\.storage\s*\(/.test(source) && typeof instance.storage !== 'function') {
+    // Always inject; never gate on source regexes. Regex detection misses
+    // TS-cast call shapes like `(this as any).storage(...)` and silently
+    // leaves the helper undefined — the same blind spot that caused the
+    // memory-injection data-loss bug. Every helper is a lazy closure (zero
+    // cost unless called) and user-defined methods always win.
+    injectPathHelpers(instance) {
+        if (typeof instance.storage !== 'function') {
+            // Mirror Photon.storage() in photon-core base.ts exactly: documented
+            // contract is the data dir (getPhotonDataDir), never next to source.
+            // The previous source-adjacent resolution was copied from assets()
+            // (where source-adjacent is correct) and contradicted every doc.
+            const storageBaseDir = this.baseDir;
             instance.storage = (subpath) => {
                 if (!instance._photonFilePath || typeof instance._photonFilePath !== 'string') {
                     throw new Error('storage() requires _photonFilePath to be set by the runtime loader. ' +
                         'Ensure this photon is loaded through the standard runtime.');
                 }
-                const dir = path.dirname(instance._photonFilePath);
-                const name = path.basename(instance._photonFilePath).replace(/\.photon\.(ts|js)$/, '');
-                const target = path.join(dir, name, subpath);
+                const name = (typeof instance._photonName === 'string' && instance._photonName) ||
+                    path.basename(instance._photonFilePath).replace(/\.photon\.(ts|js)$/, '');
+                const ns = (typeof instance._photonNamespace === 'string' && instance._photonNamespace) || 'local';
+                const target = path.join(getPhotonDataDir(ns, name, storageBaseDir), subpath);
                 mkdirSync(target, { recursive: true });
                 return target;
             };
         }
-        if (/this\.assets\s*\(/.test(source) && typeof instance.assets !== 'function') {
+        if (typeof instance.assets !== 'function') {
             instance.assets = (subpath, options) => {
                 const normalized = typeof options === 'boolean' ? { load: options } : (options ?? {});
                 if (!instance._photonFilePath || typeof instance._photonFilePath !== 'string') {
@@ -4523,7 +4614,7 @@ Run: photon mcp ${mcpName} --config
                 return readFileSync(assetPath, normalized.encoding ?? 'utf-8');
             };
         }
-        if (/this\.assetUrl\s*\(/.test(source) && typeof instance.assetUrl !== 'function') {
+        if (typeof instance.assetUrl !== 'function') {
             instance.assetUrl = (subpath) => {
                 const name = (typeof instance._photonName === 'string' && instance._photonName
                     ? instance._photonName