ssh_tunnel_proxy 2.1.1 → 3.0.0

package/examples/zrok-termux.ts

@@ -0,0 +1,147 @@
+/*
+ * examples/zrok-termux.ts
+ *
+ * The topology this refactor was built against:
+ *
+ *   workstation                          phone (Termux + proot)
+ *   ───────────                          ──────────────────────
+ *   browser -> 127.0.0.1:8280 ─┐
+ *   ssh     -> 127.0.0.1:8122 ─┤
+ *                              │  SSH over a private zrok TCP share
+ *                              └─ 127.0.0.1:9191 ══════════════> sshd on 127.0.0.1:8022
+ *                                                                 ├─ 127.0.0.1:8080  (web app in proot)
+ *                                                                 └─ 192.168.1.1:22  (LAN router)
+ *
+ * Bring the relay up first — this library never creates it:
+ *
+ *   phone:        zrok share private --backend-mode tcpTunnel 127.0.0.1:8022
+ *   workstation:  zrok access private --bind 127.0.0.1:9191 <share-token>
+ *   workstation:  nc 127.0.0.1 9191     # must print SSH-2.0-... before running this
+ *
+ * Then:  npx tsc && node build-examples/zrok-termux.js
+ *
+ * License: MIT
+ */
+
+import { SSHTunnel, credential, isTunnelError } from '../src/index';
+
+async function main(): Promise<void> {
+  const tunnel = new SSHTunnel(
+    {
+      id: 'phone',
+      transport: {
+        endpoint: { host: '127.0.0.1', port: 9191 },
+        username: 'user',
+        privateKey: credential.file('~/.ssh/id_ed25519'),
+        // Documentation only. The library treats every path as a plain address.
+        reachability: 'zrok',
+        keepaliveIntervalMs: 10_000,
+      },
+      localForwards: [
+        {
+          id: 'app',
+          listen: { host: '127.0.0.1', port: 8280 },
+          target: { host: '127.0.0.1', port: 8080 },
+        },
+        {
+          id: 'router-ssh',
+          listen: { host: '127.0.0.1', port: 8122 },
+          target: { host: '192.168.1.1', port: 22 },
+        },
+      ],
+      portPolicy: {
+        // 192.168.1.1:22 is privileged, so it has to be named explicitly.
+        allowedPrivilegedPorts: [22],
+        allowedLocalListenPorts: [8280, 8122],
+        allowedRemoteHosts: ['127.0.0.1', '192.168.1.1'],
+      },
+      reconnect: {
+        enabled: true,
+        initialDelayMs: 1_000,
+        maxDelayMs: 30_000,
+        maxAttempts: 0, // retry forever; the phone's link comes and goes
+      },
+    },
+    { connectionIdleTimeoutMs: 0, debugSsh: false },
+  );
+
+  tunnel.on('ready', (status) => {
+    console.log(`tunnel ready via ${status.endpoint.host}:${status.endpoint.port}`);
+    for (const forward of status.forwards) {
+      console.log(
+        `  ${forward.direction === 'local' ? 'L' : 'R'} ` +
+          `${forward.listen.host}:${forward.assignedPort ?? forward.listen.port}` +
+          ` -> ${forward.target.host}:${forward.target.port} [${forward.state}]`,
+      );
+    }
+  });
+
+  tunnel.on('forward', ({ status, previous }) => {
+    if (status.state !== previous) {
+      console.log(`forward ${status.forwardId}: ${previous} -> ${status.state}`);
+    }
+  });
+
+  tunnel.on('reconnect', ({ attempt, delayMs, cause }) => {
+    console.warn(`link lost (${cause ?? 'unknown'}); retry ${attempt} in ${delayMs}ms`);
+  });
+
+  tunnel.on('error', (err) => {
+    console.error(`[${err.code}] ${err.message}`);
+    if (err.code === 'TARGET_UNREACHABLE') {
+      console.error('  is the service actually running on the phone side?');
+    }
+  });
+
+  tunnel.on('close', () => console.log('tunnel closed'));
+
+  try {
+    await tunnel.connect();
+  } catch (err) {
+    if (isTunnelError(err) && err.code === 'AUTH_FAILED') {
+      console.error('check that ~/.ssh/id_ed25519.pub is in the phone\'s authorized_keys');
+    }
+    throw err;
+  }
+
+  const app = tunnel.resolveEndpoint('app');
+  console.log(`open http://${app.endpoint.host}:${app.endpoint.port}`);
+
+  // Confirm the far side is the host we think it is.
+  const { stdout } = await tunnel.exec('id -un; uname -m');
+  console.log(`peer identity: ${stdout.trim().replace(/\n/g, ' ')}`);
+
+  // A reverse forward: expose a service running here to the phone.
+  const reverse = await tunnel.addRemoteForward({
+    id: 'workstation-api',
+    bind: { host: '127.0.0.1', port: 0 }, // let the phone pick the port
+    target: { host: '127.0.0.1', port: 3000 },
+  });
+  console.log(`phone can reach this host's :3000 at 127.0.0.1:${reverse.assignedPort}`);
+
+  // Periodic accounting, which v1 could not report at all.
+  const reporter = setInterval(() => {
+    const connections = tunnel.listConnections();
+    if (connections.length === 0) return;
+    console.log(`${connections.length} open connection(s):`);
+    for (const connection of connections) {
+      console.log(
+        `  ${connection.forwardId} ${connection.state} ` +
+          `↑${connection.bytesToTarget}B ↓${connection.bytesFromTarget}B`,
+      );
+    }
+  }, 30_000);
+
+  const shutdown = async () => {
+    clearInterval(reporter);
+    await tunnel.close();
+    process.exit(0);
+  };
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/package.json

@@ -1,63 +1,53 @@
 {
   "name": "ssh_tunnel_proxy",
-  "author": "Autonomous",
-  "license": "MIT",
-  "version": "2.1.1",
-  "description": "setup ssh tunnel with local and remote port forwarding, node ssh cli interface, use ngrok to obtain host:port",
-  "main": "dist/cjs/index.js",
-  "module": "dist/esm/index.js",
-  "types": "typings/index.d.ts",
-  "scripts": {
-    "build": "npm run build:cjs && npm run build:esm && npm run build:types && npm run build:testbench",
-    "build:cjs": "node tools/cleanup cjs && tsc -p config/tsconfig.cjs.json",
-    "build:esm": "node tools/cleanup esm && tsc -p config/tsconfig.esm.json",
-    "build:types": "node tools/cleanup types && tsc -p config/tsconfig.types.json",
-    "build:testbench": "tsc -p config/tsconfig.testbench.json",
-    "lint": "eslint \"src/*.ts\"",
-    "prepare": "npm run build",
-    "prepublishOnly": "npm test && npm run lint",
-    "preversion": "npm run lint",
-    "version": "git add -A src",
-    "postversion": "git push && git push --tags",
-    "test": "mocha --exit"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/autonomous1/ssh_tunnel_proxy"
-  },
+  "version": "3.0.0",
+  "description": "Programmatic local and reverse TCP port forwarding over SSH for Node.js, built for outbound-only and constrained-device deployments.",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
   "files": [
-    "dist/**/*",
-    "ssh2-node"
+    "build",
+    "proto",
+    "examples",
+    "README.md",
+    "MIGRATION.md",
+    "LICENSE"
   ],
-  "bin": {
-    "ssh2-node": "./ssh2-node"
+  "engines": {
+    "node": ">=18"
   },
+  "scripts": {
+    "clean": "rm -rf build",
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run clean && npm run build",
+    "test": "npm run build && mocha --timeout 20000 test/**/*.test.js",
+    "test:unit": "npm run build && mocha --timeout 5000 test/unit/*.test.js",
+    "test:integration": "npm run build && mocha --timeout 20000 test/integration/*.test.js"
+  },
+  "keywords": [
+    "ssh",
+    "ssh2",
+    "tunnel",
+    "ssh-tunnel",
+    "reverse-tunnel",
+    "reverse-ssh",
+    "port-forwarding",
+    "tcp-proxy",
+    "nat-traversal",
+    "zrok",
+    "termux",
+    "iot",
+    "edge",
+    "nodejs"
+  ],
+  "author": "Autonomous",
+  "license": "MIT",
   "dependencies": {
-    "@ngrok/ngrok-api": "^0.9.0",
-    "bluebird": "^3.7.2",
-    "commander": "^10.0.0",
-    "electron-ssh2": "^0.1.2",
-    "form-data": "^4.0.0",
-    "fs": "^0.0.1-security",
-    "keytar": "^7.9.0",
-    "net": "^1.0.2",
-    "os": "^0.1.2",
-    "split": "^1.0.1",
-    "sshpk": "^1.17.0",
-    "through": "^2.3.8",
-    "through2": "^4.0.2"
+    "ssh2": "^1.15.0"
   },
   "devDependencies": {
-    "@types/node": "^18.13.0",
-    "@typescript-eslint/eslint-plugin": "^5.52.0",
-    "@typescript-eslint/parser": "^5.52.0",
-    "eslint": "^8.34.0",
-    "eslint-config-standard-with-typescript": "^34.0.0",
-    "eslint-plugin-import": "^2.27.5",
-    "eslint-plugin-n": "^15.6.1",
-    "eslint-plugin-promise": "^6.1.1",
-    "mocha": "^10.2.0",
-    "sinon": "^15.0.1",
-    "typescript": "^4.9.5"
+    "@types/node": "^20.11.0",
+    "@types/ssh2": "^1.15.0",
+    "mocha": "^10.4.0",
+    "typescript": "^5.4.0"
   }
 }

package/proto/sshtunnel/v1/tunnel.proto

@@ -0,0 +1,343 @@
+// sshtunnel/v1/tunnel.proto
+//
+// Language-neutral data model for programmatic SSH TCP port forwarding.
+//
+// Design rules for this file:
+//   1. It describes CONFIGURATION, STATE and EVENTS only. It never describes
+//      implementation mechanics (sockets, channels, event emitters, promises).
+//   2. It contains no credential material. Secrets are referenced indirectly
+//      through a CredentialRef so that a graph/config file can be committed,
+//      diffed and shared without leaking keys.
+//   3. It is the source of truth shared by the TypeScript runtime, a future
+//      Python runtime, and any control-plane API placed in front of them.
+//
+// License: MIT
+
+syntax = "proto3";
+
+package sshtunnel.v1;
+
+option go_package = "github.com/autonomous/ssh_tunnel_proxy/gen/sshtunnel/v1;sshtunnelv1";
+option java_multiple_files = true;
+option java_package = "org.sshtunnel.v1";
+
+// ---------------------------------------------------------------------------
+// Primitives
+// ---------------------------------------------------------------------------
+
+// A TCP endpoint. `host` is an IP literal or DNS name; it is never a URL.
+message Endpoint {
+  string host = 1;
+  uint32 port = 2; // 1..65535
+}
+
+// Indirect reference to secret material. The runtime resolves the reference at
+// connect time; the model itself never carries the secret.
+message CredentialRef {
+  enum Source {
+    SOURCE_UNSPECIFIED = 0;
+    SOURCE_FILE = 1;        // value = filesystem path, "~" expanded by runtime
+    SOURCE_ENV = 2;         // value = environment variable name
+    SOURCE_INLINE = 3;      // value = literal (test fixtures only)
+    SOURCE_AGENT = 4;       // value = agent socket path, or empty for SSH_AUTH_SOCK
+    SOURCE_CALLBACK = 5;    // value = host-defined resolver name
+  }
+  Source source = 1;
+  string value = 2;
+}
+
+// ---------------------------------------------------------------------------
+// Port policy
+// ---------------------------------------------------------------------------
+
+// Port authorization is an explicit caller policy, not a library surprise.
+// Local listen ports and remote target ports are separate decisions because
+// they protect different things: local binding rights vs. what the SSH peer is
+// permitted to reach.
+message PortPolicy {
+  // Ports below 1024 are rejected unless listed here.
+  repeated uint32 allowed_privileged_ports = 1;
+
+  // If non-empty, a local listener may only bind one of these ports.
+  repeated uint32 allowed_local_listen_ports = 2;
+
+  // If non-empty, a forward may only target one of these remote ports.
+  repeated uint32 allowed_remote_target_ports = 3;
+
+  // If non-empty, a forward may only target one of these hosts, as written.
+  repeated string allowed_remote_hosts = 4;
+}
+
+// ---------------------------------------------------------------------------
+// Forwards
+// ---------------------------------------------------------------------------
+
+// ssh -L : listen on this machine, deliver to a host reachable from the SSH peer.
+message LocalForward {
+  string id = 1;             // stable, caller-chosen; used in events and lookups
+  Endpoint listen = 2;       // bound on the machine running this runtime
+  Endpoint target = 3;       // resolved by the SSH peer
+  bool exclusive = 4;        // fail instead of reusing an existing listener
+  uint32 max_connections = 5; // 0 = unlimited
+}
+
+// ssh -R : the SSH peer listens, connections are delivered to a host reachable
+// from this machine.
+message RemoteForward {
+  string id = 1;
+  Endpoint bind = 2;         // bound on the SSH peer; port 0 = peer assigns
+  Endpoint target = 3;       // resolved by the machine running this runtime
+  uint32 max_connections = 4; // 0 = unlimited
+}
+
+// ---------------------------------------------------------------------------
+// Transport
+// ---------------------------------------------------------------------------
+
+// How to reach the SSH listener. This model deliberately assumes an SSH
+// listener already exists at `endpoint` — it never provisions a relay. A
+// reachability provider such as zrok, ngrok or a VPS is an external concern
+// recorded only as documentation metadata.
+message SshTransport {
+  Endpoint endpoint = 1;
+  string username = 2;
+  CredentialRef private_key = 3;
+  CredentialRef passphrase = 4;
+  CredentialRef password = 5;
+
+  uint32 keepalive_interval_ms = 6;   // default 10000
+  uint32 keepalive_count_max = 7;     // default 3
+  uint32 ready_timeout_ms = 8;        // default 20000
+  repeated string host_key_fingerprints = 9; // sha256:... ; empty = accept any
+
+  enum Reachability {
+    REACHABILITY_UNSPECIFIED = 0;
+    REACHABILITY_DIRECT = 1;
+    REACHABILITY_ZROK = 2;
+    REACHABILITY_NGROK = 3;
+    REACHABILITY_CUSTOM = 4;
+  }
+  Reachability reachability = 10; // documentation only; no behavioral effect
+}
+
+message ReconnectPolicy {
+  bool enabled = 1;              // default true
+  uint32 max_attempts = 2;       // 0 = unlimited
+  uint32 initial_delay_ms = 3;   // default 1000
+  uint32 max_delay_ms = 4;       // default 30000
+  double backoff_multiplier = 5; // default 2.0
+  double jitter_ratio = 6;       // 0.0..1.0, default 0.2
+}
+
+// The complete, portable definition of one tunnel.
+message TunnelConfig {
+  string id = 1;
+  string label = 2;
+  SshTransport transport = 3;
+  PortPolicy port_policy = 4;
+  ReconnectPolicy reconnect = 5;
+  repeated LocalForward local_forwards = 6;
+  repeated RemoteForward remote_forwards = 7;
+  map<string, string> metadata = 8;
+}
+
+// ---------------------------------------------------------------------------
+// State
+// ---------------------------------------------------------------------------
+
+enum TunnelState {
+  TUNNEL_STATE_UNSPECIFIED = 0;
+  TUNNEL_STATE_IDLE = 1;
+  TUNNEL_STATE_CONNECTING = 2;
+  TUNNEL_STATE_READY = 3;
+  TUNNEL_STATE_RECONNECTING = 4;
+  TUNNEL_STATE_CLOSING = 5;
+  TUNNEL_STATE_CLOSED = 6;
+  TUNNEL_STATE_FAILED = 7;
+}
+
+enum ForwardState {
+  FORWARD_STATE_UNSPECIFIED = 0;
+  FORWARD_STATE_PENDING = 1;
+  FORWARD_STATE_OPENING = 2;
+  FORWARD_STATE_ACTIVE = 3;
+  FORWARD_STATE_DEGRADED = 4;  // registered, but transport is down
+  FORWARD_STATE_CLOSING = 5;
+  FORWARD_STATE_CLOSED = 6;
+  FORWARD_STATE_FAILED = 7;
+}
+
+// Lifecycle of a single proxied TCP connection carried by a forward.
+enum ConnectionState {
+  CONNECTION_STATE_UNSPECIFIED = 0;
+  CONNECTION_STATE_ACCEPTED = 1;   // inbound socket accepted, no channel yet
+  CONNECTION_STATE_OPENING = 2;    // SSH channel being opened
+  CONNECTION_STATE_PIPED = 3;      // bidirectional flow established
+  CONNECTION_STATE_HALF_CLOSED = 4;
+  CONNECTION_STATE_CLOSED = 5;
+  CONNECTION_STATE_FAILED = 6;
+}
+
+enum ForwardDirection {
+  FORWARD_DIRECTION_UNSPECIFIED = 0;
+  FORWARD_DIRECTION_LOCAL = 1;   // ssh -L
+  FORWARD_DIRECTION_REMOTE = 2;  // ssh -R
+}
+
+message ConnectionStatus {
+  string connection_id = 1;
+  string forward_id = 2;
+  ForwardDirection direction = 3;
+  ConnectionState state = 4;
+  Endpoint source = 5;
+  Endpoint destination = 6;
+  int64 opened_at_unix_ms = 7;
+  int64 closed_at_unix_ms = 8;
+  uint64 bytes_to_target = 9;
+  uint64 bytes_from_target = 10;
+  string error = 11;
+}
+
+message ForwardStatus {
+  string forward_id = 1;
+  ForwardDirection direction = 2;
+  ForwardState state = 3;
+  Endpoint listen = 4;        // for remote forwards, the peer-side bind
+  Endpoint target = 5;
+  uint32 assigned_port = 6;   // resolved port when requested port was 0
+  uint32 active_connections = 7;
+  uint64 total_connections = 8;
+  string error = 9;
+}
+
+message TunnelStatus {
+  string tunnel_id = 1;
+  TunnelState state = 2;
+  Endpoint endpoint = 3;
+  uint32 reconnect_attempt = 4;
+  int64 connected_at_unix_ms = 5;
+  repeated ForwardStatus forwards = 6;
+  string error = 7;
+}
+
+// ---------------------------------------------------------------------------
+// Events
+// ---------------------------------------------------------------------------
+
+message TunnelEvent {
+  int64 timestamp_unix_ms = 1;
+  string tunnel_id = 2;
+
+  oneof payload {
+    StateChanged state_changed = 10;
+    ForwardChanged forward_changed = 11;
+    ConnectionChanged connection_changed = 12;
+    ReconnectScheduled reconnect_scheduled = 13;
+    ErrorRaised error_raised = 14;
+  }
+
+  message StateChanged {
+    TunnelState previous = 1;
+    TunnelState current = 2;
+    string reason = 3;
+  }
+
+  message ForwardChanged {
+    ForwardStatus status = 1;
+    ForwardState previous = 2;
+  }
+
+  message ConnectionChanged {
+    ConnectionStatus status = 1;
+    ConnectionState previous = 2;
+  }
+
+  message ReconnectScheduled {
+    uint32 attempt = 1;
+    uint32 delay_ms = 2;
+    string cause = 3;
+  }
+
+  message ErrorRaised {
+    // Mirrors the runtime error taxonomy so non-TypeScript consumers can
+    // branch on a stable code rather than on a message string.
+    enum Code {
+      CODE_UNSPECIFIED = 0;
+      CODE_INVALID_FORWARD_SPEC = 1;
+      CODE_PORT_NOT_PERMITTED = 2;
+      CODE_HOST_NOT_PERMITTED = 3;
+      CODE_TRANSPORT_NOT_READY = 4;
+      CODE_AUTH_FAILED = 5;
+      CODE_LISTEN_FAILED = 6;
+      CODE_REMOTE_BIND_FAILED = 7;
+      CODE_CHANNEL_OPEN_FAILED = 8;
+      CODE_TARGET_UNREACHABLE = 9;
+      CODE_DUPLICATE_FORWARD_ID = 10;
+      CODE_UNKNOWN_FORWARD = 11;
+      CODE_CONNECTION_LIMIT = 12;
+      CODE_RECONNECT_EXHAUSTED = 13;
+      CODE_CREDENTIAL_UNRESOLVED = 14;
+    }
+    Code code = 1;
+    string message = 2;
+    string forward_id = 3;
+    string connection_id = 4;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Optional control plane
+// ---------------------------------------------------------------------------
+//
+// Implementing this service is NOT required to use the library in-process. It
+// exists so that a non-Node runtime (for example a Python agent-flow runtime)
+// can drive a Node tunnel manager over a loopback control API and resolve a
+// named forward to a concrete local endpoint.
+
+message OpenTunnelRequest { TunnelConfig config = 1; }
+message OpenTunnelResponse { TunnelStatus status = 1; }
+
+message CloseTunnelRequest { string tunnel_id = 1; }
+message CloseTunnelResponse { TunnelStatus status = 1; }
+
+message GetTunnelStatusRequest { string tunnel_id = 1; }
+message GetTunnelStatusResponse { TunnelStatus status = 1; }
+
+message OpenLocalForwardRequest {
+  string tunnel_id = 1;
+  LocalForward forward = 2;
+}
+message OpenRemoteForwardRequest {
+  string tunnel_id = 1;
+  RemoteForward forward = 2;
+}
+message OpenForwardResponse { ForwardStatus status = 1; }
+
+message CloseForwardRequest {
+  string tunnel_id = 1;
+  string forward_id = 2;
+}
+message CloseForwardResponse { ForwardStatus status = 1; }
+
+// Resolve a semantic forward id to the loopback endpoint a caller should use.
+message ResolveEndpointRequest {
+  string tunnel_id = 1;
+  string forward_id = 2;
+}
+message ResolveEndpointResponse {
+  Endpoint endpoint = 1;
+  ForwardState state = 2;
+}
+
+message WatchEventsRequest { string tunnel_id = 1; }
+
+service TunnelControl {
+  rpc OpenTunnel(OpenTunnelRequest) returns (OpenTunnelResponse);
+  rpc CloseTunnel(CloseTunnelRequest) returns (CloseTunnelResponse);
+  rpc GetTunnelStatus(GetTunnelStatusRequest) returns (GetTunnelStatusResponse);
+  rpc OpenLocalForward(OpenLocalForwardRequest) returns (OpenForwardResponse);
+  rpc OpenRemoteForward(OpenRemoteForwardRequest) returns (OpenForwardResponse);
+  rpc CloseForward(CloseForwardRequest) returns (CloseForwardResponse);
+  rpc ResolveEndpoint(ResolveEndpointRequest) returns (ResolveEndpointResponse);
+  rpc WatchEvents(WatchEventsRequest) returns (stream TunnelEvent);
+}

package/dist/TestMessage.d.ts

@@ -1,13 +0,0 @@
-export declare class TestMessage {
-    generateMessage(to: string, from: string, action: string, contents: string): {
-        envelope: {
-            to: string;
-            from: string;
-            timestamp: Date;
-            action: string;
-        };
-        contents: string;
-    };
-    signMessage(msg: string, key: any): any;
-    verifyMessage(msg: string, signature: any, key: any): any;
-}

package/dist/TestMessage.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TestMessage = void 0;
-var crypto_1 = require("crypto");
-var TestMessage = (function () {
-    function TestMessage() {
-    }
-    TestMessage.prototype.generateMessage = function (to, from, action, contents) {
-        return {
-            envelope: {
-                to: to,
-                from: from,
-                timestamp: new Date(),
-                action: action
-            },
-            contents: (contents) ? contents : (0, crypto_1.randomUUID)()
-        };
-    };
-    TestMessage.prototype.signMessage = function (msg, key) {
-        var s = key.createSign('sha1');
-        s.update(msg);
-        return s.sign();
-    };
-    TestMessage.prototype.verifyMessage = function (msg, signature, key) {
-        var v = key.createVerify('sha1');
-        v.update(msg);
-        return v.verify(signature);
-    };
-    return TestMessage;
-}());
-exports.TestMessage = TestMessage;
-//# sourceMappingURL=TestMessage.js.map

package/dist/TestMessage.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"TestMessage.js","sourceRoot":"","sources":["../src/TestMessage.ts"],"names":[],"mappings":";;;AAAA,iCAAoC;AAEpC;IAAA;IAyBA,CAAC;IAvBU,qCAAe,GAAtB,UAAuB,EAAU,EAAE,IAAY,EAAE,MAAc,EAAE,QAAe;QAC5E,OAAO;YACH,QAAQ,EAAE;gBACN,EAAE,EAAE,EAAE;gBACN,IAAI,EAAE,IAAI;gBACV,SAAS,EAAE,IAAI,IAAI,EAAE;gBACrB,MAAM,EAAE,MAAM;aACjB;YACD,QAAQ,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAA,mBAAU,GAAE;SACjD,CAAA;IACL,CAAC;IAEM,iCAAW,GAAlB,UAAmB,GAAU,EAAE,GAAG;QAC9B,IAAM,CAAC,GAAG,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QACjC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACd,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC;IACpB,CAAC;IAEM,mCAAa,GAApB,UAAqB,GAAU,EAAE,SAAS,EAAE,GAAG;QAC3C,IAAM,CAAC,GAAG,GAAG,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;QACnC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACd,OAAO,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IAC/B,CAAC;IACL,kBAAC;AAAD,CAAC,AAzBD,IAyBC;AAzBY,kCAAW"}

package/dist/cjs/TestMessage.d.ts

@@ -1,13 +0,0 @@
-export declare class TestMessage {
-    generateMessage(to: string, from: string, action: string, contents: string): {
-        envelope: {
-            to: string;
-            from: string;
-            timestamp: Date;
-            action: string;
-        };
-        contents: string;
-    };
-    signMessage(msg: string, key: any): any;
-    verifyMessage(msg: string, signature: any, key: any): any;
-}