@i4ctime/q-ring 0.11.5 → 0.12.0

package/dist/{chunk-MQM4DLPI.js → chunk-YWDKAZWS.js}

@@ -555,87 +555,11 @@ import { randomUUID } from "crypto";
 // src/utils/http-request.ts
 import { request as httpsRequest } from "https";
 import { request as httpRequestPlain } from "http";
-var DEFAULT_TIMEOUT_MS = 1e4;
-var DEFAULT_MAX_RESPONSE_BYTES = 65536;
-function httpRequest(opts) {
-  const {
-    url,
-    method = "GET",
-    headers = {},
-    body,
-    timeoutMs = DEFAULT_TIMEOUT_MS,
-    maxResponseBytes = DEFAULT_MAX_RESPONSE_BYTES
-  } = opts;
-  return new Promise((resolve, reject) => {
-    const parsed = new URL(url);
-    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-      reject(new Error(`Unsupported URL protocol: ${parsed.protocol}`));
-      return;
-    }
-    const reqFn = parsed.protocol === "https:" ? httpsRequest : httpRequestPlain;
-    const reqHeaders = { ...headers };
-    if (body && !reqHeaders["Content-Length"]) {
-      reqHeaders["Content-Length"] = Buffer.byteLength(body);
-    }
-    const req = reqFn(
-      url,
-      { method, headers: reqHeaders, timeout: timeoutMs },
-      (res) => {
-        const chunks = [];
-        let totalBytes = 0;
-        let truncated = false;
-        res.on("data", (chunk) => {
-          totalBytes += chunk.length;
-          if (totalBytes > maxResponseBytes) {
-            truncated = true;
-            res.destroy();
-            return;
-          }
-          chunks.push(chunk);
-        });
-        let settled = false;
-        const settle = (result) => {
-          if (!settled) {
-            settled = true;
-            resolve(result);
-          }
-        };
-        const fail = (err) => {
-          if (!settled) {
-            settled = true;
-            reject(err);
-          }
-        };
-        res.on("error", (err) => fail(new Error(`Response error: ${err.message}`)));
-        res.on("end", () => {
-          settle({
-            statusCode: res.statusCode ?? 0,
-            body: Buffer.concat(chunks).toString("utf8"),
-            truncated
-          });
-        });
-        res.on("close", () => {
-          settle({
-            statusCode: res.statusCode ?? 0,
-            body: Buffer.concat(chunks).toString("utf8"),
-            truncated
-          });
-        });
-      }
-    );
-    req.on("error", (err) => reject(new Error(`Network error: ${err.message}`)));
-    req.on("timeout", () => {
-      req.destroy();
-      reject(new Error("Request timed out"));
-    });
-    if (body) req.write(body);
-    req.end();
-  });
-}
 
 // src/core/ssrf.ts
 import { lookup } from "dns/promises";
 import * as dns from "dns";
+import { lookup as dnsLookup } from "dns";
 import { isIPv4, isIPv6 } from "net";
 function lookupAddressesSync(hostname2) {
   const lookupSync2 = dns.lookupSync;
@@ -682,6 +606,36 @@ async function checkSSRF(url) {
   }
   return null;
 }
+function guardedLookup(hostname2, options, callback) {
+  if (process.env.Q_RING_ALLOW_PRIVATE_HOOKS === "1") {
+    dnsLookup(
+      hostname2,
+      options,
+      callback
+    );
+    return;
+  }
+  dnsLookup(
+    hostname2,
+    options,
+    (err, address, family) => {
+      if (err) return callback(err, address, family);
+      const list = Array.isArray(address) ? address : [{ address, family: family ?? 0 }];
+      for (const a of list) {
+        if (isPrivateIP(a.address)) {
+          const blocked = Object.assign(
+            new Error(
+              `Blocked: "${hostname2}" resolved to private address ${a.address} at connect time.`
+            ),
+            { code: "EQRINGSSRF" }
+          );
+          return callback(blocked, address, family);
+        }
+      }
+      callback(null, address, family);
+    }
+  );
+}
 function checkJitHttpProvisionUrl(url) {
   if (process.env.Q_RING_ALLOW_PRIVATE_HOOKS === "1") return null;
   try {
@@ -719,6 +673,91 @@ function checkJitHttpProvisionUrl(url) {
   return null;
 }
 
+// src/utils/http-request.ts
+var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_MAX_RESPONSE_BYTES = 65536;
+function httpRequest(opts) {
+  const {
+    url,
+    method = "GET",
+    headers = {},
+    body,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+    maxResponseBytes = DEFAULT_MAX_RESPONSE_BYTES
+  } = opts;
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      reject(new Error(`Unsupported URL protocol: ${parsed.protocol}`));
+      return;
+    }
+    const reqFn = parsed.protocol === "https:" ? httpsRequest : httpRequestPlain;
+    const reqHeaders = { ...headers };
+    if (body && !reqHeaders["Content-Length"]) {
+      reqHeaders["Content-Length"] = Buffer.byteLength(body);
+    }
+    const req = reqFn(
+      url,
+      {
+        method,
+        headers: reqHeaders,
+        timeout: timeoutMs,
+        // Re-validate the resolved IP at connect time (DNS-rebinding guard).
+        lookup: guardedLookup
+      },
+      (res) => {
+        const chunks = [];
+        let totalBytes = 0;
+        let truncated = false;
+        res.on("data", (chunk) => {
+          totalBytes += chunk.length;
+          if (totalBytes > maxResponseBytes) {
+            truncated = true;
+            res.destroy();
+            return;
+          }
+          chunks.push(chunk);
+        });
+        let settled = false;
+        const settle = (result) => {
+          if (!settled) {
+            settled = true;
+            resolve(result);
+          }
+        };
+        const fail = (err) => {
+          if (!settled) {
+            settled = true;
+            reject(err);
+          }
+        };
+        res.on("error", (err) => fail(new Error(`Response error: ${err.message}`)));
+        res.on("end", () => {
+          settle({
+            statusCode: res.statusCode ?? 0,
+            body: Buffer.concat(chunks).toString("utf8"),
+            truncated
+          });
+        });
+        res.on("close", () => {
+          settle({
+            statusCode: res.statusCode ?? 0,
+            body: Buffer.concat(chunks).toString("utf8"),
+            truncated
+          });
+        });
+      }
+    );
+    req.on("error", (err) => reject(new Error(`Network error: ${err.message}`)));
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request timed out"));
+    });
+    if (body) req.write(body);
+    req.end();
+  });
+}
+
 // src/core/hooks.ts
 function getRegistryPath2() {
   const dir = join5(homedir3(), ".config", "q-ring");
@@ -1065,15 +1104,33 @@ function listApprovals() {
 }
 
 // src/core/policy.ts
+import { statSync as statSync2 } from "fs";
+import { join as join7 } from "path";
 var cachedPolicy = null;
+var policyRoot = null;
+function setPolicyRoot(root) {
+  policyRoot = root;
+  cachedPolicy = null;
+}
+function resolvePolicyPath(projectPath) {
+  return policyRoot ?? projectPath ?? process.cwd();
+}
+function configMtime(pp) {
+  try {
+    return statSync2(join7(pp, ".q-ring.json")).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
 function loadPolicy(projectPath) {
-  const pp = projectPath ?? process.cwd();
-  if (cachedPolicy && cachedPolicy.path === pp) {
+  const pp = resolvePolicyPath(projectPath);
+  const mtimeMs = configMtime(pp);
+  if (cachedPolicy && cachedPolicy.path === pp && cachedPolicy.mtimeMs === mtimeMs) {
     return cachedPolicy.policy;
   }
   const config = readProjectConfig(pp);
   const policy = config?.policy ?? {};
-  cachedPolicy = { path: pp, policy };
+  cachedPolicy = { path: pp, mtimeMs, policy };
   return policy;
 }
 function checkToolPolicy(toolName, projectPath) {
@@ -1161,7 +1218,13 @@ function checkExecPolicy(command, projectPath) {
   const policy = loadPolicy(projectPath);
   if (!policy.exec) return { allowed: true, policySource: "no-policy" };
   if (policy.exec.denyCommands) {
-    const denied = policy.exec.denyCommands.find((d) => command.includes(d));
+    const denied = policy.exec.denyCommands.find((d) => {
+      const pattern = new RegExp(
+        `(^|[\\s/])${d.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(\\s|$)`,
+        "i"
+      );
+      return pattern.test(command);
+    });
     if (denied) {
       return {
         allowed: false,
@@ -1171,7 +1234,8 @@ function checkExecPolicy(command, projectPath) {
     }
   }
   if (policy.exec.allowCommands) {
-    const allowed = policy.exec.allowCommands.some((a) => command.startsWith(a));
+    const normalized = command.trimStart();
+    const allowed = policy.exec.allowCommands.some((a) => normalized.startsWith(a));
     if (!allowed) {
       return {
         allowed: false,
@@ -1198,7 +1262,7 @@ function getPolicySummary(projectPath) {
 // src/core/keyring.ts
 import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync4, unlinkSync } from "fs";
 import { homedir as homedir5 } from "os";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 import { Entry, findCredentials } from "@napi-rs/keyring";
 
 // src/utils/hash.ts
@@ -1402,10 +1466,10 @@ registry.register(httpProvider);
 
 // src/core/keyring.ts
 function withJitEnvelopeLock(service, key, fn) {
-  const dir = join7(homedir5(), ".config", "q-ring", "jit-locks");
+  const dir = join8(homedir5(), ".config", "q-ring", "jit-locks");
   mkdirSync5(dir, { recursive: true });
   const safe = Buffer.from(`${service}\0${key}`, "utf8").toString("base64url");
-  const lockPath = join7(dir, `${safe}.lock`);
+  const lockPath = join8(dir, `${safe}.lock`);
   const deadline = Date.now() + 8e3;
   while (Date.now() < deadline) {
     try {
@@ -1789,6 +1853,16 @@ function exportSecrets(opts = {}) {
     if (entry.envelope) {
       const decay = checkDecay(entry.envelope);
       if (decay.isExpired) continue;
+      if (source === "mcp" && entry.envelope.meta.requiresApproval && !hasApproval(entry.key, entry.scope)) {
+        logAudit({
+          action: "read",
+          key: entry.key,
+          scope: entry.scope,
+          source,
+          detail: "blocked: requires user approval (export)"
+        });
+        continue;
+      }
       const value = collapseValue(entry.envelope, env);
       if (value !== null) {
         rawValues.set(entry.key, value);
@@ -1920,7 +1994,7 @@ function tunnelList() {
 
 // src/core/memory.ts
 import { existsSync as existsSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6 } from "fs";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 import { homedir as homedir6, hostname, userInfo } from "os";
 import { createCipheriv, createDecipheriv, createHash as createHash3, randomBytes as randomBytes3 } from "crypto";
 import { Entry as Entry2 } from "@napi-rs/keyring";
@@ -1928,14 +2002,14 @@ var MEMORY_FILE = "agent-memory.enc";
 var KEYRING_SERVICE = "qring-memory-key";
 var KEYRING_ACCOUNT = "encryption-key";
 function getMemoryDir() {
-  const dir = join8(homedir6(), ".config", "q-ring");
+  const dir = join9(homedir6(), ".config", "q-ring");
   if (!existsSync6(dir)) {
     mkdirSync6(dir, { recursive: true });
   }
   return dir;
 }
 function getMemoryPath() {
-  return join8(getMemoryDir(), MEMORY_FILE);
+  return join9(getMemoryDir(), MEMORY_FILE);
 }
 function deriveLegacyKey() {
   const fingerprint = `qring-memory:${hostname()}:${userInfo().username}`;
@@ -2043,14 +2117,15 @@ export {
   exportAudit,
   detectAnomalies,
   listEntanglements,
-  httpRequest,
   checkSSRF,
+  httpRequest,
   registerHook,
   removeHook,
   listHooks,
   fireHooks,
   listApprovals,
   registry,
+  setPolicyRoot,
   checkToolPolicy,
   checkKeyReadPolicy,
   checkExecPolicy,
@@ -2074,4 +2149,4 @@ export {
   listMemory,
   forget
 };
-//# sourceMappingURL=chunk-MQM4DLPI.js.map
+//# sourceMappingURL=chunk-YWDKAZWS.js.map