@fairfox/polly 0.2.1 → 0.3.1

package/dist/vendor/visualize/src/cli.js

@@ -42,9 +42,22 @@ class ProjectDetector {
       if (packageJson.dependencies?.electron || packageJson.devDependencies?.electron) {
         return this.detectElectron(packageJson);
       }
-      if (packageJson.dependencies?.ws || packageJson.dependencies?.["socket.io"] || packageJson.dependencies?.elysia || packageJson.dependencies?.express) {
+      const deps = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies
+      };
+      if (deps?.ws || deps?.["socket.io"] || deps?.elysia || deps?.express || deps?.fastify || deps?.hono || deps?.koa) {
         return this.detectWebSocketApp(packageJson);
       }
+      const serverResult = this.detectWebSocketApp(packageJson);
+      if (Object.keys(serverResult.entryPoints).length > 0) {
+        return serverResult;
+      }
+    } else {
+      const serverResult = this.detectWebSocketApp({});
+      if (Object.keys(serverResult.entryPoints).length > 0) {
+        return serverResult;
+      }
     }
     return this.detectGenericProject();
   }
@@ -176,37 +189,53 @@ class ProjectDetector {
   }
   detectWebSocketApp(packageJson) {
     const entryPoints = {};
+    const contextMapping = {};
     const serverCandidates = [
       "src/server.ts",
+      "src/server.js",
       "src/index.ts",
+      "src/index.js",
       "src/main.ts",
+      "src/main.js",
       "src/app.ts",
+      "src/app.js",
       "server.ts",
-      "index.ts"
+      "server.js",
+      "index.ts",
+      "index.js"
     ];
-    for (const candidate of serverCandidates) {
-      const fullPath = path3.join(this.projectRoot, candidate);
-      if (fs3.existsSync(fullPath)) {
-        entryPoints.server = fullPath;
-        break;
+    const scoredServers = this.scoreServerCandidates(serverCandidates);
+    if (scoredServers.length > 0) {
+      const best = scoredServers[0];
+      entryPoints.server = best.path;
+      if (best.hasWebSocket) {
+        contextMapping.server = "WebSocket Server";
+      } else if (best.hasHTTP) {
+        contextMapping.server = "HTTP Server";
+      } else {
+        contextMapping.server = "Server";
       }
     }
     const clientCandidates = [
       "src/client/index.ts",
+      "src/client/index.js",
       "src/client.ts",
-      "client/index.ts"
+      "src/client.js",
+      "client/index.ts",
+      "client/index.js"
     ];
     for (const candidate of clientCandidates) {
       const fullPath = path3.join(this.projectRoot, candidate);
       if (fs3.existsSync(fullPath)) {
         entryPoints.client = fullPath;
+        contextMapping.client = "Client";
         break;
       }
     }
     return {
       type: "websocket-app",
       entryPoints,
-      contextMapping: {
+      contextMapping: Object.keys(contextMapping).length > 0 ? contextMapping : {
         server: "Server",
         client: "Client"
       },
@@ -217,6 +246,98 @@ class ProjectDetector {
       }
     };
   }
+  scoreServerCandidates(candidates) {
+    const scored = [];
+    for (const candidate of candidates) {
+      const fullPath = path3.join(this.projectRoot, candidate);
+      if (!fs3.existsSync(fullPath))
+        continue;
+      try {
+        const content = fs3.readFileSync(fullPath, "utf-8");
+        let score = 0;
+        let hasWebSocket = false;
+        let hasHTTP = false;
+        let framework = null;
+        const patterns = {
+          bunWebSocket: /Bun\.serve\s*\([^)]*websocket\s*:/i,
+          bunHTTP: /Bun\.serve\s*\(/i,
+          wsServer: /new\s+WebSocket\.Server/i,
+          wsImport: /from\s+['"]ws['"]/,
+          socketIO: /io\s*\(|require\s*\(\s*['"]socket\.io['"]\s*\)/i,
+          elysia: /new\s+Elysia\s*\(|\.ws\s*\(/i,
+          elysiaImport: /from\s+['"]elysia['"]/,
+          express: /express\s*\(\)|app\.listen/i,
+          expressWs: /expressWs\s*\(/i,
+          httpServer: /createServer|app\.listen|server\.listen/i,
+          webSocket: /WebSocket|websocket|\.ws\s*\(|wss\s*:/i
+        };
+        if (patterns.bunWebSocket.test(content)) {
+          score += 15;
+          hasWebSocket = true;
+          hasHTTP = true;
+          framework = "Bun";
+        } else if (patterns.bunHTTP.test(content)) {
+          score += 10;
+          hasHTTP = true;
+          framework = "Bun";
+        }
+        if (patterns.wsServer.test(content) || patterns.wsImport.test(content)) {
+          score += 12;
+          hasWebSocket = true;
+          framework = framework || "ws";
+        }
+        if (patterns.socketIO.test(content)) {
+          score += 12;
+          hasWebSocket = true;
+          framework = framework || "socket.io";
+        }
+        if (patterns.elysia.test(content) || patterns.elysiaImport.test(content)) {
+          score += 10;
+          hasHTTP = true;
+          framework = framework || "Elysia";
+        }
+        if (patterns.elysiaImport.test(content) && patterns.webSocket.test(content)) {
+          score += 8;
+          hasWebSocket = true;
+        }
+        if (patterns.express.test(content)) {
+          score += 8;
+          hasHTTP = true;
+          framework = framework || "Express";
+        }
+        if (patterns.expressWs.test(content)) {
+          score += 5;
+          hasWebSocket = true;
+        }
+        if (patterns.httpServer.test(content) && !hasHTTP) {
+          score += 5;
+          hasHTTP = true;
+        }
+        if (patterns.webSocket.test(content) && !hasWebSocket) {
+          score += 3;
+          hasWebSocket = true;
+        }
+        if (/\.listen\s*\(/.test(content)) {
+          score += 5;
+        }
+        if (/export\s+default/.test(content)) {
+          score += 3;
+        }
+        if (candidate.includes("server")) {
+          score += 3;
+        }
+        if (candidate === "src/index.ts" || candidate === "src/index.js") {
+          score += 2;
+        }
+        if (score > 0) {
+          scored.push({ path: fullPath, score, hasWebSocket, hasHTTP, framework });
+        }
+      } catch (error) {
+        continue;
+      }
+    }
+    return scored.sort((a, b) => b.score - a.score);
+  }
   detectGenericProject() {
     const entryPoints = {};
     const tsConfigPath = path3.join(this.projectRoot, "tsconfig.json");
@@ -343,10 +464,14 @@ class ManifestParser {
   manifestPath;
   manifestData;
   baseDir;
-  constructor(projectRoot) {
+  constructor(projectRoot, optional = false) {
     this.baseDir = projectRoot;
     this.manifestPath = path.join(projectRoot, "manifest.json");
     if (!fs.existsSync(this.manifestPath)) {
+      if (optional) {
+        this.manifestData = null;
+        return;
+      }
       throw new Error(`manifest.json not found at ${this.manifestPath}`);
     }
     try {
@@ -356,7 +481,13 @@ class ManifestParser {
       throw new Error(`Failed to parse manifest.json: ${error}`);
     }
   }
+  hasManifest() {
+    return this.manifestData !== null;
+  }
   parse() {
+    if (!this.manifestData) {
+      throw new Error("Cannot parse manifest: manifest.json not loaded. Use hasManifest() to check availability.");
+    }
     const manifest = this.manifestData;
     return {
       name: manifest.name || "Unknown Extension",
@@ -373,6 +504,9 @@ class ManifestParser {
     };
   }
   getContextEntryPoints() {
+    if (!this.manifestData) {
+      return {};
+    }
     const entryPoints = {};
     const background = this.parseBackground();
     if (background) {
@@ -415,6 +549,8 @@ class ManifestParser {
     return entryPoints;
   }
   parseBackground() {
+    if (!this.manifestData)
+      return;
     const bg = this.manifestData.background;
     if (!bg)
       return;
@@ -439,6 +575,8 @@ class ManifestParser {
     return;
   }
   parseContentScripts() {
+    if (!this.manifestData)
+      return;
     const cs = this.manifestData.content_scripts;
     if (!cs || !Array.isArray(cs))
       return;
@@ -449,6 +587,8 @@ class ManifestParser {
     }));
   }
   parsePopup() {
+    if (!this.manifestData)
+      return;
     const action = this.manifestData.action || this.manifestData.browser_action;
     if (!action)
       return;
@@ -461,6 +601,8 @@ class ManifestParser {
     return;
   }
   parseOptions() {
+    if (!this.manifestData)
+      return;
     const options = this.manifestData.options_ui || this.manifestData.options_page;
     if (!options)
       return;
@@ -476,6 +618,8 @@ class ManifestParser {
     };
   }
   parseDevtools() {
+    if (!this.manifestData)
+      return;
     const devtools = this.manifestData.devtools_page;
     if (!devtools)
       return;
@@ -780,7 +924,34 @@ class FlowAnalyzer {
           const expression = node.getExpression();
           if (Node2.isPropertyAccessExpression(expression)) {
             const methodName = expression.getName();
-            if (methodName === "send" || methodName === "emit") {
+            if (methodName === "send" || methodName === "emit" || methodName === "postMessage" || methodName === "broadcast") {
+              const args = node.getArguments();
+              if (args.length > 0) {
+                const firstArg = args[0];
+                let msgType;
+                if (Node2.isStringLiteral(firstArg)) {
+                  msgType = firstArg.getLiteralValue();
+                } else if (Node2.isObjectLiteralExpression(firstArg)) {
+                  const typeProperty = firstArg.getProperty("type");
+                  if (typeProperty && Node2.isPropertyAssignment(typeProperty)) {
+                    const initializer = typeProperty.getInitializer();
+                    if (initializer && Node2.isStringLiteral(initializer)) {
+                      msgType = initializer.getLiteralValue();
+                    }
+                  }
+                }
+                if (msgType === messageType) {
+                  senders.push({
+                    context,
+                    file: filePath,
+                    line: node.getStartLineNumber()
+                  });
+                }
+              }
+            }
+          }
+          if (Node2.isIdentifier(expression)) {
+            if (expression.getText() === "postMessage") {
               const args = node.getArguments();
               if (args.length > 0) {
                 const firstArg = args[0];
@@ -932,6 +1103,15 @@ class FlowAnalyzer {
     if (path2.includes("/offscreen/") || path2.includes("\\offscreen\\")) {
       return "offscreen";
     }
+    if (path2.includes("/server/") || path2.includes("\\server\\") || path2.includes("/server.")) {
+      return "server";
+    }
+    if (path2.includes("/client/") || path2.includes("\\client\\") || path2.includes("/client.")) {
+      return "client";
+    }
+    if (path2.includes("/worker/") || path2.includes("\\worker\\") || path2.includes("service-worker")) {
+      return "worker";
+    }
     return "unknown";
   }
 }
@@ -1138,10 +1318,12 @@ import { Project as Project4, SyntaxKind as SyntaxKind2, Node as Node4 } from "t
 
 class HandlerExtractor {
   project;
+  typeGuardCache;
   constructor(tsConfigPath) {
     this.project = new Project4({
       tsConfigFilePath: tsConfigPath
     });
+    this.typeGuardCache = new WeakMap;
   }
   extractHandlers() {
     const handlers = [];
@@ -1168,7 +1350,7 @@ class HandlerExtractor {
         const expression = node.getExpression();
         if (Node4.isPropertyAccessExpression(expression)) {
           const methodName = expression.getName();
-          if (methodName === "on") {
+          if (methodName === "on" || methodName === "addEventListener") {
             const handler = this.extractHandler(node, context, filePath);
             if (handler) {
               handlers.push(handler);
@@ -1176,6 +1358,18 @@ class HandlerExtractor {
           }
         }
       }
+      if (Node4.isSwitchStatement(node)) {
+        const switchHandlers = this.extractSwitchCaseHandlers(node, context, filePath);
+        handlers.push(...switchHandlers);
+      }
+      if (Node4.isVariableDeclaration(node)) {
+        const mapHandlers = this.extractHandlerMapPattern(node, context, filePath);
+        handlers.push(...mapHandlers);
+      }
+      if (Node4.isIfStatement(node)) {
+        const typeGuardHandlers = this.extractTypeGuardHandlers(node, context, filePath);
+        handlers.push(...typeGuardHandlers);
+      }
     });
     return handlers;
   }
@@ -1317,6 +1511,182 @@ class HandlerExtractor {
     }
     return;
   }
+  extractSwitchCaseHandlers(switchNode, context, filePath) {
+    const handlers = [];
+    try {
+      const expression = switchNode.getExpression();
+      const expressionText = expression.getText();
+      if (!/\.(type|kind|event|action)/.test(expressionText)) {
+        return handlers;
+      }
+      const caseClauses = switchNode.getClauses();
+      for (const clause of caseClauses) {
+        if (Node4.isCaseClause(clause)) {
+          const caseExpr = clause.getExpression();
+          let messageType = null;
+          if (Node4.isStringLiteral(caseExpr)) {
+            messageType = caseExpr.getLiteralValue();
+          }
+          if (messageType) {
+            const line = clause.getStartLineNumber();
+            handlers.push({
+              messageType,
+              node: context,
+              assignments: [],
+              preconditions: [],
+              postconditions: [],
+              location: { file: filePath, line }
+            });
+          }
+        }
+      }
+    } catch (error) {}
+    return handlers;
+  }
+  extractHandlerMapPattern(varDecl, context, filePath) {
+    const handlers = [];
+    try {
+      const initializer = varDecl.getInitializer();
+      if (!initializer || !Node4.isObjectLiteralExpression(initializer)) {
+        return handlers;
+      }
+      const varName = varDecl.getName().toLowerCase();
+      if (!/(handler|listener|callback|event)s?/.test(varName)) {
+        return handlers;
+      }
+      const properties = initializer.getProperties();
+      for (const prop of properties) {
+        if (Node4.isPropertyAssignment(prop)) {
+          const nameNode = prop.getNameNode();
+          let messageType = null;
+          if (Node4.isStringLiteral(nameNode)) {
+            messageType = nameNode.getLiteralValue();
+          } else if (Node4.isIdentifier(nameNode)) {
+            messageType = nameNode.getText();
+          }
+          if (messageType) {
+            const line = prop.getStartLineNumber();
+            handlers.push({
+              messageType,
+              node: context,
+              assignments: [],
+              preconditions: [],
+              postconditions: [],
+              location: { file: filePath, line }
+            });
+          }
+        }
+      }
+    } catch (error) {}
+    return handlers;
+  }
+  extractTypeGuardHandlers(ifNode, context, filePath) {
+    const handlers = [];
+    try {
+      const sourceFile = ifNode.getSourceFile();
+      let typeGuards = this.typeGuardCache.get(sourceFile);
+      if (!typeGuards) {
+        typeGuards = this.findTypePredicateFunctions(sourceFile);
+        this.typeGuardCache.set(sourceFile, typeGuards);
+      }
+      if (typeGuards.size === 0) {
+        return handlers;
+      }
+      let currentIf = ifNode;
+      while (currentIf) {
+        const handler = this.extractHandlerFromIfClause(currentIf, typeGuards, context, filePath);
+        if (handler) {
+          handlers.push(handler);
+        }
+        const elseStatement = currentIf.getElseStatement();
+        if (elseStatement && Node4.isIfStatement(elseStatement)) {
+          currentIf = elseStatement;
+        } else {
+          break;
+        }
+      }
+    } catch (error) {}
+    return handlers;
+  }
+  extractHandlerFromIfClause(ifNode, typeGuards, context, filePath) {
+    try {
+      const condition = ifNode.getExpression();
+      if (!Node4.isCallExpression(condition)) {
+        return null;
+      }
+      const funcExpr = condition.getExpression();
+      let funcName;
+      if (Node4.isIdentifier(funcExpr)) {
+        funcName = funcExpr.getText();
+      }
+      if (!funcName || !typeGuards.has(funcName)) {
+        return null;
+      }
+      const messageType = typeGuards.get(funcName);
+      const line = ifNode.getStartLineNumber();
+      return {
+        messageType,
+        node: context,
+        assignments: [],
+        preconditions: [],
+        postconditions: [],
+        location: { file: filePath, line }
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+  findTypePredicateFunctions(sourceFile) {
+    const typeGuards = new Map;
+    sourceFile.forEachDescendant((node) => {
+      if (Node4.isFunctionDeclaration(node) || Node4.isFunctionExpression(node) || Node4.isArrowFunction(node)) {
+        const returnType = node.getReturnType();
+        const returnTypeText = returnType.getText();
+        if (/is\s+\w+/.test(returnTypeText)) {
+          let functionName;
+          if (Node4.isFunctionDeclaration(node)) {
+            functionName = node.getName();
+          } else if (Node4.isFunctionExpression(node)) {
+            const parent = node.getParent();
+            if (Node4.isVariableDeclaration(parent)) {
+              functionName = parent.getName();
+            }
+          } else if (Node4.isArrowFunction(node)) {
+            const parent = node.getParent();
+            if (Node4.isVariableDeclaration(parent)) {
+              functionName = parent.getName();
+            }
+          }
+          if (functionName) {
+            let messageType = null;
+            const typeMatch = returnTypeText.match(/is\s+(\w+)/);
+            if (typeMatch) {
+              const typeName = typeMatch[1];
+              messageType = this.extractMessageTypeFromTypeName(typeName);
+            }
+            if (!messageType) {
+              const body = node.getBody();
+              if (body) {
+                const bodyText = body.getText();
+                const typeValueMatch = bodyText.match(/\.type\s*===?\s*['"](\w+)['"]/);
+                if (typeValueMatch) {
+                  messageType = typeValueMatch[1];
+                }
+              }
+            }
+            if (messageType) {
+              typeGuards.set(functionName, messageType);
+            }
+          }
+        }
+      }
+    });
+    return typeGuards;
+  }
+  extractMessageTypeFromTypeName(typeName) {
+    const messageType = typeName.replace(/Message$/, "").replace(/Event$/, "").replace(/Request$/, "").replace(/Command$/, "").replace(/Query$/, "").toLowerCase();
+    return messageType;
+  }
   inferContext(filePath) {
     const path2 = filePath.toLowerCase();
     if (path2.includes("/background/") || path2.includes("\\background\\")) {
@@ -1337,6 +1707,15 @@ class HandlerExtractor {
     if (path2.includes("/offscreen/") || path2.includes("\\offscreen\\")) {
       return "offscreen";
     }
+    if (path2.includes("/server/") || path2.includes("\\server\\") || path2.includes("/server.")) {
+      return "server";
+    }
+    if (path2.includes("/client/") || path2.includes("\\client\\") || path2.includes("/client.")) {
+      return "client";
+    }
+    if (path2.includes("/worker/") || path2.includes("\\worker\\") || path2.includes("service-worker")) {
+      return "worker";
+    }
     return "unknown";
   }
 }
@@ -1486,10 +1865,8 @@ class ArchitectureAnalyzer {
     let projectConfig;
     let entryPoints = {};
     let systemInfo;
-    const manifestPath = path4.join(this.options.projectRoot, "manifest.json");
-    const hasManifest = fs4.existsSync(manifestPath);
-    if (hasManifest && !this.options.useProjectDetector) {
-      const manifestParser = new ManifestParser(this.options.projectRoot);
+    const manifestParser = new ManifestParser(this.options.projectRoot, true);
+    if (manifestParser.hasManifest() && !this.options.useProjectDetector) {
       manifest = manifestParser.parse();
       entryPoints = manifestParser.getContextEntryPoints();
       systemInfo = {
@@ -2256,11 +2633,17 @@ async function generateCommand() {
     console.log(color(`   Using: ${tsConfigPath}`, COLORS.gray));
     const projectRoot = findProjectRoot();
     if (!projectRoot) {
-      console.error(color("❌ Could not find manifest.json", COLORS.red));
-      console.error("   Run this command from your extension project root");
+      console.error(color("❌ Could not find project root", COLORS.red));
+      console.error("   Run this command from a directory with manifest.json, package.json, or tsconfig.json");
       process.exit(1);
     }
     console.log(color(`   Project: ${projectRoot}`, COLORS.gray));
+    const hasManifest = fs6.existsSync(path6.join(projectRoot, "manifest.json"));
+    if (hasManifest) {
+      console.log(color(`   Type: Chrome Extension`, COLORS.gray));
+    } else {
+      console.log(color(`   Type: Detecting from project structure...`, COLORS.gray));
+    }
     const analysis = await analyzeArchitecture({
       tsConfigPath,
       projectRoot
@@ -2447,7 +2830,15 @@ async function serveCommand(args) {
 }
 function showHelp() {
   console.log(`
-${color("bun visualize", COLORS.blue)} - Architecture visualization for web extensions
+${color("bun visualize", COLORS.blue)} - Architecture visualization tool
+
+${color("Supports:", COLORS.blue)}
+
+  • Chrome Extensions (manifest.json)
+  • PWAs (public/manifest.json)
+  • WebSocket/Server Apps (ws, socket.io, elysia)
+  • Electron Apps
+  • Generic TypeScript Projects
 
 ${color("Commands:", COLORS.blue)}
 
@@ -2467,14 +2858,14 @@ ${color("Commands:", COLORS.blue)}
 
 ${color("Getting Started:", COLORS.blue)}
 
-  1. Run ${color("bun visualize", COLORS.green)} from your extension project root
+  1. Run ${color("bun visualize", COLORS.green)} from your project root
   2. Find generated ${color("docs/architecture.dsl", COLORS.blue)}
   3. View with Structurizr Lite (see instructions after generation)
 
 ${color("What gets generated:", COLORS.blue)}
 
-  • System Context diagram - Extension + external systems
-  • Container diagram - Extension contexts (background, content, popup, etc.)
+  • System Context diagram - Your app + external systems
+  • Container diagram - App contexts (background, content, server, client, etc.)
   • Component diagrams - Internal components within contexts
   • Dynamic diagrams - Message flows between contexts
 
@@ -2500,8 +2891,7 @@ function findTsConfig() {
 function findProjectRoot() {
   const locations = [process.cwd(), path6.join(process.cwd(), "..")];
   for (const loc of locations) {
-    const manifestPath = path6.join(loc, "manifest.json");
-    if (fs6.existsSync(manifestPath)) {
+    if (fs6.existsSync(path6.join(loc, "manifest.json")) || fs6.existsSync(path6.join(loc, "package.json")) || fs6.existsSync(path6.join(loc, "tsconfig.json"))) {
       return loc;
     }
   }
@@ -2519,4 +2909,4 @@ Stack trace:`, COLORS.gray));
   process.exit(1);
 });
 
-//# debugId=42A0D5368C5C715B64756E2164756E21
+//# debugId=2DAA9097DE2E4CFB64756E2164756E21