@streamr/cli-tools 103.0.0-rc.0 → 103.0.0-rc.1

package/bin/streamr-stream-create.ts

@@ -1,30 +0,0 @@
-#!/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'
-
-interface Options extends BaseOptions {
-    description?: string
-    streamConfig?: any
-    partitions?: number
-}
-
-createClientCommand(async (client: StreamrClient, streamIdOrPath: string, options: Options) => {
-    const body: any = {
-        id: streamIdOrPath,
-        description: options.description,
-        config: options.streamConfig,
-        partitions: options.partitions
-    }
-    const stream = await client.createStream(body)
-    console.info(JSON.stringify({ id: stream.id, ...await stream.getMetadata() }, 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

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-import '../src/logLevel'
-
-import { PermissionAssignment, Stream } from '@streamr/sdk'
-import { runModifyPermissionsCommand } from '../src/permission'
-
-runModifyPermissionsCommand(
-    (stream: Stream, assigment: PermissionAssignment) => stream.grantPermissions(assigment),
-    'grant'
-)

package/bin/streamr-stream-publish.ts

@@ -1,78 +0,0 @@
-#!/usr/bin/env node
-import '../src/logLevel'
-
-import { Writable } from 'stream'
-import { StreamrClient } from '@streamr/sdk'
-import { hexToBinary, wait } from '@streamr/utils'
-import es from 'event-stream'
-import { createClientCommand, Options as BaseOptions } from '../src/command'
-
-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,
-    client: StreamrClient
-): Writable => {
-    const writable = new Writable({
-        objectMode: true,
-        write: (data: any, _: any, done: any) => {
-            let message = null
-            // ignore newlines, etc
-            if (!data || String(data).trim() === '') {
-                done()
-                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 && typeof message === 'object') ? message[partitionKeyField] : undefined
-            client.publish(stream, message, { partitionKey }).then(
-                () => done(),
-                (err) => done(err)
-            )
-        }
-    })
-    return writable
-}
-
-createClientCommand(async (client: StreamrClient, streamId: string, options: Options) => {
-    const ps = publishStream(streamId, options.partitionKeyField, 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)
-            })
-            // 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 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,33 +0,0 @@
-#!/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'
-
-interface Options extends BaseOptions {
-    publisherId?: string
-    disableOrdering: boolean
-    subscribe: boolean
-}
-
-createClientCommand(async (client: StreamrClient, from: string, streamId: string, options: Options) => {
-    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

@@ -1,31 +0,0 @@
-#!/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'
-
-interface Options extends BaseOptions {
-    disableOrdering: boolean
-    subscribe: boolean
-}
-
-createClientCommand(async (client: StreamrClient, n: string, streamId: string, options: Options) => {
-    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

@@ -1,39 +0,0 @@
-#!/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'
-
-interface Options extends BaseOptions {
-    publisherId?: string
-    msgChainId?: string
-    subscribe: boolean
-}
-
-createClientCommand(async (client: StreamrClient, from: string, to: string, streamId: string, options: Options) => {
-    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

@@ -1,12 +0,0 @@
-#!/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

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-import '../src/logLevel'
-
-import { PermissionAssignment, Stream } from '@streamr/sdk'
-import { runModifyPermissionsCommand } from '../src/permission'
-
-runModifyPermissionsCommand(
-    (stream: Stream, assigment: PermissionAssignment) => stream.revokePermissions(assigment),
-    'revoke'
-)

package/bin/streamr-stream-search.ts

@@ -1,62 +0,0 @@
-#!/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'
-import { getPermission, PERMISSIONS } from '../src/permission'
-import { getOptionType, OptionType } from '../src/common'
-
-interface Options extends BaseOptions {
-    user?: string | true
-    public: boolean
-    all?: StreamPermission[]
-    any?: StreamPermission[]
-}
-
-const createPermissionFilter = async (
-    user: string | true | undefined,
-    allowPublic: boolean | undefined,
-    allOf: StreamPermission[] | undefined,
-    anyOf: StreamPermission[] | undefined,
-    client: StreamrClient
-): Promise<SearchStreamsPermissionFilter | undefined> => {
-    if (user !== undefined) {
-        return {
-            userId: (getOptionType(user) === OptionType.ARGUMENT) ? user as string : await client.getUserId(),
-            allowPublic: allowPublic ?? false,
-            allOf,
-            anyOf
-        }
-    } else if ((allowPublic !== undefined) || (allOf !== undefined) || (anyOf !== undefined)) {
-        console.error('specify a user with "--user" when using "--public", "--all" or "--any"')
-        process.exit(1)
-    }
-}
-
-const createPermissionListOption = (id: string) => {
-    return new Option(`--${id} <permissions>`, 'comma-separated list of permissions')
-        .choices(Array.from(PERMISSIONS.keys()))
-        .argParser((value: string) => value.split(',').map((id) => getPermission(id)))
-}
-
-createClientCommand(async (client: StreamrClient, term: string | undefined, options: Options) => {
-    const permissionFilter = await createPermissionFilter(
-        options.user,
-        options.public,
-        options.all,
-        options.any,
-        client
-    )
-    const streams = client.searchStreams(term, permissionFilter)
-    for await (const stream of streams) {
-        console.info(stream.id)
-    }
-})
-    .arguments('[term]')
-    .description('search streams')
-    .option('--user [user]', 'a stream must have permissions for the given user, defaults to the authenticated user')
-    .option('--public', 'the permission can be implicit (a public permission to the stream)')
-    .addOption(createPermissionListOption('all'))
-    .addOption(createPermissionListOption('any'))
-    .parseAsync()

package/bin/streamr-stream-show.ts

@@ -1,37 +0,0 @@
-#!/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/omit'
-
-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, ...await stream.getMetadata() }
-    if (options.includePermissions) {
-        const assigments = await stream.getPermissions()
-        obj.permissions = assigments.map((assignment) => {
-            return {
-                ...withRenamedField(assignment, 'userId', 'user'),
-                permissions: assignment.permissions.map(getPermissionId)
-            }
-        })
-    }
-    console.info(JSON.stringify(obj, null, 2))
-})
-    .arguments('<streamId>')
-    .description('show detailed information about a stream')
-    .option('--include-permissions', 'include list of permissions', false)
-    .parseAsync()

package/bin/streamr-stream-subscribe.ts

@@ -1,43 +0,0 @@
-#!/usr/bin/env node
-import '../src/logLevel'
-
-import omit from 'lodash/omit'
-import isString from 'lodash/isString'
-import { StreamrClient, MessageMetadata } from '@streamr/sdk'
-import { createClientCommand, Options as BaseOptions } from '../src/command'
-import { createFnParseInt } from '../src/common'
-import { binaryToHex } from '@streamr/utils'
-
-interface Options extends BaseOptions {
-    partition: number
-    disableOrdering: boolean
-    raw: boolean
-    withMetadata: boolean
-}
-
-createClientCommand(async (client: StreamrClient, streamId: string, options: Options) => {
-    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)
-    await client.subscribe({
-        streamId,
-        partition: options.partition,
-        raw: options.raw
-    }, (content, metadata) => {
-        const output = formMessage(content, metadata)
-        console.info(isString(output) ? output : JSON.stringify(output))
-    })
-}, {
-    autoDestroyClient: false,
-    clientOptionsFactory: (options) => ({
-        orderMessages: !options.disableOrdering
-    })
-})
-    .arguments('<streamId>')
-    .description('subscribe to a stream, prints JSON messages to stdout line-by-line')
-    .option('-p, --partition [partition]', 'partition', createFnParseInt('--partition'), 0)
-    .option('-d, --disable-ordering', 'disable ordering of messages by OrderingUtil', false)
-    .option('-r, --raw', 'subscribe raw', false)
-    .option('-m, --with-metadata', 'print each message with its metadata included', false)
-    .parseAsync()

package/bin/streamr-stream.ts

@@ -1,17 +0,0 @@
-#!/usr/bin/env node
-import { program } from 'commander'
-import pkg from '../package.json'
-
-program
-    .version(pkg.version)
-    .usage('<command> [<args>]')
-    .description('stream subcommands')
-    .command('subscribe', 'subscribe to a stream')
-    .command('publish', 'publish to a stream')
-    .command('search', 'search for streams')
-    .command('show', 'info about a stream')
-    .command('create', 'create a new stream')
-    .command('resend', 'request resend of a stream')
-    .command('grant-permission', 'grant permission')
-    .command('revoke-permission', 'revoke permission')
-    .parse()

package/bin/streamr-wallet-whoami.ts

@@ -1,11 +0,0 @@
-#!/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.getUserId())
-})
-    .description('displays your public address')
-    .parseAsync()

package/bin/streamr-wallet.ts

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-import { program } from 'commander'
-import pkg from '../package.json'
-
-program
-    .version(pkg.version)
-    .usage('<command> [<args>]')
-    .description('wallet subcommands')
-    .command('whoami', 'displays your public address')
-    .parse()

package/bin/streamr.ts

@@ -1,14 +0,0 @@
-#!/usr/bin/env node
-import { program } from 'commander'
-import pkg from '../package.json'
-
-program
-    .version(pkg.version)
-    .usage('<command> <subcommand> [<args>]')
-    .description('command line tools for interacting with Streamr https://streamr.network')
-    .command('stream', 'stream subcommands')
-    .command('storage-node', 'storage node subcommands')
-    .command('mock-data', 'mock data subcommands')
-    .command('wallet', 'wallet subcommands')
-    .command('internal', 'subcommands for internal use')
-    .parse()

package/jest.config.ts

@@ -1 +0,0 @@
-export { default } from '../../jest.config'

package/src/client.ts

@@ -1,34 +0,0 @@
-import { StreamrClient, StreamrClientConfig } from '@streamr/sdk'
-import merge from 'lodash/merge'
-import { Options } from './command'
-import { getConfig } from './config'
-
-export const getClientConfig = (commandOptions: Options, overridenOptions: StreamrClientConfig = {}): StreamrClientConfig => {
-    const configFileJson = getConfig(commandOptions.config)?.client
-    const environmentOptions = { environment: commandOptions.env }
-    const authenticationOptions = (commandOptions.privateKey !== undefined) ? { auth: { privateKey: commandOptions.privateKey } } : undefined
-    return merge(
-        configFileJson,
-        environmentOptions,
-        authenticationOptions,
-        overridenOptions
-    )
-}
-
-const addInterruptHandler = (client: StreamrClient) => {
-    process.on('SIGINT', async () => {
-        try {
-            await client.destroy()
-        } catch {
-            // no-op
-        }
-        process.exit()
-    })
-}
-
-export const createClient = (commandOptions: Options, overridenOptions: StreamrClientConfig = {}): StreamrClient => {
-    const config = getClientConfig(commandOptions, overridenOptions)
-    const client = new StreamrClient(config)
-    addInterruptHandler(client)
-    return client
-}

package/src/command.ts

@@ -1,53 +0,0 @@
-import { DEFAULT_ENVIRONMENT_ID, ENVIRONMENT_IDS, EnvironmentId, StreamrClientConfig } from '@streamr/sdk'
-import commander, { Command } from 'commander'
-import pkg from '../package.json'
-import { createClient } from './client'
-import { createFnParseEnum, formEnumArgValueDescription } from './common'
-
-export interface Options {
-    privateKey?: string
-    config?: string
-    env?: EnvironmentId
-}
-
-export const createCommand = (): commander.Command => {
-    return new Command()
-        .version(pkg.version)
-        .showHelpAfterError()
-        .allowExcessArguments(false)
-}
-
-export interface CommandOpts {
-    autoDestroyClient?: boolean
-    clientOptionsFactory?: (options: any) => StreamrClientConfig
-}
-
-export const createClientCommand = (
-    action: (...handleArgs: any[]) => Promise<void>, 
-    opts: CommandOpts = {
-        autoDestroyClient: true,
-        clientOptionsFactory: () => ({})
-    }
-): commander.Command => {
-    return createCommand()
-        .option('--private-key <key>', 'use an Ethereum private key to authenticate')
-        .option('--config <file>', 'read connection and authentication settings from a config file')
-        .option('--env <environmentId>', `use pre-defined environment (${formEnumArgValueDescription(ENVIRONMENT_IDS, DEFAULT_ENVIRONMENT_ID)})`,
-            createFnParseEnum('env', ENVIRONMENT_IDS))
-        .action(async (...args: any[]) => {
-            const commandOptions = args[args.length - 1].opts()
-            try {
-                const client = createClient(commandOptions, opts.clientOptionsFactory!(commandOptions))
-                try {
-                    await action(...[client].concat(args))
-                } finally {
-                    if (opts.autoDestroyClient) {
-                        await client.destroy()
-                    }
-                }
-            } catch (e: any) {
-                console.error(e)
-                process.exit(1)
-            }
-        })
-}

package/src/common.ts

@@ -1,43 +0,0 @@
-export enum OptionType {
-    FLAG, // e.g. "--enable"
-    ARGUMENT  // e.g. "--private-key 0x1234"
-}
-
-export const getOptionType = (value: string | boolean): OptionType | never => {
-    if (typeof value === 'boolean') {
-        return OptionType.FLAG
-    } else if (typeof value === 'string') {
-        return OptionType.ARGUMENT
-    } else {
-        throw new Error(`unknown option type (value: ${value})`)
-    }
-}
-
-export function createFnParseInt(name: string): (s: string) => number {
-    return (str: string) => {
-        const n = parseInt(str, 10)
-        if (isNaN(n)) {
-            console.error(`${name} must be an integer (was "${str}")`)
-            process.exit(1)
-        }
-        return n
-    }
-}
-
-export function createFnParseEnum(name: string, allowedValues: string[]): (s: string) => string {
-    return (value: string) => {
-        if (!allowedValues.includes(value)) {
-            console.error(`${name} must be one of: ${allowedValues.map((s) => wrapWithQuotes(s)).join(', ')}`)
-            process.exit(1)
-        }
-        return value
-    }
-}
-
-export const formEnumArgValueDescription = (allowedValues: string[], defaultValue: string): string => {
-    return `one of: ${allowedValues.map(wrapWithQuotes).join(', ')}, default: ${wrapWithQuotes(defaultValue)}`
-}
-
-export const wrapWithQuotes = (str: string): string => {
-    return `"${str}"`
-}

package/src/config.ts

@@ -1,56 +0,0 @@
-import path from 'path'
-import os from 'os'
-import { readFileSync } from 'fs'
-import { StreamrClientConfig } from '@streamr/sdk'
-
-interface Config {
-    client: StreamrClientConfig
-}
-
-/*
- * Validate that the config contains at least one root level element: the "client" block.
- * The values of the "client" blocks are validated by StreamrClient when the configuration 
- * is used.
- *  
- * We don't check other root level elements. It is ok to use a Broker config file as
- * a cli-tools config file. In that case the file contains e.g. "plugins" block, 
- * but cli-tools can just ignore that block.
- */
-const validateConfig = (config: any, fileName: string): void | never => {
-    const CLIENT_CONFIG_BLOCK = 'client'
-    if (config[CLIENT_CONFIG_BLOCK] === undefined) {
-        throw new Error(`Missing root element "${CLIENT_CONFIG_BLOCK}" in ${fileName}`)
-    }
-}
-
-const tryReadConfigFile = (fileName: string): Config | undefined | never => {
-    let content
-    try {
-        content = readFileSync(fileName, 'utf8')
-    } catch {
-        return undefined
-    }
-    const json = JSON.parse(content)
-    validateConfig(json, fileName)
-    return json
-}
-
-export const getConfig = (id?: string): Config | undefined => {
-    const CONFIG_DIRECTORY = path.join(os.homedir(), '.streamr', 'config')
-    if (id !== undefined) {
-        const fileNames = [
-            id,
-            path.join(CONFIG_DIRECTORY, `${id}.json`),
-        ]
-        for (const fileName of fileNames) {
-            const content = tryReadConfigFile(fileName)
-            if (content !== undefined) {
-                return content
-            }
-        }
-        throw new Error('Config file not found')
-    } else {
-        const fileName = path.join(CONFIG_DIRECTORY, `default.json`)
-        return tryReadConfigFile(fileName)
-    }
-}

package/src/logLevel.ts

@@ -1,9 +0,0 @@
-/*
- * Minimal logging for NetworkNode and other users of Logger.ts in the network package.
- * This file needs to be imported before any of the network package classes
- * so that the environment variable is updated before any Logger instances are created.
- * The import is needed for the files where network packages are used (typically
- * the files which call createClientCommand()).
- */
-
-process.env.LOG_LEVEL = process.env.LOG_LEVEL ?? 'error'