thursday-agent 0.1.0 → 0.1.2

package/node_modules/libsql/index.js

@@ -1,441 +0,0 @@
-"use strict";
-
-const { load, currentTarget } = require("@neon-rs/load");
-const { familySync, GLIBC, MUSL } = require("detect-libc");
-
-function requireNative() {
-  if (process.env.LIBSQL_JS_DEV) {
-    return load(__dirname)
-  }
-  let target = currentTarget();
-  // Workaround for Bun, which reports a musl target, but really wants glibc...
-  if (familySync() == GLIBC) {
-    switch (target) {
-      case "linux-x64-musl":
-        target = "linux-x64-gnu";
-        break;
-      case "linux-arm64-musl":
-        target = "linux-arm64-gnu";
-        break;
-    }
-  }
-  // @neon-rs/load doesn't detect arm musl
-  if (target === "linux-arm-gnueabihf" && familySync() == MUSL) {
-      target = "linux-arm-musleabihf";
-  }
-  return require(`@libsql/${target}`);
-}
-
-const {
-  databaseOpen,
-  databaseOpenWithSync,
-  databaseInTransaction,
-  databaseInterrupt,
-  databaseClose,
-  databaseSyncSync,
-  databaseSyncUntilSync,
-  databaseExecSync,
-  databasePrepareSync,
-  databaseDefaultSafeIntegers,
-  databaseAuthorizer,
-  databaseLoadExtension,
-  databaseMaxWriteReplicationIndex,
-  statementRaw,
-  statementIsReader,
-  statementGet,
-  statementRun,
-  statementInterrupt,
-  statementRowsSync,
-  statementColumns,
-  statementSafeIntegers,
-  rowsNext,
-} = requireNative();
-
-const Authorization = require("./auth");
-const SqliteError = require("./sqlite-error");
-
-function convertError(err) {
-  if (err.libsqlError) {
-    return new SqliteError(err.message, err.code, err.rawCode);
-  }
-  return err;
-}
-
-/**
- * Database represents a connection that can prepare and execute SQL statements.
- */
-class Database {
-  /**
-   * Creates a new database connection. If the database file pointed to by `path` does not exists, it will be created.
-   *
-   * @constructor
-   * @param {string} path - Path to the database file.
-   */
-  constructor(path, opts) {
-    const encryptionCipher = opts?.encryptionCipher ?? "aes256cbc";
-    if (opts && opts.syncUrl) {
-      var authToken = "";
-      if (opts.syncAuth) {
-          console.warn("Warning: The `syncAuth` option is deprecated, please use `authToken` option instead.");
-          authToken = opts.syncAuth;
-      } else if (opts.authToken) {
-          authToken = opts.authToken;
-      }
-      const encryptionKey = opts?.encryptionKey ?? "";
-      const syncPeriod = opts?.syncPeriod ?? 0.0;
-      const readYourWrites = opts?.readYourWrites ?? true;
-      const offline = opts?.offline ?? false;
-      const remoteEncryptionKey = opts?.remoteEncryptionKey ?? "";
-      this.db = databaseOpenWithSync(path, opts.syncUrl, authToken, encryptionCipher, encryptionKey, syncPeriod, readYourWrites, offline, remoteEncryptionKey);
-    } else {
-      const authToken = opts?.authToken ?? "";
-      const encryptionKey = opts?.encryptionKey ?? "";
-      const timeout = opts?.timeout ?? 0.0;
-      const remoteEncryptionKey = opts?.remoteEncryptionKey ?? "";
-      this.db = databaseOpen(path, authToken, encryptionCipher, encryptionKey, timeout, remoteEncryptionKey);
-    }
-    // TODO: Use a libSQL API for this?
-    this.memory = path === ":memory:";
-    this.readonly = false;
-    this.name = "";
-    this.open = true;
-
-    const db = this.db;
-    Object.defineProperties(this, {
-      inTransaction: {
-        get() {
-          return databaseInTransaction(db);
-        }
-      },
-    });
-  }
-
-  sync() {
-    return databaseSyncSync.call(this.db);
-  }
-
-  syncUntil(replicationIndex) {
-    return databaseSyncUntilSync.call(this.db, replicationIndex);
-  }
-
-  /**
-   * Prepares a SQL statement for execution.
-   *
-   * @param {string} sql - The SQL statement string to prepare.
-   */
-  prepare(sql) {
-    try {
-      const stmt = databasePrepareSync.call(this.db, sql);
-      return new Statement(stmt);
-    } catch (err) {
-      throw convertError(err);
-    }
-  }
-
-  /**
-   * Returns a function that executes the given function in a transaction.
-   *
-   * @param {function} fn - The function to wrap in a transaction.
-   */
-  transaction(fn) {
-    if (typeof fn !== "function")
-      throw new TypeError("Expected first argument to be a function");
-
-    const db = this;
-    const wrapTxn = (mode) => {
-      return (...bindParameters) => {
-        db.exec("BEGIN " + mode);
-        try {
-          const result = fn(...bindParameters);
-          db.exec("COMMIT");
-          return result;
-        } catch (err) {
-          db.exec("ROLLBACK");
-          throw err;
-        }
-      };
-    };
-    const properties = {
-      default: { value: wrapTxn("") },
-      deferred: { value: wrapTxn("DEFERRED") },
-      immediate: { value: wrapTxn("IMMEDIATE") },
-      exclusive: { value: wrapTxn("EXCLUSIVE") },
-      database: { value: this, enumerable: true },
-    };
-    Object.defineProperties(properties.default.value, properties);
-    Object.defineProperties(properties.deferred.value, properties);
-    Object.defineProperties(properties.immediate.value, properties);
-    Object.defineProperties(properties.exclusive.value, properties);
-    return properties.default.value;
-  }
-
-  pragma(source, options) {
-    if (options == null) options = {};
-    if (typeof source !== 'string') throw new TypeError('Expected first argument to be a string');
-    if (typeof options !== 'object') throw new TypeError('Expected second argument to be an options object');
-    const simple = options['simple'];
-    const stmt = this.prepare(`PRAGMA ${source}`, this, true);
-    return simple ? stmt.pluck().get() : stmt.all();
-  }
-
-  backup(filename, options) {
-    throw new Error("not implemented");
-  }
-
-  serialize(options) {
-    throw new Error("not implemented");
-  }
-
-  function(name, options, fn) {
-    // Apply defaults
-    if (options == null) options = {};
-    if (typeof options === "function") {
-      fn = options;
-      options = {};
-    }
-
-    // Validate arguments
-    if (typeof name !== "string")
-      throw new TypeError("Expected first argument to be a string");
-    if (typeof fn !== "function")
-      throw new TypeError("Expected last argument to be a function");
-    if (typeof options !== "object")
-      throw new TypeError("Expected second argument to be an options object");
-    if (!name)
-      throw new TypeError(
-        "User-defined function name cannot be an empty string"
-      );
-
-    throw new Error("not implemented");
-  }
-
-  aggregate(name, options) {
-    // Validate arguments
-    if (typeof name !== "string")
-      throw new TypeError("Expected first argument to be a string");
-    if (typeof options !== "object" || options === null)
-      throw new TypeError("Expected second argument to be an options object");
-    if (!name)
-      throw new TypeError(
-        "User-defined function name cannot be an empty string"
-      );
-
-    throw new Error("not implemented");
-  }
-
-  table(name, factory) {
-    // Validate arguments
-    if (typeof name !== "string")
-      throw new TypeError("Expected first argument to be a string");
-    if (!name)
-      throw new TypeError(
-        "Virtual table module name cannot be an empty string"
-      );
-
-    throw new Error("not implemented");
-  }
-
-  authorizer(rules) {
-    databaseAuthorizer.call(this.db, rules);
-  }
-
-  loadExtension(...args) {
-    databaseLoadExtension.call(this.db, ...args);
-  }
-
-  maxWriteReplicationIndex() {
-    return databaseMaxWriteReplicationIndex.call(this.db)
-  }
-
-  /**
-   * Executes a SQL statement.
-   *
-   * @param {string} sql - The SQL statement string to execute.
-   */
-  exec(sql) {
-    try {
-      databaseExecSync.call(this.db, sql);
-    } catch (err) {
-      throw convertError(err);
-    }
-  }
-
-  /**
-   * Interrupts the database connection.
-   */
-  interrupt() {
-    databaseInterrupt.call(this.db);
-  }
-
-  /**
-   * Closes the database connection.
-   */
-  close() {
-    databaseClose.call(this.db);
-    this.open = false;
-  }
-
-  /**
-   * Toggle 64-bit integer support.
-   */
-  defaultSafeIntegers(toggle) {
-    databaseDefaultSafeIntegers.call(this.db, toggle ?? true);
-    return this;
-  }
-
-  unsafeMode(...args) {
-    throw new Error("not implemented");
-  }
-}
-
-/**
- * Statement represents a prepared SQL statement that can be executed.
- */
-class Statement {
-  constructor(stmt) {
-    this.stmt = stmt;
-    this.pluckMode = false;
-  }
-
-  /**
-   * Toggle raw mode.
-   *
-   * @param raw Enable or disable raw mode. If you don't pass the parameter, raw mode is enabled.
-   */
-  raw(raw) {
-    statementRaw.call(this.stmt, raw ?? true);
-    return this;
-  }
-
-  /**
-   * Toggle pluck mode.
-   *
-   * @param pluckMode Enable or disable pluck mode. If you don't pass the parameter, pluck mode is enabled.
-   */
-  pluck(pluckMode) {
-    this.pluckMode = pluckMode ?? true;
-    return this;
-  }
-
-  get reader() {
-    return statementIsReader.call(this.stmt);
-  }
-
-  /**
-   * Executes the SQL statement and returns an info object.
-   */
-  run(...bindParameters) {
-    try {
-      if (bindParameters.length == 1 && typeof bindParameters[0] === "object") {
-        return statementRun.call(this.stmt, bindParameters[0]);
-      } else {
-        return statementRun.call(this.stmt, bindParameters.flat());
-      }
-    } catch (err) {
-      throw convertError(err);
-    }
-  }
-
-  /**
-   * Executes the SQL statement and returns the first row.
-   *
-   * @param bindParameters - The bind parameters for executing the statement.
-   */
-  get(...bindParameters) {
-    try {
-      if (bindParameters.length == 1 && typeof bindParameters[0] === "object") {
-        return statementGet.call(this.stmt, bindParameters[0]);
-      } else {
-        return statementGet.call(this.stmt, bindParameters.flat());
-      }
-    } catch (err) {
-      throw convertError(err);
-    }
-  }
-
-  /**
-   * Executes the SQL statement and returns an iterator to the resulting rows.
-   *
-   * @param bindParameters - The bind parameters for executing the statement.
-   */
-  iterate(...bindParameters) {
-    var rows = undefined;
-    if (bindParameters.length == 1 && typeof bindParameters[0] === "object") {
-      rows = statementRowsSync.call(this.stmt, bindParameters[0]);
-    } else {
-      rows = statementRowsSync.call(this.stmt, bindParameters.flat());
-    }
-    const iter = {
-      nextRows: Array(100),
-      nextRowIndex: 100,
-      next() {
-        try {
-          if (this.nextRowIndex === 100) {
-            rowsNext.call(rows, this.nextRows);
-            this.nextRowIndex = 0;
-          }
-          const row = this.nextRows[this.nextRowIndex];
-          this.nextRows[this.nextRowIndex] = undefined;
-          if (!row) {
-            return { done: true };
-          }
-        this.nextRowIndex++;
-          return { value: row, done: false };
-        } catch (err) {
-          throw convertError(err);
-        }
-      },
-      [Symbol.iterator]() {
-        return this;
-      },
-    };
-    return iter;
-  }
-
-  /**
-   * Executes the SQL statement and returns an array of the resulting rows.
-   *
-   * @param bindParameters - The bind parameters for executing the statement.
-   */
-  all(...bindParameters) {
-    try {
-      const result = [];
-      for (const row of this.iterate(...bindParameters)) {
-        if (this.pluckMode) {
-          result.push(row[Object.keys(row)[0]]);
-        } else {
-          result.push(row);
-        }
-      }
-      return result;
-    } catch (err) {
-      throw convertError(err);
-    }
-  }
-
-  /**
-   * Interrupts the statement.
-   */
-  interrupt() {
-    statementInterrupt.call(this.stmt);
-  }
-
-  /**
-   * Returns the columns in the result set returned by this prepared statement.
-   */
-  columns() {
-    return statementColumns.call(this.stmt);
-  }
-
-  /**
-   * Toggle 64-bit integer support.
-   */
-  safeIntegers(toggle) {
-    statementSafeIntegers.call(this.stmt, toggle ?? true);
-    return this;
-  }
-}
-
-module.exports = Database;
-module.exports.Authorization = Authorization;
-module.exports.SqliteError = SqliteError;

package/node_modules/libsql/node_modules/detect-libc/lib/detect-libc.js

@@ -1,279 +0,0 @@
-// Copyright 2017 Lovell Fuller and others.
-// SPDX-License-Identifier: Apache-2.0
-
-'use strict';
-
-const childProcess = require('child_process');
-const { isLinux, getReport } = require('./process');
-const { LDD_PATH, readFile, readFileSync } = require('./filesystem');
-
-let cachedFamilyFilesystem;
-let cachedVersionFilesystem;
-
-const command = 'getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true';
-let commandOut = '';
-
-const safeCommand = () => {
-  if (!commandOut) {
-    return new Promise((resolve) => {
-      childProcess.exec(command, (err, out) => {
-        commandOut = err ? ' ' : out;
-        resolve(commandOut);
-      });
-    });
-  }
-  return commandOut;
-};
-
-const safeCommandSync = () => {
-  if (!commandOut) {
-    try {
-      commandOut = childProcess.execSync(command, { encoding: 'utf8' });
-    } catch (_err) {
-      commandOut = ' ';
-    }
-  }
-  return commandOut;
-};
-
-/**
- * A String constant containing the value `glibc`.
- * @type {string}
- * @public
- */
-const GLIBC = 'glibc';
-
-/**
- * A Regexp constant to get the GLIBC Version.
- * @type {string}
- */
-const RE_GLIBC_VERSION = /GLIBC\s(\d+\.\d+)/;
-
-/**
- * A String constant containing the value `musl`.
- * @type {string}
- * @public
- */
-const MUSL = 'musl';
-
-/**
- * This string is used to find if the {@link LDD_PATH} is GLIBC
- * @type {string}
- */
-const GLIBC_ON_LDD = GLIBC.toUpperCase();
-
-/**
- * This string is used to find if the {@link LDD_PATH} is musl
- * @type {string}
- */
-const MUSL_ON_LDD = MUSL.toLowerCase();
-
-const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-');
-
-const familyFromReport = () => {
-  const report = getReport();
-  if (report.header && report.header.glibcVersionRuntime) {
-    return GLIBC;
-  }
-  if (Array.isArray(report.sharedObjects)) {
-    if (report.sharedObjects.some(isFileMusl)) {
-      return MUSL;
-    }
-  }
-  return null;
-};
-
-const familyFromCommand = (out) => {
-  const [getconf, ldd1] = out.split(/[\r\n]+/);
-  if (getconf && getconf.includes(GLIBC)) {
-    return GLIBC;
-  }
-  if (ldd1 && ldd1.includes(MUSL)) {
-    return MUSL;
-  }
-  return null;
-};
-
-const getFamilyFromLddContent = (content) => {
-  if (content.includes(MUSL_ON_LDD)) {
-    return MUSL;
-  }
-  if (content.includes(GLIBC_ON_LDD)) {
-    return GLIBC;
-  }
-  return null;
-};
-
-const familyFromFilesystem = async () => {
-  if (cachedFamilyFilesystem !== undefined) {
-    return cachedFamilyFilesystem;
-  }
-  cachedFamilyFilesystem = null;
-  try {
-    const lddContent = await readFile(LDD_PATH);
-    cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
-  } catch (e) {}
-  return cachedFamilyFilesystem;
-};
-
-const familyFromFilesystemSync = () => {
-  if (cachedFamilyFilesystem !== undefined) {
-    return cachedFamilyFilesystem;
-  }
-  cachedFamilyFilesystem = null;
-  try {
-    const lddContent = readFileSync(LDD_PATH);
-    cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
-  } catch (e) {}
-  return cachedFamilyFilesystem;
-};
-
-/**
- * Resolves with the libc family when it can be determined, `null` otherwise.
- * @returns {Promise<?string>}
- */
-const family = async () => {
-  let family = null;
-  if (isLinux()) {
-    family = await familyFromFilesystem();
-    if (!family) {
-      family = familyFromReport();
-    }
-    if (!family) {
-      const out = await safeCommand();
-      family = familyFromCommand(out);
-    }
-  }
-  return family;
-};
-
-/**
- * Returns the libc family when it can be determined, `null` otherwise.
- * @returns {?string}
- */
-const familySync = () => {
-  let family = null;
-  if (isLinux()) {
-    family = familyFromFilesystemSync();
-    if (!family) {
-      family = familyFromReport();
-    }
-    if (!family) {
-      const out = safeCommandSync();
-      family = familyFromCommand(out);
-    }
-  }
-  return family;
-};
-
-/**
- * Resolves `true` only when the platform is Linux and the libc family is not `glibc`.
- * @returns {Promise<boolean>}
- */
-const isNonGlibcLinux = async () => isLinux() && await family() !== GLIBC;
-
-/**
- * Returns `true` only when the platform is Linux and the libc family is not `glibc`.
- * @returns {boolean}
- */
-const isNonGlibcLinuxSync = () => isLinux() && familySync() !== GLIBC;
-
-const versionFromFilesystem = async () => {
-  if (cachedVersionFilesystem !== undefined) {
-    return cachedVersionFilesystem;
-  }
-  cachedVersionFilesystem = null;
-  try {
-    const lddContent = await readFile(LDD_PATH);
-    const versionMatch = lddContent.match(RE_GLIBC_VERSION);
-    if (versionMatch) {
-      cachedVersionFilesystem = versionMatch[1];
-    }
-  } catch (e) {}
-  return cachedVersionFilesystem;
-};
-
-const versionFromFilesystemSync = () => {
-  if (cachedVersionFilesystem !== undefined) {
-    return cachedVersionFilesystem;
-  }
-  cachedVersionFilesystem = null;
-  try {
-    const lddContent = readFileSync(LDD_PATH);
-    const versionMatch = lddContent.match(RE_GLIBC_VERSION);
-    if (versionMatch) {
-      cachedVersionFilesystem = versionMatch[1];
-    }
-  } catch (e) {}
-  return cachedVersionFilesystem;
-};
-
-const versionFromReport = () => {
-  const report = getReport();
-  if (report.header && report.header.glibcVersionRuntime) {
-    return report.header.glibcVersionRuntime;
-  }
-  return null;
-};
-
-const versionSuffix = (s) => s.trim().split(/\s+/)[1];
-
-const versionFromCommand = (out) => {
-  const [getconf, ldd1, ldd2] = out.split(/[\r\n]+/);
-  if (getconf && getconf.includes(GLIBC)) {
-    return versionSuffix(getconf);
-  }
-  if (ldd1 && ldd2 && ldd1.includes(MUSL)) {
-    return versionSuffix(ldd2);
-  }
-  return null;
-};
-
-/**
- * Resolves with the libc version when it can be determined, `null` otherwise.
- * @returns {Promise<?string>}
- */
-const version = async () => {
-  let version = null;
-  if (isLinux()) {
-    version = await versionFromFilesystem();
-    if (!version) {
-      version = versionFromReport();
-    }
-    if (!version) {
-      const out = await safeCommand();
-      version = versionFromCommand(out);
-    }
-  }
-  return version;
-};
-
-/**
- * Returns the libc version when it can be determined, `null` otherwise.
- * @returns {?string}
- */
-const versionSync = () => {
-  let version = null;
-  if (isLinux()) {
-    version = versionFromFilesystemSync();
-    if (!version) {
-      version = versionFromReport();
-    }
-    if (!version) {
-      const out = safeCommandSync();
-      version = versionFromCommand(out);
-    }
-  }
-  return version;
-};
-
-module.exports = {
-  GLIBC,
-  MUSL,
-  family,
-  familySync,
-  isNonGlibcLinux,
-  isNonGlibcLinuxSync,
-  version,
-  versionSync
-};