@pleaseai/agent 0.1.16 → 0.1.17

package/.output/server/node_modules/@libsql/client/lib-esm/ws.js

@@ -0,0 +1,359 @@
+import * as hrana from "@libsql/hrana-client";
+import { LibsqlError } from "@libsql/core/api";
+import { expandConfig } from "@libsql/core/config";
+import { HranaTransaction, executeHranaBatch, stmtToHrana, resultSetFromHrana, mapHranaError, } from "./hrana.js";
+import { SqlCache } from "./sql_cache.js";
+import { encodeBaseUrl } from "@libsql/core/uri";
+import { supportedUrlLink } from "@libsql/core/util";
+import promiseLimit from "promise-limit";
+export * from "@libsql/core/api";
+export function createClient(config) {
+    return _createClient(expandConfig(config, false));
+}
+/** @private */
+export function _createClient(config) {
+    if (config.scheme !== "wss" && config.scheme !== "ws") {
+        throw new LibsqlError('The WebSocket client supports only "libsql:", "wss:" and "ws:" URLs, ' +
+            `got ${JSON.stringify(config.scheme + ":")}. For more information, please read ${supportedUrlLink}`, "URL_SCHEME_NOT_SUPPORTED");
+    }
+    if (config.encryptionKey !== undefined) {
+        throw new LibsqlError("Encryption key is not supported by the remote client.", "ENCRYPTION_KEY_NOT_SUPPORTED");
+    }
+    if (config.scheme === "ws" && config.tls) {
+        throw new LibsqlError(`A "ws:" URL cannot opt into TLS by using ?tls=1`, "URL_INVALID");
+    }
+    else if (config.scheme === "wss" && !config.tls) {
+        throw new LibsqlError(`A "wss:" URL cannot opt out of TLS by using ?tls=0`, "URL_INVALID");
+    }
+    const url = encodeBaseUrl(config.scheme, config.authority, config.path);
+    let client;
+    try {
+        client = hrana.openWs(url, config.authToken);
+    }
+    catch (e) {
+        if (e instanceof hrana.WebSocketUnsupportedError) {
+            const suggestedScheme = config.scheme === "wss" ? "https" : "http";
+            const suggestedUrl = encodeBaseUrl(suggestedScheme, config.authority, config.path);
+            throw new LibsqlError("This environment does not support WebSockets, please switch to the HTTP client by using " +
+                `a "${suggestedScheme}:" URL (${JSON.stringify(suggestedUrl)}). ` +
+                `For more information, please read ${supportedUrlLink}`, "WEBSOCKETS_NOT_SUPPORTED");
+        }
+        throw mapHranaError(e);
+    }
+    return new WsClient(client, url, config.authToken, config.intMode, config.concurrency);
+}
+const maxConnAgeMillis = 60 * 1000;
+const sqlCacheCapacity = 100;
+export class WsClient {
+    #url;
+    #authToken;
+    #intMode;
+    // State of the current connection. The `hrana.WsClient` inside may be closed at any moment due to an
+    // asynchronous error.
+    #connState;
+    // If defined, this is a connection that will be used in the future, once it is ready.
+    #futureConnState;
+    closed;
+    protocol;
+    #isSchemaDatabase;
+    #promiseLimitFunction;
+    /** @private */
+    constructor(client, url, authToken, intMode, concurrency) {
+        this.#url = url;
+        this.#authToken = authToken;
+        this.#intMode = intMode;
+        this.#connState = this.#openConn(client);
+        this.#futureConnState = undefined;
+        this.closed = false;
+        this.protocol = "ws";
+        this.#promiseLimitFunction = promiseLimit(concurrency);
+    }
+    async limit(fn) {
+        return this.#promiseLimitFunction(fn);
+    }
+    async execute(stmtOrSql, args) {
+        let stmt;
+        if (typeof stmtOrSql === "string") {
+            stmt = {
+                sql: stmtOrSql,
+                args: args || [],
+            };
+        }
+        else {
+            stmt = stmtOrSql;
+        }
+        return this.limit(async () => {
+            const streamState = await this.#openStream();
+            try {
+                const hranaStmt = stmtToHrana(stmt);
+                // Schedule all operations synchronously, so they will be pipelined and executed in a single
+                // network roundtrip.
+                streamState.conn.sqlCache.apply([hranaStmt]);
+                const hranaRowsPromise = streamState.stream.query(hranaStmt);
+                streamState.stream.closeGracefully();
+                const hranaRowsResult = await hranaRowsPromise;
+                return resultSetFromHrana(hranaRowsResult);
+            }
+            catch (e) {
+                throw mapHranaError(e);
+            }
+            finally {
+                this._closeStream(streamState);
+            }
+        });
+    }
+    async batch(stmts, mode = "deferred") {
+        return this.limit(async () => {
+            const streamState = await this.#openStream();
+            try {
+                const normalizedStmts = stmts.map((stmt) => {
+                    if (Array.isArray(stmt)) {
+                        return {
+                            sql: stmt[0],
+                            args: stmt[1] || [],
+                        };
+                    }
+                    return stmt;
+                });
+                const hranaStmts = normalizedStmts.map(stmtToHrana);
+                const version = await streamState.conn.client.getVersion();
+                // Schedule all operations synchronously, so they will be pipelined and executed in a single
+                // network roundtrip.
+                streamState.conn.sqlCache.apply(hranaStmts);
+                const batch = streamState.stream.batch(version >= 3);
+                const resultsPromise = executeHranaBatch(mode, version, batch, hranaStmts);
+                const results = await resultsPromise;
+                return results;
+            }
+            catch (e) {
+                throw mapHranaError(e);
+            }
+            finally {
+                this._closeStream(streamState);
+            }
+        });
+    }
+    async migrate(stmts) {
+        return this.limit(async () => {
+            const streamState = await this.#openStream();
+            try {
+                const hranaStmts = stmts.map(stmtToHrana);
+                const version = await streamState.conn.client.getVersion();
+                // Schedule all operations synchronously, so they will be pipelined and executed in a single
+                // network roundtrip.
+                const batch = streamState.stream.batch(version >= 3);
+                const resultsPromise = executeHranaBatch("deferred", version, batch, hranaStmts, true);
+                const results = await resultsPromise;
+                return results;
+            }
+            catch (e) {
+                throw mapHranaError(e);
+            }
+            finally {
+                this._closeStream(streamState);
+            }
+        });
+    }
+    async transaction(mode = "write") {
+        return this.limit(async () => {
+            const streamState = await this.#openStream();
+            try {
+                const version = await streamState.conn.client.getVersion();
+                // the BEGIN statement will be batched with the first statement on the transaction to save a
+                // network roundtrip
+                return new WsTransaction(this, streamState, mode, version);
+            }
+            catch (e) {
+                this._closeStream(streamState);
+                throw mapHranaError(e);
+            }
+        });
+    }
+    async executeMultiple(sql) {
+        return this.limit(async () => {
+            const streamState = await this.#openStream();
+            try {
+                // Schedule all operations synchronously, so they will be pipelined and executed in a single
+                // network roundtrip.
+                const promise = streamState.stream.sequence(sql);
+                streamState.stream.closeGracefully();
+                await promise;
+            }
+            catch (e) {
+                throw mapHranaError(e);
+            }
+            finally {
+                this._closeStream(streamState);
+            }
+        });
+    }
+    sync() {
+        throw new LibsqlError("sync not supported in ws mode", "SYNC_NOT_SUPPORTED");
+    }
+    async #openStream() {
+        if (this.closed) {
+            throw new LibsqlError("The client is closed", "CLIENT_CLOSED");
+        }
+        const now = new Date();
+        const ageMillis = now.valueOf() - this.#connState.openTime.valueOf();
+        if (ageMillis > maxConnAgeMillis &&
+            this.#futureConnState === undefined) {
+            // The existing connection is too old, let's open a new one.
+            const futureConnState = this.#openConn();
+            this.#futureConnState = futureConnState;
+            // However, if we used `futureConnState` immediately, we would introduce additional latency,
+            // because we would have to wait for the WebSocket handshake to complete, even though we may a
+            // have perfectly good existing connection in `this.#connState`!
+            //
+            // So we wait until the `hrana.Client.getVersion()` operation completes (which happens when the
+            // WebSocket hanshake completes), and only then we replace `this.#connState` with
+            // `futureConnState`, which is stored in `this.#futureConnState` in the meantime.
+            futureConnState.client.getVersion().then((_version) => {
+                if (this.#connState !== futureConnState) {
+                    // We need to close `this.#connState` before we replace it. However, it is possible
+                    // that `this.#connState` has already been replaced: see the code below.
+                    if (this.#connState.streamStates.size === 0) {
+                        this.#connState.client.close();
+                    }
+                    else {
+                        // If there are existing streams on the connection, we must not close it, because
+                        // these streams would be broken. The last stream to be closed will also close the
+                        // connection in `_closeStream()`.
+                    }
+                }
+                this.#connState = futureConnState;
+                this.#futureConnState = undefined;
+            }, (_e) => {
+                // If the new connection could not be established, let's just ignore the error and keep
+                // using the existing connection.
+                this.#futureConnState = undefined;
+            });
+        }
+        if (this.#connState.client.closed) {
+            // An error happened on this connection and it has been closed. Let's try to seamlessly reconnect.
+            try {
+                if (this.#futureConnState !== undefined) {
+                    // We are already in the process of opening a new connection, so let's just use it
+                    // immediately.
+                    this.#connState = this.#futureConnState;
+                }
+                else {
+                    this.#connState = this.#openConn();
+                }
+            }
+            catch (e) {
+                throw mapHranaError(e);
+            }
+        }
+        const connState = this.#connState;
+        try {
+            // Now we wait for the WebSocket handshake to complete (if it hasn't completed yet). Note that
+            // this does not increase latency, because any messages that we would send on the WebSocket before
+            // the handshake would be queued until the handshake is completed anyway.
+            if (connState.useSqlCache === undefined) {
+                connState.useSqlCache =
+                    (await connState.client.getVersion()) >= 2;
+                if (connState.useSqlCache) {
+                    connState.sqlCache.capacity = sqlCacheCapacity;
+                }
+            }
+            const stream = connState.client.openStream();
+            stream.intMode = this.#intMode;
+            const streamState = { conn: connState, stream };
+            connState.streamStates.add(streamState);
+            return streamState;
+        }
+        catch (e) {
+            throw mapHranaError(e);
+        }
+    }
+    #openConn(client) {
+        try {
+            client ??= hrana.openWs(this.#url, this.#authToken);
+            return {
+                client,
+                useSqlCache: undefined,
+                sqlCache: new SqlCache(client, 0),
+                openTime: new Date(),
+                streamStates: new Set(),
+            };
+        }
+        catch (e) {
+            throw mapHranaError(e);
+        }
+    }
+    async reconnect() {
+        try {
+            for (const st of Array.from(this.#connState.streamStates)) {
+                try {
+                    st.stream.close();
+                }
+                catch { }
+            }
+            this.#connState.client.close();
+        }
+        catch { }
+        if (this.#futureConnState) {
+            try {
+                this.#futureConnState.client.close();
+            }
+            catch { }
+            this.#futureConnState = undefined;
+        }
+        const next = this.#openConn();
+        const version = await next.client.getVersion();
+        next.useSqlCache = version >= 2;
+        if (next.useSqlCache) {
+            next.sqlCache.capacity = sqlCacheCapacity;
+        }
+        this.#connState = next;
+        this.closed = false;
+    }
+    _closeStream(streamState) {
+        streamState.stream.close();
+        const connState = streamState.conn;
+        connState.streamStates.delete(streamState);
+        if (connState.streamStates.size === 0 &&
+            connState !== this.#connState) {
+            // We are not using this connection anymore and this is the last stream that was using it, so we
+            // must close it now.
+            connState.client.close();
+        }
+    }
+    close() {
+        this.#connState.client.close();
+        this.closed = true;
+        if (this.#futureConnState) {
+            try {
+                this.#futureConnState.client.close();
+            }
+            catch { }
+            this.#futureConnState = undefined;
+        }
+        this.closed = true;
+    }
+}
+export class WsTransaction extends HranaTransaction {
+    #client;
+    #streamState;
+    /** @private */
+    constructor(client, state, mode, version) {
+        super(mode, version);
+        this.#client = client;
+        this.#streamState = state;
+    }
+    /** @private */
+    _getStream() {
+        return this.#streamState.stream;
+    }
+    /** @private */
+    _getSqlCache() {
+        return this.#streamState.conn.sqlCache;
+    }
+    close() {
+        this.#client._closeStream(this.#streamState);
+    }
+    get closed() {
+        return this.#streamState.stream.closed;
+    }
+}

package/.output/server/node_modules/@libsql/client/package.json

@@ -0,0 +1,123 @@
+{
+  "name": "@libsql/client",
+  "version": "0.17.0",
+  "keywords": [
+    "libsql",
+    "database",
+    "sqlite",
+    "serverless",
+    "vercel",
+    "netlify",
+    "lambda"
+  ],
+  "description": "libSQL driver for TypeScript and JavaScript",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tursodatabase/libsql-client-ts",
+    "directory": "packages/libsql-client"
+  },
+  "authors": [
+    "Jan Špaček <honza@chiselstrike.com>",
+    "Pekka Enberg <penberg@chiselstrike.com>",
+    "Jan Plhak <jp@chiselstrike.com>"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "main": "lib-cjs/node.js",
+  "types": "lib-esm/node.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib-esm/node.d.ts",
+      "import": {
+        "workerd": "./lib-esm/web.js",
+        "deno": "./lib-esm/node.js",
+        "edge-light": "./lib-esm/web.js",
+        "netlify": "./lib-esm/web.js",
+        "node": "./lib-esm/node.js",
+        "browser": "./lib-esm/web.js",
+        "default": "./lib-esm/node.js"
+      },
+      "require": "./lib-cjs/node.js"
+    },
+    "./node": {
+      "types": "./lib-esm/node.d.ts",
+      "import": "./lib-esm/node.js",
+      "require": "./lib-cjs/node.js"
+    },
+    "./http": {
+      "types": "./lib-esm/http.d.ts",
+      "import": "./lib-esm/http.js",
+      "require": "./lib-cjs/http.js"
+    },
+    "./ws": {
+      "types": "./lib-esm/ws.d.ts",
+      "import": "./lib-esm/ws.js",
+      "require": "./lib-cjs/ws.js"
+    },
+    "./sqlite3": {
+      "types": "./lib-esm/sqlite3.d.ts",
+      "import": "./lib-esm/sqlite3.js",
+      "require": "./lib-cjs/sqlite3.js"
+    },
+    "./web": {
+      "types": "./lib-esm/web.d.ts",
+      "import": "./lib-esm/web.js",
+      "require": "./lib-cjs/web.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./lib-esm/node.d.ts"
+      ],
+      "http": [
+        "./lib-esm/http.d.ts"
+      ],
+      "hrana": [
+        "./lib-esm/hrana.d.ts"
+      ],
+      "sqlite3": [
+        "./lib-esm/sqlite3.d.ts"
+      ],
+      "web": [
+        "./lib-esm/web.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "lib-cjs/**",
+    "lib-esm/**",
+    "README.md"
+  ],
+  "scripts": {
+    "prepublishOnly": "npm run build",
+    "prebuild": "rm -rf ./lib-cjs ./lib-esm",
+    "build": "npm run build:cjs && npm run build:esm",
+    "build:cjs": "tsc -p tsconfig.build-cjs.json",
+    "build:esm": "tsc -p tsconfig.build-esm.json",
+    "format:check": "prettier --check .",
+    "postbuild": "cp package-cjs.json ./lib-cjs/package.json",
+    "test": "jest --runInBand",
+    "typecheck": "tsc --noEmit",
+    "typedoc": "rm -rf ./docs && typedoc",
+    "lint-staged": "lint-staged"
+  },
+  "dependencies": {
+    "@libsql/core": "^0.17.0",
+    "@libsql/hrana-client": "^0.9.0",
+    "js-base64": "^3.7.5",
+    "libsql": "^0.5.22",
+    "promise-limit": "^2.7.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.2.5",
+    "@types/node": "^18.15.5",
+    "jest": "^29.3.1",
+    "lint-staged": "^15.2.2",
+    "msw": "^2.3.0",
+    "prettier": "3.2.5",
+    "ts-jest": "^29.0.5",
+    "typedoc": "^0.23.28",
+    "typescript": "^4.9.4"
+  }
+}

package/.output/server/node_modules/@libsql/core/lib-esm/api.js

@@ -0,0 +1,29 @@
+/** Error thrown by the client. */
+export class LibsqlError extends Error {
+    /** Machine-readable error code. */
+    code;
+    /** Extended error code with more specific information (e.g., SQLITE_CONSTRAINT_PRIMARYKEY). */
+    extendedCode;
+    /** Raw numeric error code */
+    rawCode;
+    constructor(message, code, extendedCode, rawCode, cause) {
+        if (code !== undefined) {
+            message = `${code}: ${message}`;
+        }
+        super(message, { cause });
+        this.code = code;
+        this.extendedCode = extendedCode;
+        this.rawCode = rawCode;
+        this.name = "LibsqlError";
+    }
+}
+/** Error thrown by the client during batch operations. */
+export class LibsqlBatchError extends LibsqlError {
+    /** The zero-based index of the statement that failed in the batch. */
+    statementIndex;
+    constructor(message, statementIndex, code, extendedCode, rawCode, cause) {
+        super(message, code, extendedCode, rawCode, cause);
+        this.statementIndex = statementIndex;
+        this.name = "LibsqlBatchError";
+    }
+}

package/.output/server/node_modules/@libsql/core/lib-esm/config.js

@@ -0,0 +1,138 @@
+import { LibsqlError } from "./api.js";
+import { parseUri } from "./uri.js";
+import { supportedUrlLink } from "./util.js";
+const inMemoryMode = ":memory:";
+export function isInMemoryConfig(config) {
+    return (config.scheme === "file" &&
+        (config.path === ":memory:" || config.path.startsWith(":memory:?")));
+}
+export function expandConfig(config, preferHttp) {
+    if (typeof config !== "object") {
+        // produce a reasonable error message in the common case where users type
+        // `createClient("libsql://...")` instead of `createClient({url: "libsql://..."})`
+        throw new TypeError(`Expected client configuration as object, got ${typeof config}`);
+    }
+    let { url, authToken, tls, intMode, concurrency } = config;
+    // fill simple defaults right here
+    concurrency = Math.max(0, concurrency || 20);
+    intMode ??= "number";
+    let connectionQueryParams = []; // recognized query parameters which we sanitize through white list of valid key-value pairs
+    // convert plain :memory: url to URI format to make logic more uniform
+    if (url === inMemoryMode) {
+        url = "file::memory:";
+    }
+    // parse url parameters first and override config with update values
+    const uri = parseUri(url);
+    const originalUriScheme = uri.scheme.toLowerCase();
+    const isInMemoryMode = originalUriScheme === "file" &&
+        uri.path === inMemoryMode &&
+        uri.authority === undefined;
+    let queryParamsDef;
+    if (isInMemoryMode) {
+        queryParamsDef = {
+            cache: {
+                values: ["shared", "private"],
+                update: (key, value) => connectionQueryParams.push(`${key}=${value}`),
+            },
+        };
+    }
+    else {
+        queryParamsDef = {
+            tls: {
+                values: ["0", "1"],
+                update: (_, value) => (tls = value === "1"),
+            },
+            authToken: {
+                update: (_, value) => (authToken = value),
+            },
+        };
+    }
+    for (const { key, value } of uri.query?.pairs ?? []) {
+        if (!Object.hasOwn(queryParamsDef, key)) {
+            throw new LibsqlError(`Unsupported URL query parameter ${JSON.stringify(key)}`, "URL_PARAM_NOT_SUPPORTED");
+        }
+        const queryParamDef = queryParamsDef[key];
+        if (queryParamDef.values !== undefined &&
+            !queryParamDef.values.includes(value)) {
+            throw new LibsqlError(`Unknown value for the "${key}" query argument: ${JSON.stringify(value)}. Supported values are: [${queryParamDef.values.map((x) => '"' + x + '"').join(", ")}]`, "URL_INVALID");
+        }
+        if (queryParamDef.update !== undefined) {
+            queryParamDef?.update(key, value);
+        }
+    }
+    // fill complex defaults & validate config
+    const connectionQueryParamsString = connectionQueryParams.length === 0
+        ? ""
+        : `?${connectionQueryParams.join("&")}`;
+    const path = uri.path + connectionQueryParamsString;
+    let scheme;
+    if (originalUriScheme === "libsql") {
+        if (tls === false) {
+            if (uri.authority?.port === undefined) {
+                throw new LibsqlError('A "libsql:" URL with ?tls=0 must specify an explicit port', "URL_INVALID");
+            }
+            scheme = preferHttp ? "http" : "ws";
+        }
+        else {
+            scheme = preferHttp ? "https" : "wss";
+        }
+    }
+    else {
+        scheme = originalUriScheme;
+    }
+    if (scheme === "http" || scheme === "ws") {
+        tls ??= false;
+    }
+    else {
+        tls ??= true;
+    }
+    if (scheme !== "http" &&
+        scheme !== "ws" &&
+        scheme !== "https" &&
+        scheme !== "wss" &&
+        scheme !== "file") {
+        throw new LibsqlError('The client supports only "libsql:", "wss:", "ws:", "https:", "http:" and "file:" URLs, ' +
+            `got ${JSON.stringify(uri.scheme + ":")}. ` +
+            `For more information, please read ${supportedUrlLink}`, "URL_SCHEME_NOT_SUPPORTED");
+    }
+    if (intMode !== "number" && intMode !== "bigint" && intMode !== "string") {
+        throw new TypeError(`Invalid value for intMode, expected "number", "bigint" or "string", got ${JSON.stringify(intMode)}`);
+    }
+    if (uri.fragment !== undefined) {
+        throw new LibsqlError(`URL fragments are not supported: ${JSON.stringify("#" + uri.fragment)}`, "URL_INVALID");
+    }
+    if (isInMemoryMode) {
+        return {
+            scheme: "file",
+            tls: false,
+            path,
+            intMode,
+            concurrency,
+            syncUrl: config.syncUrl,
+            syncInterval: config.syncInterval,
+            readYourWrites: config.readYourWrites,
+            offline: config.offline,
+            fetch: config.fetch,
+            authToken: undefined,
+            encryptionKey: undefined,
+            remoteEncryptionKey: undefined,
+            authority: undefined,
+        };
+    }
+    return {
+        scheme,
+        tls,
+        authority: uri.authority,
+        path,
+        authToken,
+        intMode,
+        concurrency,
+        encryptionKey: config.encryptionKey,
+        remoteEncryptionKey: config.remoteEncryptionKey,
+        syncUrl: config.syncUrl,
+        syncInterval: config.syncInterval,
+        readYourWrites: config.readYourWrites,
+        offline: config.offline,
+        fetch: config.fetch,
+    };
+}