ssh2web 1.0.0

package/dist/protocol/codec.js

@@ -0,0 +1,35 @@
+/**
+ * RFC 4253 SSH binary packet format.
+ * Single responsibility: Packet structure encoding/decoding without encryption.
+ */
+import { AES_BLOCK_SIZE, MIN_PADDING } from "../domain/constants";
+export function buildPacket(payload, etm = false) {
+    const padLen = calculatePadding(payload.length, etm);
+    const plen = 1 + payload.length + padLen;
+    const out = new Uint8Array(4 + plen);
+    const view = new DataView(out.buffer);
+    view.setUint32(0, plen, false);
+    out[4] = padLen;
+    out.set(payload, 5);
+    crypto.getRandomValues(out.subarray(5 + payload.length, 5 + payload.length + padLen));
+    return out;
+}
+export function parsePacket(data) {
+    if (data.length < 5)
+        return null;
+    const plen = new DataView(data.buffer, data.byteOffset, 4).getUint32(0, false);
+    const total = 4 + plen;
+    if (data.length < total)
+        return null;
+    const padLen = data[4];
+    const payloadLen = plen - 1 - padLen;
+    const payload = data.slice(5, 5 + payloadLen);
+    return { payload, consumed: total };
+}
+function calculatePadding(payloadLen, etm) {
+    if (etm) {
+        const innerLen = 1 + payloadLen;
+        return MIN_PADDING + (AES_BLOCK_SIZE - ((innerLen + MIN_PADDING) % AES_BLOCK_SIZE)) % AES_BLOCK_SIZE;
+    }
+    return MIN_PADDING + (AES_BLOCK_SIZE - ((5 + payloadLen + MIN_PADDING) % AES_BLOCK_SIZE)) % AES_BLOCK_SIZE;
+}

package/dist/protocol/deserialization.d.ts

@@ -0,0 +1,19 @@
+export interface StringValue {
+    value: string;
+    consumed: number;
+}
+export interface BytesValue {
+    value: Uint8Array;
+    consumed: number;
+}
+export interface BigintValue {
+    value: bigint;
+    consumed: number;
+}
+export declare function readString(data: Uint8Array, offset: number): StringValue | null;
+export declare function readBytes(data: Uint8Array, offset: number): BytesValue | null;
+export declare function readMpint(data: Uint8Array, offset: number): BigintValue | null;
+export declare function readStringThrows(data: Uint8Array, offset: number): StringValue;
+export declare function readBytesThrows(data: Uint8Array, offset: number): BytesValue;
+export declare function readMpintThrows(data: Uint8Array, offset: number): BigintValue;
+//# sourceMappingURL=deserialization.d.ts.map

package/dist/protocol/deserialization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deserialization.d.ts","sourceRoot":"","sources":["../../protocol/deserialization.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,UAAU,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAM/E;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAM7E;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAQ9E;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW,CAI9E;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,UAAU,CAI5E;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,WAAW,CAI7E"}

package/dist/protocol/deserialization.js

@@ -0,0 +1,53 @@
+/**
+ * SSH protocol deserialization (reading data types from packets).
+ * Single responsibility: Decoding strings, bytes, and integers.
+ */
+import { ParseError } from "../domain/errors";
+export function readString(data, offset) {
+    if (offset + 4 > data.length)
+        return null;
+    const len = new DataView(data.buffer, data.byteOffset + offset, 4).getUint32(0, false);
+    if (offset + 4 + len > data.length)
+        return null;
+    const value = new TextDecoder().decode(data.subarray(offset + 4, offset + 4 + len));
+    return { value, consumed: 4 + len };
+}
+export function readBytes(data, offset) {
+    if (offset + 4 > data.length)
+        return null;
+    const len = new DataView(data.buffer, data.byteOffset + offset, 4).getUint32(0, false);
+    if (offset + 4 + len > data.length)
+        return null;
+    const value = data.slice(offset + 4, offset + 4 + len);
+    return { value, consumed: 4 + len };
+}
+export function readMpint(data, offset) {
+    const rb = readBytes(data, offset);
+    if (!rb)
+        return null;
+    const b = rb.value;
+    let n = 0n;
+    for (let i = 0; i < b.length; i++)
+        n = (n << 8n) | BigInt(b[i]);
+    if (b.length > 0 && (b[0] & 0x80))
+        n -= 1n << BigInt(b.length * 8);
+    return { value: n, consumed: rb.consumed };
+}
+export function readStringThrows(data, offset) {
+    const result = readString(data, offset);
+    if (!result)
+        throw new ParseError(`Failed to read string at offset ${offset}`);
+    return result;
+}
+export function readBytesThrows(data, offset) {
+    const result = readBytes(data, offset);
+    if (!result)
+        throw new ParseError(`Failed to read bytes at offset ${offset}`);
+    return result;
+}
+export function readMpintThrows(data, offset) {
+    const result = readMpint(data, offset);
+    if (!result)
+        throw new ParseError(`Failed to read mpint at offset ${offset}`);
+    return result;
+}

package/dist/protocol/messages.d.ts

@@ -0,0 +1,5 @@
+/**
+ * SSH message type utilities and debug information.
+ */
+export declare function getMessageName(msgType: number): string;
+//# sourceMappingURL=messages.d.ts.map

package/dist/protocol/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../protocol/messages.ts"],"names":[],"mappings":"AAAA;;GAEG;AA8BH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEtD"}

package/dist/protocol/messages.js

@@ -0,0 +1,33 @@
+/**
+ * SSH message type utilities and debug information.
+ */
+const MESSAGE_NAMES = {
+    1: "DISCONNECT",
+    3: "UNIMPLEMENTED",
+    4: "DEBUG",
+    5: "SERVICE_REQUEST",
+    6: "SERVICE_ACCEPT",
+    7: "EXT_INFO",
+    20: "KEXINIT",
+    21: "NEWKEYS",
+    30: "KEX_DH_INIT",
+    31: "KEX_DH_REPLY",
+    50: "USERAUTH_REQUEST",
+    51: "USERAUTH_FAILURE",
+    52: "USERAUTH_SUCCESS",
+    60: "USERAUTH_PK_OK",
+    80: "GLOBAL_REQUEST",
+    81: "REQUEST_SUCCESS",
+    82: "REQUEST_FAILURE",
+    90: "CHANNEL_OPEN",
+    91: "CHANNEL_OPEN_CONFIRMATION",
+    93: "CHANNEL_WINDOW_ADJUST",
+    94: "CHANNEL_DATA",
+    95: "CHANNEL_EXTENDED_DATA",
+    98: "CHANNEL_REQUEST",
+    99: "CHANNEL_SUCCESS",
+    100: "CHANNEL_FAILURE",
+};
+export function getMessageName(msgType) {
+    return MESSAGE_NAMES[msgType] ?? `msg${msgType}`;
+}

package/dist/protocol/serialization.d.ts

@@ -0,0 +1,11 @@
+/**
+ * SSH protocol serialization (writing data types to packets).
+ * Single responsibility: Encoding strings, bytes, and integers.
+ */
+export declare function writeString(s: string): Uint8Array;
+export declare function writeBytes(b: Uint8Array): Uint8Array;
+export declare function writeUint32(n: number): Uint8Array;
+export declare function writeBigintMpint(n: bigint): Uint8Array;
+export declare function writeByteMpint(k: Uint8Array): Uint8Array;
+export declare function concat(...arr: Uint8Array[]): Uint8Array;
+//# sourceMappingURL=serialization.d.ts.map

package/dist/protocol/serialization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialization.d.ts","sourceRoot":"","sources":["../../protocol/serialization.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU,CAMjD;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,UAAU,GAAG,UAAU,CAKpD;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU,CAIjD;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU,CAYtD;AAED,wBAAgB,cAAc,CAAC,CAAC,EAAE,UAAU,GAAG,UAAU,CASxD;AAED,wBAAgB,MAAM,CAAC,GAAG,GAAG,EAAE,UAAU,EAAE,GAAG,UAAU,CASvD"}

package/dist/protocol/serialization.js

@@ -0,0 +1,69 @@
+/**
+ * SSH protocol serialization (writing data types to packets).
+ * Single responsibility: Encoding strings, bytes, and integers.
+ */
+export function writeString(s) {
+    const enc = new TextEncoder().encode(s);
+    const out = new Uint8Array(4 + enc.length);
+    new DataView(out.buffer).setUint32(0, enc.length, false);
+    out.set(enc, 4);
+    return out;
+}
+export function writeBytes(b) {
+    const out = new Uint8Array(4 + b.length);
+    new DataView(out.buffer).setUint32(0, b.length, false);
+    out.set(b, 4);
+    return out;
+}
+export function writeUint32(n) {
+    const out = new Uint8Array(4);
+    new DataView(out.buffer).setUint32(0, n, false);
+    return out;
+}
+export function writeBigintMpint(n) {
+    if (n === 0n)
+        return writeBytes(new Uint8Array(0));
+    const neg = n < 0n;
+    if (neg)
+        n = -n;
+    let bytes = bigintToBytes(n);
+    if (bytes[0] & 0x80) {
+        const tmp = new Uint8Array(bytes.length + 1);
+        tmp[0] = 0;
+        tmp.set(bytes, 1);
+        bytes = tmp;
+    }
+    return writeBytes(bytes);
+}
+export function writeByteMpint(k) {
+    let kk = k;
+    if (kk.length > 0 && (kk[0] & 0x80) !== 0) {
+        const tmp = new Uint8Array(kk.length + 1);
+        tmp[0] = 0;
+        tmp.set(kk, 1);
+        kk = tmp;
+    }
+    return writeBytes(kk);
+}
+export function concat(...arr) {
+    const len = arr.reduce((a, b) => a + b.length, 0);
+    const out = new Uint8Array(len);
+    let off = 0;
+    for (const a of arr) {
+        out.set(a, off);
+        off += a.length;
+    }
+    return out;
+}
+function bigintToBytes(n) {
+    if (n === 0n)
+        return new Uint8Array([0]);
+    let hex = n.toString(16);
+    if (hex.length % 2)
+        hex = "0" + hex;
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    }
+    return bytes;
+}

package/dist/transport/transportcipher.d.ts

@@ -0,0 +1,25 @@
+export interface EncryptResult {
+    ciphertext: Uint8Array;
+}
+export interface DecryptResult {
+    payload: Uint8Array;
+    consumed: number;
+}
+export declare class TransportCipher {
+    private ivEnc;
+    private ivDec;
+    private keyEnc;
+    private keyDec;
+    private seqOut;
+    private seqIn;
+    private macEtm;
+    private macC;
+    private macS;
+    constructor(ivC: Uint8Array, keyC: Uint8Array, macC: Uint8Array, ivS: Uint8Array, keyS: Uint8Array, macS: Uint8Array, initialSeqOut: number, initialSeqIn: number, macEtm: boolean, keyEncCrypto: CryptoKey, keyDecCrypto: CryptoKey);
+    encrypt(payload: Uint8Array): Promise<EncryptResult>;
+    decrypt(data: Uint8Array): Promise<DecryptResult | null>;
+    private decryptEtm;
+    private decryptStandard;
+}
+export declare function createTransportCipher(ivC: Uint8Array, keyC: Uint8Array, macC: Uint8Array, ivS: Uint8Array, keyS: Uint8Array, macS: Uint8Array, initialSeqOut: number, initialSeqIn: number, macEtm: boolean): Promise<TransportCipher>;
+//# sourceMappingURL=transportcipher.d.ts.map

package/dist/transport/transportcipher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transportcipher.d.ts","sourceRoot":"","sources":["../../transport/transportcipher.ts"],"names":[],"mappings":"AAWA,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,UAAU,CAAC;CACxB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,UAAU,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,qBAAa,eAAe;IAC1B,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,MAAM,CAAY;IAC1B,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,MAAM,CAAU;IACxB,OAAO,CAAC,IAAI,CAAa;IACzB,OAAO,CAAC,IAAI,CAAa;gBAGvB,GAAG,EAAE,UAAU,EACf,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,UAAU,EACf,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,UAAU,EAChB,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,OAAO,EACf,YAAY,EAAE,SAAS,EACvB,YAAY,EAAE,SAAS;IAanB,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,aAAa,CAAC;IAsBpD,OAAO,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;YAKhD,UAAU;YAgCV,eAAe;CAqC9B;AAED,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,UAAU,EACf,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,UAAU,EACf,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,UAAU,EAChB,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,OAAO,GACd,OAAO,CAAC,eAAe,CAAC,CAI1B"}

package/dist/transport/transportcipher.js

@@ -0,0 +1,129 @@
+/**
+ * Transport layer cipher that combines AES-CTR and HMAC-SHA256.
+ * Manages encryption/decryption state, sequence numbers, and MAC verification.
+ */
+import { encryptAES128CTR, decryptAES128CTR } from "../crypto/cipher";
+import { computeHMACSHA256, constantTimeEqual } from "../crypto/mac";
+import { buildPacket } from "../protocol/codec";
+import { writeUint32, concat } from "../protocol/serialization";
+import { HMAC_SHA256_SIZE, AES_BLOCK_SIZE, MAX_PACKET_SIZE } from "../domain/constants";
+import { MacVerificationError, ProtocolError } from "../domain/errors";
+export class TransportCipher {
+    constructor(ivC, keyC, macC, ivS, keyS, macS, initialSeqOut, initialSeqIn, macEtm, keyEncCrypto, keyDecCrypto) {
+        this.ivEnc = new Uint8Array(ivC);
+        this.ivDec = new Uint8Array(ivS);
+        this.keyEnc = keyEncCrypto;
+        this.keyDec = keyDecCrypto;
+        this.seqOut = initialSeqOut;
+        this.seqIn = initialSeqIn;
+        this.macEtm = macEtm;
+        this.macC = macC;
+        this.macS = macS;
+    }
+    async encrypt(payload) {
+        const raw = buildPacket(payload, this.macEtm);
+        const seq = this.seqOut++;
+        let ciphertext;
+        let macInput;
+        if (this.macEtm) {
+            const packetLen = raw.subarray(0, 4);
+            const { ciphertext: ct, nextIv } = await encryptAES128CTR(this.keyEnc, this.ivEnc, raw.subarray(4));
+            this.ivEnc = nextIv;
+            ciphertext = ct;
+            macInput = concat(writeUint32(seq), packetLen, ciphertext);
+            const mac = await computeHMACSHA256(this.macC, macInput);
+            return { ciphertext: concat(packetLen, ciphertext, mac) };
+        }
+        const { ciphertext: ct, nextIv } = await encryptAES128CTR(this.keyEnc, this.ivEnc, raw);
+        this.ivEnc = nextIv;
+        ciphertext = ct;
+        macInput = concat(writeUint32(seq), raw);
+        const mac = await computeHMACSHA256(this.macC, macInput);
+        return { ciphertext: concat(ciphertext, mac) };
+    }
+    async decrypt(data) {
+        if (this.macEtm)
+            return this.decryptEtm(data);
+        return this.decryptStandard(data);
+    }
+    async decryptEtm(data) {
+        if (data.length < 4 + HMAC_SHA256_SIZE)
+            return null;
+        const plen = new DataView(data.buffer, data.byteOffset, 4).getUint32(0, false);
+        if (plen < 5 || plen > MAX_PACKET_SIZE)
+            return null;
+        const totalLen = 4 + plen + HMAC_SHA256_SIZE;
+        if (data.length < totalLen)
+            return null;
+        const packetLen = data.subarray(0, 4);
+        const ciphertext = data.subarray(4, 4 + plen);
+        const macReceived = data.subarray(4 + plen, 4 + plen + HMAC_SHA256_SIZE);
+        const macInput = concat(writeUint32(this.seqIn), packetLen, ciphertext);
+        const macExpected = await computeHMACSHA256(this.macS, macInput);
+        if (!constantTimeEqual(macReceived, macExpected)) {
+            throw new MacVerificationError("MAC verification failed (EtM mode)");
+        }
+        const { plaintext: fullRawInner, nextIv } = await decryptAES128CTR(this.keyDec, this.ivDec, ciphertext);
+        const padLen = fullRawInner[0];
+        if (padLen < 4 || padLen > 255) {
+            throw new ProtocolError(`Invalid padding length: ${padLen} (seq=${this.seqIn})`);
+        }
+        if (padLen > plen - 1) {
+            throw new ProtocolError(`Padding exceeds packet length (seq=${this.seqIn})`);
+        }
+        const payloadLen = plen - 1 - padLen;
+        if (payloadLen < 0 || 1 + payloadLen > fullRawInner.length) {
+            throw new ProtocolError(`Invalid payload length: ${payloadLen} (seq=${this.seqIn})`);
+        }
+        this.ivDec = nextIv;
+        this.seqIn++;
+        const payload = fullRawInner.subarray(1, 1 + payloadLen);
+        return { payload, consumed: totalLen };
+    }
+    async decryptStandard(data) {
+        if (data.length < AES_BLOCK_SIZE + HMAC_SHA256_SIZE)
+            return null;
+        const firstBlock = data.subarray(0, AES_BLOCK_SIZE);
+        const { plaintext: first, nextIv: ivAfterFirst } = await decryptAES128CTR(this.keyDec, this.ivDec, firstBlock);
+        const plen = new DataView(first.buffer, first.byteOffset, 4).getUint32(0, false);
+        if (plen < 5 || plen > MAX_PACKET_SIZE)
+            return null;
+        const totalEnc = 4 + plen;
+        if (data.length < totalEnc + HMAC_SHA256_SIZE)
+            return null;
+        const macReceived = data.subarray(totalEnc, totalEnc + HMAC_SHA256_SIZE);
+        let fullRaw;
+        let ivAfterDecrypt;
+        if (totalEnc <= AES_BLOCK_SIZE) {
+            fullRaw = first.subarray(0, totalEnc);
+            ivAfterDecrypt = ivAfterFirst;
+        }
+        else {
+            const { plaintext: raw, nextIv: ivAfterRest } = await decryptAES128CTR(this.keyDec, ivAfterFirst, data.subarray(AES_BLOCK_SIZE, totalEnc));
+            ivAfterDecrypt = ivAfterRest;
+            fullRaw = concat(first, raw);
+        }
+        const padLen = fullRaw[4];
+        if (padLen < 4 || padLen > 255) {
+            throw new ProtocolError(`Invalid padding length: ${padLen} (seq=${this.seqIn})`);
+        }
+        const payloadLen = plen - 1 - padLen;
+        if (payloadLen < 0 || 5 + payloadLen > fullRaw.length) {
+            throw new ProtocolError(`Invalid payload length: ${payloadLen} (seq=${this.seqIn})`);
+        }
+        const macInput = concat(writeUint32(this.seqIn), fullRaw);
+        const macExpected = await computeHMACSHA256(this.macS, macInput);
+        if (!constantTimeEqual(macReceived, macExpected)) {
+            throw new MacVerificationError("MAC verification failed");
+        }
+        this.seqIn++;
+        this.ivDec = ivAfterDecrypt;
+        const payload = fullRaw.subarray(5, 5 + payloadLen);
+        return { payload, consumed: totalEnc + HMAC_SHA256_SIZE };
+    }
+}
+export async function createTransportCipher(ivC, keyC, macC, ivS, keyS, macS, initialSeqOut, initialSeqIn, macEtm) {
+    const keyEncCrypto = await crypto.subtle.importKey("raw", keyC, { name: "AES-CTR" }, false, ["encrypt"]);
+    const keyDecCrypto = await crypto.subtle.importKey("raw", keyS, { name: "AES-CTR" }, false, ["decrypt"]);
+    return new TransportCipher(ivC, keyC, macC, ivS, keyS, macS, initialSeqOut, initialSeqIn, macEtm, keyEncCrypto, keyDecCrypto);
+}

package/dist/vitest.config.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("vite").UserConfig;
+export default _default;
+//# sourceMappingURL=vitest.config.d.ts.map

package/dist/vitest.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.config.d.ts","sourceRoot":"","sources":["../vitest.config.ts"],"names":[],"mappings":";AAEA,wBAMG"}

package/dist/vitest.config.js

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+export default defineConfig({
+    test: {
+        include: ["**/*.test.ts"],
+        environment: "node",
+        globals: true,
+    },
+});

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "ssh2web",
+  "author": "Qasim Soomro",
+  "version": "1.0.0",
+  "description": "SSH-2 client for the browser over WebSocket. Key exchange, public-key auth, session API.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "ssh",
+    "ssh2",
+    "websocket",
+    "browser",
+    "client"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/qas/ssh2web"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^4.0.18",
+    "typescript": "5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}