rezo 1.0.43 → 1.0.45

package/dist/cache/navigation-history.js

@@ -1,296 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { createHash } from "node:crypto";
-function detectRuntime() {
-  if (typeof globalThis.Bun !== "undefined")
-    return "bun";
-  if (typeof globalThis.Deno !== "undefined")
-    return "deno";
-  return "node";
-}
-async function createDatabase(dbPath) {
-  const runtime = detectRuntime();
-  if (runtime === "bun") {
-    const { Database } = await import("bun:sqlite");
-    const db = new Database(dbPath);
-    return {
-      run: (sql, ...params) => db.run(sql, ...params),
-      get: (sql, ...params) => db.query(sql).get(...params),
-      all: (sql, ...params) => db.query(sql).all(...params),
-      close: () => db.close()
-    };
-  }
-  if (runtime === "deno") {
-    try {
-      const { Database } = await import("node:sqlite");
-      const db = new Database(dbPath);
-      return {
-        run: (sql, ...params) => db.exec(sql, params),
-        get: (sql, ...params) => {
-          const stmt = db.prepare(sql);
-          return stmt.get(...params);
-        },
-        all: (sql, ...params) => {
-          const stmt = db.prepare(sql);
-          return stmt.all(...params);
-        },
-        close: () => db.close()
-      };
-    } catch {
-      throw new Error("Deno SQLite support requires Node.js compatibility mode");
-    }
-  }
-  const { DatabaseSync } = await import("node:sqlite");
-  const db = new DatabaseSync(dbPath);
-  return {
-    run: (sql, ...params) => {
-      const stmt = db.prepare(sql);
-      stmt.run(...params);
-    },
-    get: (sql, ...params) => {
-      const stmt = db.prepare(sql);
-      return stmt.get(...params);
-    },
-    all: (sql, ...params) => {
-      const stmt = db.prepare(sql);
-      return stmt.all(...params);
-    },
-    close: () => db.close()
-  };
-}
-
-export class NavigationHistory {
-  db = null;
-  options;
-  storeDir;
-  dbPath;
-  closed = false;
-  initPromise = null;
-  constructor(options = {}) {
-    this.options = {
-      storeDir: options.storeDir || "./navigation-history",
-      dbFileName: options.dbFileName || "navigation.db",
-      hashUrls: options.hashUrls ?? false
-    };
-    this.storeDir = path.resolve(this.options.storeDir);
-    this.dbPath = path.join(this.storeDir, this.options.dbFileName);
-    if (!fs.existsSync(this.storeDir)) {
-      fs.mkdirSync(this.storeDir, { recursive: true });
-    }
-  }
-  static async create(options = {}) {
-    const store = new NavigationHistory(options);
-    await store.initialize();
-    return store;
-  }
-  async initialize() {
-    if (this.initPromise)
-      return this.initPromise;
-    this.initPromise = (async () => {
-      this.db = await createDatabase(this.dbPath);
-      this.db.run(`
-        CREATE TABLE IF NOT EXISTS sessions (
-          sessionId TEXT PRIMARY KEY,
-          baseUrl TEXT NOT NULL,
-          startedAt INTEGER NOT NULL,
-          lastActivityAt INTEGER NOT NULL,
-          status TEXT DEFAULT 'running',
-          urlsVisited INTEGER DEFAULT 0,
-          urlsQueued INTEGER DEFAULT 0,
-          urlsFailed INTEGER DEFAULT 0,
-          metadata TEXT
-        )
-      `);
-      this.db.run(`
-        CREATE TABLE IF NOT EXISTS queue (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          sessionId TEXT NOT NULL,
-          urlKey TEXT NOT NULL,
-          originalUrl TEXT NOT NULL,
-          method TEXT DEFAULT 'GET',
-          priority INTEGER DEFAULT 0,
-          body TEXT,
-          headers TEXT,
-          metadata TEXT,
-          addedAt INTEGER NOT NULL,
-          UNIQUE(sessionId, urlKey)
-        )
-      `);
-      this.db.run(`
-        CREATE TABLE IF NOT EXISTS visited (
-          id INTEGER PRIMARY KEY AUTOINCREMENT,
-          sessionId TEXT NOT NULL,
-          urlKey TEXT NOT NULL,
-          originalUrl TEXT NOT NULL,
-          status INTEGER,
-          visitedAt INTEGER NOT NULL,
-          finalUrl TEXT,
-          contentType TEXT,
-          errorMessage TEXT,
-          UNIQUE(sessionId, urlKey)
-        )
-      `);
-      this.db.run("CREATE INDEX IF NOT EXISTS idx_queue_session ON queue(sessionId)");
-      this.db.run("CREATE INDEX IF NOT EXISTS idx_queue_priority ON queue(sessionId, priority DESC)");
-      this.db.run("CREATE INDEX IF NOT EXISTS idx_visited_session ON visited(sessionId)");
-      this.db.run("CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status)");
-    })();
-    return this.initPromise;
-  }
-  getUrlKey(url) {
-    if (this.options.hashUrls) {
-      return createHash("sha256").update(url).digest("hex");
-    }
-    return url;
-  }
-  async createSession(sessionId, baseUrl, metadata) {
-    if (this.closed || !this.db)
-      throw new Error("NavigationHistory is closed");
-    const now = Date.now();
-    const session = {
-      sessionId,
-      baseUrl,
-      startedAt: now,
-      lastActivityAt: now,
-      status: "running",
-      urlsVisited: 0,
-      urlsQueued: 0,
-      urlsFailed: 0,
-      metadata: metadata ? JSON.stringify(metadata) : undefined
-    };
-    this.db.run(`INSERT OR REPLACE INTO sessions (sessionId, baseUrl, startedAt, lastActivityAt, status, urlsVisited, urlsQueued, urlsFailed, metadata)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, sessionId, baseUrl, now, now, "running", 0, 0, 0, session.metadata ?? null);
-    return session;
-  }
-  async getSession(sessionId) {
-    if (this.closed || !this.db)
-      throw new Error("NavigationHistory is closed");
-    return this.db.get("SELECT * FROM sessions WHERE sessionId = ?", sessionId);
-  }
-  async updateSessionStatus(sessionId, status) {
-    if (this.closed || !this.db)
-      throw new Error("NavigationHistory is closed");
-    this.db.run("UPDATE sessions SET status = ?, lastActivityAt = ? WHERE sessionId = ?", status, Date.now(), sessionId);
-  }
-  async updateSessionStats(sessionId, stats) {
-    if (this.closed || !this.db)
-      throw new Error("NavigationHistory is closed");
-    const updates = ["lastActivityAt = ?"];
-    const params = [Date.now()];
-    if (stats.urlsVisited !== undefined) {
-      updates.push("urlsVisited = ?");
-      params.push(stats.urlsVisited);
-    }
-    if (stats.urlsQueued !== undefined) {
-      updates.push("urlsQueued = ?");
-      params.push(stats.urlsQueued);
-    }
-    if (stats.urlsFailed !== undefined) {
-      updates.push("urlsFailed = ?");
-      params.push(stats.urlsFailed);
-    }
-    params.push(sessionId);
-    this.db.run(`UPDATE sessions SET ${updates.join(", ")} WHERE sessionId = ?`, ...params);
-  }
-  async addToQueue(sessionId, url, options = {}) {
-    if (this.closed || !this.db)
-      throw new Error("NavigationHistory is closed");
-    const urlKey = this.getUrlKey(url);
-    const existing = this.db.get("SELECT id FROM queue WHERE sessionId = ? AND urlKey = ?", sessionId, urlKey);
-    if (existing)
-      return false;
-    const isVisited = this.db.get("SELECT id FROM visited WHERE sessionId = ? AND urlKey = ?", sessionId, urlKey);
-    if (isVisited)
-      return false;
-    this.db.run(`INSERT INTO queue (sessionId, urlKey, originalUrl, method, priority, body, headers, metadata, addedAt)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`, sessionId, urlKey, url, options.method || "GET", options.priority || 0, options.body ? JSON.stringify(options.body) : null, options.headers ? JSON.stringify(options.headers) : null, options.metadata ? JSON.stringify(options.metadata) : null, Date.now());
-    return true;
-  }
-  async getNextFromQueue(sessionId) {
-    if (this.closed || !this.db)
-      throw new Error("NavigationHistory is closed");
-    const item = this.db.get("SELECT originalUrl as url, method, priority, body, headers, metadata, addedAt FROM queue WHERE sessionId = ? ORDER BY priority DESC, addedAt ASC LIMIT 1", sessionId);
-    return item;
-  }
-  async removeFromQueue(sessionId, url) {
-    if (this.closed || !this.db)
-      throw new Error("NavigationHistory is closed");
-    const urlKey = this.getUrlKey(url);
-    this.db.run("DELETE FROM queue WHERE sessionId = ? AND urlKey = ?", sessionId, urlKey);
-    return true;
-  }
-  async getQueueSize(sessionId) {
-    if (this.closed || !this.db)
-      throw new Error("NavigationHistory is closed");
-    const result = this.db.get("SELECT COUNT(*) as count FROM queue WHERE sessionId = ?", sessionId);
-    return result?.count || 0;
-  }
-  async markVisited(sessionId, url, result = {}) {
-    if (this.closed || !this.db)
-      throw new Error("NavigationHistory is closed");
-    const urlKey = this.getUrlKey(url);
-    this.db.run("DELETE FROM queue WHERE sessionId = ? AND urlKey = ?", sessionId, urlKey);
-    this.db.run(`INSERT OR REPLACE INTO visited (sessionId, urlKey, originalUrl, status, visitedAt, finalUrl, contentType, errorMessage)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, sessionId, urlKey, url, result.status || 0, Date.now(), result.finalUrl ?? null, result.contentType ?? null, result.errorMessage ?? null);
-  }
-  async isVisited(sessionId, url) {
-    if (this.closed || !this.db)
-      throw new Error("NavigationHistory is closed");
-    const urlKey = this.getUrlKey(url);
-    const result = this.db.get("SELECT id FROM visited WHERE sessionId = ? AND urlKey = ?", sessionId, urlKey);
-    return !!result;
-  }
-  async getVisitedCount(sessionId) {
-    if (this.closed || !this.db)
-      throw new Error("NavigationHistory is closed");
-    const result = this.db.get("SELECT COUNT(*) as count FROM visited WHERE sessionId = ?", sessionId);
-    return result?.count || 0;
-  }
-  async getFailedUrls(sessionId) {
-    if (this.closed || !this.db)
-      throw new Error("NavigationHistory is closed");
-    return this.db.all("SELECT url, status, visitedAt, finalUrl, contentType, errorMessage FROM visited WHERE sessionId = ? AND (status >= 400 OR errorMessage IS NOT NULL)", sessionId);
-  }
-  async getAllQueuedUrls(sessionId) {
-    if (this.closed || !this.db)
-      throw new Error("NavigationHistory is closed");
-    return this.db.all("SELECT originalUrl as url, method, priority, body, headers, metadata, addedAt FROM queue WHERE sessionId = ? ORDER BY priority DESC, addedAt ASC", sessionId);
-  }
-  async clearQueue(sessionId) {
-    if (this.closed || !this.db)
-      throw new Error("NavigationHistory is closed");
-    this.db.run("DELETE FROM queue WHERE sessionId = ?", sessionId);
-  }
-  async clearVisited(sessionId) {
-    if (this.closed || !this.db)
-      throw new Error("NavigationHistory is closed");
-    this.db.run("DELETE FROM visited WHERE sessionId = ?", sessionId);
-  }
-  async deleteSession(sessionId) {
-    if (this.closed || !this.db)
-      throw new Error("NavigationHistory is closed");
-    this.db.run("DELETE FROM queue WHERE sessionId = ?", sessionId);
-    this.db.run("DELETE FROM visited WHERE sessionId = ?", sessionId);
-    this.db.run("DELETE FROM sessions WHERE sessionId = ?", sessionId);
-  }
-  async getResumableSessions() {
-    if (this.closed || !this.db)
-      throw new Error("NavigationHistory is closed");
-    return this.db.all("SELECT * FROM sessions WHERE status IN ('running', 'paused') ORDER BY lastActivityAt DESC");
-  }
-  async close() {
-    if (this.closed)
-      return;
-    this.closed = true;
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-    }
-  }
-  get isClosed() {
-    return this.closed;
-  }
-  get databasePath() {
-    return this.dbPath;
-  }
-}

package/dist/cache/url-store.cjs

@@ -1,294 +0,0 @@
-const fs = require("node:fs");
-const path = require("node:path");
-const { createHash } = require("node:crypto");
-function detectRuntime() {
-  if (typeof globalThis.Bun !== "undefined") {
-    return "bun";
-  }
-  if (typeof globalThis.Deno !== "undefined") {
-    return "deno";
-  }
-  return "node";
-}
-async function createDatabase(dbPath) {
-  const runtime = detectRuntime();
-  if (runtime === "bun") {
-    const { Database } = await import("bun:sqlite");
-    const db = new Database(dbPath);
-    return {
-      run: (sql, ...params) => db.run(sql, ...params),
-      get: (sql, ...params) => db.query(sql).get(...params),
-      all: (sql, ...params) => db.query(sql).all(...params),
-      close: () => db.close()
-    };
-  }
-  if (runtime === "deno") {
-    try {
-      const { Database } = await import("node:sqlite");
-      const db = new Database(dbPath);
-      return {
-        run: (sql, ...params) => db.exec(sql, params),
-        get: (sql, ...params) => {
-          const stmt = db.prepare(sql);
-          return stmt.get(...params);
-        },
-        all: (sql, ...params) => {
-          const stmt = db.prepare(sql);
-          return stmt.all(...params);
-        },
-        close: () => db.close()
-      };
-    } catch {
-      throw new Error("Deno SQLite support requires Node.js compatibility mode");
-    }
-  }
-  const { DatabaseSync } = await import("node:sqlite");
-  const db = new DatabaseSync(dbPath);
-  return {
-    run: (sql, ...params) => {
-      if (params.length === 0) {
-        db.exec(sql);
-      } else {
-        db.prepare(sql).run(...params);
-      }
-    },
-    get: (sql, ...params) => {
-      const stmt = db.prepare(sql);
-      return stmt.get(...params);
-    },
-    all: (sql, ...params) => {
-      const stmt = db.prepare(sql);
-      return stmt.all(...params);
-    },
-    close: () => db.close()
-  };
-}
-
-class UrlStore {
-  db = null;
-  options;
-  storeDir;
-  dbPath;
-  closed = false;
-  initPromise = null;
-  constructor(options = {}) {
-    this.options = {
-      storeDir: options.storeDir || "./url-store",
-      dbFileName: options.dbFileName || "urls.db",
-      ttl: options.ttl || 604800000,
-      maxUrls: options.maxUrls ?? 0,
-      hashUrls: options.hashUrls ?? false
-    };
-    this.storeDir = path.resolve(this.options.storeDir);
-    this.dbPath = path.join(this.storeDir, this.options.dbFileName);
-    if (!fs.existsSync(this.storeDir)) {
-      fs.mkdirSync(this.storeDir, { recursive: true });
-    }
-  }
-  static async create(options = {}) {
-    const store = new UrlStore(options);
-    await store.initialize();
-    return store;
-  }
-  async initialize() {
-    if (this.initPromise)
-      return this.initPromise;
-    this.initPromise = (async () => {
-      this.db = await createDatabase(this.dbPath);
-      this.db.run(`
-        CREATE TABLE IF NOT EXISTS urls (
-          url TEXT PRIMARY KEY,
-          visitedAt INTEGER NOT NULL,
-          expiresAt INTEGER NOT NULL,
-          namespace TEXT DEFAULT 'default',
-          metadata TEXT
-        )
-      `);
-      this.db.run("CREATE INDEX IF NOT EXISTS idx_expires ON urls(expiresAt)");
-      this.db.run("CREATE INDEX IF NOT EXISTS idx_namespace ON urls(namespace)");
-      this.db.run("CREATE INDEX IF NOT EXISTS idx_visited ON urls(visitedAt)");
-    })();
-    return this.initPromise;
-  }
-  getUrlKey(url) {
-    if (this.options.hashUrls) {
-      return createHash("sha256").update(url).digest("hex");
-    }
-    return url;
-  }
-  async set(url, namespace = "default", metadata, ttl) {
-    if (this.closed)
-      throw new Error("UrlStore is closed");
-    await this.initialize();
-    const key = this.getUrlKey(url);
-    const now = Date.now();
-    const expiresAt = now + (ttl ?? this.options.ttl);
-    const metaStr = metadata ? JSON.stringify(metadata) : null;
-    this.db.run(`
-      INSERT OR REPLACE INTO urls (url, visitedAt, expiresAt, namespace, metadata)
-      VALUES (?, ?, ?, ?, ?)
-    `, key, now, expiresAt, namespace, metaStr);
-    if (this.options.maxUrls > 0) {
-      const count = this.db.get("SELECT COUNT(*) as cnt FROM urls");
-      if (count && count.cnt > this.options.maxUrls) {
-        const excess = count.cnt - this.options.maxUrls;
-        this.db.run(`
-          DELETE FROM urls WHERE url IN (
-            SELECT url FROM urls ORDER BY visitedAt ASC LIMIT ?
-          )
-        `, excess);
-      }
-    }
-  }
-  async has(url, namespace) {
-    if (this.closed)
-      return false;
-    await this.initialize();
-    const key = this.getUrlKey(url);
-    const now = Date.now();
-    let entry;
-    if (namespace) {
-      entry = this.db.get("SELECT url, expiresAt FROM urls WHERE url = ? AND namespace = ?", key, namespace);
-    } else {
-      entry = this.db.get("SELECT url, expiresAt FROM urls WHERE url = ?", key);
-    }
-    if (!entry)
-      return false;
-    return entry.expiresAt >= now;
-  }
-  async hasMany(urls, namespace) {
-    if (this.closed)
-      return new Set;
-    await this.initialize();
-    const result = new Set;
-    const now = Date.now();
-    const batchSize = 100;
-    for (let i = 0;i < urls.length; i += batchSize) {
-      const batch = urls.slice(i, i + batchSize);
-      const keys = batch.map((u) => this.getUrlKey(u));
-      const placeholders = keys.map(() => "?").join(",");
-      let entries;
-      if (namespace) {
-        entries = this.db.all(`SELECT url, expiresAt FROM urls WHERE url IN (${placeholders}) AND namespace = ?`, ...keys, namespace);
-      } else {
-        entries = this.db.all(`SELECT url, expiresAt FROM urls WHERE url IN (${placeholders})`, ...keys);
-      }
-      for (const entry of entries) {
-        if (entry.expiresAt >= now) {
-          const idx = keys.indexOf(entry.url);
-          if (idx !== -1) {
-            result.add(batch[idx]);
-          }
-        }
-      }
-    }
-    return result;
-  }
-  async getMetadata(url, namespace) {
-    if (this.closed)
-      return null;
-    await this.initialize();
-    const key = this.getUrlKey(url);
-    let entry;
-    if (namespace) {
-      entry = this.db.get("SELECT metadata FROM urls WHERE url = ? AND namespace = ?", key, namespace);
-    } else {
-      entry = this.db.get("SELECT metadata FROM urls WHERE url = ?", key);
-    }
-    if (!entry?.metadata)
-      return null;
-    try {
-      return JSON.parse(entry.metadata);
-    } catch {
-      return null;
-    }
-  }
-  async delete(url, namespace) {
-    if (this.closed)
-      return false;
-    await this.initialize();
-    const key = this.getUrlKey(url);
-    if (namespace) {
-      this.db.run("DELETE FROM urls WHERE url = ? AND namespace = ?", key, namespace);
-    } else {
-      this.db.run("DELETE FROM urls WHERE url = ?", key);
-    }
-    return true;
-  }
-  async clear(namespace) {
-    if (this.closed)
-      return;
-    await this.initialize();
-    if (namespace) {
-      this.db.run("DELETE FROM urls WHERE namespace = ?", namespace);
-    } else {
-      this.db.run("DELETE FROM urls");
-    }
-  }
-  async cleanup() {
-    if (this.closed)
-      return 0;
-    await this.initialize();
-    const now = Date.now();
-    const countBefore = this.db.get("SELECT COUNT(*) as cnt FROM urls");
-    this.db.run("DELETE FROM urls WHERE expiresAt < ?", now);
-    const countAfter = this.db.get("SELECT COUNT(*) as cnt FROM urls");
-    return (countBefore?.cnt || 0) - (countAfter?.cnt || 0);
-  }
-  async getAll(namespace = "default", includeExpired = false) {
-    if (this.closed)
-      return [];
-    await this.initialize();
-    const now = Date.now();
-    let entries;
-    if (includeExpired) {
-      entries = this.db.all("SELECT url FROM urls WHERE namespace = ?", namespace);
-    } else {
-      entries = this.db.all("SELECT url FROM urls WHERE namespace = ? AND expiresAt >= ?", namespace, now);
-    }
-    return entries.map((e) => e.url);
-  }
-  async stats(namespace) {
-    if (this.closed)
-      return { total: 0, expired: 0, namespaces: 0 };
-    await this.initialize();
-    const now = Date.now();
-    let total;
-    let expired;
-    if (namespace) {
-      total = this.db.get("SELECT COUNT(*) as cnt FROM urls WHERE namespace = ?", namespace);
-      expired = this.db.get("SELECT COUNT(*) as cnt FROM urls WHERE namespace = ? AND expiresAt < ?", namespace, now);
-    } else {
-      total = this.db.get("SELECT COUNT(*) as cnt FROM urls");
-      expired = this.db.get("SELECT COUNT(*) as cnt FROM urls WHERE expiresAt < ?", now);
-    }
-    const namespaceCount = this.db.get("SELECT COUNT(DISTINCT namespace) as cnt FROM urls");
-    return {
-      total: total?.cnt || 0,
-      expired: expired?.cnt || 0,
-      namespaces: namespaceCount?.cnt || 0
-    };
-  }
-  async close() {
-    if (this.closed)
-      return;
-    this.closed = true;
-    await this.initPromise;
-    if (this.db) {
-      try {
-        this.db.close();
-      } catch {}
-      this.db = null;
-    }
-  }
-  get isClosed() {
-    return this.closed;
-  }
-  get path() {
-    return this.dbPath;
-  }
-}
-
-exports.UrlStore = UrlStore;
-exports.default = UrlStore;
-module.exports = Object.assign(UrlStore, exports);