init: vibn-agent-runner — Gemini autonomous agent backend

Made-with: Cursor

node_modules/google-auth-library/build/src/crypto/browser/crypto.d.ts

@@ -0,0 +1,27 @@
+import { Crypto, JwkCertificate } from '../shared';
+export declare class BrowserCrypto implements Crypto {
+    constructor();
+    sha256DigestBase64(str: string): Promise<string>;
+    randomBytesBase64(count: number): string;
+    private static padBase64;
+    verify(pubkey: JwkCertificate, data: string, signature: string): Promise<boolean>;
+    sign(privateKey: JwkCertificate, data: string): Promise<string>;
+    decodeBase64StringUtf8(base64: string): string;
+    encodeBase64StringUtf8(text: string): string;
+    /**
+     * Computes the SHA-256 hash of the provided string.
+     * @param str The plain text string to hash.
+     * @return A promise that resolves with the SHA-256 hash of the provided
+     *   string in hexadecimal encoding.
+     */
+    sha256DigestHex(str: string): Promise<string>;
+    /**
+     * Computes the HMAC hash of a message using the provided crypto key and the
+     * SHA-256 algorithm.
+     * @param key The secret crypto key in utf-8 or ArrayBuffer format.
+     * @param msg The plain text message.
+     * @return A promise that resolves with the HMAC-SHA256 hash in ArrayBuffer
+     *   format.
+     */
+    signWithHmacSha256(key: string | ArrayBuffer, msg: string): Promise<ArrayBuffer>;
+}

node_modules/google-auth-library/build/src/crypto/browser/crypto.js

@@ -0,0 +1,127 @@
+"use strict";
+// Copyright 2019 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+/* global window */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserCrypto = void 0;
+// This file implements crypto functions we need using in-browser
+// SubtleCrypto interface `window.crypto.subtle`.
+const base64js = require("base64-js");
+const shared_1 = require("../shared");
+class BrowserCrypto {
+    constructor() {
+        if (typeof window === 'undefined' ||
+            window.crypto === undefined ||
+            window.crypto.subtle === undefined) {
+            throw new Error("SubtleCrypto not found. Make sure it's an https:// website.");
+        }
+    }
+    async sha256DigestBase64(str) {
+        // SubtleCrypto digest() method is async, so we must make
+        // this method async as well.
+        // To calculate SHA256 digest using SubtleCrypto, we first
+        // need to convert an input string to an ArrayBuffer:
+        const inputBuffer = new TextEncoder().encode(str);
+        // Result is ArrayBuffer as well.
+        const outputBuffer = await window.crypto.subtle.digest('SHA-256', inputBuffer);
+        return base64js.fromByteArray(new Uint8Array(outputBuffer));
+    }
+    randomBytesBase64(count) {
+        const array = new Uint8Array(count);
+        window.crypto.getRandomValues(array);
+        return base64js.fromByteArray(array);
+    }
+    static padBase64(base64) {
+        // base64js requires padding, so let's add some '='
+        while (base64.length % 4 !== 0) {
+            base64 += '=';
+        }
+        return base64;
+    }
+    async verify(pubkey, data, signature) {
+        const algo = {
+            name: 'RSASSA-PKCS1-v1_5',
+            hash: { name: 'SHA-256' },
+        };
+        const dataArray = new TextEncoder().encode(data);
+        const signatureArray = base64js.toByteArray(BrowserCrypto.padBase64(signature));
+        const cryptoKey = await window.crypto.subtle.importKey('jwk', pubkey, algo, true, ['verify']);
+        // SubtleCrypto's verify method is async so we must make
+        // this method async as well.
+        const result = await window.crypto.subtle.verify(algo, cryptoKey, Buffer.from(signatureArray), dataArray);
+        return result;
+    }
+    async sign(privateKey, data) {
+        const algo = {
+            name: 'RSASSA-PKCS1-v1_5',
+            hash: { name: 'SHA-256' },
+        };
+        const dataArray = new TextEncoder().encode(data);
+        const cryptoKey = await window.crypto.subtle.importKey('jwk', privateKey, algo, true, ['sign']);
+        // SubtleCrypto's sign method is async so we must make
+        // this method async as well.
+        const result = await window.crypto.subtle.sign(algo, cryptoKey, dataArray);
+        return base64js.fromByteArray(new Uint8Array(result));
+    }
+    decodeBase64StringUtf8(base64) {
+        const uint8array = base64js.toByteArray(BrowserCrypto.padBase64(base64));
+        const result = new TextDecoder().decode(uint8array);
+        return result;
+    }
+    encodeBase64StringUtf8(text) {
+        const uint8array = new TextEncoder().encode(text);
+        const result = base64js.fromByteArray(uint8array);
+        return result;
+    }
+    /**
+     * Computes the SHA-256 hash of the provided string.
+     * @param str The plain text string to hash.
+     * @return A promise that resolves with the SHA-256 hash of the provided
+     *   string in hexadecimal encoding.
+     */
+    async sha256DigestHex(str) {
+        // SubtleCrypto digest() method is async, so we must make
+        // this method async as well.
+        // To calculate SHA256 digest using SubtleCrypto, we first
+        // need to convert an input string to an ArrayBuffer:
+        const inputBuffer = new TextEncoder().encode(str);
+        // Result is ArrayBuffer as well.
+        const outputBuffer = await window.crypto.subtle.digest('SHA-256', inputBuffer);
+        return (0, shared_1.fromArrayBufferToHex)(outputBuffer);
+    }
+    /**
+     * Computes the HMAC hash of a message using the provided crypto key and the
+     * SHA-256 algorithm.
+     * @param key The secret crypto key in utf-8 or ArrayBuffer format.
+     * @param msg The plain text message.
+     * @return A promise that resolves with the HMAC-SHA256 hash in ArrayBuffer
+     *   format.
+     */
+    async signWithHmacSha256(key, msg) {
+        // Convert key, if provided in ArrayBuffer format, to string.
+        const rawKey = typeof key === 'string'
+            ? key
+            : String.fromCharCode(...new Uint16Array(key));
+        const enc = new TextEncoder();
+        const cryptoKey = await window.crypto.subtle.importKey('raw', enc.encode(rawKey), {
+            name: 'HMAC',
+            hash: {
+                name: 'SHA-256',
+            },
+        }, false, ['sign']);
+        return window.crypto.subtle.sign('HMAC', cryptoKey, enc.encode(msg));
+    }
+}
+exports.BrowserCrypto = BrowserCrypto;
+//# sourceMappingURL=crypto.js.map

node_modules/google-auth-library/build/src/crypto/crypto.d.ts

@@ -0,0 +1,8 @@
+import { Crypto } from './shared';
+export * from './shared';
+export interface CryptoSigner {
+    update(data: string): void;
+    sign(key: string, outputFormat: string): string;
+}
+export declare function createCrypto(): Crypto;
+export declare function hasBrowserCrypto(): boolean;

node_modules/google-auth-library/build/src/crypto/crypto.js

@@ -0,0 +1,54 @@
+"use strict";
+// Copyright 2019 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+/* global window */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCrypto = createCrypto;
+exports.hasBrowserCrypto = hasBrowserCrypto;
+const crypto_1 = require("./browser/crypto");
+const crypto_2 = require("./node/crypto");
+__exportStar(require("./shared"), exports);
+// Crypto interface will provide required crypto functions.
+// Use `createCrypto()` factory function to create an instance
+// of Crypto. It will either use Node.js `crypto` module, or
+// use browser's SubtleCrypto interface. Since most of the
+// SubtleCrypto methods return promises, we must make those
+// methods return promises here as well, even though in Node.js
+// they are synchronous.
+function createCrypto() {
+    if (hasBrowserCrypto()) {
+        return new crypto_1.BrowserCrypto();
+    }
+    return new crypto_2.NodeCrypto();
+}
+function hasBrowserCrypto() {
+    return (typeof window !== 'undefined' &&
+        typeof window.crypto !== 'undefined' &&
+        typeof window.crypto.subtle !== 'undefined');
+}
+//# sourceMappingURL=crypto.js.map

node_modules/google-auth-library/build/src/crypto/node/crypto.d.ts

@@ -0,0 +1,25 @@
+import { Crypto } from '../shared';
+export declare class NodeCrypto implements Crypto {
+    sha256DigestBase64(str: string): Promise<string>;
+    randomBytesBase64(count: number): string;
+    verify(pubkey: string, data: string | Buffer, signature: string): Promise<boolean>;
+    sign(privateKey: string, data: string | Buffer): Promise<string>;
+    decodeBase64StringUtf8(base64: string): string;
+    encodeBase64StringUtf8(text: string): string;
+    /**
+     * Computes the SHA-256 hash of the provided string.
+     * @param str The plain text string to hash.
+     * @return A promise that resolves with the SHA-256 hash of the provided
+     *   string in hexadecimal encoding.
+     */
+    sha256DigestHex(str: string): Promise<string>;
+    /**
+     * Computes the HMAC hash of a message using the provided crypto key and the
+     * SHA-256 algorithm.
+     * @param key The secret crypto key in utf-8 or ArrayBuffer format.
+     * @param msg The plain text message.
+     * @return A promise that resolves with the HMAC-SHA256 hash in ArrayBuffer
+     *   format.
+     */
+    signWithHmacSha256(key: string | ArrayBuffer, msg: string): Promise<ArrayBuffer>;
+}

node_modules/google-auth-library/build/src/crypto/node/crypto.js

@@ -0,0 +1,88 @@
+"use strict";
+// Copyright 2019 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeCrypto = void 0;
+const crypto = require("crypto");
+class NodeCrypto {
+    async sha256DigestBase64(str) {
+        return crypto.createHash('sha256').update(str).digest('base64');
+    }
+    randomBytesBase64(count) {
+        return crypto.randomBytes(count).toString('base64');
+    }
+    async verify(pubkey, data, signature) {
+        const verifier = crypto.createVerify('RSA-SHA256');
+        verifier.update(data);
+        verifier.end();
+        return verifier.verify(pubkey, signature, 'base64');
+    }
+    async sign(privateKey, data) {
+        const signer = crypto.createSign('RSA-SHA256');
+        signer.update(data);
+        signer.end();
+        return signer.sign(privateKey, 'base64');
+    }
+    decodeBase64StringUtf8(base64) {
+        return Buffer.from(base64, 'base64').toString('utf-8');
+    }
+    encodeBase64StringUtf8(text) {
+        return Buffer.from(text, 'utf-8').toString('base64');
+    }
+    /**
+     * Computes the SHA-256 hash of the provided string.
+     * @param str The plain text string to hash.
+     * @return A promise that resolves with the SHA-256 hash of the provided
+     *   string in hexadecimal encoding.
+     */
+    async sha256DigestHex(str) {
+        return crypto.createHash('sha256').update(str).digest('hex');
+    }
+    /**
+     * Computes the HMAC hash of a message using the provided crypto key and the
+     * SHA-256 algorithm.
+     * @param key The secret crypto key in utf-8 or ArrayBuffer format.
+     * @param msg The plain text message.
+     * @return A promise that resolves with the HMAC-SHA256 hash in ArrayBuffer
+     *   format.
+     */
+    async signWithHmacSha256(key, msg) {
+        const cryptoKey = typeof key === 'string' ? key : toBuffer(key);
+        return toArrayBuffer(crypto.createHmac('sha256', cryptoKey).update(msg).digest());
+    }
+}
+exports.NodeCrypto = NodeCrypto;
+/**
+ * Converts a Node.js Buffer to an ArrayBuffer.
+ * https://stackoverflow.com/questions/8609289/convert-a-binary-nodejs-buffer-to-javascript-arraybuffer
+ * @param buffer The Buffer input to covert.
+ * @return The ArrayBuffer representation of the input.
+ */
+function toArrayBuffer(buffer) {
+    const ab = new ArrayBuffer(buffer.length);
+    const view = new Uint8Array(ab);
+    for (let i = 0; i < buffer.length; ++i) {
+        view[i] = buffer[i];
+    }
+    return ab;
+}
+/**
+ * Converts an ArrayBuffer to a Node.js Buffer.
+ * @param arrayBuffer The ArrayBuffer input to covert.
+ * @return The Buffer representation of the input.
+ */
+function toBuffer(arrayBuffer) {
+    return Buffer.from(arrayBuffer);
+}
+//# sourceMappingURL=crypto.js.map

node_modules/google-auth-library/build/src/crypto/shared.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Crypto interface will provide required crypto functions.
+ * Use `createCrypto()` factory function to create an instance
+ * of Crypto. It will either use Node.js `crypto` module, or
+ * use browser's SubtleCrypto interface. Since most of the
+ * SubtleCrypto methods return promises, we must make those
+ * methods return promises here as well, even though in Node.js
+ * they are synchronous.
+ */
+export interface Crypto {
+    sha256DigestBase64(str: string): Promise<string>;
+    randomBytesBase64(n: number): string;
+    verify(pubkey: string | JwkCertificate, data: string | Buffer, signature: string): Promise<boolean>;
+    sign(privateKey: string | JwkCertificate, data: string | Buffer): Promise<string>;
+    decodeBase64StringUtf8(base64: string): string;
+    encodeBase64StringUtf8(text: string): string;
+    /**
+     * Computes the SHA-256 hash of the provided string.
+     * @param str The plain text string to hash.
+     * @return A promise that resolves with the SHA-256 hash of the provided
+     *   string in hexadecimal encoding.
+     */
+    sha256DigestHex(str: string): Promise<string>;
+    /**
+     * Computes the HMAC hash of a message using the provided crypto key and the
+     * SHA-256 algorithm.
+     * @param key The secret crypto key in utf-8 or ArrayBuffer format.
+     * @param msg The plain text message.
+     * @return A promise that resolves with the HMAC-SHA256 hash in ArrayBuffer
+     *   format.
+     */
+    signWithHmacSha256(key: string | ArrayBuffer, msg: string): Promise<ArrayBuffer>;
+}
+export interface JwkCertificate {
+    kty: string;
+    alg: string;
+    use?: string;
+    kid: string;
+    n: string;
+    e: string;
+}
+/**
+ * Converts an ArrayBuffer to a hexadecimal string.
+ * @param arrayBuffer The ArrayBuffer to convert to hexadecimal string.
+ * @return The hexadecimal encoding of the ArrayBuffer.
+ */
+export declare function fromArrayBufferToHex(arrayBuffer: ArrayBuffer): string;

node_modules/google-auth-library/build/src/crypto/shared.js

@@ -0,0 +1,32 @@
+"use strict";
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromArrayBufferToHex = fromArrayBufferToHex;
+/**
+ * Converts an ArrayBuffer to a hexadecimal string.
+ * @param arrayBuffer The ArrayBuffer to convert to hexadecimal string.
+ * @return The hexadecimal encoding of the ArrayBuffer.
+ */
+function fromArrayBufferToHex(arrayBuffer) {
+    // Convert buffer to byte array.
+    const byteArray = Array.from(new Uint8Array(arrayBuffer));
+    // Convert bytes to hex string.
+    return byteArray
+        .map(byte => {
+        return byte.toString(16).padStart(2, '0');
+    })
+        .join('');
+}
+//# sourceMappingURL=shared.js.map