@i4ctime/q-ring 0.9.8 → 0.10.1

package/dist/{chunk-JV4JFWV6.js → chunk-LLMO64FE.js}

@@ -1,6 +1,37 @@
 #!/usr/bin/env node
 
 // src/core/envelope.ts
+import { z } from "zod";
+var EntanglementLinkSchema = z.object({
+  service: z.string(),
+  key: z.string()
+});
+var SecretMetadataSchema = z.object({
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  expiresAt: z.string().optional(),
+  ttlSeconds: z.number().optional(),
+  description: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  entangled: z.array(EntanglementLinkSchema).optional(),
+  accessCount: z.number(),
+  lastAccessedAt: z.string().optional(),
+  ephemeral: z.boolean().optional(),
+  rotationFormat: z.string().optional(),
+  rotationPrefix: z.string().optional(),
+  provider: z.string().optional(),
+  validationUrl: z.string().optional(),
+  requiresApproval: z.boolean().optional(),
+  jitProvider: z.string().optional(),
+  jitExpiresAt: z.string().optional()
+});
+var QuantumEnvelopeSchema = z.object({
+  v: z.literal(1),
+  value: z.string().optional(),
+  states: z.record(z.string(), z.string()).optional(),
+  defaultEnv: z.string().optional(),
+  meta: SecretMetadataSchema
+});
 function createEnvelope(value, opts) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   let expiresAt = opts?.expiresAt;
@@ -32,8 +63,9 @@ function createEnvelope(value, opts) {
 function parseEnvelope(raw) {
   try {
     const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed === "object" && parsed.v === 1) {
-      return parsed;
+    const r = QuantumEnvelopeSchema.safeParse(parsed);
+    if (r.success) {
+      return r.data;
     }
   } catch {
   }
@@ -84,6 +116,15 @@ function checkDecay(envelope) {
   const now = Date.now();
   const expires = new Date(envelope.meta.expiresAt).getTime();
   const created = new Date(envelope.meta.createdAt).getTime();
+  if (!Number.isFinite(expires) || !Number.isFinite(created)) {
+    return {
+      isExpired: true,
+      isStale: true,
+      lifetimePercent: 100,
+      secondsRemaining: null,
+      timeRemaining: "invalid date"
+    };
+  }
   const totalLifetime = expires - created;
   const elapsed = now - created;
   const remaining = expires - now;
@@ -188,12 +229,15 @@ function collapseEnvironment(ctx = {}) {
   }
   return null;
 }
+var MAX_BRANCH_GLOB_PATTERN_LEN = 200;
+var MAX_BRANCH_GLOB_REGEX_SOURCE = 400;
 function matchGlob(branchMap, branch) {
   for (const [pattern, env] of Object.entries(branchMap)) {
     if (!pattern.includes("*")) continue;
-    const regex = new RegExp(
-      "^" + pattern.replace(/\*/g, ".*") + "$"
-    );
+    if (pattern.length > MAX_BRANCH_GLOB_PATTERN_LEN) continue;
+    const source = "^" + pattern.replace(/\*/g, ".*") + "$";
+    if (source.length > MAX_BRANCH_GLOB_REGEX_SOURCE) continue;
+    const regex = new RegExp(source);
     if (regex.test(branch)) return env;
   }
   return void 0;
@@ -206,11 +250,27 @@ function mapEnvName(raw) {
 }
 
 // src/core/observer.ts
-import { existsSync as existsSync2, mkdirSync, appendFileSync, readFileSync as readFileSync2, openSync, fstatSync, readSync, closeSync } from "fs";
+import {
+  existsSync as existsSync2,
+  mkdirSync,
+  appendFileSync,
+  readFileSync as readFileSync2,
+  openSync,
+  fstatSync,
+  readSync,
+  closeSync,
+  statSync
+} from "fs";
 import { join as join2 } from "path";
 import { homedir } from "os";
 import { createHash } from "crypto";
 function getAuditDir() {
+  if (process.env.QRING_AUDIT_DIR) {
+    if (!existsSync2(process.env.QRING_AUDIT_DIR)) {
+      mkdirSync(process.env.QRING_AUDIT_DIR, { recursive: true });
+    }
+    return process.env.QRING_AUDIT_DIR;
+  }
   const dir = join2(homedir(), ".config", "q-ring");
   if (!existsSync2(dir)) {
     mkdirSync(dir, { recursive: true });
@@ -256,11 +316,24 @@ function logAudit(event) {
   } catch {
   }
 }
+var MAX_AUDIT_BYTES = 12 * 1024 * 1024;
 function queryAudit(query = {}) {
   const path = getAuditPath();
   if (!existsSync2(path)) return [];
   try {
-    const lines = readFileSync2(path, "utf8").split("\n").filter((l) => l.trim());
+    const st = statSync(path);
+    const readStart = st.size > MAX_AUDIT_BYTES ? st.size - MAX_AUDIT_BYTES : 0;
+    const readLen = st.size > MAX_AUDIT_BYTES ? MAX_AUDIT_BYTES : st.size;
+    const buf = Buffer.alloc(readLen);
+    const fd = openSync(path, "r");
+    readSync(fd, buf, 0, readLen, readStart);
+    closeSync(fd);
+    let text = buf.toString("utf8");
+    if (readStart > 0) {
+      const firstNl = text.indexOf("\n");
+      if (firstNl !== -1) text = text.slice(firstNl + 1);
+    }
+    const lines = text.split("\n").filter((l) => l.trim());
     let events = lines.map((line) => {
       try {
         return JSON.parse(line);
@@ -393,7 +466,7 @@ function detectAnomalies(key) {
 }
 
 // src/core/entanglement.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
 import { join as join3 } from "path";
 import { homedir as homedir2 } from "os";
 function getRegistryPath() {
@@ -415,7 +488,9 @@ function loadRegistry() {
   }
 }
 function saveRegistry(registry2) {
-  writeFileSync2(getRegistryPath(), JSON.stringify(registry2, null, 2));
+  writeFileSync(getRegistryPath(), JSON.stringify(registry2, null, 2), {
+    mode: 384
+  });
 }
 function entangle(source, target) {
   const registry2 = loadRegistry();
@@ -454,6 +529,9 @@ function listEntanglements() {
 }
 
 // src/core/keyring.ts
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync4, unlinkSync } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join6 } from "path";
 import { Entry, findCredentials } from "@napi-rs/keyring";
 
 // src/utils/hash.ts
@@ -509,18 +587,18 @@ function resolveScope(opts) {
 }
 
 // src/core/hooks.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3 } from "fs";
 import { join as join4 } from "path";
 import { homedir as homedir3 } from "os";
-import { exec, spawn } from "child_process";
+import { execFile, spawn } from "child_process";
 import { randomUUID } from "crypto";
 
 // src/utils/http-request.ts
 import { request as httpsRequest } from "https";
-import { request as httpRequest } from "http";
+import { request as httpRequestPlain } from "http";
 var DEFAULT_TIMEOUT_MS = 1e4;
 var DEFAULT_MAX_RESPONSE_BYTES = 65536;
-function httpRequest_(opts) {
+function httpRequest(opts) {
   const {
     url,
     method = "GET",
@@ -535,7 +613,7 @@ function httpRequest_(opts) {
       reject(new Error(`Unsupported URL protocol: ${parsed.protocol}`));
       return;
     }
-    const reqFn = parsed.protocol === "https:" ? httpsRequest : httpRequest;
+    const reqFn = parsed.protocol === "https:" ? httpsRequest : httpRequestPlain;
     const reqHeaders = { ...headers };
     if (body && !reqHeaders["Content-Length"]) {
       reqHeaders["Content-Length"] = Buffer.byteLength(body);
@@ -598,6 +676,19 @@ function httpRequest_(opts) {
 
 // src/core/ssrf.ts
 import { lookup } from "dns/promises";
+import * as dns from "dns";
+import { isIPv4, isIPv6 } from "net";
+function lookupAddressesSync(hostname) {
+  const lookupSync2 = dns.lookupSync;
+  return lookupSync2(hostname, { all: true });
+}
+function isHostnameIpLiteral(hostname) {
+  if (isIPv4(hostname)) return true;
+  if (hostname.startsWith("[") && hostname.endsWith("]")) {
+    return isIPv6(hostname.slice(1, -1));
+  }
+  return isIPv6(hostname);
+}
 function isPrivateIP(ip) {
   const octet = "(?:25[0-5]|2[0-4]\\d|1?\\d{1,2})";
   const ipv4Re = new RegExp(`^::ffff:(${octet}\\.${octet}\\.${octet}\\.${octet})$`, "i");
@@ -632,15 +723,39 @@ async function checkSSRF(url) {
   }
   return null;
 }
-function checkSSRFSync(url) {
+function checkJitHttpProvisionUrl(url) {
   if (process.env.Q_RING_ALLOW_PRIVATE_HOOKS === "1") return null;
   try {
     const parsed = new URL(url);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return "Blocked: JIT HTTP provider only allows http: or https: URLs.";
+    }
     const hostname = parsed.hostname.replace(/^\[|\]$/g, "");
+    if (!hostname) {
+      return "Blocked: empty hostname in JIT URL.";
+    }
     if (isPrivateIP(hostname)) {
       return `Blocked: URL resolves to private address (${hostname}). Set Q_RING_ALLOW_PRIVATE_HOOKS=1 to override.`;
     }
+    if (isHostnameIpLiteral(hostname)) {
+      return null;
+    }
+    let results;
+    try {
+      results = lookupAddressesSync(hostname);
+    } catch {
+      return `Blocked: DNS resolution failed for "${hostname}" (JIT HTTP provisioning fails closed).`;
+    }
+    if (!results.length) {
+      return `Blocked: DNS returned no addresses for "${hostname}".`;
+    }
+    for (const { address } of results) {
+      if (isPrivateIP(address)) {
+        return `Blocked: URL "${hostname}" resolves to private address ${address}. Set Q_RING_ALLOW_PRIVATE_HOOKS=1 to override.`;
+      }
+    }
   } catch {
+    return "Blocked: malformed JIT HTTP URL.";
   }
   return null;
 }
@@ -665,7 +780,9 @@ function loadRegistry2() {
   }
 }
 function saveRegistry2(registry2) {
-  writeFileSync3(getRegistryPath2(), JSON.stringify(registry2, null, 2));
+  writeFileSync2(getRegistryPath2(), JSON.stringify(registry2, null, 2), {
+    mode: 384
+  });
 }
 function registerHook(entry) {
   const registry2 = loadRegistry2();
@@ -721,6 +838,14 @@ function matchesHook(hook, payload, tags) {
   if (m.scope && m.scope !== payload.scope) return false;
   return true;
 }
+var SAFE_PGREP_NAME = /^[a-zA-Z0-9._:/-]{1,256}$/;
+function shellRunner() {
+  if (process.platform === "win32") {
+    const comspec = process.env.ComSpec ?? "cmd.exe";
+    return { file: comspec, args: ["/d", "/s", "/c"] };
+  }
+  return { file: "/bin/sh", args: ["-c"] };
+}
 function executeShell(command, payload) {
   return new Promise((resolve) => {
     const env = {
@@ -729,13 +854,33 @@ function executeShell(command, payload) {
       QRING_HOOK_ACTION: payload.action,
       QRING_HOOK_SCOPE: payload.scope
     };
-    exec(command, { timeout: 3e4, env }, (err, stdout, stderr) => {
-      if (err) {
-        resolve({ hookId: "", success: false, message: `Shell error: ${err.message}` });
-      } else {
-        resolve({ hookId: "", success: true, message: stdout.trim() || "OK" });
+    const { file, args } = shellRunner();
+    execFile(
+      file,
+      [...args, command],
+      {
+        timeout: 3e4,
+        env,
+        windowsHide: true,
+        maxBuffer: 4 * 1024 * 1024,
+        encoding: "utf8"
+      },
+      (err, stdout) => {
+        if (err) {
+          resolve({
+            hookId: "",
+            success: false,
+            message: `Shell error: ${err.message}`
+          });
+        } else {
+          resolve({
+            hookId: "",
+            success: true,
+            message: (stdout ?? "").trim() || "OK"
+          });
+        }
       }
-    });
+    );
   });
 }
 async function executeHttp(url, payload) {
@@ -752,7 +897,7 @@ async function executeHttp(url, payload) {
   }
   try {
     const body = JSON.stringify(payload);
-    const res = await httpRequest_({
+    const res = await httpRequest({
       url,
       method: "POST",
       headers: {
@@ -777,24 +922,48 @@ async function executeHttp(url, payload) {
 }
 function executeSignal(target, signal = "SIGHUP") {
   return new Promise((resolve) => {
-    const pid = parseInt(target, 10);
-    if (!isNaN(pid)) {
+    const trimmed = target.trim();
+    if (/^\d+$/.test(trimmed)) {
+      const pid = parseInt(trimmed, 10);
       try {
         process.kill(pid, signal);
-        resolve({ hookId: "", success: true, message: `Signal ${signal} sent to PID ${pid}` });
+        resolve({
+          hookId: "",
+          success: true,
+          message: `Signal ${signal} sent to PID ${pid}`
+        });
       } catch (err) {
-        resolve({ hookId: "", success: false, message: `Signal error: ${err instanceof Error ? err.message : String(err)}` });
+        resolve({
+          hookId: "",
+          success: false,
+          message: `Signal error: ${err instanceof Error ? err.message : String(err)}`
+        });
       }
       return;
     }
-    const child = spawn("pgrep", ["-f", target], { timeout: 5e3, stdio: ["ignore", "pipe", "pipe"] });
+    if (!SAFE_PGREP_NAME.test(trimmed)) {
+      resolve({
+        hookId: "",
+        success: false,
+        message: "Signal target must be a numeric PID, or a process name matching /^[a-zA-Z0-9._:/-]{1,256}$/ (no spaces or shell metacharacters)."
+      });
+      return;
+    }
+    const child = spawn("pgrep", ["-f", trimmed], {
+      timeout: 5e3,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
     let stdout = "";
     child.stdout.on("data", (d) => {
       stdout += d.toString();
     });
     child.on("close", (code) => {
       if (code !== 0 || !stdout.trim()) {
-        resolve({ hookId: "", success: false, message: `Process "${target}" not found` });
+        resolve({
+          hookId: "",
+          success: false,
+          message: `Process "${trimmed}" not found`
+        });
         return;
       }
       const pids = stdout.trim().split("\n").map((p) => parseInt(p.trim(), 10)).filter((p) => !isNaN(p));
@@ -806,10 +975,18 @@ function executeSignal(target, signal = "SIGHUP") {
         } catch {
         }
       }
-      resolve({ hookId: "", success: sent > 0, message: `Signal ${signal} sent to ${sent} process(es)` });
+      resolve({
+        hookId: "",
+        success: sent > 0,
+        message: `Signal ${signal} sent to ${sent} process(es)`
+      });
     });
     child.on("error", () => {
-      resolve({ hookId: "", success: false, message: `Process "${target}" not found` });
+      resolve({
+        hookId: "",
+        success: false,
+        message: `Process "${trimmed}" not found`
+      });
     });
   });
 }
@@ -866,33 +1043,50 @@ async function fireHooks(payload, tags) {
 }
 
 // src/core/approval.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "fs";
 import { join as join5 } from "path";
 import { homedir as homedir4 } from "os";
-import { createHmac, randomBytes } from "crypto";
+import { createHmac, randomBytes, timingSafeEqual } from "crypto";
 function getHmacSecret() {
-  const secretPath = join5(homedir4(), ".config", "q-ring", ".approval-key");
   const dir = join5(homedir4(), ".config", "q-ring");
-  if (!existsSync5(dir)) mkdirSync4(dir, { recursive: true });
+  const secretPath = join5(dir, ".approval-key");
+  if (!existsSync5(dir)) mkdirSync4(dir, { recursive: true, mode: 448 });
   if (existsSync5(secretPath)) {
     return readFileSync5(secretPath, "utf8").trim();
   }
   const secret = randomBytes(32).toString("hex");
-  writeFileSync4(secretPath, secret, { mode: 384 });
+  writeFileSync3(secretPath, secret, { mode: 384 });
   return secret;
 }
 function computeHmac(entry) {
-  const payload = `${entry.id}|${entry.key}|${entry.scope}|${entry.reason}|${entry.grantedBy}|${entry.grantedAt}|${entry.expiresAt}`;
+  const payload = [
+    entry.id,
+    entry.key,
+    entry.scope,
+    entry.reason,
+    entry.grantedBy,
+    entry.grantedAt,
+    entry.expiresAt,
+    entry.workspace ?? "",
+    entry.sessionId ?? ""
+  ].join("|");
   return createHmac("sha256", getHmacSecret()).update(payload).digest("hex");
 }
 function verifyHmac(entry) {
   const expected = computeHmac(entry);
-  return expected === entry.hmac;
+  const a = Buffer.from(expected, "utf8");
+  const b = Buffer.from(entry.hmac, "utf8");
+  if (a.length !== b.length) return false;
+  try {
+    return timingSafeEqual(a, b);
+  } catch {
+    return false;
+  }
 }
 function getRegistryPath3() {
   const dir = join5(homedir4(), ".config", "q-ring");
   if (!existsSync5(dir)) {
-    mkdirSync4(dir, { recursive: true });
+    mkdirSync4(dir, { recursive: true, mode: 448 });
   }
   return join5(dir, "approvals.json");
 }
@@ -908,7 +1102,7 @@ function loadRegistry3() {
   }
 }
 function saveRegistry3(registry2) {
-  writeFileSync4(getRegistryPath3(), JSON.stringify(registry2, null, 2), { mode: 384 });
+  writeFileSync3(getRegistryPath3(), JSON.stringify(registry2, null, 2), { mode: 384 });
 }
 function cleanup(registry2) {
   const now = Date.now();
@@ -976,6 +1170,20 @@ function listApprovals() {
 
 // src/core/provision.ts
 import { execFileSync, spawnSync } from "child_process";
+import { z as z2 } from "zod";
+var AwsStsConfigSchema = z2.object({
+  roleArn: z2.string(),
+  sessionName: z2.string().optional(),
+  durationSeconds: z2.number().optional()
+});
+var HttpJitConfigSchema = z2.object({
+  url: z2.string(),
+  method: z2.string().optional(),
+  valuePath: z2.string().optional(),
+  expiresInSeconds: z2.number().optional(),
+  headers: z2.record(z2.string(), z2.string()).optional(),
+  body: z2.unknown().optional()
+});
 var ProvisionRegistry = class {
   providers = /* @__PURE__ */ new Map();
   register(provider) {
@@ -992,16 +1200,20 @@ var awsStsProvider = {
   name: "aws-sts",
   description: "AWS STS AssumeRole (requires existing local AWS CLI credentials)",
   provision(configRaw) {
-    let config;
+    let raw;
     try {
-      config = JSON.parse(configRaw);
+      raw = JSON.parse(configRaw);
     } catch {
       throw new Error('aws-sts requires valid JSON config (e.g. {"roleArn":"arn:aws:..."})');
     }
+    const parsed = AwsStsConfigSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new Error(`aws-sts invalid config: ${parsed.error.message}`);
+    }
+    const config = parsed.data;
     const roleArn = config.roleArn;
     const sessionName = config.sessionName || "q-ring-agent";
     const duration = config.durationSeconds || 3600;
-    if (!roleArn) throw new Error("aws-sts requires roleArn in config");
     try {
       const output = execFileSync("aws", [
         "sts",
@@ -1015,8 +1227,8 @@ var awsStsProvider = {
         "--output",
         "json"
       ], { encoding: "utf8" });
-      const parsed = JSON.parse(output);
-      const creds = parsed.Credentials;
+      const parsed2 = JSON.parse(output);
+      const creds = parsed2.Credentials;
       const value = JSON.stringify({
         AWS_ACCESS_KEY_ID: creds.AccessKeyId,
         AWS_SECRET_ACCESS_KEY: creds.SecretAccessKey,
@@ -1035,18 +1247,23 @@ var httpProvider = {
   name: "http",
   description: "Generic HTTP token endpoint using Node.js http/https",
   provision(configRaw) {
-    let config;
+    let raw;
     try {
-      config = JSON.parse(configRaw);
+      raw = JSON.parse(configRaw);
     } catch {
       throw new Error("http provider requires valid JSON config");
     }
+    const parsed = HttpJitConfigSchema.safeParse(raw);
+    if (!parsed.success) {
+      throw new Error(`http provider invalid config: ${parsed.error.message}`);
+    }
+    const config = parsed.data;
     const url = config.url;
     const method = config.method || "POST";
     const valuePath = config.valuePath || "token";
     const expiresInSeconds = config.expiresInSeconds || 3600;
     if (!url) throw new Error("http provider requires url in config");
-    const ssrfBlock = checkSSRFSync(url);
+    const ssrfBlock = checkJitHttpProvisionUrl(url);
     if (ssrfBlock) throw new Error(`SSRF blocked: ${ssrfBlock}`);
     const headers = {
       "User-Agent": "q-ring-jit/1.0",
@@ -1080,8 +1297,8 @@ req.end();
       if (result.status !== 0) {
         throw new Error(result.stderr || "HTTP request failed");
       }
-      const parsed = JSON.parse(result.stdout);
-      let val = parsed;
+      const parsed2 = JSON.parse(result.stdout);
+      let val = parsed2;
       for (const key of valuePath.split(".")) {
         val = val[key];
       }
@@ -1110,6 +1327,39 @@ function loadPolicy(projectPath) {
   cachedPolicy = { path: pp, policy };
   return policy;
 }
+function checkSecretLifecyclePolicy(input, projectPath) {
+  const policy = loadPolicy(projectPath);
+  if (!policy.secrets) return { allowed: true, policySource: "no-policy" };
+  const s = policy.secrets;
+  if (s.maxTtlSeconds != null && input.ttlSeconds != null && input.ttlSeconds > s.maxTtlSeconds) {
+    return {
+      allowed: false,
+      reason: `TTL ${input.ttlSeconds}s exceeds policy maximum ${s.maxTtlSeconds}s`,
+      policySource: ".q-ring.json policy.secrets.maxTtlSeconds"
+    };
+  }
+  if (s.requireApprovalForTags?.length && input.tags?.length) {
+    const hit = input.tags.find((t) => s.requireApprovalForTags.includes(t));
+    if (hit && !input.requiresApproval) {
+      return {
+        allowed: false,
+        reason: `Tag "${hit}" requires explicit approval metadata (set requiresApproval / --requires-approval)`,
+        policySource: ".q-ring.json policy.secrets.requireApprovalForTags"
+      };
+    }
+  }
+  if (s.requireRotationFormatForTags?.length && input.tags?.length) {
+    const hit = input.tags.find((t) => s.requireRotationFormatForTags.includes(t));
+    if (hit && !input.rotationFormat) {
+      return {
+        allowed: false,
+        reason: `Tag "${hit}" requires a rotationFormat to be set`,
+        policySource: ".q-ring.json policy.secrets.requireRotationFormatForTags"
+      };
+    }
+  }
+  return { allowed: true, policySource: ".q-ring.json" };
+}
 function checkKeyReadPolicy(key, tags, projectPath) {
   const policy = loadPolicy(projectPath);
   if (!policy.mcp) return { allowed: true, policySource: "no-policy" };
@@ -1178,6 +1428,32 @@ function getPolicySummary(projectPath) {
 }
 
 // src/core/keyring.ts
+function withJitEnvelopeLock(service, key, fn) {
+  const dir = join6(homedir5(), ".config", "q-ring", "jit-locks");
+  mkdirSync5(dir, { recursive: true });
+  const safe = Buffer.from(`${service}\0${key}`, "utf8").toString("base64url");
+  const lockPath = join6(dir, `${safe}.lock`);
+  const deadline = Date.now() + 8e3;
+  while (Date.now() < deadline) {
+    try {
+      writeFileSync4(lockPath, `${process.pid}
+`, { flag: "wx", mode: 384 });
+      try {
+        return fn();
+      } finally {
+        try {
+          unlinkSync(lockPath);
+        } catch {
+        }
+      }
+    } catch {
+      const start = Date.now();
+      while (Date.now() - start < 15) {
+      }
+    }
+  }
+  throw new Error("Could not acquire JIT envelope lock (timeout)");
+}
 function readEnvelope(service, key) {
   const entry = new Entry(service, key);
   const raw = entry.getPassword();
@@ -1196,7 +1472,7 @@ function resolveEnv(opts) {
 }
 function resolveTemplates(value, opts, seen) {
   if (!value.includes("{{") || !value.includes("}}")) return value;
-  return value.replace(/\{\{([^}]+)\}\}/g, (match, refKeyRaw) => {
+  return value.replace(/\{\{([^}]+)\}\}/g, (_match, refKeyRaw) => {
     const refKey = refKeyRaw.trim();
     const refValue = getSecret(refKey, { ...opts, _seen: seen });
     if (refValue === null) {
@@ -1207,7 +1483,7 @@ function resolveTemplates(value, opts, seen) {
 }
 function resolveTemplatesOffline(value, rawValues, seen) {
   if (!value.includes("{{") || !value.includes("}}")) return value;
-  return value.replace(/\{\{([^}]+)\}\}/g, (match, refKeyRaw) => {
+  return value.replace(/\{\{([^}]+)\}\}/g, (_match, refKeyRaw) => {
     const refKey = refKeyRaw.trim();
     if (seen.has(refKey)) {
       throw new Error(`Circular dependency detected: ${[...seen].join(" -> ")} -> ${refKey}`);
@@ -1277,11 +1553,27 @@ function getSecret(key, opts = {}) {
           isExpired = new Date(envelope.meta.jitExpiresAt).getTime() <= Date.now();
         }
         if (isExpired) {
-          const result = provider.provision(value);
-          envelope.states = envelope.states ?? {};
-          envelope.states["jit"] = result.value;
-          envelope.meta.jitExpiresAt = result.expiresAt;
-          writeEnvelope(service, key, envelope);
+          const jitConfigSource = value;
+          withJitEnvelopeLock(service, key, () => {
+            const latest = readEnvelope(service, key);
+            if (!latest?.meta.jitProvider) return;
+            let innerExpired = true;
+            if (latest.states && latest.states["jit"] && latest.meta.jitExpiresAt) {
+              innerExpired = new Date(latest.meta.jitExpiresAt).getTime() <= Date.now();
+            }
+            if (!innerExpired) {
+              envelope.states = latest.states;
+              envelope.meta.jitExpiresAt = latest.meta.jitExpiresAt;
+              return;
+            }
+            const result = provider.provision(jitConfigSource);
+            latest.states = latest.states ?? {};
+            latest.states["jit"] = result.value;
+            latest.meta.jitExpiresAt = result.expiresAt;
+            writeEnvelope(service, key, latest);
+            envelope.states = latest.states;
+            envelope.meta.jitExpiresAt = latest.meta.jitExpiresAt;
+          });
         }
         value = envelope.states["jit"];
       }
@@ -1323,6 +1615,20 @@ function setSecret(key, value, opts = {}) {
   const prov = opts.provider ?? existing?.meta.provider;
   const reqApp = opts.requiresApproval ?? existing?.meta.requiresApproval;
   const jitProv = opts.jitProvider ?? existing?.meta.jitProvider;
+  const mergedTags = opts.tags ?? existing?.meta.tags;
+  const ttlForPolicy = opts.ttlSeconds ?? existing?.meta.ttlSeconds;
+  const life = checkSecretLifecyclePolicy(
+    {
+      tags: mergedTags,
+      ttlSeconds: ttlForPolicy,
+      rotationFormat: rotFmt,
+      requiresApproval: !!reqApp
+    },
+    opts.projectPath
+  );
+  if (!life.allowed) {
+    throw new Error(life.reason ?? "Secret lifecycle policy denied");
+  }
   if (opts.states) {
     envelope = createEnvelope("", {
       states: opts.states,
@@ -1649,7 +1955,7 @@ export {
   exportAudit,
   detectAnomalies,
   listEntanglements,
-  httpRequest_,
+  httpRequest,
   checkSSRF,
   registerHook,
   removeHook,
@@ -1678,4 +1984,4 @@ export {
   tunnelDestroy,
   tunnelList
 };
-//# sourceMappingURL=chunk-JV4JFWV6.js.map
+//# sourceMappingURL=chunk-LLMO64FE.js.map