@streamr/cli-tools 101.1.2 → 102.0.0-beta.1

package/README.md

@@ -169,7 +169,7 @@ You must pass either the `--private-key` or `--config` option.
 User can specify environment and authentication details with the following command line arguments:
 - `--private-key <key>`, e.g. `--private-key 0x1234567890123456789012345678901234567890123456789012345678901234`
 - `--config <file>`, e.g. `--config foobar.json`
-- `--dev` use the pre-defined [development environment](https://github.com/streamr-dev/streamr-docker-dev)
+- `--env` use a pre-defined environment, e.g. `--env dev2` to use the [development environment](https://github.com/streamr-dev/streamr-docker-dev)
 
 The `--config` argument tries to read a configuration file from the current working directory (either without a file extension, or with `.json` extension added). It also tries to read it from `~/.streamr/config/${id}.json` dotfile.
 

package/bin/streamr-internal-node-info.ts

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+import '../src/logLevel'
+
+import { DhtNode, PeerDescriptor, toDhtAddress, toNodeId } from '@streamr/dht'
+import StreamrClient, { DhtAddress } from '@streamr/sdk'
+import { NetworkNode, NodeInfo, StreamPartitionInfo } from '@streamr/trackerless-network'
+import { binaryToHex, ChangeFieldType, Logger } from '@streamr/utils'
+import { createClientCommand } from '../src/command'
+import semver from 'semver'
+
+const logger = new Logger(module)
+
+export type NormalizedNodeInfo = ChangeFieldType<
+    NodeInfo,
+    'streamPartitions',
+    Omit<StreamPartitionInfo, 'deprecatedContentDeliveryLayerNeighbors'>[]>
+
+const toNormalizeNodeInfo = (info: NodeInfo): NormalizedNodeInfo => {
+    const isLegacyFormat = semver.satisfies(semver.coerce(info.applicationVersion)!, '< 102.0.0')
+    return {
+        ...info,
+        streamPartitions: info.streamPartitions.map((sp: StreamPartitionInfo) => ({
+            ...sp,
+            contentDeliveryLayerNeighbors: !isLegacyFormat
+                ? sp.contentDeliveryLayerNeighbors
+                : sp.deprecatedContentDeliveryLayerNeighbors.map((n) => ({
+                    peerDescriptor: n
+                }))
+        }))
+    }
+}
+
+const createPeerDescriptorOutput = (peerDescriptor: PeerDescriptor) => {
+    return {
+        nodeId: toNodeId(peerDescriptor),
+        type: peerDescriptor.type,
+        udp: peerDescriptor.udp,
+        tcp: peerDescriptor.tcp,
+        websocket: peerDescriptor.websocket,
+        region: peerDescriptor.region,
+        ipAddress: peerDescriptor.ipAddress,
+        publicKey: (peerDescriptor.publicKey !== undefined) ? binaryToHex(peerDescriptor.publicKey) : undefined,
+        signature: (peerDescriptor.signature !== undefined) ? binaryToHex(peerDescriptor.signature) : undefined
+    }
+}
+
+const createNodeInfoOutput = (nodeInfo: NormalizedNodeInfo) => {
+    return {
+        peerDescriptor: createPeerDescriptorOutput(nodeInfo.peerDescriptor),
+        controlLayer: {
+            neighbors: nodeInfo.controlLayer.neighbors.map((n) => toNodeId(n)),
+            connections: nodeInfo.controlLayer.connections.map((n) => toNodeId(n))
+        },
+        streamPartitions: nodeInfo.streamPartitions.map((sp) => ({
+            id: sp.id,
+            controlLayerNeighbors: sp.controlLayerNeighbors.map((n) => toNodeId(n)),
+            contentDeliveryLayerNeighbors: sp.contentDeliveryLayerNeighbors.map((n) => ({
+                nodeId: toNodeId(n.peerDescriptor),
+                rtt: n.rtt
+            }))
+        })),
+        applicationVersion: nodeInfo.applicationVersion
+    }
+}
+
+createClientCommand(async (client: StreamrClient, nodeId: string) => {
+    const networkNode = await client.getNode().getNode() as NetworkNode
+    const controlLayerNode = networkNode.stack.getControlLayerNode()
+    const peerDescriptors = await (controlLayerNode as DhtNode).findClosestNodesFromDht(nodeId as DhtAddress)
+    const peerDescriptor = peerDescriptors.find((pd) => toDhtAddress(pd.nodeId) === nodeId)
+    if (peerDescriptor !== undefined) {
+        const info = await networkNode.stack.fetchNodeInfo(peerDescriptor)
+        const normalizedInfo = toNormalizeNodeInfo(info)
+        console.info(JSON.stringify(createNodeInfoOutput(normalizedInfo), undefined, 4))
+    } else {
+        logger.error('No peer descriptor found')
+    }
+})
+    .description('show detailed information about a node')
+    .arguments('nodeId')
+    .parseAsync()

package/bin/streamr-internal-operator-delegate.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import '../src/logLevel'
+
+import { StreamrClient, _operatorContractUtils } from '@streamr/sdk'
+import { createClientCommand } from '../src/command'
+import { parseEther } from 'ethers'
+
+createClientCommand(async (client: StreamrClient, operatorAddress: string, dataTokenAmount: string) => {
+    await _operatorContractUtils.delegate(
+        await client.getSigner(),
+        operatorAddress,
+        parseEther(dataTokenAmount),
+        _operatorContractUtils.getTestTokenContract()
+    )
+})
+    .description('delegate funds to an operator')
+    .arguments('<operatorAddress> <dataTokenAmount>')
+    .parseAsync()

package/bin/streamr-internal-operator-stake.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import '../src/logLevel'
+
+import { StreamrClient, _operatorContractUtils } from '@streamr/sdk'
+import { createClientCommand } from '../src/command'
+import { parseEther } from 'ethers'
+
+createClientCommand(async (client: StreamrClient, operatorContractAddress: string, sponsorshipAddress: string, dataTokenAmount: string) => {
+    const operatorContract = _operatorContractUtils.getOperatorContract(operatorContractAddress).connect(await client.getSigner())
+    await _operatorContractUtils.stake(
+        operatorContract,
+        sponsorshipAddress,
+        parseEther(dataTokenAmount)
+    )
+})
+    .description('stake funds to a sponsorship')
+    .arguments('<operatorContractAddress> <sponsorshipAddress> <dataTokenAmount>')
+    .parseAsync()

package/bin/streamr-internal-operator-undelegate.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import '../src/logLevel'
+
+import { StreamrClient, _operatorContractUtils } from '@streamr/sdk'
+import { createClientCommand } from '../src/command'
+import { parseEther } from 'ethers'
+
+createClientCommand(async (client: StreamrClient, operatorAddress: string, dataTokenAmount: string) => {
+    await _operatorContractUtils.undelegate(
+        await client.getSigner(),
+        _operatorContractUtils.getOperatorContract(operatorAddress),
+        parseEther(dataTokenAmount)
+    )
+})
+    .description('undelegate funds from an operator')
+    .arguments('<operatorAddress> <dataTokenAmount>')
+    .parseAsync()

package/bin/streamr-internal-operator-unstake.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import '../src/logLevel'
+
+import { StreamrClient, _operatorContractUtils } from '@streamr/sdk'
+import { createClientCommand } from '../src/command'
+
+createClientCommand(async (client: StreamrClient, operatorContractAddress: string, sponsorshipAddress: string) => {
+    const operatorContract = _operatorContractUtils.getOperatorContract(operatorContractAddress).connect(await client.getSigner())
+    await _operatorContractUtils.unstake(
+        operatorContract,
+        sponsorshipAddress
+    )
+})
+    .arguments('<operatorContractAddress> <sponsorshipAddress>')
+    .description('unstake all funds from a sponsorship')
+    .parseAsync()

package/bin/streamr-internal-show-sdk-config.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import '../src/logLevel'
+
+import StreamrClient from '@streamr/sdk'
+import { createClientCommand } from '../src/command'
+
+createClientCommand(async (client: StreamrClient) => {
+    const config = client.getConfig()
+    console.info(JSON.stringify(config, undefined, 4))
+})
+    .parseAsync()

package/bin/streamr-internal-sponsorship-sponsor.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import '../src/logLevel'
+
+import { StreamrClient, _operatorContractUtils } from '@streamr/sdk'
+import { createClientCommand } from '../src/command'
+import { parseEther } from 'ethers'
+
+createClientCommand(async (client: StreamrClient, sponsorshipAddress: string, dataTokenAmount: string) => {
+    await _operatorContractUtils.sponsor(
+        await client.getSigner(),
+        sponsorshipAddress,
+        parseEther(dataTokenAmount),
+        _operatorContractUtils.getTestTokenContract()
+    )
+})
+    .description('sponsor a stream')
+    .arguments('<sponsorshipAddress> <tokenAmount>')
+    .parseAsync()

package/bin/streamr-internal-visualize-topology.ts

@@ -117,6 +117,6 @@ createCommand()
             ? fs.readFileSync(topologyDefinitionFile, 'utf-8')
             : await readStdin()
         // TODO could validate the content
-        console.log(createGraph(JSON.parse(topologyDefinition) as Topology))
+        console.info(createGraph(JSON.parse(topologyDefinition) as Topology))
     })
     .parse()

package/bin/streamr-internal.ts

@@ -6,5 +6,12 @@ program
     .version(pkg.version)
     .usage('<command> [<args>]')
     .description('subcommands for internal use, the API of the commands may change')
+    .command('node-info', 'info about a node')
     .command('visualize-topology', 'visualize network topology')
+    .command('show-sdk-config', 'show config used by internal StreamrClient')
+    .command('sponsorship-sponsor', 'sponsor a sponsorship')
+    .command('operator-delegate', 'delegate funds to an operator')
+    .command('operator-undelegate', 'undelegate funds from an operator')
+    .command('operator-stake', 'stake operator\'s funds to a sponsorship')
+    .command('operator-unstake', 'unstake all operator\'s funds from a sponsorship')
     .parse()

package/bin/streamr-mock-data-generate.ts

@@ -2,9 +2,13 @@
 import { createFnParseInt } from '../src/common'
 import { createCommand, Options as BaseOptions } from '../src/command'
 import { randomString } from '@streamr/utils'
+import crypto from 'crypto'
 
 interface Options extends BaseOptions {
     rate: number
+    binary: boolean
+    minLength: number
+    maxLength: number
 }
 
 function genArray<T>(size: number, elementFn: () => T): T[] {
@@ -15,24 +19,33 @@ function genArray<T>(size: number, elementFn: () => T): T[] {
     return arr
 }
 
-export const generate = (rate: number): void => {
-    setInterval(() => {
-        console.info(JSON.stringify({
-            someText: randomString(64),
-            aNumber: Math.random() * 10000,
-            bNumber: Math.random(),
-            yesOrNo: Math.random() > 0.5,
-            arrayOfStrings: genArray(Math.floor(Math.random() * 20), () => randomString(8)),
-            arrayOfIntegers: genArray(Math.floor(Math.random() * 10), () => Math.floor(Math.random() * 100))
+export const generateJson = (): string => {
+    return JSON.stringify({
+        someText: randomString(64),
+        aNumber: Math.random() * 10000,
+        bNumber: Math.random(),
+        yesOrNo: Math.random() > 0.5,
+        arrayOfStrings: genArray(Math.floor(Math.random() * 20), () => randomString(8)),
+        arrayOfIntegers: genArray(Math.floor(Math.random() * 10), () => Math.floor(Math.random() * 100))
+    })
+}
 
-        }))
-    }, rate)
+export const generateBinary = ({ minLength, maxLength }: Options): string => {
+    const length = Math.floor(Math.random() * (maxLength - minLength + 1)) + minLength
+    const buffer = crypto.randomBytes(length)
+    return buffer.toString('hex')
 }
 
 createCommand()
-    .description('generate and print semi-random JSON data to stdout')
+    .description('generate and print semi-random JSON data or random binary data (hexadecimal) to stdout')
     .option('-r, --rate <n>', 'rate in milliseconds', createFnParseInt('--rate'), 500)
+    .option('--binary', 'generate binary data instead of JSON')
+    .option('--min-length <n>', 'minimum message length in bytes (only for binary data)', createFnParseInt('--min-length'), 512)
+    .option('--max-length <n>', 'maximum message length in bytes (only for binary data)', createFnParseInt('--max-length'), 4096)
     .action((options: Options) => {
-        generate(options.rate)
+        const generate = options.binary ? generateBinary : generateJson
+        setInterval(() => {
+            console.info(generate(options))
+        }, options.rate)
     })
     .parse()

package/bin/streamr-mock-data.ts

@@ -6,5 +6,5 @@ program
     .version(pkg.version)
     .usage('<command> [<args>]')
     .description('mock-data subcommands')
-    .command('generate', 'generate JSON data')
+    .command('generate', 'generate random JSON or binary data')
     .parse()

package/bin/streamr-storage-node-add-stream.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import '../src/logLevel'
+
 import { StreamrClient } from '@streamr/sdk'
 import { createClientCommand } from '../src/command'
 

package/bin/streamr-storage-node-list-streams.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import '../src/logLevel'
+
 import EasyTable from 'easy-table'
 import { StreamrClient } from '@streamr/sdk'
 import { createClientCommand } from '../src/command'
@@ -7,12 +8,12 @@ import { createClientCommand } from '../src/command'
 createClientCommand((async (client: StreamrClient, storageNodeAddress: string) => {
     const { streams } = await client.getStoredStreams(storageNodeAddress)
     if (streams.length > 0) {
-        console.info(EasyTable.print(streams.map((stream) => {
+        console.info(EasyTable.print(await Promise.all(streams.map(async (stream) => {
             return {
                 id: stream.id,
-                partitions: stream.getMetadata().partitions
+                partitions: await stream.getPartitionCount()
             }
-        })))
+        }))))
     }
 }))
     .arguments('<storageNodeAddress>')

package/bin/streamr-storage-node-list.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import '../src/logLevel'
+
 import { StreamrClient } from '@streamr/sdk'
 import EasyTable from 'easy-table'
 import { createClientCommand, Options as BaseOptions } from '../src/command'

package/bin/streamr-storage-node-remove-stream.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import '../src/logLevel'
+
 import { StreamrClient } from '@streamr/sdk'
 import { createClientCommand } from '../src/command'
 

package/bin/streamr-stream-create.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import '../src/logLevel'
+
 import { StreamrClient } from '@streamr/sdk'
 import { createFnParseInt } from '../src/common'
 import { createClientCommand, Options as BaseOptions } from '../src/command'
@@ -18,7 +19,7 @@ createClientCommand(async (client: StreamrClient, streamIdOrPath: string, option
         partitions: options.partitions
     }
     const stream = await client.createStream(body)
-    console.info(JSON.stringify({ id: stream.id, ...stream.getMetadata() }, null, 2))
+    console.info(JSON.stringify({ id: stream.id, ...await stream.getMetadata() }, null, 2))
 })
     .arguments('<streamId>')
     .description('create a new stream')

package/bin/streamr-stream-grant-permission.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import '../src/logLevel'
+
 import { PermissionAssignment, Stream } from '@streamr/sdk'
 import { runModifyPermissionsCommand } from '../src/permission'
 

package/bin/streamr-stream-publish.ts

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import '../src/logLevel'
+
 import { Writable } from 'stream'
 import { StreamrClient } from '@streamr/sdk'
-import { wait } from '@streamr/utils'
+import { hexToBinary, wait } from '@streamr/utils'
 import es from 'event-stream'
 import { createClientCommand, Options as BaseOptions } from '../src/command'
 
@@ -10,6 +11,10 @@ interface Options extends BaseOptions {
     partitionKeyField?: string
 }
 
+const isHexadecimal = (str: string): boolean => {
+    return /^[0-9a-fA-F]+$/.test(str)
+}
+
 const publishStream = (
     stream: string,
     partitionKeyField: string | undefined,
@@ -18,21 +23,26 @@ const publishStream = (
     const writable = new Writable({
         objectMode: true,
         write: (data: any, _: any, done: any) => {
-            let json = null
+            let message = null
             // ignore newlines, etc
             if (!data || String(data).trim() === '') {
                 done()
                 return
             }
-            try {
-                json = JSON.parse(data)
-            } catch (e) {
-                console.error(data.toString())
-                done(e)
-                return
+            const trimmedData = String(data).trim()
+            if (isHexadecimal(trimmedData)) {
+                message = hexToBinary(trimmedData)
+            } else {
+                try {
+                    message = JSON.parse(trimmedData)
+                } catch (e) {
+                    console.error(data.toString())
+                    done(e)
+                    return
+                }
             }
-            const partitionKey = (partitionKeyField !== undefined) ? json[partitionKeyField] : undefined
-            client.publish(stream, json, { partitionKey }).then(
+            const partitionKey = (partitionKeyField !== undefined && typeof message === 'object') ? message[partitionKeyField] : undefined
+            client.publish(stream, message, { partitionKey }).then(
                 () => done(),
                 (err) => done(err)
             )
@@ -57,10 +67,12 @@ createClientCommand(async (client: StreamrClient, streamId: string, options: Opt
                 await wait(2000)
                 resolve(undefined)
             })
+            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors
             .once('error', (err: any) => reject(err) )
     })
 })
     .arguments('<streamId>')
-    .description('publish to a stream by reading JSON messages from stdin line-by-line')
-    .option('-k, --partition-key-field <string>', 'field name in each message to use for assigning the message to a stream partition')
+    .description('publish to a stream by reading JSON messages from stdin line-by-line or hexadecimal strings for binary data')
+    // eslint-disable-next-line max-len
+    .option('-k, --partition-key-field <string>', 'field name in each message to use for assigning the message to a stream partition (only for JSON data)')
     .parseAsync()

package/bin/streamr-stream-resend-from.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import '../src/logLevel'
+
 import { StreamrClient } from '@streamr/sdk'
 import { createClientCommand, Options as BaseOptions } from '../src/command'
 import { resend } from '../src/resend'

package/bin/streamr-stream-resend-last.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import '../src/logLevel'
+
 import { StreamrClient } from '@streamr/sdk'
 import { createClientCommand, Options as BaseOptions } from '../src/command'
 import { resend } from '../src/resend'

package/bin/streamr-stream-resend-range.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import '../src/logLevel'
+
 import { StreamrClient } from '@streamr/sdk'
 import { createClientCommand, Options as BaseOptions } from '../src/command'
 import { assertBothOrNoneDefined, resend } from '../src/resend'

package/bin/streamr-stream-resend.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import '../src/logLevel'
+
 import { createCommand } from '../src/command'
 
 createCommand()

package/bin/streamr-stream-revoke-permission.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import '../src/logLevel'
+
 import { PermissionAssignment, Stream } from '@streamr/sdk'
 import { runModifyPermissionsCommand } from '../src/permission'
 

package/bin/streamr-stream-search.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import '../src/logLevel'
+
 import { StreamrClient, SearchStreamsPermissionFilter, StreamPermission } from '@streamr/sdk'
 import { createClientCommand, Options as BaseOptions } from '../src/command'
 import { Option } from 'commander'
@@ -22,7 +23,7 @@ const createPermissionFilter = async (
 ): Promise<SearchStreamsPermissionFilter | undefined> => {
     if (user !== undefined) {
         return {
-            user: (getOptionType(user) === OptionType.ARGUMENT) ? user as string : await client.getAddress(),
+            userId: (getOptionType(user) === OptionType.ARGUMENT) ? user as string : await client.getUserId(),
             allowPublic: allowPublic ?? false,
             allOf,
             anyOf
@@ -49,7 +50,7 @@ createClientCommand(async (client: StreamrClient, term: string | undefined, opti
     )
     const streams = client.searchStreams(term, permissionFilter)
     for await (const stream of streams) {
-        console.log(stream.id)
+        console.info(stream.id)
     }
 })
     .arguments('[term]')

package/bin/streamr-stream-show.ts

@@ -1,21 +1,30 @@
 #!/usr/bin/env node
 import '../src/logLevel'
+
 import { StreamrClient } from '@streamr/sdk'
 import { createClientCommand, Options as BaseOptions } from '../src/command'
 import { getPermissionId } from '../src/permission'
+import { omit } from 'lodash'
 
 interface Options extends BaseOptions {
     includePermissions: boolean
 }
 
+const withRenamedField = (obj: any, from: string, to: string) => {
+    return {
+        ...omit(obj, from),
+        [to]: obj[from]
+    }
+}
+
 createClientCommand(async (client: StreamrClient, streamId: string, options: Options) => {
     const stream = await client.getStream(streamId)
-    const obj: any = { id: stream.id, ...stream.getMetadata() }
+    const obj: any = { id: stream.id, ...await stream.getMetadata() }
     if (options.includePermissions) {
         const assigments = await stream.getPermissions()
         obj.permissions = assigments.map((assignment) => {
             return {
-                ...assignment,
+                ...withRenamedField(assignment, 'userId', 'user'),
                 permissions: assignment.permissions.map(getPermissionId)
             }
         })

package/bin/streamr-stream-subscribe.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import '../src/logLevel'
+
 import omit from 'lodash/omit'
 import isString from 'lodash/isString'
 import { StreamrClient, MessageMetadata } from '@streamr/sdk'
@@ -15,7 +16,7 @@ interface Options extends BaseOptions {
 }
 
 createClientCommand(async (client: StreamrClient, streamId: string, options: Options) => {
-    const formContent = (content: unknown) => options.raw ? binaryToHex(content as Uint8Array) : content
+    const formContent = (content: unknown) => content instanceof Uint8Array ? binaryToHex(content) : content
     const formMessage = options.withMetadata
         ? (content: unknown, metadata: MessageMetadata) => ({ content: formContent(content), metadata: omit(metadata, 'streamMessage') })
         : (content: unknown) => formContent(content)

package/bin/streamr-wallet-whoami.ts

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 import '../src/logLevel'
+
 import { StreamrClient } from '@streamr/sdk'
 import { createClientCommand } from '../src/command'
 
 createClientCommand(async (client: StreamrClient) => {
-    console.info(await client.getAddress())
+    console.info(await client.getUserId())
 })
     .description('displays your public address')
     .parseAsync()

package/dist/bin/streamr-internal-node-info.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+import '../src/logLevel';
+import { NodeInfo, StreamPartitionInfo } from '@streamr/trackerless-network';
+import { ChangeFieldType } from '@streamr/utils';
+export type NormalizedNodeInfo = ChangeFieldType<NodeInfo, 'streamPartitions', Omit<StreamPartitionInfo, 'deprecatedContentDeliveryLayerNeighbors'>[]>;

package/dist/bin/streamr-internal-node-info.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("../src/logLevel");
+const dht_1 = require("@streamr/dht");
+const utils_1 = require("@streamr/utils");
+const command_1 = require("../src/command");
+const semver_1 = __importDefault(require("semver"));
+const logger = new utils_1.Logger(module);
+const toNormalizeNodeInfo = (info) => {
+    const isLegacyFormat = semver_1.default.satisfies(semver_1.default.coerce(info.applicationVersion), '< 102.0.0');
+    return {
+        ...info,
+        streamPartitions: info.streamPartitions.map((sp) => ({
+            ...sp,
+            contentDeliveryLayerNeighbors: !isLegacyFormat
+                ? sp.contentDeliveryLayerNeighbors
+                : sp.deprecatedContentDeliveryLayerNeighbors.map((n) => ({
+                    peerDescriptor: n
+                }))
+        }))
+    };
+};
+const createPeerDescriptorOutput = (peerDescriptor) => {
+    return {
+        nodeId: (0, dht_1.toNodeId)(peerDescriptor),
+        type: peerDescriptor.type,
+        udp: peerDescriptor.udp,
+        tcp: peerDescriptor.tcp,
+        websocket: peerDescriptor.websocket,
+        region: peerDescriptor.region,
+        ipAddress: peerDescriptor.ipAddress,
+        publicKey: (peerDescriptor.publicKey !== undefined) ? (0, utils_1.binaryToHex)(peerDescriptor.publicKey) : undefined,
+        signature: (peerDescriptor.signature !== undefined) ? (0, utils_1.binaryToHex)(peerDescriptor.signature) : undefined
+    };
+};
+const createNodeInfoOutput = (nodeInfo) => {
+    return {
+        peerDescriptor: createPeerDescriptorOutput(nodeInfo.peerDescriptor),
+        controlLayer: {
+            neighbors: nodeInfo.controlLayer.neighbors.map((n) => (0, dht_1.toNodeId)(n)),
+            connections: nodeInfo.controlLayer.connections.map((n) => (0, dht_1.toNodeId)(n))
+        },
+        streamPartitions: nodeInfo.streamPartitions.map((sp) => ({
+            id: sp.id,
+            controlLayerNeighbors: sp.controlLayerNeighbors.map((n) => (0, dht_1.toNodeId)(n)),
+            contentDeliveryLayerNeighbors: sp.contentDeliveryLayerNeighbors.map((n) => ({
+                nodeId: (0, dht_1.toNodeId)(n.peerDescriptor),
+                rtt: n.rtt
+            }))
+        })),
+        applicationVersion: nodeInfo.applicationVersion
+    };
+};
+(0, command_1.createClientCommand)(async (client, nodeId) => {
+    const networkNode = await client.getNode().getNode();
+    const controlLayerNode = networkNode.stack.getControlLayerNode();
+    const peerDescriptors = await controlLayerNode.findClosestNodesFromDht(nodeId);
+    const peerDescriptor = peerDescriptors.find((pd) => (0, dht_1.toDhtAddress)(pd.nodeId) === nodeId);
+    if (peerDescriptor !== undefined) {
+        const info = await networkNode.stack.fetchNodeInfo(peerDescriptor);
+        const normalizedInfo = toNormalizeNodeInfo(info);
+        console.info(JSON.stringify(createNodeInfoOutput(normalizedInfo), undefined, 4));
+    }
+    else {
+        logger.error('No peer descriptor found');
+    }
+})
+    .description('show detailed information about a node')
+    .arguments('nodeId')
+    .parseAsync();
+//# sourceMappingURL=streamr-internal-node-info.js.map