@usestatemachines/cli 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const doctorInputSchema: z.ZodObject<{
+    offline: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const doctorCheckSchema: z.ZodObject<{
+    name: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        ok: "ok";
+        skipped: "skipped";
+        warning: "warning";
+    }>;
+    message: z.ZodString;
+    fix: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const doctorResultSchema: z.ZodObject<{
+    checks: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        status: z.ZodEnum<{
+            failed: "failed";
+            ok: "ok";
+            skipped: "skipped";
+            warning: "warning";
+        }>;
+        message: z.ZodString;
+        fix: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const doctorCommand: import("../../command.js").RegisteredCommand;

package/dist/commands/doctor/command.js

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { defineCommand } from '../../command.js';
+export const doctorInputSchema = z.strictObject({
+    offline: z.boolean().default(false),
+});
+export const doctorCheckSchema = z.strictObject({
+    name: z.string(),
+    status: z.enum(['ok', 'warning', 'failed', 'skipped']),
+    message: z.string(),
+    fix: z.string().nullable(),
+});
+export const doctorResultSchema = z.strictObject({
+    checks: z.array(doctorCheckSchema),
+});
+export const doctorCommand = defineCommand({
+    name: ['doctor'],
+    summary: 'Check credentials, workspace access, and local configuration.',
+    need: 'public',
+    workspace: true,
+    destructive: false,
+    streams: false,
+    arguments: [],
+    flags: [
+        {
+            name: 'offline',
+            key: 'offline',
+            type: 'boolean',
+            negatedName: null,
+            description: 'Skip checks that need a network connection.',
+        },
+    ],
+    input: doctorInputSchema,
+    result: doctorResultSchema,
+    progress: z.never(),
+    load: () => import('./run.js'),
+});

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

@@ -0,0 +1,13 @@
+import type { z } from 'zod';
+import type { PublicContext } from '../../context-types.js';
+import type { doctorInputSchema, doctorResultSchema } from './command.js';
+export declare function run(input: z.infer<typeof doctorInputSchema>, context: PublicContext): Promise<{
+    checks: {
+        name: string;
+        status: "failed" | "ok" | "skipped" | "warning";
+        message: string;
+        fix: string | null;
+    }[];
+}>;
+export declare function text(result: z.infer<typeof doctorResultSchema>): string;
+export declare function exitCode(result: z.infer<typeof doctorResultSchema>): 0 | 1;

package/dist/commands/doctor/run.js

@@ -0,0 +1,12 @@
+import { runDoctor } from '../../doctor.js';
+export function run(input, context) {
+    return runDoctor(context, input);
+}
+export function text(result) {
+    return `${result.checks
+        .map((check) => `${check.status}: ${check.name}: ${check.message}${check.fix === null ? '' : ` ${check.fix}`}`)
+        .join('\n')}\n`;
+}
+export function exitCode(result) {
+    return result.checks.some((check) => check.status === 'failed') ? 1 : 0;
+}

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

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+export declare const envPullInputSchema: z.ZodObject<{
+    file: z.ZodDefault<z.ZodString>;
+}, z.core.$strict>;
+export declare const envPullCommand: import("../../command.js").RegisteredCommand;

package/dist/commands/env/command.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { defineCommand } from '../../command.js';
+import { envPullResultSchema } from '../../program-types.js';
+export const envPullInputSchema = z.strictObject({
+    file: z.string().min(1).default('.env.local'),
+});
+export const envPullCommand = defineCommand({
+    name: ['env', 'pull'],
+    summary: 'Write a workspace key to a dotenv file. Replaces the previous key for this repository and workspace, even when the file changes.',
+    need: 'workspace',
+    destructive: false,
+    streams: false,
+    arguments: [{ name: 'file', key: 'file', required: false, many: false }],
+    flags: [],
+    input: envPullInputSchema,
+    result: envPullResultSchema,
+    progress: z.never(),
+    load: () => import('./pull.js'),
+});

package/dist/commands/env/pull.d.ts

@@ -0,0 +1,6 @@
+import type { z } from 'zod';
+import type { WorkspaceContext } from '../../context-types.js';
+import type { EnvPullResult } from '../../program-types.js';
+import type { envPullInputSchema } from './command.js';
+export declare function run(input: z.infer<typeof envPullInputSchema>, context: WorkspaceContext): Promise<EnvPullResult>;
+export declare function text(result: EnvPullResult): string;

package/dist/commands/env/pull.js

@@ -0,0 +1,6 @@
+export async function run(input, context) {
+    return context.programs.pullEnvironment(input.file);
+}
+export function text(result) {
+    return `Wrote workspace key to ${result.path}. Expires ${result.expiresAt}.${result.pendingRevocation ? ' Previous key revocation is pending.' : ''}\n`;
+}

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

@@ -0,0 +1,121 @@
+import { z } from 'zod';
+export declare const createInputSchema: z.ZodObject<{
+    app: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    snapshot: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    label: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    timeLimit: z.ZodOptional<z.ZodString>;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
+    wait: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const environmentsCreateCommand: 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>;
+    status: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        deleted: "deleted";
+        failed: "failed";
+        running: "running";
+        starting: "starting";
+    }>>>;
+    label: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const listResultSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        workspaceId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        labels: z.ZodRecord<z.ZodString, z.ZodString>;
+        status: z.ZodString;
+        reason: z.ZodNullable<z.ZodString>;
+        failure: z.ZodNullable<z.ZodObject<{
+            appName: z.ZodString;
+            code: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strict>>;
+        timeLimitMinutes: z.ZodNumber;
+        tokenInUrl: z.ZodBoolean;
+        snapshotId: z.ZodNullable<z.ZodString>;
+        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>;
+            url: z.ZodString;
+        }, 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;
+        startedAt: z.ZodNullable<z.ZodString>;
+        deletedAt: z.ZodNullable<z.ZodString>;
+        expiresAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const environmentsListCommand: import("../../command.js").RegisteredCommand;
+export declare const environmentsGetCommand: import("../../command.js").RegisteredCommand;
+export declare const waitInputSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodDefault<z.ZodEnum<{
+        deleted: "deleted";
+        failed: "failed";
+        running: "running";
+        starting: "starting";
+    }>>;
+    timeout: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const environmentsWaitCommand: import("../../command.js").RegisteredCommand;
+export declare const deleteInputSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    label: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const deleteResultSchema: z.ZodObject<{
+    data: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        workspaceId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        labels: z.ZodRecord<z.ZodString, z.ZodString>;
+        status: z.ZodString;
+        reason: z.ZodNullable<z.ZodString>;
+        failure: z.ZodNullable<z.ZodObject<{
+            appName: z.ZodString;
+            code: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strict>>;
+        timeLimitMinutes: z.ZodNumber;
+        tokenInUrl: z.ZodBoolean;
+        snapshotId: z.ZodNullable<z.ZodString>;
+        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>;
+            url: z.ZodString;
+        }, 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;
+        startedAt: z.ZodNullable<z.ZodString>;
+        deletedAt: z.ZodNullable<z.ZodString>;
+        expiresAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const deleteProgressSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    event: z.ZodLiteral<"matches">;
+    ids: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    event: z.ZodLiteral<"deleted">;
+    id: z.ZodString;
+}, z.core.$strict>], "event">;
+export declare const environmentsDeleteCommand: import("../../command.js").RegisteredCommand;

package/dist/commands/environments/command.js

@@ -0,0 +1,170 @@
+import { z } from 'zod';
+import { defineCommand } from '../../command.js';
+import { acceptedSchema, environmentResultSchema, environmentStatusSchema, idArgument, idempotencyKeySchema, idInputSchema, labelFlag, labelInputSchema, pageFlags, pageInput, waitFlag, } from '../../resources/schema.js';
+export const createInputSchema = z
+    .strictObject({
+    app: z
+        .array(z.string().regex(/^[a-z][a-z0-9-]{1,39}$/))
+        .min(1)
+        .max(10)
+        .optional(),
+    snapshot: z.string().min(1).optional(),
+    name: z.string().trim().min(1).max(120).optional(),
+    label: labelInputSchema,
+    timeLimit: z
+        .string()
+        .regex(/^[1-9]\d*$/)
+        .refine((value) => Number(value) <= 1440)
+        .optional(),
+    idempotencyKey: idempotencyKeySchema,
+    wait: z.boolean().optional(),
+})
+    .refine((input) => (input.app === undefined) !== (input.snapshot === undefined));
+export const environmentsCreateCommand = defineCommand({
+    name: ['environments', 'create'],
+    summary: 'Create an environment.',
+    need: 'workspace',
+    destructive: false,
+    streams: true,
+    arguments: [],
+    flags: [
+        {
+            name: 'app',
+            key: 'app',
+            type: 'string[]',
+            description: 'Include an app. Repeat for more apps.',
+        },
+        {
+            name: 'snapshot',
+            key: 'snapshot',
+            type: 'string',
+            description: 'Restore a snapshot instead of choosing apps.',
+        },
+        {
+            name: 'name',
+            key: 'name',
+            type: 'string',
+            description: 'Name the environment.',
+        },
+        labelFlag,
+        {
+            name: 'time-limit',
+            key: 'timeLimit',
+            type: 'string',
+            description: 'Delete the environment after this many minutes.',
+        },
+        {
+            name: 'idempotency-key',
+            key: 'idempotencyKey',
+            type: 'string',
+            description: 'Reuse a key to retry the same create.',
+        },
+        waitFlag,
+    ],
+    input: createInputSchema,
+    result: environmentResultSchema,
+    progress: acceptedSchema,
+    load: () => import('./create.js'),
+});
+export const listInputSchema = z.strictObject({
+    ...pageInput,
+    status: z.array(environmentStatusSchema).max(5).optional(),
+    label: labelInputSchema,
+});
+export const listResultSchema = z.strictObject({
+    data: z.array(environmentResultSchema),
+    nextCursor: z.string().nullable(),
+});
+export const environmentsListCommand = defineCommand({
+    name: ['environments', 'list'],
+    summary: 'List environments in the workspace.',
+    need: 'workspace',
+    destructive: false,
+    streams: false,
+    arguments: [],
+    flags: [
+        ...pageFlags,
+        {
+            name: 'status',
+            key: 'status',
+            type: 'string[]',
+            description: 'Match a status. Repeat for more statuses.',
+        },
+        labelFlag,
+    ],
+    input: listInputSchema,
+    result: listResultSchema,
+    progress: z.never(),
+    load: () => import('./list.js'),
+});
+export const environmentsGetCommand = defineCommand({
+    name: ['environments', 'get'],
+    summary: 'Show an environment.',
+    need: 'workspace',
+    destructive: false,
+    streams: false,
+    arguments: [idArgument],
+    flags: [],
+    input: idInputSchema,
+    result: environmentResultSchema,
+    progress: z.never(),
+    load: () => import('./get.js'),
+});
+export const waitInputSchema = idInputSchema.extend({
+    status: environmentStatusSchema.default('running'),
+    timeout: z
+        .string()
+        .regex(/^[1-9]\d*$/)
+        .refine((value) => Number.isSafeInteger(Number(value) * 1000))
+        .optional(),
+});
+export const environmentsWaitCommand = defineCommand({
+    name: ['environments', 'wait'],
+    summary: 'Wait for an environment status.',
+    need: 'workspace',
+    destructive: false,
+    streams: false,
+    arguments: [idArgument],
+    flags: [
+        {
+            name: 'status',
+            key: 'status',
+            type: 'string',
+            description: 'Wait for this status. Defaults to running.',
+        },
+        {
+            name: 'timeout',
+            key: 'timeout',
+            type: 'string',
+            description: 'Stop waiting after this many seconds.',
+        },
+    ],
+    input: waitInputSchema,
+    result: environmentResultSchema,
+    progress: z.never(),
+    load: () => import('./wait.js'),
+});
+export const deleteInputSchema = z
+    .strictObject({ id: z.string().min(1).optional(), label: labelInputSchema })
+    .refine((input) => (input.id !== undefined) !== input.label.length > 0);
+export const deleteResultSchema = z.strictObject({
+    data: z.array(environmentResultSchema),
+});
+export const deleteProgressSchema = z.discriminatedUnion('event', [
+    z.strictObject({ event: z.literal('matches'), ids: z.array(z.string()) }),
+    z.strictObject({ event: z.literal('deleted'), id: z.string() }),
+]);
+export const environmentsDeleteCommand = defineCommand({
+    name: ['environments', 'delete'],
+    summary: 'Delete an environment or every environment with matching labels.',
+    need: 'workspace',
+    destructive: true,
+    confirmation: 'handler',
+    streams: false,
+    arguments: [{ ...idArgument, required: false }],
+    flags: [labelFlag],
+    input: deleteInputSchema,
+    result: deleteResultSchema,
+    progress: deleteProgressSchema,
+    load: () => import('./delete.js'),
+});

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

@@ -0,0 +1,9 @@
+import type { z } from 'zod';
+import type { CommandEvent } from '../../command.js';
+import type { WorkspaceContext } from '../../context-types.js';
+import { resourceText } from '../../resources/read.js';
+import type { acceptedSchema, environmentResultSchema } from '../../resources/schema.js';
+import type { createInputSchema } from './command.js';
+export declare function run(input: z.infer<typeof createInputSchema>, context: WorkspaceContext): AsyncIterable<CommandEvent<z.infer<typeof environmentResultSchema>, z.infer<typeof acceptedSchema>>>;
+export declare const text: typeof resourceText;
+export declare function progressText(progress: z.infer<typeof acceptedSchema>): string;

package/dist/commands/environments/create.js

@@ -0,0 +1,42 @@
+import { createKey, labels, resourceError } from '../../resources/create.js';
+import { environmentResult, resourceText, snapshot, } from '../../resources/read.js';
+export async function* run(input, context) {
+    const parsedLabels = labels(input.label);
+    if (input.snapshot !== undefined) {
+        await snapshot(context, input.snapshot);
+    }
+    const idempotencyKey = createKey(input.idempotencyKey, context);
+    let id;
+    try {
+        const created = await context.sdk.environments.create({
+            workspaceId: context.workspace.id,
+            ...(input.app === undefined ? {} : { apps: input.app }),
+            ...(input.snapshot === undefined ? {} : { snapshotId: input.snapshot }),
+            ...(input.name === undefined ? {} : { name: input.name }),
+            labels: parsedLabels,
+            ...(input.timeLimit === undefined
+                ? {}
+                : { timeLimitMinutes: Number(input.timeLimit) }),
+        }, { wait: false, idempotencyKey, signal: context.io.signal });
+        id = created.id;
+        yield { kind: 'progress', value: { event: 'accepted', id } };
+        const result = (input.wait ?? context.presentation.mode === 'interactive')
+            ? await context.sdk.environments.wait(id, {
+                status: 'running',
+                signal: context.io.signal,
+            })
+            : created;
+        yield { kind: 'result', value: environmentResult(result) };
+    }
+    catch (cause) {
+        throw await resourceError(cause, context, {
+            resource: 'environment',
+            idempotencyKey,
+            ...(id === undefined ? {} : { id }),
+        });
+    }
+}
+export const text = resourceText;
+export function progressText(progress) {
+    return `Environment accepted: ${progress.id}`;
+}

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

@@ -0,0 +1,7 @@
+import type { z } from 'zod';
+import type { CommandEvent } from '../../command.js';
+import type { WorkspaceContext } from '../../context-types.js';
+import type { deleteInputSchema, deleteProgressSchema, deleteResultSchema } from './command.js';
+export declare function run(input: z.infer<typeof deleteInputSchema>, context: WorkspaceContext): AsyncIterable<CommandEvent<z.infer<typeof deleteResultSchema>, z.infer<typeof deleteProgressSchema>>>;
+export declare function text(result: z.infer<typeof deleteResultSchema>): string;
+export declare function progressText(progress: z.infer<typeof deleteProgressSchema>): string;

package/dist/commands/environments/delete.js

@@ -0,0 +1,48 @@
+import { CliError } from '../../errors.js';
+import { environment, environmentResult, pages } from '../../resources/read.js';
+export async function* run(input, context) {
+    const matches = input.id === undefined
+        ? (await pages({ all: true }, (query) => context.sdk.environments.list({
+            ...query,
+            workspaceId: context.workspace.id,
+            label: input.label,
+        }))).data.filter((value) => value.status !== 'deleted')
+        : [await environment(context, input.id)];
+    for (const value of matches) {
+        context.workspace.assertMember(value.workspaceId);
+    }
+    yield {
+        kind: 'progress',
+        value: { event: 'matches', ids: matches.map((value) => value.id) },
+    };
+    if (matches.length > 0 && !context.globals.yes) {
+        if (context.presentation.mode !== 'interactive') {
+            throw new CliError('cli.input_required', {
+                message: 'Use --yes to confirm deletion.',
+            });
+        }
+        if (!(await context.io.prompt.confirm(`Delete ${matches.length} environment${matches.length === 1 ? '' : 's'}?`, { signal: context.io.signal, deadline: null }))) {
+            throw new CliError('cli.cancelled');
+        }
+    }
+    const data = [];
+    for (const value of matches) {
+        data.push(environmentResult(await context.sdk.environments.delete(value.id, {
+            signal: context.io.signal,
+        })));
+        yield { kind: 'progress', value: { event: 'deleted', id: value.id } };
+    }
+    yield { kind: 'result', value: { data } };
+}
+export function text(result) {
+    return result.data.length === 0
+        ? 'No matching environments.\n'
+        : `${result.data.map((value) => `Deleted ${value.id}`).join('\n')}\n`;
+}
+export function progressText(progress) {
+    return progress.event === 'matches'
+        ? progress.ids.length === 0
+            ? 'No matching environments.'
+            : `Environments to delete:\n${progress.ids.join('\n')}`
+        : `Deleted ${progress.id}`;
+}

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

@@ -0,0 +1,39 @@
+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;
+    name: string | null;
+    labels: Record<string, string>;
+    status: string;
+    reason: string | null;
+    failure: {
+        appName: string;
+        code: string;
+        message: string;
+    } | null;
+    timeLimitMinutes: number;
+    tokenInUrl: boolean;
+    snapshotId: string | null;
+    apps: {
+        appId: string;
+        name: string;
+        version: string;
+        versionId: string;
+        setup: Record<string, z.JSONType>;
+        services: Record<string, z.JSONType>;
+        url: string;
+    }[];
+    createdBy: {
+        id: string | null;
+        name: string | null;
+        type: string;
+    };
+    createdAt: string;
+    startedAt: string | null;
+    deletedAt: string | null;
+    expiresAt: string | null;
+}>;
+export declare const text: typeof resourceText;

package/dist/commands/environments/get.js

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

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

@@ -0,0 +1,41 @@
+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;
+        name: string | null;
+        labels: Record<string, string>;
+        status: string;
+        reason: string | null;
+        failure: {
+            appName: string;
+            code: string;
+            message: string;
+        } | null;
+        timeLimitMinutes: number;
+        tokenInUrl: boolean;
+        snapshotId: string | null;
+        apps: {
+            appId: string;
+            name: string;
+            version: string;
+            versionId: string;
+            setup: Record<string, z.JSONType>;
+            services: Record<string, z.JSONType>;
+            url: string;
+        }[];
+        createdBy: {
+            id: string | null;
+            name: string | null;
+            type: string;
+        };
+        createdAt: string;
+        startedAt: string | null;
+        deletedAt: string | null;
+        expiresAt: string | null;
+    }[];
+    nextCursor: string | null;
+}>;
+export declare function text(result: z.infer<typeof listResultSchema>): string;

package/dist/commands/environments/list.js

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