@noy-db/hub 0.3.0-pre.9 → 0.4.0-pre.0

package/dist/chunk-6XE5TMPR.js

@@ -0,0 +1,367 @@
+import {
+  generateULID
+} from "./chunk-ZJADGNYF.js";
+import {
+  base64ToBuffer,
+  bufferToBase64
+} from "./chunk-HOONYZY2.js";
+import {
+  SessionExpiredError,
+  SessionNotFoundError,
+  SessionPolicyError,
+  ValidationError
+} from "./chunk-W2OG6JOL.js";
+
+// src/with-party/session/session.ts
+var subtle = globalThis.crypto.subtle;
+var DEFAULT_TTL_MS = 60 * 60 * 1e3;
+var sessionKeyStore = /* @__PURE__ */ new Map();
+async function createSession(keyring, vault, options = {}) {
+  const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+  const sessionId = generateULID();
+  const expiresAt = new Date(Date.now() + ttlMs).toISOString();
+  const sessionKey = await subtle.generateKey(
+    { name: "AES-GCM", length: 256 },
+    false,
+    // non-extractable — this is the tab-scope security invariant
+    ["encrypt", "decrypt"]
+  );
+  const dekMap = {};
+  for (const [collName, dek] of keyring.deks) {
+    const raw = await subtle.exportKey("raw", dek);
+    dekMap[collName] = bufferToBase64(raw);
+  }
+  const payload = JSON.stringify({
+    userId: keyring.userId,
+    displayName: keyring.displayName,
+    role: keyring.role,
+    permissions: keyring.permissions,
+    deks: dekMap,
+    salt: bufferToBase64(keyring.salt)
+  });
+  const iv = globalThis.crypto.getRandomValues(new Uint8Array(12));
+  const encrypted = await subtle.encrypt(
+    { name: "AES-GCM", iv },
+    sessionKey,
+    new TextEncoder().encode(payload)
+  );
+  const token = {
+    _noydb_session: 1,
+    sessionId,
+    userId: keyring.userId,
+    vault,
+    role: keyring.role,
+    expiresAt,
+    wrappedKek: bufferToBase64(encrypted),
+    kekIv: bufferToBase64(iv)
+  };
+  sessionKeyStore.set(sessionId, sessionKey);
+  return { token, sessionId };
+}
+async function resolveSession(token) {
+  if (Date.now() > new Date(token.expiresAt).getTime()) {
+    sessionKeyStore.delete(token.sessionId);
+    throw new SessionExpiredError(token.sessionId);
+  }
+  const sessionKey = sessionKeyStore.get(token.sessionId);
+  if (!sessionKey) {
+    throw new SessionNotFoundError(token.sessionId);
+  }
+  const iv = base64ToBuffer(token.kekIv);
+  const ciphertext = base64ToBuffer(token.wrappedKek);
+  let plaintext;
+  try {
+    plaintext = await subtle.decrypt(
+      { name: "AES-GCM", iv },
+      sessionKey,
+      ciphertext
+    );
+  } catch {
+    throw new SessionNotFoundError(token.sessionId);
+  }
+  const payload = JSON.parse(new TextDecoder().decode(plaintext));
+  const deks = /* @__PURE__ */ new Map();
+  for (const [collName, rawBase64] of Object.entries(payload.deks)) {
+    const dek = await subtle.importKey(
+      "raw",
+      base64ToBuffer(rawBase64),
+      { name: "AES-GCM", length: 256 },
+      true,
+      ["encrypt", "decrypt"]
+    );
+    deks.set(collName, dek);
+  }
+  return {
+    userId: payload.userId,
+    displayName: payload.displayName,
+    role: payload.role,
+    permissions: payload.permissions,
+    deks,
+    kek: null,
+    // KEK not available in session context
+    salt: base64ToBuffer(payload.salt),
+    authenticators: []
+  };
+}
+function revokeSession(sessionId) {
+  sessionKeyStore.delete(sessionId);
+}
+function isSessionAlive(token) {
+  if (Date.now() > new Date(token.expiresAt).getTime()) return false;
+  return sessionKeyStore.has(token.sessionId);
+}
+function revokeAllSessions() {
+  sessionKeyStore.clear();
+}
+function activeSessionCount() {
+  return sessionKeyStore.size;
+}
+
+// src/with-party/session/session-policy.ts
+var PolicyEnforcer = class {
+  policy;
+  sessionId;
+  onRevoke;
+  createdAt;
+  lastActivityAt;
+  idleTimer = null;
+  absoluteTimer = null;
+  visibilityHandler = null;
+  constructor(opts) {
+    this.policy = opts.policy;
+    this.sessionId = opts.sessionId;
+    this.onRevoke = opts.onRevoke;
+    this.createdAt = Date.now();
+    this.lastActivityAt = Date.now();
+    this.scheduleIdleTimer();
+    this.scheduleAbsoluteTimer();
+    this.registerBackgroundLock();
+  }
+  /**
+   * Record an activity timestamp and reset the idle timer.
+   * Call this at the top of every Noydb public method.
+   */
+  touch() {
+    this.lastActivityAt = Date.now();
+    this.scheduleIdleTimer();
+  }
+  /**
+   * Check whether the given operation is allowed under the active policy.
+   * Throws `SessionPolicyError` if the operation requires re-authentication.
+   * Throws `SessionExpiredError` if the absolute timeout has been exceeded
+   * (defensive check in case the timer fired before the call arrived).
+   *
+   * This is a synchronous check — callers don't await it.
+   */
+  checkOperation(op) {
+    const { absoluteTimeoutMs } = this.policy;
+    if (absoluteTimeoutMs !== void 0 && Date.now() - this.createdAt >= absoluteTimeoutMs) {
+      this.expire("absolute");
+      throw new SessionExpiredError(this.sessionId);
+    }
+    const required = this.policy.requireReAuthFor ?? [];
+    if (required.includes(op)) {
+      throw new SessionPolicyError(op);
+    }
+  }
+  /**
+   * Tear down timers and background-lock listener. Call from `Noydb.close()`
+   * and whenever the session is revoked externally.
+   */
+  destroy() {
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
+    if (this.absoluteTimer) {
+      clearTimeout(this.absoluteTimer);
+      this.absoluteTimer = null;
+    }
+    if (this.visibilityHandler && typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", this.visibilityHandler);
+      this.visibilityHandler = null;
+    }
+  }
+  /** How long since the last activity, in ms. */
+  get idleMs() {
+    return Date.now() - this.lastActivityAt;
+  }
+  /** How long since session creation, in ms. */
+  get ageMs() {
+    return Date.now() - this.createdAt;
+  }
+  // ── Private ──────────────────────────────────────────────────────────
+  scheduleIdleTimer() {
+    const { idleTimeoutMs } = this.policy;
+    if (!idleTimeoutMs) return;
+    if (this.idleTimer) clearTimeout(this.idleTimer);
+    this.idleTimer = setTimeout(() => {
+      this.expire("idle");
+    }, idleTimeoutMs);
+  }
+  scheduleAbsoluteTimer() {
+    const { absoluteTimeoutMs } = this.policy;
+    if (!absoluteTimeoutMs) return;
+    if (this.absoluteTimer) clearTimeout(this.absoluteTimer);
+    this.absoluteTimer = setTimeout(() => {
+      this.expire("absolute");
+    }, absoluteTimeoutMs);
+  }
+  registerBackgroundLock() {
+    if (!this.policy.lockOnBackground) return;
+    if (typeof document === "undefined") return;
+    this.visibilityHandler = () => {
+      if (document.hidden) {
+        this.expire("background");
+      }
+    };
+    document.addEventListener("visibilitychange", this.visibilityHandler);
+  }
+  expire(reason) {
+    this.destroy();
+    revokeSession(this.sessionId);
+    this.onRevoke(reason);
+  }
+};
+function createEnforcer(opts) {
+  return new PolicyEnforcer(opts);
+}
+function validateSessionPolicy(policy) {
+  const { idleTimeoutMs, absoluteTimeoutMs } = policy;
+  if (idleTimeoutMs !== void 0 && (typeof idleTimeoutMs !== "number" || idleTimeoutMs <= 0)) {
+    throw new Error(`SessionPolicy.idleTimeoutMs must be a positive number, got ${idleTimeoutMs}`);
+  }
+  if (absoluteTimeoutMs !== void 0 && (typeof absoluteTimeoutMs !== "number" || absoluteTimeoutMs <= 0)) {
+    throw new Error(`SessionPolicy.absoluteTimeoutMs must be a positive number, got ${absoluteTimeoutMs}`);
+  }
+  if (idleTimeoutMs !== void 0 && absoluteTimeoutMs !== void 0 && idleTimeoutMs >= absoluteTimeoutMs) {
+    throw new Error(
+      `SessionPolicy.idleTimeoutMs (${idleTimeoutMs}ms) must be less than absoluteTimeoutMs (${absoluteTimeoutMs}ms)`
+    );
+  }
+}
+
+// src/with-party/session/dev-unlock.ts
+var REQUIRED_ACKNOWLEDGE = "I-UNDERSTAND-THIS-DISABLES-UNLOCK-SECURITY";
+var STORAGE_PREFIX = "noydb:dev-unlock:";
+function assertDevEnvironment() {
+  if (typeof process !== "undefined" && process.env.NODE_ENV === "production") {
+    throw new ValidationError(
+      'devUnlock is not available in production builds. process.env.NODE_ENV is "production".'
+    );
+  }
+  if (typeof globalThis !== "undefined" && globalThis.__vite_is_production__ === true) {
+    throw new ValidationError("devUnlock is not available in production builds.");
+  }
+  if (typeof window !== "undefined" && typeof window.location !== "undefined") {
+    const host = window.location.hostname;
+    if (host !== "localhost" && host !== "127.0.0.1" && host !== "::1" && !host.endsWith(".local")) {
+      throw new ValidationError(
+        `devUnlock is only available on localhost. Current hostname: "${host}". Set NODE_ENV=development and run on localhost to use dev unlock.`
+      );
+    }
+  }
+}
+function storageKey(vault, userId) {
+  return `${STORAGE_PREFIX}${vault}:${userId}`;
+}
+function resolveStorage(persistAcrossTabs) {
+  if (typeof window === "undefined") {
+    throw new ValidationError("devUnlock requires a browser environment (window.sessionStorage / window.localStorage).");
+  }
+  return persistAcrossTabs ? window.localStorage : window.sessionStorage;
+}
+async function enableDevUnlock(vault, userId, keyring, options) {
+  if (options.acknowledge !== REQUIRED_ACKNOWLEDGE) {
+    throw new ValidationError(
+      `devUnlock requires acknowledge: '${REQUIRED_ACKNOWLEDGE}'. Got: '${options.acknowledge}'. This is intentional \u2014 the full string must appear in your source.`
+    );
+  }
+  assertDevEnvironment();
+  const storage = resolveStorage(options.persistAcrossTabs);
+  const dekMap = {};
+  for (const [collName, dek] of keyring.deks) {
+    const raw = await globalThis.crypto.subtle.exportKey("raw", dek);
+    dekMap[collName] = bufferToBase64(raw);
+  }
+  const payload = JSON.stringify({
+    _noydb_dev_unlock: 1,
+    userId: keyring.userId,
+    displayName: keyring.displayName,
+    role: keyring.role,
+    permissions: keyring.permissions,
+    deks: dekMap,
+    salt: bufferToBase64(keyring.salt)
+  });
+  storage.setItem(storageKey(vault, userId), payload);
+  console.warn(
+    "%c\u26A0\uFE0F NOYDB DEV UNLOCK ACTIVE \u26A0\uFE0F",
+    "color: red; font-size: 16px; font-weight: bold",
+    `
+
+Vault "${vault}" user "${userId}" is stored in ${options.persistAcrossTabs ? "localStorage" : "sessionStorage"} in PLAINTEXT DEKs.
+This is ONLY safe for local development. Never use in production.
+Call clearDevUnlock() to remove.`
+  );
+}
+async function loadDevUnlock(vault, userId, options = {}) {
+  if (typeof window === "undefined") return null;
+  const storage = resolveStorage(options.persistAcrossTabs);
+  const raw = storage.getItem(storageKey(vault, userId));
+  if (!raw) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (parsed._noydb_dev_unlock !== 1) return null;
+  const deks = /* @__PURE__ */ new Map();
+  for (const [collName, rawBase64] of Object.entries(parsed.deks)) {
+    const dek = await globalThis.crypto.subtle.importKey(
+      "raw",
+      base64ToBuffer(rawBase64),
+      { name: "AES-GCM", length: 256 },
+      true,
+      ["encrypt", "decrypt"]
+    );
+    deks.set(collName, dek);
+  }
+  return {
+    userId: parsed.userId,
+    displayName: parsed.displayName,
+    role: parsed.role,
+    permissions: parsed.permissions,
+    deks,
+    kek: null,
+    salt: base64ToBuffer(parsed.salt),
+    authenticators: []
+  };
+}
+function clearDevUnlock(vault, userId, options = {}) {
+  if (typeof window === "undefined") return;
+  const storage = resolveStorage(options.persistAcrossTabs);
+  storage.removeItem(storageKey(vault, userId));
+}
+function isDevUnlockActive(vault, userId, options = {}) {
+  if (typeof window === "undefined") return false;
+  const storage = resolveStorage(options.persistAcrossTabs);
+  return storage.getItem(storageKey(vault, userId)) !== null;
+}
+
+export {
+  createSession,
+  resolveSession,
+  revokeSession,
+  isSessionAlive,
+  revokeAllSessions,
+  activeSessionCount,
+  PolicyEnforcer,
+  createEnforcer,
+  validateSessionPolicy,
+  enableDevUnlock,
+  loadDevUnlock,
+  clearDevUnlock,
+  isDevUnlockActive
+};
+//# sourceMappingURL=chunk-6XE5TMPR.js.map

package/dist/chunk-A4FXFAKF.js

@@ -0,0 +1,45 @@
+import {
+  NOYDB_FORMAT_VERSION
+} from "./chunk-VCTXU4AT.js";
+
+// src/kernel/enclave/record-keys/tombstone.ts
+function isTombstoneShape(envelope) {
+  return envelope._data === "" && envelope._cek === void 0 && envelope._del !== true;
+}
+function isTombstone(envelope, encrypted) {
+  if (!encrypted) return false;
+  return isTombstoneShape(envelope);
+}
+function buildTombstone(version, actor) {
+  return {
+    _noydb: NOYDB_FORMAT_VERSION,
+    _v: version,
+    _ts: (/* @__PURE__ */ new Date()).toISOString(),
+    _iv: "",
+    _data: "",
+    ...actor ? { _by: actor } : {}
+  };
+}
+function isDeleteMarker(envelope) {
+  return envelope._del === true;
+}
+function buildDeleteMarker(version, actor) {
+  return {
+    _noydb: NOYDB_FORMAT_VERSION,
+    _v: version,
+    _ts: (/* @__PURE__ */ new Date()).toISOString(),
+    _iv: "",
+    _data: "",
+    _del: true,
+    ...actor ? { _by: actor } : {}
+  };
+}
+
+export {
+  isTombstoneShape,
+  isTombstone,
+  buildTombstone,
+  isDeleteMarker,
+  buildDeleteMarker
+};
+//# sourceMappingURL=chunk-A4FXFAKF.js.map