@i4ctime/q-ring 0.17.0 → 0.17.6

package/dist/{chunk-KFILBHOY.js → chunk-VMDD5QTJ.js}

@@ -1502,10 +1502,23 @@ var secretsPolicySchema = z2.object({
   requireRotationFormatForTags: stringArray.optional(),
   maxTtlSeconds: z2.number().optional()
 }).strict();
+var rateLimitSchema = z2.object({
+  maxCalls: z2.number().int().positive(),
+  perSeconds: z2.number().positive()
+}).strict();
+var wrapPolicySchema = z2.object({
+  allowTools: stringArray.optional(),
+  denyTools: stringArray.optional(),
+  approveTools: stringArray.optional(),
+  rateLimit: rateLimitSchema.optional(),
+  toolRateLimits: z2.record(z2.string(), rateLimitSchema).optional(),
+  redactResults: z2.boolean().optional()
+}).strict();
 var policySchema = z2.object({
   mcp: mcpPolicySchema.optional(),
   exec: execPolicySchema.optional(),
-  secrets: secretsPolicySchema.optional()
+  secrets: secretsPolicySchema.optional(),
+  wrap: wrapPolicySchema.optional()
 }).strict();
 var PolicyConfigError = class extends Error {
   constructor(message) {
@@ -1681,6 +1694,7 @@ function getPolicySummary(projectPath) {
     hasMcpPolicy: !!policy.mcp,
     hasExecPolicy: !!policy.exec,
     hasSecretPolicy: !!policy.secrets,
+    hasWrapPolicy: !!policy.wrap,
     details: policy
   };
 }
@@ -1785,6 +1799,129 @@ function notifyApprovalRequested(key, source) {
   );
 }
 
+// src/core/canary-webhooks.ts
+import { existsSync as existsSync7, writeFileSync as writeFileSync6, mkdirSync as mkdirSync7 } from "fs";
+import { join as join10 } from "path";
+import { homedir as homedir7 } from "os";
+import { randomUUID as randomUUID2 } from "crypto";
+function getRegistryPath4() {
+  const override = process.env.QRING_CANARY_ALERTS_PATH;
+  if (override) return override;
+  const dir = join10(homedir7(), ".config", "q-ring");
+  if (!existsSync7(dir)) mkdirSync7(dir, { recursive: true, mode: 448 });
+  return join10(dir, "canary-alerts.json");
+}
+function loadRegistry4() {
+  return loadJsonRegistry(getRegistryPath4(), { channels: [] });
+}
+function listCanaryAlerts() {
+  return loadRegistry4().channels;
+}
+function describeAlertUrl(url) {
+  try {
+    const u = new URL(url);
+    const tail = u.pathname.length > 12 ? `${u.pathname.slice(0, 8)}\u2026${u.pathname.slice(-4)}` : u.pathname;
+    return `${u.protocol}//${u.host}${tail}`;
+  } catch {
+    return url;
+  }
+}
+function headline(event) {
+  return event.test ? "q-ring canary alert test" : "q-ring: CANARY TRIPPED";
+}
+function summary(event) {
+  const who = event.agent ? `${event.source} (${event.agent})` : event.source;
+  const where = event.env ? `${event.scope}/${event.env}` : event.scope;
+  return event.test ? `This is a test from \`qring canary alert test\`. Trips on honeytoken "${event.key}" (${where}) would arrive here.` : `Honeytoken "${event.key}" (${where}) was read by ${who} at ${event.timestamp}. ${event.detail}. This credential is fake \u2014 but something reached for it. Investigate: qring audit --action canary`;
+}
+function buildAlertPayload(type, event) {
+  const json = { "Content-Type": "application/json", "User-Agent": "q-ring-canary/1.0" };
+  switch (type) {
+    case "discord":
+      return {
+        body: JSON.stringify({ content: `\u{1F6A8} **${headline(event)}**
+${summary(event)}` }),
+        headers: json
+      };
+    case "slack":
+      return {
+        body: JSON.stringify({ text: `:rotating_light: *${headline(event)}*
+${summary(event)}` }),
+        headers: json
+      };
+    case "ntfy":
+      return {
+        body: summary(event),
+        headers: {
+          "Content-Type": "text/plain",
+          "User-Agent": "q-ring-canary/1.0",
+          Title: headline(event),
+          Priority: event.test ? "3" : "5",
+          Tags: event.test ? "test_tube" : "rotating_light"
+        }
+      };
+    case "generic":
+      return {
+        body: JSON.stringify({
+          event: "canary",
+          test: event.test ?? false,
+          key: event.key,
+          scope: event.scope,
+          env: event.env,
+          source: event.source,
+          agent: event.agent ?? void 0,
+          detail: event.detail,
+          timestamp: event.timestamp
+        }),
+        headers: json
+      };
+  }
+}
+async function sendOne(channel, event) {
+  const base = { channelId: channel.id, type: channel.type };
+  const ssrfBlock = await checkSSRF(channel.url);
+  if (ssrfBlock) {
+    logAudit({
+      action: "policy_deny",
+      key: event.key,
+      scope: event.scope,
+      source: "hook",
+      detail: `canary alert SSRF blocked: ${describeAlertUrl(channel.url)}`
+    });
+    return { ...base, success: false, message: ssrfBlock };
+  }
+  try {
+    const { body, headers } = buildAlertPayload(channel.type, event);
+    const res = await httpRequest({
+      url: channel.url,
+      method: "POST",
+      headers,
+      body,
+      timeoutMs: 1e4
+    });
+    return {
+      ...base,
+      success: res.statusCode >= 200 && res.statusCode < 300,
+      message: `HTTP ${res.statusCode}`
+    };
+  } catch (err) {
+    return { ...base, success: false, message: err instanceof Error ? err.message : "HTTP error" };
+  }
+}
+async function sendCanaryAlerts(event, onlyId) {
+  const channels = listCanaryAlerts().filter((c) => onlyId ? c.id === onlyId : c.enabled);
+  if (channels.length === 0) return [];
+  const results = await Promise.allSettled(channels.map((c) => sendOne(c, event)));
+  return results.map(
+    (r, i) => r.status === "fulfilled" ? r.value : {
+      channelId: channels[i].id,
+      type: channels[i].type,
+      success: false,
+      message: String(r.reason)
+    }
+  );
+}
+
 // src/core/canary-alert.ts
 var TRIP_THROTTLE_MS = 30 * 1e3;
 var lastAlerted = /* @__PURE__ */ new Map();
@@ -1798,16 +1935,27 @@ function recordCanaryTrip(trip) {
     source: trip.source,
     detail: `CANARY TRIPPED: ${trip.detail ?? `honeytoken read via ${trip.source}`}`
   });
-  if (!notificationsEnabled()) return;
   const now = Date.now();
   const last = lastAlerted.get(trip.key);
   if (last !== void 0 && now - last < TRIP_THROTTLE_MS) return;
   lastAlerted.set(trip.key, now);
-  const who = agent ? `${trip.source} (${agent})` : trip.source;
-  notifyUser(
-    "q-ring: CANARY TRIPPED",
-    `Honeytoken "${trip.key}" was read by ${who}. This credential is fake \u2014 but something reached for it. Investigate: qring audit --action canary`
-  );
+  if (notificationsEnabled()) {
+    const who = agent ? `${trip.source} (${agent})` : trip.source;
+    notifyUser(
+      "q-ring: CANARY TRIPPED",
+      `Honeytoken "${trip.key}" was read by ${who}. This credential is fake \u2014 but something reached for it. Investigate: qring audit --action canary`
+    );
+  }
+  void sendCanaryAlerts({
+    key: trip.key,
+    scope: trip.scope,
+    env: trip.env,
+    source: trip.source,
+    agent,
+    detail: trip.detail ?? `honeytoken read via ${trip.source}`,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  }).catch(() => {
+  });
 }
 
 // src/core/provision.ts
@@ -2502,9 +2650,9 @@ function tunnelList() {
 }
 
 // src/core/memory.ts
-import { existsSync as existsSync7, readFileSync as readFileSync8, writeFileSync as writeFileSync6, mkdirSync as mkdirSync7, chmodSync as chmodSync3 } from "fs";
-import { join as join10 } from "path";
-import { homedir as homedir7, hostname, userInfo } from "os";
+import { existsSync as existsSync8, readFileSync as readFileSync8, writeFileSync as writeFileSync7, mkdirSync as mkdirSync8, chmodSync as chmodSync3 } from "fs";
+import { join as join11 } from "path";
+import { homedir as homedir8, hostname, userInfo } from "os";
 import {
   createCipheriv as createCipheriv2,
   createDecipheriv as createDecipheriv2,
@@ -2516,21 +2664,21 @@ var MEMORY_FILE = "agent-memory.enc";
 var KEYRING_SERVICE = "qring-memory-key";
 var KEYRING_ACCOUNT = "encryption-key";
 function getMemoryDir() {
-  const dir = join10(homedir7(), ".config", "q-ring");
-  if (!existsSync7(dir)) {
-    mkdirSync7(dir, { recursive: true, mode: 448 });
+  const dir = join11(homedir8(), ".config", "q-ring");
+  if (!existsSync8(dir)) {
+    mkdirSync8(dir, { recursive: true, mode: 448 });
   }
   return dir;
 }
 function writeMemoryFile(path, data) {
-  writeFileSync6(path, data, { mode: 384 });
+  writeFileSync7(path, data, { mode: 384 });
   try {
     chmodSync3(path, 384);
   } catch {
   }
 }
 function getMemoryPath() {
-  return join10(getMemoryDir(), MEMORY_FILE);
+  return join11(getMemoryDir(), MEMORY_FILE);
 }
 var PBKDF2_ITERATIONS2 = 21e4;
 var KEY_LENGTH2 = 32;
@@ -2624,7 +2772,7 @@ function decrypt(blob) {
 }
 function loadStore2() {
   const path = getMemoryPath();
-  if (!existsSync7(path)) {
+  if (!existsSync8(path)) {
     return { entries: {} };
   }
   try {
@@ -2672,6 +2820,84 @@ function forget(key) {
   return false;
 }
 
+// src/core/sessions.ts
+var DEFAULT_MAX_EVENTS = 200;
+var UNLABELED = "unlabeled";
+function slug(label) {
+  return label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 48) || UNLABELED;
+}
+function sessionKeyFor(event) {
+  if (event.action === "wrap" && event.correlationId) return `wrap:${event.correlationId}`;
+  if (event.agent) return `pid:${event.pid}:${slug(event.agent)}`;
+  if (event.source === "mcp" || event.source === "agent") return `pid:${event.pid}:${UNLABELED}`;
+  return null;
+}
+function wrapLabelFrom(detail) {
+  const m = detail?.match(/^airlock session started: (.+?)(?: \(env (?:inherited|stripped)\))?$/);
+  return m?.[1];
+}
+function buildSessions(events, maxEvents = DEFAULT_MAX_EVENTS) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    const key = sessionKeyFor(e);
+    if (!key) continue;
+    const bucket = byKey.get(key);
+    if (bucket) bucket.push(e);
+    else byKey.set(key, [e]);
+  }
+  const sessions = [];
+  for (const [key, bucket] of byKey) {
+    bucket.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+    const first = bucket[0];
+    const last = bucket[bucket.length - 1];
+    const countsByAction = {};
+    const sources = /* @__PURE__ */ new Map();
+    const keys = /* @__PURE__ */ new Set();
+    let denials = 0;
+    let wrapLabel;
+    for (const e of bucket) {
+      countsByAction[e.action] = (countsByAction[e.action] ?? 0) + 1;
+      sources.set(e.source, (sources.get(e.source) ?? 0) + 1);
+      if (e.key) keys.add(e.key);
+      if (e.action === "policy_deny") denials++;
+      if (!wrapLabel && e.action === "wrap") wrapLabel = wrapLabelFrom(e.detail);
+    }
+    const source = [...sources.entries()].sort((a, b) => b[1] - a[1])[0][0];
+    const agent = bucket.find((e) => e.agent)?.agent ?? UNLABELED;
+    const isWrap = key.startsWith("wrap:");
+    sessions.push({
+      id: isWrap ? key.slice("wrap:".length) : `${first.pid}-${slug(agent)}`,
+      agent,
+      source,
+      pid: first.pid,
+      startedAt: first.timestamp,
+      endedAt: last.timestamp,
+      eventCount: bucket.length,
+      countsByAction,
+      keys: [...keys].sort(),
+      denials,
+      ...isWrap ? { wrapLabel: wrapLabel ?? "(unknown command)" } : {},
+      events: bucket.slice(-maxEvents).reverse()
+    });
+  }
+  sessions.sort((a, b) => new Date(b.endedAt).getTime() - new Date(a.endedAt).getTime());
+  return sessions;
+}
+function agentVisibleEvents(events) {
+  return events.filter((e) => e.action !== "canary");
+}
+function loadEvents(query) {
+  return queryAudit({ since: query.since, agent: query.agent }).filter((e) => e.action !== "list");
+}
+function listAgentSessionsForAgents(query = {}) {
+  const sessions = buildSessions(agentVisibleEvents(loadEvents(query)), query.maxEvents);
+  return query.limit ? sessions.slice(0, query.limit) : sessions;
+}
+function summariseSession(session) {
+  const { events: _events, ...summary2 } = session;
+  return summary2;
+}
+
 export {
   PACKAGE_VERSION,
   checkDecay,
@@ -2714,6 +2940,9 @@ export {
   remember,
   recall,
   listMemory,
-  forget
+  forget,
+  buildSessions,
+  listAgentSessionsForAgents,
+  summariseSession
 };
-//# sourceMappingURL=chunk-KFILBHOY.js.map
+//# sourceMappingURL=chunk-VMDD5QTJ.js.map