@launchsecure/launch-kit 0.0.5 → 0.0.7

package/dist/server/chart-serve.js

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,6 +30,30 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/server/graph/core/config.ts
+var config_exports = {};
+__export(config_exports, {
+  loadConfig: () => loadConfig
+});
+function loadConfig(rootDir) {
+  const configPath = (0, import_node_path.join)(rootDir, CONFIG_FILENAME);
+  if (!(0, import_node_fs.existsSync)(configPath)) return {};
+  try {
+    return JSON.parse((0, import_node_fs.readFileSync)(configPath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+var import_node_fs, import_node_path, CONFIG_FILENAME;
+var init_config = __esm({
+  "src/server/graph/core/config.ts"() {
+    "use strict";
+    import_node_fs = require("node:fs");
+    import_node_path = require("node:path");
+    CONFIG_FILENAME = ".launchchart.json";
+  }
+});
+
 // src/server/chart-serve.ts
 var chart_serve_exports = {};
 __export(chart_serve_exports, {
@@ -35,30 +62,17 @@ __export(chart_serve_exports, {
 });
 module.exports = __toCommonJS(chart_serve_exports);
 var import_node_http = __toESM(require("node:http"));
-var import_node_fs11 = __toESM(require("node:fs"));
-var import_node_path12 = __toESM(require("node:path"));
+var import_node_fs13 = __toESM(require("node:fs"));
+var import_node_path15 = __toESM(require("node:path"));
 
 // src/server/graph/index.ts
-var import_node_fs9 = require("node:fs");
-var import_node_path10 = require("node:path");
+var import_node_fs11 = require("node:fs");
+var import_node_path13 = require("node:path");
 
 // src/server/graph/core/graph-builder.ts
 var import_node_fs8 = require("node:fs");
 var import_node_path9 = require("node:path");
-
-// src/server/graph/core/config.ts
-var import_node_fs = require("node:fs");
-var import_node_path = require("node:path");
-var CONFIG_FILENAME = ".launchchart.json";
-function loadConfig(rootDir) {
-  const configPath = (0, import_node_path.join)(rootDir, CONFIG_FILENAME);
-  if (!(0, import_node_fs.existsSync)(configPath)) return {};
-  try {
-    return JSON.parse((0, import_node_fs.readFileSync)(configPath, "utf-8"));
-  } catch {
-    return {};
-  }
-}
+init_config();
 
 // src/server/graph/core/parser-registry.ts
 var import_node_path8 = require("node:path");
@@ -524,34 +538,6 @@ function classifyType(id) {
   if (id.startsWith("lib/") || id.startsWith("config/")) return "lib";
   return "component";
 }
-function classifyModule(id) {
-  if (/app\/\(auth\)\//.test(id)) return "auth";
-  if (/app\/\(admin\)\//.test(id)) return "admin";
-  if (/app\/\(settings\)\//.test(id)) return "settings";
-  if (/app\/\(app\)\/\[orgSlug\]\/\(project-pages\)\//.test(id)) return "project";
-  if (/app\/\(app\)\/\[orgSlug\]\/\(org-pages\)\//.test(id)) return "org";
-  if (/app\/\(app\)\/\[orgSlug\]\//.test(id)) return "org";
-  if (id.startsWith("app/integrations/")) return "integrations";
-  if (id.startsWith("app/docs/")) return "admin";
-  if (id.startsWith("client/components/ui/")) return "shared-ui";
-  if (id.startsWith("client/components/layout/") || /client\/lib\/navigation/.test(id)) return "layout";
-  if (/client\/components\/auth\//.test(id) || /client\/lib\/auth-/.test(id) || /client\/lib\/github-oauth/.test(id) || /client\/lib\/permission-service/.test(id) || /client\/hooks\/use-permissions/.test(id)) return "auth";
-  if (/client\/components\/prd-/.test(id) || /client\/hooks\/use-admin/.test(id)) return "admin";
-  if (/client\/components\/org-/.test(id) || /client\/hooks\/use-org-/.test(id) || /client\/hooks\/use-provider-def/.test(id)) return "org";
-  if (/client\/components\/project/.test(id) || /client\/hooks\/use-project-/.test(id) || /client\/hooks\/use-pipeline/.test(id) || /client\/hooks\/use-databases/.test(id) || /client\/hooks\/use-provider-env/.test(id) || /client\/hooks\/use-role-assign/.test(id) || /client\/components\/pipeline/.test(id) || /client\/components\/deployments/.test(id)) return "project";
-  if (/client\/hooks\/use-(profile|sessions|organizations|notification)/.test(id)) return "settings";
-  if (id.startsWith("server/auth/")) return "auth";
-  if (id.startsWith("server/mcp/")) return "mcp";
-  if (id.startsWith("server/lib/")) return "server-lib";
-  if (id.startsWith("server/middleware")) return "middleware";
-  if (id.startsWith("server/services/")) return "services";
-  if (id.startsWith("server/db")) return "db";
-  if (id.startsWith("server/errors")) return "errors";
-  if (id.startsWith("server/")) return "server-lib";
-  if (id.startsWith("config/")) return "config";
-  if (id.startsWith("lib/")) return "lib";
-  return "root";
-}
 function extractRoute(id) {
   if (!id.endsWith("/page.tsx")) return null;
   let route = id.replace(/^app\//, "/").replace(/\/page\.tsx$/, "");
@@ -772,8 +758,7 @@ function generate(rootDir) {
     const parsed = parsedByPath.get(absPath);
     const name = parsed.name || nameFromFilename(absPath);
     const route = extractRoute(id);
-    const module_ = classifyModule(id);
-    nodes.push({ id, type, name, route, module: module_, exports: parsed.exports });
+    nodes.push({ id, type, name, route, exports: parsed.exports });
     nodeIdSet.add(id);
     nodeTypeMap.set(id, type);
     if (route) routeToNodeId.set(route, id);
@@ -877,7 +862,6 @@ function generate(rootDir) {
       type: "external",
       name: parsed.name || nameFromFilename(absPath),
       route: null,
-      module: "external",
       exports: parsed.exports
     });
     nodeIdSet.add(externalId);
@@ -1892,31 +1876,425 @@ function generateAll(rootDir) {
 }
 
 // src/server/graph/index.ts
+init_config();
+
+// src/server/graph/core/tagger-registry.ts
+var import_node_path11 = require("node:path");
+
+// src/server/graph/taggers/module-tagger.ts
+var import_node_fs9 = require("node:fs");
+var import_node_path10 = require("node:path");
+function matchGlob(pattern, id) {
+  const patParts = pattern.split("/");
+  const idParts = id.split("/");
+  return matchParts(patParts, 0, idParts, 0);
+}
+function matchParts(pat, pi, id, ii) {
+  while (pi < pat.length && ii < id.length) {
+    const p = pat[pi];
+    if (p === "**") {
+      for (let skip = ii; skip <= id.length; skip++) {
+        if (matchParts(pat, pi + 1, id, skip)) return true;
+      }
+      return false;
+    }
+    if (p === "*") {
+      pi++;
+      ii++;
+      continue;
+    }
+    if (p !== id[ii]) return false;
+    pi++;
+    ii++;
+  }
+  while (pi < pat.length && pat[pi] === "**") pi++;
+  return pi === pat.length && ii === id.length;
+}
+var CONVENTION_DIRS = ["features", "modules", "domains", "areas"];
+function detectConventionDirs(rootDir) {
+  const result = /* @__PURE__ */ new Map();
+  const searchDirs = [
+    rootDir,
+    (0, import_node_path10.join)(rootDir, "src"),
+    (0, import_node_path10.join)(rootDir, "app"),
+    (0, import_node_path10.join)(rootDir, "lib")
+  ];
+  for (const base of searchDirs) {
+    for (const convention of CONVENTION_DIRS) {
+      const dir = (0, import_node_path10.join)(base, convention);
+      if (!(0, import_node_fs9.existsSync)(dir)) continue;
+      try {
+        const stat = (0, import_node_fs9.statSync)(dir);
+        if (!stat.isDirectory()) continue;
+        const entries = (0, import_node_fs9.readdirSync)(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
+        if (entries.length > 0) {
+          const relPath = dir.replace(rootDir + "/", "").replace(rootDir + "\\", "");
+          result.set(relPath, entries);
+        }
+      } catch {
+      }
+    }
+  }
+  return result;
+}
+function extractRouteGroups(id) {
+  const groups = [];
+  const re = /\(([^)]+)\)/g;
+  let m;
+  while ((m = re.exec(id)) !== null) {
+    groups.push(m[1]);
+  }
+  return groups;
+}
+var SKIP_SEGMENTS = /* @__PURE__ */ new Set([
+  "src",
+  "app",
+  "client",
+  "server",
+  "lib",
+  "config"
+]);
+function isRouteGroup(segment) {
+  return segment.startsWith("(") && segment.endsWith(")");
+}
+function isDynamicSegment(segment) {
+  return segment.startsWith("[") || segment.startsWith(":");
+}
+function isDomainDir(segment) {
+  return segment.includes(".") && !segment.endsWith(".tsx") && !segment.endsWith(".ts") && !segment.endsWith(".js") && !segment.endsWith(".jsx") && !segment.endsWith(".vue");
+}
+var TRIVIAL_GROUPS = /* @__PURE__ */ new Set([
+  // Generic app wrappers
+  "app",
+  "all",
+  "ee",
+  "home",
+  "root",
+  "main",
+  "site",
+  // Auth/access boundary wrappers — protect routes, not feature modules
+  "protected",
+  "authenticated",
+  "authed",
+  "private",
+  "public",
+  "logged-in",
+  "logged-out",
+  "unprotected",
+  "unauthenticated",
+  "auth-required",
+  "no-auth",
+  "guest-only"
+]);
+function isTrivialGroup(name, extraTrivial) {
+  if (TRIVIAL_GROUPS.has(name)) return true;
+  if (extraTrivial?.has(name)) return true;
+  const lower = name.toLowerCase();
+  const wrapperPatterns = [
+    /^.*-?wrapper$/,
+    // "page-wrapper", "use-page-wrapper"
+    /^.*-?layout$/,
+    // "admin-layout", "settings-layout"
+    /^use-/,
+    // "use-page-wrapper"
+    /^default$/
+  ];
+  return wrapperPatterns.some((p) => p.test(lower));
+}
+function normalizeGroupName(name) {
+  return name.replace(/-pages?$/, "").replace(/-layout$/, "").replace(/-wrapper$/, "");
+}
+function extractModuleFromPath(id, extraTrivial) {
+  const segments = id.split("/");
+  const routeGroups = extractRouteGroups(id);
+  const moduleGroups = routeGroups.filter((g) => !isTrivialGroup(g, extraTrivial)).map(normalizeGroupName);
+  if (moduleGroups.length > 0) {
+    return moduleGroups[moduleGroups.length - 1];
+  }
+  const meaningful = [];
+  for (const seg of segments) {
+    if (seg.includes(".")) continue;
+    if (isRouteGroup(seg)) continue;
+    if (isDynamicSegment(seg)) continue;
+    if (isDomainDir(seg)) continue;
+    if (SKIP_SEGMENTS.has(seg)) continue;
+    meaningful.push(seg);
+  }
+  if (meaningful.length > 0) {
+    return meaningful[0];
+  }
+  return "root";
+}
+var cachedRootDir = null;
+var cachedConventionDirs = /* @__PURE__ */ new Map();
+var moduleTagger = {
+  id: "module",
+  tagKey: "module",
+  trackUntagged: true,
+  layers: null,
+  // applies to all layers
+  tag(nodes, layer, rootDir) {
+    if (cachedRootDir !== rootDir) {
+      cachedConventionDirs = detectConventionDirs(rootDir);
+      cachedRootDir = rootDir;
+    }
+    let configRules = [];
+    let extraTrivial;
+    try {
+      const { loadConfig: loadConfig2 } = (init_config(), __toCommonJS(config_exports));
+      const config = loadConfig2(rootDir);
+      configRules = config.taggers?.module?.rules ?? [];
+      const trivialFromConfig = config.taggers?.module?.trivialGroups;
+      if (trivialFromConfig?.length) {
+        extraTrivial = new Set(trivialFromConfig);
+      }
+    } catch {
+    }
+    const result = /* @__PURE__ */ new Map();
+    for (const node of nodes) {
+      const id = node.id;
+      let matched = false;
+      for (const rule of configRules) {
+        if (matchGlob(rule.match, id)) {
+          result.set(id, rule.module);
+          matched = true;
+          break;
+        }
+      }
+      if (matched) continue;
+      matched = false;
+      for (const [convDir, moduleNames] of cachedConventionDirs) {
+        if (id.startsWith(convDir + "/")) {
+          const rest = id.slice(convDir.length + 1);
+          const firstSeg = rest.split("/")[0];
+          if (moduleNames.includes(firstSeg)) {
+            result.set(id, firstSeg);
+            matched = true;
+            break;
+          }
+        }
+      }
+      if (matched) continue;
+      const module2 = extractModuleFromPath(id, extraTrivial);
+      result.set(id, module2);
+    }
+    return result;
+  }
+};
+
+// src/server/graph/taggers/screen-tagger.ts
+var SCREEN_TYPES = /* @__PURE__ */ new Set(["page", "layout"]);
+var screenTagger = {
+  id: "screen",
+  tagKey: "screen",
+  trackUntagged: true,
+  layers: ["ui"],
+  tag(nodes, layer) {
+    if (layer !== "ui") return /* @__PURE__ */ new Map();
+    const result = /* @__PURE__ */ new Map();
+    for (const node of nodes) {
+      if (SCREEN_TYPES.has(node.type)) {
+        result.set(node.id, "true");
+      }
+    }
+    return result;
+  }
+};
+
+// src/server/graph/core/tagger-registry.ts
+var TaggerRegistry = class {
+  constructor() {
+    this.taggers = [];
+    this.ids = /* @__PURE__ */ new Set();
+  }
+  register(tagger) {
+    if (this.ids.has(tagger.id)) {
+      throw new Error(`Duplicate tagger id: ${tagger.id}`);
+    }
+    this.ids.add(tagger.id);
+    this.taggers.push(tagger);
+  }
+  getAll() {
+    return this.taggers;
+  }
+  getForLayer(layer) {
+    return this.taggers.filter((t) => t.layers === null || t.layers.includes(layer));
+  }
+};
+var BUILTIN_TAGGERS = [moduleTagger, screenTagger];
+function registerBuiltins2(registry, disabled, config) {
+  for (const tagger of BUILTIN_TAGGERS) {
+    if (disabled.has(tagger.id)) continue;
+    const override = config.taggers?.trackUntagged?.[tagger.id];
+    if (override !== void 0) {
+      tagger.trackUntagged = override;
+    }
+    registry.register(tagger);
+  }
+}
+function loadCustomTaggers(registry, config, rootDir, disabled) {
+  for (const entry of config.taggers?.custom ?? []) {
+    if (disabled.has(entry.id)) continue;
+    try {
+      const absPath = (0, import_node_path11.resolve)(rootDir, entry.path);
+      const mod = require(absPath);
+      const tagger = "default" in mod ? mod.default : mod;
+      const override = config.taggers?.trackUntagged?.[tagger.id];
+      if (override !== void 0) {
+        tagger.trackUntagged = override;
+      }
+      registry.register(tagger);
+    } catch (err) {
+      process.stderr.write(`[launch-chart] failed to load custom tagger from ${entry.path}: ${err}
+`);
+    }
+  }
+}
+function createTaggerRegistry(config, rootDir) {
+  const registry = new TaggerRegistry();
+  const disabled = new Set(config.taggers?.disabled ?? []);
+  registerBuiltins2(registry, disabled, config);
+  loadCustomTaggers(registry, config, rootDir, disabled);
+  return registry;
+}
+
+// src/server/graph/core/tag-store.ts
+var import_node_fs10 = require("node:fs");
+var import_node_path12 = require("node:path");
+var TAGS_FILENAME = "tags.json";
 var GRAPHS_DIR = ".launchsecure/graphs";
+var tagCache = /* @__PURE__ */ new Map();
+function tagsFilePath(rootDir) {
+  return (0, import_node_path12.join)(rootDir, GRAPHS_DIR, TAGS_FILENAME);
+}
+function readTagStore(rootDir) {
+  const filePath = tagsFilePath(rootDir);
+  if (!(0, import_node_fs10.existsSync)(filePath)) return {};
+  const stat = (0, import_node_fs10.statSync)(filePath);
+  const cached = tagCache.get(filePath);
+  if (cached && cached.mtimeMs === stat.mtimeMs) {
+    return cached.store;
+  }
+  try {
+    const content = (0, import_node_fs10.readFileSync)(filePath, "utf-8");
+    const store = JSON.parse(content);
+    tagCache.set(filePath, { mtimeMs: stat.mtimeMs, store });
+    return store;
+  } catch {
+    return {};
+  }
+}
+function writeTagStore(rootDir, store) {
+  const filePath = tagsFilePath(rootDir);
+  const dir = (0, import_node_path12.dirname)(filePath);
+  (0, import_node_fs10.mkdirSync)(dir, { recursive: true });
+  const cleaned = {};
+  for (const [nodeId, tags] of Object.entries(store)) {
+    if (Object.keys(tags).length > 0) {
+      cleaned[nodeId] = tags;
+    }
+  }
+  (0, import_node_fs10.writeFileSync)(filePath, JSON.stringify(cleaned, null, 2) + "\n", "utf-8");
+  tagCache.delete(filePath);
+}
+function setTag(rootDir, nodeId, key, value) {
+  const store = readTagStore(rootDir);
+  if (!store[nodeId]) store[nodeId] = {};
+  store[nodeId][key] = value;
+  writeTagStore(rootDir, store);
+}
+function removeTag(rootDir, nodeId, key) {
+  const store = readTagStore(rootDir);
+  if (!store[nodeId]) return;
+  delete store[nodeId][key];
+  if (Object.keys(store[nodeId]).length === 0) {
+    delete store[nodeId];
+  }
+  writeTagStore(rootDir, store);
+}
+
+// src/server/graph/index.ts
+var GRAPHS_DIR2 = ".launchsecure/graphs";
 var LAYERS = ["ui", "api", "db"];
 var graphCache = /* @__PURE__ */ new Map();
+var taggedCache = /* @__PURE__ */ new Map();
 function graphsDir(rootDir) {
-  return (0, import_node_path10.join)(rootDir, GRAPHS_DIR);
+  return (0, import_node_path13.join)(rootDir, GRAPHS_DIR2);
 }
 function graphFilePath(rootDir, layer) {
-  return (0, import_node_path10.join)(graphsDir(rootDir), `${layer}.json`);
+  return (0, import_node_path13.join)(graphsDir(rootDir), `${layer}.json`);
+}
+function tagsFilePath2(rootDir) {
+  return (0, import_node_path13.join)(graphsDir(rootDir), "tags.json");
+}
+function getMtimeMs(filePath) {
+  if (!(0, import_node_fs11.existsSync)(filePath)) return 0;
+  return (0, import_node_fs11.statSync)(filePath).mtimeMs;
 }
 function invalidateCache(filePath) {
   graphCache.delete(filePath);
 }
-function readGraph(rootDir, layer) {
+function invalidateTaggedCache(rootDir, layer) {
+  taggedCache.delete(`${rootDir}:${layer}`);
+}
+function applyTags(graph, layer, rootDir) {
+  const config = loadConfig(rootDir);
+  const registry = createTaggerRegistry(config, rootDir);
+  const manualTags = readTagStore(rootDir);
+  const taggedNodes = graph.nodes.map((n) => ({ ...n }));
+  const taggers = registry.getForLayer(layer);
+  for (const tagger of taggers) {
+    const assignments = tagger.tag(taggedNodes, layer, rootDir);
+    for (const node of taggedNodes) {
+      if (!node.tags) node.tags = {};
+      const tags = node.tags;
+      const value = assignments.get(node.id);
+      if (value !== void 0) {
+        tags[tagger.tagKey] = value;
+      } else if (tagger.trackUntagged) {
+        tags[tagger.tagKey] = "untagged";
+      }
+    }
+  }
+  for (const node of taggedNodes) {
+    const manual = manualTags[node.id];
+    if (manual) {
+      if (!node.tags) node.tags = {};
+      const tags = node.tags;
+      Object.assign(tags, manual);
+    }
+  }
+  return { ...graph, nodes: taggedNodes };
+}
+function readGraphRaw(rootDir, layer) {
   const filePath = graphFilePath(rootDir, layer);
-  if (!(0, import_node_fs9.existsSync)(filePath)) return null;
-  const stat = (0, import_node_fs9.statSync)(filePath);
+  if (!(0, import_node_fs11.existsSync)(filePath)) return null;
+  const stat = (0, import_node_fs11.statSync)(filePath);
   const cached = graphCache.get(filePath);
   if (cached && cached.mtimeMs === stat.mtimeMs) {
     return cached.graph;
   }
-  const content = (0, import_node_fs9.readFileSync)(filePath, "utf-8");
+  const content = (0, import_node_fs11.readFileSync)(filePath, "utf-8");
   const graph = JSON.parse(content);
   graphCache.set(filePath, { mtimeMs: stat.mtimeMs, graph });
   return graph;
 }
+function readGraph(rootDir, layer) {
+  const rawFilePath = graphFilePath(rootDir, layer);
+  if (!(0, import_node_fs11.existsSync)(rawFilePath)) return null;
+  const rawMtime = getMtimeMs(rawFilePath);
+  const tagsMtime = getMtimeMs(tagsFilePath2(rootDir));
+  const cacheKey = `${rootDir}:${layer}`;
+  const cached = taggedCache.get(cacheKey);
+  if (cached && cached.rawMtimeMs === rawMtime && cached.tagsMtimeMs === tagsMtime) {
+    return cached.graph;
+  }
+  const raw = readGraphRaw(rootDir, layer);
+  if (!raw) return null;
+  const tagged = applyTags(raw, layer, rootDir);
+  taggedCache.set(cacheKey, { rawMtimeMs: rawMtime, tagsMtimeMs: tagsMtime, graph: tagged });
+  return tagged;
+}
 function readAllGraphs(rootDir) {
   const result = {};
   for (const layer of LAYERS) {
@@ -1927,32 +2305,52 @@ function readAllGraphs(rootDir) {
 }
 function generateGraph(rootDir, layer) {
   const dir = graphsDir(rootDir);
-  (0, import_node_fs9.mkdirSync)(dir, { recursive: true });
+  (0, import_node_fs11.mkdirSync)(dir, { recursive: true });
   const results = layer ? [generateLayer(rootDir, layer)].filter((r) => r !== null) : generateAll(rootDir);
   for (const result of results) {
     const filePath = graphFilePath(rootDir, result.layer);
-    (0, import_node_fs9.writeFileSync)(filePath, JSON.stringify(result.output, null, 2) + "\n", "utf-8");
+    (0, import_node_fs11.writeFileSync)(filePath, JSON.stringify(result.output, null, 2) + "\n", "utf-8");
     invalidateCache(filePath);
+    invalidateTaggedCache(rootDir, result.layer);
   }
   return results;
 }
 
 // src/server/lockfile.ts
 var import_node_child_process = require("node:child_process");
-var import_node_fs10 = require("node:fs");
+var import_node_fs12 = require("node:fs");
 var import_node_os = require("node:os");
-var import_node_path11 = require("node:path");
-function lockDir() {
-  return (0, import_node_path11.join)((0, import_node_os.homedir)(), ".launchsecure");
-}
-function lockPath() {
-  return (0, import_node_path11.join)(lockDir(), "launch-chart.lock");
-}
-function readLock() {
-  const p = lockPath();
-  if (!(0, import_node_fs10.existsSync)(p)) return null;
+var import_node_path14 = require("node:path");
+function lockDir(projectRoot) {
+  if (projectRoot) {
+    return (0, import_node_path14.join)(projectRoot, ".launchsecure");
+  }
+  return (0, import_node_path14.join)((0, import_node_os.homedir)(), ".launchsecure");
+}
+function lockPath(projectRoot) {
+  return (0, import_node_path14.join)(lockDir(projectRoot), "launch-chart.lock");
+}
+var _activeProjectRoot;
+function readLock(projectRoot) {
+  const root = projectRoot ?? _activeProjectRoot;
+  const p = lockPath(root);
+  if (!(0, import_node_fs12.existsSync)(p)) {
+    if (root) {
+      const globalP = lockPath();
+      if ((0, import_node_fs12.existsSync)(globalP)) {
+        try {
+          const data = JSON.parse((0, import_node_fs12.readFileSync)(globalP, "utf-8"));
+          if (typeof data.pid === "number" && typeof data.port === "number" && data.cwd === root) {
+            return data;
+          }
+        } catch {
+        }
+      }
+    }
+    return null;
+  }
   try {
-    const data = JSON.parse((0, import_node_fs10.readFileSync)(p, "utf-8"));
+    const data = JSON.parse((0, import_node_fs12.readFileSync)(p, "utf-8"));
     if (typeof data.pid !== "number" || typeof data.port !== "number") return null;
     return data;
   } catch {
@@ -1981,34 +2379,41 @@ function getListenerPid(port) {
     return null;
   }
 }
-function getLiveLock() {
-  const lock = readLock();
+function getLiveLock(projectRoot) {
+  const root = projectRoot ?? _activeProjectRoot;
+  const lock = readLock(root);
   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_fs10.unlinkSync)(lockPath());
+      (0, import_node_fs12.unlinkSync)(lockPath(root));
     } catch {
     }
     return null;
   }
   return lock;
 }
-function writeLock(data) {
-  (0, import_node_fs10.mkdirSync)(lockDir(), { recursive: true });
-  (0, import_node_fs10.writeFileSync)(lockPath(), JSON.stringify(data, null, 2) + "\n", "utf-8");
+function writeLock(data, projectRoot) {
+  const root = projectRoot ?? _activeProjectRoot;
+  (0, import_node_fs12.mkdirSync)(lockDir(root), { recursive: true });
+  (0, import_node_fs12.writeFileSync)(lockPath(root), JSON.stringify(data, null, 2) + "\n", "utf-8");
+  if (root) _activeProjectRoot = root;
 }
-function clearLock() {
+function clearLock(projectRoot) {
+  const root = projectRoot ?? _activeProjectRoot;
   try {
-    (0, import_node_fs10.unlinkSync)(lockPath());
+    (0, import_node_fs12.unlinkSync)(lockPath(root));
   } catch {
   }
 }
 
 // src/server/chart-serve.ts
-var DEFAULT_PORT = 52819;
-var MAX_PORT_SCAN = 20;
+init_config();
+var MAX_PORT_SCAN = 3;
+function randomPort() {
+  return 49152 + Math.floor(Math.random() * (65535 - 49152));
+}
 var MIME_TYPES = {
   ".html": "text/html; charset=utf-8",
   ".js": "application/javascript; charset=utf-8",
@@ -2023,16 +2428,16 @@ var MIME_TYPES = {
 function findProjectRoot(startDir) {
   let dir = startDir;
   for (let i = 0; i < 8; i++) {
-    const graphsDir2 = import_node_path12.default.join(dir, ".launchsecure", "graphs");
-    if (import_node_fs11.default.existsSync(import_node_path12.default.join(graphsDir2, "ui.json")) || import_node_fs11.default.existsSync(import_node_path12.default.join(graphsDir2, "api.json")) || import_node_fs11.default.existsSync(import_node_path12.default.join(graphsDir2, "db.json"))) return dir;
-    const parent = import_node_path12.default.dirname(dir);
+    const graphsDir2 = import_node_path15.default.join(dir, ".launchsecure", "graphs");
+    if (import_node_fs13.default.existsSync(import_node_path15.default.join(graphsDir2, "ui.json")) || import_node_fs13.default.existsSync(import_node_path15.default.join(graphsDir2, "api.json")) || import_node_fs13.default.existsSync(import_node_path15.default.join(graphsDir2, "db.json"))) return dir;
+    const parent = import_node_path15.default.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   dir = startDir;
   for (let i = 0; i < 8; i++) {
-    if (import_node_fs11.default.existsSync(import_node_path12.default.join(dir, ".git"))) return dir;
-    const parent = import_node_path12.default.dirname(dir);
+    if (import_node_fs13.default.existsSync(import_node_path15.default.join(dir, ".git"))) return dir;
+    const parent = import_node_path15.default.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -2084,16 +2489,16 @@ function buildMergedGraph(projectRoot) {
   };
 }
 function serveStatic(res, filePath) {
-  if (!import_node_fs11.default.existsSync(filePath) || !import_node_fs11.default.statSync(filePath).isFile()) return false;
-  const ext = import_node_path12.default.extname(filePath).toLowerCase();
+  if (!import_node_fs13.default.existsSync(filePath) || !import_node_fs13.default.statSync(filePath).isFile()) return false;
+  const ext = import_node_path15.default.extname(filePath).toLowerCase();
   const mime = MIME_TYPES[ext] ?? "application/octet-stream";
   res.writeHead(200, { "Content-Type": mime, "Cache-Control": "no-cache" });
-  import_node_fs11.default.createReadStream(filePath).pipe(res);
+  import_node_fs13.default.createReadStream(filePath).pipe(res);
   return true;
 }
 function serveIndex(res, clientDir) {
-  const indexPath = import_node_path12.default.join(clientDir, "index.html");
-  if (!import_node_fs11.default.existsSync(indexPath)) {
+  const indexPath = import_node_path15.default.join(clientDir, "index.html");
+  if (!import_node_fs13.default.existsSync(indexPath)) {
     res.writeHead(500, { "Content-Type": "text/plain" });
     res.end(`LaunchChart client bundle not found at ${clientDir}. Run 'npm run build:chart-client'.`);
     return;
@@ -2101,14 +2506,14 @@ function serveIndex(res, clientDir) {
   serveStatic(res, indexPath);
 }
 function tryListen(server, port) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const onError = (err) => {
       server.off("listening", onListening);
       reject(err);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve2(port);
+      resolve3(port);
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -2135,7 +2540,7 @@ async function bindWithFallback(server, startPort) {
 async function startChartServer(opts = {}) {
   const cwd = opts.cwd ?? process.cwd();
   const projectRoot = findProjectRoot(cwd);
-  const existing = getLiveLock();
+  const existing = getLiveLock(projectRoot);
   if (existing) {
     if (!opts.quiet) {
       process.stderr.write(
@@ -2145,7 +2550,7 @@ async function startChartServer(opts = {}) {
     }
     return { port: existing.port, url: existing.url };
   }
-  const clientDir = opts.clientDir ?? import_node_path12.default.join(__dirname, "..", "chart-client");
+  const clientDir = opts.clientDir ?? import_node_path15.default.join(__dirname, "..", "chart-client");
   const server = import_node_http.default.createServer((req, res) => {
     try {
       const url2 = new URL(req.url ?? "/", `http://${req.headers.host}`);
@@ -2183,6 +2588,26 @@ async function startChartServer(opts = {}) {
         }
         return;
       }
+      if (req.method === "GET" && url2.pathname === "/api/file-content") {
+        const relPath = url2.searchParams.get("path");
+        if (!relPath || relPath.includes("..") || import_node_path15.default.isAbsolute(relPath)) {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Invalid path" }));
+          return;
+        }
+        const filePath = import_node_path15.default.join(projectRoot, relPath);
+        if (!filePath.startsWith(projectRoot) || !import_node_fs13.default.existsSync(filePath) || !import_node_fs13.default.statSync(filePath).isFile()) {
+          res.writeHead(404, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "File not found" }));
+          return;
+        }
+        const ext = import_node_path15.default.extname(filePath).toLowerCase();
+        const langMap = { ".ts": "typescript", ".tsx": "tsx", ".js": "javascript", ".jsx": "jsx", ".prisma": "prisma", ".json": "json", ".css": "css" };
+        const content = import_node_fs13.default.readFileSync(filePath, "utf-8");
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ content, language: langMap[ext] ?? "text", path: relPath }));
+        return;
+      }
       if (req.method === "GET" && url2.pathname === "/api/health") {
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ ok: true, projectRoot }));
@@ -2212,8 +2637,94 @@ async function startChartServer(opts = {}) {
         req.on("end", () => {
           try {
             const newConfig = JSON.parse(body);
-            const configPath = import_node_path12.default.join(projectRoot, ".launchchart.json");
-            import_node_fs11.default.writeFileSync(configPath, JSON.stringify(newConfig, null, 2) + "\n", "utf-8");
+            const configPath = import_node_path15.default.join(projectRoot, ".launchchart.json");
+            import_node_fs13.default.writeFileSync(configPath, JSON.stringify(newConfig, null, 2) + "\n", "utf-8");
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: true }));
+          } catch (err) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: false, error: String(err) }));
+          }
+        });
+        return;
+      }
+      if (req.method === "GET" && url2.pathname === "/api/tagger-config") {
+        const config = loadConfig(projectRoot);
+        const builtinTaggers = [
+          { id: "module", tagKey: "module", trackUntagged: config.taggers?.trackUntagged?.module ?? true },
+          { id: "screen", tagKey: "screen", trackUntagged: config.taggers?.trackUntagged?.screen ?? true }
+        ];
+        const disabled = config.taggers?.disabled ?? [];
+        const customTaggers = config.taggers?.custom ?? [];
+        const moduleRules = config.taggers?.module?.rules ?? [];
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ builtinTaggers, disabled, customTaggers, moduleRules }));
+        return;
+      }
+      if (req.method === "POST" && url2.pathname === "/api/tagger-config") {
+        let body = "";
+        req.on("data", (chunk) => {
+          body += chunk.toString();
+        });
+        req.on("end", () => {
+          try {
+            const taggerConfig = JSON.parse(body);
+            const config = loadConfig(projectRoot);
+            config.taggers = taggerConfig;
+            const configPath = import_node_path15.default.join(projectRoot, ".launchchart.json");
+            import_node_fs13.default.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: true }));
+          } catch (err) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: false, error: String(err) }));
+          }
+        });
+        return;
+      }
+      if (req.method === "GET" && url2.pathname === "/api/tags") {
+        const store = readTagStore(projectRoot);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(store));
+        return;
+      }
+      if (req.method === "POST" && url2.pathname === "/api/tags") {
+        let body = "";
+        req.on("data", (chunk) => {
+          body += chunk.toString();
+        });
+        req.on("end", () => {
+          try {
+            const { nodeId, key, value } = JSON.parse(body);
+            if (!nodeId || !key || !value) {
+              res.writeHead(400, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ ok: false, error: "nodeId, key, and value are required" }));
+              return;
+            }
+            setTag(projectRoot, nodeId, key, value);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: true }));
+          } catch (err) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ ok: false, error: String(err) }));
+          }
+        });
+        return;
+      }
+      if (req.method === "DELETE" && url2.pathname === "/api/tags") {
+        let body = "";
+        req.on("data", (chunk) => {
+          body += chunk.toString();
+        });
+        req.on("end", () => {
+          try {
+            const { nodeId, key } = JSON.parse(body);
+            if (!nodeId || !key) {
+              res.writeHead(400, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ ok: false, error: "nodeId and key are required" }));
+              return;
+            }
+            removeTag(projectRoot, nodeId, key);
             res.writeHead(200, { "Content-Type": "application/json" });
             res.end(JSON.stringify({ ok: true }));
           } catch (err) {
@@ -2224,7 +2735,7 @@ async function startChartServer(opts = {}) {
         return;
       }
       if (url2.pathname !== "/") {
-        const staticPath = import_node_path12.default.join(clientDir, url2.pathname);
+        const staticPath = import_node_path15.default.join(clientDir, url2.pathname);
         if (serveStatic(res, staticPath)) return;
       }
       serveIndex(res, clientDir);
@@ -2233,7 +2744,8 @@ async function startChartServer(opts = {}) {
       res.end(JSON.stringify({ error: String(err) }));
     }
   });
-  const port = await bindWithFallback(server, opts.port ?? DEFAULT_PORT);
+  const startPort = opts.port ?? randomPort();
+  const port = await bindWithFallback(server, startPort);
   const url = `http://localhost:${port}`;
   writeLock({
     pid: process.pid,
@@ -2241,9 +2753,9 @@ async function startChartServer(opts = {}) {
     cwd,
     url,
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
-  });
+  }, projectRoot);
   const cleanup = () => {
-    clearLock();
+    clearLock(projectRoot);
     server.close();
   };
   process.once("SIGINT", () => {