agentworkshop 0.8.6 → 0.8.8

package/.output/server/node_modules/pg-protocol/dist/serializer.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serialize = void 0;
+const buffer_writer_1 = require("./buffer-writer");
+const writer = new buffer_writer_1.Writer();
+const startup = (opts) => {
+    // protocol version
+    writer.addInt16(3).addInt16(0);
+    for (const key of Object.keys(opts)) {
+        writer.addCString(key).addCString(opts[key]);
+    }
+    writer.addCString('client_encoding').addCString('UTF8');
+    const bodyBuffer = writer.addCString('').flush();
+    // this message is sent without a code
+    const length = bodyBuffer.length + 4;
+    return new buffer_writer_1.Writer().addInt32(length).add(bodyBuffer).flush();
+};
+const requestSsl = () => {
+    const response = Buffer.allocUnsafe(8);
+    response.writeInt32BE(8, 0);
+    response.writeInt32BE(80877103, 4);
+    return response;
+};
+const password = (password) => {
+    return writer.addCString(password).flush(112 /* code.startup */);
+};
+const sendSASLInitialResponseMessage = function (mechanism, initialResponse) {
+    // 0x70 = 'p'
+    writer.addCString(mechanism).addInt32PrefixedString(initialResponse);
+    return writer.flush(112 /* code.startup */);
+};
+const sendSCRAMClientFinalMessage = function (additionalData) {
+    return writer.addString(additionalData).flush(112 /* code.startup */);
+};
+const query = (text) => {
+    return writer.addCString(text).flush(81 /* code.query */);
+};
+const emptyArray = [];
+const parse = (query) => {
+    // expect something like this:
+    // { name: 'queryName',
+    //   text: 'select * from blah',
+    //   types: ['int8', 'bool'] }
+    // normalize missing query names to allow for null
+    const name = query.name || '';
+    if (name.length > 63) {
+        console.error('Warning! Postgres only supports 63 characters for query names.');
+        console.error('You supplied %s (%s)', name, name.length);
+        console.error('This can cause conflicts and silent errors executing queries');
+    }
+    const types = query.types || emptyArray;
+    const len = types.length;
+    const buffer = writer
+        .addCString(name) // name of query
+        .addCString(query.text) // actual query text
+        .addInt16(len);
+    for (let i = 0; i < len; i++) {
+        buffer.addInt32(types[i]);
+    }
+    return writer.flush(80 /* code.parse */);
+};
+const paramWriter = new buffer_writer_1.Writer();
+const writeValues = function (values, valueMapper) {
+    for (let i = 0; i < values.length; i++) {
+        const mappedVal = valueMapper ? valueMapper(values[i], i) : values[i];
+        if (mappedVal == null) {
+            // add the param type (string) to the writer
+            writer.addInt16(0 /* ParamType.STRING */);
+            // write -1 to the param writer to indicate null
+            paramWriter.addInt32(-1);
+        }
+        else if (mappedVal instanceof Buffer) {
+            // add the param type (binary) to the writer
+            writer.addInt16(1 /* ParamType.BINARY */);
+            // add the buffer to the param writer
+            paramWriter.addInt32(mappedVal.length);
+            paramWriter.add(mappedVal);
+        }
+        else {
+            // add the param type (string) to the writer
+            writer.addInt16(0 /* ParamType.STRING */);
+            // length prefix + UTF-8 bytes in one pass (Buffer.byteLength computed once)
+            paramWriter.addInt32PrefixedString(mappedVal);
+        }
+    }
+};
+const bind = (config = {}) => {
+    // normalize config
+    const portal = config.portal || '';
+    const statement = config.statement || '';
+    const binary = config.binary || false;
+    const values = config.values || emptyArray;
+    const len = values.length;
+    writer.addCString(portal).addCString(statement);
+    writer.addInt16(len);
+    try {
+        writeValues(values, config.valueMapper);
+    }
+    catch (err) {
+        writer.clear();
+        paramWriter.clear();
+        throw err;
+    }
+    writer.addInt16(len);
+    writer.add(paramWriter.flush());
+    // all results use the same format code
+    writer.addInt16(1);
+    // format code
+    writer.addInt16(binary ? 1 /* ParamType.BINARY */ : 0 /* ParamType.STRING */);
+    return writer.flush(66 /* code.bind */);
+};
+const emptyExecute = Buffer.from([69 /* code.execute */, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00]);
+const execute = (config) => {
+    // this is the happy path for most queries
+    if (!config || (!config.portal && !config.rows)) {
+        return emptyExecute;
+    }
+    const portal = config.portal || '';
+    const rows = config.rows || 0;
+    const portalLength = Buffer.byteLength(portal);
+    const len = 4 + portalLength + 1 + 4;
+    // one extra bit for code
+    const buff = Buffer.allocUnsafe(1 + len);
+    buff[0] = 69 /* code.execute */;
+    buff.writeInt32BE(len, 1);
+    buff.write(portal, 5, 'utf-8');
+    buff[portalLength + 5] = 0; // null terminate portal cString
+    buff.writeUInt32BE(rows, buff.length - 4);
+    return buff;
+};
+const cancel = (processID, secretKey) => {
+    const buffer = Buffer.allocUnsafe(16);
+    buffer.writeInt32BE(16, 0);
+    buffer.writeInt16BE(1234, 4);
+    buffer.writeInt16BE(5678, 6);
+    buffer.writeInt32BE(processID, 8);
+    buffer.writeInt32BE(secretKey, 12);
+    return buffer;
+};
+const cstringMessage = (code, string) => {
+    const stringLen = Buffer.byteLength(string);
+    const len = 4 + stringLen + 1;
+    // one extra bit for code
+    const buffer = Buffer.allocUnsafe(1 + len);
+    buffer[0] = code;
+    buffer.writeInt32BE(len, 1);
+    buffer.write(string, 5, 'utf-8');
+    buffer[len] = 0; // null terminate cString
+    return buffer;
+};
+const emptyDescribePortal = writer.addCString('P').flush(68 /* code.describe */);
+const emptyDescribeStatement = writer.addCString('S').flush(68 /* code.describe */);
+const describe = (msg) => {
+    return msg.name
+        ? cstringMessage(68 /* code.describe */, `${msg.type}${msg.name || ''}`)
+        : msg.type === 'P'
+            ? emptyDescribePortal
+            : emptyDescribeStatement;
+};
+const close = (msg) => {
+    const text = `${msg.type}${msg.name || ''}`;
+    return cstringMessage(67 /* code.close */, text);
+};
+const copyData = (chunk) => {
+    return writer.add(chunk).flush(100 /* code.copyFromChunk */);
+};
+const copyFail = (message) => {
+    return cstringMessage(102 /* code.copyFail */, message);
+};
+const codeOnlyBuffer = (code) => Buffer.from([code, 0x00, 0x00, 0x00, 0x04]);
+const flushBuffer = codeOnlyBuffer(72 /* code.flush */);
+const syncBuffer = codeOnlyBuffer(83 /* code.sync */);
+const endBuffer = codeOnlyBuffer(88 /* code.end */);
+const copyDoneBuffer = codeOnlyBuffer(99 /* code.copyDone */);
+const serialize = {
+    startup,
+    password,
+    requestSsl,
+    sendSASLInitialResponseMessage,
+    sendSCRAMClientFinalMessage,
+    query,
+    parse,
+    bind,
+    execute,
+    describe,
+    close,
+    flush: () => flushBuffer,
+    sync: () => syncBuffer,
+    end: () => endBuffer,
+    copyData,
+    copyDone: () => copyDoneBuffer,
+    copyFail,
+    cancel,
+};
+exports.serialize = serialize;
+//# sourceMappingURL=serializer.js.map

package/.output/server/node_modules/pg-protocol/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "pg-protocol",
+  "version": "1.16.0",
+  "description": "The postgres client/server binary protocol, implemented in TypeScript",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./dist/*": "./dist/*.js",
+    "./dist/*.js": "./dist/*.js"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@types/chai": "^4.2.7",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^16",
+    "chai": "^4.2.0",
+    "mocha": "^11.7.5",
+    "ts-node": "^8.5.4",
+    "typescript": "^6.0.3"
+  },
+  "scripts": {
+    "test": "mocha dist/**/*.test.js",
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "prepublish": "yarn build",
+    "pretest": "yarn build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/brianc/node-postgres.git",
+    "directory": "packages/pg-protocol"
+  },
+  "files": [
+    "/dist/*{js,ts,map}",
+    "/src",
+    "/esm"
+  ],
+  "gitHead": "df274d1ba9ad9d11a8f1079314faeafde7208207"
+}

package/.output/server/node_modules/pg-types/index.js

@@ -0,0 +1,47 @@
+var textParsers = require('./lib/textParsers');
+var binaryParsers = require('./lib/binaryParsers');
+var arrayParser = require('./lib/arrayParser');
+var builtinTypes = require('./lib/builtins');
+
+exports.getTypeParser = getTypeParser;
+exports.setTypeParser = setTypeParser;
+exports.arrayParser = arrayParser;
+exports.builtins = builtinTypes;
+
+var typeParsers = {
+  text: {},
+  binary: {}
+};
+
+//the empty parse function
+function noParse (val) {
+  return String(val);
+};
+
+//returns a function used to convert a specific type (specified by
+//oid) into a result javascript type
+//note: the oid can be obtained via the following sql query:
+//SELECT oid FROM pg_type WHERE typname = 'TYPE_NAME_HERE';
+function getTypeParser (oid, format) {
+  format = format || 'text';
+  if (!typeParsers[format]) {
+    return noParse;
+  }
+  return typeParsers[format][oid] || noParse;
+};
+
+function setTypeParser (oid, format, parseFn) {
+  if(typeof format == 'function') {
+    parseFn = format;
+    format = 'text';
+  }
+  typeParsers[format][oid] = parseFn;
+};
+
+textParsers.init(function(oid, converter) {
+  typeParsers.text[oid] = converter;
+});
+
+binaryParsers.init(function(oid, converter) {
+  typeParsers.binary[oid] = converter;
+});

package/.output/server/node_modules/pg-types/lib/arrayParser.js

@@ -0,0 +1,11 @@
+var array = require('postgres-array');
+
+module.exports = {
+  create: function (source, transform) {
+    return {
+      parse: function() {
+        return array.parse(source, transform);
+      }
+    };
+  }
+};

package/.output/server/node_modules/pg-types/lib/binaryParsers.js

@@ -0,0 +1,257 @@
+var parseInt64 = require('pg-int8');
+
+var parseBits = function(data, bits, offset, invert, callback) {
+  offset = offset || 0;
+  invert = invert || false;
+  callback = callback || function(lastValue, newValue, bits) { return (lastValue * Math.pow(2, bits)) + newValue; };
+  var offsetBytes = offset >> 3;
+
+  var inv = function(value) {
+    if (invert) {
+      return ~value & 0xff;
+    }
+
+    return value;
+  };
+
+  // read first (maybe partial) byte
+  var mask = 0xff;
+  var firstBits = 8 - (offset % 8);
+  if (bits < firstBits) {
+    mask = (0xff << (8 - bits)) & 0xff;
+    firstBits = bits;
+  }
+
+  if (offset) {
+    mask = mask >> (offset % 8);
+  }
+
+  var result = 0;
+  if ((offset % 8) + bits >= 8) {
+    result = callback(0, inv(data[offsetBytes]) & mask, firstBits);
+  }
+
+  // read bytes
+  var bytes = (bits + offset) >> 3;
+  for (var i = offsetBytes + 1; i < bytes; i++) {
+    result = callback(result, inv(data[i]), 8);
+  }
+
+  // bits to read, that are not a complete byte
+  var lastBits = (bits + offset) % 8;
+  if (lastBits > 0) {
+    result = callback(result, inv(data[bytes]) >> (8 - lastBits), lastBits);
+  }
+
+  return result;
+};
+
+var parseFloatFromBits = function(data, precisionBits, exponentBits) {
+  var bias = Math.pow(2, exponentBits - 1) - 1;
+  var sign = parseBits(data, 1);
+  var exponent = parseBits(data, exponentBits, 1);
+
+  if (exponent === 0) {
+    return 0;
+  }
+
+  // parse mantissa
+  var precisionBitsCounter = 1;
+  var parsePrecisionBits = function(lastValue, newValue, bits) {
+    if (lastValue === 0) {
+      lastValue = 1;
+    }
+
+    for (var i = 1; i <= bits; i++) {
+      precisionBitsCounter /= 2;
+      if ((newValue & (0x1 << (bits - i))) > 0) {
+        lastValue += precisionBitsCounter;
+      }
+    }
+
+    return lastValue;
+  };
+
+  var mantissa = parseBits(data, precisionBits, exponentBits + 1, false, parsePrecisionBits);
+
+  // special cases
+  if (exponent == (Math.pow(2, exponentBits + 1) - 1)) {
+    if (mantissa === 0) {
+      return (sign === 0) ? Infinity : -Infinity;
+    }
+
+    return NaN;
+  }
+
+  // normale number
+  return ((sign === 0) ? 1 : -1) * Math.pow(2, exponent - bias) * mantissa;
+};
+
+var parseInt16 = function(value) {
+  if (parseBits(value, 1) == 1) {
+    return -1 * (parseBits(value, 15, 1, true) + 1);
+  }
+
+  return parseBits(value, 15, 1);
+};
+
+var parseInt32 = function(value) {
+  if (parseBits(value, 1) == 1) {
+    return -1 * (parseBits(value, 31, 1, true) + 1);
+  }
+
+  return parseBits(value, 31, 1);
+};
+
+var parseFloat32 = function(value) {
+  return parseFloatFromBits(value, 23, 8);
+};
+
+var parseFloat64 = function(value) {
+  return parseFloatFromBits(value, 52, 11);
+};
+
+var parseNumeric = function(value) {
+  var sign = parseBits(value, 16, 32);
+  if (sign == 0xc000) {
+    return NaN;
+  }
+
+  var weight = Math.pow(10000, parseBits(value, 16, 16));
+  var result = 0;
+
+  var digits = [];
+  var ndigits = parseBits(value, 16);
+  for (var i = 0; i < ndigits; i++) {
+    result += parseBits(value, 16, 64 + (16 * i)) * weight;
+    weight /= 10000;
+  }
+
+  var scale = Math.pow(10, parseBits(value, 16, 48));
+  return ((sign === 0) ? 1 : -1) * Math.round(result * scale) / scale;
+};
+
+var parseDate = function(isUTC, value) {
+  var sign = parseBits(value, 1);
+  var rawValue = parseBits(value, 63, 1);
+
+  // discard usecs and shift from 2000 to 1970
+  var result = new Date((((sign === 0) ? 1 : -1) * rawValue / 1000) + 946684800000);
+
+  if (!isUTC) {
+    result.setTime(result.getTime() + result.getTimezoneOffset() * 60000);
+  }
+
+  // add microseconds to the date
+  result.usec = rawValue % 1000;
+  result.getMicroSeconds = function() {
+    return this.usec;
+  };
+  result.setMicroSeconds = function(value) {
+    this.usec = value;
+  };
+  result.getUTCMicroSeconds = function() {
+    return this.usec;
+  };
+
+  return result;
+};
+
+var parseArray = function(value) {
+  var dim = parseBits(value, 32);
+
+  var flags = parseBits(value, 32, 32);
+  var elementType = parseBits(value, 32, 64);
+
+  var offset = 96;
+  var dims = [];
+  for (var i = 0; i < dim; i++) {
+    // parse dimension
+    dims[i] = parseBits(value, 32, offset);
+    offset += 32;
+
+    // ignore lower bounds
+    offset += 32;
+  }
+
+  var parseElement = function(elementType) {
+    // parse content length
+    var length = parseBits(value, 32, offset);
+    offset += 32;
+
+    // parse null values
+    if (length == 0xffffffff) {
+      return null;
+    }
+
+    var result;
+    if ((elementType == 0x17) || (elementType == 0x14)) {
+      // int/bigint
+      result = parseBits(value, length * 8, offset);
+      offset += length * 8;
+      return result;
+    }
+    else if (elementType == 0x19) {
+      // string
+      result = value.toString(this.encoding, offset >> 3, (offset += (length << 3)) >> 3);
+      return result;
+    }
+    else {
+      console.log("ERROR: ElementType not implemented: " + elementType);
+    }
+  };
+
+  var parse = function(dimension, elementType) {
+    var array = [];
+    var i;
+
+    if (dimension.length > 1) {
+      var count = dimension.shift();
+      for (i = 0; i < count; i++) {
+        array[i] = parse(dimension, elementType);
+      }
+      dimension.unshift(count);
+    }
+    else {
+      for (i = 0; i < dimension[0]; i++) {
+        array[i] = parseElement(elementType);
+      }
+    }
+
+    return array;
+  };
+
+  return parse(dims, elementType);
+};
+
+var parseText = function(value) {
+  return value.toString('utf8');
+};
+
+var parseBool = function(value) {
+  if(value === null) return null;
+  return (parseBits(value, 8) > 0);
+};
+
+var init = function(register) {
+  register(20, parseInt64);
+  register(21, parseInt16);
+  register(23, parseInt32);
+  register(26, parseInt32);
+  register(1700, parseNumeric);
+  register(700, parseFloat32);
+  register(701, parseFloat64);
+  register(16, parseBool);
+  register(1114, parseDate.bind(null, false));
+  register(1184, parseDate.bind(null, true));
+  register(1000, parseArray);
+  register(1007, parseArray);
+  register(1016, parseArray);
+  register(1008, parseArray);
+  register(1009, parseArray);
+  register(25, parseText);
+};
+
+module.exports = {
+  init: init
+};

package/.output/server/node_modules/pg-types/lib/builtins.js

@@ -0,0 +1,73 @@
+/**
+ * Following query was used to generate this file:
+
+ SELECT json_object_agg(UPPER(PT.typname), PT.oid::int4 ORDER BY pt.oid)
+ FROM pg_type PT
+ WHERE typnamespace = (SELECT pgn.oid FROM pg_namespace pgn WHERE nspname = 'pg_catalog') -- Take only builting Postgres types with stable OID (extension types are not guaranted to be stable)
+ AND typtype = 'b' -- Only basic types
+ AND typelem = 0 -- Ignore aliases
+ AND typisdefined -- Ignore undefined types
+ */
+
+module.exports = {
+    BOOL: 16,
+    BYTEA: 17,
+    CHAR: 18,
+    INT8: 20,
+    INT2: 21,
+    INT4: 23,
+    REGPROC: 24,
+    TEXT: 25,
+    OID: 26,
+    TID: 27,
+    XID: 28,
+    CID: 29,
+    JSON: 114,
+    XML: 142,
+    PG_NODE_TREE: 194,
+    SMGR: 210,
+    PATH: 602,
+    POLYGON: 604,
+    CIDR: 650,
+    FLOAT4: 700,
+    FLOAT8: 701,
+    ABSTIME: 702,
+    RELTIME: 703,
+    TINTERVAL: 704,
+    CIRCLE: 718,
+    MACADDR8: 774,
+    MONEY: 790,
+    MACADDR: 829,
+    INET: 869,
+    ACLITEM: 1033,
+    BPCHAR: 1042,
+    VARCHAR: 1043,
+    DATE: 1082,
+    TIME: 1083,
+    TIMESTAMP: 1114,
+    TIMESTAMPTZ: 1184,
+    INTERVAL: 1186,
+    TIMETZ: 1266,
+    BIT: 1560,
+    VARBIT: 1562,
+    NUMERIC: 1700,
+    REFCURSOR: 1790,
+    REGPROCEDURE: 2202,
+    REGOPER: 2203,
+    REGOPERATOR: 2204,
+    REGCLASS: 2205,
+    REGTYPE: 2206,
+    UUID: 2950,
+    TXID_SNAPSHOT: 2970,
+    PG_LSN: 3220,
+    PG_NDISTINCT: 3361,
+    PG_DEPENDENCIES: 3402,
+    TSVECTOR: 3614,
+    TSQUERY: 3615,
+    GTSVECTOR: 3642,
+    REGCONFIG: 3734,
+    REGDICTIONARY: 3769,
+    JSONB: 3802,
+    REGNAMESPACE: 4089,
+    REGROLE: 4096
+};