@portel/photon 1.16.1 → 1.17.0

package/dist/loader.js

@@ -5,6 +5,7 @@
  */
 import * as fs from 'fs/promises';
 import { realpathSync, existsSync, mkdirSync, symlinkSync, readFileSync } from 'fs';
+import { readText, readJSON, writeText, writeJSON } from './shared/io.js';
 import { createRequire } from 'module';
 import * as path from 'path';
 import { pathToFileURL } from 'url';
@@ -185,8 +186,6 @@ export class PhotonLoader {
     mcpClients = new Map();
     /** In-flight MCP client creation promises — dedup concurrent creates for the same dep */
     mcpClientPromises = new Map();
-    /** SDK factory for MCP connections */
-    sdkFactory;
     /** Cached MCP config from ~/.photon/config.json */
     mcpConfig;
     /** Inflight config load promise (dedup concurrent calls) */
@@ -309,7 +308,7 @@ export class PhotonLoader {
             : crypto.createHash('sha256').update(content).digest('hex').slice(0, 12);
         const safeLabel = this.sanitizeCacheLabel(label);
         const cachePath = path.join(cacheDir, `${safeLabel}.${hash}.photon.ts`);
-        await fs.writeFile(cachePath, content, 'utf-8');
+        await writeText(cachePath, content);
         return cachePath;
     }
     async runCommand(command, args, cwd) {
@@ -357,8 +356,7 @@ export class PhotonLoader {
     }
     async readDependencyMetadata(cacheKey) {
         try {
-            const data = await fs.readFile(this.getDependencyMetadataPath(cacheKey), 'utf-8');
-            return JSON.parse(data);
+            return await readJSON(this.getDependencyMetadataPath(cacheKey));
         }
         catch (error) {
             this.logger.debug('Failed to read dependency metadata', { error });
@@ -390,12 +388,12 @@ export class PhotonLoader {
     async writeDependencyMetadata(cacheKey, hash, dependencies, photonPath, photonCoreVersion) {
         const metadataPath = this.getDependencyMetadataPath(cacheKey);
         await fs.mkdir(path.dirname(metadataPath), { recursive: true });
-        await fs.writeFile(metadataPath, JSON.stringify({
+        await writeJSON(metadataPath, {
             hash,
             dependencies,
             photonPath: photonPath ? path.resolve(photonPath) : undefined,
             photonCoreVersion,
-        }, null, 2), 'utf-8');
+        });
     }
     async ensureDependenciesWithHash(cacheKey, mcpName, dependencies, sourceHash, photonPath) {
         const metadata = await this.readDependencyMetadata(cacheKey);
@@ -521,7 +519,7 @@ export class PhotonLoader {
             let mcpName = '';
             let cacheKey = null;
             if (absolutePath.endsWith('.ts')) {
-                tsContent = await fs.readFile(absolutePath, 'utf-8');
+                tsContent = await readText(absolutePath);
                 // Check runtime version compatibility
                 const requiredRuntime = parseRuntimeRequirement(tsContent);
                 if (requiredRuntime) {
@@ -818,7 +816,7 @@ export class PhotonLoader {
                                 const instName = file.replace('.json', '');
                                 const statePath = path.join(stateDir, file);
                                 try {
-                                    const snapshot = JSON.parse(await fs.readFile(statePath, 'utf-8'));
+                                    const snapshot = await readJSON(statePath);
                                     const stat = await fs.stat(statePath);
                                     yield {
                                         name: instName,
@@ -1267,7 +1265,7 @@ export class PhotonLoader {
         const absolutePath = path.resolve(filePath);
         if (absolutePath.endsWith('.ts')) {
             // Clear the compiled cache
-            const tsContent = await fs.readFile(absolutePath, 'utf-8');
+            const tsContent = await readText(absolutePath);
             const hash = crypto.createHash('sha256').update(tsContent).digest('hex').slice(0, 16);
             const mcpName = path.basename(absolutePath, '.ts').replace('.photon', '');
             const cacheKey = this.getCacheKey(mcpName, absolutePath);
@@ -1401,8 +1399,7 @@ export class PhotonLoader {
             // First, try loading from manual schema override file
             const schemaJsonPath = sourceFilePath.replace(/\.ts$/, '.schema.json');
             try {
-                const schemaContent = await fs.readFile(schemaJsonPath, 'utf-8');
-                const schemas = JSON.parse(schemaContent);
+                const schemas = await readJSON(schemaJsonPath);
                 // Process tools
                 if (schemas.tools) {
                     for (const schema of schemas.tools) {
@@ -1458,7 +1455,7 @@ export class PhotonLoader {
                     jsonError.code === 'ENOENT';
                 if (isNotFound) {
                     const extractor = new SchemaExtractor();
-                    const source = sourceContent || (await fs.readFile(sourceFilePath, 'utf-8'));
+                    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));
@@ -1526,8 +1523,7 @@ export class PhotonLoader {
     async loadSettings(photonName, instanceName) {
         const settingsPath = this.getSettingsPath(photonName, instanceName);
         try {
-            const data = await fs.readFile(settingsPath, 'utf-8');
-            return JSON.parse(data);
+            return await readJSON(settingsPath);
         }
         catch {
             return {};
@@ -1540,7 +1536,7 @@ export class PhotonLoader {
         const settingsPath = this.getSettingsPath(photonName, instanceName);
         const dir = path.dirname(settingsPath);
         await fs.mkdir(dir, { recursive: true });
-        await fs.writeFile(settingsPath, JSON.stringify(values, null, 2));
+        await writeJSON(settingsPath, values);
     }
     /**
      * Inject settings into a photon instance:
@@ -1704,7 +1700,7 @@ export class PhotonLoader {
      */
     async extractConstructorParams(filePath) {
         try {
-            const source = await fs.readFile(filePath, 'utf-8');
+            const source = await readText(filePath);
             const extractor = new SchemaExtractor();
             return extractor.extractConstructorParams(source);
         }
@@ -1831,7 +1827,7 @@ export class PhotonLoader {
                     const stateKey = injection.stateKey;
                     const stateFile = getInstanceStatePath(mcpName, instanceName, this.baseDir, photonPath);
                     try {
-                        const snapshot = JSON.parse(await fs.readFile(stateFile, 'utf-8'));
+                        const snapshot = await readJSON(stateFile);
                         if (stateKey in snapshot) {
                             values.push(snapshot[stateKey]);
                             this.log(`  ✅ Restored state: ${stateKey} (from ${stateFile})`);
@@ -2316,7 +2312,7 @@ export class PhotonLoader {
         const packageJsonPath = path.join(cacheDir, 'package.json');
         if (!(await this.pathExists(packageJsonPath))) {
             const pkgName = `photon-npm-${this.sanitizeCacheLabel(packageSpec)}`;
-            await fs.writeFile(packageJsonPath, JSON.stringify({ name: pkgName, version: PHOTON_VERSION }, null, 2), 'utf-8');
+            await writeJSON(packageJsonPath, { name: pkgName, version: PHOTON_VERSION });
         }
         const packageRoot = this.getPackageInstallPath(cacheDir, packageName);
         if (await this.pathExists(packageRoot)) {
@@ -2591,9 +2587,7 @@ Run: photon mcp ${mcpName} --config
                 // so we must emit events here where ALL tool executions are guaranteed to pass through
                 if (mcp.instance && typeof mcp.instance.emit === 'function') {
                     try {
-                        // Check if this is a @stateful photon by looking for emit method and @stateful tag
                         const photonName = mcp.name;
-                        const hasStatefulTag = mcp.tools.some((t) => t.name === toolName); // Assume @stateful if loaded
                         // Attach __meta to result if it's an object and doesn't already have it
                         if (result && typeof result === 'object' && !Array.isArray(result) && !result.__meta) {
                             const timestamp = new Date().toISOString();