@usestatemachines/cli 0.0.0-stage → 0.1.0

package/dist/command.d.ts

@@ -0,0 +1,119 @@
+import { z } from 'zod';
+import type { ContextNeed, ContextResolvers, Contexts, Presentation } from './context-types.js';
+import { type ExitCode } from './errors.js';
+export type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+export interface ArgSpec {
+    readonly name: string;
+    readonly key: string;
+    readonly required: boolean;
+    readonly many: boolean;
+}
+export type FlagSpec = {
+    readonly name: string;
+    readonly key: string;
+    readonly description: string;
+    readonly short?: string;
+} & ({
+    readonly type: 'boolean';
+    readonly negatedName: string | null;
+} | {
+    readonly type: 'string' | 'string[]';
+});
+export interface CommandSyntax {
+    readonly name: readonly [string, ...string[]];
+    readonly arguments: readonly ArgSpec[];
+    readonly flags: readonly FlagSpec[];
+}
+export interface CommandHelp extends CommandSyntax {
+    readonly summary: string;
+    readonly need: ContextNeed;
+    readonly destructive: boolean;
+    readonly confirmation: 'before-run' | 'handler';
+    readonly streams: boolean;
+    readonly acceptsWorkspace: boolean;
+    readonly output: 'structured' | 'raw' | 'passthrough';
+    readonly outputException: 'dotenv' | null;
+    readonly inputSchema: JsonValue;
+    readonly resultSchema: JsonValue;
+    readonly progressSchema: JsonValue;
+    readonly exitCodes: readonly ExitCode[];
+}
+export type CommandEvent<Result, Progress> = {
+    readonly kind: 'progress';
+    readonly value: Progress;
+} | {
+    readonly kind: 'result';
+    readonly value: Result;
+};
+export type CommandExecution<Result, Progress> = Promise<Result> | AsyncIterable<CommandEvent<Result, Progress>>;
+export interface CommandModule<Input, Result, Progress, Need extends ContextNeed> {
+    run(input: Input, context: Contexts[Need]): CommandExecution<Result, Progress>;
+    text(result: Result, input: Input): string;
+    outputFormat?(input: Input): 'text' | 'json' | null;
+    literalText?(result: Result, input: Input): string | null;
+    progressText?(progress: Progress): string;
+    exitCode?(result: Result): ExitCode;
+}
+interface DefinitionBase<Shape extends z.ZodRawShape, Need extends ContextNeed> extends CommandSyntax {
+    readonly summary: string;
+    readonly need: Need;
+    readonly destructive: boolean;
+    readonly confirmation?: 'before-run' | 'handler';
+    readonly outputException?: 'dotenv';
+    readonly workspace?: boolean;
+    readonly input: z.ZodObject<Shape>;
+}
+export interface CommandDefinition<Shape extends z.ZodRawShape, Result extends JsonValue, Progress extends JsonValue, Need extends ContextNeed> extends DefinitionBase<Shape, Need> {
+    readonly streams: boolean;
+    readonly result: z.ZodType<Result>;
+    readonly progress: z.ZodType<Progress>;
+    load(): Promise<CommandModule<z.output<z.ZodObject<Shape>>, Result, Progress, Need>>;
+}
+export interface RawHttpResponse {
+    readonly status: number;
+    readonly body: AsyncIterable<Uint8Array>;
+}
+export interface RawCommandDefinition<Shape extends z.ZodRawShape, Need extends ContextNeed> extends DefinitionBase<Shape, Need> {
+    load(): Promise<{
+        run(input: z.output<z.ZodObject<Shape>>, context: Contexts[Need]): Promise<RawHttpResponse>;
+    }>;
+}
+export interface CommandRuntime {
+    readonly contexts: ContextResolvers;
+    readonly presentation: Presentation;
+}
+export type Printable = {
+    readonly kind: 'progress';
+    readonly json: JsonValue;
+    readonly always?: boolean;
+    text?(): string;
+} | {
+    readonly kind: 'result';
+    readonly json: JsonValue;
+    readonly exitCode: ExitCode;
+    readonly format?: 'text' | 'json' | null;
+    text(): string;
+} | {
+    readonly kind: 'raw';
+    readonly response: RawHttpResponse;
+} | {
+    readonly kind: 'literal';
+    readonly text: string;
+    readonly exitCode: ExitCode;
+};
+export interface RegisteredCommand {
+    readonly syntax: CommandSyntax;
+    readonly help: CommandHelp;
+    validate(raw: unknown): void;
+    invoke(raw: unknown, runtime: CommandRuntime): AsyncIterable<Printable>;
+}
+export declare function commandHelp(base: Omit<CommandHelp, 'inputSchema' | 'resultSchema' | 'progressSchema'>, schemas: {
+    readonly input: () => JsonValue;
+    readonly result: () => JsonValue;
+    readonly progress: () => JsonValue;
+}): CommandHelp;
+export declare function defineCommand<Shape extends z.ZodRawShape, Result extends JsonValue, Progress extends JsonValue, Need extends ContextNeed>(definition: CommandDefinition<Shape, Result, Progress, Need>): RegisteredCommand;
+export declare function defineRawCommand<Shape extends z.ZodRawShape, Need extends ContextNeed>(definition: RawCommandDefinition<Shape, Need>): RegisteredCommand;
+export {};

package/dist/command.js

@@ -0,0 +1,195 @@
+import { z } from 'zod';
+import { CliError, exitCodeHelp } from './errors.js';
+import { untrustedResult } from './text.js';
+function matchesInputType(schema, type) {
+    if (schema === undefined || typeof schema === 'boolean') {
+        return false;
+    }
+    if (schema.type === 'null') {
+        return true;
+    }
+    if (schema.anyOf) {
+        return schema.anyOf.every((part) => matchesInputType(part, type));
+    }
+    const expected = type === 'string[]' ? 'array' : type;
+    const matches = Array.isArray(schema.type)
+        ? schema.type.includes(expected) &&
+            schema.type.every((value) => value === expected || value === 'null')
+        : schema.type === expected;
+    if (!matches) {
+        return false;
+    }
+    return (type !== 'string[]' ||
+        (!Array.isArray(schema.items) && matchesInputType(schema.items, 'string')));
+}
+function validateMetadata(definition) {
+    const keys = [...definition.arguments, ...definition.flags].map((field) => field.key);
+    const names = definition.flags.flatMap((flag) => flag.type === 'boolean' && flag.negatedName !== null
+        ? [flag.name, flag.negatedName]
+        : [flag.name]);
+    const schemaKeys = Object.keys(definition.input.shape);
+    if (new Set(keys).size !== keys.length ||
+        new Set(names).size !== names.length ||
+        schemaKeys.length !== keys.length ||
+        schemaKeys.some((key) => !keys.includes(key))) {
+        throw new Error('Command arguments and flags must describe each input schema field once.');
+    }
+}
+function inputJsonSchema(definition) {
+    const inputSchema = z.toJSONSchema(definition.input, { io: 'input' });
+    if (definition.flags.some((flag) => !matchesInputType(inputSchema.properties?.[flag.key], flag.type)) ||
+        definition.arguments.some((argument) => !matchesInputType(inputSchema.properties?.[argument.key], argument.many ? 'string[]' : 'string') ||
+            argument.required !==
+                (inputSchema.required?.includes(argument.key) ?? false))) {
+        throw new Error('Command argument and flag types must match their input schema fields.');
+    }
+    return z.json().parse(inputSchema);
+}
+function once(compute) {
+    let cached = null;
+    return () => {
+        cached ??= { value: compute() };
+        return cached.value;
+    };
+}
+export function commandHelp(base, schemas) {
+    const input = once(schemas.input);
+    const result = once(schemas.result);
+    const progress = once(schemas.progress);
+    return {
+        ...base,
+        get inputSchema() {
+            return input();
+        },
+        get resultSchema() {
+            return result();
+        },
+        get progressSchema() {
+            return progress();
+        },
+    };
+}
+function helpBase(definition) {
+    validateMetadata(definition);
+    return {
+        name: definition.name,
+        summary: definition.summary,
+        arguments: definition.arguments,
+        flags: definition.flags,
+        need: definition.need,
+        destructive: definition.destructive,
+        confirmation: definition.confirmation ?? 'before-run',
+        outputException: definition.outputException ?? null,
+        acceptsWorkspace: definition.workspace ?? definition.need === 'workspace',
+        exitCodes: exitCodeHelp.map((entry) => entry.code),
+    };
+}
+function parseInput(definition, raw) {
+    const parsed = definition.input.safeParse(raw);
+    if (!parsed.success) {
+        const custom = parsed.error.issues.find((issue) => issue.code === 'custom');
+        throw new CliError('cli.invalid_arguments', custom === undefined ? {} : { message: custom.message });
+    }
+    return parsed.data;
+}
+function validateValue(schema, raw) {
+    const parsed = schema.safeParse(raw);
+    if (!parsed.success) {
+        throw new CliError('cli.invalid_result');
+    }
+    return parsed.data;
+}
+export function defineCommand(definition) {
+    const help = commandHelp({
+        ...helpBase(definition),
+        streams: definition.streams,
+        output: 'structured',
+    }, {
+        input: () => inputJsonSchema(definition),
+        result: () => z.json().parse(z.toJSONSchema(definition.result)),
+        progress: () => z.json().parse(z.toJSONSchema(definition.progress)),
+    });
+    const eventSchema = z.strictObject({
+        kind: z.enum(['progress', 'result']),
+        value: z.unknown(),
+    });
+    return {
+        syntax: definition,
+        help,
+        validate(raw) {
+            parseInput(definition, raw);
+        },
+        async *invoke(raw, runtime) {
+            const input = parseInput(definition, raw);
+            const context = await runtime.contexts[definition.need]();
+            const handler = await definition.load();
+            const execution = handler.run(input, context);
+            function resultOutput(result) {
+                const literal = handler.literalText?.(result, input);
+                const exitCode = handler.exitCode?.(result) ?? 0;
+                if (literal !== undefined && literal !== null) {
+                    if (definition.outputException !== 'dotenv') {
+                        throw new CliError('cli.invalid_result');
+                    }
+                    return { kind: 'literal', text: literal, exitCode };
+                }
+                return {
+                    kind: 'result',
+                    json: result,
+                    exitCode,
+                    format: handler.outputFormat?.(input) ?? null,
+                    text: () => handler.text(validateValue(definition.result, untrustedResult(result)), input),
+                };
+            }
+            if (!(Symbol.asyncIterator in execution)) {
+                const result = validateValue(definition.result, await execution);
+                yield resultOutput(result);
+                return;
+            }
+            let final = null;
+            for await (const rawEvent of execution) {
+                if (final !== null) {
+                    throw new CliError('cli.invalid_result');
+                }
+                const event = validateValue(eventSchema, rawEvent);
+                if (event.kind === 'progress') {
+                    const progress = validateValue(definition.progress, event.value);
+                    yield {
+                        kind: 'progress',
+                        json: progress,
+                        always: !definition.streams,
+                        text: () => handler.progressText?.(validateValue(definition.progress, untrustedResult(progress))) ?? JSON.stringify(untrustedResult(progress)),
+                    };
+                }
+                else {
+                    final = { value: validateValue(definition.result, event.value) };
+                }
+            }
+            if (final === null) {
+                throw new CliError('cli.invalid_result');
+            }
+            const result = final.value;
+            yield resultOutput(result);
+        },
+    };
+}
+export function defineRawCommand(definition) {
+    const help = commandHelp({ ...helpBase(definition), streams: false, output: 'raw' }, {
+        input: () => inputJsonSchema(definition),
+        result: () => null,
+        progress: () => null,
+    });
+    return {
+        syntax: definition,
+        help,
+        validate(raw) {
+            parseInput(definition, raw);
+        },
+        async *invoke(raw, runtime) {
+            const input = parseInput(definition, raw);
+            const context = await runtime.contexts[definition.need]();
+            const handler = await definition.load();
+            yield { kind: 'raw', response: await handler.run(input, context) };
+        },
+    };
+}

package/dist/commands/api/command.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export declare const apiInputSchema: z.ZodObject<{
+    method: z.ZodEnum<{
+        DELETE: "DELETE";
+        GET: "GET";
+        HEAD: "HEAD";
+        OPTIONS: "OPTIONS";
+        PATCH: "PATCH";
+        POST: "POST";
+        PUT: "PUT";
+    }>;
+    path: z.ZodString;
+    data: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const apiCommand: import("../../command.js").RegisteredCommand;

package/dist/commands/api/command.js

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { defineRawCommand } from '../../command.js';
+export const apiInputSchema = z
+    .strictObject({
+    method: z.enum([
+        'GET',
+        'POST',
+        'PUT',
+        'PATCH',
+        'DELETE',
+        'HEAD',
+        'OPTIONS',
+    ]),
+    path: z.string().min(1),
+    data: z.string().optional(),
+})
+    .refine((input) => input.data === undefined ||
+    (input.method !== 'GET' && input.method !== 'HEAD'), { message: 'GET and HEAD requests cannot include --data.' });
+export const apiCommand = defineRawCommand({
+    name: ['api'],
+    summary: 'Send one API request and print its raw body. Exit 3 for 401, and 1 for other responses outside 2xx. Resource IDs are not checked against a linked workspace.',
+    need: 'account',
+    destructive: false,
+    arguments: [
+        { name: 'method', key: 'method', required: true, many: false },
+        { name: 'path', key: 'path', required: true, many: false },
+    ],
+    flags: [
+        {
+            name: 'data',
+            key: 'data',
+            type: 'string',
+            description: 'JSON request data, or @file.',
+        },
+    ],
+    input: apiInputSchema,
+    load: () => import('./run.js'),
+});

package/dist/commands/api/run.d.ts

@@ -0,0 +1,4 @@
+import type { z } from 'zod';
+import type { AccountContext } from '../../context-types.js';
+import type { apiInputSchema } from './command.js';
+export declare function run(input: z.infer<typeof apiInputSchema>, context: AccountContext): Promise<import("../../command.js").RawHttpResponse>;

package/dist/commands/api/run.js

@@ -0,0 +1,24 @@
+import { resolve } from 'node:path';
+import { CliError } from '../../errors.js';
+export async function run(input, context) {
+    let data = input.data ?? null;
+    if (data?.startsWith('@')) {
+        data = await context.io.files.read(resolve(context.io.host.cwd, data.slice(1)), { signal: context.io.signal, deadline: null });
+        if (data === null) {
+            throw new CliError('cli.invalid_arguments', {
+                message: 'The request data file was not found.',
+            });
+        }
+    }
+    if (data !== null) {
+        try {
+            JSON.parse(data);
+        }
+        catch {
+            throw new CliError('cli.invalid_arguments', {
+                message: 'Request data must be valid JSON.',
+            });
+        }
+    }
+    return context.internal.raw({ method: input.method, path: input.path, data });
+}

package/dist/commands/apps/command.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export declare const listInputSchema: z.ZodObject<{
+    limit: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodString>;
+    all: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const listResultSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        vendor: z.ZodString;
+        type: z.ZodLiteral<"replica">;
+        logoPath: z.ZodString;
+        defaultVersionId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const appsListCommand: import("../../command.js").RegisteredCommand;

package/dist/commands/apps/command.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { defineCommand } from '../../command.js';
+import { pageFlags, pageInput } from '../../resources/schema.js';
+export const listInputSchema = z.strictObject(pageInput);
+export const listResultSchema = z.strictObject({
+    data: z.array(z.strictObject({
+        id: z.string(),
+        name: z.string(),
+        description: z.string(),
+        vendor: z.string(),
+        type: z.literal('replica'),
+        logoPath: z.string(),
+        defaultVersionId: z.string().nullable(),
+    })),
+    nextCursor: z.string().nullable(),
+});
+export const appsListCommand = defineCommand({
+    name: ['apps', 'list'],
+    summary: 'List apps and their default versions.',
+    need: 'account',
+    destructive: false,
+    streams: false,
+    arguments: [],
+    flags: pageFlags,
+    input: listInputSchema,
+    result: listResultSchema,
+    progress: z.never(),
+    load: () => import('./list.js'),
+});

package/dist/commands/apps/list.d.ts

@@ -0,0 +1,8 @@
+import type { z } from 'zod';
+import type { AccountContext } from '../../context-types.js';
+import type { listInputSchema, listResultSchema } from './command.js';
+export declare function run(input: z.infer<typeof listInputSchema>, context: AccountContext): Promise<{
+    data: import("@usestatemachines/sdk").App[];
+    nextCursor: string | null;
+}>;
+export declare function text(result: z.infer<typeof listResultSchema>): string;

package/dist/commands/apps/list.js

@@ -0,0 +1,10 @@
+import { pages } from '../../resources/read.js';
+export async function run(input, context) {
+    const page = await pages(input, (query) => context.sdk.apps.list(query));
+    return { data: page.data, nextCursor: page.nextCursor };
+}
+export function text(result) {
+    return result.data.length === 0
+        ? 'No apps.\n'
+        : `${result.data.map((app) => `${app.id}\t${app.name}\t${app.defaultVersionId ?? '-'}`).join('\n')}\n`;
+}

package/dist/commands/connect/command.d.ts

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+export declare const connectInputSchema: z.ZodObject<{
+    id: z.ZodString;
+    app: z.ZodString;
+    actor: z.ZodOptional<z.ZodString>;
+    as: z.ZodOptional<z.ZodEnum<{
+        env: "env";
+        json: "json";
+    }>>;
+    showSecrets: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const connectResultSchema: z.ZodObject<{
+    environmentId: z.ZodString;
+    appName: z.ZodString;
+    actorId: z.ZodString;
+    token: z.ZodString;
+    services: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        url: z.ZodString;
+        headers: z.ZodRecord<z.ZodString, z.ZodString>;
+        servers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            url: z.ZodString;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    expiresAt: z.ZodString;
+    login: z.ZodNullable<z.ZodObject<{
+        authentication: z.ZodString;
+        url: z.ZodString;
+        parameters: z.ZodRecord<z.ZodString, z.ZodString>;
+        secrets: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const connectCommand: import("../../command.js").RegisteredCommand;

package/dist/commands/connect/command.js

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+import { defineCommand } from '../../command.js';
+import { idArgument } from '../../resources/schema.js';
+export const connectInputSchema = z.strictObject({
+    id: z.string().min(1),
+    app: z.string().regex(/^[a-z][a-z0-9-]{0,39}$/),
+    actor: z.string().min(1).max(255).optional(),
+    as: z.enum(['json', 'env']).optional(),
+    showSecrets: z.boolean().default(false),
+});
+export const connectResultSchema = z.strictObject({
+    environmentId: z.string(),
+    appName: z.string(),
+    actorId: z.string(),
+    token: z.string(),
+    services: z.array(z.strictObject({
+        id: z.string(),
+        url: z.string(),
+        headers: z.record(z.string(), z.string()),
+        servers: z
+            .array(z.strictObject({ name: z.string(), url: z.string() }))
+            .optional(),
+    })),
+    expiresAt: z.string(),
+    login: z
+        .strictObject({
+        authentication: z.string(),
+        url: z.string(),
+        parameters: z.record(z.string(), z.string()),
+        secrets: z.record(z.string(), z.string()),
+    })
+        .nullable(),
+});
+export const connectCommand = defineCommand({
+    name: ['connect'],
+    summary: 'Create credentials for an app in an environment.',
+    need: 'workspace',
+    destructive: false,
+    streams: false,
+    outputException: 'dotenv',
+    arguments: [
+        idArgument,
+        { name: 'app', key: 'app', required: true, many: false },
+    ],
+    flags: [
+        {
+            name: 'actor',
+            key: 'actor',
+            type: 'string',
+            description: 'Connect as this actor.',
+        },
+        {
+            name: 'as',
+            key: 'as',
+            type: 'string',
+            description: 'Print credentials as json, or as env variables such as STATEMACHINES_<APP>_<SERVICE>_URL and STATEMACHINES_<APP>_ACTOR_TOKEN.',
+        },
+        {
+            name: 'show-secrets',
+            key: 'showSecrets',
+            type: 'boolean',
+            negatedName: null,
+            description: 'Show credentials in text output.',
+        },
+    ],
+    input: connectInputSchema,
+    result: connectResultSchema,
+    progress: z.never(),
+    load: () => import('./run.js'),
+});

package/dist/commands/connect/run.d.ts

@@ -0,0 +1,10 @@
+import type { z } from 'zod';
+import type { WorkspaceContext } from '../../context-types.js';
+import type { connectInputSchema, connectResultSchema } from './command.js';
+type Input = z.infer<typeof connectInputSchema>;
+type Result = z.infer<typeof connectResultSchema>;
+export declare function run(input: Input, context: WorkspaceContext): Promise<Result>;
+export declare function outputFormat(input: Input): 'text' | 'json' | null;
+export declare function literalText(result: Result, input: Input): string | null;
+export declare function text(result: Result, input: Input): string;
+export {};

package/dist/commands/connect/run.js

@@ -0,0 +1,71 @@
+import { parseEnv } from 'node:util';
+import { CliError } from '../../errors.js';
+import { credentialVariables } from '../../generated/internal.js';
+import { environment } from '../../resources/read.js';
+export async function run(input, context) {
+    const checked = await environment(context, input.id);
+    const credentials = await checked.connect(input.app, {
+        ...(input.actor === undefined ? {} : { actorId: input.actor }),
+    });
+    return {
+        environmentId: credentials.environmentId,
+        appName: credentials.appName,
+        actorId: credentials.actorId,
+        token: credentials.token,
+        services: credentials.services,
+        expiresAt: credentials.expiresAt.toISOString(),
+        login: credentials.login,
+    };
+}
+export function outputFormat(input) {
+    return input.as === 'env' ? 'text' : input.as === 'json' ? 'json' : null;
+}
+function redactedUrl(value, token) {
+    try {
+        const url = new URL(value);
+        if (url.username !== '') {
+            url.username = '***';
+        }
+        if (url.password !== '') {
+            url.password = '***';
+        }
+        for (const name of new Set(url.searchParams.keys())) {
+            if (/token|key|auth|secret|password|signature|credential/i.test(name)) {
+                url.searchParams.set(name, '***');
+            }
+        }
+        const result = url.toString();
+        return token === ''
+            ? result
+            : [token, encodeURIComponent(token)].reduce((text, secret) => text.replaceAll(secret, '***'), result);
+    }
+    catch {
+        return '[hidden]';
+    }
+}
+function dotenvValue(value) {
+    const quote = ["'", '`', '"'].find((candidate) => !value.includes(candidate) &&
+        parseEnv(`VALUE=${candidate}${value}${candidate}`).VALUE === value);
+    if (quote === undefined || value.includes('\0')) {
+        throw new CliError('cli.invalid_response', {
+            message: 'These credentials cannot be represented as dotenv values. Use --as json.',
+        });
+    }
+    return `${quote}${value}${quote}`;
+}
+export function literalText(result, input) {
+    if (input.as === 'env') {
+        const variables = credentialVariables(result.appName, result.token, result.services);
+        if (new Set(variables.map(([name]) => name)).size !== variables.length) {
+            throw new CliError('cli.invalid_response', {
+                message: 'The credentials have conflicting dotenv names. Use --as json.',
+            });
+        }
+        return `${variables.map(([name, value]) => `${name}=${dotenvValue(value)}`).join('\n')}\n`;
+    }
+    return null;
+}
+export function text(result, input) {
+    const services = result.services.map(({ id, url }) => `${id}: ${input.showSecrets ? url : redactedUrl(url, result.token)}\n`);
+    return `${services.join('')}Token: ${input.showSecrets ? result.token : '[hidden]'}\n`;
+}