Stableness Shadowsocks Node

https://github.com/stableness/shadowsocks-node
Admin
A Node.js command-line tool that provides Shadowsocks client and server functionalities, enabling...
Tokens:7,183
Snippets:24
Trust Score:4.5
License:GPL-3.0
Update:10 months ago
Show doc for...
Tokens:
Raw
### Shadowsocks-Node CLI Usage Examples

Source: https://context7.com/stableness/shadowsocks-node/llms.txt

Demonstrates various command-line interface commands for starting the Shadowsocks client. It covers basic configurations, multiple proxies, subscription URLs, and different encryption methods.

```bash
# Basic usage with local SOCKS5 proxy and remote server
ss-node -l :8080 -r ss://chacha20-ietf-poly1305:mypassword@example.com:8388

# With custom encryption method override
ss-node -l :8080 -r ss://example.com:8388 -k mypassword -m aes-256-gcm

# Multiple local proxies with authentication
ss-node -l socks5://user:pass@127.0.0.1:8080 -l socks5://127.0.0.1:9090 -r ss://server.com:8388 -k secret

# Multiple remote servers (randomly selected)
ss-node -l :8080 -r ss://server1.com:8388 -r ss://server2.com:8388 -k mypassword

# Using subscription URLs with auto-refresh (default 1 hour)
ss-node -l :8080 -s https://example.com/subscription -f 1800

# Silent mode with deprecated cipher support
ss-node -l :8080 -r ss://rc4-md5:password@old-server.com:8388 -q --enable_deprecated_cipher

# Using base64url encoded credentials
ss-node -l :8080 -r ss://Y2hhY2hhMjAtaWV0Zi1wb2x5MTMwNTpteXBhc3N3b3Jk@example.com:8388

# Using base64 encoded full URI
ss-node -l :8080 -r ss://Y2hhY2hhMjAtaWV0Zi1wb2x5MTMwNTpteXBhc3N3b3JkQGV4YW1wbGUuY29tOjgzODg=
```

--------------------------------

### Shadowsocks-Node load() Function Configuration

Source: https://context7.com/stableness/shadowsocks-node/llms.txt

Illustrates how to use the `load()` function in Node.js to configure and start the Shadowsocks client. It shows basic setup, advanced configurations with multiple subscriptions, and error handling.

```typescript
import { load } from '@stableness/shadowsocks-node';

// Basic configuration
const subscription = load({
    local: ['127.0.0.1:8080'],
    remote: ['ss://chacha20-ietf-poly1305:password@server.example.com:8388'],
    subscribe: [],
    refresh: 3600,
    quiet: false,
    enable_deprecated_cipher: false,
});

// Execute and handle errors
subscription().then(result => {
    if (result._tag === 'Right') {
        const rxSubscription = result.right;
        console.log('Shadowsocks client started successfully');

        // Cleanup on shutdown
        process.on('SIGINT', () => {
            rxSubscription.unsubscribe();
            process.exit(0);
        });
    } else {
        console.error('Failed to start:', result.left);
        process.exit(1);
    }
});

// Advanced configuration with subscriptions
const advancedConfig = load({
    local: [
        'socks5://username:password@127.0.0.1:8080',
        ':9090'  // Shorthand for socks5://0.0.0.0:9090
    ],
    remote: [
        'ss://server1.example.com:8388',
        'ss://aes-256-gcm:secret@server2.example.com:8388'
    ],
    subscribe: [
        'https://provider1.com/subscription',
        'https://provider2.com/subscription'
    ],
    refresh: 1800,  // Refresh subscriptions every 30 minutes
    key: 'override-password',
    method: 'chacha20-ietf-poly1305',
    quiet: false,
    enable_deprecated_cipher: false,
});

advancedConfig();
```

--------------------------------

### Define and Validate Shadowsocks-Node CLI Options (TypeScript)

Source: https://context7.com/stableness/shadowsocks-node/llms.txt

Demonstrates how to define and validate configuration options for the shadowsocks-node CLI using TypeScript. It imports the Options type, shows an example of a partial options object, and includes a validation function to check for required parameters and valid settings. This snippet is essential for programmatically configuring the Shadowsocks client.

```typescript
import type { Options } from '@stableness/shadowsocks-node/dist/bin.js';

// Type-safe options object
const options: Partial<Options> = {
    local: [
        'socks5://127.0.0.1:8080',
        ':9090'
    ],
    remote: [
        'ss://server1.example.com:8388',
        'ss://chacha20-ietf-poly1305:password@server2.example.com:8388'
    ],
    subscribe: [
        'https://provider.example.com/subscription',
        'file:///path/to/local/servers.txt'
    ],
    refresh: 1800,  // seconds
    method: 'chacha20-ietf-poly1305',
    key: 'override-password',
    quiet: false,
    enable_deprecated_cipher: false,
    third_party_providers_use_at_your_own_risk: false,
    YOLO: false
};

// Validation example
function validateOptions(opts: Partial<Options>): string[] {
    const errors: string[] = [];

    if (!opts.local || opts.local.length === 0) {
        errors.push('At least one local address required');
    }

    if (!opts.remote || opts.remote.length === 0) {
        if (!opts.subscribe || opts.subscribe.length === 0) {
            errors.push('Either remote or subscribe address required');
        }
    }

    if (opts.refresh && opts.refresh < 60) {
        errors.push('Refresh interval must be at least 60 seconds');
    }

    return errors;
}

const validationErrors = validateOptions(options);
if (validationErrors.length > 0) {
    console.error('Configuration errors:', validationErrors);
}
```

--------------------------------

### Command Line Interface (CLI)

Source: https://context7.com/stableness/shadowsocks-node/llms.txt

The `ss-node` command-line tool allows users to configure and run the Shadowsocks client with various options for local proxies, remote servers, and subscription management.

```APIDOC
## Command Line Interface (CLI)

The `ss-node` command provides a CLI tool for running the Shadowsocks client with flexible configuration options for local proxies, remote servers, and subscriptions.

### Usage Examples

*   **Basic Usage:**
    ```bash
    ss-node -l :8080 -r ss://chacha20-ietf-poly1305:mypassword@example.com:8388
    ```

*   **Custom Encryption Method:**
    ```bash
    ss-node -l :8080 -r ss://example.com:8388 -k mypassword -m aes-256-gcm
    ```

*   **Multiple Local Proxies:**
    ```bash
    ss-node -l socks5://user:pass@127.0.0.1:8080 -l socks5://127.0.0.1:9090 -r ss://server.com:8388 -k secret
    ```

*   **Multiple Remote Servers:**
    ```bash
    ss-node -l :8080 -r ss://server1.com:8388 -r ss://server2.com:8388 -k mypassword
    ```

*   **Subscription URLs:**
    ```bash
    ss-node -l :8080 -s https://example.com/subscription -f 1800
    ```

*   **Deprecated Cipher Support:**
    ```bash
    ss-node -l :8080 -r ss://rc4-md5:password@old-server.com:8388 -q --enable_deprecated_cipher
    ```

*   **Base64url Encoded Credentials:**
    ```bash
    ss-node -l :8080 -r ss://Y2hhY2hhMjAtaWV0Zi1wb2x5MTMwNTpteXBhc3N3b3JkQGV4YW1wbGUuY29tOjgzODg=
    ```

*   **Base64 Encoded Full URI:**
    ```bash
    ss-node -l :8080 -r ss://Y2hhY2hhMjAtaWV0Zi1wb2x5MTMwNTpteXBhc3N3b3JkQGV4YW1wbGUuY29tOjgzODg=
    ```
```

--------------------------------

### load() Function

Source: https://context7.com/stableness/shadowsocks-node/llms.txt

The `load()` function initializes and configures the Shadowsocks client, setting up local SOCKS5 proxies, remote server connections, and handling subscription updates.

```APIDOC
## load() Function

The `load()` function is the main entry point that bootstraps the Shadowsocks client, configuring local SOCKS5 proxies and establishing connections to remote servers with subscription support and error handling.

### Method

`load(config: ShadowsocksNodeConfig): () => Promise<Rx.Subscription | Error>
`

### Parameters

#### Request Body (`ShadowsocksNodeConfig`)

- **local** (string[]) - Required - An array of local proxy endpoints (e.g., `':8080'`, `'socks5://user:pass@127.0.0.1:8080'`).
- **remote** (string[]) - Optional - An array of remote Shadowsocks server configurations (e.g., `'ss://method:password@server:port'`). If provided, it overrides the `key` and `method` parameters.
- **subscribe** (string[]) - Optional - An array of URLs for subscription lists. These lists are automatically refreshed.
- **refresh** (number) - Optional - The interval in seconds for refreshing subscription lists. Defaults to 3600 (1 hour).
- **key** (string) - Optional - The password for the Shadowsocks server. Can be overridden by remote configuration.
- **method** (string) - Optional - The encryption method to use (e.g., `'chacha20-ietf-poly1305'`). Can be overridden by remote configuration.
- **quiet** (boolean) - Optional - If true, suppresses console output. Defaults to `false`.
- **enable_deprecated_cipher** (boolean) - Optional - If true, allows the use of deprecated cipher methods. Defaults to `false`.

### Returns

A function that, when called, returns a Promise resolving to either an RxJS Subscription object upon successful startup or an Error object if startup fails.

### Request Example (Basic)

```typescript
import { load } from '@stableness/shadowsocks-node';

const subscription = load({
    local: ['127.0.0.1:8080'],
    remote: ['ss://chacha20-ietf-poly1305:password@server.example.com:8388'],
    subscribe: [],
    refresh: 3600,
    quiet: false,
    enable_deprecated_cipher: false,
});

subscription().then(result => {
    if (result._tag === 'Right') {
        const rxSubscription = result.right;
        console.log('Shadowsocks client started successfully');

        process.on('SIGINT', () => {
            rxSubscription.unsubscribe();
            process.exit(0);
        });
    } else {
        console.error('Failed to start:', result.left);
        process.exit(1);
    }
});
```

### Request Example (Advanced)

```typescript
const advancedConfig = load({
    local: [
        'socks5://username:password@127.0.0.1:8080',
        ':9090'  // Shorthand for socks5://0.0.0.0:9090
    ],
    remote: [
        'ss://server1.example.com:8388',
        'ss://aes-256-gcm:secret@server2.example.com:8388'
    ],
    subscribe: [
        'https://provider1.com/subscription',
        'https://provider2.com/subscription'
    ],
    refresh: 1800,  // Refresh subscriptions every 30 minutes
    key: 'override-password',
    method: 'chacha20-ietf-poly1305',
    quiet: false,
    enable_deprecated_cipher: false,
});

advancedConfig();
```

### Response Example (Success)

Upon successful startup, the Promise resolves with an RxJS Subscription object.

```typescript
// Example: result.right would be an RxJS Subscription object
console.log('Shadowsocks client started successfully');
```

### Response Example (Error)

If startup fails, the Promise resolves with an Error object.

```typescript
// Example: result.left would be an Error object
console.error('Failed to start:', error);
```
```

--------------------------------

### Fetch and Parse Subscription URLs with crawlRowsStartsBy()

Source: https://context7.com/stableness/shadowsocks-node/llms.txt

Fetches and parses subscription URLs to extract Shadowsocks server configurations. It supports plain text and base64 encoded formats with automatic retry and refresh capabilities. Dependencies include '@stableness/wabble/dist/extra.js' and 'fp-ts/ReadonlyNonEmptyArray'.

```typescript
import { crawlRowsStartsBy } from '@stableness/wabble/dist/extra.js';
import * as NA from 'fp-ts/ReadonlyNonEmptyArray';

// Define subscription environment
const subscriptionConfig = {
    endpoint: 'https://provider.example.com/servers',
    base64: true,           // Endpoint returns base64 encoded content
    timeout: 5000,          // Request timeout in milliseconds
    refresh: 3600,          // Refresh interval in seconds
    retry: 3                // Number of retry attempts
};

// Create subscription crawler for ss:// URIs
const serverCrawler = crawlRowsStartsBy('ss://')(subscriptionConfig);

// Subscribe to server list updates
serverCrawler.subscribe({
    next: (serverUris) => {
        console.log(`Received ${serverUris.length} servers:`);
        serverUris.forEach((uri, index) => {
            console.log(`  ${index + 1}. ${uri}`);
        });

        // Parse and use servers
        const servers = serverUris.map(uri => ({
            uri,
            key: 'override-password',
            alg: 'chacha20-ietf-poly1305'
        }));
    },
    error: (err) => {
        console.error('Failed to fetch subscription:', err);
    }
});

// Multiple subscription sources
const multiCrawler = crawlRowsStartsBy('ss://', 'ssr://')(subscriptionConfig);
```

--------------------------------

### Transform Raw Configurations with convert()

Source: https://context7.com/stableness/shadowsocks-node/llms.txt

Transforms raw configuration objects into validated Config structures with properly typed services and servers for internal use by the proxy system. It requires '@stableness/wabble/dist/extra.js' for the conversion logic. The function takes a raw configuration object and returns a validated Config object or throws an error for invalid configurations.

```typescript
import { convert } from '@stableness/wabble/dist/extra.js';

// Raw configuration object
const rawConfig = {
    services: [{
        protocol: 'socks5',
        host: '127.0.0.1',
        port: 8080,
        auth: null
    }],
    servers: [{
        protocol: 'ss',
        host: 'server.example.com',
        port: 8388,
        key: Buffer.from('mypassword'),
        cipher: {
            type: 'AEAD',
            algorithm: 'chacha20-ietf-poly1305',
            keySize: 32,
            saltSize: 32,
            nonceSize: 12,
            tagSize: 16
        }
    }]
};

// Convert and validate
try {
    const config = convert(rawConfig);

    console.log('Services:', config.services.length);
    console.log('Servers:', config.servers.length);

    // Access typed properties
    config.services.forEach(service => {
        console.log(`SOCKS5 proxy: ${service.protocol}://${service.host}:${service.port}`);
    });

    config.servers.forEach(server => {
        console.log(`Remote: ${server.protocol}://${server.host}:${server.port}`);
        console.log(`Cipher: ${server.cipher.type} - ${server.cipher.algorithm}`);
    });
} catch (error) {
    console.error('Invalid configuration:', error);
}
```

--------------------------------

### socks5Proxy() Function

Source: https://context7.com/stableness/shadowsocks-node/llms.txt

Creates a SOCKS5 proxy server that listens for incoming connections. It provides hooks for custom traffic handling and connection management via reactive streams.

```APIDOC
## socks5Proxy() Function

### Description
Creates a SOCKS5 proxy server with hooks for custom traffic handling and connection management using reactive streams.

### Method
`socks5Proxy(service)(logger)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **service** (object) - Configuration for the SOCKS5 service.
  - **protocol** (string) - Must be 'socks5'.
  - **host** (string) - The host to listen on.
  - **port** (number) - The port to listen on.
  - **auth** (Option<(credentials: object) => boolean>) - Optional authentication function.
- **logger** (object) - A logger instance.

### Request Example
```typescript
import { socks5Proxy, logging } from '@stableness/wabble/dist/extra.js';
import * as O from 'fp-ts/Option';

const service = {
    protocol: 'socks5' as const,
    host: '127.0.0.1',
    port: 8080,
    auth: O.some((credentials) => {
        return credentials.username === 'user' &&
               credentials.password === 'pass';
    })
};

const proxyObservable = socks5Proxy(service)(logging);

const subscription = proxyObservable.subscribe({
    next: ({ host, port, hook, abort }) => {
        console.log(`New connection to ${host}:${port}`);
        hook(upstreamSocket, downstreamSocket).then(() => {
            console.log('Connection closed successfully');
        }).catch(err => {
            console.error('Connection error:', err);
        });
    },
    error: (err) => {
        console.error('Proxy error:', err);
    }
});
```

### Response
#### Success Response (200)
- **Observable** - An observable that emits connection events.

#### Response Example
```json
// Emitted event object:
{
  "host": "127.0.0.1",
  "port": 8080,
  "hook": "function",
  "abort": "function"
}
```
```

--------------------------------

### loadBy() Function

Source: https://context7.com/stableness/shadowsocks-node/llms.txt

The `loadBy()` function allows for dependency injection of custom configuration subjects, runners, and loggers to create specialized load functions. This is useful for advanced use cases and testing scenarios.

```APIDOC
## loadBy() Function

### Description
Creates a customized load function by accepting custom configuration subjects, runners, and loggers. Useful for testing or advanced configurations.

### Method
`loadBy(configSubject, runnerSubject, customLogger)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **configSubject** (Rx.ReplaySubject) - A reactive subject for configuration updates.
- **runnerSubject** (Rx.Observable) - A reactive subject for runner events.
- **customLogger** (object) - A logger instance (e.g., pino).

### Request Example
```typescript
import { loadBy } from '@stableness/shadowsocks-node';
import * as Rx from 'rxjs';
import pino from 'pino';

const customLogger = pino({
    level: 'debug',
    transport: {
        target: 'pino-pretty',
        options: { colorize: true }
    }
});

const configSubject = new Rx.ReplaySubject(1);
const runnerSubject = new Rx.NEVER;

const customLoad = loadBy(configSubject, runnerSubject, customLogger);

const result = customLoad({
    local: [':8080'],
    remote: ['ss://example.com:8388'],
    subscribe: [],
    refresh: 3600,
    key: 'mypassword',
    quiet: false,
});

result().then(either => {
    if (either._tag === 'Right') {
        const subscription = either.right;
        configSubject.subscribe(config => {
            console.log('Active servers:', config.servers.length);
        });
    }
});
```

### Response
#### Success Response (200)
- **(Function)** - Returns a function that, when called, returns a TaskEither representing the loading process.

#### Response Example
```json
// The returned function's execution will yield a TaskEither.
// Example of the type of value within the TaskEither:
{
  "_tag": "Right",
  "right": "Subscription object"
}
```
```

--------------------------------

### socks5Proxy() Function - TypeScript

Source: https://context7.com/stableness/shadowsocks-node/llms.txt

Creates a SOCKS5 proxy server that listens for incoming connections. It provides hooks for custom traffic handling and connection management via reactive streams. This function requires '@stableness/wabble/dist/extra.js' and 'fp-ts/Option'.

```typescript
import { socks5Proxy, logging } from '@stableness/wabble/dist/extra.js';
import * as O from 'fp-ts/Option';

// Define SOCKS5 service configuration
const service = {
    protocol: 'socks5' as const,
    host: '127.0.0.1',
    port: 8080,
    auth: O.some((credentials) => {
        // Custom authentication logic
        return credentials.username === 'user' &&
               credentials.password === 'pass';
    })
};

// Create proxy with logging
const proxyObservable = socks5Proxy(service)(logging);

// Subscribe to connection events
const subscription = proxyObservable.subscribe({
    next: ({ host, port, hook, abort }) => {
        console.log(`New connection to ${host}:${port}`);

        // Handle traffic through custom hook
        hook(upstreamSocket, downstreamSocket).then(() => {
            console.log('Connection closed successfully');
        }).catch(err => {
            console.error('Connection error:', err);
        });

        // Abort connection if needed
        // abort();
    },
    error: (err) => {
        console.error('Proxy error:', err);
    }
});
```

--------------------------------

### loadBy() Factory Function - TypeScript

Source: https://context7.com/stableness/shadowsocks-node/llms.txt

The `loadBy()` function is a factory for creating custom load functions. It accepts custom configuration subjects, runners, and loggers for advanced use cases and testing. Dependencies include 'rxjs' for reactive subjects and 'pino' for logging.

```typescript
import { loadBy } from '@stableness/shadowsocks-node';
import * as Rx from 'rxjs';
import pino from 'pino';

// Create custom logger
const customLogger = pino({
    level: 'debug',
    transport: {
        target: 'pino-pretty',
        options: { colorize: true }
    }
});

// Create custom reactive subjects
const configSubject = new Rx.ReplaySubject(1);
const runnerSubject = new Rx.NEVER;  // Custom runner implementation

// Create custom load function
const customLoad = loadBy(configSubject, runnerSubject, customLogger);

// Use the custom loader
const result = customLoad({
    local: [':8080'],
    remote: ['ss://example.com:8388'],
    subscribe: [],
    refresh: 3600,
    key: 'mypassword',
    quiet: false,
});

result().then(either => {
    if (either._tag === 'Right') {
        const subscription = either.right;

        // Subscribe to config changes
        configSubject.subscribe(config => {
            console.log('Active servers:', config.servers.length);
            console.log('Active services:', config.services.length);
        });
    }
});
```

--------------------------------

### chainSS() Function

Source: https://context7.com/stableness/shadowsocks-node/llms.txt

Establishes an encrypted Shadowsocks tunnel between a local proxy and a remote server. It handles cipher negotiation, key derivation, and bidirectional encrypted data streaming.

```APIDOC
## chainSS() Function

### Description
Establishes an encrypted Shadowsocks tunnel, handling cipher negotiation, key derivation, and data streaming.

### Method
`chainSS(remoteServer)(connectionOpts)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **remoteServer** (object) - Configuration for the remote Shadowsocks server.
  - **protocol** (string) - Must be 'ss'.
  - **host** (string) - The remote server host.
  - **port** (number) - The remote server port.
  - **key** (Buffer) - The encryption key.
  - **cipher** (object) - Cipher suite details.
    - **type** (string) - e.g., 'AEAD'.
    - **algorithm** (string) - e.g., 'chacha20-ietf-poly1305'.
    - **keySize** (number) - Key size in bytes.
    - **saltSize** (number) - Salt size in bytes.
    - **nonceSize** (number) - Nonce size in bytes.
    - **tagSize** (number) - Tag size in bytes.
- **connectionOpts** (object) - Options for the connection.
  - **host** (string) - Target host to connect to.
  - **port** (number) - Target port to connect to.
  - **abort** (function) - Function to abort the connection.
  - **logger** (object) - Logger instance.
  - **hook** (function) - Async function for handling bidirectional data flow.

### Request Example
```typescript
import { chainSS, cryptoPairsCE } from '@stableness/wabble/dist/extra.js';
import * as TE from 'fp-ts/TaskEither';
import * as E from 'fp-ts/Either';

const remoteServer = {
    protocol: 'ss' as const,
    host: 'server.example.com',
    port: 8388,
    key: Buffer.from('mypassword'),
    cipher: {
        type: 'AEAD' as const,
        algorithm: 'chacha20-ietf-poly1305',
        keySize: 32,
        saltSize: 32,
        nonceSize: 12,
        tagSize: 16
    }
};

const connectionOpts = {
    host: 'target.example.com',
    port: 443,
    abort: () => console.log('Connection aborted'),
    logger: console,
    hook: async (clientSocket, serverSocket) => {
        clientSocket.pipe(serverSocket);
        serverSocket.pipe(clientSocket);
    }
};

const tunnelTask = chainSS(remoteServer)(connectionOpts);

tunnelTask().then(result => {
    if (E.isRight(result)) {
        console.log('Shadowsocks tunnel established');
    } else {
        console.error('Tunnel failed:', result.left);
    }
});
```

### Response
#### Success Response (200)
- **TaskEither** - A TaskEither representing the tunnel establishment process. A `Right` value indicates success.

#### Response Example
```json
// If successful, the TaskEither will resolve to a Right value.
// Example of the type of value:
{
  "isRight": true
}
// If failed, it will resolve to a Left value with an error.
{
  "isLeft": true,
  "left": "Error details"
}
```
```

--------------------------------

### Generate Encryption/Decryption Stream Pairs with cryptoPairs()

Source: https://context7.com/stableness/shadowsocks-node/llms.txt

Generates encryption and decryption stream pairs for the Shadowsocks protocol based on server cipher configuration and initial handshake data. It uses functions from '@stableness/wabble/dist/extra.js' and requires 'fp-ts/Either' and 'net.Socket'. This function is crucial for setting up secure communication channels.

```typescript
import { cryptoPairs, cryptoPairsCE } from '@stableness/wabble/dist/extra.js';
import * as E from 'fp-ts/Either';
import { Socket } from 'net';

// Server with AEAD cipher
const server = {
    protocol: 'ss' as const,
    host: 'server.example.com',
    port: 8388,
    key: Buffer.from('mypassword'),
    cipher: {
        type: 'AEAD' as const,
        algorithm: 'chacha20-ietf-poly1305',
        keySize: 32,
        saltSize: 32,
        nonceSize: 12,
        tagSize: 16
    }
};

// SOCKS5 handshake for target destination
const targetHost = 'example.com';
const targetPort = 443;
const handshakeData = new Uint8Array([
    0x03,  // Address type: domain
    targetHost.length,
    ...Buffer.from(targetHost),
    (targetPort >> 8) & 0xff,
    targetPort & 0xff
]);

// Generate cipher streams (unsafe version)
const { enc, dec } = cryptoPairs(server, handshakeData);

// Or use safe Either version
const pairsResult = cryptoPairsCE(server)(handshakeData);

if (E.isRight(pairsResult)) {
    const { enc, dec } = pairsResult.right;

    // Use in socket pipeline
    const clientSocket = new Socket();
    const serverSocket = new Socket();

    // Encrypt outgoing data
    clientSocket.pipe(enc).pipe(serverSocket);

    // Decrypt incoming data
    serverSocket.pipe(dec).pipe(clientSocket);
} else {
    console.error('Failed to create cipher pairs:', pairsResult.left);
}
```

--------------------------------

### chainSS() Function - TypeScript

Source: https://context7.com/stableness/shadowsocks-node/llms.txt

Establishes an encrypted Shadowsocks tunnel between a local proxy and a remote server. It handles cipher negotiation, key derivation, and bidirectional encrypted data streaming. Dependencies include '@stableness/wabble/dist/extra.js', 'fp-ts/TaskEither', and 'fp-ts/Either'.

```typescript
import { chainSS, cryptoPairsCE } from '@stableness/wabble/dist/extra.js';
import * as TE from 'fp-ts/TaskEither';
import * as E from 'fp-ts/Either';

// Define remote server configuration
const remoteServer = {
    protocol: 'ss' as const,
    host: 'server.example.com',
    port: 8388,
    key: Buffer.from('mypassword'),
    cipher: {
        type: 'AEAD' as const,
        algorithm: 'chacha20-ietf-poly1305',
        keySize: 32,
        saltSize: 32,
        nonceSize: 12,
        tagSize: 16
    }
};

// Connection options from SOCKS5 proxy
const connectionOpts = {
    host: 'target.example.com',
    port: 443,
    abort: () => console.log('Connection aborted'),
    logger: console,
    hook: async (clientSocket, serverSocket) => {
        // Custom hook for bidirectional data flow
        clientSocket.pipe(serverSocket);
        serverSocket.pipe(clientSocket);
    }
};

// Establish Shadowsocks chain
const tunnelTask = chainSS(remoteServer)(connectionOpts);

// Execute with error handling
tunnelTask().then(result => {
    if (E.isRight(result)) {
        console.log('Shadowsocks tunnel established');
    } else {
        console.error('Tunnel failed:', result.left);
    }
});
```
Tokens:
Raw