@usestatemachines/cli 0.0.0-stage → 0.1.0

package/dist/commands/requests/list.js

@@ -0,0 +1,25 @@
+import { environment, pages, requestResult } from '../../resources/read.js';
+export async function run(input, context) {
+    await environment(context, input.environmentId);
+    const status = input.status;
+    const filter = status === undefined
+        ? {}
+        : status === '2xx' ||
+            status === '3xx' ||
+            status === '4xx' ||
+            status === '5xx'
+            ? { statusClass: status }
+            : { responseStatus: Number(status) };
+    const page = await pages(input, (query) => context.sdk.requests.list({
+        ...query,
+        ...filter,
+        environmentId: input.environmentId,
+        ...(input.app === undefined ? {} : { appName: input.app }),
+    }));
+    return { data: page.data.map(requestResult), nextCursor: page.nextCursor };
+}
+export function text(result) {
+    return result.data.length === 0
+        ? 'No requests.\n'
+        : `${result.data.map((value) => `${value.id}\t${value.method}\t${value.path}\t${value.responseStatus}\t${value.durationMs} ms`).join('\n')}\n`;
+}

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

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+export declare const createInputSchema: z.ZodObject<{
+    environmentId: z.ZodString;
+    wait: z.ZodDefault<z.ZodBoolean>;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const snapshotsCreateCommand: import("../../command.js").RegisteredCommand;
+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;
+        workspaceId: z.ZodString;
+        environmentId: z.ZodString;
+        environmentName: z.ZodNullable<z.ZodString>;
+        name: z.ZodNullable<z.ZodString>;
+        status: z.ZodString;
+        failure: z.ZodNullable<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strict>>;
+        sizeBytes: z.ZodNullable<z.ZodNumber>;
+        apps: z.ZodArray<z.ZodObject<{
+            appId: z.ZodString;
+            name: z.ZodString;
+            version: z.ZodString;
+            versionId: z.ZodString;
+            setup: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            services: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            sizeBytes: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strict>>;
+        createdBy: z.ZodObject<{
+            id: z.ZodNullable<z.ZodString>;
+            name: z.ZodNullable<z.ZodString>;
+            type: z.ZodString;
+        }, z.core.$strict>;
+        createdAt: z.ZodString;
+        readyAt: z.ZodNullable<z.ZodString>;
+        deletedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const snapshotsListCommand: import("../../command.js").RegisteredCommand;
+export declare const snapshotsGetCommand: import("../../command.js").RegisteredCommand;
+export declare const snapshotsDeleteCommand: import("../../command.js").RegisteredCommand;

package/dist/commands/snapshots/command.js

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+import { defineCommand } from '../../command.js';
+import { idArgument, idempotencyKeySchema, idInputSchema, pageFlags, pageInput, snapshotResultSchema, waitFlag, } from '../../resources/schema.js';
+export const createInputSchema = z.strictObject({
+    environmentId: z.string().min(1),
+    wait: z.boolean().default(false),
+    idempotencyKey: idempotencyKeySchema,
+});
+export const snapshotsCreateCommand = defineCommand({
+    name: ['snapshots', 'create'],
+    summary: 'Create a snapshot of an environment.',
+    need: 'workspace',
+    destructive: false,
+    streams: false,
+    arguments: [
+        {
+            name: 'environment-id',
+            key: 'environmentId',
+            required: true,
+            many: false,
+        },
+    ],
+    flags: [
+        waitFlag,
+        {
+            name: 'idempotency-key',
+            key: 'idempotencyKey',
+            type: 'string',
+            description: 'Reuse a key to retry the same create.',
+        },
+    ],
+    input: createInputSchema,
+    result: snapshotResultSchema,
+    progress: z.never(),
+    load: () => import('./create.js'),
+});
+export const listInputSchema = z.strictObject(pageInput);
+export const listResultSchema = z.strictObject({
+    data: z.array(snapshotResultSchema),
+    nextCursor: z.string().nullable(),
+});
+export const snapshotsListCommand = defineCommand({
+    name: ['snapshots', 'list'],
+    summary: 'List snapshots in the workspace.',
+    need: 'workspace',
+    destructive: false,
+    streams: false,
+    arguments: [],
+    flags: pageFlags,
+    input: listInputSchema,
+    result: listResultSchema,
+    progress: z.never(),
+    load: () => import('./list.js'),
+});
+export const snapshotsGetCommand = defineCommand({
+    name: ['snapshots', 'get'],
+    summary: 'Show a snapshot.',
+    need: 'workspace',
+    destructive: false,
+    streams: false,
+    arguments: [idArgument],
+    flags: [],
+    input: idInputSchema,
+    result: snapshotResultSchema,
+    progress: z.never(),
+    load: () => import('./get.js'),
+});
+export const snapshotsDeleteCommand = defineCommand({
+    name: ['snapshots', 'delete'],
+    summary: 'Delete a snapshot.',
+    need: 'workspace',
+    destructive: true,
+    streams: false,
+    arguments: [idArgument],
+    flags: [],
+    input: idInputSchema,
+    result: snapshotResultSchema,
+    progress: z.never(),
+    load: () => import('./delete.js'),
+});

package/dist/commands/snapshots/create.d.ts

@@ -0,0 +1,7 @@
+import type { z } from 'zod';
+import type { WorkspaceContext } from '../../context-types.js';
+import { resourceText } from '../../resources/read.js';
+import type { snapshotResultSchema } from '../../resources/schema.js';
+import type { createInputSchema } from './command.js';
+export declare function run(input: z.infer<typeof createInputSchema>, context: WorkspaceContext): Promise<z.infer<typeof snapshotResultSchema>>;
+export declare const text: typeof resourceText;

package/dist/commands/snapshots/create.js

@@ -0,0 +1,26 @@
+import { createKey, resourceError } from '../../resources/create.js';
+import { environment, resourceText, snapshotResult, } from '../../resources/read.js';
+export async function run(input, context) {
+    await environment(context, input.environmentId);
+    const idempotencyKey = createKey(input.idempotencyKey, context);
+    let id;
+    try {
+        const created = await context.sdk.snapshots.create({ environmentId: input.environmentId }, { wait: false, idempotencyKey, signal: context.io.signal });
+        id = created.id;
+        const result = input.wait
+            ? await context.sdk.snapshots.wait(id, {
+                status: 'ready',
+                signal: context.io.signal,
+            })
+            : created;
+        return snapshotResult(result);
+    }
+    catch (cause) {
+        throw await resourceError(cause, context, {
+            resource: 'snapshot',
+            idempotencyKey,
+            ...(id === undefined ? {} : { id }),
+        });
+    }
+}
+export const text = resourceText;

package/dist/commands/snapshots/delete.d.ts

@@ -0,0 +1,34 @@
+import type { z } from 'zod';
+import type { WorkspaceContext } from '../../context-types.js';
+import type { idInputSchema, snapshotResultSchema } from '../../resources/schema.js';
+export declare function run(input: z.infer<typeof idInputSchema>, context: WorkspaceContext): Promise<{
+    id: string;
+    workspaceId: string;
+    environmentId: string;
+    environmentName: string | null;
+    name: string | null;
+    status: string;
+    failure: {
+        code: string;
+        message: string;
+    } | null;
+    sizeBytes: number | null;
+    apps: {
+        appId: string;
+        name: string;
+        version: string;
+        versionId: string;
+        setup: Record<string, z.JSONType>;
+        services: Record<string, z.JSONType>;
+        sizeBytes: number | null;
+    }[];
+    createdBy: {
+        id: string | null;
+        name: string | null;
+        type: string;
+    };
+    createdAt: string;
+    readyAt: string | null;
+    deletedAt: string | null;
+}>;
+export declare function text(result: z.infer<typeof snapshotResultSchema>): string;

package/dist/commands/snapshots/delete.js

@@ -0,0 +1,8 @@
+import { snapshot, snapshotResult } from '../../resources/read.js';
+export async function run(input, context) {
+    await snapshot(context, input.id);
+    return snapshotResult(await context.sdk.snapshots.delete(input.id));
+}
+export function text(result) {
+    return `Deleted ${result.id}\n`;
+}

package/dist/commands/snapshots/get.d.ts

@@ -0,0 +1,35 @@
+import type { z } from 'zod';
+import type { WorkspaceContext } from '../../context-types.js';
+import { resourceText } from '../../resources/read.js';
+import type { idInputSchema } from '../../resources/schema.js';
+export declare function run(input: z.infer<typeof idInputSchema>, context: WorkspaceContext): Promise<{
+    id: string;
+    workspaceId: string;
+    environmentId: string;
+    environmentName: string | null;
+    name: string | null;
+    status: string;
+    failure: {
+        code: string;
+        message: string;
+    } | null;
+    sizeBytes: number | null;
+    apps: {
+        appId: string;
+        name: string;
+        version: string;
+        versionId: string;
+        setup: Record<string, z.JSONType>;
+        services: Record<string, z.JSONType>;
+        sizeBytes: number | null;
+    }[];
+    createdBy: {
+        id: string | null;
+        name: string | null;
+        type: string;
+    };
+    createdAt: string;
+    readyAt: string | null;
+    deletedAt: string | null;
+}>;
+export declare const text: typeof resourceText;

package/dist/commands/snapshots/get.js

@@ -0,0 +1,5 @@
+import { resourceText, snapshot, snapshotResult, } from '../../resources/read.js';
+export async function run(input, context) {
+    return snapshotResult(await snapshot(context, input.id));
+}
+export const text = resourceText;

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

@@ -0,0 +1,37 @@
+import type { z } from 'zod';
+import type { WorkspaceContext } from '../../context-types.js';
+import type { listInputSchema, listResultSchema } from './command.js';
+export declare function run(input: z.infer<typeof listInputSchema>, context: WorkspaceContext): Promise<{
+    data: {
+        id: string;
+        workspaceId: string;
+        environmentId: string;
+        environmentName: string | null;
+        name: string | null;
+        status: string;
+        failure: {
+            code: string;
+            message: string;
+        } | null;
+        sizeBytes: number | null;
+        apps: {
+            appId: string;
+            name: string;
+            version: string;
+            versionId: string;
+            setup: Record<string, z.JSONType>;
+            services: Record<string, z.JSONType>;
+            sizeBytes: number | null;
+        }[];
+        createdBy: {
+            id: string | null;
+            name: string | null;
+            type: string;
+        };
+        createdAt: string;
+        readyAt: string | null;
+        deletedAt: string | null;
+    }[];
+    nextCursor: string | null;
+}>;
+export declare function text(result: z.infer<typeof listResultSchema>): string;

package/dist/commands/snapshots/list.js

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

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

@@ -0,0 +1 @@
+export declare const unlinkCommand: import("../../command.js").RegisteredCommand;

package/dist/commands/unlink/command.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { defineCommand } from '../../command.js';
+export const unlinkCommand = defineCommand({
+    name: ['unlink'],
+    summary: 'Remove this repository’s workspace link.',
+    need: 'public',
+    destructive: false,
+    streams: false,
+    arguments: [],
+    flags: [],
+    input: z.strictObject({}),
+    result: z.strictObject({ path: z.string().nullable() }),
+    progress: z.never(),
+    load: () => import('./run.js'),
+});

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

@@ -0,0 +1,7 @@
+import type { PublicContext } from '../../context-types.js';
+export declare function run(_input: object, context: PublicContext): Promise<{
+    path: string | null;
+}>;
+export declare function text(result: {
+    path: string | null;
+}): string;

package/dist/commands/unlink/run.js

@@ -0,0 +1,8 @@
+export async function run(_input, context) {
+    return context.projects.unlink();
+}
+export function text(result) {
+    return result.path === null
+        ? 'This repository is not linked.\n'
+        : 'Repository unlinked.\n';
+}

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

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+export declare const whoamiResultSchema: z.ZodObject<{
+    user: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        email: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    organization: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        role: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    credential: z.ZodObject<{
+        kind: z.ZodString;
+        id: z.ZodNullable<z.ZodString>;
+        expiresAt: z.ZodNullable<z.ZodString>;
+        idleExpiresAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    profile: z.ZodNullable<z.ZodString>;
+    origin: z.ZodString;
+    permissions: z.ZodArray<z.ZodString>;
+    workspace: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        source: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const whoamiCommand: import("../../command.js").RegisteredCommand;

package/dist/commands/whoami/command.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { defineCommand } from '../../command.js';
+export const whoamiResultSchema = z.strictObject({
+    user: z
+        .strictObject({
+        id: z.string(),
+        name: z.string().nullable(),
+        email: z.string().nullable(),
+    })
+        .nullable(),
+    organization: z
+        .strictObject({
+        id: z.string(),
+        name: z.string(),
+        role: z.string().nullable(),
+    })
+        .nullable(),
+    credential: z.strictObject({
+        kind: z.string(),
+        id: z.string().nullable(),
+        expiresAt: z.string().nullable(),
+        idleExpiresAt: z.string().nullable(),
+    }),
+    profile: z.string().nullable(),
+    origin: z.string(),
+    permissions: z.array(z.string()),
+    workspace: z
+        .strictObject({ id: z.string(), name: z.string(), source: z.string() })
+        .nullable(),
+});
+export const whoamiCommand = defineCommand({
+    name: ['whoami'],
+    summary: 'Show the active credential, organization, and workspace.',
+    need: 'account',
+    workspace: true,
+    destructive: false,
+    streams: false,
+    arguments: [],
+    flags: [],
+    input: z.strictObject({}),
+    result: whoamiResultSchema,
+    progress: z.never(),
+    load: () => import('./run.js'),
+});

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

@@ -0,0 +1,5 @@
+import type { z } from 'zod';
+import type { AccountContext } from '../../context-types.js';
+import type { whoamiResultSchema } from './command.js';
+export declare function run(_input: object, context: AccountContext): Promise<z.infer<typeof whoamiResultSchema>>;
+export declare function text(value: z.infer<typeof whoamiResultSchema>): string;

package/dist/commands/whoami/run.js

@@ -0,0 +1,39 @@
+export async function run(_input, context) {
+    const me = await context.sdk.me();
+    const workspace = await context.resolveWorkspace();
+    const credential = me.credential;
+    return {
+        user: me.user === null
+            ? null
+            : { id: me.user.id, name: me.user.name, email: me.user.email },
+        organization: me.organization === null
+            ? null
+            : {
+                id: me.organization.id,
+                name: me.organization.name,
+                role: me.organization.role,
+            },
+        credential: {
+            kind: credential.kind,
+            id: 'id' in credential && typeof credential.id === 'string'
+                ? credential.id
+                : null,
+            expiresAt: 'expiresAt' in credential && credential.expiresAt instanceof Date
+                ? credential.expiresAt.toISOString()
+                : null,
+            idleExpiresAt: 'idleExpiresAt' in credential &&
+                credential.idleExpiresAt instanceof Date
+                ? credential.idleExpiresAt.toISOString()
+                : null,
+        },
+        profile: context.account.kind === 'cli-token' ? context.account.profile : null,
+        origin: context.account.origin,
+        permissions: me.permissions,
+        workspace: workspace === null
+            ? null
+            : { id: workspace.id, name: workspace.name, source: workspace.source },
+    };
+}
+export function text(value) {
+    return `${value.user?.email ?? value.credential.kind}\nOrganization: ${value.organization?.name ?? 'None'}\nCredential: ${value.credential.kind}\nOrigin: ${value.origin}\nWorkspace: ${value.workspace === null ? 'Not selected' : `${value.workspace.name} (${value.workspace.source})`}\n`;
+}

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

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+export declare const workspaceResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    createdAt: z.ZodString;
+    archivedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+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;
+        createdAt: z.ZodString;
+        archivedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const workspacesListCommand: import("../../command.js").RegisteredCommand;
+export declare const useInputSchema: z.ZodObject<{
+    workspace: z.ZodString;
+}, z.core.$strict>;
+export declare const useResultSchema: z.ZodObject<{
+    profile: z.ZodString;
+    workspace: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const workspacesUseCommand: import("../../command.js").RegisteredCommand;

package/dist/commands/workspaces/command.js

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+import { defineCommand } from '../../command.js';
+export const workspaceResultSchema = z.strictObject({
+    id: z.string(),
+    name: z.string(),
+    createdAt: z.string(),
+    archivedAt: z.string().nullable(),
+});
+export const listInputSchema = z.strictObject({
+    limit: z
+        .string()
+        .regex(/^[1-9]\d*$/)
+        .optional(),
+    cursor: z.string().min(1).optional(),
+    all: z.boolean().default(false),
+});
+export const listResultSchema = z.strictObject({
+    data: z.array(workspaceResultSchema),
+    nextCursor: z.string().nullable(),
+});
+export const workspacesListCommand = defineCommand({
+    name: ['workspaces', 'list'],
+    summary: 'List accessible workspaces.',
+    need: 'account',
+    destructive: false,
+    streams: false,
+    arguments: [],
+    flags: [
+        {
+            name: 'limit',
+            key: 'limit',
+            type: 'string',
+            description: 'Maximum results per page.',
+        },
+        {
+            name: 'cursor',
+            key: 'cursor',
+            type: 'string',
+            description: 'Continue from this cursor.',
+        },
+        {
+            name: 'all',
+            key: 'all',
+            type: 'boolean',
+            negatedName: null,
+            description: 'Read every page.',
+        },
+    ],
+    input: listInputSchema,
+    result: listResultSchema,
+    progress: z.never(),
+    load: () => import('./list.js'),
+});
+export const useInputSchema = z.strictObject({ workspace: z.string().min(1) });
+export const useResultSchema = z.strictObject({
+    profile: z.string(),
+    workspace: z.strictObject({ id: z.string(), name: z.string() }),
+});
+export const workspacesUseCommand = defineCommand({
+    name: ['workspaces', 'use'],
+    summary: 'Set the profile’s default workspace.',
+    need: 'account',
+    destructive: false,
+    streams: false,
+    arguments: [
+        { name: 'workspace', key: 'workspace', required: true, many: false },
+    ],
+    flags: [],
+    input: useInputSchema,
+    result: useResultSchema,
+    progress: z.never(),
+    load: () => import('./use.js'),
+});

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

@@ -0,0 +1,5 @@
+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<z.infer<typeof listResultSchema>>;
+export declare function text(result: z.infer<typeof listResultSchema>): string;

package/dist/commands/workspaces/list.js

@@ -0,0 +1,42 @@
+import { CliError } from '../../errors.js';
+export async function run(input, context) {
+    const limit = input.limit === undefined ? undefined : Number(input.limit);
+    if (limit !== undefined && (!Number.isSafeInteger(limit) || limit > 100)) {
+        throw new CliError('cli.invalid_arguments', {
+            message: 'Use a limit between 1 and 100.',
+        });
+    }
+    const data = [];
+    let cursor = input.cursor;
+    let nextCursor = null;
+    const seen = new Set();
+    do {
+        const page = await context.sdk.workspaces.list({
+            ...(limit === undefined ? {} : { limit }),
+            ...(cursor === undefined ? {} : { cursor }),
+        });
+        data.push(...page.data.map((workspace) => ({
+            id: workspace.id,
+            name: workspace.name,
+            createdAt: workspace.createdAt.toISOString(),
+            archivedAt: workspace.archivedAt?.toISOString() ?? null,
+        })));
+        nextCursor = page.nextCursor;
+        if (!input.all || nextCursor === null) {
+            break;
+        }
+        if (seen.has(nextCursor)) {
+            throw new CliError('cli.invalid_response');
+        }
+        seen.add(nextCursor);
+        cursor = nextCursor;
+    } while (input.all && nextCursor !== null);
+    return { data, nextCursor };
+}
+export function text(result) {
+    return result.data.length === 0
+        ? 'No workspaces.\n'
+        : `${result.data
+            .map((workspace) => `${workspace.id}\t${workspace.name}`)
+            .join('\n')}\n`;
+}

package/dist/commands/workspaces/use.d.ts

@@ -0,0 +1,5 @@
+import type { z } from 'zod';
+import type { AccountContext } from '../../context-types.js';
+import type { useInputSchema, useResultSchema } from './command.js';
+export declare function run(input: z.infer<typeof useInputSchema>, context: AccountContext): Promise<z.infer<typeof useResultSchema>>;
+export declare function text(value: z.infer<typeof useResultSchema>): string;

package/dist/commands/workspaces/use.js

@@ -0,0 +1,18 @@
+import { CliError } from '../../errors.js';
+export async function run(input, context) {
+    if (context.account.kind !== 'cli-token') {
+        throw new CliError('cli.invalid_arguments', {
+            message: 'A workspace key has a fixed workspace. Sign in to set a profile’s default.',
+        });
+    }
+    const workspace = await context.findWorkspace(input.workspace);
+    await context.accounts.setWorkspace({
+        account: context.account,
+        workspace: workspace.id,
+        mode: 'replace',
+    });
+    return { profile: context.account.profile, workspace };
+}
+export function text(value) {
+    return `Default workspace: ${value.workspace.name}\n`;
+}