@agentistics/mcp 2.77.0 → 2.78.0

package/dist/agentistics-mcp.js

@@ -171,6 +171,51 @@ var DEFAULT_TEAM = Object.freeze({
   connections: Object.freeze([])
 });
 var SHARE_SOURCE_TYPES = new Set(["repo", "project", "none"]);
+// ../core/src/redact.ts
+var REDACTION = "[REDACTED]";
+var PLACEHOLDER = /^(\*+|x+|\.+|-+|<[^>]*>|\{[^}]*\}|\$\{?[A-Z_][A-Z0-9_]*\}?|your[-_]?\w*|todo|changeme|none|null|nil|empty|redacted|\[redacted\])$/i;
+function looksSecret(value) {
+  const v = value.trim().replace(/^["']|["']$/g, "");
+  if (v.length < 12)
+    return false;
+  if (PLACEHOLDER.test(v))
+    return false;
+  if (/^\d+$/.test(v))
+    return false;
+  if (/\s/.test(v))
+    return false;
+  const classes = [/[a-z]/.test(v), /[A-Z]/.test(v), /\d/.test(v), /[^A-Za-z0-9]/.test(v)].filter(Boolean).length;
+  return classes >= 2;
+}
+function guarded(whole, prefix, value) {
+  return looksSecret(value) ? `${prefix}${REDACTION}` : whole;
+}
+var STRONG = [
+  /-----BEGIN[^-]*PRIVATE KEY-----[\s\S]*?-----END[^-]*PRIVATE KEY-----/g,
+  /\bgithub_pat_[A-Za-z0-9_]{20,}/g,
+  /\bgh[pousr]_[A-Za-z0-9]{20,}/g,
+  /\bsk-ant-[A-Za-z0-9\-_]{16,}/g,
+  /\bsk-(?:proj-)?[A-Za-z0-9\-_]{20,}/g,
+  /\bxox[baprs]-[A-Za-z0-9-]{10,}/g,
+  /\bAIza[A-Za-z0-9\-_]{35}/g,
+  /\bAKIA[0-9A-Z]{16}\b/g,
+  /\beyJ[A-Za-z0-9\-_]{8,}\.eyJ[A-Za-z0-9\-_]{8,}\.[A-Za-z0-9\-_]{8,}/g,
+  /\bact1_[A-Za-z0-9\-_]+\.[A-Za-z0-9]{16,}/g
+];
+var URI_CREDENTIAL = /\b([a-z][a-z0-9+.\-]*:\/\/[^\s:/@"']+:)([^\s@"']+)@/gi;
+var ASSIGNMENT = /(^|[^A-Za-z0-9_])((?:[A-Za-z0-9]+[_-])*(?:pass(?:word|wd)?|pwd|secret|token|auth|credentials?|api[_-]?key|access[_-]?key|private[_-]?key)[a-z0-9_-]*\s*[:=]\s*)(["']?[^\s"',;]+["']?)/gi;
+var BEARER = /\b(Bearer\s+)([A-Za-z0-9\-._~+/]{12,}=*)/g;
+function redactSecrets(text) {
+  if (typeof text !== "string" || text === "")
+    return "";
+  let out = text;
+  for (const re of STRONG)
+    out = out.replace(re, REDACTION);
+  out = out.replace(URI_CREDENTIAL, (whole, prefix, pw) => PLACEHOLDER.test(pw) ? whole : `${prefix}${REDACTION}@`);
+  out = out.replace(ASSIGNMENT, (whole, lead, prefix, value) => guarded(whole, `${lead}${prefix}`, value));
+  out = out.replace(BEARER, (whole, prefix, value) => guarded(whole, prefix, value));
+  return out;
+}
 // ../core/src/plan-catalog.ts
 var CLAUDE_PRICING = "https://claude.com/pricing";
 var COPILOT_PRICING = "https://github.com/features/copilot/plans";
@@ -815,6 +860,224 @@ function harnessParam() {
   };
 }
 
+// agent-audit.ts
+import { createHash } from "node:crypto";
+import * as nodeFs from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+var AUDIT_ROTATE_BYTES = 10 * 1024 * 1024;
+var AUDIT_KEEP_FILES = 3;
+function defaultAuditPath(env = process.env) {
+  return join(env.AGENTISTICS_DIR ?? join(homedir(), ".agentistics"), "agent-audit.jsonl");
+}
+var TARGET_KEYS = [
+  "ref",
+  "id",
+  "taskId",
+  "subtaskId",
+  "sessionId",
+  "session",
+  "sessions",
+  "group",
+  "parentGroupId",
+  "blockedBy",
+  "componentId",
+  "instanceId",
+  "tag",
+  "remove"
+];
+var ID_SHAPE = /^[A-Za-z0-9][A-Za-z0-9_.:@-]{0,79}$/;
+var MAX_TARGETS = 20;
+function asId(v) {
+  if (typeof v !== "string" || !ID_SHAPE.test(v))
+    return null;
+  return redactSecrets(v) === v ? v : null;
+}
+function targetsOf(args) {
+  const out = [];
+  let omitted = 0;
+  if (!args || typeof args !== "object")
+    return { targets: out, omitted };
+  const a = args;
+  for (const key of TARGET_KEYS) {
+    const raw = a[key];
+    if (raw === undefined || raw === null || typeof raw === "boolean")
+      continue;
+    for (const v of Array.isArray(raw) ? raw : [raw]) {
+      const id = asId(v);
+      if (id === null) {
+        omitted++;
+        continue;
+      }
+      if (out.length >= MAX_TARGETS) {
+        omitted++;
+        continue;
+      }
+      if (!out.includes(id))
+        out.push(id);
+    }
+  }
+  return { targets: out, omitted };
+}
+function canonical(v) {
+  if (Array.isArray(v))
+    return `[${v.map(canonical).join(",")}]`;
+  if (v && typeof v === "object") {
+    const o = v;
+    return `{${Object.keys(o).sort().map((k) => `${JSON.stringify(k)}:${canonical(o[k])}`).join(",")}}`;
+  }
+  return JSON.stringify(v ?? null);
+}
+function argsHash(args) {
+  return createHash("sha256").update(canonical(args ?? {})).digest("hex").slice(0, 16);
+}
+function label(v) {
+  if (typeof v !== "string")
+    return;
+  const t = v.trim().slice(0, 64);
+  if (!/^[\w.:@/ -]{1,64}$/.test(t))
+    return;
+  return redactSecrets(t) === t ? t : undefined;
+}
+function actorOf(client, args, naySession) {
+  const a = args && typeof args === "object" ? args : {};
+  const declared = label(a.actor) ?? label(a.by);
+  const nay = naySession !== undefined ? asId(naySession) ?? undefined : undefined;
+  return {
+    client: label(client?.name) ?? null,
+    clientVersion: label(client?.version) ?? null,
+    ...declared !== undefined ? { declared } : {},
+    ...nay !== undefined ? { naySession: nay } : {}
+  };
+}
+function outcomeOf(result) {
+  if (result === "unknown_tool")
+    return "unknown_tool";
+  if (!result.isError)
+    return "ok";
+  const m = /→ HTTP (\d{3})\b/.exec(result.errorText ?? "");
+  return m ? `http_${Number(m[1])}` : "error";
+}
+function isKnownTool(name) {
+  return Object.prototype.hasOwnProperty.call(AGENT_TOOL_POLICY, name);
+}
+function riskOf(name) {
+  return isKnownTool(name) ? AGENT_TOOL_POLICY[name].risk : null;
+}
+function buildToolAuditRecord(input) {
+  const known = isKnownTool(input.name);
+  const { targets, omitted } = targetsOf(input.args);
+  return {
+    v: 1,
+    kind: "tool",
+    at: input.at.toISOString(),
+    actor: actorOf(input.client, input.args, input.naySession),
+    tool: known ? input.name : null,
+    risk: riskOf(input.name),
+    targets,
+    ...omitted > 0 ? { targetsOmitted: omitted } : {},
+    argsHash: argsHash(input.args),
+    outcome: known ? outcomeOf(input.result) : "unknown_tool"
+  };
+}
+function hourOf(at) {
+  return at.toISOString().slice(0, 13);
+}
+function readCountRecord(hour, counts) {
+  return { v: 1, kind: "reads", hour, counts: { ...counts } };
+}
+function rotatedPath(path, n) {
+  return n === 0 ? path : `${path}.${n}`;
+}
+function createAgentAuditSink(opts = {}) {
+  const path = opts.path ?? defaultAuditPath();
+  const maxBytes = opts.maxBytes ?? AUDIT_ROTATE_BYTES;
+  const keep = Math.max(1, opts.keep ?? AUDIT_KEEP_FILES);
+  const fs = opts.fs ?? nodeFs;
+  const now = opts.now ?? (() => new Date);
+  let written = 0;
+  let writeFailures = 0;
+  let pendingDropped = 0;
+  let modeChecked = false;
+  let readHour = null;
+  let readCounts = {};
+  function sizeOf(p) {
+    try {
+      return fs.statSync(p).size;
+    } catch {
+      return 0;
+    }
+  }
+  function rotate() {
+    fs.rmSync(rotatedPath(path, keep - 1), { force: true });
+    for (let n = keep - 2;n >= 0; n--) {
+      const from = rotatedPath(path, n);
+      try {
+        fs.renameSync(from, rotatedPath(path, n + 1));
+      } catch (e) {
+        if (e?.code !== "ENOENT")
+          throw e;
+      }
+    }
+    modeChecked = false;
+  }
+  function write(rec) {
+    try {
+      const line = `${JSON.stringify(pendingDropped > 0 ? { ...rec, dropped: pendingDropped } : rec)}
+`;
+      if (!modeChecked)
+        fs.mkdirSync(dirname(path), { recursive: true, mode: 448 });
+      if (keep > 1 && sizeOf(path) + Buffer.byteLength(line) > maxBytes && sizeOf(path) > 0)
+        rotate();
+      else if (keep === 1 && sizeOf(path) + Buffer.byteLength(line) > maxBytes)
+        fs.rmSync(path, { force: true });
+      fs.appendFileSync(path, line, { mode: 384 });
+      if (!modeChecked) {
+        fs.chmodSync(path, 384);
+        modeChecked = true;
+      }
+      written++;
+      pendingDropped = 0;
+    } catch {
+      writeFailures++;
+      pendingDropped++;
+    }
+  }
+  function flushReads() {
+    if (readHour === null || Object.keys(readCounts).length === 0)
+      return;
+    const rec = readCountRecord(readHour, readCounts);
+    readHour = null;
+    readCounts = {};
+    write(rec);
+  }
+  return {
+    recordCall(input) {
+      try {
+        const at = now();
+        const hour = hourOf(at);
+        if (readHour !== null && readHour !== hour)
+          flushReads();
+        if (riskOf(input.name) === "R") {
+          readHour = hour;
+          readCounts[input.name] = (readCounts[input.name] ?? 0) + 1;
+          return;
+        }
+        write(buildToolAuditRecord({ ...input, at }));
+      } catch {
+        writeFailures++;
+        pendingDropped++;
+      }
+    },
+    flush() {
+      flushReads();
+    },
+    stats() {
+      return { written, writeFailures, pendingDropped };
+    }
+  };
+}
+
 // agentistics-mcp.ts
 var API = process.env.AGENTISTICS_API ?? "http://localhost:47291";
 var HARNESS_PARAM = harnessParam();
@@ -1385,7 +1648,30 @@ var TOOLS = [
   }
 ];
 server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
+var audit = createAgentAuditSink();
+process.on("exit", () => audit.flush());
+for (const sig of ["SIGINT", "SIGTERM"]) {
+  process.on(sig, () => {
+    audit.flush();
+    process.exit(0);
+  });
+}
 server.setRequestHandler(CallToolRequestSchema, async (req) => {
+  const result = await callTool(req);
+  const first = result.content?.[0];
+  audit.recordCall({
+    name: req.params.name,
+    args: req.params.arguments,
+    client: server.getClientVersion(),
+    naySession: process.env.AGENTISTICS_NAY_SESSION,
+    result: {
+      isError: result.isError === true,
+      errorText: first && first.type === "text" ? first.text : undefined
+    }
+  });
+  return result;
+});
+async function callTool(req) {
   const { name, arguments: args } = req.params;
   try {
     switch (name) {
@@ -2064,6 +2350,6 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
       isError: true
     };
   }
-});
+}
 var transport = new StdioServerTransport;
 await server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentistics/mcp",
-  "version": "2.77.0",
+  "version": "2.78.0",
   "description": "Agentistics MCP server — Claude Code analytics for Claude Desktop and Claude Code",
   "type": "module",
   "main": "./dist/agentistics-mcp.js",