@fairfox/polly 0.85.1 → 0.86.0

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

@@ -20,8 +20,8 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 // tools/analysis/src/extract/project-detector.ts
 var exports_project_detector = {};
 __export(exports_project_detector, {
-  detectProjectConfig: () => detectProjectConfig,
-  ProjectDetector: () => ProjectDetector
+  ProjectDetector: () => ProjectDetector,
+  detectProjectConfig: () => detectProjectConfig
 });
 import * as fs3 from "node:fs";
 import * as path3 from "node:path";
@@ -666,9 +666,293 @@ function detectProjectConfig(projectRoot) {
 }
 var init_project_detector = () => {};
 
+// tools/verify/src/runner/container-name.ts
+function mintContainerName(kind) {
+  counter += 1;
+  const unique = crypto.randomUUID().slice(0, 8);
+  return `${CONTAINER_NAME_PREFIX}${sanitizeKind(kind)}-${process.pid}-${counter}-${unique}`;
+}
+function sanitizeKind(kind) {
+  const cleaned = kind.replace(/[^a-zA-Z0-9_.-]/g, "-");
+  return cleaned.length > 0 ? cleaned : "run";
+}
+var CONTAINER_NAME_PREFIX = "polly-tla-", counter = 0;
+
+// tools/verify/src/runner/docker.ts
+var exports_docker = {};
+__export(exports_docker, {
+  DockerRunner: () => DockerRunner,
+  removeContainer: () => removeContainer,
+  sweepOrphanedContainers: () => sweepOrphanedContainers,
+  sweepOrphanedContainersOnce: () => sweepOrphanedContainersOnce
+});
+import { spawn, spawnSync } from "node:child_process";
+import * as fs6 from "node:fs";
+import * as path5 from "node:path";
+function removeContainer(name) {
+  try {
+    spawnSync("docker", ["rm", "-f", name], { timeout: 1e4, stdio: "ignore" });
+  } catch {}
+}
+function sweepOrphanedContainersOnce() {
+  if (swept)
+    return [];
+  swept = true;
+  return sweepOrphanedContainers();
+}
+function sweepOrphanedContainers() {
+  try {
+    const listed = spawnSync("docker", [
+      "ps",
+      "--all",
+      "--filter",
+      "status=created",
+      "--filter",
+      `name=${CONTAINER_NAME_PREFIX}`,
+      "--format",
+      "{{.Names}}"
+    ], { timeout: 1e4, encoding: "utf8" });
+    const names = (listed.stdout ?? "").split(`
+`).map((line) => line.trim()).filter((line) => line.startsWith(CONTAINER_NAME_PREFIX));
+    for (const name of names) {
+      removeContainer(name);
+    }
+    return names;
+  } catch {
+    return [];
+  }
+}
+
+class DockerRunner {
+  IMAGE_NAME = "polly-tla:latest";
+  DOCKERFILE_PATH = path5.join(__dirname, "../../Dockerfile");
+  async isDockerAvailable() {
+    try {
+      const result = await this.runCommand("docker", ["info"], {
+        timeout: 5000
+      });
+      return result.exitCode === 0;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("timed out")) {
+        throw error;
+      }
+      return false;
+    }
+  }
+  async hasImage() {
+    try {
+      const result = await this.runCommand("docker", ["images", "-q", this.IMAGE_NAME], {
+        timeout: 1e4
+      });
+      return result.stdout.trim().length > 0;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("timed out")) {
+        throw error;
+      }
+      return false;
+    }
+  }
+  async buildImage(onProgress) {
+    const dockerfileDir = path5.dirname(this.DOCKERFILE_PATH);
+    await this.runCommandStreaming("docker", ["build", "-f", this.DOCKERFILE_PATH, "-t", this.IMAGE_NAME, dockerfileDir], onProgress, 300000);
+  }
+  async pullImage(onProgress) {
+    await this.buildImage(onProgress);
+  }
+  async runTLC(specPath, options) {
+    if (!fs6.existsSync(specPath)) {
+      throw new Error(`Spec file not found: ${specPath}`);
+    }
+    const specDir = path5.dirname(specPath);
+    const specName = path5.basename(specPath, ".tla");
+    const cfgPath = path5.join(specDir, `${specName}.cfg`);
+    if (!fs6.existsSync(cfgPath)) {
+      throw new Error(`Config file not found: ${cfgPath}`);
+    }
+    const statesDir = path5.join(specDir, "states");
+    if (fs6.existsSync(statesDir)) {
+      fs6.rmSync(statesDir, { recursive: true, force: true });
+    }
+    const containerName = mintContainerName("tlc");
+    sweepOrphanedContainersOnce();
+    const args = [
+      "run",
+      "--rm",
+      "--name",
+      containerName,
+      "-v",
+      `${specDir}:/work`,
+      this.IMAGE_NAME,
+      "tlc",
+      "-workers",
+      `${options?.workers || 1}`,
+      "-cleanup",
+      "-metadir",
+      "/tmp/states"
+    ];
+    if (options?.maxDepth !== undefined && options.maxDepth > 0) {
+      args.push("-depth", `${options.maxDepth}`);
+    }
+    args.push(`${specName}.tla`);
+    const result = await this.runCommand("docker", args, {
+      timeout: options?.timeout,
+      containerName
+    });
+    return this.parseTLCOutput(result);
+  }
+  parseTLCOutput(result) {
+    const output = result.stdout + result.stderr;
+    const violationMatch = output.match(/Error: Invariant (.*?) is violated/);
+    if (violationMatch) {
+      return {
+        success: false,
+        violation: {
+          type: "invariant",
+          name: violationMatch[1],
+          trace: this.extractTrace(output)
+        },
+        output
+      };
+    }
+    if (result.exitCode !== 0 || output.includes("Error:")) {
+      return {
+        success: false,
+        error: this.extractError(output),
+        output
+      };
+    }
+    const statesMatch = output.match(/(\d+) states generated/);
+    const distinctMatch = output.match(/(\d+) distinct states/);
+    return {
+      success: true,
+      stats: {
+        statesGenerated: statesMatch?.[1] ? Number.parseInt(statesMatch[1], 10) : 0,
+        distinctStates: distinctMatch?.[1] ? Number.parseInt(distinctMatch[1], 10) : 0
+      },
+      output
+    };
+  }
+  extractTrace(output) {
+    const lines = output.split(`
+`);
+    const trace = [];
+    let inTrace = false;
+    for (const line of lines) {
+      if (line.includes("State ") && line.includes(":")) {
+        inTrace = true;
+        trace.push(line);
+      } else if (inTrace) {
+        if (line.trim() === "" || line.startsWith("Error:")) {
+          break;
+        }
+        trace.push(line);
+      }
+    }
+    return trace;
+  }
+  extractError(output) {
+    if (/StatePool\w*\.run/.test(output) && /states\/.*No such file or directory/.test(output)) {
+      return "TLC state-pool IO failure (states/.../<n>: No such file or directory). This is a Docker filesystem flake, not a spec error — re-run the verification. See issue #152.";
+    }
+    const errorMatch = output.match(/Error: (.*?)(?:\n|$)/);
+    if (errorMatch?.[1]) {
+      return errorMatch[1];
+    }
+    if (output.includes("Parse Error")) {
+      return "TLA+ syntax error in specification";
+    }
+    if (output.includes("Semantic Error")) {
+      return "Semantic error in specification";
+    }
+    return "Unknown error occurred during model checking";
+  }
+  runCommand(command, args, options) {
+    return new Promise((resolve3, reject) => {
+      const proc = spawn(command, args);
+      let stdout = "";
+      let stderr = "";
+      proc.stdout.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr.on("data", (data) => {
+        stderr += data.toString();
+      });
+      const timeoutValue = options?.timeout ?? 0;
+      const timeout = timeoutValue > 0 ? setTimeout(() => {
+        proc.kill("SIGKILL");
+        if (options?.containerName) {
+          removeContainer(options.containerName);
+        }
+        reject(new Error(`Command timed out after ${Math.floor(timeoutValue / 1000)}s. TLC was still making progress. Consider increasing the timeout or setting timeout: 0 for no timeout.`));
+      }, timeoutValue) : null;
+      proc.on("close", (exitCode) => {
+        if (timeout)
+          clearTimeout(timeout);
+        resolve3({
+          exitCode: exitCode || 0,
+          stdout,
+          stderr
+        });
+      });
+      proc.on("error", (error) => {
+        if (timeout)
+          clearTimeout(timeout);
+        reject(error);
+      });
+    });
+  }
+  runCommandStreaming(command, args, onOutput, timeout) {
+    return new Promise((resolve3, reject) => {
+      const proc = spawn(command, args);
+      const timeoutHandle = timeout && timeout > 0 ? setTimeout(() => {
+        proc.kill();
+        reject(new Error(`Command timed out after ${Math.floor(timeout / 1000)}s. Docker may be unresponsive.`));
+      }, timeout) : null;
+      proc.stdout.on("data", (data) => {
+        if (onOutput) {
+          const lines = data.toString().split(`
+`);
+          for (const line of lines) {
+            if (line.trim()) {
+              onOutput(line.trim());
+            }
+          }
+        }
+      });
+      proc.stderr.on("data", (data) => {
+        if (onOutput) {
+          const lines = data.toString().split(`
+`);
+          for (const line of lines) {
+            if (line.trim()) {
+              onOutput(line.trim());
+            }
+          }
+        }
+      });
+      proc.on("close", (exitCode) => {
+        if (timeoutHandle)
+          clearTimeout(timeoutHandle);
+        if (exitCode === 0) {
+          resolve3();
+        } else {
+          reject(new Error(`Command failed with exit code ${exitCode}`));
+        }
+      });
+      proc.on("error", (error) => {
+        if (timeoutHandle)
+          clearTimeout(timeoutHandle);
+        reject(error);
+      });
+    });
+  }
+}
+var __dirname = "/Users/AJT/projects/polly/packages/polly/tools/verify/src/runner", swept = false;
+var init_docker = () => {};
+
 // tools/visualize/src/cli.ts
-import * as fs7 from "node:fs";
-import * as path6 from "node:path";
+import * as fs8 from "node:fs";
+import * as path7 from "node:path";
 
 // tools/analysis/src/extract/architecture.ts
 import * as fs4 from "node:fs";
@@ -1326,7 +1610,8 @@ class FlowAnalyzer {
 import {
   Node as Node4,
   Project as Project3,
-  SyntaxKind
+  SyntaxKind,
+  VariableDeclarationKind
 } from "ts-morph";
 
 // tools/analysis/src/extract/relationships.ts
@@ -2712,16 +2997,116 @@ class HandlerExtractor {
       return;
     }
     if (this.isTranslatableInitializer(initializer)) {
-      assignments.push({ field, value: `EXPR:${initializer.getText()}` });
+      const captured = this.resolveSignalAliases(this.unwrapParentheses(initializer));
+      assignments.push({ field, value: `EXPR:${captured}` });
       return;
     }
-    if (process.env["POLLY_DEBUG"]) {
-      const on = signalName ? ` on ${signalName}.value` : "";
-      console.log(`[WARN] dropped object-literal property '${name}'${on} — initializer kind ${initializer.getKindName()} is not translatable to TLA+`);
-    }
+    const on = signalName ? ` on ${signalName}.value` : "";
+    console.log(`[WARN] dropped object-literal property '${name}'${on} — initializer \`${initializer.getText().replace(/\s+/g, " ").slice(0, 80)}\` (${initializer.getKindName()}) is not translatable to TLA+`);
+  }
+  resolveSignalAliases(initializer) {
+    const aliases = this.collectSignalAliases(initializer);
+    if (aliases.size === 0)
+      return initializer.getText();
+    const base = initializer.getStart();
+    const edits = [];
+    const visit = (node) => {
+      if (!Node4.isPropertyAccessExpression(node))
+        return;
+      const target = node.getExpression();
+      if (!Node4.isIdentifier(target))
+        return;
+      const signal = aliases.get(target.getText());
+      if (!signal)
+        return;
+      edits.push({
+        start: target.getStart() - base,
+        end: target.getEnd() - base,
+        text: `${signal}.value`
+      });
+    };
+    visit(initializer);
+    initializer.forEachDescendant(visit);
+    if (edits.length === 0)
+      return initializer.getText();
+    let text = initializer.getText();
+    for (const edit of edits.sort((a, b) => b.start - a.start)) {
+      text = text.slice(0, edit.start) + edit.text + text.slice(edit.end);
+    }
+    return text;
+  }
+  collectSignalAliases(node) {
+    const aliases = new Map;
+    const fn = node.getFirstAncestor((a) => Node4.isArrowFunction(a) || Node4.isFunctionExpression(a) || Node4.isFunctionDeclaration(a));
+    if (!fn)
+      return aliases;
+    const reassigned = this.collectReassignedIdentifiers(fn);
+    fn.forEachDescendant((inner) => {
+      if (!Node4.isVariableDeclaration(inner))
+        return;
+      const binding = this.readSignalAliasBinding(inner);
+      if (!binding)
+        return;
+      if (aliases.has(binding.signal))
+        return;
+      if (reassigned.has(binding.alias))
+        return;
+      aliases.set(binding.alias, binding.signal);
+    });
+    return aliases;
+  }
+  collectReassignedIdentifiers(fn) {
+    const reassigned = new Set;
+    fn.forEachDescendant((inner) => {
+      if (!Node4.isBinaryExpression(inner))
+        return;
+      if (inner.getOperatorToken().getText() !== "=")
+        return;
+      const left = inner.getLeft();
+      if (Node4.isIdentifier(left))
+        reassigned.add(left.getText());
+    });
+    return reassigned;
+  }
+  readSignalAliasBinding(decl) {
+    const list = decl.getParent();
+    if (!Node4.isVariableDeclarationList(list))
+      return null;
+    if (list.getDeclarationKind() !== VariableDeclarationKind.Const)
+      return null;
+    const nameNode = decl.getNameNode();
+    if (!Node4.isIdentifier(nameNode))
+      return null;
+    const init = decl.getInitializer();
+    if (!init || !Node4.isPropertyAccessExpression(init))
+      return null;
+    if (init.getName() !== "value")
+      return null;
+    const target = init.getExpression();
+    if (!Node4.isIdentifier(target))
+      return null;
+    return { alias: nameNode.getText(), signal: target.getText() };
   }
   isTranslatableInitializer(node) {
-    return Node4.isBinaryExpression(node) || Node4.isPropertyAccessExpression(node) || Node4.isElementAccessExpression(node) || Node4.isPrefixUnaryExpression(node) || Node4.isPostfixUnaryExpression(node) || Node4.isParenthesizedExpression(node);
+    const kindAllowed = Node4.isBinaryExpression(node) || Node4.isPropertyAccessExpression(node) || Node4.isElementAccessExpression(node) || Node4.isPrefixUnaryExpression(node) || Node4.isPostfixUnaryExpression(node) || Node4.isParenthesizedExpression(node) || Node4.isConditionalExpression(node);
+    if (!kindAllowed)
+      return false;
+    if (this.containsComment(node))
+      return false;
+    if (node.getFirstDescendantByKind(SyntaxKind.CallExpression))
+      return false;
+    return this.unwrapParentheses(node).getFirstDescendantByKind(SyntaxKind.ConditionalExpression) === undefined;
+  }
+  unwrapParentheses(node) {
+    let current = node;
+    while (Node4.isParenthesizedExpression(current)) {
+      current = current.getExpression();
+    }
+    return current;
+  }
+  containsComment(node) {
+    const text = node.getText();
+    return text.includes("//") || text.includes("/*");
   }
   extractPayloadPropertyParam(initializer) {
     if (!Node4.isPropertyAccessExpression(initializer))
@@ -6486,24 +6871,25 @@ function generateStructurizrDSL(analysis, options) {
 }
 
 // tools/visualize/src/runner/export.ts
-import { spawn } from "node:child_process";
-import * as fs6 from "node:fs";
-import * as path5 from "node:path";
+init_docker();
+import { spawn as spawn2 } from "node:child_process";
+import * as fs7 from "node:fs";
+import * as path6 from "node:path";
 
 class DiagramExporter {
   static DOCKER_IMAGE = "structurizr/structurizr:latest";
   static DEFAULT_TIMEOUT = 120000;
   async export(options) {
     const { dslPath, outputDir, timeout = DiagramExporter.DEFAULT_TIMEOUT } = options;
-    if (!fs6.existsSync(dslPath)) {
+    if (!fs7.existsSync(dslPath)) {
       return {
         success: false,
         siteDir: "",
         error: `DSL file not found: ${dslPath}`
       };
     }
-    if (!fs6.existsSync(outputDir)) {
-      fs6.mkdirSync(outputDir, { recursive: true });
+    if (!fs7.existsSync(outputDir)) {
+      fs7.mkdirSync(outputDir, { recursive: true });
     }
     const dockerAvailable = await this.isDockerAvailable();
     if (!dockerAvailable) {
@@ -6536,13 +6922,16 @@ class DiagramExporter {
     }
   }
   async exportStaticSite(dslPath, outputDir, timeout) {
-    const dslDir = path5.dirname(dslPath);
-    const dslFileName = path5.basename(dslPath);
+    const dslDir = path6.dirname(dslPath);
+    const dslFileName = path6.basename(dslPath);
     const workspaceMount = `${dslDir}:/usr/local/structurizr`;
     const outputMount = `${outputDir}:/output`;
+    const containerName = mintContainerName("structurizr");
     const args = [
       "run",
       "--rm",
+      "--name",
+      containerName,
       "-v",
       workspaceMount,
       "-v",
@@ -6556,7 +6945,7 @@ class DiagramExporter {
       "-o",
       "/output"
     ];
-    await this.runDocker(args, timeout);
+    await this.runDocker(args, timeout, containerName);
   }
   async isDockerAvailable() {
     try {
@@ -6576,7 +6965,7 @@ class DiagramExporter {
   }
   async pullImage(onProgress) {
     return new Promise((resolve3, reject) => {
-      const proc = spawn("docker", ["pull", DiagramExporter.DOCKER_IMAGE]);
+      const proc = spawn2("docker", ["pull", DiagramExporter.DOCKER_IMAGE]);
       proc.stdout.on("data", (data) => {
         onProgress?.(data.toString().trim());
       });
@@ -6595,16 +6984,19 @@ class DiagramExporter {
       });
     });
   }
-  async runDocker(args, timeout) {
-    return this.runCommand("docker", args, timeout);
+  async runDocker(args, timeout, containerName) {
+    return this.runCommand("docker", args, timeout, containerName);
   }
-  async runCommand(command, args, timeout) {
+  async runCommand(command, args, timeout, containerName) {
     return new Promise((resolve3, reject) => {
-      const proc = spawn(command, args);
+      const proc = spawn2(command, args);
       let stdout = "";
       let stderr = "";
       const timer = setTimeout(() => {
-        proc.kill();
+        proc.kill("SIGKILL");
+        if (containerName) {
+          removeContainer(containerName);
+        }
         reject(new Error(`Command timed out after ${timeout}ms`));
       }, timeout);
       proc.stdout.on("data", (data) => {
@@ -6741,7 +7133,7 @@ function findAndDisplayProjectConfig() {
   return { tsConfigPath, projectRoot };
 }
 function displayProjectType(projectRoot) {
-  const hasManifest = fs7.existsSync(path6.join(projectRoot, "manifest.json"));
+  const hasManifest = fs8.existsSync(path7.join(projectRoot, "manifest.json"));
   const projectType = hasManifest ? "Chrome Extension" : "Detecting from project structure...";
   console.log(color(`   Type: ${projectType}`, COLORS.gray));
 }
@@ -6786,16 +7178,16 @@ function generateAndWriteDSL(analysis, snapshot) {
     componentDiagramContexts: contextTypes.length > 0 ? contextTypes : ["background"],
     snapshot
   });
-  const outputDir = path6.join(process.cwd(), "docs");
-  if (!fs7.existsSync(outputDir)) {
-    fs7.mkdirSync(outputDir, { recursive: true });
+  const outputDir = path7.join(process.cwd(), "docs");
+  if (!fs8.existsSync(outputDir)) {
+    fs8.mkdirSync(outputDir, { recursive: true });
   }
-  const dslPath = path6.join(outputDir, "architecture.dsl");
-  fs7.writeFileSync(dslPath, dsl, "utf-8");
+  const dslPath = path7.join(outputDir, "architecture.dsl");
+  fs8.writeFileSync(dslPath, dsl, "utf-8");
   return dslPath;
 }
 function displayNextSteps(dslPath) {
-  const outputDir = path6.join(process.cwd(), "docs");
+  const outputDir = path7.join(process.cwd(), "docs");
   console.log(color(`✅ Architecture documentation generated!
 `, COLORS.green));
   console.log(`   File: ${color(dslPath, COLORS.blue)}`);
@@ -6826,11 +7218,11 @@ async function exportCommand(_args) {
 \uD83D\uDCE4 Generating static site...
 `, COLORS.blue));
   try {
-    const dslPath = path6.join(process.cwd(), "docs", "architecture.dsl");
-    if (!fs7.existsSync(dslPath)) {
+    const dslPath = path7.join(process.cwd(), "docs", "architecture.dsl");
+    if (!fs8.existsSync(dslPath)) {
       process.exit(1);
     }
-    const outputDir = path6.join(process.cwd(), "docs", "site");
+    const outputDir = path7.join(process.cwd(), "docs", "site");
     console.log(color(`   DSL: ${dslPath}`, COLORS.gray));
     console.log(color(`   Output: ${outputDir}`, COLORS.gray));
     console.log();
@@ -6863,9 +7255,9 @@ async function serveCommand(args) {
 \uD83C\uDF10 Starting static site server...
 `, COLORS.blue));
   try {
-    const siteDir = path6.join(process.cwd(), "docs", "site");
-    const indexPath = path6.join(siteDir, "index.html");
-    if (!fs7.existsSync(indexPath)) {
+    const siteDir = path7.join(process.cwd(), "docs", "site");
+    const indexPath = path7.join(siteDir, "index.html");
+    if (!fs8.existsSync(indexPath)) {
       process.exit(1);
     }
     const portArg = args.find((arg) => arg.startsWith("--port="));
@@ -6881,8 +7273,8 @@ async function serveCommand(args) {
       port,
       fetch(req) {
         const url = new URL(req.url);
-        const filePath = path6.join(siteDir, url.pathname === "/" ? "index.html" : url.pathname);
-        if (fs7.existsSync(filePath) && fs7.statSync(filePath).isFile()) {
+        const filePath = path7.join(siteDir, url.pathname === "/" ? "index.html" : url.pathname);
+        if (fs8.existsSync(filePath) && fs8.statSync(filePath).isFile()) {
           const file = BunGlobal.file(filePath);
           return new Response(file);
         }
@@ -6966,20 +7358,20 @@ ${color("Learn More:", COLORS.blue)}
 }
 function findTsConfig() {
   const locations = [
-    path6.join(process.cwd(), "tsconfig.json"),
-    path6.join(process.cwd(), "..", "tsconfig.json")
+    path7.join(process.cwd(), "tsconfig.json"),
+    path7.join(process.cwd(), "..", "tsconfig.json")
   ];
   for (const loc of locations) {
-    if (fs7.existsSync(loc)) {
+    if (fs8.existsSync(loc)) {
       return loc;
     }
   }
   return null;
 }
 function findProjectRoot() {
-  const locations = [process.cwd(), path6.join(process.cwd(), "..")];
+  const locations = [process.cwd(), path7.join(process.cwd(), "..")];
   for (const loc of locations) {
-    if (fs7.existsSync(path6.join(loc, "manifest.json")) || fs7.existsSync(path6.join(loc, "package.json")) || fs7.existsSync(path6.join(loc, "tsconfig.json"))) {
+    if (fs8.existsSync(path7.join(loc, "manifest.json")) || fs8.existsSync(path7.join(loc, "package.json")) || fs8.existsSync(path7.join(loc, "tsconfig.json"))) {
       return loc;
     }
   }
@@ -6989,4 +7381,4 @@ main().catch((_error) => {
   process.exit(1);
 });
 
-//# debugId=4CA1C5520447E2E464756E2164756E21
+//# debugId=B0F08E74B7BC706B64756E2164756E21