xytara 2.0.0 → 2.2.0

package/lib/runtime_state_store.js

@@ -0,0 +1,354 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+function normalizeFilePath(filePath) {
+  const raw = typeof filePath === "string" ? filePath.trim() : "";
+  return raw ? path.resolve(raw) : "";
+}
+
+function normalizeUrl(url) {
+  const raw = typeof url === "string" ? url.trim() : "";
+  return raw ? raw.replace(/\/+$/, "") : "";
+}
+
+function normalizeString(value, fallback = "") {
+  const raw = typeof value === "string" ? value.trim() : "";
+  return raw || fallback;
+}
+
+function serializeValue(value) {
+  if (value instanceof Map) {
+    return {
+      __runtime_state_kind: "Map",
+      value: Array.from(value.entries()).map(([key, entry]) => [key, serializeValue(entry)])
+    };
+  }
+  if (value instanceof Set) {
+    return {
+      __runtime_state_kind: "Set",
+      value: Array.from(value.values()).map((entry) => serializeValue(entry))
+    };
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => serializeValue(entry));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [key, serializeValue(entry)])
+    );
+  }
+  return value;
+}
+
+function deserializeValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => deserializeValue(entry));
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  if (value.__runtime_state_kind === "Map" && Array.isArray(value.value)) {
+    return new Map(value.value.map((entry) => [entry[0], deserializeValue(entry[1])]));
+  }
+  if (value.__runtime_state_kind === "Set" && Array.isArray(value.value)) {
+    return new Set(value.value.map((entry) => deserializeValue(entry)));
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, entry]) => [key, deserializeValue(entry)])
+  );
+}
+
+function createRuntimeStateStore(config = {}) {
+  const filePath = normalizeFilePath(config.filePath);
+  const directoryPath = filePath ? path.dirname(filePath) : "";
+  const intervalMs = Math.max(1000, Number.parseInt(String(config.intervalMs || 5000), 10) || 5000);
+  const supabaseUrl = normalizeUrl(config.supabaseUrl);
+  const supabaseServiceRoleKey = normalizeString(config.supabaseServiceRoleKey);
+  const supabaseTable = normalizeString(config.supabaseTable, "xytara_runtime_state");
+  const stateKey = normalizeString(config.stateKey, "default");
+  const storageMode = supabaseUrl && supabaseServiceRoleKey ? "supabase" : filePath ? "file" : "memory";
+  let dirty = false;
+  let timer = null;
+  let lastPersistedAtIso = null;
+  let lastFlushSucceeded = false;
+  let lastError = null;
+  let snapshotExists = false;
+  let snapshotUpdatedAtIso = null;
+  let snapshotSizeBytes = 0;
+  let remoteConfigured = storageMode === "supabase";
+  let remoteReachable = storageMode !== "supabase";
+  let remoteTableReady = storageMode !== "supabase";
+
+  function enabled() {
+    return storageMode !== "memory";
+  }
+
+  function markDirty() {
+    if (!enabled()) return;
+    dirty = true;
+  }
+
+  function applyRestoredState(state, restored) {
+    if (!restored || typeof restored !== "object" || !state) return false;
+    for (const key of Object.keys(state)) {
+      if (Object.prototype.hasOwnProperty.call(restored, key)) {
+        state[key] = restored[key];
+      }
+    }
+    return true;
+  }
+
+  function inspectFileDirectory() {
+    let exists = false;
+    let writable = false;
+    let error = null;
+    if (storageMode !== "file") {
+      return {
+        exists: false,
+        writable: false,
+        error: null
+      };
+    }
+    try {
+      exists = fs.existsSync(directoryPath);
+      if (exists) {
+        fs.accessSync(directoryPath, fs.constants.W_OK);
+        writable = true;
+      }
+    } catch (issue) {
+      writable = false;
+      error = issue;
+    }
+    return {
+      exists,
+      writable,
+      error
+    };
+  }
+
+  async function fetchSupabase(pathname, options = {}) {
+    const response = await fetch(`${supabaseUrl}${pathname}`, {
+      ...options,
+      headers: {
+        apikey: supabaseServiceRoleKey,
+        authorization: `Bearer ${supabaseServiceRoleKey}`,
+        ...(options.headers || {})
+      }
+    });
+    remoteReachable = true;
+    if (!response.ok) {
+      const text = await response.text();
+      const error = new Error(`supabase_runtime_state_${response.status}: ${text || response.statusText}`);
+      error.status = response.status;
+      throw error;
+    }
+    return response;
+  }
+
+  function updateSuccessSnapshotMetadata(persistedAtIso, serializedSnapshot) {
+    lastPersistedAtIso = persistedAtIso;
+    lastFlushSucceeded = true;
+    lastError = null;
+    snapshotExists = true;
+    snapshotUpdatedAtIso = persistedAtIso;
+    snapshotSizeBytes = Buffer.byteLength(JSON.stringify(serializedSnapshot), "utf8");
+  }
+
+  async function flushSupabase(state) {
+    if (!dirty || !state) return false;
+    const persistedAtIso = new Date().toISOString();
+    const serializedSnapshot = serializeValue(state);
+    const payload = [{
+      state_key: stateKey,
+      snapshot: serializedSnapshot,
+      persisted_at_iso: persistedAtIso
+    }];
+    try {
+      await fetchSupabase(`/rest/v1/${encodeURIComponent(supabaseTable)}?on_conflict=state_key`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          prefer: "resolution=merge-duplicates,return=minimal"
+        },
+        body: JSON.stringify(payload)
+      });
+      remoteTableReady = true;
+      dirty = false;
+      updateSuccessSnapshotMetadata(persistedAtIso, serializedSnapshot);
+      return true;
+    } catch (error) {
+      lastFlushSucceeded = false;
+      lastError = error;
+      remoteReachable = false;
+      remoteTableReady = false;
+      throw error;
+    }
+  }
+
+  function flushFile(state) {
+    if (!dirty || !state) return false;
+    try {
+      fs.mkdirSync(path.dirname(filePath), { recursive: true });
+      const tempPath = `${filePath}.tmp`;
+      const persistedAtIso = new Date().toISOString();
+      const serializedSnapshot = serializeValue(state);
+      const snapshot = {
+        persisted_at_iso: persistedAtIso,
+        state: serializedSnapshot
+      };
+      fs.writeFileSync(tempPath, JSON.stringify(snapshot, null, 2), "utf8");
+      fs.renameSync(tempPath, filePath);
+      dirty = false;
+      updateSuccessSnapshotMetadata(persistedAtIso, serializedSnapshot);
+      return true;
+    } catch (error) {
+      lastFlushSucceeded = false;
+      lastError = error;
+      throw error;
+    }
+  }
+
+  async function flush(state) {
+    if (!enabled() || !dirty || !state) return false;
+    if (storageMode === "supabase") {
+      return flushSupabase(state);
+    }
+    if (storageMode === "file") {
+      return flushFile(state);
+    }
+    return false;
+  }
+
+  async function loadSupabase(state) {
+    try {
+      const response = await fetchSupabase(
+        `/rest/v1/${encodeURIComponent(supabaseTable)}?state_key=eq.${encodeURIComponent(stateKey)}&select=snapshot,persisted_at_iso&limit=1`
+      );
+      const rows = await response.json();
+      const row = Array.isArray(rows) && rows[0] ? rows[0] : null;
+      remoteTableReady = true;
+      if (!row || !row.snapshot) {
+        dirty = false;
+        lastFlushSucceeded = true;
+        lastError = null;
+        snapshotExists = false;
+        return false;
+      }
+      const restored = deserializeValue(row.snapshot);
+      const applied = applyRestoredState(state, restored);
+      dirty = false;
+      lastPersistedAtIso = row.persisted_at_iso ? String(row.persisted_at_iso) : null;
+      lastFlushSucceeded = true;
+      lastError = null;
+      snapshotExists = applied;
+      snapshotUpdatedAtIso = lastPersistedAtIso;
+      snapshotSizeBytes = Buffer.byteLength(JSON.stringify(row.snapshot), "utf8");
+      return applied;
+    } catch (error) {
+      lastFlushSucceeded = false;
+      lastError = error;
+      remoteReachable = false;
+      remoteTableReady = false;
+      throw error;
+    }
+  }
+
+  async function loadFile(state) {
+    if (!state || !fs.existsSync(filePath)) return false;
+    const raw = fs.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    const restored = deserializeValue(parsed && parsed.state ? parsed.state : parsed);
+    const applied = applyRestoredState(state, restored);
+    dirty = false;
+    lastPersistedAtIso = parsed && parsed.persisted_at_iso ? String(parsed.persisted_at_iso) : null;
+    lastFlushSucceeded = true;
+    lastError = null;
+    snapshotExists = applied;
+    snapshotUpdatedAtIso = parsed && parsed.persisted_at_iso ? String(parsed.persisted_at_iso) : null;
+    snapshotSizeBytes = Buffer.byteLength(raw, "utf8");
+    return applied;
+  }
+
+  async function load(state) {
+    if (!enabled() || !state) return false;
+    if (storageMode === "supabase") {
+      return loadSupabase(state);
+    }
+    if (storageMode === "file") {
+      return loadFile(state);
+    }
+    return false;
+  }
+
+  function inspect() {
+    const fileDirectory = inspectFileDirectory();
+    const fileStats = storageMode === "file" && snapshotExists && fs.existsSync(filePath)
+      ? fs.statSync(filePath)
+      : null;
+    return {
+      enabled: enabled(),
+      storage_mode: storageMode,
+      file_path: filePath || null,
+      directory_path: directoryPath || null,
+      interval_ms: intervalMs,
+      dirty,
+      timer_active: Boolean(timer),
+      directory_exists: storageMode === "file" ? fileDirectory.exists : false,
+      directory_writable: storageMode === "file" ? fileDirectory.writable : false,
+      directory_error: storageMode === "file" && fileDirectory.error ? fileDirectory.error.message : null,
+      snapshot_exists: snapshotExists,
+      snapshot_size_bytes: fileStats ? fileStats.size : snapshotSizeBytes,
+      snapshot_updated_at_iso: fileStats ? fileStats.mtime.toISOString() : snapshotUpdatedAtIso,
+      last_persisted_at_iso: lastPersistedAtIso,
+      last_flush_succeeded: lastFlushSucceeded,
+      last_error: lastError ? lastError.message : null,
+      supabase_url: supabaseUrl || null,
+      supabase_table: storageMode === "supabase" ? supabaseTable : null,
+      supabase_state_key: storageMode === "supabase" ? stateKey : null,
+      remote_configured: remoteConfigured,
+      remote_reachable: remoteReachable,
+      remote_table_ready: remoteTableReady
+    };
+  }
+
+  function start(state) {
+    if (!enabled() || timer) return;
+    timer = setInterval(() => {
+      Promise.resolve(flush(state)).catch((error) => {
+        console.error("runtime state snapshot flush failed", error);
+      });
+    }, intervalMs);
+    if (typeof timer.unref === "function") timer.unref();
+  }
+
+  async function stop(state) {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+    try {
+      await flush(state);
+    } catch (error) {
+      console.error("runtime state snapshot final flush failed", error);
+    }
+  }
+
+  return {
+    enabled,
+    storageMode,
+    filePath,
+    intervalMs,
+    inspect,
+    load,
+    markDirty,
+    flush,
+    start,
+    stop
+  };
+}
+
+module.exports = {
+  createRuntimeStateStore
+};