@launchsecure/launch-kit 0.0.3 → 0.0.4

package/dist/server/cli.js

@@ -6341,6 +6341,7 @@ function getTs() {
   }
   return tsModule;
 }
+var HTTP_METHODS = /* @__PURE__ */ new Set(["get", "post", "put", "patch", "delete", "head", "options"]);
 function parseFile(absPath) {
   const ts = getTs();
   const content = (0, import_node_fs.readFileSync)(absPath, "utf-8");
@@ -6363,6 +6364,8 @@ function parseFile(absPath) {
   const reExports = [];
   const jsxElements = /* @__PURE__ */ new Set();
   const navigations = [];
+  const fetchCalls = [];
+  const includeConcat = process.env.LAUNCH_CHART_INCLUDE_CONCAT_FETCHES === "1";
   function addExport(name2, kind) {
     if (!exportsSet.has(name2)) {
       exportsSet.add(name2);
@@ -6385,6 +6388,33 @@ function parseFile(absPath) {
     }
     return null;
   }
+  function looksLikeUrl(s) {
+    return s.startsWith("/") || /^(https?:)?\/\//i.test(s);
+  }
+  function templateStartsWithSlash(expr) {
+    const head = expr.head.text;
+    return head.startsWith("/");
+  }
+  function extractUrlFromFetchArg(arg) {
+    if (ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg)) {
+      if (!looksLikeUrl(arg.text)) return null;
+      return { url: arg.text, isTemplate: false };
+    }
+    if (ts.isTemplateExpression(arg)) {
+      if (!templateStartsWithSlash(arg)) return null;
+      return { url: arg.getText(sourceFile), isTemplate: true };
+    }
+    if (includeConcat && ts.isBinaryExpression(arg) && arg.operatorToken.kind === ts.SyntaxKind.PlusToken) {
+      let leftmost = arg;
+      while (ts.isBinaryExpression(leftmost) && leftmost.operatorToken.kind === ts.SyntaxKind.PlusToken) {
+        leftmost = leftmost.left;
+      }
+      if ((ts.isStringLiteral(leftmost) || ts.isNoSubstitutionTemplateLiteral(leftmost)) && leftmost.text.startsWith("/")) {
+        return { url: arg.getText(sourceFile), isTemplate: false, isConcat: true };
+      }
+    }
+    return null;
+  }
   function visit(node) {
     if (ts.isImportDeclaration(node)) {
       const moduleSpec = node.moduleSpecifier;
@@ -6408,6 +6438,8 @@ function parseFile(absPath) {
         }
         if (names.length > 0 || isTypeOnly) {
           imports.push({ names, specifier, isTypeOnly, typeNames });
+        } else if (!clause) {
+          imports.push({ names: [], specifier, isTypeOnly: false, typeNames: /* @__PURE__ */ new Set() });
         }
       }
     }
@@ -6421,6 +6453,19 @@ function parseFile(absPath) {
             reExports.push({ name: exportedName, from: fromSpec });
           }
         }
+      } else if (!node.exportClause && fromSpec) {
+        reExports.push({ name: "*", from: fromSpec, isWildcard: true });
+      }
+    }
+    if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+      const arg = node.arguments[0];
+      if (arg && ts.isStringLiteral(arg)) {
+        imports.push({
+          names: [],
+          specifier: arg.text,
+          isTypeOnly: false,
+          typeNames: /* @__PURE__ */ new Set()
+        });
       }
     }
     if (ts.isExportAssignment(node) && !node.isExportEquals) {
@@ -6482,6 +6527,36 @@ function parseFile(absPath) {
         }
       }
     }
+    if (ts.isCallExpression(node) && node.arguments.length > 0) {
+      const expr = node.expression;
+      const firstArg = node.arguments[0];
+      if (ts.isIdentifier(expr) && expr.text === "fetch") {
+        const extracted = extractUrlFromFetchArg(firstArg);
+        if (extracted) {
+          fetchCalls.push({
+            url: extracted.url,
+            isTemplate: extracted.isTemplate,
+            ...extracted.isConcat ? { isConcat: true } : {},
+            kind: "fetch"
+          });
+        }
+      }
+      if (ts.isPropertyAccessExpression(expr) && ts.isIdentifier(expr.name)) {
+        const methodName = expr.name.text;
+        if (HTTP_METHODS.has(methodName)) {
+          const extracted = extractUrlFromFetchArg(firstArg);
+          if (extracted) {
+            fetchCalls.push({
+              method: methodName.toUpperCase(),
+              url: extracted.url,
+              isTemplate: extracted.isTemplate,
+              ...extracted.isConcat ? { isConcat: true } : {},
+              kind: "client-method"
+            });
+          }
+        }
+      }
+    }
     if (ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node)) {
       const tagName = node.tagName;
       if (ts.isIdentifier(tagName) && tagName.text === "Link") {
@@ -6531,7 +6606,8 @@ function parseFile(absPath) {
     imports,
     reExports,
     jsxElements,
-    navigations
+    navigations,
+    fetchCalls
   };
 }
 var MUTATION_METHODS = /* @__PURE__ */ new Set([
@@ -6610,6 +6686,19 @@ function walk(dir, exts) {
   }
   return results;
 }
+function walkWithIgnore(dir, exts, ignoreDirs) {
+  const results = [];
+  if (!(0, import_node_fs2.existsSync)(dir)) return results;
+  for (const entry of (0, import_node_fs2.readdirSync)(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) {
+      if (ignoreDirs.has(entry.name)) continue;
+      results.push(...walkWithIgnore((0, import_node_path2.join)(dir, entry.name), exts, ignoreDirs));
+    } else if (exts.includes((0, import_node_path2.extname)(entry.name))) {
+      results.push((0, import_node_path2.join)(dir, entry.name));
+    }
+  }
+  return results;
+}
 function toNodeId(srcDir, absPath) {
   return (0, import_node_path2.relative)(srcDir, absPath).replace(/\\/g, "/");
 }
@@ -6629,20 +6718,58 @@ function resolveRelativeImport(fromFile, specifier) {
   }
   return null;
 }
+function resolveBarrelMap(barrelAbsPath, parsedByPath, memo, visiting) {
+  const cached = memo.get(barrelAbsPath);
+  if (cached) return cached;
+  if (visiting.has(barrelAbsPath)) return /* @__PURE__ */ new Map();
+  visiting.add(barrelAbsPath);
+  const parsed = parsedByPath.get(barrelAbsPath);
+  const map = /* @__PURE__ */ new Map();
+  if (!parsed) {
+    visiting.delete(barrelAbsPath);
+    memo.set(barrelAbsPath, map);
+    return map;
+  }
+  for (const re of parsed.reExports) {
+    if (!re.from.startsWith(".")) continue;
+    const resolved = resolveRelativeImport(barrelAbsPath, re.from);
+    if (!resolved) continue;
+    if (re.isWildcard) {
+      const targetBn = (0, import_node_path2.basename)(resolved);
+      const targetIsBarrel = targetBn === "index.ts" || targetBn === "index.tsx";
+      if (targetIsBarrel) {
+        const nested = resolveBarrelMap(resolved, parsedByPath, memo, visiting);
+        for (const [name, target] of nested) {
+          if (!map.has(name)) map.set(name, target);
+        }
+      } else {
+        const targetParsed = parsedByPath.get(resolved);
+        if (targetParsed) {
+          for (const exp of targetParsed.exports) {
+            if (!map.has(exp)) map.set(exp, resolved);
+          }
+        }
+      }
+    } else {
+      if (!map.has(re.name)) map.set(re.name, resolved);
+    }
+  }
+  visiting.delete(barrelAbsPath);
+  memo.set(barrelAbsPath, map);
+  return map;
+}
 function buildAllBarrelMaps(srcDir, parsedByPath) {
   const barrels = /* @__PURE__ */ new Map();
+  const memo = /* @__PURE__ */ new Map();
   for (const [absPath, parsed] of parsedByPath) {
     const bn = (0, import_node_path2.basename)(absPath);
     if (bn !== "index.ts" && bn !== "index.tsx") continue;
     if (parsed.reExports.length === 0) continue;
-    const barrelId = (0, import_node_path2.relative)(srcDir, (0, import_node_path2.dirname)(absPath)).replace(/\\/g, "/");
-    const map = /* @__PURE__ */ new Map();
-    for (const re of parsed.reExports) {
-      if (!re.from.startsWith(".")) continue;
-      const resolved = resolveRelativeImport(absPath, re.from);
-      if (resolved) map.set(re.name, resolved);
+    const map = resolveBarrelMap(absPath, parsedByPath, memo, /* @__PURE__ */ new Set());
+    if (map.size > 0) {
+      const barrelId = (0, import_node_path2.relative)(srcDir, (0, import_node_path2.dirname)(absPath)).replace(/\\/g, "/");
+      barrels.set(barrelId, map);
     }
-    if (map.size > 0) barrels.set(barrelId, map);
   }
   return barrels;
 }
@@ -6780,6 +6907,105 @@ function matchRouteToPage(route, routeToNodeId) {
   if (routeToNodeId.has(normalized)) return routeToNodeId.get(normalized);
   return null;
 }
+function loadApiRoutes(rootDir) {
+  const apiJsonPath = (0, import_node_path2.join)(rootDir, ".launchsecure", "graphs", "api.json");
+  if (!(0, import_node_fs2.existsSync)(apiJsonPath)) return [];
+  try {
+    const parsed = JSON.parse((0, import_node_fs2.readFileSync)(apiJsonPath, "utf-8"));
+    const routes = [];
+    for (const n of parsed.nodes ?? []) {
+      const path9 = n.path;
+      if (!path9 || typeof path9 !== "string") continue;
+      routes.push({
+        path: path9,
+        nodeId: n.id,
+        segments: path9.split("/").filter(Boolean)
+      });
+    }
+    return routes;
+  } catch {
+    return [];
+  }
+}
+function buildApiPathMap(routes) {
+  const map = /* @__PURE__ */ new Map();
+  for (const r of routes) {
+    if (!map.has(r.path)) map.set(r.path, r.nodeId);
+  }
+  return map;
+}
+function normalizeFetchUrl(raw) {
+  let s = raw.replace(/^`|`$/g, "");
+  const qIdx = s.indexOf("?");
+  if (qIdx >= 0) s = s.slice(0, qIdx);
+  const hIdx = s.indexOf("#");
+  if (hIdx >= 0) s = s.slice(0, hIdx);
+  let hadInterpolation = false;
+  s = s.replace(/\$\{([^}]+)\}/g, (_, expr) => {
+    hadInterpolation = true;
+    const cleaned = expr.trim();
+    const last = cleaned.split(".").pop() ?? cleaned;
+    const name = last.replace(/[^\w]/g, "") || "param";
+    return ":" + name;
+  });
+  s = s.replace(/\/+/g, "/");
+  if (s.length > 1 && s.endsWith("/")) s = s.slice(0, -1);
+  return { path: s || "/", hadInterpolation };
+}
+function scoreApiRouteMatch(candidate, known) {
+  if (candidate.length !== known.length) return -1;
+  let score = 0;
+  for (let i = 0; i < candidate.length; i++) {
+    const a = candidate[i];
+    const b = known[i];
+    if (a === b) {
+      score += 3;
+      continue;
+    }
+    if (a.startsWith(":") && b.startsWith(":")) {
+      score += 2;
+      continue;
+    }
+    if (a.startsWith(":") || b.startsWith(":")) {
+      score += 1;
+      continue;
+    }
+    return -1;
+  }
+  return score;
+}
+function resolveFetchCall(call, apiPathMap, apiRoutes) {
+  const raw = call.url;
+  if (/^(https?:)?\/\//i.test(raw)) {
+    return { kind: "external", normalizedUrl: raw };
+  }
+  if (call.isConcat) {
+    return { kind: "dynamic", normalizedUrl: raw };
+  }
+  const { path: path9, hadInterpolation } = normalizeFetchUrl(raw);
+  if (!path9.startsWith("/")) {
+    return { kind: "unresolved", normalizedUrl: path9 };
+  }
+  const segs = path9.split("/").filter(Boolean);
+  if (hadInterpolation && segs.length > 0 && segs[0].startsWith(":")) {
+    return { kind: "dynamic", normalizedUrl: path9 };
+  }
+  const exact = apiPathMap.get(path9);
+  if (exact) return { kind: "resolved", nodeId: exact, normalizedUrl: path9 };
+  let bestScore = -1;
+  let bestId = null;
+  for (const r of apiRoutes) {
+    const score = scoreApiRouteMatch(segs, r.segments);
+    if (score > bestScore) {
+      bestScore = score;
+      bestId = r.nodeId;
+    }
+  }
+  if (bestId && bestScore > 0) {
+    return { kind: "resolved", nodeId: bestId, normalizedUrl: path9 };
+  }
+  return { kind: "unresolved", normalizedUrl: path9 };
+}
 function extractEdges(srcDir, absPath, sourceId, parsed, nodeIdSet, nodeTypeMap, barrelMaps, routeToNodeId) {
   const edges = [];
   const flagged = [];
@@ -6884,7 +7110,7 @@ function detect(rootDir) {
 function generate(rootDir) {
   const srcDir = (0, import_node_path2.join)(rootDir, "src");
   const appFiles = walk((0, import_node_path2.join)(srcDir, "app"), [".tsx", ".ts"]).filter(
-    (f) => f.endsWith("/page.tsx") || f.endsWith("/layout.tsx")
+    (f) => (0, import_node_path2.basename)(f) !== "route.ts" && (0, import_node_path2.basename)(f) !== "route.tsx"
   );
   const clientFiles = walk((0, import_node_path2.join)(srcDir, "client"), [".tsx", ".ts"]);
   const serverFiles = walk((0, import_node_path2.join)(srcDir, "server"), [".ts", ".tsx"]).filter(
@@ -6917,6 +7143,7 @@ function generate(rootDir) {
   }
   const allEdges = [];
   const allFlagged = [];
+  const crossRefs = [];
   for (const absPath of fileSet) {
     const sourceId = toNodeId(srcDir, absPath);
     const parsed = parsedByPath.get(absPath);
@@ -6933,6 +7160,139 @@ function generate(rootDir) {
     allEdges.push(...edges);
     allFlagged.push(...flagged);
   }
+  const apiRoutes = loadApiRoutes(rootDir);
+  const apiPathMap = buildApiPathMap(apiRoutes);
+  const includeExternalFetches = process.env.LAUNCH_CHART_INCLUDE_EXTERNAL_FETCHES === "1";
+  const fetchSeen = /* @__PURE__ */ new Set();
+  let fetchResolvedCount = 0;
+  let fetchDynamicCount = 0;
+  let fetchUnresolvedCount = 0;
+  let fetchExternalCount = 0;
+  for (const absPath of fileSet) {
+    const sourceId = toNodeId(srcDir, absPath);
+    const parsed = parsedByPath.get(absPath);
+    if (parsed.fetchCalls.length === 0) continue;
+    for (const call of parsed.fetchCalls) {
+      const result = resolveFetchCall(call, apiPathMap, apiRoutes);
+      const methodTag = call.method ?? (call.kind === "fetch" ? "GET?" : "?");
+      if (result.kind === "resolved" && result.nodeId) {
+        const key = `${sourceId}\u2192${result.nodeId}\u2192calls_api`;
+        if (fetchSeen.has(key)) continue;
+        fetchSeen.add(key);
+        crossRefs.push({
+          source: sourceId,
+          target: result.nodeId,
+          type: "calls_api",
+          layer: "api"
+        });
+        fetchResolvedCount++;
+        continue;
+      }
+      if (result.kind === "dynamic") {
+        fetchDynamicCount++;
+        allFlagged.push({
+          source: sourceId,
+          target: "DYNAMIC",
+          type: "calls_api",
+          label: call.isConcat ? `${methodTag} fetch with concat: ${call.url}` : `${methodTag} fetch with template: ${call.url}`,
+          confidence: call.isConcat ? "low" : "medium"
+        });
+        continue;
+      }
+      if (result.kind === "external") {
+        fetchExternalCount++;
+        if (!includeExternalFetches) continue;
+        allFlagged.push({
+          source: sourceId,
+          target: "EXTERNAL",
+          type: "calls_external",
+          label: `${methodTag} external fetch: ${call.url}`,
+          confidence: "high"
+        });
+        continue;
+      }
+      fetchUnresolvedCount++;
+      allFlagged.push({
+        source: sourceId,
+        target: "UNRESOLVED",
+        type: "calls_api",
+        label: `${methodTag} fetch to unknown path: ${result.normalizedUrl}`,
+        confidence: "medium"
+      });
+    }
+  }
+  const externalScanned = new Set(allDiscovered.map((f) => f.replace(/\\/g, "/")));
+  const IGNORE_DIRS = /* @__PURE__ */ new Set([
+    "node_modules",
+    ".next",
+    "dist",
+    ".launchsecure",
+    ".git",
+    "src",
+    "coverage",
+    ".turbo",
+    "build",
+    "out",
+    ".vercel"
+  ]);
+  const externalCandidates = walkWithIgnore(rootDir, [".ts", ".tsx"], IGNORE_DIRS);
+  for (const absPath of externalCandidates) {
+    const normalized = absPath.replace(/\\/g, "/");
+    if (externalScanned.has(normalized)) continue;
+    let parsed;
+    try {
+      parsed = parseFile(absPath);
+    } catch {
+      continue;
+    }
+    const externalId = (0, import_node_path2.relative)(rootDir, absPath).replace(/\\/g, "/");
+    const edgesFromThis = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const imp of parsed.imports) {
+      const { specifier, isTypeOnly, names } = imp;
+      let resolved = null;
+      if (specifier.startsWith("@/")) {
+        const relToSrc = specifier.slice(2);
+        const barrelMap = barrelMaps.get(relToSrc);
+        if (barrelMap && names.length > 0) {
+          for (const name of names) {
+            const targetAbs = barrelMap.get(name);
+            if (!targetAbs) continue;
+            const targetId2 = toNodeId(srcDir, targetAbs);
+            if (!nodeIdSet.has(targetId2)) continue;
+            const key2 = `${externalId}\u2192${targetId2}`;
+            if (seen.has(key2)) continue;
+            seen.add(key2);
+            edgesFromThis.push({ source: externalId, target: targetId2, type: "imports" });
+          }
+          continue;
+        }
+        resolved = resolveImport(srcDir, specifier);
+      } else if (specifier.startsWith(".")) {
+        resolved = resolveRelativeImport(absPath, specifier);
+      }
+      if (!resolved) continue;
+      const targetId = toNodeId(srcDir, resolved);
+      if (!nodeIdSet.has(targetId)) continue;
+      if (targetId.endsWith("/index.ts") || targetId.endsWith("/index.tsx")) continue;
+      const key = `${externalId}\u2192${targetId}\u2192${isTypeOnly ? "type" : "value"}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      edgesFromThis.push({ source: externalId, target: targetId, type: "imports" });
+    }
+    if (edgesFromThis.length === 0) continue;
+    nodes.push({
+      id: externalId,
+      type: "external",
+      name: parsed.name || nameFromFilename(absPath),
+      route: null,
+      module: "external",
+      exports: parsed.exports
+    });
+    nodeIdSet.add(externalId);
+    nodeTypeMap.set(externalId, "external");
+    allEdges.push(...edgesFromThis);
+  }
   const flaggedSet = /* @__PURE__ */ new Set();
   const dedupedFlagged = allFlagged.filter((f) => {
     const key = `${f.source}\u2192${f.target}\u2192${f.label}`;
@@ -6964,6 +7324,7 @@ function generate(rootDir) {
     total_configs: byType("config"),
     total_utils: byType("util"),
     total_libs: byType("lib"),
+    total_external: byType("external"),
     total_edges: allEdges.length,
     total_flagged: dedupedFlagged.length
   };
@@ -6975,11 +7336,20 @@ function generate(rootDir) {
       layer: "ui",
       parser: "react-nextjs-ast",
       ...stats,
+      api_call_detection: {
+        includeExternalFetches,
+        includeConcatFetches: process.env.LAUNCH_CHART_INCLUDE_CONCAT_FETCHES === "1",
+        apiRoutesLoaded: apiRoutes.length,
+        resolved: fetchResolvedCount,
+        dynamic: fetchDynamicCount,
+        unresolved: fetchUnresolvedCount,
+        external: fetchExternalCount
+      },
       notes: "Auto-generated via TypeScript AST \u2014 edges derived from actual imports, renders from JSX usage, navigations from router/Link calls."
     },
     nodes,
     edges: allEdges,
-    cross_refs: [],
+    cross_refs: crossRefs,
     contradictions: [],
     warnings: [],
     flagged_edges: dedupedFlagged,
@@ -7004,7 +7374,7 @@ var reactNextjsParser = {
 // src/server/graph/parsers/api/nextjs-routes.ts
 var import_node_fs3 = require("node:fs");
 var import_node_path3 = require("node:path");
-var HTTP_METHODS = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]);
+var HTTP_METHODS2 = /* @__PURE__ */ new Set(["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]);
 function walk2(dir) {
   const results = [];
   if (!(0, import_node_fs3.existsSync)(dir)) return results;
@@ -7048,7 +7418,7 @@ function generate2(rootDir) {
     const authWrappers = extractAuthWrappers(absPath);
     const methods = [];
     for (const exp of parsed.exports) {
-      if (HTTP_METHODS.has(exp)) methods.push(exp);
+      if (HTTP_METHODS2.has(exp)) methods.push(exp);
     }
     const routePath = filePathToRoute(apiDir, absPath);
     const relPath = (0, import_node_path3.relative)(rootDir, absPath).replace(/\\/g, "/");
@@ -7118,7 +7488,7 @@ function generate2(rootDir) {
     flagged_edges: [],
     patterns: {
       total_endpoints: nodes.length,
-      methods_breakdown: [...HTTP_METHODS].reduce((acc, m) => {
+      methods_breakdown: [...HTTP_METHODS2].reduce((acc, m) => {
         acc[m] = nodes.filter((n) => n.methods.includes(m)).length;
         return acc;
       }, {}),
@@ -7310,13 +7680,14 @@ function generateLayer(rootDir, layer) {
   };
 }
 function generateAll(rootDir) {
-  const layers = ["ui", "api", "db"];
+  const layers = ["api", "db", "ui"];
   const results = [];
   for (const layer of layers) {
     const result = generateLayer(rootDir, layer);
     if (result) results.push(result);
   }
-  return results;
+  const byLayer = new Map(results.map((r) => [r.layer, r]));
+  return ["ui", "api", "db"].map((l) => byLayer.get(l)).filter((r) => !!r);
 }
 
 // src/server/graph/index.ts
@@ -7421,8 +7792,69 @@ function handleGraphCommand(subcommand, args) {
 }
 
 // src/server/graph-mcp.ts
+var import_node_fs7 = require("node:fs");
+var import_node_path7 = require("node:path");
+
+// src/server/lockfile.ts
+var import_node_child_process = require("node:child_process");
 var import_node_fs6 = require("node:fs");
+var import_node_os = require("node:os");
 var import_node_path6 = require("node:path");
+function lockDir() {
+  return (0, import_node_path6.join)((0, import_node_os.homedir)(), ".launchsecure");
+}
+function lockPath() {
+  return (0, import_node_path6.join)(lockDir(), "launch-chart.lock");
+}
+function readLock() {
+  const p = lockPath();
+  if (!(0, import_node_fs6.existsSync)(p)) return null;
+  try {
+    const data = JSON.parse((0, import_node_fs6.readFileSync)(p, "utf-8"));
+    if (typeof data.pid !== "number" || typeof data.port !== "number") return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getListenerPid(port) {
+  try {
+    const out = (0, import_node_child_process.execFileSync)("lsof", ["-nP", "-iTCP:" + port, "-sTCP:LISTEN", "-t"], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 500
+    }).trim();
+    if (!out) return null;
+    const pid = parseInt(out.split("\n")[0], 10);
+    return Number.isFinite(pid) ? pid : null;
+  } catch {
+    return null;
+  }
+}
+function getLiveLock() {
+  const lock = readLock();
+  if (!lock) return null;
+  const listenerPid = getListenerPid(lock.port);
+  const live = listenerPid !== null ? listenerPid === lock.pid : isPidAlive(lock.pid);
+  if (!live) {
+    try {
+      (0, import_node_fs6.unlinkSync)(lockPath());
+    } catch {
+    }
+    return null;
+  }
+  return lock;
+}
+
+// src/server/graph-mcp.ts
 var SERVER_INFO = {
   name: "launchsecure-graph",
   version: "0.0.1"
@@ -7548,6 +7980,14 @@ Returns: { pattern, filter, files_searched, total_matches, matches: [{file, line
       },
       required: ["layer", "pattern"]
     }
+  },
+  {
+    name: "get_graph_ui_url",
+    description: 'Return the URL of a running launch-chart UI server if one exists. The UI is a visual, interactive view of the merged UI+API+DB project graph served by `launch-chart serve` (or auto-started via LAUNCH_CHART_AUTOSERVE=1). \n\nReturns: { running: boolean, url?: string, port?: number, pid?: number, startedAt?: string, cwd?: string }. If running is false, no server is currently live \u2014 suggest the user run `launch-chart serve` to start one. \n\nUse this when the user asks "open the graph", "show me the project graph UI", "where\'s the chart", etc.',
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
   }
 ];
 function matchesSearch(node, query) {
@@ -7900,9 +8340,9 @@ function handleReadGraph(args) {
   return okJson(result);
 }
 function nodeToFilePath(rootDir, layer, nodeId) {
-  if (layer === "ui") return (0, import_node_path6.join)(rootDir, "src", nodeId);
-  if (layer === "api") return (0, import_node_path6.join)(rootDir, nodeId);
-  if (layer === "db") return (0, import_node_path6.join)(rootDir, "prisma", "schema.prisma");
+  if (layer === "ui") return (0, import_node_path7.join)(rootDir, "src", nodeId);
+  if (layer === "api") return (0, import_node_path7.join)(rootDir, nodeId);
+  if (layer === "db") return (0, import_node_path7.join)(rootDir, "prisma", "schema.prisma");
   return null;
 }
 function handleGrepNodes(args) {
@@ -7962,11 +8402,11 @@ function handleGrepNodes(args) {
   let filesSearched = 0;
   let truncated = false;
   for (const [filePath, nodeId] of filePaths) {
-    if (!(0, import_node_fs6.existsSync)(filePath)) continue;
+    if (!(0, import_node_fs7.existsSync)(filePath)) continue;
     filesSearched++;
     let content;
     try {
-      content = (0, import_node_fs6.readFileSync)(filePath, "utf-8");
+      content = (0, import_node_fs7.readFileSync)(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -8003,6 +8443,23 @@ function handleGrepNodes(args) {
     truncated
   });
 }
+function handleGetGraphUiUrl() {
+  const lock = getLiveLock();
+  if (!lock) {
+    return okJson({
+      running: false,
+      hint: "No launch-chart UI server is currently running. Start one with `launch-chart serve`, or set LAUNCH_CHART_AUTOSERVE=1 in your MCP config to auto-start it alongside the MCP server."
+    });
+  }
+  return okJson({
+    running: true,
+    url: lock.url,
+    port: lock.port,
+    pid: lock.pid,
+    cwd: lock.cwd,
+    startedAt: lock.startedAt
+  });
+}
 function send(msg) {
   process.stdout.write(JSON.stringify(msg) + "\n");
 }
@@ -8046,6 +8503,10 @@ function handleMessage(msg) {
       respond(id ?? null, handleGrepNodes(args));
       return;
     }
+    if (toolName === "get_graph_ui_url") {
+      respond(id ?? null, handleGetGraphUiUrl());
+      return;
+    }
     respondError(id ?? null, -32601, `Unknown tool: ${toolName}`);
     return;
   }