@remnic/core 1.1.12 → 1.1.14

package/dist/chunk-MSWG7JI6.js

@@ -0,0 +1,237 @@
+import {
+  resolveHomeDir
+} from "./chunk-XIG5PDM7.js";
+
+// src/tokens.ts
+import fs from "fs";
+import path from "path";
+import { randomBytes, randomUUID } from "crypto";
+var TOKEN_PREFIXES = {
+  "openclaw": "remnic_oc_",
+  "claude-code": "remnic_cc_",
+  "codex-cli": "remnic_cx_",
+  "codex": "remnic_cx_",
+  "hermes": "remnic_hm_",
+  "pi": "remnic_pi_",
+  "replit": "remnic_rl_",
+  "cursor": "remnic_cu_",
+  "cline": "remnic_cl_",
+  "github-copilot": "remnic_gh_",
+  "roo-code": "remnic_rc_",
+  "windsurf": "remnic_ws_",
+  "amp": "remnic_am_",
+  "generic-mcp": "remnic_gm_"
+};
+function defaultTokensPath() {
+  return path.join(resolveHomeDir(), ".remnic", "tokens.json");
+}
+function legacyTokensPath() {
+  return path.join(resolveHomeDir(), ".engram", "tokens.json");
+}
+function resolveReadPath(tokensPath) {
+  const primary = tokensPath ?? defaultTokensPath();
+  if (tokensPath) return primary;
+  if (fs.existsSync(primary)) return primary;
+  const legacy = legacyTokensPath();
+  return fs.existsSync(legacy) ? legacy : primary;
+}
+function ensureDir(filePath) {
+  const dir = path.dirname(filePath);
+  fs.mkdirSync(dir, { recursive: true });
+}
+function isEnoent(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function validateTokenEntry(raw, index) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new Error(`invalid token entry at index ${index}: expected object`);
+  }
+  const entry = raw;
+  if (typeof entry.token !== "string" || entry.token.length === 0) {
+    throw new Error(`invalid token entry at index ${index}: token must be a non-empty string`);
+  }
+  if (typeof entry.connector !== "string" || entry.connector.length === 0) {
+    throw new Error(`invalid token entry at index ${index}: connector must be a non-empty string`);
+  }
+  return {
+    token: entry.token,
+    connector: entry.connector,
+    createdAt: typeof entry.createdAt === "string" && entry.createdAt.length > 0 ? entry.createdAt : (/* @__PURE__ */ new Date(0)).toISOString()
+  };
+}
+function parseTokenStore(rawText, filePath) {
+  let raw;
+  try {
+    raw = JSON.parse(rawText);
+  } catch (error) {
+    throw new Error(
+      `failed to parse token store at ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (typeof raw === "object" && raw !== null && !Array.isArray(raw)) {
+    const record = raw;
+    if (record.tokens !== void 0) {
+      if (!Array.isArray(record.tokens)) {
+        throw new Error(`invalid token store at ${filePath}: tokens must be an array`);
+      }
+      return {
+        store: {
+          tokens: record.tokens.map((entry, index) => validateTokenEntry(entry, index))
+        },
+        migratedLegacy: false
+      };
+    }
+    const migrated = [];
+    for (const [key, value] of Object.entries(record)) {
+      if (typeof value === "string" && value.length > 0) {
+        migrated.push(
+          validateTokenEntry(
+            { token: value, connector: key, createdAt: (/* @__PURE__ */ new Date()).toISOString() },
+            migrated.length
+          )
+        );
+      }
+    }
+    if (migrated.length > 0) {
+      return { store: { tokens: migrated }, migratedLegacy: true };
+    }
+  }
+  throw new Error(`invalid token store at ${filePath}: expected token array or legacy connector map`);
+}
+function loadTokenStore(tokensPath) {
+  const p = resolveReadPath(tokensPath);
+  try {
+    const rawText = fs.readFileSync(p, "utf8");
+    const { store, migratedLegacy } = parseTokenStore(rawText, p);
+    if (migratedLegacy) {
+      try {
+        saveTokenStore(store, tokensPath);
+      } catch {
+      }
+    }
+    return store;
+  } catch (error) {
+    if (isEnoent(error)) {
+      return { tokens: [] };
+    }
+    throw error;
+  }
+}
+function fsyncDirectoryBestEffort(dirPath) {
+  let dirFd = null;
+  try {
+    dirFd = fs.openSync(dirPath, "r");
+    fs.fsyncSync(dirFd);
+  } catch {
+  } finally {
+    if (dirFd !== null) {
+      try {
+        fs.closeSync(dirFd);
+      } catch {
+      }
+    }
+  }
+}
+function saveTokenStore(store, tokensPath) {
+  const p = tokensPath ?? defaultTokensPath();
+  ensureDir(p);
+  const validated = {
+    tokens: store.tokens.map((entry, index) => validateTokenEntry(entry, index))
+  };
+  const dir = path.dirname(p);
+  const tmpPath = path.join(dir, `.${path.basename(p)}.${process.pid}.${randomUUID()}.tmp`);
+  let fd = null;
+  try {
+    fd = fs.openSync(tmpPath, "w", 384);
+    fs.writeFileSync(fd, JSON.stringify(validated, null, 2) + "\n", "utf8");
+    fs.fsyncSync(fd);
+    fs.closeSync(fd);
+    fd = null;
+    fs.renameSync(tmpPath, p);
+    try {
+      fs.chmodSync(p, 384);
+    } catch {
+    }
+    fsyncDirectoryBestEffort(dir);
+  } catch (error) {
+    if (fd !== null) {
+      try {
+        fs.closeSync(fd);
+      } catch {
+      }
+    }
+    try {
+      fs.rmSync(tmpPath, { force: true });
+    } catch {
+    }
+    throw error;
+  }
+}
+function buildTokenEntry(connector) {
+  const prefix = TOKEN_PREFIXES[connector] ?? "remnic_xx_";
+  const token = prefix + randomBytes(24).toString("hex");
+  return {
+    token,
+    connector,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function commitTokenEntry(entry, tokensPath) {
+  const store = loadTokenStore(tokensPath);
+  store.tokens = store.tokens.filter((t) => t.connector !== entry.connector);
+  store.tokens.push(entry);
+  saveTokenStore(store, tokensPath);
+}
+function generateToken(connector, tokensPath) {
+  const store = loadTokenStore(tokensPath);
+  store.tokens = store.tokens.filter((t) => t.connector !== connector);
+  const entry = buildTokenEntry(connector);
+  store.tokens.push(entry);
+  saveTokenStore(store, tokensPath);
+  return entry;
+}
+function listTokens(tokensPath) {
+  return loadTokenStore(tokensPath).tokens;
+}
+function revokeToken(connector, tokensPath) {
+  const store = loadTokenStore(tokensPath);
+  const before = store.tokens.length;
+  store.tokens = store.tokens.filter((t) => t.connector !== connector);
+  if (store.tokens.length < before) {
+    saveTokenStore(store, tokensPath);
+    return true;
+  }
+  return false;
+}
+function getAllValidTokens(tokensPath) {
+  return loadTokenStore(tokensPath).tokens.map((t) => t.token);
+}
+var TOKEN_CACHE_TTL_MS = 5e3;
+var _cachedTokens = [];
+var _cachedAt = 0;
+var _cachedPath;
+function getAllValidTokensCached(tokensPath) {
+  const now = Date.now();
+  if (now - _cachedAt < TOKEN_CACHE_TTL_MS && tokensPath === _cachedPath) return _cachedTokens;
+  _cachedTokens = getAllValidTokens(tokensPath);
+  _cachedAt = now;
+  _cachedPath = tokensPath;
+  return _cachedTokens;
+}
+function resolveConnectorFromToken(token, tokensPath) {
+  return loadTokenStore(tokensPath).tokens.find((t) => t.token === token)?.connector;
+}
+
+export {
+  loadTokenStore,
+  saveTokenStore,
+  buildTokenEntry,
+  commitTokenEntry,
+  generateToken,
+  listTokens,
+  revokeToken,
+  getAllValidTokens,
+  getAllValidTokensCached,
+  resolveConnectorFromToken
+};
+//# sourceMappingURL=chunk-MSWG7JI6.js.map

package/dist/chunk-MSWG7JI6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tokens.ts"],"sourcesContent":["/**\n * Token management for Remnic multi-connector auth.\n *\n * Manages per-connector tokens in ~/.remnic/tokens.json.\n * Each connector gets a unique token with a recognizable prefix.\n */\n\nimport fs from \"node:fs\";\nimport path from \"node:path\";\nimport { randomBytes, randomUUID } from \"node:crypto\";\nimport { resolveHomeDir } from \"./runtime/env.js\";\n\nexport interface TokenEntry {\n  token: string;\n  connector: string;\n  createdAt: string;\n}\n\nexport interface TokenStore {\n  tokens: TokenEntry[];\n}\n\nconst TOKEN_PREFIXES: Record<string, string> = {\n  \"openclaw\": \"remnic_oc_\",\n  \"claude-code\": \"remnic_cc_\",\n  \"codex-cli\": \"remnic_cx_\",\n  \"codex\": \"remnic_cx_\",\n  \"hermes\": \"remnic_hm_\",\n  \"pi\": \"remnic_pi_\",\n  \"replit\": \"remnic_rl_\",\n  \"cursor\": \"remnic_cu_\",\n  \"cline\": \"remnic_cl_\",\n  \"github-copilot\": \"remnic_gh_\",\n  \"roo-code\": \"remnic_rc_\",\n  \"windsurf\": \"remnic_ws_\",\n  \"amp\": \"remnic_am_\",\n  \"generic-mcp\": \"remnic_gm_\",\n};\n\nfunction defaultTokensPath(): string {\n  return path.join(resolveHomeDir(), \".remnic\", \"tokens.json\");\n}\n\nfunction legacyTokensPath(): string {\n  return path.join(resolveHomeDir(), \".engram\", \"tokens.json\");\n}\n\nfunction resolveReadPath(tokensPath?: string): string {\n  const primary = tokensPath ?? defaultTokensPath();\n  if (tokensPath) return primary;\n  if (fs.existsSync(primary)) return primary;\n  const legacy = legacyTokensPath();\n  return fs.existsSync(legacy) ? legacy : primary;\n}\n\nfunction ensureDir(filePath: string): void {\n  const dir = path.dirname(filePath);\n  fs.mkdirSync(dir, { recursive: true });\n}\n\nfunction isEnoent(error: unknown): boolean {\n  return error instanceof Error && \"code\" in error && (error as NodeJS.ErrnoException).code === \"ENOENT\";\n}\n\nfunction validateTokenEntry(raw: unknown, index: number): TokenEntry {\n  if (typeof raw !== \"object\" || raw === null || Array.isArray(raw)) {\n    throw new Error(`invalid token entry at index ${index}: expected object`);\n  }\n  const entry = raw as Record<string, unknown>;\n  if (typeof entry.token !== \"string\" || entry.token.length === 0) {\n    throw new Error(`invalid token entry at index ${index}: token must be a non-empty string`);\n  }\n  if (typeof entry.connector !== \"string\" || entry.connector.length === 0) {\n    throw new Error(`invalid token entry at index ${index}: connector must be a non-empty string`);\n  }\n  return {\n    token: entry.token,\n    connector: entry.connector,\n    createdAt:\n      typeof entry.createdAt === \"string\" && entry.createdAt.length > 0\n        ? entry.createdAt\n        : new Date(0).toISOString(),\n  };\n}\n\nfunction parseTokenStore(rawText: string, filePath: string): { store: TokenStore; migratedLegacy: boolean } {\n  let raw: unknown;\n  try {\n    raw = JSON.parse(rawText);\n  } catch (error) {\n    throw new Error(\n      `failed to parse token store at ${filePath}: ${error instanceof Error ? error.message : String(error)}`,\n    );\n  }\n\n  if (typeof raw === \"object\" && raw !== null && !Array.isArray(raw)) {\n    const record = raw as Record<string, unknown>;\n    if (record.tokens !== undefined) {\n      if (!Array.isArray(record.tokens)) {\n        throw new Error(`invalid token store at ${filePath}: tokens must be an array`);\n      }\n      return {\n        store: {\n          tokens: record.tokens.map((entry, index) => validateTokenEntry(entry, index)),\n        },\n        migratedLegacy: false,\n      };\n    }\n\n    // Migrate legacy flat-map format: { \"connector\": \"token_value\", ... }\n    const migrated: TokenEntry[] = [];\n    for (const [key, value] of Object.entries(record)) {\n      if (typeof value === \"string\" && value.length > 0) {\n        migrated.push(\n          validateTokenEntry(\n            { token: value, connector: key, createdAt: new Date().toISOString() },\n            migrated.length,\n          ),\n        );\n      }\n    }\n    if (migrated.length > 0) {\n      return { store: { tokens: migrated }, migratedLegacy: true };\n    }\n  }\n\n  throw new Error(`invalid token store at ${filePath}: expected token array or legacy connector map`);\n}\n\nexport function loadTokenStore(tokensPath?: string): TokenStore {\n  const p = resolveReadPath(tokensPath);\n  try {\n    const rawText = fs.readFileSync(p, \"utf8\");\n    const { store, migratedLegacy } = parseTokenStore(rawText, p);\n    if (migratedLegacy) {\n      // Auto-migrate legacy flat-map stores in new format. This is best-effort:\n      // a migration write failure must not hide the successfully parsed tokens.\n      try {\n        saveTokenStore(store, tokensPath);\n      } catch {\n        // Migration write failed (e.g., read-only fs) — still return parsed tokens.\n      }\n    }\n    return store;\n  } catch (error) {\n    if (isEnoent(error)) {\n      return { tokens: [] };\n    }\n    throw error;\n  }\n}\n\nfunction fsyncDirectoryBestEffort(dirPath: string): void {\n  let dirFd: number | null = null;\n  try {\n    dirFd = fs.openSync(dirPath, \"r\");\n    fs.fsyncSync(dirFd);\n  } catch {\n    // Directory fsync is not supported on every platform/filesystem.\n  } finally {\n    if (dirFd !== null) {\n      try { fs.closeSync(dirFd); } catch { /* ignore */ }\n    }\n  }\n}\n\nexport function saveTokenStore(store: TokenStore, tokensPath?: string): void {\n  const p = tokensPath ?? defaultTokensPath();\n  ensureDir(p);\n  const validated: TokenStore = {\n    tokens: store.tokens.map((entry, index) => validateTokenEntry(entry, index)),\n  };\n  const dir = path.dirname(p);\n  const tmpPath = path.join(dir, `.${path.basename(p)}.${process.pid}.${randomUUID()}.tmp`);\n  let fd: number | null = null;\n  try {\n    fd = fs.openSync(tmpPath, \"w\", 0o600);\n    fs.writeFileSync(fd, JSON.stringify(validated, null, 2) + \"\\n\", \"utf8\");\n    fs.fsyncSync(fd);\n    fs.closeSync(fd);\n    fd = null;\n    fs.renameSync(tmpPath, p);\n    // Tighten permissions on pre-existing files after atomic replacement.\n    try { fs.chmodSync(p, 0o600); } catch { /* ignore on platforms without chmod */ }\n    fsyncDirectoryBestEffort(dir);\n  } catch (error) {\n    if (fd !== null) {\n      try { fs.closeSync(fd); } catch { /* ignore */ }\n    }\n    try { fs.rmSync(tmpPath, { force: true }); } catch { /* ignore cleanup failure */ }\n    throw error;\n  }\n}\n\n/**\n * Build a TokenEntry candidate WITHOUT saving it to the store.\n * Callers use this when they need to defer the save until after a\n * dependent write (e.g. Hermes config.yaml) succeeds — see\n * commitTokenEntry() to persist the candidate.\n */\nexport function buildTokenEntry(connector: string): TokenEntry {\n  const prefix = TOKEN_PREFIXES[connector] ?? \"remnic_xx_\";\n  const token = prefix + randomBytes(24).toString(\"hex\");\n  return {\n    token,\n    connector,\n    createdAt: new Date().toISOString(),\n  };\n}\n\n/**\n * Persist a pre-built TokenEntry into the store, replacing any existing\n * entry for the same connector. Used together with buildTokenEntry() when\n * the caller wants to defer the save until after a dependent write succeeds.\n *\n * For transactional rollback, callers should snapshot the full store via\n * loadTokenStore() BEFORE calling commitTokenEntry() and restore it with\n * saveTokenStore() on failure. A full-store snapshot handles partial writes\n * of tokens.json atomically — single-entry restore via the return value is\n * insufficient because if this function throws during saveTokenStore, the\n * return statement never executes (UXJI/UXJT fix).\n */\nexport function commitTokenEntry(entry: TokenEntry, tokensPath?: string): void {\n  const store = loadTokenStore(tokensPath);\n  store.tokens = store.tokens.filter((t) => t.connector !== entry.connector);\n  store.tokens.push(entry);\n  saveTokenStore(store, tokensPath);\n}\n\nexport function generateToken(connector: string, tokensPath?: string): TokenEntry {\n  const store = loadTokenStore(tokensPath);\n\n  // Remove existing token for this connector\n  store.tokens = store.tokens.filter((t) => t.connector !== connector);\n\n  const entry = buildTokenEntry(connector);\n  store.tokens.push(entry);\n  saveTokenStore(store, tokensPath);\n  return entry;\n}\n\nexport function listTokens(tokensPath?: string): TokenEntry[] {\n  return loadTokenStore(tokensPath).tokens;\n}\n\nexport function revokeToken(connector: string, tokensPath?: string): boolean {\n  const store = loadTokenStore(tokensPath);\n  const before = store.tokens.length;\n  store.tokens = store.tokens.filter((t) => t.connector !== connector);\n  if (store.tokens.length < before) {\n    saveTokenStore(store, tokensPath);\n    return true;\n  }\n  return false;\n}\n\nexport function getAllValidTokens(tokensPath?: string): string[] {\n  return loadTokenStore(tokensPath).tokens.map((t) => t.token);\n}\n\n// Cached token loader to avoid synchronous disk I/O on every HTTP request.\n// Re-reads tokens.json at most once per TTL interval (default 5s).\nconst TOKEN_CACHE_TTL_MS = 5_000;\nlet _cachedTokens: string[] = [];\nlet _cachedAt = 0;\nlet _cachedPath: string | undefined;\n\nexport function getAllValidTokensCached(tokensPath?: string): string[] {\n  const now = Date.now();\n  if (now - _cachedAt < TOKEN_CACHE_TTL_MS && tokensPath === _cachedPath) return _cachedTokens;\n  _cachedTokens = getAllValidTokens(tokensPath);\n  _cachedAt = now;\n  _cachedPath = tokensPath;\n  return _cachedTokens;\n}\n\nexport function resolveConnectorFromToken(token: string, tokensPath?: string): string | undefined {\n  return loadTokenStore(tokensPath).tokens.find((t) => t.token === token)?.connector;\n}\n"],"mappings":";;;;;AAOA,OAAO,QAAQ;AACf,OAAO,UAAU;AACjB,SAAS,aAAa,kBAAkB;AAaxC,IAAM,iBAAyC;AAAA,EAC7C,YAAY;AAAA,EACZ,eAAe;AAAA,EACf,aAAa;AAAA,EACb,SAAS;AAAA,EACT,UAAU;AAAA,EACV,MAAM;AAAA,EACN,UAAU;AAAA,EACV,UAAU;AAAA,EACV,SAAS;AAAA,EACT,kBAAkB;AAAA,EAClB,YAAY;AAAA,EACZ,YAAY;AAAA,EACZ,OAAO;AAAA,EACP,eAAe;AACjB;AAEA,SAAS,oBAA4B;AACnC,SAAO,KAAK,KAAK,eAAe,GAAG,WAAW,aAAa;AAC7D;AAEA,SAAS,mBAA2B;AAClC,SAAO,KAAK,KAAK,eAAe,GAAG,WAAW,aAAa;AAC7D;AAEA,SAAS,gBAAgB,YAA6B;AACpD,QAAM,UAAU,cAAc,kBAAkB;AAChD,MAAI,WAAY,QAAO;AACvB,MAAI,GAAG,WAAW,OAAO,EAAG,QAAO;AACnC,QAAM,SAAS,iBAAiB;AAChC,SAAO,GAAG,WAAW,MAAM,IAAI,SAAS;AAC1C;AAEA,SAAS,UAAU,UAAwB;AACzC,QAAM,MAAM,KAAK,QAAQ,QAAQ;AACjC,KAAG,UAAU,KAAK,EAAE,WAAW,KAAK,CAAC;AACvC;AAEA,SAAS,SAAS,OAAyB;AACzC,SAAO,iBAAiB,SAAS,UAAU,SAAU,MAAgC,SAAS;AAChG;AAEA,SAAS,mBAAmB,KAAc,OAA2B;AACnE,MAAI,OAAO,QAAQ,YAAY,QAAQ,QAAQ,MAAM,QAAQ,GAAG,GAAG;AACjE,UAAM,IAAI,MAAM,gCAAgC,KAAK,mBAAmB;AAAA,EAC1E;AACA,QAAM,QAAQ;AACd,MAAI,OAAO,MAAM,UAAU,YAAY,MAAM,MAAM,WAAW,GAAG;AAC/D,UAAM,IAAI,MAAM,gCAAgC,KAAK,oCAAoC;AAAA,EAC3F;AACA,MAAI,OAAO,MAAM,cAAc,YAAY,MAAM,UAAU,WAAW,GAAG;AACvE,UAAM,IAAI,MAAM,gCAAgC,KAAK,wCAAwC;AAAA,EAC/F;AACA,SAAO;AAAA,IACL,OAAO,MAAM;AAAA,IACb,WAAW,MAAM;AAAA,IACjB,WACE,OAAO,MAAM,cAAc,YAAY,MAAM,UAAU,SAAS,IAC5D,MAAM,aACN,oBAAI,KAAK,CAAC,GAAE,YAAY;AAAA,EAChC;AACF;AAEA,SAAS,gBAAgB,SAAiB,UAAkE;AAC1G,MAAI;AACJ,MAAI;AACF,UAAM,KAAK,MAAM,OAAO;AAAA,EAC1B,SAAS,OAAO;AACd,UAAM,IAAI;AAAA,MACR,kCAAkC,QAAQ,KAAK,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,CAAC;AAAA,IACvG;AAAA,EACF;AAEA,MAAI,OAAO,QAAQ,YAAY,QAAQ,QAAQ,CAAC,MAAM,QAAQ,GAAG,GAAG;AAClE,UAAM,SAAS;AACf,QAAI,OAAO,WAAW,QAAW;AAC/B,UAAI,CAAC,MAAM,QAAQ,OAAO,MAAM,GAAG;AACjC,cAAM,IAAI,MAAM,0BAA0B,QAAQ,2BAA2B;AAAA,MAC/E;AACA,aAAO;AAAA,QACL,OAAO;AAAA,UACL,QAAQ,OAAO,OAAO,IAAI,CAAC,OAAO,UAAU,mBAAmB,OAAO,KAAK,CAAC;AAAA,QAC9E;AAAA,QACA,gBAAgB;AAAA,MAClB;AAAA,IACF;AAGA,UAAM,WAAyB,CAAC;AAChC,eAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,MAAM,GAAG;AACjD,UAAI,OAAO,UAAU,YAAY,MAAM,SAAS,GAAG;AACjD,iBAAS;AAAA,UACP;AAAA,YACE,EAAE,OAAO,OAAO,WAAW,KAAK,YAAW,oBAAI,KAAK,GAAE,YAAY,EAAE;AAAA,YACpE,SAAS;AAAA,UACX;AAAA,QACF;AAAA,MACF;AAAA,IACF;AACA,QAAI,SAAS,SAAS,GAAG;AACvB,aAAO,EAAE,OAAO,EAAE,QAAQ,SAAS,GAAG,gBAAgB,KAAK;AAAA,IAC7D;AAAA,EACF;AAEA,QAAM,IAAI,MAAM,0BAA0B,QAAQ,gDAAgD;AACpG;AAEO,SAAS,eAAe,YAAiC;AAC9D,QAAM,IAAI,gBAAgB,UAAU;AACpC,MAAI;AACF,UAAM,UAAU,GAAG,aAAa,GAAG,MAAM;AACzC,UAAM,EAAE,OAAO,eAAe,IAAI,gBAAgB,SAAS,CAAC;AAC5D,QAAI,gBAAgB;AAGlB,UAAI;AACF,uBAAe,OAAO,UAAU;AAAA,MAClC,QAAQ;AAAA,MAER;AAAA,IACF;AACA,WAAO;AAAA,EACT,SAAS,OAAO;AACd,QAAI,SAAS,KAAK,GAAG;AACnB,aAAO,EAAE,QAAQ,CAAC,EAAE;AAAA,IACtB;AACA,UAAM;AAAA,EACR;AACF;AAEA,SAAS,yBAAyB,SAAuB;AACvD,MAAI,QAAuB;AAC3B,MAAI;AACF,YAAQ,GAAG,SAAS,SAAS,GAAG;AAChC,OAAG,UAAU,KAAK;AAAA,EACpB,QAAQ;AAAA,EAER,UAAE;AACA,QAAI,UAAU,MAAM;AAClB,UAAI;AAAE,WAAG,UAAU,KAAK;AAAA,MAAG,QAAQ;AAAA,MAAe;AAAA,IACpD;AAAA,EACF;AACF;AAEO,SAAS,eAAe,OAAmB,YAA2B;AAC3E,QAAM,IAAI,cAAc,kBAAkB;AAC1C,YAAU,CAAC;AACX,QAAM,YAAwB;AAAA,IAC5B,QAAQ,MAAM,OAAO,IAAI,CAAC,OAAO,UAAU,mBAAmB,OAAO,KAAK,CAAC;AAAA,EAC7E;AACA,QAAM,MAAM,KAAK,QAAQ,CAAC;AAC1B,QAAM,UAAU,KAAK,KAAK,KAAK,IAAI,KAAK,SAAS,CAAC,CAAC,IAAI,QAAQ,GAAG,IAAI,WAAW,CAAC,MAAM;AACxF,MAAI,KAAoB;AACxB,MAAI;AACF,SAAK,GAAG,SAAS,SAAS,KAAK,GAAK;AACpC,OAAG,cAAc,IAAI,KAAK,UAAU,WAAW,MAAM,CAAC,IAAI,MAAM,MAAM;AACtE,OAAG,UAAU,EAAE;AACf,OAAG,UAAU,EAAE;AACf,SAAK;AACL,OAAG,WAAW,SAAS,CAAC;AAExB,QAAI;AAAE,SAAG,UAAU,GAAG,GAAK;AAAA,IAAG,QAAQ;AAAA,IAA0C;AAChF,6BAAyB,GAAG;AAAA,EAC9B,SAAS,OAAO;AACd,QAAI,OAAO,MAAM;AACf,UAAI;AAAE,WAAG,UAAU,EAAE;AAAA,MAAG,QAAQ;AAAA,MAAe;AAAA,IACjD;AACA,QAAI;AAAE,SAAG,OAAO,SAAS,EAAE,OAAO,KAAK,CAAC;AAAA,IAAG,QAAQ;AAAA,IAA+B;AAClF,UAAM;AAAA,EACR;AACF;AAQO,SAAS,gBAAgB,WAA+B;AAC7D,QAAM,SAAS,eAAe,SAAS,KAAK;AAC5C,QAAM,QAAQ,SAAS,YAAY,EAAE,EAAE,SAAS,KAAK;AACrD,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,YAAW,oBAAI,KAAK,GAAE,YAAY;AAAA,EACpC;AACF;AAcO,SAAS,iBAAiB,OAAmB,YAA2B;AAC7E,QAAM,QAAQ,eAAe,UAAU;AACvC,QAAM,SAAS,MAAM,OAAO,OAAO,CAAC,MAAM,EAAE,cAAc,MAAM,SAAS;AACzE,QAAM,OAAO,KAAK,KAAK;AACvB,iBAAe,OAAO,UAAU;AAClC;AAEO,SAAS,cAAc,WAAmB,YAAiC;AAChF,QAAM,QAAQ,eAAe,UAAU;AAGvC,QAAM,SAAS,MAAM,OAAO,OAAO,CAAC,MAAM,EAAE,cAAc,SAAS;AAEnE,QAAM,QAAQ,gBAAgB,SAAS;AACvC,QAAM,OAAO,KAAK,KAAK;AACvB,iBAAe,OAAO,UAAU;AAChC,SAAO;AACT;AAEO,SAAS,WAAW,YAAmC;AAC5D,SAAO,eAAe,UAAU,EAAE;AACpC;AAEO,SAAS,YAAY,WAAmB,YAA8B;AAC3E,QAAM,QAAQ,eAAe,UAAU;AACvC,QAAM,SAAS,MAAM,OAAO;AAC5B,QAAM,SAAS,MAAM,OAAO,OAAO,CAAC,MAAM,EAAE,cAAc,SAAS;AACnE,MAAI,MAAM,OAAO,SAAS,QAAQ;AAChC,mBAAe,OAAO,UAAU;AAChC,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAEO,SAAS,kBAAkB,YAA+B;AAC/D,SAAO,eAAe,UAAU,EAAE,OAAO,IAAI,CAAC,MAAM,EAAE,KAAK;AAC7D;AAIA,IAAM,qBAAqB;AAC3B,IAAI,gBAA0B,CAAC;AAC/B,IAAI,YAAY;AAChB,IAAI;AAEG,SAAS,wBAAwB,YAA+B;AACrE,QAAM,MAAM,KAAK,IAAI;AACrB,MAAI,MAAM,YAAY,sBAAsB,eAAe,YAAa,QAAO;AAC/E,kBAAgB,kBAAkB,UAAU;AAC5C,cAAY;AACZ,gBAAc;AACd,SAAO;AACT;AAEO,SAAS,0BAA0B,OAAe,YAAyC;AAChG,SAAO,eAAe,UAAU,EAAE,OAAO,KAAK,CAAC,MAAM,EAAE,UAAU,KAAK,GAAG;AAC3E;","names":[]}

package/dist/chunk-MT25YHYH.js

@@ -0,0 +1,141 @@
+import {
+  namespaceCollectionName
+} from "./chunk-PU63GXWS.js";
+import {
+  NamespaceStorageRouter
+} from "./chunk-QQUAB63I.js";
+import {
+  isSafeRouteNamespace
+} from "./chunk-U3PN77QT.js";
+
+// src/namespaces/migrate.ts
+import path from "path";
+import { access, mkdir, readdir, rename } from "fs/promises";
+var LEGACY_NAMESPACE_CHILDREN = [
+  "facts",
+  "corrections",
+  "entities",
+  "questions",
+  "artifacts",
+  "identity",
+  "state",
+  "config",
+  "summaries",
+  "procedures",
+  // Issue #564 PR 3: reasoning_trace memories live in their own subtree.
+  // Must be included here so namespace migration moves existing traces
+  // into the target namespace root alongside other memory data.
+  "reasoning-traces",
+  "profile.md"
+];
+async function exists(p) {
+  try {
+    await access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function hasAnyLegacyData(rootDir) {
+  for (const child of LEGACY_NAMESPACE_CHILDREN) {
+    if (await exists(path.join(rootDir, child))) return true;
+  }
+  return false;
+}
+async function discoverConfiguredNamespaces(config) {
+  const discovered = /* @__PURE__ */ new Set([
+    config.defaultNamespace,
+    config.sharedNamespace,
+    ...config.namespacePolicies.map((policy) => policy.name)
+  ]);
+  const namespacesDir = path.join(config.memoryDir, "namespaces");
+  try {
+    const entries = await readdir(namespacesDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && isSafeRouteNamespace(entry.name)) {
+        discovered.add(entry.name);
+      }
+    }
+  } catch {
+  }
+  return [...discovered];
+}
+async function listNamespaces(options) {
+  const storageRouter = options.storageRouter ?? new NamespaceStorageRouter(options.config);
+  const namespaces = await discoverConfiguredNamespaces(options.config);
+  const items = await Promise.all(
+    namespaces.map(async (namespace) => {
+      const storage = await storageRouter.storageFor(namespace);
+      const usesLegacyRoot = namespace === options.config.defaultNamespace && storage.dir === options.config.memoryDir;
+      return {
+        namespace,
+        rootDir: storage.dir,
+        exists: await exists(storage.dir),
+        usesLegacyRoot,
+        hasMemoryData: await hasAnyLegacyData(storage.dir),
+        collection: namespaceCollectionName(options.config.qmdCollection, namespace, {
+          defaultNamespace: options.config.defaultNamespace,
+          useLegacyDefaultCollection: usesLegacyRoot
+        })
+      };
+    })
+  );
+  return items.sort((a, b) => a.namespace.localeCompare(b.namespace));
+}
+async function verifyNamespaces(options) {
+  const namespaces = await listNamespaces(options);
+  const problems = [];
+  for (const entry of namespaces) {
+    if (entry.exists && !entry.hasMemoryData) {
+      problems.push(`${entry.namespace}: root exists but contains no Engram data`);
+    }
+  }
+  return {
+    ok: problems.length === 0,
+    problems,
+    namespaces
+  };
+}
+async function runNamespaceMigration(options) {
+  if (!options.config.namespacesEnabled) {
+    throw new Error("Namespaces are disabled.");
+  }
+  const targetNamespace = options.to.trim();
+  if (!isSafeRouteNamespace(targetNamespace)) {
+    throw new Error(`Invalid namespace: ${options.to}`);
+  }
+  const targetRoot = path.join(options.config.memoryDir, "namespaces", targetNamespace);
+  const moved = [];
+  for (const child of LEGACY_NAMESPACE_CHILDREN) {
+    const from = path.join(options.config.memoryDir, child);
+    if (!await exists(from)) continue;
+    const to = path.join(targetRoot, child);
+    if (await exists(to)) {
+      throw new Error(`Target already contains ${child}: ${to}`);
+    }
+    moved.push({ from, to });
+  }
+  if (!options.dryRun && moved.length > 0) {
+    await mkdir(targetRoot, { recursive: true });
+    for (const move of moved) {
+      await rename(move.from, move.to);
+    }
+  }
+  return {
+    dryRun: options.dryRun === true,
+    fromRoot: options.config.memoryDir,
+    targetRoot,
+    moved,
+    collection: namespaceCollectionName(options.config.qmdCollection, targetNamespace, {
+      defaultNamespace: options.config.defaultNamespace,
+      useLegacyDefaultCollection: false
+    })
+  };
+}
+
+export {
+  listNamespaces,
+  verifyNamespaces,
+  runNamespaceMigration
+};
+//# sourceMappingURL=chunk-MT25YHYH.js.map

package/dist/chunk-MT25YHYH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/namespaces/migrate.ts"],"sourcesContent":["import path from \"node:path\";\nimport { access, mkdir, readdir, rename } from \"node:fs/promises\";\nimport type { PluginConfig } from \"../types.js\";\nimport { NamespaceStorageRouter } from \"./storage.js\";\nimport { namespaceCollectionName } from \"./search.js\";\nimport { isSafeRouteNamespace } from \"../routing/engine.js\";\n\nconst LEGACY_NAMESPACE_CHILDREN = [\n  \"facts\",\n  \"corrections\",\n  \"entities\",\n  \"questions\",\n  \"artifacts\",\n  \"identity\",\n  \"state\",\n  \"config\",\n  \"summaries\",\n  \"procedures\",\n  // Issue #564 PR 3: reasoning_trace memories live in their own subtree.\n  // Must be included here so namespace migration moves existing traces\n  // into the target namespace root alongside other memory data.\n  \"reasoning-traces\",\n  \"profile.md\",\n] as const;\n\nexport interface NamespaceInventoryEntry {\n  namespace: string;\n  rootDir: string;\n  exists: boolean;\n  usesLegacyRoot: boolean;\n  hasMemoryData: boolean;\n  collection: string;\n}\n\nexport interface NamespaceVerifyReport {\n  ok: boolean;\n  problems: string[];\n  namespaces: NamespaceInventoryEntry[];\n}\n\nexport interface NamespaceMigrationMove {\n  from: string;\n  to: string;\n}\n\nexport interface NamespaceMigrationReport {\n  dryRun: boolean;\n  fromRoot: string;\n  targetRoot: string;\n  moved: NamespaceMigrationMove[];\n  collection: string;\n}\n\nasync function exists(p: string): Promise<boolean> {\n  try {\n    await access(p);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nasync function hasAnyLegacyData(rootDir: string): Promise<boolean> {\n  for (const child of LEGACY_NAMESPACE_CHILDREN) {\n    if (await exists(path.join(rootDir, child))) return true;\n  }\n  return false;\n}\n\nasync function discoverConfiguredNamespaces(\n  config: PluginConfig,\n): Promise<string[]> {\n  const discovered = new Set<string>([\n    config.defaultNamespace,\n    config.sharedNamespace,\n    ...config.namespacePolicies.map((policy) => policy.name),\n  ]);\n\n  const namespacesDir = path.join(config.memoryDir, \"namespaces\");\n  try {\n    const entries = await readdir(namespacesDir, { withFileTypes: true });\n    for (const entry of entries) {\n      if (entry.isDirectory() && isSafeRouteNamespace(entry.name)) {\n        discovered.add(entry.name);\n      }\n    }\n  } catch {\n    // No namespace directory yet.\n  }\n\n  return [...discovered];\n}\n\nexport async function listNamespaces(options: {\n  config: PluginConfig;\n  storageRouter?: NamespaceStorageRouter;\n}): Promise<NamespaceInventoryEntry[]> {\n  const storageRouter = options.storageRouter ?? new NamespaceStorageRouter(options.config);\n  const namespaces = await discoverConfiguredNamespaces(options.config);\n  const items = await Promise.all(\n    namespaces.map(async (namespace) => {\n      const storage = await storageRouter.storageFor(namespace);\n      const usesLegacyRoot =\n        namespace === options.config.defaultNamespace &&\n        storage.dir === options.config.memoryDir;\n      return {\n        namespace,\n        rootDir: storage.dir,\n        exists: await exists(storage.dir),\n        usesLegacyRoot,\n        hasMemoryData: await hasAnyLegacyData(storage.dir),\n        collection: namespaceCollectionName(options.config.qmdCollection, namespace, {\n          defaultNamespace: options.config.defaultNamespace,\n          useLegacyDefaultCollection: usesLegacyRoot,\n        }),\n      } satisfies NamespaceInventoryEntry;\n    }),\n  );\n\n  return items.sort((a, b) => a.namespace.localeCompare(b.namespace));\n}\n\nexport async function verifyNamespaces(options: {\n  config: PluginConfig;\n  storageRouter?: NamespaceStorageRouter;\n}): Promise<NamespaceVerifyReport> {\n  const namespaces = await listNamespaces(options);\n  const problems: string[] = [];\n\n  for (const entry of namespaces) {\n    if (entry.exists && !entry.hasMemoryData) {\n      problems.push(`${entry.namespace}: root exists but contains no Engram data`);\n    }\n  }\n\n  return {\n    ok: problems.length === 0,\n    problems,\n    namespaces,\n  };\n}\n\nexport async function runNamespaceMigration(options: {\n  config: PluginConfig;\n  to: string;\n  dryRun?: boolean;\n}): Promise<NamespaceMigrationReport> {\n  if (!options.config.namespacesEnabled) {\n    throw new Error(\"Namespaces are disabled.\");\n  }\n\n  const targetNamespace = options.to.trim();\n  if (!isSafeRouteNamespace(targetNamespace)) {\n    throw new Error(`Invalid namespace: ${options.to}`);\n  }\n\n  const targetRoot = path.join(options.config.memoryDir, \"namespaces\", targetNamespace);\n  const moved: NamespaceMigrationMove[] = [];\n\n  for (const child of LEGACY_NAMESPACE_CHILDREN) {\n    const from = path.join(options.config.memoryDir, child);\n    if (!(await exists(from))) continue;\n    const to = path.join(targetRoot, child);\n    if (await exists(to)) {\n      throw new Error(`Target already contains ${child}: ${to}`);\n    }\n    moved.push({ from, to });\n  }\n\n  if (!options.dryRun && moved.length > 0) {\n    await mkdir(targetRoot, { recursive: true });\n    for (const move of moved) {\n      await rename(move.from, move.to);\n    }\n  }\n\n  return {\n    dryRun: options.dryRun === true,\n    fromRoot: options.config.memoryDir,\n    targetRoot,\n    moved,\n    collection: namespaceCollectionName(options.config.qmdCollection, targetNamespace, {\n      defaultNamespace: options.config.defaultNamespace,\n      useLegacyDefaultCollection: false,\n    }),\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-MT4HVDUZ.js

@@ -0,0 +1,53 @@
+import {
+  parseXrayFormat
+} from "./chunk-FBYESMQ2.js";
+import {
+  RECALL_DISCLOSURE_LEVELS,
+  isRecallDisclosure
+} from "./chunk-Q7P4WJDP.js";
+
+// src/recall-xray-cli.ts
+function parseXrayDisclosureFlag(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string" || !isRecallDisclosure(value)) {
+    throw new Error(
+      `--disclosure expects one of ${RECALL_DISCLOSURE_LEVELS.join(", ")}; got ${JSON.stringify(value)}`
+    );
+  }
+  return value;
+}
+function parseXrayBudgetFlag(value) {
+  if (value === void 0 || value === null) return void 0;
+  const parsed = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0 || !Number.isInteger(parsed)) {
+    throw new Error(
+      `--budget expects a positive integer; got ${JSON.stringify(value)}`
+    );
+  }
+  return parsed;
+}
+function parseXrayCliOptions(rawQuery, options) {
+  if (typeof rawQuery !== "string" || rawQuery.trim().length === 0) {
+    throw new Error("xray: <query> is required and must be non-empty");
+  }
+  const format = parseXrayFormat(options.format);
+  const budget = parseXrayBudgetFlag(options.budget);
+  const namespace = typeof options.namespace === "string" && options.namespace.trim().length > 0 ? options.namespace.trim() : void 0;
+  const outPath = typeof options.out === "string" && options.out.trim().length > 0 ? options.out.trim() : void 0;
+  const disclosure = parseXrayDisclosureFlag(options.disclosure);
+  return {
+    query: rawQuery,
+    format,
+    ...budget !== void 0 ? { budget } : {},
+    ...namespace !== void 0 ? { namespace } : {},
+    ...outPath !== void 0 ? { outPath } : {},
+    ...disclosure !== void 0 ? { disclosure } : {}
+  };
+}
+
+export {
+  parseXrayDisclosureFlag,
+  parseXrayBudgetFlag,
+  parseXrayCliOptions
+};
+//# sourceMappingURL=chunk-MT4HVDUZ.js.map