securenow 8.16.0 → 8.18.0

package/esm-detect.js

@@ -0,0 +1,57 @@
+'use strict';
+
+/**
+ * Is this an ESM app, so the preload must register the ESM loader hook?
+ *
+ * Node decides a file's module type from the nearest package.json above THE FILE, not from
+ * the working directory. Process managers often start apps from another directory (pm2 `cwd`,
+ * systemd WorkingDirectory, a Docker WORKDIR, a supervisor that runs each environment from its
+ * own folder). Checking only process.cwd() then missed the hook, and every library the app
+ * imports (Express, pg, ...) went uninstrumented: no http.route on any request span.
+ *
+ * ESM when any of these says so: the entry script is .mjs; the nearest package.json above the
+ * entry script (process.argv[1], or pm2's pm_exec_path) has "type": "module"; or the working
+ * directory's package.json does (the original check, kept for launchers whose argv[1] is a wrapper).
+ */
+const fs = require('fs');
+const path = require('path');
+
+function readType(pkgPath) {
+  try {
+    return JSON.parse(fs.readFileSync(pkgPath, 'utf8').replace(/^/, '')).type || 'commonjs';
+  } catch (_) {
+    return null;
+  }
+}
+
+function nearestPackageJson(startDir) {
+  let dir = startDir;
+  for (let i = 0; i < 64; i++) {
+    const candidate = path.join(dir, 'package.json');
+    if (fs.existsSync(candidate)) return candidate;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+  return null;
+}
+
+/** @returns {{ esm: boolean, reason: string|null }} */
+function detectEsmApp({ argv = process.argv, cwd = process.cwd(), env = process.env } = {}) {
+  const entries = [argv && argv[1], env && env.pm_exec_path]
+    .filter((p) => typeof p === 'string' && p && !p.startsWith('-'))
+    .map((p) => path.resolve(cwd, p));
+
+  for (const entry of entries) {
+    if (/\.mjs$/i.test(entry)) return { esm: true, reason: `${path.basename(entry)} is an .mjs file` };
+    if (/\.cjs$/i.test(entry)) continue;
+    const pkgPath = nearestPackageJson(path.dirname(entry));
+    if (pkgPath && readType(pkgPath) === 'module') return { esm: true, reason: `${pkgPath} has "type": "module"` };
+  }
+
+  const cwdPkg = path.resolve(cwd, 'package.json');
+  if (fs.existsSync(cwdPkg) && readType(cwdPkg) === 'module') return { esm: true, reason: `${cwdPkg} has "type": "module"` };
+  return { esm: false, reason: null };
+}
+
+module.exports = { detectEsmApp, nearestPackageJson };

package/mcp/catalog.js

@@ -353,7 +353,7 @@ const TOOLS = [
   {
     name: 'securenow_traces_show',
     title: 'Show Trace',
-    description: 'Show spans for a trace id scoped to one or more app keys.',
+    description: 'Show spans for a trace id scoped to one or more app keys. Fields identical on every span (service, environment and other resource attributes) come once under shared; empty fields are left out.',
     scope: 'traces:read',
     readOnly: true,
     method: 'GET',
@@ -385,6 +385,25 @@ const TOOLS = [
       limit: number('Maximum logs to return.', { minimum: 1, maximum: 500 }),
     }, ['appKeys']),
   },
+  {
+    name: 'securenow_logs_errors',
+    title: 'Summarize Error Logs',
+    description: 'What is failing: error (and fatal) log lines grouped by message, with ids, uuids, IPs and numbers normalized so repeats are one group. Each group: a sample line, how many times, first and last seen, environments, exception type and sample trace ids (pass one to securenow_logs_for_trace or securenow_traces_show). Far cheaper than listing raw logs. includeWarn adds warnings.',
+    scope: 'logs:read',
+    readOnly: true,
+    method: 'GET',
+    endpoint: '/logs/errors',
+    queryFields: ['appKeys', 'environment', 'since', 'from', 'to', 'includeWarn', 'limit'],
+    normalize: { appKeys: normalizeAppKeys },
+    inputSchema: objectSchema({
+      ...appKeysInput,
+      ...environmentInput,
+      since: string('Window: 30m, 1h (default), 6h, 2d; or pass from/to.'),
+      ...timeRangeInput,
+      includeWarn: boolean('Also group warnings.'),
+      limit: number('Maximum groups (default 20).', { minimum: 1, maximum: 100 }),
+    }, ['appKeys']),
+  },
   {
     name: 'securenow_logs_for_trace',
     title: 'Logs For Trace',
@@ -1381,13 +1400,13 @@ const TOOLS = [
   {
     name: 'securenow_alert_rule_draft',
     title: 'Draft an Alert Rule From English',
-    description: 'Turn a detection idea in plain English into an alert rule draft for one app, checked against that app\'s data. It reads the app\'s real event types, attribute keys and routes, then picks the kind: instant (conditions checked on every incoming request, alerts within seconds; one request is enough evidence) or periodic (SQL run on a schedule: counts, thresholds, distinct counts, ratios, sequences, baselines, security events, app log lines). Periodic SQL is run once against the data; instant conditions are replayed over the app\'s last 2000 requests, so check.matches shows what would alert today (false positives). Nothing is saved: create it with securenow_alert_rule_create, passing the draft fields. Waits up to 120 seconds.',
+    description: 'Turn a detection idea in plain English into an alert rule draft for one app, checked against that app\'s data. It reads the app\'s real event types, attribute keys and routes, then picks the kind: instant (conditions checked on every incoming request, alerts within seconds; one request is enough evidence) or periodic (SQL run on a schedule: counts, thresholds, distinct counts, ratios, sequences, baselines, security events, app log lines). Periodic SQL is run once against the data; instant conditions are replayed over the app\'s last 2000 requests, so check.matches shows what would alert today (false positives). Nothing is saved: create it with securenow_alert_rule_create, passing the draft fields. To CHANGE an existing rule, pass ruleId and describe the change in text: the draft is the whole rule rewritten (same kind, the rest kept), with `current` showing the rule as it is; apply it with securenow_alert_rule_update (sqlQuery + schedule, or instant {matchMode, conditions, environments}). Waits up to 120 seconds.',
     scope: 'alerts:write',
     readOnly: false,
     confirm: true,
     method: 'POST',
     endpoint: '/alert-rules/draft',
-    bodyFields: ['text', 'applicationKey', 'environment', 'kind'],
+    bodyFields: ['text', 'applicationKey', 'environment', 'kind', 'ruleId'],
     poll: {
       tool: 'securenow_alert_rule_draft_status',
       idField: 'draftId',
@@ -1400,8 +1419,9 @@ const TOOLS = [
       applicationKey: string('App key the rule watches; the draft is checked against its data.'),
       environment: string('Only watch this environment (e.g. production). Omit to watch every environment.'),
       kind: string('Optional: instant or periodic. Omit to let the drafter choose.'),
+      ruleId: string('Optional: an existing custom rule to change; text then describes the change. applicationKey defaults to one the rule watches.'),
       ...confirmSchema,
-    }, ['text', 'applicationKey', 'confirm', 'reason']),
+    }, ['text', 'confirm', 'reason']),
   },
   {
     name: 'securenow_alert_rule_draft_status',
@@ -1419,13 +1439,13 @@ const TOOLS = [
   {
     name: 'securenow_alert_rule_create',
     title: 'Create Alert Rule (Test Mode)',
-    description: 'Create an alert rule. It always starts in test mode: it alerts, but nothing blocks, rate-limits or acts on its alerts until a person promotes it. Instant rule: executionMode "instant" plus instant {matchMode: any|all, conditions: [{field: path|method|user_agent|status_code|request_body|request_headers|client_ip|host, operator, value}]}. Periodic rule: sqlQuery plus schedule {cronExpression}; the SQL must scope every table with the __USER_APP_KEYS__ placeholder, bound time on every table read, and return a column named ip (rows without an ip never alert). Easiest path: securenow_alert_rule_draft, then pass its draft fields here. Write action; requires confirmation.',
+    description: 'Create an alert rule. It always starts in test mode: it alerts, but nothing blocks, rate-limits or acts on its alerts until a person promotes it. Instant rule: executionMode "instant" plus instant {matchMode: any|all, conditions: [{field: path|method|user_agent|status_code|request_body|request_headers|client_ip|host, operator, value}]}. Periodic rule: sqlQuery plus schedule {cronExpression}; the SQL must scope every table with the __USER_APP_KEYS__ placeholder, bound time on every table read, and return a column named ip (the API refuses SQL with no ip column, since it would never alert, unless allowNoIp). A periodic rule runs once right away (firstRunQueued); see securenow_alert_rule_runs. Easiest path: securenow_alert_rule_draft, then pass its draft fields here. Write action; requires confirmation.',
     scope: 'alerts:write',
     readOnly: false,
     confirm: true,
     method: 'POST',
     endpoint: '/alert-rules',
-    bodyFields: ['name', 'description', 'nlpQuery', 'category', 'severity', 'applications', 'applicationsAll', 'executionMode', 'sqlQuery', 'schedule', 'instant', 'throttle'],
+    bodyFields: ['name', 'description', 'nlpQuery', 'category', 'severity', 'applications', 'applicationsAll', 'executionMode', 'sqlQuery', 'schedule', 'instant', 'throttle', 'allowNoIp'],
     inputSchema: objectSchema({
       name: string('Rule name.'),
       description: string('What it catches, in a sentence.'),
@@ -1438,7 +1458,8 @@ const TOOLS = [
       sqlQuery: string('Periodic rules: the detection SELECT.'),
       schedule: { type: 'object', additionalProperties: true, description: 'Periodic rules: {cronExpression: "* * * * *", description: "Every minute"}. Default every 15 minutes.' },
       instant: { type: 'object', additionalProperties: true, description: 'Instant rules: {matchMode: "any" | "all", conditions: [{field, operator, value}], environments: ["staging"] (optional; omit to watch every environment)}.' },
-      throttle: { type: 'object', additionalProperties: true, description: 'Optional {enabled: true, minutes: 15}: one alert per rule per window.' },
+      throttle: { type: 'object', additionalProperties: true, description: 'Optional {enabled: true, minutes: 15}: one alert per address every N minutes (other addresses still alert).' },
+      allowNoIp: boolean('Periodic rules: save SQL that returns no ip column anyway (it will never notify). Default false.'),
       ...confirmSchema,
     }, ['name', 'confirm', 'reason']),
   },
@@ -1520,25 +1541,28 @@ const TOOLS = [
   {
     name: 'securenow_alert_rule_update',
     title: 'Update Alert Rule',
-    description: 'Update alert rule scope/status/schedule/throttle or record a review action. Write action; requires confirmation.',
+    description: 'Update alert rule scope/status/severity/schedule/throttle, a custom rule\'s SQL (sqlQuery, checked like create: scoped, time-bounded, with an ip column) or instant conditions (instant: {matchMode, conditions, environments}; omitted fields such as the instant block stay as they are), or record a review action. reviewNote is kept as the version\'s reason. Write action; requires confirmation.',
     scope: 'alerts:write',
     readOnly: false,
     confirm: true,
     method: 'PUT',
     endpoint: '/alert-rules/:id',
     pathParams: ['id'],
-    bodyFields: ['name', 'description', 'status', 'applicationsAll', 'applications', 'schedule', 'throttle', 'alertChannelIds', 'reviewAction', 'reviewNote', 'reviewNotificationId'],
+    bodyFields: ['name', 'description', 'severity', 'status', 'applicationsAll', 'applications', 'schedule', 'throttle', 'sqlQuery', 'instant', 'alertChannelIds', 'reviewAction', 'reviewNote', 'reviewNotificationId'],
     inputSchema: objectSchema({
       id: string('Alert rule id.'),
       name: string('Rule name for custom rules.'),
       description: string('Rule description for custom rules.'),
+      severity: string('critical, high, medium or low (custom rules).'),
       status: string('Active, Disabled, or Paused.'),
       applicationsAll: boolean('Scope rule to all applications.'),
       applications: arrayOfStrings('Application keys when applicationsAll is false.'),
       schedule: { type: 'object', additionalProperties: true, description: 'Schedule patch.' },
-      throttle: { type: 'object', additionalProperties: true, description: 'Throttle patch.' },
+      throttle: { type: 'object', additionalProperties: true, description: 'Throttle patch {enabled, minutes}: one alert per address every N minutes.' },
+      sqlQuery: string('Custom periodic rules: the replacement detection SELECT (e.g. from a securenow_alert_rule_draft with ruleId).'),
+      instant: { type: 'object', additionalProperties: true, description: 'Custom instant rules: {matchMode, conditions: [{field, operator, value}], environments}. Fields left out keep their current values.' },
       alertChannelIds: arrayOfStrings('Alert channel ids.'),
-      reviewAction: string('Rule review action, e.g. keep_active or saved_new_version.'),
+      reviewAction: string('Rule review action: keep_active (keep it running and stop auto-pausing it) or tuned_version (the rule was tuned; resume it).'),
       reviewNote: string('Review note.'),
       reviewNotificationId: string('Notification id tied to this review.'),
       ...confirmSchema,
@@ -1832,7 +1856,7 @@ const TOOLS = [
   {
     name: 'securenow_alert_rule_test',
     title: 'Test Alert Rule',
-    description: 'Start an alert rule test. Pass mode "dry_run" for a read-only query run; "live" (the server default when mode is omitted) inserts synthetic spans into the app\'s telemetry.',
+    description: 'Start an alert rule test. By default (mode "dry_run") it runs the rule\'s query once on the app\'s real data and inserts nothing. Mode "live" first inserts 6 synthetic attack requests into the app\'s telemetry; only ask for it explicitly.',
     scope: 'alerts:write',
     readOnly: false,
     confirm: true,
@@ -1843,7 +1867,7 @@ const TOOLS = [
     inputSchema: objectSchema({
       id: string('Alert rule id.'),
       applicationKey: string('Application key to test.'),
-      mode: string('dry_run (read-only, recommended) or live (inserts synthetic spans).'),
+      mode: string('dry_run (default, read-only) or live (inserts 6 synthetic attack requests).'),
       ...confirmSchema,
     }, ['id', 'confirm', 'reason']),
   },
@@ -1880,6 +1904,84 @@ const TOOLS = [
       testId: string('Alert rule test id.'),
     }, ['id', 'testId']),
   },
+  {
+    name: 'securenow_alert_rule_runs',
+    title: 'List Alert Rule Runs',
+    description: 'A rule\'s recent runs, newest first: when it ran (schedule, manual, create or instant trigger), what it returned (rows, addresses), and the outcome: notified, no_rows, throttled (address alerted on within the throttle window), suppressed_blocked (already blocked), suppressed_trusted, no_ip (rows without an address), storm, auto_resolved (dismissed by an exclusion, trusted IP or verified bot), skipped or error. suppressedIps says which addresses were left out and why. Also nextRunAt for periodic rules. Quiet runs are kept 2 days, the rest 14.',
+    scope: 'alerts:read',
+    readOnly: true,
+    method: 'GET',
+    endpoint: '/alert-rules/:id/runs',
+    pathParams: ['id'],
+    queryFields: ['limit', 'since'],
+    inputSchema: objectSchema({
+      id: string('Alert rule id.'),
+      limit: number('How many runs (default 50, max 200).', { minimum: 1, maximum: 200 }),
+      since: string('Only runs since then: 30m, 1h, 2d or an ISO date.'),
+    }, ['id']),
+  },
+  {
+    name: 'securenow_alert_rule_run_now',
+    title: 'Run Alert Rule Now',
+    description: 'Run a periodic (scheduled) rule once now, outside its schedule. It can notify like a scheduled run (test-mode rules alert only). The run appears in securenow_alert_rule_runs within seconds with trigger "manual". Instant rules have nothing to run (they check every request); use securenow_alert_rule_explain instead. Write action; requires confirmation.',
+    scope: 'alerts:write',
+    readOnly: false,
+    confirm: true,
+    method: 'POST',
+    endpoint: '/alert-rules/:id/run',
+    pathParams: ['id'],
+    inputSchema: objectSchema({
+      id: string('Alert rule id (an active periodic rule).'),
+      ...confirmSchema,
+    }, ['id', 'confirm', 'reason']),
+  },
+  {
+    name: 'securenow_alert_rule_explain',
+    title: 'Explain Why a Rule Did or Didn\'t Alert',
+    description: 'Why did (or didn\'t) this rule alert on this address? Checks, in a time window: the rule\'s status, mode, apps and environments; its runs and what each did with the address (notified, throttled, already blocked, trusted, dismissed); the per-address throttle; blocks on the address and the rule that made them; trusted and allowlist entries; notifications; and the address\'s requests, replayed through an instant rule\'s conditions. Returns ordered findings and a one-line verdict, e.g. "Detected at 15:06:31 but not notified: 203.0.113.50 was already blocked by instant rule X".',
+    scope: 'alerts:read',
+    readOnly: true,
+    method: 'GET',
+    endpoint: '/alert-rules/:id/explain',
+    pathParams: ['id'],
+    queryFields: ['ip', 'since'],
+    inputSchema: objectSchema({
+      id: string('Alert rule id.'),
+      ip: string('The address to explain (IPv4 or IPv6).'),
+      since: string('Window start: 30m, 1h (default), 2d or an ISO date; at most 7 days.'),
+    }, ['id', 'ip']),
+  },
+  {
+    name: 'securenow_alert_rule_request_promotion',
+    title: 'Ask a Person to Promote an Alert Rule',
+    description: 'Ask a person to promote a test-mode rule to prod, with why it is ready and the evidence (runs, notifications it caught, false-positive checks). Agents create rules in test mode and cannot approve this themselves: a person approves on the rules page or with `securenow human approve-promotion`, which moves the rule to prod (its instant block, matching automations and the AI pipeline can then act on its alerts). One pending request per rule. Write action; requires confirmation.',
+    scope: 'alerts:write',
+    readOnly: false,
+    confirm: true,
+    method: 'POST',
+    endpoint: '/alert-rules/:id/promotion-requests',
+    pathParams: ['id'],
+    bodyFields: ['reason', 'evidence'],
+    inputSchema: objectSchema({
+      id: string('Alert rule id (a custom rule in test mode).'),
+      evidence: string('What shows it is ready: e.g. runs and their outcomes, notifications it raised on real attacks, how many false positives in how long.'),
+      ...confirmSchema,
+    }, ['id', 'confirm', 'reason']),
+  },
+  {
+    name: 'securenow_alert_rule_promotion_requests',
+    title: 'List Alert Rule Promotion Requests',
+    description: 'Requests to promote test-mode rules to prod and their status (pending, approved, denied), who asked and why, and who decided.',
+    scope: 'alerts:read',
+    readOnly: true,
+    method: 'GET',
+    endpoint: '/alert-rules/promotion-requests',
+    queryFields: ['status', 'limit'],
+    inputSchema: objectSchema({
+      status: string('pending (default), approved, denied or all.'),
+      limit: number('How many (default 50, max 100).', { minimum: 1, maximum: 100 }),
+    }),
+  },
   {
     name: 'securenow_alert_rule_exclusions_list',
     title: 'List Alert Rule Exclusions',
@@ -2656,8 +2758,40 @@ function mcpToolDefinition(tool) {
   };
 }
 
-function listTools() {
-  return TOOLS.map(mcpToolDefinition);
+// Tool profiles: a smaller tool list for an agent that does one job (fewer tools, less context).
+// Every profile keeps the auth and app tools. `securenow mcp --profile <name>` (or
+// SECURENOW_MCP_PROFILE) picks one; the default is every tool.
+const PROFILE_BASE_TOOLS = new Set(['securenow_auth_status', 'securenow_apps_list', 'securenow_apps_info']);
+const TOOL_PROFILES = {
+  investigator: {
+    description: 'Read-only investigation: notifications, traces, logs, IP intelligence, forensics questions and chat, rule run history and "why didn\'t this alert".',
+    includes: (tool) => tool.readOnly || /^securenow_forensics_(query|chat|chat_confirm)$/.test(tool.name),
+  },
+  detection: {
+    description: 'Write and tune detections: draft, create, test, run and explain alert rules, with the traces, logs, notifications and forensics to check them against.',
+    includes: (tool) => /^securenow_alert_rules?_/.test(tool.name)
+      || /^securenow_(traces|logs|forensics|ip)_/.test(tool.name)
+      || /^securenow_notifications_(list|get|batch_get)$/.test(tool.name),
+  },
+  responder: {
+    description: 'Respond to alerts: notifications, the human action queue and alert reviews, blocks, allowlist, trusted IPs, rate limits, challenges, automations, firewall and IP intelligence.',
+    includes: (tool) => /^securenow_(notifications|human|alert_review|blocklist|allowlist|trusted|rate_limit|challenge|automation|ip|firewall)_/.test(tool.name)
+      || ['securenow_alert_rule_get', 'securenow_alert_rule_runs', 'securenow_alert_rule_explain', 'securenow_traces_list', 'securenow_traces_show', 'securenow_logs_for_trace'].includes(tool.name),
+  },
+};
+
+function toolsForProfile(profile) {
+  const name = String(profile || 'all').trim().toLowerCase();
+  if (name === 'all') return TOOLS;
+  const selected = TOOL_PROFILES[name];
+  if (!selected) {
+    throw new Error(`Unknown MCP profile "${profile}". Use one of: all, ${Object.keys(TOOL_PROFILES).join(', ')}`);
+  }
+  return TOOLS.filter((tool) => PROFILE_BASE_TOOLS.has(tool.name) || selected.includes(tool));
+}
+
+function listTools(profile) {
+  return toolsForProfile(profile).map(mcpToolDefinition);
 }
 
 function listResources() {
@@ -2897,7 +3031,29 @@ function summarizeRateLimit(r) {
   return { ...r, metadata: undefined, effectiveStatus: r.status === 'active' && expired ? 'expired' : r.status };
 }
 
+// One trace's spans repeat the same resource fields (service, environment, SDK...) on every span:
+// keep those once under `shared` and drop empty fields, so a trace costs far less context.
+function compactSpans(res) {
+  if (!Array.isArray(res?.spans) || res.spans.length < 2) return res;
+  const spans = res.spans;
+  const isEmpty = (v) => v == null || v === '' || (typeof v === 'object' && !Array.isArray(v) && Object.keys(v).length === 0)
+    || (Array.isArray(v) && v.length === 0);
+  const shared = {};
+  for (const key of new Set(spans.flatMap((span) => Object.keys(span || {})))) {
+    const first = JSON.stringify(spans[0]?.[key]);
+    if (spans.every((span) => JSON.stringify(span?.[key]) === first)) shared[key] = spans[0]?.[key];
+  }
+  const keep = (span) => Object.fromEntries(Object.entries(span || {}).filter(([key, value]) => !(key in shared) && !isEmpty(value)));
+  return {
+    ...res,
+    _compact: 'Fields identical on every span are listed once under shared; empty fields are left out.',
+    shared: Object.fromEntries(Object.entries(shared).filter(([, value]) => !isEmpty(value))),
+    spans: spans.map(keep),
+  };
+}
+
 const SUMMARIZERS = {
+  securenow_traces_show: compactSpans,
   securenow_notifications_list: (res) => (Array.isArray(res?.notifications) ? { ...res, notifications: res.notifications.map(summarizeNotification) } : res),
   securenow_alert_rules_list: (res) => {
     if (!Array.isArray(res?.alertRules)) return res;
@@ -2952,6 +3108,8 @@ module.exports = {
   getTool,
   mcpToolDefinition,
   listTools,
+  toolsForProfile,
+  TOOL_PROFILES,
   listResources,
   listPrompts,
   promptMessages,

package/mcp/server.js

@@ -9,6 +9,7 @@ const {
   RESOURCES,
   getTool,
   listTools,
+  toolsForProfile,
   listResources,
   listPrompts,
   promptMessages,
@@ -26,6 +27,17 @@ const {
 const SERVER_NAME = 'securenow';
 const PROTOCOL_VERSION = '2025-06-18';
 
+// `securenow mcp --profile investigator|detection|responder` (or SECURENOW_MCP_PROFILE) serves a
+// subset of the tools; the default is every tool.
+const PROFILE = String(process.env.SECURENOW_MCP_PROFILE || 'all').trim().toLowerCase() || 'all';
+let PROFILE_TOOL_NAMES;
+try {
+  PROFILE_TOOL_NAMES = new Set(toolsForProfile(PROFILE).map((tool) => tool.name));
+} catch (err) {
+  process.stderr.write(`[securenow mcp] ${err.message}\n`);
+  process.exit(2);
+}
+
 function write(message) {
   process.stdout.write(`${JSON.stringify(message)}\n`);
 }
@@ -201,7 +213,7 @@ function readResource(uri) {
 
   const text = resourceContent(resource, {
     projectConfig: () => jsonText(localAuthStatus()),
-    toolsCatalog: () => jsonText(listTools().map((tool) => ({
+    toolsCatalog: () => jsonText(listTools(PROFILE).map((tool) => ({
       name: tool.name,
       description: tool.description,
       readOnly: tool.annotations?.readOnlyHint === true,
@@ -240,7 +252,7 @@ async function handleRequest(message) {
     }
 
     if (method === 'ping') return ok(id, {});
-    if (method === 'tools/list') return ok(id, { tools: listTools() });
+    if (method === 'tools/list') return ok(id, { tools: listTools(PROFILE) });
     if (method === 'resources/list') return ok(id, { resources: listResources() });
     if (method === 'prompts/list') return ok(id, { prompts: listPrompts() });
 
@@ -262,6 +274,9 @@ async function handleRequest(message) {
       const args = params.arguments || {};
       const tool = getTool(name);
       if (!tool) throw new Error(`Unknown tool: ${name}`);
+      if (!PROFILE_TOOL_NAMES.has(name)) {
+        throw new Error(`Tool ${name} is not in the "${PROFILE}" MCP profile. Restart the server without --profile (or with another profile) to use it.`);
+      }
 
       const result = await callApiTool(tool, args);
       return ok(id, asToolResult({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "securenow",
-  "version": "8.16.0",
+  "version": "8.18.0",
   "mcpName": "ai.securenow/securenow",
   "description": "OpenTelemetry instrumentation for Node.js, Next.js, and Nuxt - Send traces and logs to any OTLP-compatible backend",
   "type": "commonjs",
@@ -11,7 +11,7 @@
     "securenow-mcp": "mcp/server.js"
   },
   "scripts": {
-    "test": "node test-app-config.js && node test-resolve-ip.js && node test-otel-defaults.js && node test-telemetry.js && node test-legacy-semconv.js && node test-otp-redaction.js && node test-header-redaction.js && node test-firewall-paths.js && node test-rate-limits.js && node test-rate-limit-redis.js && node test-log-format.js && node test-crash-capture.js && node test-sdk-disabled.js && node test-internal-thread.js && node test-package-contents.js"
+    "test": "node test-app-config.js && node test-resolve-ip.js && node test-otel-defaults.js && node test-telemetry.js && node test-legacy-semconv.js && node test-otp-redaction.js && node test-header-redaction.js && node test-firewall-paths.js && node test-rate-limits.js && node test-rate-limit-redis.js && node test-log-format.js && node test-crash-capture.js && node test-sdk-disabled.js && node test-internal-thread.js && node test-esm-detect.js && node test-package-contents.js"
   },
   "keywords": [
     "opentelemetry",
@@ -160,6 +160,7 @@
     "challenge.js",
     "otel-defaults.js",
     "internal-thread.js",
+    "esm-detect.js",
     "legacy-semconv.js",
     "otp-redaction.js",
     "header-redaction.js",

package/register.js

@@ -14,13 +14,9 @@ if (require('./sdk-disabled').sdkDisabled('register')) return;
 // 1. Auto-register the ESM loader hook so customers never need --import
 (() => {
   try {
-    const fs = require('fs');
-    const path = require('path');
-    const pkgPath = path.resolve(process.cwd(), 'package.json');
-    if (!fs.existsSync(pkgPath)) return;
-
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8').replace(/^\uFEFF/, ''));
-    if (pkg.type !== 'module') return;
+    // ESM is decided by the entry script's package.json, not only the working directory's
+    // (process managers often start apps from another directory). See esm-detect.js.
+    if (!require('./esm-detect').detectEsmApp().esm) return;
 
     // Already registered via --import?
     const execArgv = process.execArgv.join(' ');

package/tracing.js

@@ -338,19 +338,13 @@ function collectMultipartMeta(request, contentType, sensitiveFields, maxTextFiel
 // (e.g. Node 18, or require('securenow/tracing') called directly without register.js).
 (() => {
   try {
-    const fs = require('fs');
-    const path = require('path');
-    const pkgPath = path.resolve(process.cwd(), 'package.json');
-    if (fs.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-      if (pkg.type === 'module') {
-        const execArgv = process.execArgv.join(' ');
-        const hasCliHook = execArgv.includes('hook.mjs') || execArgv.includes('import-in-the-middle');
-        const hasModuleRegister = typeof require('node:module').register === 'function';
-        if (!hasCliHook && !hasModuleRegister) {
-          console.warn('[securenow] ⚠️  ESM app detected ("type": "module") but no ESM loader hook available.');
-          console.warn('[securenow]    Upgrade to Node >=20.6 (recommended) or add: --import @opentelemetry/instrumentation/hook.mjs');
-        }
+    if (require('./esm-detect').detectEsmApp().esm) {
+      const execArgv = process.execArgv.join(' ');
+      const hasCliHook = execArgv.includes('hook.mjs') || execArgv.includes('import-in-the-middle');
+      const hasModuleRegister = typeof require('node:module').register === 'function';
+      if (!hasCliHook && !hasModuleRegister) {
+        console.warn('[securenow] ⚠️  ESM app detected ("type": "module") but no ESM loader hook available.');
+        console.warn('[securenow]    Upgrade to Node >=20.6 (recommended) or add: --import @opentelemetry/instrumentation/hook.mjs');
       }
     }
   } catch (_) {}