@streamr/cli-tools 4.1.1 → 6.0.0-alpha.1

package/.eslintignore

@@ -0,0 +1,2 @@
+node_modules/**
+dist/**

package/.eslintrc

@@ -0,0 +1,6 @@
+{
+  "extends": "eslint-config-streamr-ts",
+  "rules": {
+    "no-console": "off"
+  }
+}

package/CHANGELOG.md

@@ -5,6 +5,44 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+- Add permission commands: `stream grant-permission` and `stream revoke-permission`
+- Remove `typescript` and `ts-node` as run-time dependencies
+- (Breaking) Remove `--msg-chain-id` parameter from `stream resend from`
+- (Breaking) `stream create` argument is a stream ID, not a name
+- Support path notation when defining a stream ID
+- (Breaking) Remove `misc get-session-token` command
+- (Breaking) Change permission names and arguments:
+  - renamed `--operation` to `--permission` in `stream list`
+  - the data format of `permissions` returned by `--include-permissions` of `stream show` 
+  - enum values updated for all commands: `subscribe`, `publish`, `edit`, `delete` and `grant`
+- (Breaking) Remove `lastUpdated` and `name` columns from `stream list` output
+- (Breaking) Modify configuration management:
+  - can read config from `~/.streamr/config/default.json`
+  - `--config` argument added
+  - `--stg`, `--http-url` and `--ws-url` arguments removed
+- (Breaking) Rename `--config` argument to `--stream-config` in `stream create`
+- (Breaking) Remove `stream list` command
+- Add `stream search` command
+- Bump dependency streamr-client to 6.1.0
+- Bump dependency commander to 8.3.0
+
+## [5.0.0] - 2021-05-05
+### Added
+- Add storage node commands under `streamr storage-node`
+
+### Changed
+- (Breaking) Commands are divided to subcommands: most of the existing command are under `streamr stream`, and `generate` command under `streamr mock-data`
+  - `streamr subscribe` is now `streamr stream subscribe`
+  - `streamr publish` is now `streamr stream publish`
+  - `streamr list` is now `streamr stream list`
+  - `streamr show` is now `streamr stream show`
+  - `streamr create` is now `streamr stream create`
+  - `streamr resend` is now `streamr stream resend`
+  - `streamr generate` is now `streamr mock-data generate`
+- Fixed examples of --private-key in README
+- Internal implementation was converted to TypeScript
+- Bump dependency streamr-client to 5.2.1
+- Bump dependency commander to 7.2.0
 
 ## [4.1.1] - 2021-02-11
 ### Changed
@@ -22,7 +60,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Ethereum authentication with `--privateKey <key>`. This also enables message signing when publishing messages.
 
 ### Changed
--  (Breaking) Rename command `listen` to `subscribe`.
+- (Breaking) Rename command `listen` to `subscribe`.
 - (Breaking) API key is now given with `--apiKey <key>`. API keys are deprecated. Option `--privateKey` should be preferred.
 
 ## [3.1.1] - 2020-04-16
@@ -48,7 +86,8 @@ ordering and gap filling.
 - Bump dependency commander to ^4.0.1.
 - Re-organize README.md and a few touches to Developing section paragraphs.
 
-[Unreleased]: https://github.com/streamr-dev/cli-tools/compare/v4.1.1...HEAD
+[Unreleased]: https://github.com/streamr-dev/cli-tools/compare/v5.0.0...HEAD
+[5.0.0]: https://github.com/streamr-dev/cli-tools/compare/v4.1.1...v5.0.0
 [4.1.1]: https://github.com/streamr-dev/cli-tools/compare/v4.1.0...v4.1.1
 [4.1.0]: https://github.com/streamr-dev/cli-tools/compare/v4.0.0...v4.1.0
 [4.0.0]: https://github.com/streamr-dev/cli-tools/compare/v3.1.1...v4.0.0

package/README.md

@@ -1,3 +1,9 @@
+<p align="center">
+  <a href="https://streamr.network">
+    <img alt="Streamr" src="https://raw.githubusercontent.com/streamr-dev/network-monorepo/main/packages/client/readme-header-img.png" width="1320" />
+  </a>
+</p>
+
 # @streamr/cli-tools
 
 Command line tool for interacting with [Streamr](https://streamr.network).
@@ -18,88 +24,115 @@ npm install -g @streamr/cli-tools
 ```
 
 ## Use
-To get a list of all (sub)commands simply run `streamr`.
+All commands follow pattern `streamr <command> <subcommand>`, e.g.
+```
+streamr stream subscribe
+streamr mock-data generate
+```
 
-All (sub)commands follow pattern `streamr <command>`.
+To get a list of all commands simply run `streamr`. To list subcommands run e.g. `streamr stream`
 
-Run `streamr help <command>` or `streamr <command> --help` to get more information about a a command, its options, and
-so forth.
+Run `streamr <command> <subcommand> --help` to get more information about a a command, its options, and so forth.
+
+If there is a stream parameter in a command, it can be defined as a full id (e.g. `0x1234567890123456789012345678901234567890/foo/bar`) or a path (e.g. `/foo/bar`). If path notation is used, the stream ID is made by prefixing the authenticated Ethereum address (`--private-key <key>`) to the path.
 
 ### subscribe
 Used to subscribe to a stream and output real-time JSON objects to stdout line-by-line.
 
 For example, to subscribe to a public stream such as the tram demo do
 ```
-streamr subscribe 7wa7APtlTq6EC5iTCBy6dw
+streamr stream subscribe streamr.eth/demos/helsinki-trams
 ```
 
 To subscribe to a private stream and authenticate with an Ethereum private key:
 
 ```
-streamr subscribe streamId --privateKey <key>
+streamr stream subscribe streamId --private-key <key>
 ```
 
-Flag `--dev` or `--stg` can be enabled for the command to operate on pre-defined development or staging environment. Alternatively, you can give `--ws-url <url>` and `--http-url <url>` to connect to any custom network.
-
-
 ###  publish
 Used to publish events to a stream from stdin line-by-line. Each line should be a valid JSON object.
 
 Example of use:
 ```
-streamr publish <streamId> --privateKey <key>
+streamr stream publish <streamId> --private-key <key>
 ```
 
-Flag `--dev` or `--stg` can be enabled for the command to operate on pre-defined development or staging environment.
-
 
 ### generate
 Generate random JSON objects to stdout line-by-line.
 
 Useful for generating test data to be published to a stream with `publish`, e.g.:
 ```
-streamr generate | streamr publish <streamId> --privateKey <key>
+streamr mock-data generate | streamr stream publish <streamId> --private-key <key>
 ```
 
 ### list
 Fetch a list of streams that are accessible to the user authenticated by the private key
 ```
-streamr list --privateKey <key>
+streamr stream list --private-key <key>
 ```
 
 ### show
 Show detailed information about a specific stream
 ```
-streamr show <streamId> --privateKey <key>
+streamr stream show <streamId> --private-key <key>
 ```
 
 ### create
 Create a new stream
 ```
-streamr create <name> --privateKey <key>
+streamr stream create <streamId> --private-key <key>
+```
+E.g.
+```
+streamr stream create /foo/bar
+streamr stream create 0x1234567890123456789012345678901234567890/foobar
+streamr stream create yourdomain.ens/foobar
 ```
 
+
 ### resend
 Request a resend of historical data printed as JSON objects to stdout line-by-line.
 
 For example, to fetch the 10 latest messages of a public stream such as the tram demo do
 ```
-streamr resend last 10 7wa7APtlTq6EC5iTCBy6dw
+streamr stream resend last 10 streamr.eth/demos/helsinki-trams
 ```
 
 
 To fetch data starting from a particular date-time
 ```
-streamr resend from 2019-05-10T17:00:00 <streamId> --privateKey <key>
+streamr stream resend from 2019-05-10T17:00:00 <streamId> --private-key <key>
 ```
 
 To fetch data between two date-times
 ```
-streamr resend range 2019-05-10T17:00:00 2019-05-11T21:00:00 <streamId> --privateKey <key>
+streamr stream resend range 2019-05-10T17:00:00 2019-05-11T21:00:00 <streamId> --private-key <key>
 ```
 
-Flag `--dev` or `--stg` can be enabled for the command to operate on pre-defined development or staging environment.
+#### Configuration
+
+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)
+
+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.
 
+If no `--config` argument is specified, default settings are read from `~/.streamr/config/default.json`, if that file exists.
+
+The configuration file is a JSON. It has one root-level property `client`, which contains any configuration properties for the [streamr-client-javascript](https://github.com/streamr-dev/network-monorepo/blob/main/packages/client/) client. Example:
+```
+{
+    "client": {
+        "auth": {
+            "privateKey": ...
+        },
+        "publishWithSignature": "always"
+    }
+}
+```
 
 ### Examples: Piping with subscribe and publish
 
@@ -111,21 +144,21 @@ You can pipe the line-by-line JSON objects output by `subscribe` to
 your program written in any language. Just make the program read JSON objects
 from stdin.
 ```
-streamr subscribe 7wa7APtlTq6EC5iTCBy6dw | ruby calculate-average-speed.rb
+streamr stream subscribe streamr.eth/demos/helsinki-trams | ruby calculate-average-speed.rb
 ```
 
 #### Publishing to a stream from any programming language
 If your program produces JSON objects to stdout (line-by-line), you can
 redirect it to command `publish` to publish the JSON objects to a stream.
 ```
-python printSensorReadingsAsJson.py | streamr publish <streamId> --privateKey <key>
+python printSensorReadingsAsJson.py | streamr stream publish <streamId> --private-key <key>
 ```
 
 #### Transforming streams
 You can also subscribe to a stream, apply a transformation, and then pipe the
 transformed output into another stream.
 ```
-streamr subscribe <sourceStream> | ./calculateMovingAverages | streamr publish <destinationStream> --privateKey <key>
+streamr stream subscribe <sourceStream> | ./calculateMovingAverages | streamr stream publish <destinationStream> --private-key <key>
 ```
 
 Same rules apply here as before. Your program should accept line-by-line JSON
@@ -136,16 +169,11 @@ If you have a working stream in production that you'd also like to use in your
 development environment, you can combine the `subscribe` and `publish` commands to effectively copy
 the real-time events.
 ```
-streamr subscribe 7wa7APtlTq6EC5iTCBy6dw | streamr publish --dev <streamId> --privateKey <key>
-```
-
-And the same for staging environment:
-```
-streamr subscribe 7wa7APtlTq6EC5iTCBy6dw | streamr publish --stg <streamId> --privateKey <key>
+streamr stream subscribe streamr.eth/demos/helsinki-trams | streamr stream publish --dev <streamId> --private-key <key>
 ```
 
 ## Develop
-This project is a thin wrapper around [streamr-client-javascript](https://github.com/streamr-dev/streamr-client-javascript),
+This project is a thin wrapper around [streamr-client-javascript](https://github.com/streamr-dev/network-monorepo/blob/main/packages/client/),
 which does the heavy lifting, while this project concentrates on CLI concerns: parsing and
 passing arguments, stdin/stdout, errors, and so forth.
 

package/{src/generate.js → bin/streamr-mock-data-generate.ts}

@@ -1,5 +1,13 @@
+#!/usr/bin/env node
+import pkg from '../package.json'
+import { createFnParseInt } from '../src/common'
+import { createCommand } from '../src/command'
+
 // From: https://stackoverflow.com/questions/10726909/random-alpha-numeric-string-in-javascript
-function randomString(length, chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ') {
+function randomString(
+    length: number,
+    chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+): string {
     let result = ''
     for (let i = length; i > 0; --i) {
         result += chars[Math.floor(Math.random() * chars.length)]
@@ -7,7 +15,7 @@ function randomString(length, chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDE
     return result
 }
 
-function genArray(size, elementFn) {
+function genArray<T>(size: number, elementFn: () => T): T[] {
     const arr = []
     for (let i=0; i < size; ++i) {
         arr.push(elementFn())
@@ -15,7 +23,7 @@ function genArray(size, elementFn) {
     return arr
 }
 
-module.exports = (rate) => {
+export const generate = (rate: number): void => {
     setInterval(() => {
         console.info(JSON.stringify({
             someText: randomString(64),
@@ -28,3 +36,12 @@ module.exports = (rate) => {
         }))
     }, rate)
 }
+
+createCommand()
+    .description('generate and print semi-random JSON data to stdout')
+    .option('-r, --rate <n>', 'rate in milliseconds', createFnParseInt('--rate'), 500)
+    .version(pkg.version)
+    .action((options: any) => {
+        generate(options.rate)
+    })
+    .parse()

package/bin/streamr-mock-data.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { program } from 'commander'
+import pkg from '../package.json'
+
+program
+    .version(pkg.version)
+    .usage('<command> [<args>]')
+    .description('mock-data subcommands')
+    .command('generate', 'generate JSON data')
+    .parse()

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

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import '../src/logLevel'
+import StreamrClient from 'streamr-client'
+import { createClientCommand } from '../src/command'
+
+createClientCommand(async (client: StreamrClient, storageNodeAddress: string, streamId: string) => {
+    const stream = await client.getStream(streamId)
+    await stream.addToStorageNode(storageNodeAddress)
+})
+    .arguments('<storageNodeAddress> <streamId>')
+    .description('add stream to a storage node')
+    .parseAsync()

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

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import '../src/logLevel'
+import EasyTable from 'easy-table'
+import StreamrClient from 'streamr-client'
+import { createClientCommand } from '../src/command'
+import { StreamPartIDUtils } from 'streamr-client-protocol'
+
+createClientCommand((async (client: StreamrClient, storageNodeAddress: string) => {
+    const streamParts = await client.getStreamPartsByStorageNode(storageNodeAddress)
+    if (streamParts.length > 0) {
+        console.info(EasyTable.print(streamParts.map((streamPartId) => {
+            const [streamId, streamPartition] = StreamPartIDUtils.getStreamIDAndPartition(streamPartId)
+            return {
+                streamId,
+                streamPartition
+            }
+        })))
+    }
+}))
+    .arguments('<storageNodeAddress>')
+    .description('list stream parts in a storage node')
+    .parseAsync()

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

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import '../src/logLevel'
+import { StreamrClient } from 'streamr-client'
+import EasyTable from 'easy-table'
+import { createClientCommand } from '../src/command'
+
+const getStorageNodes = async (streamId: string | undefined, client: StreamrClient): Promise<string[]> => {
+    if (streamId !== undefined) {
+        const stream = await client.getStream(streamId)
+        return stream.getStorageNodes()
+    } else {
+        return client.getAllStorageNodes()
+    }
+}
+
+createClientCommand(async (client: StreamrClient, options: any) => {
+    const streamId = options.stream
+    const addresses = await getStorageNodes(streamId, client)
+    if (addresses.length > 0) {
+        console.info(EasyTable.print(addresses.map((address: string) => ({
+            address
+        }))))
+    }
+})
+    .description('fetch a list of storage nodes')
+    .option('-s, --stream <streamId>', 'only storage nodes which store the given stream (needs authentication)')
+    .parseAsync()

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

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import '../src/logLevel'
+import StreamrClient from 'streamr-client'
+import { createClientCommand } from '../src/command'
+
+createClientCommand(async (client: StreamrClient, storageNodeAddress: string, streamId: string) => {
+    const stream = await client.getStream(streamId)
+    await stream.removeFromStorageNode(storageNodeAddress)
+})
+    .arguments('<storageNodeAddress> <streamId>')
+    .description('remove stream from a storage node')
+    .parseAsync()

package/bin/streamr-storage-node.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { program } from 'commander'
+import pkg from '../package.json'
+
+program
+    .version(pkg.version)
+    .usage('<command> [<args>]')
+    .description('storage node subcommands')
+    .command('list', 'list storage nodes')
+    .command('add-stream', 'add stream')
+    .command('remove-stream', 'remove stream')
+    .command('list-stream-parts', 'list stream parts in a storage node')
+    .parse()

package/bin/streamr-stream-create.ts

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import '../src/logLevel'
+import StreamrClient from 'streamr-client'
+import { createFnParseInt } from '../src/common'
+import { createClientCommand } from '../src/command'
+
+createClientCommand(async (client: StreamrClient, streamIdOrPath: string, options: any) => {
+    const body: any = {
+        id: streamIdOrPath,
+        description: options.description,
+        config: options.streamConfig,
+        partitions: options.partitions
+    }
+    const stream = await client.createStream(body)
+    console.info(JSON.stringify(stream.toObject(), null, 2))
+})
+    .arguments('<streamId>')
+    .description('create a new stream')
+    .option('-d, --description <description>', 'define a description')
+    .option('-c, --stream-config <config>', 'define a configuration as JSON', (s: string) => JSON.parse(s))
+    .option('-p, --partitions <count>', 'define a partition count',
+        createFnParseInt('--partitions'))
+    .parseAsync()

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

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import '../src/logLevel'
+import { Stream, StreamPermission } from 'streamr-client'
+import { runModifyPermissionsCommand } from '../src/permission'
+
+runModifyPermissionsCommand(
+    (stream: Stream, permission: StreamPermission, target: string) => stream.grantUserPermission(permission, target),
+    (stream: Stream, permission: StreamPermission) => stream.grantPublicPermission(permission),
+    'grant'
+)

package/bin/streamr-stream-publish.ts

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import '../src/logLevel'
+import { Writable } from 'stream'
+import { StreamrClient } from 'streamr-client'
+import { wait } from 'streamr-test-utils'
+import es from 'event-stream'
+import { createClientCommand } from '../src/command'
+
+const publishStream = (
+    stream: string,
+    partitionKey: string | undefined,
+    client: StreamrClient
+): Writable => {
+    const writable = new Writable({
+        objectMode: true,
+        write: (data: any, _: any, done: any) => {
+            let json = 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
+            }
+            // @ts-expect-error TODO: the last argument here looks wrong, should be just `partitionKey`?
+            client.publish(stream, json, Date.now(), json[partitionKey]).then(
+                () => done(),
+                (err) => done(err)
+            )
+        }
+    })
+    return writable
+}
+
+createClientCommand(async (client: StreamrClient, streamId: string, options: any) => {
+    const ps = publishStream(streamId, options.partitionKey, client)
+    return new Promise((resolve, reject) => {
+        process.stdin
+            .pipe(es.split())
+            .pipe(ps)
+            .once('finish', async () => {
+                // We need to wait some time because the client.publish() may resolve the promise
+                // before the node has propagated the message. That may happend if the node
+                // has not yet connected to Tracker when client.publish() is called. In that case
+                // the message is put to the propagation queue (activeTaskStore.add call in
+                // network Propagation.ts:59) and the client.publish() promise resolves immeditatelly.
+                // TODO Remove this wait when NET-604 has been resolved
+                await wait(2000)
+                resolve(undefined)
+            })
+            .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 <string>', 'field name in each message to use for assigning the message to a stream partition')
+    .parseAsync()

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

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import '../src/logLevel'
+import StreamrClient from 'streamr-client'
+import { createClientCommand } from '../src/command'
+import { resend } from '../src/resend'
+
+createClientCommand(async (client: StreamrClient, from: string, streamId: string, options: any) => {
+    const resendOptions = {
+        from: {
+            timestamp: Date.parse(from),
+            sequenceNumber: 0
+        },
+        publisherId: options.publisherId
+    }
+    await resend(streamId, resendOptions, client, options.subscribe)
+}, {
+    clientOptionsFactory: (options) => ({
+        orderMessages: !options.disableOrdering
+    })
+})
+    .arguments('<from> <streamId>')
+    .description('request messages starting from given date-time (format: "YYYY-MM-DDTHH:mm:ss.sssZ")')
+    .option('--publisher-id <string>', 'filter results by publisher')
+    .option('-d, --disable-ordering', 'disable ordering of messages by OrderingUtil', false)
+    .option('-s, --subscribe', 'subscribe in addition to resend', false)
+    .parseAsync()

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

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import '../src/logLevel'
+import StreamrClient from 'streamr-client'
+import { createClientCommand } from '../src/command'
+import { resend } from '../src/resend'
+
+createClientCommand(async (client: StreamrClient, n: string, streamId: string, options: any) => {
+    if (isNaN(n as any)) {
+        console.error('argument n is not a number')
+        process.exit(1)
+    }
+    const resendOptions = {
+        last: parseInt(n)
+    }
+    await resend(streamId, resendOptions, client, options.subscribe)
+}, {
+    clientOptionsFactory: (options) => ({
+        orderMessages: !options.disableOrdering
+    })
+})
+    .arguments('<n> <streamId>')
+    .description('request last N messages')
+    .option('-d, --disable-ordering', 'disable ordering of messages by OrderingUtil', false)
+    .option('-s, --subscribe', 'subscribe in addition to resend', false)
+    .parseAsync()

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

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import '../src/logLevel'
+import { StreamrClient } from 'streamr-client'
+import { createClientCommand } from '../src/command'
+import { assertBothOrNoneDefined, resend } from '../src/resend'
+
+createClientCommand(async (client: StreamrClient, from: string, to: string, streamId: string, options: any) => {
+    const resendOptions = {
+        from: {
+            timestamp: Date.parse(from),
+            sequenceNumber: 0
+        },
+        to: {
+            timestamp: Date.parse(to),
+            sequenceNumber: 0
+        },
+        publisherId: options.publisherId,
+        msgChainId: options.msgChainId
+    }
+    assertBothOrNoneDefined('publisherId', 'msgChainId', '--publisher-id must be accompanied by option --msg-chain-id', options)
+    await resend(streamId, resendOptions, client, false) 
+}, {
+    clientOptionsFactory: (options) => ({
+        orderMessages: !options.disableOrdering
+    })
+})
+    .arguments('<from> <to> <streamId>')
+    .description('request messages between two given date-times (format: "YYYY-MM-DDTHH:mm:ss.sssZ")')
+    .option('--publisher-id <string>', 'filter results by publisher')
+    .option('--msg-chain-id <string>', 'filter results by message chain')
+    .option('-d, --disable-ordering', 'disable ordering of messages by OrderingUtil', false)
+    .parseAsync()

package/bin/streamr-stream-resend.ts

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import '../src/logLevel'
+import { createCommand } from '../src/command'
+
+createCommand()
+    .usage('<command> [<args>]')
+    .description('request resend of stream and print JSON messages to stdout line-by-line')
+    .command('from', 'request messages starting from given date-time')
+    .command('last', 'request last N messages')
+    .command('range', 'request messages between two given date-times')
+    .parse()

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

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import '../src/logLevel'
+import { Stream, StreamPermission } from 'streamr-client'
+import { runModifyPermissionsCommand } from '../src/permission'
+
+runModifyPermissionsCommand(
+    (stream: Stream, permission: StreamPermission, target: string) => stream.revokeUserPermission(permission, target),
+    (stream: Stream, permission: StreamPermission) => stream.revokePublicPermission(permission),
+    'revoke'
+)

package/bin/streamr-stream-search.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import '../src/logLevel'
+import EasyTable from 'easy-table'
+import StreamrClient from 'streamr-client'
+import { createClientCommand } from '../src/command'
+
+createClientCommand(async (client: StreamrClient, term: string) => {
+    const streams = await client.searchStreams(term)
+    if (streams.length > 0) {
+        console.info(EasyTable.print(streams.map(({id}) => ({
+            id
+        }))))
+    }
+})
+    .arguments('<term>')
+    .description('search streams')
+    .parseAsync()