agentworkshop 0.8.6 → 0.8.8

package/.output/server/node_modules/pg-protocol/dist/buffer-writer.js

@@ -0,0 +1,104 @@
+"use strict";
+//binary data writer tuned for encoding binary specific to the postgres binary protocol
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Writer = void 0;
+class Writer {
+    constructor(size = 256) {
+        this.size = size;
+        this.offset = 5;
+        this.headerPosition = 0;
+        this.buffer = Buffer.allocUnsafe(size);
+    }
+    ensure(size) {
+        const remaining = this.buffer.length - this.offset;
+        if (remaining < size) {
+            const oldBuffer = this.buffer;
+            // exponential growth factor of around ~ 1.5
+            // https://stackoverflow.com/questions/2269063/buffer-growth-strategy
+            const newSize = oldBuffer.length + (oldBuffer.length >> 1) + size;
+            this.buffer = Buffer.allocUnsafe(newSize);
+            oldBuffer.copy(this.buffer);
+        }
+    }
+    addInt32(num) {
+        this.ensure(4);
+        this.buffer[this.offset++] = (num >>> 24) & 0xff;
+        this.buffer[this.offset++] = (num >>> 16) & 0xff;
+        this.buffer[this.offset++] = (num >>> 8) & 0xff;
+        this.buffer[this.offset++] = (num >>> 0) & 0xff;
+        return this;
+    }
+    addInt16(num) {
+        this.ensure(2);
+        this.buffer[this.offset++] = (num >>> 8) & 0xff;
+        this.buffer[this.offset++] = (num >>> 0) & 0xff;
+        return this;
+    }
+    addCString(string) {
+        if (!string) {
+            this.ensure(1);
+        }
+        else {
+            const len = Buffer.byteLength(string);
+            this.ensure(len + 1); // +1 for null terminator
+            this.buffer.write(string, this.offset, 'utf-8');
+            this.offset += len;
+        }
+        this.buffer[this.offset++] = 0; // null terminator
+        return this;
+    }
+    addString(string = '') {
+        const len = Buffer.byteLength(string);
+        this.ensure(len);
+        this.buffer.write(string, this.offset);
+        this.offset += len;
+        return this;
+    }
+    // Write an Int32 byte-length prefix immediately followed by the string's UTF-8
+    // bytes. Postgres' Bind wire format prefixes every parameter with its length,
+    // and doing it in one method computes Buffer.byteLength ONCE — the previous
+    // `addInt32(Buffer.byteLength(s)).addString(s)` pairing scanned the string
+    // three times (byteLength for the prefix, byteLength again inside addString,
+    // then the encode), which is costly for large text parameters.
+    addInt32PrefixedString(string) {
+        const len = Buffer.byteLength(string);
+        this.ensure(4 + len);
+        const buffer = this.buffer;
+        let offset = this.offset;
+        buffer[offset++] = (len >>> 24) & 0xff;
+        buffer[offset++] = (len >>> 16) & 0xff;
+        buffer[offset++] = (len >>> 8) & 0xff;
+        buffer[offset++] = (len >>> 0) & 0xff;
+        buffer.write(string, offset, 'utf-8');
+        this.offset = offset + len;
+        return this;
+    }
+    add(otherBuffer) {
+        this.ensure(otherBuffer.length);
+        otherBuffer.copy(this.buffer, this.offset);
+        this.offset += otherBuffer.length;
+        return this;
+    }
+    join(code) {
+        if (code) {
+            this.buffer[this.headerPosition] = code;
+            //length is everything in this packet minus the code
+            const length = this.offset - (this.headerPosition + 1);
+            this.buffer.writeInt32BE(length, this.headerPosition + 1);
+        }
+        return this.buffer.slice(code ? 0 : 5, this.offset);
+    }
+    flush(code) {
+        const result = this.join(code);
+        this.offset = 5;
+        this.headerPosition = 0;
+        this.buffer = Buffer.allocUnsafe(this.size);
+        return result;
+    }
+    clear() {
+        this.offset = 5;
+        this.headerPosition = 0;
+    }
+}
+exports.Writer = Writer;
+//# sourceMappingURL=buffer-writer.js.map

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseError = exports.serialize = void 0;
+exports.parse = parse;
+const messages_1 = require("./messages");
+Object.defineProperty(exports, "DatabaseError", { enumerable: true, get: function () { return messages_1.DatabaseError; } });
+const serializer_1 = require("./serializer");
+Object.defineProperty(exports, "serialize", { enumerable: true, get: function () { return serializer_1.serialize; } });
+const parser_1 = require("./parser");
+function parse(stream, callback) {
+    const parser = new parser_1.Parser();
+    stream.on('data', (buffer) => parser.parse(buffer, callback));
+    return new Promise((resolve) => stream.on('end', () => resolve()));
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoticeMessage = exports.DataRowMessage = exports.CommandCompleteMessage = exports.ReadyForQueryMessage = exports.NotificationResponseMessage = exports.BackendKeyDataMessage = exports.AuthenticationMD5Password = exports.ParameterStatusMessage = exports.ParameterDescriptionMessage = exports.RowDescriptionMessage = exports.Field = exports.CopyResponse = exports.CopyDataMessage = exports.DatabaseError = exports.copyDone = exports.emptyQuery = exports.replicationStart = exports.portalSuspended = exports.noData = exports.closeComplete = exports.bindComplete = exports.parseComplete = void 0;
+exports.parseComplete = {
+    name: 'parseComplete',
+    length: 5,
+};
+exports.bindComplete = {
+    name: 'bindComplete',
+    length: 5,
+};
+exports.closeComplete = {
+    name: 'closeComplete',
+    length: 5,
+};
+exports.noData = {
+    name: 'noData',
+    length: 5,
+};
+exports.portalSuspended = {
+    name: 'portalSuspended',
+    length: 5,
+};
+exports.replicationStart = {
+    name: 'replicationStart',
+    length: 4,
+};
+exports.emptyQuery = {
+    name: 'emptyQuery',
+    length: 4,
+};
+exports.copyDone = {
+    name: 'copyDone',
+    length: 4,
+};
+class DatabaseError extends Error {
+    constructor(message, length, name) {
+        super(message);
+        this.length = length;
+        this.name = name;
+    }
+}
+exports.DatabaseError = DatabaseError;
+class CopyDataMessage {
+    constructor(length, chunk) {
+        this.length = length;
+        this.chunk = chunk;
+        this.name = 'copyData';
+    }
+}
+exports.CopyDataMessage = CopyDataMessage;
+class CopyResponse {
+    constructor(length, name, binary, columnCount) {
+        this.length = length;
+        this.name = name;
+        this.binary = binary;
+        this.columnTypes = new Array(columnCount);
+    }
+}
+exports.CopyResponse = CopyResponse;
+class Field {
+    constructor(name, tableID, columnID, dataTypeID, dataTypeSize, dataTypeModifier, format) {
+        this.name = name;
+        this.tableID = tableID;
+        this.columnID = columnID;
+        this.dataTypeID = dataTypeID;
+        this.dataTypeSize = dataTypeSize;
+        this.dataTypeModifier = dataTypeModifier;
+        this.format = format;
+    }
+}
+exports.Field = Field;
+class RowDescriptionMessage {
+    constructor(length, fieldCount) {
+        this.length = length;
+        this.fieldCount = fieldCount;
+        this.name = 'rowDescription';
+        this.fields = new Array(this.fieldCount);
+    }
+}
+exports.RowDescriptionMessage = RowDescriptionMessage;
+class ParameterDescriptionMessage {
+    constructor(length, parameterCount) {
+        this.length = length;
+        this.parameterCount = parameterCount;
+        this.name = 'parameterDescription';
+        this.dataTypeIDs = new Array(this.parameterCount);
+    }
+}
+exports.ParameterDescriptionMessage = ParameterDescriptionMessage;
+class ParameterStatusMessage {
+    constructor(length, parameterName, parameterValue) {
+        this.length = length;
+        this.parameterName = parameterName;
+        this.parameterValue = parameterValue;
+        this.name = 'parameterStatus';
+    }
+}
+exports.ParameterStatusMessage = ParameterStatusMessage;
+class AuthenticationMD5Password {
+    constructor(length, salt) {
+        this.length = length;
+        this.salt = salt;
+        this.name = 'authenticationMD5Password';
+    }
+}
+exports.AuthenticationMD5Password = AuthenticationMD5Password;
+class BackendKeyDataMessage {
+    constructor(length, processID, secretKey) {
+        this.length = length;
+        this.processID = processID;
+        this.secretKey = secretKey;
+        this.name = 'backendKeyData';
+    }
+}
+exports.BackendKeyDataMessage = BackendKeyDataMessage;
+class NotificationResponseMessage {
+    constructor(length, processId, channel, payload) {
+        this.length = length;
+        this.processId = processId;
+        this.channel = channel;
+        this.payload = payload;
+        this.name = 'notification';
+    }
+}
+exports.NotificationResponseMessage = NotificationResponseMessage;
+class ReadyForQueryMessage {
+    constructor(length, status) {
+        this.length = length;
+        this.status = status;
+        this.name = 'readyForQuery';
+    }
+}
+exports.ReadyForQueryMessage = ReadyForQueryMessage;
+class CommandCompleteMessage {
+    constructor(length, text) {
+        this.length = length;
+        this.text = text;
+        this.name = 'commandComplete';
+    }
+}
+exports.CommandCompleteMessage = CommandCompleteMessage;
+class DataRowMessage {
+    constructor(length, fields) {
+        this.length = length;
+        this.fields = fields;
+        this.name = 'dataRow';
+        this.fieldCount = fields.length;
+    }
+}
+exports.DataRowMessage = DataRowMessage;
+class NoticeMessage {
+    constructor(length, message) {
+        this.length = length;
+        this.message = message;
+        this.name = 'notice';
+    }
+}
+exports.NoticeMessage = NoticeMessage;
+//# sourceMappingURL=messages.js.map

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

@@ -0,0 +1,325 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+const messages_1 = require("./messages");
+const buffer_reader_1 = require("./buffer-reader");
+// every message is prefixed with a single byte
+const CODE_LENGTH = 1;
+// every message has an int32 length which includes itself but does
+// NOT include the code in the length
+const LEN_LENGTH = 4;
+const HEADER_LENGTH = CODE_LENGTH + LEN_LENGTH;
+// A placeholder for a `BackendMessage`’s length value that will be set after construction.
+const LATEINIT_LENGTH = -1;
+const emptyBuffer = Buffer.allocUnsafe(0);
+class Parser {
+    constructor(opts) {
+        this.buffer = emptyBuffer;
+        this.bufferLength = 0;
+        this.bufferOffset = 0;
+        this.reader = new buffer_reader_1.BufferReader();
+        if ((opts === null || opts === void 0 ? void 0 : opts.mode) === 'binary') {
+            throw new Error('Binary mode not supported yet');
+        }
+        this.mode = (opts === null || opts === void 0 ? void 0 : opts.mode) || 'text';
+    }
+    parse(buffer, callback) {
+        this.mergeBuffer(buffer);
+        const bufferFullLength = this.bufferOffset + this.bufferLength;
+        let offset = this.bufferOffset;
+        while (offset + HEADER_LENGTH <= bufferFullLength) {
+            // code is 1 byte long - it identifies the message type
+            const code = this.buffer[offset];
+            // length is 1 Uint32BE - it is the length of the message EXCLUDING the code
+            const length = this.buffer.readUInt32BE(offset + CODE_LENGTH);
+            const fullMessageLength = CODE_LENGTH + length;
+            if (fullMessageLength + offset <= bufferFullLength) {
+                const message = this.handlePacket(offset + HEADER_LENGTH, code, length, this.buffer);
+                callback(message);
+                offset += fullMessageLength;
+            }
+            else {
+                break;
+            }
+        }
+        if (offset === bufferFullLength) {
+            // No more use for the buffer
+            this.buffer = emptyBuffer;
+            this.bufferLength = 0;
+            this.bufferOffset = 0;
+        }
+        else {
+            // Adjust the cursors of remainingBuffer
+            this.bufferLength = bufferFullLength - offset;
+            this.bufferOffset = offset;
+        }
+    }
+    mergeBuffer(buffer) {
+        if (this.bufferLength > 0) {
+            const newLength = this.bufferLength + buffer.byteLength;
+            const newFullLength = newLength + this.bufferOffset;
+            if (newFullLength > this.buffer.byteLength) {
+                // We can't concat the new buffer with the remaining one
+                let newBuffer;
+                if (newLength <= this.buffer.byteLength && this.bufferOffset >= this.bufferLength) {
+                    // We can move the relevant part to the beginning of the buffer instead of allocating a new buffer
+                    newBuffer = this.buffer;
+                }
+                else {
+                    // Allocate a new larger buffer
+                    let newBufferLength = this.buffer.byteLength * 2;
+                    while (newLength >= newBufferLength) {
+                        newBufferLength *= 2;
+                    }
+                    newBuffer = Buffer.allocUnsafe(newBufferLength);
+                }
+                // Move the remaining buffer to the new one
+                this.buffer.copy(newBuffer, 0, this.bufferOffset, this.bufferOffset + this.bufferLength);
+                this.buffer = newBuffer;
+                this.bufferOffset = 0;
+            }
+            // Concat the new buffer with the remaining one
+            buffer.copy(this.buffer, this.bufferOffset + this.bufferLength);
+            this.bufferLength = newLength;
+        }
+        else {
+            this.buffer = buffer;
+            this.bufferOffset = 0;
+            this.bufferLength = buffer.byteLength;
+        }
+    }
+    handlePacket(offset, code, length, bytes) {
+        const { reader } = this;
+        // NOTE: This undesirably retains the buffer in `this.reader` if the `parse*Message` calls below throw. However, those should only throw in the case of a protocol error, which normally results in the reader being discarded.
+        reader.setBuffer(offset, bytes);
+        let message;
+        switch (code) {
+            case 50 /* MessageCodes.BindComplete */:
+                message = messages_1.bindComplete;
+                break;
+            case 49 /* MessageCodes.ParseComplete */:
+                message = messages_1.parseComplete;
+                break;
+            case 51 /* MessageCodes.CloseComplete */:
+                message = messages_1.closeComplete;
+                break;
+            case 110 /* MessageCodes.NoData */:
+                message = messages_1.noData;
+                break;
+            case 115 /* MessageCodes.PortalSuspended */:
+                message = messages_1.portalSuspended;
+                break;
+            case 99 /* MessageCodes.CopyDone */:
+                message = messages_1.copyDone;
+                break;
+            case 87 /* MessageCodes.ReplicationStart */:
+                message = messages_1.replicationStart;
+                break;
+            case 73 /* MessageCodes.EmptyQuery */:
+                message = messages_1.emptyQuery;
+                break;
+            case 68 /* MessageCodes.DataRow */:
+                message = parseDataRowMessage(reader);
+                break;
+            case 67 /* MessageCodes.CommandComplete */:
+                message = parseCommandCompleteMessage(reader);
+                break;
+            case 90 /* MessageCodes.ReadyForQuery */:
+                message = parseReadyForQueryMessage(reader);
+                break;
+            case 65 /* MessageCodes.NotificationResponse */:
+                message = parseNotificationMessage(reader);
+                break;
+            case 82 /* MessageCodes.AuthenticationResponse */:
+                message = parseAuthenticationResponse(reader, length);
+                break;
+            case 83 /* MessageCodes.ParameterStatus */:
+                message = parseParameterStatusMessage(reader);
+                break;
+            case 75 /* MessageCodes.BackendKeyData */:
+                message = parseBackendKeyData(reader);
+                break;
+            case 69 /* MessageCodes.ErrorMessage */:
+                message = parseErrorMessage(reader, 'error');
+                break;
+            case 78 /* MessageCodes.NoticeMessage */:
+                message = parseErrorMessage(reader, 'notice');
+                break;
+            case 84 /* MessageCodes.RowDescriptionMessage */:
+                message = parseRowDescriptionMessage(reader);
+                break;
+            case 116 /* MessageCodes.ParameterDescriptionMessage */:
+                message = parseParameterDescriptionMessage(reader);
+                break;
+            case 71 /* MessageCodes.CopyIn */:
+                message = parseCopyInMessage(reader);
+                break;
+            case 72 /* MessageCodes.CopyOut */:
+                message = parseCopyOutMessage(reader);
+                break;
+            case 100 /* MessageCodes.CopyData */:
+                message = parseCopyData(reader, length);
+                break;
+            default:
+                return new messages_1.DatabaseError('received invalid response: ' + code.toString(16), length, 'error');
+        }
+        reader.setBuffer(0, emptyBuffer);
+        message.length = length;
+        return message;
+    }
+}
+exports.Parser = Parser;
+const parseReadyForQueryMessage = (reader) => {
+    const status = reader.string(1);
+    return new messages_1.ReadyForQueryMessage(LATEINIT_LENGTH, status);
+};
+const parseCommandCompleteMessage = (reader) => {
+    const text = reader.cstring();
+    return new messages_1.CommandCompleteMessage(LATEINIT_LENGTH, text);
+};
+const parseCopyData = (reader, length) => {
+    const chunk = reader.bytes(length - 4);
+    return new messages_1.CopyDataMessage(LATEINIT_LENGTH, chunk);
+};
+const parseCopyInMessage = (reader) => parseCopyMessage(reader, 'copyInResponse');
+const parseCopyOutMessage = (reader) => parseCopyMessage(reader, 'copyOutResponse');
+const parseCopyMessage = (reader, messageName) => {
+    const isBinary = reader.byte() !== 0;
+    const columnCount = reader.int16();
+    const message = new messages_1.CopyResponse(LATEINIT_LENGTH, messageName, isBinary, columnCount);
+    for (let i = 0; i < columnCount; i++) {
+        message.columnTypes[i] = reader.int16();
+    }
+    return message;
+};
+const parseNotificationMessage = (reader) => {
+    const processId = reader.int32();
+    const channel = reader.cstring();
+    const payload = reader.cstring();
+    return new messages_1.NotificationResponseMessage(LATEINIT_LENGTH, processId, channel, payload);
+};
+const parseRowDescriptionMessage = (reader) => {
+    const fieldCount = reader.int16();
+    const message = new messages_1.RowDescriptionMessage(LATEINIT_LENGTH, fieldCount);
+    for (let i = 0; i < fieldCount; i++) {
+        message.fields[i] = parseField(reader);
+    }
+    return message;
+};
+const parseField = (reader) => {
+    const name = reader.cstring();
+    const tableID = reader.uint32();
+    const columnID = reader.int16();
+    const dataTypeID = reader.uint32();
+    const dataTypeSize = reader.int16();
+    const dataTypeModifier = reader.int32();
+    const mode = reader.int16() === 0 ? 'text' : 'binary';
+    return new messages_1.Field(name, tableID, columnID, dataTypeID, dataTypeSize, dataTypeModifier, mode);
+};
+const parseParameterDescriptionMessage = (reader) => {
+    const parameterCount = reader.int16();
+    const message = new messages_1.ParameterDescriptionMessage(LATEINIT_LENGTH, parameterCount);
+    for (let i = 0; i < parameterCount; i++) {
+        // OIDs are unsigned, same as dataTypeID in parseField above
+        message.dataTypeIDs[i] = reader.uint32();
+    }
+    return message;
+};
+const parseDataRowMessage = (reader) => {
+    const fieldCount = reader.int16();
+    const fields = new Array(fieldCount);
+    for (let i = 0; i < fieldCount; i++) {
+        const len = reader.int32();
+        // a -1 for length means the value of the field is null
+        fields[i] = len === -1 ? null : reader.string(len);
+    }
+    return new messages_1.DataRowMessage(LATEINIT_LENGTH, fields);
+};
+const parseParameterStatusMessage = (reader) => {
+    const name = reader.cstring();
+    const value = reader.cstring();
+    return new messages_1.ParameterStatusMessage(LATEINIT_LENGTH, name, value);
+};
+const parseBackendKeyData = (reader) => {
+    const processID = reader.int32();
+    const secretKey = reader.int32();
+    return new messages_1.BackendKeyDataMessage(LATEINIT_LENGTH, processID, secretKey);
+};
+const parseAuthenticationResponse = (reader, length) => {
+    const code = reader.int32();
+    // TODO(bmc): maybe better types here
+    const message = {
+        name: 'authenticationOk',
+        length,
+    };
+    switch (code) {
+        case 0: // AuthenticationOk
+            break;
+        case 3: // AuthenticationCleartextPassword
+            if (message.length === 8) {
+                message.name = 'authenticationCleartextPassword';
+            }
+            break;
+        case 5: // AuthenticationMD5Password
+            if (message.length === 12) {
+                message.name = 'authenticationMD5Password';
+                const salt = reader.bytes(4);
+                return new messages_1.AuthenticationMD5Password(LATEINIT_LENGTH, salt);
+            }
+            break;
+        case 10: // AuthenticationSASL
+            {
+                message.name = 'authenticationSASL';
+                message.mechanisms = [];
+                let mechanism;
+                do {
+                    mechanism = reader.cstring();
+                    if (mechanism) {
+                        message.mechanisms.push(mechanism);
+                    }
+                } while (mechanism);
+            }
+            break;
+        case 11: // AuthenticationSASLContinue
+            message.name = 'authenticationSASLContinue';
+            message.data = reader.string(length - 8);
+            break;
+        case 12: // AuthenticationSASLFinal
+            message.name = 'authenticationSASLFinal';
+            message.data = reader.string(length - 8);
+            break;
+        default:
+            throw new Error('Unknown authenticationOk message type ' + code);
+    }
+    return message;
+};
+const parseErrorMessage = (reader, name) => {
+    const fields = {};
+    let fieldType = reader.string(1);
+    while (fieldType !== '\0') {
+        fields[fieldType] = reader.cstring();
+        fieldType = reader.string(1);
+    }
+    const messageValue = fields.M;
+    const message = name === 'notice'
+        ? new messages_1.NoticeMessage(LATEINIT_LENGTH, messageValue)
+        : new messages_1.DatabaseError(messageValue, LATEINIT_LENGTH, name);
+    message.severity = fields.S;
+    message.code = fields.C;
+    message.detail = fields.D;
+    message.hint = fields.H;
+    message.position = fields.P;
+    message.internalPosition = fields.p;
+    message.internalQuery = fields.q;
+    message.where = fields.W;
+    message.schema = fields.s;
+    message.table = fields.t;
+    message.column = fields.c;
+    message.dataType = fields.d;
+    message.constraint = fields.n;
+    message.file = fields.F;
+    message.line = fields.L;
+    message.routine = fields.R;
+    return message;
+};
+//# sourceMappingURL=parser.js.map