@launchsecure/launch-kit 0.0.5 → 0.0.6

package/dist/server/cli.js

@@ -1727,7 +1727,7 @@ var require_usage_reader = __commonJS({
       async readJsonlFile(filePath, cutoffTime) {
         const entries = [];
         const fileProcessedEntries = /* @__PURE__ */ new Set();
-        return new Promise((resolve2) => {
+        return new Promise((resolve3) => {
           const rl = readline.createInterface({
             input: createReadStream(filePath),
             crlfDelay: Infinity
@@ -1785,11 +1785,11 @@ var require_usage_reader = __commonJS({
             }
           });
           rl.on("close", () => {
-            resolve2(entries);
+            resolve3(entries);
           });
           rl.on("error", (error) => {
             console.error("Error reading file:", filePath, error);
-            resolve2(entries);
+            resolve3(entries);
           });
         });
       }
@@ -3587,7 +3587,7 @@ var require_src = __commonJS({
         if (session.active) throw new Error(`Agent already running in session ${sessionId}`);
         const { command, args = [], env = {} } = options;
         if (!command) throw new Error("startScriptInSession requires a command");
-        return new Promise((resolve2, reject) => {
+        return new Promise((resolve3, reject) => {
           this.scriptBridge.startSession(sessionId, {
             command,
             args,
@@ -3609,7 +3609,7 @@ var require_src = __commonJS({
               session.lastActivity = /* @__PURE__ */ new Date();
               this.broadcastToSession(sessionId, { type: "script_stopped", sessionId });
               if (exitCode === 0) {
-                resolve2({ code: exitCode, signal });
+                resolve3({ code: exitCode, signal });
               } else {
                 reject(new Error(`Script exited with code ${exitCode}`));
               }
@@ -3701,6 +3701,30 @@ var require_src = __commonJS({
   }
 });
 
+// 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/cli.ts
 var import_http = __toESM(require("http"));
 var import_https = __toESM(require("https"));
@@ -5270,7 +5294,7 @@ var PostImplLaunchExecutor = class {
     return 3001;
   }
   startDevServer(port, databaseUrl) {
-    return new Promise((resolve2) => {
+    return new Promise((resolve3) => {
       const env = { ...process.env, PORT: String(port), ...databaseUrl ? { DATABASE_URL: databaseUrl } : {} };
       this.devProcess = (0, import_child_process3.spawn)("npm", ["run", "dev"], {
         cwd: this.workingDir,
@@ -5282,7 +5306,7 @@ var PostImplLaunchExecutor = class {
       const timeout = setTimeout(() => {
         if (!resolved) {
           resolved = true;
-          this.healthCheck(port).then(resolve2);
+          this.healthCheck(port).then(resolve3);
         }
       }, 15e3);
       const onData = (data) => {
@@ -5291,7 +5315,7 @@ var PostImplLaunchExecutor = class {
           if (!resolved) {
             resolved = true;
             clearTimeout(timeout);
-            resolve2(true);
+            resolve3(true);
           }
         }
       };
@@ -5302,7 +5326,7 @@ var PostImplLaunchExecutor = class {
         if (!resolved) {
           resolved = true;
           clearTimeout(timeout);
-          resolve2(false);
+          resolve3(false);
         }
       });
       this.devProcess.unref();
@@ -6324,26 +6348,13 @@ ${links}
 }
 
 // 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");
@@ -6809,34 +6820,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$/, "");
@@ -7057,8 +7040,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);
@@ -7162,7 +7144,6 @@ function generate(rootDir) {
       type: "external",
       name: parsed.name || nameFromFilename(absPath),
       route: null,
-      module: "external",
       exports: parsed.exports
     });
     nodeIdSet.add(externalId);
@@ -8177,31 +8158,403 @@ 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([
+  "app",
+  "all",
+  "ee",
+  "home",
+  "root"
+]);
+function isTrivialGroup(name) {
+  if (TRIVIAL_GROUPS.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) {
+  const segments = id.split("/");
+  const routeGroups = extractRouteGroups(id);
+  const moduleGroups = routeGroups.filter((g) => !isTrivialGroup(g)).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 = [];
+    try {
+      const { loadConfig: loadConfig2 } = (init_config(), __toCommonJS(config_exports));
+      const config = loadConfig2(rootDir);
+      configRules = config.taggers?.module?.rules ?? [];
+    } 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);
+      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 (err2) {
+      process.stderr.write(`[launch-chart] failed to load custom tagger from ${entry.path}: ${err2}
+`);
+    }
+  }
+}
+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) {
@@ -8212,12 +8565,13 @@ 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;
 }
@@ -8278,27 +8632,46 @@ function handleGraphCommand(subcommand, args) {
 }
 
 // src/server/graph-mcp.ts
-var import_node_fs11 = require("node:fs");
-var import_node_path12 = require("node:path");
+var import_node_fs13 = require("node:fs");
+var import_node_path15 = require("node:path");
 var import_node_child_process2 = require("node:child_process");
 var import_node_os2 = require("node:os");
 
 // 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 {
@@ -8327,28 +8700,31 @@ 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 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/graph-mcp.ts
+init_config();
 var SERVER_INFO = {
   name: "launchsecure-graph",
   version: "0.0.1"
@@ -8370,7 +8746,7 @@ var TOOLS = [
   },
   {
     name: "read_graph",
-    description: 'Query the structural project graph \u2014 a smart Glob replacement that locates files by type/module/name and returns structural metadata (imports, renders, routes, relations). \n\nUSE THIS FOR: "where is X", "what files are in module Y", "what pages exist under /admin", "what components does Z render", "what tables relate to User", "list all hooks in auth module". \n\nDO NOT USE FOR: finding text/code content (use Grep), reading actual source code (use Read), understanding behavior/logic/patterns (graph has no code semantics \u2014 only names and edges). \n\nQUERY PARAMS (at least one required for node data \u2014 unfiltered calls return summary only to stay in context):\n- search: substring match on node id, name, or route\n- type: filter by node type (ui layer: page, layout, component, ui, hook, context, config, util; api layer: endpoint; db layer: table, enum)\n- module: filter by module (ui layer only: auth, admin, project, org, settings, integrations, shared-ui, layout, root)\n- node_id: return this node + its neighborhood (incoming+outgoing edges within `hops`)\n- hops: neighborhood radius when node_id is set (default 1)\n- minimal: return only id/type/name/module/route per node (skip heavy fields like columns, exports)\n- include_edges: return the actual edge list. Default: TRUE for neighborhood queries (node_id), FALSE for filter queries (search/type/module). Filter responses always include `edge_count`; only pass include_edges:true when you actually need to inspect individual edges (e.g. "which components render X"). This default cuts typical filter responses in half.\n\nBATCH MODE: pass `queries` (array of query objects) to run multiple independent queries in a single call. Each query object uses the same params (layer/search/type/module/node_id/hops/minimal). Returns { batch: true, count, results: [{index, query, result}, ...] }. Use this when you need multiple graph views up-front (e.g. scoping a feature across ui+api+db layers) to save round-trips. When batch mode is used, top-level params are ignored.\n\nReturns: filtered nodes + edges between them. If no filter given, returns per-layer counts and type breakdown only.\n\nWIRE FORMAT (compact): responses that include nodes/edges use short keys and edge-by-index refs to cut payload ~40-60%. Every such response carries a `_schema` legend. Quick reference:\n  nodes[]: { i: id, t: type, n: name, m: module, r: route, mt: methods, x: exports, c: columns }\n  edges[]: { s: source_node_index, d: target_node_index, t: type, l: label }\nedges.s / edges.d are 0-based indices into THIS response\'s nodes array. If a referenced node is not in the response (boundary case), s/d may instead contain the full node id string \u2014 always check the type.\n\nBUDGET GUARDS:\n- Neighborhood queries stop expanding when the projected response exceeds budget. The response then contains `budget_exceeded: true` plus `hops_traversed < hops_requested`. When this happens, drill into a specific neighbor with another node_id call rather than retrying with larger hops \u2014 it will just truncate again.\n- Batch mode caps total response size. Once the budget is hit, later queries return `{skipped: true, reason: "batch_budget_exhausted"}` and you must re-run them individually.',
+    description: 'Query the structural project graph \u2014 a smart Glob replacement that locates files by type/module/name and returns structural metadata (imports, renders, routes, relations). \n\nUSE THIS FOR: "where is X", "what files are in module Y", "what pages exist under /admin", "what components does Z render", "what tables relate to User", "list all hooks in auth module". \n\nDO NOT USE FOR: finding text/code content (use Grep), reading actual source code (use Read), understanding behavior/logic/patterns (graph has no code semantics \u2014 only names and edges). \n\nQUERY PARAMS (at least one required for node data \u2014 unfiltered calls return summary only to stay in context):\n- search: substring match on node id, name, or route\n- type: filter by node type (ui layer: page, layout, component, ui, hook, context, config, util; api layer: endpoint; db layer: table, enum)\n- module: filter by module tag (computed from directory structure, e.g. "auth", "admin", "settings")\n- node_id: return this node + its neighborhood (incoming+outgoing edges within `hops`)\n- hops: neighborhood radius when node_id is set (default 1)\n- minimal: return only id/type/name/module/route per node (skip heavy fields like columns, exports)\n- include_edges: return the actual edge list. Default: TRUE for neighborhood queries (node_id), FALSE for filter queries (search/type/module). Filter responses always include `edge_count`; only pass include_edges:true when you actually need to inspect individual edges (e.g. "which components render X"). This default cuts typical filter responses in half.\n\nBATCH MODE: pass `queries` (array of query objects) to run multiple independent queries in a single call. Each query object uses the same params (layer/search/type/module/node_id/hops/minimal). Returns { batch: true, count, results: [{index, query, result}, ...] }. Use this when you need multiple graph views up-front (e.g. scoping a feature across ui+api+db layers) to save round-trips. When batch mode is used, top-level params are ignored.\n\nReturns: filtered nodes + edges between them. If no filter given, returns per-layer counts and type breakdown only.\n\nWIRE FORMAT (compact): responses that include nodes/edges use short keys and edge-by-index refs to cut payload ~40-60%. Every such response carries a `_schema` legend. Quick reference:\n  nodes[]: { i: id, t: type, n: name, m: module, r: route, mt: methods, x: exports, c: columns }\n  edges[]: { s: source_node_index, d: target_node_index, t: type, l: label }\nedges.s / edges.d are 0-based indices into THIS response\'s nodes array. If a referenced node is not in the response (boundary case), s/d may instead contain the full node id string \u2014 always check the type.\n\nBUDGET GUARDS:\n- Neighborhood queries stop expanding when the projected response exceeds budget. The response then contains `budget_exceeded: true` plus `hops_traversed < hops_requested`. When this happens, drill into a specific neighbor with another node_id call rather than retrying with larger hops \u2014 it will just truncate again.\n- Batch mode caps total response size. Once the budget is hit, later queries return `{skipped: true, reason: "batch_budget_exhausted"}` and you must re-run them individually.',
     inputSchema: {
       type: "object",
       properties: {
@@ -8389,7 +8765,15 @@ var TOOLS = [
         },
         module: {
           type: "string",
-          description: 'UI layer only \u2014 filter by module (e.g. "auth", "admin", "project", "org").'
+          description: 'Filter by module tag (e.g. "auth", "admin", "settings"). Works across all layers.'
+        },
+        tag_key: {
+          type: "string",
+          description: "Filter by arbitrary tag key. Must be used with tag_value."
+        },
+        tag_value: {
+          type: "string",
+          description: "Filter by tag value for the given tag_key."
         },
         node_id: {
           type: "string",
@@ -8513,6 +8897,46 @@ Use this when the user asks "is the chart running", "show me the project graph U
       type: "object",
       properties: {}
     }
+  },
+  {
+    name: "add_tag",
+    description: 'Tag a graph node with a key-value pair. Tags persist in .launchsecure/graphs/tags.json and survive graph regeneration. Use for annotating nodes with arbitrary metadata (e.g. "refactor_later", "owner", "priority"). Manual tags override computed tags (like module and screen) for the same key.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        node_id: {
+          type: "string",
+          description: 'The node id to tag (e.g. "app/(auth)/login/page.tsx").'
+        },
+        key: {
+          type: "string",
+          description: 'Tag key (e.g. "module", "owner", "refactor_later").'
+        },
+        value: {
+          type: "string",
+          description: 'Tag value (e.g. "auth", "alice", "true").'
+        }
+      },
+      required: ["node_id", "key", "value"]
+    }
+  },
+  {
+    name: "remove_tag",
+    description: "Remove a manual tag from a graph node. Only removes tags from tags.json \u2014 computed tags (module, screen) cannot be removed (they are re-derived at read time).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        node_id: {
+          type: "string",
+          description: "The node id to remove the tag from."
+        },
+        key: {
+          type: "string",
+          description: "Tag key to remove."
+        }
+      },
+      required: ["node_id", "key"]
+    }
   }
 ];
 function matchesSearch(node, query) {
@@ -8526,7 +8950,7 @@ function matchesSearch(node, query) {
 function toMinimal(nodes) {
   return nodes.map((n) => {
     const out = { id: n.id, type: n.type, name: n.name };
-    if (n.module != null) out.module = n.module;
+    if (n.tags != null) out.tags = n.tags;
     if (n.route != null) out.route = n.route;
     if (n.methods != null) out.methods = n.methods;
     return out;
@@ -8537,11 +8961,12 @@ var COMPACT_SCHEMA = {
     i: "id",
     t: "type",
     n: "name",
-    m: "module",
+    m: "module (from tags)",
     r: "route",
     mt: "methods",
     x: "exports",
-    c: "columns"
+    c: "columns",
+    tg: "tags"
   },
   edges: {
     s: "source_node_index",
@@ -8559,7 +8984,8 @@ var COMPACT_NODE_KNOWN_KEYS = /* @__PURE__ */ new Set([
   "route",
   "methods",
   "exports",
-  "columns"
+  "columns",
+  "tags"
 ]);
 var EST_CHARS_PER_NODE_FULL = {
   ui: 300,
@@ -8580,11 +9006,13 @@ var NEIGHBORHOOD_BUDGET_CHARS = 55e3;
 var BATCH_BUDGET_CHARS = 6e4;
 function toCompactNode(n) {
   const out = { i: n.id, t: n.type, n: n.name };
-  if (n.module != null) out.m = n.module;
+  const tags = n.tags;
+  if (tags?.module) out.m = tags.module;
   if (n.route != null) out.r = n.route;
   if (n.methods != null) out.mt = n.methods;
   if (n.exports != null) out.x = n.exports;
   if (n.columns != null) out.c = n.columns;
+  if (tags != null) out.tg = tags;
   for (const k of Object.keys(n)) {
     if (!COMPACT_NODE_KNOWN_KEYS.has(k) && n[k] != null) out[k] = n[k];
   }
@@ -8660,7 +9088,8 @@ function layerSummary(graph) {
   const moduleCounts = {};
   for (const n of graph.nodes) {
     typeCounts[n.type] = (typeCounts[n.type] ?? 0) + 1;
-    const mod = n.module;
+    const tags = n.tags;
+    const mod = tags?.module;
     if (mod) moduleCounts[mod] = (moduleCounts[mod] ?? 0) + 1;
   }
   const edgeTypeCounts = {};
@@ -8717,12 +9146,14 @@ function runReadGraphQueryRaw(rootDir, args) {
   const search = args.search;
   const type = args.type;
   const module_ = args.module;
+  const tagKey = args.tag_key;
+  const tagValue = args.tag_value;
   const nodeId = args.node_id;
   const hops = args.hops ?? 1;
   const layerIsDb = args.layer === "db";
   const minimal = args.minimal ?? layerIsDb;
   const includeEdges = args.include_edges;
-  const hasFilter = !!(search || type || module_ || nodeId);
+  const hasFilter = !!(search || type || module_ || nodeId || tagKey && tagValue);
   if (layer && !["ui", "api", "db"].includes(layer)) {
     return { error: `Invalid layer "${layer}". Must be one of: ui, api, db` };
   }
@@ -8778,7 +9209,9 @@ function runReadGraphQueryRaw(rootDir, args) {
   const matched = graph.nodes.filter((n) => {
     if (search && !matchesSearch(n, search)) return false;
     if (type && n.type !== type) return false;
-    if (module_ && n.module !== module_) return false;
+    const nodeTags = n.tags;
+    if (module_ && nodeTags?.module !== module_) return false;
+    if (tagKey && tagValue && nodeTags?.[tagKey] !== tagValue) return false;
     return true;
   });
   const matchedIds = new Set(matched.map((n) => n.id));
@@ -8865,9 +9298,9 @@ function handleReadGraph(args) {
   return okJson(result);
 }
 function nodeToFilePath(rootDir, layer, nodeId) {
-  if (layer === "ui") return (0, import_node_path12.join)(rootDir, "src", nodeId);
-  if (layer === "api") return (0, import_node_path12.join)(rootDir, nodeId);
-  if (layer === "db") return (0, import_node_path12.join)(rootDir, "prisma", "schema.prisma");
+  if (layer === "ui") return (0, import_node_path15.join)(rootDir, "src", nodeId);
+  if (layer === "api") return (0, import_node_path15.join)(rootDir, nodeId);
+  if (layer === "db") return (0, import_node_path15.join)(rootDir, "prisma", "schema.prisma");
   return null;
 }
 function handleGrepNodes(args) {
@@ -8927,11 +9360,11 @@ function handleGrepNodes(args) {
   let filesSearched = 0;
   let truncated = false;
   for (const [filePath, nodeId] of filePaths) {
-    if (!(0, import_node_fs11.existsSync)(filePath)) continue;
+    if (!(0, import_node_fs13.existsSync)(filePath)) continue;
     filesSearched++;
     let content;
     try {
-      content = (0, import_node_fs11.readFileSync)(filePath, "utf-8");
+      content = (0, import_node_fs13.readFileSync)(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -8969,7 +9402,8 @@ function handleGrepNodes(args) {
   });
 }
 function handleChartServerStatus() {
-  const lock = getLiveLock();
+  const rootDir = process.cwd();
+  const lock = getLiveLock(rootDir);
   if (!lock) {
     return okJson({ running: false });
   }
@@ -8983,7 +9417,8 @@ function handleChartServerStatus() {
   });
 }
 function handleStartChartServer(args) {
-  const lock = getLiveLock();
+  const rootDir = process.cwd();
+  const lock = getLiveLock(rootDir);
   if (lock) {
     return okJson({
       started: false,
@@ -8994,11 +9429,11 @@ function handleStartChartServer(args) {
     });
   }
   const entryPath = process.argv[1];
-  const logDir = (0, import_node_path12.join)((0, import_node_os2.homedir)(), ".launchsecure");
-  (0, import_node_fs11.mkdirSync)(logDir, { recursive: true });
-  const logPath = (0, import_node_path12.join)(logDir, "launch-chart.log");
-  const out = (0, import_node_fs11.openSync)(logPath, "a");
-  const err2 = (0, import_node_fs11.openSync)(logPath, "a");
+  const logDir = (0, import_node_path15.join)((0, import_node_os2.homedir)(), ".launchsecure");
+  (0, import_node_fs13.mkdirSync)(logDir, { recursive: true });
+  const logPath = (0, import_node_path15.join)(logDir, "launch-chart.log");
+  const out = (0, import_node_fs13.openSync)(logPath, "a");
+  const err2 = (0, import_node_fs13.openSync)(logPath, "a");
   const portArgs = args.port ? ["--port", String(args.port)] : [];
   const child = (0, import_node_child_process2.spawn)(process.execPath, [entryPath, "serve", ...portArgs], {
     detached: true,
@@ -9013,7 +9448,8 @@ function handleStartChartServer(args) {
   });
 }
 function handleStopChartServer() {
-  const lock = getLiveLock();
+  const rootDir = process.cwd();
+  const lock = getLiveLock(rootDir);
   if (!lock) {
     return okJson({ stopped: false, reason: "not_running" });
   }
@@ -9023,14 +9459,45 @@ function handleStopChartServer() {
   } catch (e) {
     const code = e.code;
     if (code === "ESRCH") {
-      clearLock();
+      clearLock(rootDir);
       return okJson({ stopped: true, pid: lock.pid, note: "process was already gone, lock cleaned up" });
     }
     return okJson({ stopped: false, reason: `kill failed: ${code ?? e}` });
   }
 }
+function handleAddTag(args) {
+  const rootDir = process.cwd();
+  const nodeId = args.node_id;
+  const key = args.key;
+  const value = args.value;
+  if (!nodeId) return err("node_id is required");
+  if (!key) return err("key is required");
+  if (!value) return err("value is required");
+  const graphs = readAllGraphs(rootDir);
+  let found = false;
+  for (const graph of Object.values(graphs)) {
+    if (graph && graph.nodes.some((n) => n.id === nodeId)) {
+      found = true;
+      break;
+    }
+  }
+  if (!found) {
+    return err(`Node "${nodeId}" not found in any graph layer. Check the node_id.`);
+  }
+  setTag(rootDir, nodeId, key, value);
+  return okJson({ ok: true, node_id: nodeId, tag: { [key]: value } });
+}
+function handleRemoveTag(args) {
+  const rootDir = process.cwd();
+  const nodeId = args.node_id;
+  const key = args.key;
+  if (!nodeId) return err("node_id is required");
+  if (!key) return err("key is required");
+  removeTag(rootDir, nodeId, key);
+  return okJson({ ok: true, node_id: nodeId, removed_key: key });
+}
 function handleDetectProjectStack() {
-  const rootDir = findProjectRoot(process.cwd());
+  const rootDir = process.cwd();
   const parsers = [
     { id: "react-nextjs", layer: "ui", detected: reactNextjsParser.detect(rootDir) },
     { id: "nextjs-routes", layer: "api", detected: nextjsRoutesParser.detect(rootDir) },
@@ -9048,20 +9515,20 @@ function handleDetectProjectStack() {
       if (f.type === "out_of_pattern") stats.out_of_pattern++;
     }
   }
-  const srcDir = (0, import_node_path12.join)(rootDir, "src");
-  if ((0, import_node_fs11.existsSync)(srcDir)) {
+  const srcDir = (0, import_node_path15.join)(rootDir, "src");
+  if ((0, import_node_fs13.existsSync)(srcDir)) {
     const scanDir = (dir) => {
-      if (!(0, import_node_fs11.existsSync)(dir)) return;
-      for (const entry of (0, import_node_fs11.readdirSync)(dir, { withFileTypes: true })) {
+      if (!(0, import_node_fs13.existsSync)(dir)) return;
+      for (const entry of (0, import_node_fs13.readdirSync)(dir, { withFileTypes: true })) {
         if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-        const full = (0, import_node_path12.join)(dir, entry.name);
+        const full = (0, import_node_path15.join)(dir, entry.name);
         if (entry.isDirectory()) {
           scanDir(full);
           continue;
         }
-        if (![".ts", ".tsx"].includes((0, import_node_path12.extname)(entry.name))) continue;
+        if (![".ts", ".tsx"].includes((0, import_node_path15.extname)(entry.name))) continue;
         try {
-          const content = (0, import_node_fs11.readFileSync)(full, "utf-8");
+          const content = (0, import_node_fs13.readFileSync)(full, "utf-8");
           const matches = content.match(/@api\s+(GET|POST|PUT|DELETE|PATCH)\s+\/\S+/g);
           if (matches) stats.annotations += matches.length;
         } catch {
@@ -9148,6 +9615,14 @@ function handleMessage(msg) {
       respond(id ?? null, handleDetectProjectStack());
       return;
     }
+    if (toolName === "add_tag") {
+      respond(id ?? null, handleAddTag(args));
+      return;
+    }
+    if (toolName === "remove_tag") {
+      respond(id ?? null, handleRemoveTag(args));
+      return;
+    }
     respondError(id ?? null, -32601, `Unknown tool: ${toolName}`);
     return;
   }
@@ -9245,7 +9720,7 @@ function parseArgs() {
   return { port, token, serverUrl: LAUNCHSECURE_URL, subcommand };
 }
 function tryListen(server, port, maxRetries = 10) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     let attempts = 0;
     function attempt(p) {
       server.once("error", (err2) => {
@@ -9256,7 +9731,7 @@ function tryListen(server, port, maxRetries = 10) {
           reject(err2);
         }
       });
-      server.listen(p, () => resolve2(p));
+      server.listen(p, () => resolve3(p));
     }
     attempt(port);
   });
@@ -9277,7 +9752,7 @@ function saveCredentials(creds) {
   });
 }
 function verifyToken(serverUrl, token) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const url = new URL("/api/mcp/verify", serverUrl);
     const body = JSON.stringify({ token });
     const mod = url.protocol === "https:" ? import_https.default : import_http.default;
@@ -9292,30 +9767,30 @@ function verifyToken(serverUrl, token) {
       res.on("data", (chunk) => data += chunk);
       res.on("end", () => {
         try {
-          resolve2(JSON.parse(data));
+          resolve3(JSON.parse(data));
         } catch {
-          resolve2({ valid: false, error: "Invalid response from server" });
+          resolve3({ valid: false, error: "Invalid response from server" });
         }
       });
     });
     req.on("error", (err2) => {
-      resolve2({ valid: false, error: `Cannot reach server: ${err2.message}` });
+      resolve3({ valid: false, error: `Cannot reach server: ${err2.message}` });
     });
     req.setTimeout(1e4, () => {
       req.destroy();
-      resolve2({ valid: false, error: "Connection timed out" });
+      resolve3({ valid: false, error: "Connection timed out" });
     });
     req.write(body);
     req.end();
   });
 }
 function httpRequest(reqUrl, options, body, timeout = 3e4) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const mod = reqUrl.protocol === "https:" ? import_https.default : import_http.default;
     const r = mod.request(reqUrl, options, (resp) => {
       let data = "";
       resp.on("data", (chunk) => data += chunk);
-      resp.on("end", () => resolve2({ status: resp.statusCode || 0, headers: resp.headers, body: data }));
+      resp.on("end", () => resolve3({ status: resp.statusCode || 0, headers: resp.headers, body: data }));
     });
     r.on("error", reject);
     r.setTimeout(timeout, () => {