@launchsecure/launch-kit 0.0.35 → 0.0.36

package/dist/server/cli.js

@@ -27210,6 +27210,9 @@ function buildAnalyzerMcpConfig() {
   });
 }
 function buildAnalyzerPrompt(ctx) {
+  if (ctx.kind === "event") {
+    return buildEventPrompt(ctx);
+  }
   const lines = [];
   lines.push("New user feedback received via the LaunchSecure beacon. Investigate, fix, test, and commit locally. DO NOT push \u2014 local commits only.");
   lines.push("");
@@ -27307,6 +27310,55 @@ function buildAnalyzerPrompt(ctx) {
   lines.push(`  ${n++}. If any fix is non-trivial, ambiguous, or would touch many files, STOP and either (a) ask via \`AskUserQuestion\`, or (b) write a plan in your final response instead of editing. Better to leave the user a clear next-step than to commit a wrong change.`);
   return lines.join("\n");
 }
+function buildEventPrompt(ctx) {
+  const lines = [];
+  const userPrompt = (ctx.rulePrompt ?? "").trim();
+  lines.push(
+    userPrompt || "A LaunchSecure event matched a radar capture rule. Investigate and act on it. Make local commits only \u2014 DO NOT push."
+  );
+  lines.push("");
+  lines.push("OUTPUT FORMAT \u2014 MANDATORY. Your VERY FIRST line of output, before any tool calls or thinking, must be:");
+  lines.push("  `<bug|feature|cosmetic|question|other>: <one short sentence>`");
+  lines.push("");
+  lines.push("CONTEXT \u2014 auto-injected from the event that triggered this rule. Treat it as ground truth for what happened; the instruction above is your task.");
+  if (ctx.eventType) lines.push(`- Event: ${ctx.eventType}`);
+  if (ctx.eventMessage) lines.push(`- Summary: ${ctx.eventMessage}`);
+  const metaLines = formatMetadataLines(ctx.eventMetadata ?? {});
+  if (metaLines.length > 0) {
+    lines.push("- Event fields:");
+    for (const l of metaLines) lines.push(`    ${l}`);
+  }
+  if (ctx.enrichedEntity) {
+    lines.push("");
+    lines.push("ENTITY DETAILS (fetched fresh from LaunchSecure at analysis time):");
+    lines.push("```json");
+    lines.push(safeJson(ctx.enrichedEntity));
+    lines.push("```");
+  } else if (ctx.entityRef && ctx.entityRef.kind !== "none") {
+    lines.push(`- Linked ${ctx.entityRef.kind}: ${ctx.entityRef.id ?? "(id unavailable)"} (not prefetched \u2014 fetch via MCP if you need its details)`);
+  }
+  lines.push("");
+  lines.push("TOOL DISCIPLINE \u2014 use the launch-chart MCP as the DEFAULT for code investigation (read_graph / inspect_node / grep_nodes); fall back to Read/Grep/Glob only when chart can't answer.");
+  lines.push("");
+  lines.push("PROCEDURE: emit the category line, carry out the instruction grounded in the CONTEXT above, keep changes minimal and scoped, run any relevant tests, and commit locally with a conventional message. DO NOT push. If the task is ambiguous or wide-reaching, STOP and ask via AskUserQuestion or leave a plan instead of editing.");
+  return lines.join("\n");
+}
+function formatMetadataLines(md) {
+  const SKIP = /* @__PURE__ */ new Set(["resourceType", "resourceId", "resource"]);
+  const out = [];
+  for (const [k, v] of Object.entries(md)) {
+    if (SKIP.has(k) || v === null || v === void 0 || typeof v === "object") continue;
+    out.push(`${k}: ${String(v)}`);
+  }
+  return out;
+}
+function safeJson(v) {
+  try {
+    return JSON.stringify(v, null, 2).slice(0, 4e3);
+  } catch {
+    return String(v);
+  }
+}
 function formatEventOffset(eventTs, capturedAt) {
   if (!capturedAt) return `ts=${eventTs}`;
   const diffMs = eventTs - new Date(capturedAt).getTime();
@@ -27568,6 +27620,131 @@ function parseBody(text) {
 
 // src/server/radar/receiver.ts
 var import_node_crypto5 = require("node:crypto");
+
+// src/server/radar/rules.ts
+var WEBHOOK_LIFECYCLE_EVENTS = [
+  "webhook.activated",
+  "webhook.disabled",
+  "webhook.deleted"
+];
+var COMMENT_TYPES = ["COMMENT_CREATED", "COMMENT_REPLY"];
+var BUILTIN_FEEDBACK_RULE = {
+  id: "builtin-feedback",
+  name: "Beacon feedback",
+  enabled: true,
+  trigger: "COMMENT_CREATED",
+  filters: [],
+  // the feedback predicate is special-cased (OR across sources)
+  enrich: false,
+  // beacon already fat-packs the context
+  prompt: ""
+  // empty → analyze.ts uses the built-in feedback template
+};
+function resolveRules(stored) {
+  if (Array.isArray(stored) && stored.length > 0) {
+    return stored;
+  }
+  return [BUILTIN_FEEDBACK_RULE];
+}
+function subscribedEventTypes(rules) {
+  const set = new Set(WEBHOOK_LIFECYCLE_EVENTS);
+  for (const rule of rules) {
+    if (!rule.enabled) {
+      continue;
+    }
+    if (COMMENT_TYPES.includes(rule.trigger)) {
+      for (const t of COMMENT_TYPES) {
+        set.add(t);
+      }
+    } else {
+      set.add(rule.trigger);
+    }
+  }
+  return [...set];
+}
+function isFeedbackPayload(payload) {
+  if (!COMMENT_TYPES.includes(payload.type)) {
+    return false;
+  }
+  const md = payload.metadata ?? {};
+  const tags = extractTags(md).map((t) => t.toLowerCase());
+  if (tags.includes("feedback") || tags.includes("bug")) {
+    return true;
+  }
+  const resource = md.resource ?? {};
+  if (resource.linkedResourceType === "feedback") {
+    return true;
+  }
+  if (md.linkedResourceType === "feedback") {
+    return true;
+  }
+  return false;
+}
+function extractTags(metadata) {
+  const t = metadata?.tags;
+  if (Array.isArray(t)) {
+    return t.filter((x) => typeof x === "string");
+  }
+  return [];
+}
+function metaValue(metadata, field) {
+  if (field === "tags") {
+    return extractTags(metadata);
+  }
+  return metadata[field];
+}
+function filterMatches(filter, metadata) {
+  const actual = metaValue(metadata, filter.field);
+  switch (filter.op) {
+    case "eq":
+      return typeof filter.value === "string" && String(actual) === filter.value;
+    case "in": {
+      const wanted = Array.isArray(filter.value) ? filter.value : [filter.value];
+      if (Array.isArray(actual)) {
+        return actual.some((a) => wanted.includes(String(a)));
+      }
+      return wanted.includes(String(actual));
+    }
+    case "contains": {
+      const needle = Array.isArray(filter.value) ? filter.value[0] ?? "" : filter.value;
+      if (Array.isArray(actual)) {
+        return actual.map(String).includes(needle);
+      }
+      return typeof actual === "string" && actual.includes(needle);
+    }
+    default:
+      return false;
+  }
+}
+function triggerMatches(rule, type) {
+  if (COMMENT_TYPES.includes(rule.trigger)) {
+    return COMMENT_TYPES.includes(type);
+  }
+  return rule.trigger === type;
+}
+function matchRule(payload, rules) {
+  const md = payload.metadata ?? {};
+  for (const rule of rules) {
+    if (!rule.enabled) {
+      continue;
+    }
+    if (!triggerMatches(rule, payload.type)) {
+      continue;
+    }
+    if (rule.id === BUILTIN_FEEDBACK_RULE.id) {
+      if (isFeedbackPayload(payload)) {
+        return rule;
+      }
+      continue;
+    }
+    if (rule.filters.every((f) => filterMatches(f, md))) {
+      return rule;
+    }
+  }
+  return null;
+}
+
+// src/server/radar/receiver.ts
 var SIGNATURE_HEADER = "x-ls-signature";
 var EVENT_HEADER = "x-ls-event";
 var DELIVERY_HEADER = "x-ls-delivery";
@@ -27590,23 +27767,22 @@ function verifySignature(secret, signatureHeader, body) {
   if (a.length !== b.length) return false;
   return (0, import_node_crypto5.timingSafeEqual)(a, b);
 }
-function extractTags(metadata) {
-  const t = metadata?.tags;
-  if (Array.isArray(t)) return t.filter((x) => typeof x === "string");
-  return [];
-}
-function isFeedbackEvent(payload) {
-  if (payload.type !== "COMMENT_CREATED" && payload.type !== "COMMENT_REPLY") return false;
+function buildEventContext(payload, rule) {
   const md = payload.metadata ?? {};
-  const tags = extractTags(md).map((t) => t.toLowerCase());
-  if (tags.includes("feedback") || tags.includes("bug")) return true;
-  const resource = md.resource ?? {};
-  if (resource.linkedResourceType === "feedback") return true;
-  if (md.linkedResourceType === "feedback") return true;
-  return false;
+  const isWorkItem = payload.type.startsWith("work_item.");
+  const workItemId = typeof md.workItemId === "string" ? md.workItemId : typeof md.resourceId === "string" ? md.resourceId : void 0;
+  return {
+    kind: "event",
+    eventType: payload.type,
+    eventMessage: payload.message,
+    eventMetadata: md,
+    rulePrompt: rule.prompt,
+    entityRef: rule.enrich && isWorkItem ? { kind: "work_item", id: workItemId } : { kind: "none" },
+    body: payload.message
+  };
 }
 function createReceiver(params) {
-  const { state, callbacks } = params;
+  const { state, callbacks, getRules } = params;
   return (req, res) => {
     const chunks = [];
     req.on("data", (c) => chunks.push(c));
@@ -27636,7 +27812,7 @@ function createReceiver(params) {
       res.end(JSON.stringify({ ok: true }));
       const eventHeader = req.headers[EVENT_HEADER] ?? payload.type;
       const deliveryId = req.headers[DELIVERY_HEADER] ?? "?";
-      handlePayload(payload, eventHeader, deliveryId, state, callbacks);
+      handlePayload(payload, eventHeader, deliveryId, state, callbacks, getRules);
     });
     req.on("error", () => {
       try {
@@ -27647,7 +27823,7 @@ function createReceiver(params) {
     });
   };
 }
-function handlePayload(payload, eventType, deliveryId, state, cb) {
+function handlePayload(payload, eventType, deliveryId, state, cb, getRules) {
   switch (eventType) {
     case "webhook.activated":
       console.log(`[radar] \u25C9 webhook.activated (${deliveryId})`);
@@ -27661,15 +27837,16 @@ function handlePayload(payload, eventType, deliveryId, state, cb) {
       console.log(`[radar] \u2717 webhook.deleted (${deliveryId}) \u2014 re-registering`);
       cb.onDeleted();
       return;
-    default:
-      if (!isFeedbackEvent(payload)) {
+    default: {
+      const rule = matchRule(payload, getRules());
+      if (!rule) {
         return;
       }
       if (state.hasSeen(payload.id)) {
         console.log(`[radar] dup ${payload.id} \u2014 skipping`);
         return;
       }
-      const context = buildContext(payload);
+      const context = rule.id === BUILTIN_FEEDBACK_RULE.id ? buildContext(payload) : buildEventContext(payload, rule);
       const threadId = extractThreadId(payload);
       const ping = {
         id: payload.id,
@@ -27677,14 +27854,17 @@ function handlePayload(payload, eventType, deliveryId, state, cb) {
         receivedAt: (/* @__PURE__ */ new Date()).toISOString(),
         threadId,
         context,
-        state: "queued"
+        state: "queued",
         // analyzer flips to 'analyzing' on pickup
+        ruleId: rule.id,
+        ruleName: rule.name
       };
       const appended = state.appendPingIfNew(ping);
       if (appended) {
-        console.log(`[radar] \u25C9 ping: "${ping.title}" (${deliveryId})`);
+        console.log(`[radar] \u25C9 ping [${rule.name}]: "${ping.title}" (${deliveryId})`);
         cb.onPing(ping);
       }
+    }
   }
 }
 function extractThreadId(payload) {
@@ -28043,6 +28223,12 @@ var RadarState = class {
       p.context.screenshotLocalPath = path13;
     });
   }
+  /** Persist entity details fetched (via MCP) for a rule with enrich=true. */
+  setEnrichedEntity(id, entity) {
+    return this.mutate(id, (p) => {
+      p.context.enrichedEntity = entity;
+    });
+  }
   /**
    * Wipe all analysis-result fields so the ping can be re-enqueued from a
    * clean state. Preserves immutable identity fields (id, threadId, title,
@@ -28678,6 +28864,8 @@ var Radar = class _Radar {
     }
     this.tunnel = tunnel;
     this.maxConcurrent = parsePositiveInt(process.env.RADAR_MAX_CONCURRENT_ANALYSES);
+    this.rules = resolveRules(opts.rules);
+    console.log(`[radar] ${this.rules.length} capture rule(s): ${this.rules.map((r) => r.name).join(", ")}`);
     const callbacks = {
       onLive: () => this.handleLive(),
       onDeactivated: () => this.handleDeactivated(),
@@ -28686,7 +28874,7 @@ var Radar = class _Radar {
       },
       onPing: (ping) => this.handlePing(ping)
     };
-    this.receiver = createReceiver({ state: this.state, callbacks });
+    this.receiver = createReceiver({ state: this.state, callbacks, getRules: () => this.rules });
   }
   static {
     // Tunnel provider is hardcoded for now — radar today cannot function
@@ -28772,7 +28960,8 @@ var Radar = class _Radar {
       const result = await registerOrRefresh({
         mcp: this.mcp,
         state: this.state,
-        tunnelUrl: publicUrl
+        tunnelUrl: publicUrl,
+        eventTypes: subscribedEventTypes(this.rules)
       });
       if (result.approvalStatus === "approved") {
         this.status = "live";
@@ -28862,6 +29051,21 @@ var Radar = class _Radar {
           }
         }
       }
+      const ref = ping.context.entityRef;
+      if (ref && ref.kind === "work_item" && ref.id) {
+        try {
+          const item = await this.mcp.call("work_item_get", { item_id: ref.id });
+          if (item && typeof item === "object") {
+            const u = this.state.setEnrichedEntity(ping.id, item);
+            if (u) {
+              ping = u;
+              this.broadcastPingState(u);
+            }
+          }
+        } catch (err2) {
+          console.warn(`[radar] enrichment fetch failed for ${ping.id}: ${err2 instanceof Error ? err2.message : String(err2)}`);
+        }
+      }
       const { sessionId } = await spawnAnalysisSession({ ping, projectDir: this.opts.projectRoot });
       const updated = this.state.setAnalysisStarted(ping.id, sessionId);
       console.log(`[radar] \u25B6 analyzing ${ping.id} \u2192 session ${sessionId.slice(-8)}`);
@@ -37767,6 +37971,17 @@ if (!__isMcpMode) {
       console.log(row("Project", `${cfg.orgSlug} ${dim("/")} ${cfg.projectSlug}`));
       console.log(row("Active on", localUrl));
       console.log("");
+      let radarRules = null;
+      if (process.env.RADAR_RULES) {
+        try {
+          const parsed = JSON.parse(process.env.RADAR_RULES);
+          if (Array.isArray(parsed)) {
+            radarRules = parsed;
+          }
+        } catch {
+          console.warn("[radar] RADAR_RULES is not valid JSON \u2014 using the built-in feedback rule");
+        }
+      }
       try {
         radar = new Radar({
           projectRoot: PROJECT_DIR,
@@ -37775,7 +37990,8 @@ if (!__isMcpMode) {
           serverUrl: cfg.serverUrl,
           pat: cfg.pat,
           orgSlug: cfg.orgSlug,
-          projectSlug: cfg.projectSlug
+          projectSlug: cfg.projectSlug,
+          rules: radarRules
         });
       } catch (err2) {
         console.error(`${err2 instanceof Error ? err2.message : String(err2)}`);