@i4ctime/q-ring 0.14.0 → 0.15.0

package/dist/{chunk-NNIEXAW5.js → chunk-TPPPTL4J.js}

@@ -287,21 +287,27 @@ function mapEnvName(raw) {
 
 // src/core/observer.ts
 import {
-  existsSync,
-  mkdirSync as mkdirSync2,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync3,
   appendFileSync,
-  chmodSync,
-  readFileSync as readFileSync4,
+  chmodSync as chmodSync2,
+  readFileSync as readFileSync5,
   openSync,
   fstatSync,
   readSync,
   closeSync,
   statSync as statSync3
 } from "fs";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
+import { homedir as homedir3 } from "os";
+import { createHash, createHmac, randomBytes as randomBytes2 } from "crypto";
+
+// src/core/backend.ts
+import { Entry as NapiEntry, findCredentials as napiFindCredentials } from "@napi-rs/keyring";
+import { existsSync, readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, chmodSync } from "fs";
+import { dirname as dirname2, join as join4 } from "path";
 import { homedir as homedir2 } from "os";
-import { createHash, createHmac, randomBytes } from "crypto";
-import { Entry } from "@napi-rs/keyring";
+import { createCipheriv, createDecipheriv, randomBytes, pbkdf2Sync } from "crypto";
 
 // src/utils/file-lock.ts
 import {
@@ -332,17 +338,11 @@ function withFileLock(name, fn, opts = {}) {
   const deadline = Date.now() + (opts.timeoutMs ?? 8e3);
   const staleMs = opts.staleMs ?? 3e4;
   while (Date.now() < deadline) {
+    let acquired = false;
     try {
       writeFileSync(lockPath, `${process.pid}
 `, { flag: "wx", mode: 384 });
-      try {
-        return fn();
-      } finally {
-        try {
-          unlinkSync(lockPath);
-        } catch {
-        }
-      }
+      acquired = true;
     } catch {
       try {
         const holderPid = parseInt(readFileSync3(lockPath, "utf8").trim(), 10);
@@ -356,10 +356,172 @@ function withFileLock(name, fn, opts = {}) {
       }
       sleepSync(15);
     }
+    if (acquired) {
+      try {
+        return fn();
+      } finally {
+        try {
+          unlinkSync(lockPath);
+        } catch {
+        }
+      }
+    }
   }
   throw new Error(`Could not acquire lock "${name}" (timeout)`);
 }
 
+// src/core/backend.ts
+var PASSPHRASE_ENV = "QRING_FILE_PASSPHRASE";
+var BACKEND_ENV = "QRING_BACKEND";
+var PATH_ENV = "QRING_FILE_BACKEND_PATH";
+var PBKDF2_ITERATIONS = 21e4;
+var KEY_LENGTH = 32;
+var FILE_PREFIX = "qfile1";
+var BackendUnavailableError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BackendUnavailableError";
+  }
+};
+function activeBackend() {
+  const requested = process.env[BACKEND_ENV];
+  if (requested === "file") return "file";
+  if (requested && requested !== "keyring") {
+    throw new BackendUnavailableError(
+      `Unknown ${BACKEND_ENV} "${requested}" \u2014 expected "keyring" or "file".`
+    );
+  }
+  return "keyring";
+}
+function storePath() {
+  return process.env[PATH_ENV] ?? join4(homedir2(), ".config", "q-ring", "file-backend.enc");
+}
+function passphrase() {
+  const p = process.env[PASSPHRASE_ENV];
+  if (!p) {
+    throw new BackendUnavailableError(
+      `${BACKEND_ENV}=file requires ${PASSPHRASE_ENV} to be set. q-ring refuses to store secrets under a machine-derivable key \u2014 set a strong passphrase, or use the OS keyring backend.`
+    );
+  }
+  return p;
+}
+var keyCache = null;
+function deriveKey(saltB64) {
+  const pass = passphrase();
+  if (keyCache && keyCache.salt === saltB64 && keyCache.pass === pass) {
+    return keyCache.key;
+  }
+  const key = pbkdf2Sync(pass, Buffer.from(saltB64, "base64"), PBKDF2_ITERATIONS, KEY_LENGTH, "sha512");
+  keyCache = { salt: saltB64, pass, key };
+  return key;
+}
+function loadStore() {
+  const path = storePath();
+  if (!existsSync(path)) {
+    return { map: {}, salt: randomBytes(16).toString("base64") };
+  }
+  const blob = readFileSync4(path, "utf8").trim();
+  const parts = blob.split(":");
+  if (parts.length !== 5 || parts[0] !== FILE_PREFIX) {
+    throw new BackendUnavailableError(
+      `${path} is not a valid q-ring file-backend store (expected ${FILE_PREFIX}:...).`
+    );
+  }
+  const [, salt, ivB64, tagB64, ctB64] = parts;
+  const decipher = createDecipheriv("aes-256-gcm", deriveKey(salt), Buffer.from(ivB64, "base64"));
+  decipher.setAuthTag(Buffer.from(tagB64, "base64"));
+  let plaintext;
+  try {
+    plaintext = decipher.update(Buffer.from(ctB64, "base64")) + decipher.final("utf8");
+  } catch {
+    throw new BackendUnavailableError(
+      `Cannot decrypt ${path} \u2014 wrong ${PASSPHRASE_ENV}, or the store was tampered with.`
+    );
+  }
+  return { map: JSON.parse(plaintext), salt };
+}
+function saveStore(map, salt) {
+  const path = storePath();
+  mkdirSync2(dirname2(path), { recursive: true, mode: 448 });
+  const iv = randomBytes(12);
+  const cipher = createCipheriv("aes-256-gcm", deriveKey(salt), iv);
+  const ct = Buffer.concat([cipher.update(JSON.stringify(map), "utf8"), cipher.final()]);
+  const blob = [
+    FILE_PREFIX,
+    salt,
+    iv.toString("base64"),
+    cipher.getAuthTag().toString("base64"),
+    ct.toString("base64")
+  ].join(":");
+  writeFileSync2(path, blob + "\n", { mode: 384 });
+  try {
+    chmodSync(path, 384);
+  } catch {
+  }
+}
+var SEP = "\0";
+function fileMutate(fn) {
+  return withFileLock("file-backend", () => {
+    const { map, salt } = loadStore();
+    const result = fn(map);
+    saveStore(map, salt);
+    return result;
+  });
+}
+var Entry = class {
+  constructor(service, account) {
+    this.service = service;
+    this.account = account;
+  }
+  service;
+  account;
+  napi;
+  delegate() {
+    this.napi ??= new NapiEntry(this.service, this.account);
+    return this.napi;
+  }
+  storeKey() {
+    return `${this.service}${SEP}${this.account}`;
+  }
+  getPassword() {
+    if (activeBackend() === "file") {
+      return loadStore().map[this.storeKey()] ?? null;
+    }
+    return this.delegate().getPassword();
+  }
+  setPassword(password) {
+    if (activeBackend() === "file") {
+      fileMutate((map) => {
+        map[this.storeKey()] = password;
+      });
+      return;
+    }
+    this.delegate().setPassword(password);
+  }
+  deleteCredential() {
+    if (activeBackend() === "file") {
+      return fileMutate((map) => {
+        const existed = this.storeKey() in map;
+        delete map[this.storeKey()];
+        return existed;
+      });
+    }
+    return this.delegate().deleteCredential();
+  }
+  // @napi-rs/keyring's other delete alias, used by `qring doctor`.
+  deletePassword() {
+    return this.deleteCredential();
+  }
+};
+function findCredentials(service) {
+  if (activeBackend() === "file") {
+    const { map } = loadStore();
+    const prefix = `${service}${SEP}`;
+    return Object.entries(map).filter(([k]) => k.startsWith(prefix)).map(([k, password]) => ({ account: k.slice(prefix.length), password }));
+  }
+  return napiFindCredentials(service);
+}
+
 // src/core/observer.ts
 var AUDIT_KEYRING_SERVICE = "qring-audit-chain";
 var AUDIT_KEY_ACCOUNT = "hmac-key";
@@ -370,7 +532,7 @@ function getAuditKey() {
     const entry = new Entry(AUDIT_KEYRING_SERVICE, AUDIT_KEY_ACCOUNT);
     const stored = entry.getPassword();
     if (stored) return Buffer.from(stored, "base64");
-    const key = randomBytes(32);
+    const key = randomBytes2(32);
     entry.setPassword(key.toString("base64"));
     return key;
   } catch {
@@ -401,23 +563,23 @@ function writeStoredAnchor(hash) {
 }
 function getAuditDir() {
   if (process.env.QRING_AUDIT_DIR) {
-    if (!existsSync(process.env.QRING_AUDIT_DIR)) {
-      mkdirSync2(process.env.QRING_AUDIT_DIR, { recursive: true, mode: 448 });
+    if (!existsSync2(process.env.QRING_AUDIT_DIR)) {
+      mkdirSync3(process.env.QRING_AUDIT_DIR, { recursive: true, mode: 448 });
     }
     return process.env.QRING_AUDIT_DIR;
   }
-  const dir = join4(homedir2(), ".config", "q-ring");
-  if (!existsSync(dir)) {
-    mkdirSync2(dir, { recursive: true, mode: 448 });
+  const dir = join5(homedir3(), ".config", "q-ring");
+  if (!existsSync2(dir)) {
+    mkdirSync3(dir, { recursive: true, mode: 448 });
   }
   return dir;
 }
 function getAuditPath() {
-  return join4(getAuditDir(), "audit.jsonl");
+  return join5(getAuditDir(), "audit.jsonl");
 }
 function getLastLineHash() {
   const path = getAuditPath();
-  if (!existsSync(path)) return void 0;
+  if (!existsSync2(path)) return void 0;
   try {
     const fd = openSync(path, "r");
     const stat = fstatSync(fd);
@@ -454,7 +616,7 @@ function logAudit(event) {
         const path = getAuditPath();
         appendFileSync(path, line + "\n", { mode: 384 });
         try {
-          chmodSync(path, 384);
+          chmodSync2(path, 384);
         } catch {
         }
         const key = getAuditKey();
@@ -468,7 +630,7 @@ function logAudit(event) {
 var MAX_AUDIT_BYTES = 12 * 1024 * 1024;
 function queryAudit(query = {}) {
   const path = getAuditPath();
-  if (!existsSync(path)) return [];
+  if (!existsSync2(path)) return [];
   try {
     const st = statSync3(path);
     const readStart = st.size > MAX_AUDIT_BYTES ? st.size - MAX_AUDIT_BYTES : 0;
@@ -509,10 +671,10 @@ function queryAudit(query = {}) {
 }
 function verifyAuditChain() {
   const path = getAuditPath();
-  if (!existsSync(path)) {
+  if (!existsSync2(path)) {
     return { totalEvents: 0, validEvents: 0, intact: true };
   }
-  const lines = readFileSync4(path, "utf8").split("\n").filter((l) => l.trim());
+  const lines = readFileSync5(path, "utf8").split("\n").filter((l) => l.trim());
   if (lines.length === 0) {
     return { totalEvents: 0, validEvents: 0, intact: true };
   }
@@ -563,8 +725,8 @@ function verifyAuditChain() {
 }
 function exportAudit(opts = {}) {
   const path = getAuditPath();
-  if (!existsSync(path)) return opts.format === "json" ? "[]" : "";
-  const lines = readFileSync4(path, "utf8").split("\n").filter((l) => l.trim());
+  if (!existsSync2(path)) return opts.format === "json" ? "[]" : "";
+  const lines = readFileSync5(path, "utf8").split("\n").filter((l) => l.trim());
   let events = lines.map((l) => {
     try {
       return JSON.parse(l);
@@ -629,15 +791,15 @@ function detectAnomalies(key) {
 }
 
 // src/core/entanglement.ts
-import { existsSync as existsSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3 } from "fs";
-import { join as join5 } from "path";
-import { homedir as homedir3 } from "os";
+import { existsSync as existsSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "fs";
+import { join as join6 } from "path";
+import { homedir as homedir4 } from "os";
 
 // src/utils/registry.ts
-import { existsSync as existsSync2, readFileSync as readFileSync5, renameSync } from "fs";
+import { existsSync as existsSync3, readFileSync as readFileSync6, renameSync } from "fs";
 function loadJsonRegistry(path, empty) {
-  if (!existsSync2(path)) return empty;
-  const raw = readFileSync5(path, "utf8");
+  if (!existsSync3(path)) return empty;
+  const raw = readFileSync6(path, "utf8");
   try {
     return JSON.parse(raw);
   } catch (err) {
@@ -661,18 +823,18 @@ function loadJsonRegistry(path, empty) {
 // src/core/entanglement.ts
 var REGISTRY_VERSION = 1;
 function getRegistryPath() {
-  const dir = join5(homedir3(), ".config", "q-ring");
-  if (!existsSync3(dir)) {
-    mkdirSync3(dir, { recursive: true, mode: 448 });
+  const dir = join6(homedir4(), ".config", "q-ring");
+  if (!existsSync4(dir)) {
+    mkdirSync4(dir, { recursive: true, mode: 448 });
   }
-  return join5(dir, "entanglement.json");
+  return join6(dir, "entanglement.json");
 }
 function loadRegistry() {
   return loadJsonRegistry(getRegistryPath(), { pairs: [] });
 }
 function saveRegistry(registry2) {
   registry2.version = REGISTRY_VERSION;
-  writeFileSync2(getRegistryPath(), JSON.stringify(registry2, null, 2), {
+  writeFileSync3(getRegistryPath(), JSON.stringify(registry2, null, 2), {
     mode: 384
   });
 }
@@ -706,9 +868,9 @@ function listEntanglements() {
 }
 
 // src/core/hooks.ts
-import { existsSync as existsSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "fs";
-import { join as join6 } from "path";
-import { homedir as homedir4 } from "os";
+import { existsSync as existsSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir5 } from "os";
 import { execFile, spawn } from "child_process";
 import { randomUUID } from "crypto";
 
@@ -932,17 +1094,17 @@ function httpRequest(opts) {
 
 // src/core/hooks.ts
 function getRegistryPath2() {
-  const dir = join6(homedir4(), ".config", "q-ring");
-  if (!existsSync4(dir)) {
-    mkdirSync4(dir, { recursive: true, mode: 448 });
+  const dir = join7(homedir5(), ".config", "q-ring");
+  if (!existsSync5(dir)) {
+    mkdirSync5(dir, { recursive: true, mode: 448 });
   }
-  return join6(dir, "hooks.json");
+  return join7(dir, "hooks.json");
 }
 function loadRegistry2() {
   return loadJsonRegistry(getRegistryPath2(), { hooks: [] });
 }
 function saveRegistry2(registry2) {
-  writeFileSync3(getRegistryPath2(), JSON.stringify(registry2, null, 2), {
+  writeFileSync4(getRegistryPath2(), JSON.stringify(registry2, null, 2), {
     mode: 384
   });
 }
@@ -1189,19 +1351,19 @@ async function fireHooks(payload, tags) {
 }
 
 // src/core/approval.ts
-import { existsSync as existsSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5 } from "fs";
-import { join as join7 } from "path";
-import { homedir as homedir5 } from "os";
-import { createHmac as createHmac2, randomBytes as randomBytes2, timingSafeEqual } from "crypto";
+import { existsSync as existsSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6 } from "fs";
+import { join as join8 } from "path";
+import { homedir as homedir6 } from "os";
+import { createHmac as createHmac2, randomBytes as randomBytes3, timingSafeEqual } from "crypto";
 function getHmacSecret() {
-  const dir = join7(homedir5(), ".config", "q-ring");
-  const secretPath = join7(dir, ".approval-key");
-  if (!existsSync5(dir)) mkdirSync5(dir, { recursive: true, mode: 448 });
-  if (existsSync5(secretPath)) {
-    return readFileSync6(secretPath, "utf8").trim();
-  }
-  const secret = randomBytes2(32).toString("hex");
-  writeFileSync4(secretPath, secret, { mode: 384 });
+  const dir = join8(homedir6(), ".config", "q-ring");
+  const secretPath = join8(dir, ".approval-key");
+  if (!existsSync6(dir)) mkdirSync6(dir, { recursive: true, mode: 448 });
+  if (existsSync6(secretPath)) {
+    return readFileSync7(secretPath, "utf8").trim();
+  }
+  const secret = randomBytes3(32).toString("hex");
+  writeFileSync5(secretPath, secret, { mode: 384 });
   return secret;
 }
 function computeHmac(entry) {
@@ -1231,11 +1393,11 @@ function verifyHmac(entry) {
   }
 }
 function getRegistryPath3() {
-  const dir = join7(homedir5(), ".config", "q-ring");
-  if (!existsSync5(dir)) {
-    mkdirSync5(dir, { recursive: true, mode: 448 });
+  const dir = join8(homedir6(), ".config", "q-ring");
+  if (!existsSync6(dir)) {
+    mkdirSync6(dir, { recursive: true, mode: 448 });
   }
-  return join7(dir, "approvals.json");
+  return join8(dir, "approvals.json");
 }
 function loadRegistry3() {
   return loadJsonRegistry(getRegistryPath3(), { approvals: [] });
@@ -1262,7 +1424,7 @@ function listApprovals() {
 
 // src/core/policy.ts
 import { statSync as statSync4 } from "fs";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 import { z as z2 } from "zod";
 var stringArray = z2.array(z2.string());
 var mcpPolicySchema = z2.object({
@@ -1308,7 +1470,7 @@ function resolvePolicyPath(projectPath) {
 }
 function configMtime(pp) {
   try {
-    return statSync4(join8(pp, ".q-ring.json")).mtimeMs;
+    return statSync4(join9(pp, ".q-ring.json")).mtimeMs;
   } catch {
     return 0;
   }
@@ -1331,7 +1493,7 @@ function loadPolicy(projectPath) {
   if (!parsed.success) {
     const issues = parsed.error.issues.map((i) => `policy${i.path.length ? "." + i.path.join(".") : ""}: ${i.message}`).join("; ");
     const error = new PolicyConfigError(
-      `Invalid policy in ${join8(pp, ".q-ring.json")} \u2014 refusing to run under an unparseable security policy (fail closed). Fix these and retry: ${issues}`
+      `Invalid policy in ${join9(pp, ".q-ring.json")} \u2014 refusing to run under an unparseable security policy (fail closed). Fix these and retry: ${issues}`
     );
     console.error(`q-ring: ${error.message}`);
     cachedPolicy = { path: pp, mtimeMs, error };
@@ -1466,9 +1628,6 @@ function getPolicySummary(projectPath) {
   };
 }
 
-// src/core/keyring.ts
-import { Entry as Entry2, findCredentials } from "@napi-rs/keyring";
-
 // src/utils/hash.ts
 import { createHash as createHash2 } from "crypto";
 function hashProjectPath(projectPath) {
@@ -1524,6 +1683,50 @@ function serviceForScope(scope, opts = {}) {
   return resolveScope({ ...opts, scope })[0].service;
 }
 
+// src/core/notify.ts
+import { spawn as spawn2 } from "child_process";
+var DISABLE_ENV = "QRING_NOTIFY";
+var THROTTLE_MS = 5 * 60 * 1e3;
+var lastNotified = /* @__PURE__ */ new Map();
+function notificationsEnabled() {
+  const value = process.env[DISABLE_ENV];
+  return value !== "off" && value !== "0" && value !== "false";
+}
+function notifyUser(title, body) {
+  try {
+    let command;
+    let args;
+    if (process.platform === "linux") {
+      command = "notify-send";
+      args = ["--app-name=q-ring", "--urgency=critical", title, body];
+    } else if (process.platform === "darwin") {
+      command = "osascript";
+      const clean = (s) => s.replace(/["\\]/g, "");
+      args = ["-e", `display notification "${clean(body)}" with title "${clean(title)}"`];
+    } else {
+      return false;
+    }
+    const child = spawn2(command, args, { detached: true, stdio: "ignore" });
+    child.on("error", () => {
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function notifyApprovalRequested(key, source) {
+  if (!notificationsEnabled()) return;
+  const now = Date.now();
+  const last = lastNotified.get(key);
+  if (last !== void 0 && now - last < THROTTLE_MS) return;
+  lastNotified.set(key, now);
+  notifyUser(
+    "q-ring: approval requested",
+    `An ${source} agent wants to read "${key}". Allow with: qring approve ${key}`
+  );
+}
+
 // src/core/provision.ts
 import { execFileSync, spawnSync } from "child_process";
 import { z as z3 } from "zod";
@@ -1676,14 +1879,14 @@ function withJitEnvelopeLock(service, key, fn) {
   return withFileLock(`${service}\0${key}`, fn, { dir: "jit-locks" });
 }
 function readEnvelope(service, key) {
-  const entry = new Entry2(service, key);
+  const entry = new Entry(service, key);
   const raw = entry.getPassword();
   if (raw === null) return null;
   const envelope = parseEnvelope(raw);
   return envelope ?? wrapLegacy(raw);
 }
 function writeEnvelope(service, key, envelope) {
-  const entry = new Entry2(service, key);
+  const entry = new Entry(service, key);
   entry.setPassword(serializeEnvelope(envelope));
 }
 function resolveEnv(opts) {
@@ -1760,6 +1963,7 @@ function getSecret(key, opts = {}) {
             source,
             detail: "blocked: requires user approval"
           });
+          notifyApprovalRequested(key, source);
         }
         throw new Error(`Access Denied: This secret requires user approval. Please ask the user to run 'qring approve ${key}'`);
       }
@@ -1941,7 +2145,7 @@ function deleteSecret(key, opts = {}) {
   }
   let deleted = false;
   for (const { service, scope } of scopes) {
-    const entry = new Entry2(service, key);
+    const entry = new Entry(service, key);
     try {
       if (entry.deleteCredential()) {
         deleted = true;
@@ -2121,7 +2325,7 @@ function disentangleSecrets(sourceKey, sourceOpts, targetKey, targetOpts) {
 }
 
 // src/core/tunnel.ts
-import { randomBytes as randomBytes3 } from "crypto";
+import { randomBytes as randomBytes4 } from "crypto";
 var tunnelStore = /* @__PURE__ */ new Map();
 var cleanupInterval = null;
 function ensureCleanup() {
@@ -2143,7 +2347,7 @@ function ensureCleanup() {
   }
 }
 function tunnelCreate(value, opts = {}) {
-  const id = `tun_${Date.now().toString(36)}_${randomBytes3(6).toString("base64url")}`;
+  const id = `tun_${Date.now().toString(36)}_${randomBytes4(6).toString("base64url")}`;
   const now = Date.now();
   tunnelStore.set(id, {
     value,
@@ -2193,40 +2397,39 @@ function tunnelList() {
 }
 
 // src/core/memory.ts
-import { existsSync as existsSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync5, mkdirSync as mkdirSync6, chmodSync as chmodSync2 } from "fs";
-import { join as join9 } from "path";
-import { homedir as homedir6, hostname, userInfo } from "os";
+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 {
-  createCipheriv,
-  createDecipheriv,
+  createCipheriv as createCipheriv2,
+  createDecipheriv as createDecipheriv2,
   createHash as createHash3,
-  randomBytes as randomBytes4,
-  pbkdf2Sync
+  randomBytes as randomBytes5,
+  pbkdf2Sync as pbkdf2Sync2
 } from "crypto";
-import { Entry as Entry3 } from "@napi-rs/keyring";
 var MEMORY_FILE = "agent-memory.enc";
 var KEYRING_SERVICE = "qring-memory-key";
 var KEYRING_ACCOUNT = "encryption-key";
 function getMemoryDir() {
-  const dir = join9(homedir6(), ".config", "q-ring");
-  if (!existsSync6(dir)) {
-    mkdirSync6(dir, { recursive: true, mode: 448 });
+  const dir = join10(homedir7(), ".config", "q-ring");
+  if (!existsSync7(dir)) {
+    mkdirSync7(dir, { recursive: true, mode: 448 });
   }
   return dir;
 }
 function writeMemoryFile(path, data) {
-  writeFileSync5(path, data, { mode: 384 });
+  writeFileSync6(path, data, { mode: 384 });
   try {
-    chmodSync2(path, 384);
+    chmodSync3(path, 384);
   } catch {
   }
 }
 function getMemoryPath() {
-  return join9(getMemoryDir(), MEMORY_FILE);
+  return join10(getMemoryDir(), MEMORY_FILE);
 }
-var PBKDF2_ITERATIONS = 21e4;
-var KEY_LENGTH = 32;
-var PASSPHRASE_ENV = "QRING_MEMORY_PASSPHRASE";
+var PBKDF2_ITERATIONS2 = 21e4;
+var KEY_LENGTH2 = 32;
+var PASSPHRASE_ENV2 = "QRING_MEMORY_PASSPHRASE";
 var V2_PREFIX = "qmem2";
 var MemoryKeyUnavailableError = class extends Error {
   constructor(message) {
@@ -2238,19 +2441,19 @@ function deriveLegacyKey() {
   const fingerprint = `qring-memory:${hostname()}:${userInfo().username}`;
   return createHash3("sha256").update(fingerprint).digest();
 }
-function passphrase() {
-  const p = process.env[PASSPHRASE_ENV];
+function passphrase2() {
+  const p = process.env[PASSPHRASE_ENV2];
   return p && p.length > 0 ? p : void 0;
 }
 function derivePassphraseKey(salt) {
-  return pbkdf2Sync(passphrase(), salt, PBKDF2_ITERATIONS, KEY_LENGTH, "sha512");
+  return pbkdf2Sync2(passphrase2(), salt, PBKDF2_ITERATIONS2, KEY_LENGTH2, "sha512");
 }
 function keyringKey() {
   try {
-    const entry = new Entry3(KEYRING_SERVICE, KEYRING_ACCOUNT);
+    const entry = new Entry(KEYRING_SERVICE, KEYRING_ACCOUNT);
     const stored = entry.getPassword();
     if (stored) return Buffer.from(stored, "base64");
-    const key = randomBytes4(KEY_LENGTH);
+    const key = randomBytes5(KEY_LENGTH2);
     entry.setPassword(key.toString("base64"));
     return key;
   } catch {
@@ -2258,8 +2461,8 @@ function keyringKey() {
   }
 }
 function encryptWith(data, key) {
-  const iv = randomBytes4(12);
-  const cipher = createCipheriv("aes-256-gcm", key, iv);
+  const iv = randomBytes5(12);
+  const cipher = createCipheriv2("aes-256-gcm", key, iv);
   const encrypted = Buffer.concat([cipher.update(data, "utf8"), cipher.final()]);
   const tag = cipher.getAuthTag();
   return `${iv.toString("base64")}:${tag.toString("base64")}:${encrypted.toString("base64")}`;
@@ -2270,27 +2473,27 @@ function decryptWith(blob, key) {
   const iv = Buffer.from(parts[0], "base64");
   const tag = Buffer.from(parts[1], "base64");
   const encrypted = Buffer.from(parts[2], "base64");
-  const decipher = createDecipheriv("aes-256-gcm", key, iv);
+  const decipher = createDecipheriv2("aes-256-gcm", key, iv);
   decipher.setAuthTag(tag);
   return decipher.update(encrypted) + decipher.final("utf8");
 }
 function encrypt(data) {
   const kk = keyringKey();
   if (kk) return encryptWith(data, kk);
-  if (passphrase()) {
-    const salt = randomBytes4(16);
+  if (passphrase2()) {
+    const salt = randomBytes5(16);
     const key = derivePassphraseKey(salt);
     return `${V2_PREFIX}:${salt.toString("base64")}:${encryptWith(data, key)}`;
   }
   throw new MemoryKeyUnavailableError(
-    `Cannot persist agent memory: the OS keyring is unavailable and ${PASSPHRASE_ENV} is not set. Refusing to encrypt with a machine-derivable key (any local process could recompute it and read your memory). Set ${PASSPHRASE_ENV} to a strong passphrase, or run on a host with an OS keyring.`
+    `Cannot persist agent memory: the OS keyring is unavailable and ${PASSPHRASE_ENV2} is not set. Refusing to encrypt with a machine-derivable key (any local process could recompute it and read your memory). Set ${PASSPHRASE_ENV2} to a strong passphrase, or run on a host with an OS keyring.`
   );
 }
 function decrypt(blob) {
   if (blob.startsWith(`${V2_PREFIX}:`)) {
-    if (!passphrase()) {
+    if (!passphrase2()) {
       throw new MemoryKeyUnavailableError(
-        `Agent memory was encrypted with ${PASSPHRASE_ENV} but it is not set \u2014 cannot decrypt.`
+        `Agent memory was encrypted with ${PASSPHRASE_ENV2} but it is not set \u2014 cannot decrypt.`
       );
     }
     const rest = blob.slice(V2_PREFIX.length + 1);
@@ -2314,13 +2517,13 @@ function decrypt(blob) {
   }
   return plain;
 }
-function loadStore() {
+function loadStore2() {
   const path = getMemoryPath();
-  if (!existsSync6(path)) {
+  if (!existsSync7(path)) {
     return { entries: {} };
   }
   try {
-    const raw = readFileSync7(path, "utf8");
+    const raw = readFileSync8(path, "utf8");
     const decrypted = decrypt(raw);
     return JSON.parse(decrypted);
   } catch (err) {
@@ -2330,35 +2533,35 @@ function loadStore() {
     return { entries: {} };
   }
 }
-function saveStore(store) {
+function saveStore2(store) {
   const json = JSON.stringify(store);
   const encrypted = encrypt(json);
   writeMemoryFile(getMemoryPath(), encrypted);
 }
 function remember(key, value) {
-  const store = loadStore();
+  const store = loadStore2();
   store.entries[key] = {
     value,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  saveStore(store);
+  saveStore2(store);
 }
 function recall(key) {
-  const store = loadStore();
+  const store = loadStore2();
   return store.entries[key]?.value ?? null;
 }
 function listMemory() {
-  const store = loadStore();
+  const store = loadStore2();
   return Object.entries(store.entries).map(([key, entry]) => ({
     key,
     updatedAt: entry.updatedAt
   }));
 }
 function forget(key) {
-  const store = loadStore();
+  const store = loadStore2();
   if (key in store.entries) {
     delete store.entries[key];
-    saveStore(store);
+    saveStore2(store);
     return true;
   }
   return false;
@@ -2407,4 +2610,4 @@ export {
   listMemory,
   forget
 };
-//# sourceMappingURL=chunk-NNIEXAW5.js.map
+//# sourceMappingURL=chunk-TPPPTL4J.js.map