@seamapi/cli 0.18.1 → 0.19.0

package/src/lib/{interact-for-blueprint-object.ts → interactions/blueprint-object.ts}

@@ -1,29 +1,30 @@
 import type { Parameter } from '@seamapi/blueprint'
 
-import { interactForAccessCode } from './interact-for-access-code.js'
-import { interactForAcsEntrance } from './interact-for-acs-entrance.js'
-import { interactForAcsSystem } from './interact-for-acs-system.js'
-import { interactForAcsUser } from './interact-for-acs-user.js'
-import { interactForArray } from './interact-for-array.js'
-import { interactForConnectedAccount } from './interact-for-connected-account.js'
-import { interactForCustomMetadata } from './interact-for-custom-metadata.js'
-import { interactForDevice } from './interact-for-device.js'
-import { interactForTimestamp } from './interact-for-timestamp.js'
-import { interactForUserIdentity } from './interact-for-user-identity.js'
-import { getOutput } from './output/get-output.js'
-import type { ContextHelpers } from './types.js'
-import { NonInteractiveError, toArgName } from './util/cli-args.js'
-import { ellipsis } from './util/ellipsis.js'
+import { assertRequiredParams } from 'lib/args/validate.js'
+import type { CliContext } from 'lib/context.js'
+import { NonInteractiveError, PromptCancelledError } from 'lib/errors.js'
+import { getOutput } from 'lib/output/get-output.js'
 import {
   promptAutocomplete,
   promptAutocompleteMultiselect,
-  PromptCancelledError,
   promptConfirm,
   promptNumber,
   promptSelect,
   promptText,
   withBackHint,
-} from './util/prompt.js'
+} from 'lib/prompt.js'
+import { ellipsis } from 'lib/render/text.js'
+
+import { interactForAccessCode } from './access-code.js'
+import { interactForAcsEntrance } from './acs-entrance.js'
+import { interactForAcsSystem } from './acs-system.js'
+import { interactForAcsUser } from './acs-user.js'
+import { interactForArray } from './array.js'
+import { interactForConnectedAccount } from './connected-account.js'
+import { interactForCustomMetadata } from './custom-metadata.js'
+import { interactForDevice } from './device.js'
+import { interactForTimestamp } from './timestamp.js'
+import { interactForUserIdentity } from './user-identity.js'
 
 const ergonomicPropOrder = [
   'name',
@@ -41,10 +42,11 @@ export const interactForBlueprintObject = async (
     command: string[]
     parameters: Parameter[]
     params: Record<string, any>
+    hasRequiredParameters?: boolean
     isSubProperty?: boolean
     subPropertyPath?: string
   },
-  ctx: ContextHelpers,
+  ctx: CliContext,
 ): Promise<any> => {
   // Clone args and args params so that we can mutate it
   args = { ...args, params: { ...args.params } }
@@ -59,26 +61,31 @@ export const interactForBlueprintObject = async (
   const isSupplied = (k: string): boolean => args.params[k] !== undefined
 
   const haveAllRequiredParams = required.every(isSupplied)
+  // Some request schemas require one of several parameters without marking
+  // any individual parameter as required. The request-level signal tells us
+  // that an entirely empty request still needs interaction.
+  const hasAnyParams = Object.values(args.params).some(
+    (value) => value !== undefined,
+  )
+  const satisfiesRequestRequirement =
+    args.hasRequiredParameters !== true || hasAnyParams
 
   const cmdPath = `/${args.command.join('/').replace(/-/g, '_')}`
 
   const shouldAutoSubmit =
     ctx.interactivity !== 'interactive' &&
     haveAllRequiredParams &&
+    satisfiesRequestRequirement &&
     !args.isSubProperty
   if (shouldAutoSubmit) {
     return args.params
   }
 
   if (ctx.interactivity === 'non-interactive') {
-    const missing = required.filter((k) => !isSupplied(k))
     const target = args.isSubProperty ? `"${args.subPropertyPath}"` : cmdPath
+    assertRequiredParams(args.parameters, args.params, target)
     throw new NonInteractiveError(
-      missing.length > 0
-        ? `Missing required ${
-            missing.length === 1 ? 'parameter' : 'parameters'
-          } for ${target}: ${missing.map(toArgName).join(' ')}`
-        : `Cannot prompt for ${target} in non-interactive mode`,
+      `Cannot prompt for ${target} in non-interactive mode`,
     )
   }
 
@@ -102,7 +109,9 @@ export const interactForBlueprintObject = async (
     paramToEdit = await promptAutocomplete({
       message: parameterSelectionMessage,
       choices: [
-        ...(haveAllRequiredParams && !args.isSubProperty
+        ...(haveAllRequiredParams &&
+        satisfiesRequestRequirement &&
+        !args.isSubProperty
           ? [
               {
                 value: 'done',
@@ -174,6 +183,30 @@ export const interactForBlueprintObject = async (
   // Dismissing any prompt below returns to the parameter menu with the
   // parameter left as it was, rather than ending the whole command.
   try {
+    if (prop != null && (prop.isNullable || isSupplied(paramToEdit))) {
+      const action = await promptSelect({
+        message: withBackHint(`${paramToEdit}:`),
+        choices: [
+          { label: 'Enter a value', value: 'value' },
+          ...(prop.isNullable
+            ? [{ label: 'Set to null', value: 'null' as const }]
+            : []),
+          ...(isSupplied(paramToEdit)
+            ? [{ label: 'Unset', value: 'unset' as const }]
+            : []),
+        ],
+      })
+
+      if (action === 'null') {
+        args.params[paramToEdit] = null
+        return interactForBlueprintObject(args, ctx)
+      }
+      if (action === 'unset') {
+        delete args.params[paramToEdit]
+        return interactForBlueprintObject(args, ctx)
+      }
+    }
+
     if (paramToEdit === 'device_id') {
       args.params[paramToEdit] = await interactForDevice()
       return interactForBlueprintObject(args, ctx)

package/src/lib/{interact-for-command-params.ts → interactions/command-params.ts}

@@ -1,13 +1,14 @@
-import { getCommandBlueprintDef } from './get-command-blueprint-def.js'
-import { interactForBlueprintObject } from './interact-for-blueprint-object.js'
-import type { ContextHelpers } from './types.js'
+import { getCommandBlueprintDef } from 'lib/blueprint/endpoint.js'
+import type { CliContext } from 'lib/context.js'
+
+import { interactForBlueprintObject } from './blueprint-object.js'
 
 export const interactForCommandParams = async (
   args: {
     command: string[]
     params: Record<string, any>
   },
-  ctx: ContextHelpers,
+  ctx: CliContext,
 ): Promise<any> => {
   const endpoint = getCommandBlueprintDef(args.command, ctx)
 
@@ -16,6 +17,7 @@ export const interactForCommandParams = async (
       command: args.command,
       params: args.params,
       parameters: endpoint.request.parameters,
+      hasRequiredParameters: endpoint.request.hasRequiredParameters,
     },
     ctx,
   )

package/src/lib/{interact-for-command-selection.ts → interactions/command-selection.ts}

@@ -1,12 +1,8 @@
 import { isDeepStrictEqual as isEqual } from 'node:util'
 
-import type { ContextHelpers } from './types.js'
-import { NonInteractiveError } from './util/cli-args.js'
-import {
-  promptAutocomplete,
-  PromptCancelledError,
-  withBackHint,
-} from './util/prompt.js'
+import type { Interactivity } from 'lib/args/parse.js'
+import { NonInteractiveError, PromptCancelledError } from 'lib/errors.js'
+import { promptAutocomplete, withBackHint } from 'lib/prompt.js'
 
 const uniqBy = <T>(items: T[], keyOf: (item: T) => unknown): T[] => {
   const seen = new Set<unknown>()
@@ -29,24 +25,16 @@ function ergonomicSort(aStr: string, bStr: string) {
   return a > b ? 1 : a < b ? -1 : 0
 }
 
+/**
+ * Resolve a command path to a full command, prompting to complete it when
+ * interactive. `commands` is every selectable command path, from the
+ * registry's spec.
+ */
 export async function interactForCommandSelection(
   commandPath: string[],
-  helpers: ContextHelpers,
-) {
-  const commands = helpers.blueprint.routes
-    .flatMap((route) => route.endpoints)
-    .map((endpoint) =>
-      endpoint.path.replace(/_/g, '-').replace(/^\//, '').split('/'),
-    )
-    .concat([
-      ['login'],
-      ['logout'],
-      ['config', 'reveal-location'],
-      ['config', 'use-remote-api-defs'],
-      ['select', 'workspace'],
-      ['select', 'server'],
-      ['health', 'get-health'],
-    ])
+  helpers: { commands: string[][]; interactivity: Interactivity },
+): Promise<string[]> {
+  const commands = helpers.commands
 
   const possibleCommands = uniqBy(
     commandPath.length === 0

package/src/lib/{interact-for-connected-account.ts → interactions/connected-account.ts}

@@ -1,5 +1,6 @@
-import { getSeam } from './get-seam.js'
-import { interactForResource } from './interact-for-resource.js'
+import { getSeam } from 'lib/http/client.js'
+
+import { interactForResource } from './resource.js'
 export const interactForConnectedAccount = async () => {
   const seam = await getSeam()
 

package/src/lib/{interact-for-custom-metadata.ts → interactions/custom-metadata.ts}

@@ -1,10 +1,6 @@
-import { getOutput } from './output/get-output.js'
-import {
-  PromptCancelledError,
-  promptSelect,
-  promptText,
-  withBackHint,
-} from './util/prompt.js'
+import { PromptCancelledError } from 'lib/errors.js'
+import { getOutput } from 'lib/output/get-output.js'
+import { promptSelect, promptText, withBackHint } from 'lib/prompt.js'
 
 // Structurally the CustomMetadata of @seamapi/types, spelled out here so the
 // published declarations do not depend on a development-only package.

package/src/lib/{interact-for-device.ts → interactions/device.ts}

@@ -1,5 +1,6 @@
-import { getSeam } from './get-seam.js'
-import { interactForResource } from './interact-for-resource.js'
+import { getSeam } from 'lib/http/client.js'
+
+import { interactForResource } from './resource.js'
 export const interactForDevice = async () => {
   const seam = await getSeam()
 

package/src/lib/interactions/index.ts

@@ -0,0 +1,19 @@
+export * from './access-code.js'
+export * from './acs-entrance.js'
+export * from './acs-system.js'
+export * from './acs-user.js'
+export * from './action-attempt-poll.js'
+export * from './array.js'
+export * from './blueprint-object.js'
+export * from './command-params.js'
+export * from './command-selection.js'
+export * from './connected-account.js'
+export * from './custom-metadata.js'
+export * from './device.js'
+export * from './login.js'
+export * from './resource.js'
+export * from './server-selection.js'
+export * from './timestamp.js'
+export * from './use-remote-api-defs.js'
+export * from './user-identity.js'
+export * from './workspace-id.js'

package/src/lib/{interact-for-login.ts → interactions/login.ts}

@@ -1,24 +1,27 @@
 import { isApiKey, isPersonalAccessToken } from '@seamapi/http/connect'
 import chalk from 'chalk'
 
-import { getConfigStore } from './config/index.js'
-import { assertEnvVarUnset, getTokenFromEnv, tokenEnvVar } from './env.js'
-import { getServer } from './get-server.js'
-import { interactForWorkspaceId } from './interact-for-workspace-id.js'
-import { getOutput } from './output/get-output.js'
-import { promptText } from './util/prompt.js'
-import { withLoading } from './util/with-loading.js'
-import { validateToken } from './validate-token.js'
+import { assertMutable, storeToken } from 'lib/auth/operations.js'
+import { validateToken } from 'lib/auth/validate-token.js'
+import { getConfigStore } from 'lib/config/index.js'
+import { resolveAuth } from 'lib/context.js'
+import { getOutput } from 'lib/output/get-output.js'
+import { withLoading } from 'lib/output/with-loading.js'
+import { promptText } from 'lib/prompt.js'
+
+import { interactForWorkspaceId } from './workspace-id.js'
 
 export const interactForLogin = async () => {
-  const config = await getConfigStore()
+  const config = getConfigStore()
   const output = getOutput()
+  const auth = resolveAuth(config)
 
-  assertEnvVarUnset(tokenEnvVar, getTokenFromEnv(), 'log in')
+  // Refuse before prompting: nothing typed here could be stored.
+  assertMutable(auth, 'token', 'log in')
 
-  if (getServer().includes('localhost')) {
+  if (auth.server.includes('localhost')) {
     output.info(
-      `You're using a local Seam Connect instance, you can enter the API Key to your local user, you can create a new user from:\n\n${getServer()}/admin/create_user_with_api_key`,
+      `You're using a local Seam Connect instance, you can enter the API Key to your local user, you can create a new user from:\n\n${auth.server}/admin/create_user_with_api_key`,
     )
   } else {
     output.info(
@@ -51,6 +54,6 @@ export const interactForLogin = async () => {
     )
   }
 
-  config.set(`${getServer()}.pat`, token)
+  storeToken(token, config)
   output.info(`Token saved! You may begin using the CLI!`)
 }

package/src/lib/{interact-for-resource.ts → interactions/resource.ts}

@@ -1,5 +1,5 @@
-import { promptAutocomplete, withBackHint } from './util/prompt.js'
-import { withLoading } from './util/with-loading.js'
+import { withLoading } from 'lib/output/with-loading.js'
+import { promptAutocomplete, withBackHint } from 'lib/prompt.js'
 
 export interface ResourceChoice {
   title: string

package/src/lib/{interact-for-server-selection.ts → interactions/server-selection.ts}

@@ -1,19 +1,18 @@
 import { randomBytes } from 'node:crypto'
 
-import { getConfigStore } from './config/index.js'
 import {
-  assertEnvVarUnset,
-  endpointEnvVar,
-  getEndpointFromEnv,
-  getTokenFromEnv,
-  tokenEnvVar,
-} from './env.js'
-import { getServer } from './get-server.js'
-import { getOutput } from './output/get-output.js'
-import { promptAutocomplete, promptText } from './util/prompt.js'
+  assertMutable,
+  selectFakeServer,
+  selectServer,
+} from 'lib/auth/operations.js'
+import { getConfigStore } from 'lib/config/index.js'
+import { resolveAuth } from 'lib/context.js'
+import { getOutput } from 'lib/output/get-output.js'
+import { promptAutocomplete, promptText } from 'lib/prompt.js'
 
 export async function interactForServerSelection() {
-  assertEnvVarUnset(endpointEnvVar, getEndpointFromEnv(), 'select a server')
+  const config = getConfigStore()
+  assertMutable(resolveAuth(config), 'server', 'select a server')
 
   const servers = [
     'http://localhost:3020',
@@ -27,7 +26,6 @@ export async function interactForServerSelection() {
     choices: servers.map((server) => ({ label: server, value: server })),
   })
 
-  const config = getConfigStore()
   const output = getOutput()
   if (server === servers[2]) {
     let userUrlSeed = await promptText({
@@ -38,13 +36,10 @@ export async function interactForServerSelection() {
     if (userUrlSeed.trim().length === 0) {
       userUrlSeed = randomBytes(5).toString('hex')
     }
-    assertEnvVarUnset(tokenEnvVar, getTokenFromEnv(), 'log in')
-    config.set('server', `https://${userUrlSeed}.fakeseamconnect.seam.vc`)
-    config.set(`${getServer()}.pat`, `seam_apikey1_token`)
+    selectFakeServer({ urlSeed: userUrlSeed, config })
     output.info(`PAT set to use fakeseamconnect with "seam_apikey1_token"`)
   } else {
-    config.set('server', server)
+    selectServer(server, config)
   }
-  config.delete('current_workspace_id')
   output.info(`Server set to ${server}`)
 }

package/src/lib/{interact-for-timestamp.ts → interactions/timestamp.ts}

@@ -1,4 +1,4 @@
-import { promptText, withBackHint } from './util/prompt.js'
+import { promptText, withBackHint } from 'lib/prompt.js'
 
 export const interactForTimestamp = async () => {
   const now = new Date().toISOString()

package/src/lib/{interact-for-use-remote-api-defs.ts → interactions/use-remote-api-defs.ts}

@@ -1,6 +1,6 @@
-import { getConfigStore } from './config/index.js'
-import { getOutput } from './output/get-output.js'
-import { promptSelect } from './util/prompt.js'
+import { setUseRemoteApiDefs } from 'lib/auth/operations.js'
+import { getOutput } from 'lib/output/get-output.js'
+import { promptSelect } from 'lib/prompt.js'
 
 export async function interactForUseRemoteApiDefs() {
   const useRemoteApiDefs = await promptSelect({
@@ -17,7 +17,6 @@ export async function interactForUseRemoteApiDefs() {
     ],
   })
 
-  const config = getConfigStore()
-  config.set('use_remote_api_defs', useRemoteApiDefs)
+  setUseRemoteApiDefs(useRemoteApiDefs)
   getOutput().info(`Use remote API Definitions: ${useRemoteApiDefs}`)
 }

package/src/lib/{interact-for-user-identity.ts → interactions/user-identity.ts}

@@ -1,5 +1,6 @@
-import { getSeam } from './get-seam.js'
-import { interactForResource } from './interact-for-resource.js'
+import { getSeam } from 'lib/http/client.js'
+
+import { interactForResource } from './resource.js'
 
 export const interactForUserIdentity = async () => {
   const seam = await getSeam()

package/src/lib/{interact-for-workspace-id.ts → interactions/workspace-id.ts}

@@ -1,28 +1,21 @@
 import { SeamHttpWithoutWorkspace } from '@seamapi/http/connect'
 
-import { getConfigStore } from './config/index.js'
-import {
-  assertEnvVarUnset,
-  getWorkspaceIdFromEnv,
-  workspaceIdEnvVar,
-} from './env.js'
-import { getSeamMultiWorkspace } from './get-seam.js'
-import { getServer } from './get-server.js'
-import { promptAutocomplete } from './util/prompt.js'
-import { withLoading } from './util/with-loading.js'
+import { assertMutable, selectWorkspace } from 'lib/auth/operations.js'
+import { getConfigStore } from 'lib/config/index.js'
+import { resolveAuth } from 'lib/context.js'
+import { getSeamMultiWorkspace } from 'lib/http/client.js'
+import { withLoading } from 'lib/output/with-loading.js'
+import { promptAutocomplete } from 'lib/prompt.js'
 
 export const interactForWorkspaceId = async (personalAccessToken?: string) => {
   const config = getConfigStore()
 
-  assertEnvVarUnset(
-    workspaceIdEnvVar,
-    getWorkspaceIdFromEnv(),
-    'select a workspace',
-  )
+  // Refuse before prompting: nothing selected here could be stored.
+  assertMutable(resolveAuth(config), 'workspaceId', 'select a workspace')
 
   const seam = personalAccessToken
     ? SeamHttpWithoutWorkspace.fromPersonalAccessToken(personalAccessToken, {
-        endpoint: getServer(),
+        endpoint: resolveAuth(config).server,
       })
     : await getSeamMultiWorkspace()
 
@@ -40,6 +33,6 @@ export const interactForWorkspaceId = async (personalAccessToken?: string) => {
     })),
   })
 
-  config.set('current_workspace_id', workspaceId)
+  selectWorkspace(workspaceId, config)
   return workspaceId
 }

package/src/lib/memory-prompt.ts

@@ -0,0 +1,89 @@
+import { PromptCancelledError } from 'lib/errors.js'
+import type {
+  PromptChoice,
+  PromptClient,
+  PromptConfirmOptions,
+  PromptNumberOptions,
+  PromptSelectOptions,
+  PromptTextOptions,
+} from 'lib/prompt.js'
+
+/** A question a {@link PromptClient} was asked, as a test sees it. */
+export interface PromptQuestion {
+  kind:
+    | 'text'
+    | 'number'
+    | 'confirm'
+    | 'select'
+    | 'autocomplete'
+    | 'autocompleteMultiselect'
+  message: string
+  choices?: Array<PromptChoice<unknown>>
+}
+
+/** Scripted in place of an answer to dismiss that prompt. */
+export const cancelPrompt = Symbol('cancel-prompt')
+
+/**
+ * A real {@link PromptClient} that answers from a script instead of a
+ * terminal, and records every question it was asked.
+ *
+ * Each ask consumes the next scripted answer in turn. Scripting
+ * {@link cancelPrompt} dismisses that prompt, and an exhausted script
+ * dismisses every prompt after it, exactly as a user cancelling would.
+ */
+export class MemoryPromptClient implements PromptClient {
+  /** Every question asked, in order — assert on what the user was offered. */
+  readonly questions: PromptQuestion[] = []
+
+  private readonly answers: unknown[]
+
+  constructor(script: unknown[] = []) {
+    this.answers = [...script]
+  }
+
+  canPrompt = (): boolean => true
+
+  text = async ({ message }: PromptTextOptions): Promise<string> =>
+    this.answer({ kind: 'text', message }) as string
+
+  number = async ({ message }: PromptNumberOptions): Promise<number> =>
+    this.answer({ kind: 'number', message }) as number
+
+  confirm = async ({ message }: PromptConfirmOptions): Promise<boolean> =>
+    this.answer({ kind: 'confirm', message }) as boolean
+
+  select = async <Value>({
+    message,
+    choices,
+  }: PromptSelectOptions<Value>): Promise<Value> =>
+    this.answer({ kind: 'select', message, choices }) as Value
+
+  autocomplete = async <Value>({
+    message,
+    choices,
+  }: PromptSelectOptions<Value>): Promise<Value> =>
+    this.answer({ kind: 'autocomplete', message, choices }) as Value
+
+  autocompleteMultiselect = async <Value>({
+    message,
+    choices,
+  }: PromptSelectOptions<Value>): Promise<Value[]> =>
+    this.answer({
+      kind: 'autocompleteMultiselect',
+      message,
+      choices,
+    }) as Value[]
+
+  private answer(question: PromptQuestion): unknown {
+    this.questions.push(question)
+    if (this.answers.length === 0) throw new PromptCancelledError()
+    const value = this.answers.shift()
+    if (value === cancelPrompt) throw new PromptCancelledError()
+    return value
+  }
+}
+
+export const createMemoryPrompt = (
+  script: unknown[] = [],
+): MemoryPromptClient => new MemoryPromptClient(script)

package/src/lib/output/get-output.ts

@@ -1,4 +1,4 @@
-import { createOutput, type Output } from './create-output.js'
+import { createOutput, type Output } from './output.js'
 
 let output: Output | null = null
 

package/src/lib/output/{create-memory-output.ts → memory-output.ts}

@@ -3,7 +3,7 @@ import {
   type CreateOutputOptions,
   type Output,
   type OutputStream,
-} from './create-output.js'
+} from './output.js'
 
 export interface MemoryOutput {
   output: Output

package/src/lib/output/{create-output.ts → output.ts}

@@ -58,41 +58,56 @@ export interface CreateOutputOptions {
   colors?: boolean
 }
 
-export const createOutput = ({
-  format = 'text',
-  stdout = process.stdout,
-  stderr = process.stderr,
-  colors = false,
-}: CreateOutputOptions = {}): Output => {
-  const isJson = format === 'json'
-
-  return {
-    format,
-
-    data: (value: unknown): void => {
-      if (value === undefined) return
-      stdout.write(`${formatData(value, format, colors)}\n`)
-    },
-
-    text: (value: string): void => {
-      stdout.write(`${value}\n`)
-    },
-
-    info: (message = ''): void => {
-      if (isJson) return
-      stderr.write(`${message}\n`)
-    },
-
-    warn: (message: string): void => {
-      stderr.write(`${message}\n`)
-    },
-
-    error: (message: string): void => {
-      stderr.write(`${message}\n`)
-    },
+/**
+ * The one {@link Output} implementation: writes to a pair of streams. The
+ * process streams make it the real output; in-memory streams make it the
+ * test capture (see `create-memory-output.ts`).
+ */
+export class StreamOutput implements Output {
+  readonly format: OutputFormat
+
+  private readonly stdout: OutputStream
+  private readonly stderr: OutputStream
+  private readonly colors: boolean
+
+  constructor({
+    format = 'text',
+    stdout = process.stdout,
+    stderr = process.stderr,
+    colors = false,
+  }: CreateOutputOptions = {}) {
+    this.format = format
+    this.stdout = stdout
+    this.stderr = stderr
+    this.colors = colors
+  }
+
+  data = (value: unknown): void => {
+    if (value === undefined) return
+    this.stdout.write(`${formatData(value, this.format, this.colors)}\n`)
+  }
+
+  text = (value: string): void => {
+    this.stdout.write(`${value}\n`)
+  }
+
+  info = (message = ''): void => {
+    if (this.format === 'json') return
+    this.stderr.write(`${message}\n`)
+  }
+
+  warn = (message: string): void => {
+    this.stderr.write(`${message}\n`)
+  }
+
+  error = (message: string): void => {
+    this.stderr.write(`${message}\n`)
   }
 }
 
+export const createOutput = (options: CreateOutputOptions = {}): Output =>
+  new StreamOutput(options)
+
 const formatData = (
   value: unknown,
   format: OutputFormat,