@usestatemachines/cli 0.0.0-stage → 0.1.0

package/dist/programs.js

@@ -0,0 +1,44 @@
+import { productionOrigin } from './context-types.js';
+import { CliError } from './errors.js';
+export function createPrograms(options) {
+    const { io, credential } = options;
+    const effects = (supplied) => supplied ?? { signal: io.signal, deadline: null };
+    return {
+        async run(input, supplied) {
+            const effect = effects(supplied);
+            const consume = async (key) => {
+                const environment = Object.fromEntries(Object.entries(io.host.environment).filter((entry) => entry[1] !== undefined));
+                environment.STATEMACHINES_API_KEY = key;
+                if (options.origin === productionOrigin) {
+                    delete environment.STATEMACHINES_BASE_URL;
+                }
+                else {
+                    environment.STATEMACHINES_BASE_URL = options.origin;
+                }
+                return io.child.run({
+                    ...input,
+                    environment,
+                    cwd: io.host.cwd,
+                    stdin: 'inherit',
+                    output: 'inherit',
+                    options: effect,
+                });
+            };
+            return credential.kind === 'workspace-key'
+                ? consume(credential.key)
+                : credential.keys.withRunKey({
+                    account: credential.account,
+                    workspace: options.workspace,
+                    consume,
+                }, effect);
+        },
+        async pullEnvironment(file, supplied) {
+            if (credential.kind === 'workspace-key') {
+                throw new CliError('cli.env_requires_login');
+            }
+            const effect = effects(supplied);
+            const target = await options.files.prepare(file, effect);
+            return credential.keys.pullEnvironment({ account: credential.account, workspace: options.workspace, target }, effect);
+        },
+    };
+}

package/dist/project-roots.d.ts

@@ -0,0 +1,3 @@
+import type { EffectOptions, Io } from './io-types.js';
+export declare function findPackageRoot(io: Io, from: string, stopAt: string | null, options: EffectOptions): Promise<string | null>;
+export declare function findProjectRoot(io: Io, options: EffectOptions): Promise<string | null>;

package/dist/project-roots.js

@@ -0,0 +1,26 @@
+import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+export async function findPackageRoot(io, from, stopAt, options) {
+    let directory = resolve(from);
+    for (;;) {
+        if ((await io.files.inspect(join(directory, 'package.json'), options))
+            .kind !== 'missing') {
+            return directory;
+        }
+        const parent = dirname(directory);
+        if (directory === stopAt || parent === directory) {
+            return null;
+        }
+        directory = parent;
+    }
+}
+export async function findProjectRoot(io, options) {
+    const home = resolve(io.host.home);
+    const belowHome = (root) => {
+        const up = root === null ? '' : relative(root, home);
+        return up === '..' || up.startsWith(`..${sep}`) || isAbsolute(up)
+            ? root
+            : null;
+    };
+    return (belowHome(await io.files.findRepositoryRoot(io.host.cwd, options)) ??
+        belowHome(await findPackageRoot(io, io.host.cwd, home, options)));
+}

package/dist/prompt.d.ts

@@ -0,0 +1,3 @@
+import type { Readable, Writable } from 'node:stream';
+import type { Prompter } from './io-types.js';
+export declare function createPrompter(input: Readable, output: Writable): Prompter;

package/dist/prompt.js

@@ -0,0 +1,61 @@
+import { confirm, isCancel, multiselect, select } from '@clack/prompts';
+import { CliError } from './errors.js';
+import { untrustedText } from './text.js';
+export function createPrompter(input, output) {
+    return {
+        async confirm(question, options) {
+            const result = await confirm({
+                message: untrustedText(question),
+                input,
+                output,
+                signal: options.signal,
+            });
+            if (isCancel(result)) {
+                throw new CliError('cli.cancelled');
+            }
+            return result;
+        },
+        async multiselect(question, choices, initialValues, options) {
+            const result = await multiselect({
+                message: untrustedText(question),
+                options: choices.map((choice) => ({
+                    value: choice.value,
+                    label: untrustedText(choice.label),
+                })),
+                initialValues: [...initialValues],
+                required: false,
+                input,
+                output,
+                signal: options.signal,
+            });
+            if (isCancel(result)) {
+                throw new CliError('cli.cancelled');
+            }
+            const selected = choices.filter((choice) => result.includes(choice.value));
+            if (selected.length !== result.length) {
+                throw new CliError('cli.internal');
+            }
+            return selected.map((choice) => choice.value);
+        },
+        async select(question, choices, options) {
+            const result = await select({
+                message: untrustedText(question),
+                options: choices.map((choice) => ({
+                    value: choice.value,
+                    label: untrustedText(choice.label),
+                })),
+                input,
+                output,
+                signal: options.signal,
+            });
+            if (isCancel(result)) {
+                throw new CliError('cli.cancelled');
+            }
+            const choice = choices.find((choice) => choice.value === result);
+            if (!choice) {
+                throw new CliError('cli.internal');
+            }
+            return choice.value;
+        },
+    };
+}

package/dist/registry.d.ts

@@ -0,0 +1,2 @@
+import type { RegisteredCommand } from './command.js';
+export declare const commands: readonly RegisteredCommand[];

package/dist/registry.js

@@ -0,0 +1,44 @@
+import { apiCommand } from './commands/api/command.js';
+import { appsListCommand } from './commands/apps/command.js';
+import { connectCommand } from './commands/connect/command.js';
+import { doctorCommand } from './commands/doctor/command.js';
+import { envPullCommand } from './commands/env/command.js';
+import { environmentsCreateCommand, environmentsDeleteCommand, environmentsGetCommand, environmentsListCommand, environmentsWaitCommand, } from './commands/environments/command.js';
+import { initCommand } from './commands/init/command.js';
+import { linkCommand } from './commands/link/command.js';
+import { loginCommand } from './commands/login/command.js';
+import { logoutCommand } from './commands/logout/command.js';
+import { profilesListCommand, profilesUseCommand, } from './commands/profiles/command.js';
+import { requestsGetCommand, requestsListCommand, } from './commands/requests/command.js';
+import { snapshotsCreateCommand, snapshotsDeleteCommand, snapshotsGetCommand, snapshotsListCommand, } from './commands/snapshots/command.js';
+import { unlinkCommand } from './commands/unlink/command.js';
+import { whoamiCommand } from './commands/whoami/command.js';
+import { workspacesListCommand, workspacesUseCommand, } from './commands/workspaces/command.js';
+export const commands = [
+    appsListCommand,
+    environmentsCreateCommand,
+    environmentsListCommand,
+    environmentsGetCommand,
+    environmentsWaitCommand,
+    environmentsDeleteCommand,
+    connectCommand,
+    snapshotsCreateCommand,
+    snapshotsListCommand,
+    snapshotsGetCommand,
+    snapshotsDeleteCommand,
+    requestsListCommand,
+    requestsGetCommand,
+    envPullCommand,
+    loginCommand,
+    logoutCommand,
+    whoamiCommand,
+    profilesListCommand,
+    profilesUseCommand,
+    workspacesListCommand,
+    workspacesUseCommand,
+    linkCommand,
+    initCommand,
+    unlinkCommand,
+    doctorCommand,
+    apiCommand,
+];

package/dist/resources/create.d.ts

@@ -0,0 +1,9 @@
+import type { WorkspaceContext } from '../context-types.js';
+import { ApiError, CliError } from '../errors.js';
+export declare function labels(values: readonly string[]): Record<string, string>;
+export declare function createKey(provided: string | undefined, context: WorkspaceContext): string;
+export declare function resourceError(cause: unknown, context: WorkspaceContext, details: {
+    resource: 'environment' | 'snapshot';
+    id?: string;
+    idempotencyKey?: string;
+}): Promise<ApiError | CliError>;

package/dist/resources/create.js

@@ -0,0 +1,55 @@
+import { ApiError, CliError, withErrorDetails } from '../errors.js';
+import { parseEnvironmentLabels } from '../generated/internal.js';
+import { commandError } from '../output.js';
+export function labels(values) {
+    try {
+        return parseEnvironmentLabels(Object.fromEntries(values.map((value) => {
+            const separator = value.indexOf('=');
+            return [value.slice(0, separator), value.slice(separator + 1)];
+        })));
+    }
+    catch {
+        throw new CliError('cli.invalid_arguments', {
+            message: 'Use valid, non-reserved key=value labels.',
+        });
+    }
+}
+export function createKey(provided, context) {
+    return (provided ?? `cli_${Buffer.from(context.io.randomBytes(32)).toString('hex')}`);
+}
+function commandArgument(value) {
+    return /^[A-Za-z0-9_-]+$/.test(value)
+        ? value
+        : `'${value.replaceAll("'", "'\\''")}'`;
+}
+export async function resourceError(cause, context, details) {
+    const metadata = {
+        resource: details.resource,
+        id: details.id ?? null,
+        idempotencyKey: details.idempotencyKey ?? null,
+    };
+    if (context.io.signal.aborted && details.id !== undefined) {
+        const id = commandArgument(details.id);
+        const workspace = commandArgument(context.workspace.id);
+        return new CliError('cli.cancelled', {
+            message: `Stopped waiting for ${details.resource} ${details.id}.`,
+            details: metadata,
+            next: [
+                {
+                    command: `statemachines ${details.resource}s delete ${id} --workspace ${workspace} --yes`,
+                    reason: `Delete the ${details.resource} when it is no longer needed.`,
+                },
+            ],
+        });
+    }
+    const error = await commandError(cause, context.io.signal);
+    const previous = error.document.error.details;
+    const retained = error instanceof ApiError
+        ? { fields: previous }
+        : previous !== null &&
+            typeof previous === 'object' &&
+            !Array.isArray(previous)
+            ? previous
+            : {};
+    return withErrorDetails(error, { ...retained, ...metadata });
+}

package/dist/resources/read.d.ts

@@ -0,0 +1,15 @@
+import type { Environment, Page, PageQuery, Request, Snapshot } from '@usestatemachines/sdk';
+import type { z } from 'zod';
+import type { WorkspaceContext } from '../context-types.js';
+import type { environmentResultSchema, pageInput, requestResultSchema, snapshotResultSchema } from './schema.js';
+export declare function environment(context: WorkspaceContext, id: string): Promise<Environment>;
+export declare function snapshot(context: WorkspaceContext, id: string): Promise<Snapshot>;
+export declare function pages<T>(input: z.infer<z.ZodObject<typeof pageInput>>, read: (query: PageQuery) => Promise<Page<T>>): Promise<Page<T>>;
+export declare function environmentResult(value: Environment): z.infer<typeof environmentResultSchema>;
+export declare function snapshotResult(value: Snapshot): z.infer<typeof snapshotResultSchema>;
+export declare function requestResult(value: Request): z.infer<typeof requestResultSchema>;
+export declare function resourceText(value: {
+    id: string;
+    status: string;
+    name: string | null;
+}): string;

package/dist/resources/read.js

@@ -0,0 +1,69 @@
+import { CliError } from '../errors.js';
+export async function environment(context, id) {
+    const resource = await context.sdk.environments.get(id);
+    context.workspace.assertMember(resource.workspaceId);
+    return resource;
+}
+export async function snapshot(context, id) {
+    const resource = await context.sdk.snapshots.get(id);
+    context.workspace.assertMember(resource.workspaceId);
+    return resource;
+}
+export async function pages(input, read) {
+    const data = [];
+    let cursor = input.cursor;
+    const seen = new Set(cursor === undefined ? [] : [cursor]);
+    for (;;) {
+        const page = await read({
+            ...(input.limit === undefined ? {} : { limit: Number(input.limit) }),
+            ...(cursor === undefined ? {} : { cursor }),
+        });
+        data.push(...page.data);
+        if (!input.all || page.nextCursor === null) {
+            return { data, nextCursor: page.nextCursor };
+        }
+        if (seen.has(page.nextCursor)) {
+            throw new CliError('cli.invalid_response');
+        }
+        seen.add(page.nextCursor);
+        cursor = page.nextCursor;
+    }
+}
+export function environmentResult(value) {
+    return {
+        id: value.id,
+        workspaceId: value.workspaceId,
+        name: value.name,
+        labels: value.labels,
+        status: value.status,
+        reason: value.reason,
+        failure: value.failure,
+        timeLimitMinutes: value.timeLimitMinutes,
+        tokenInUrl: value.tokenInUrl,
+        snapshotId: value.snapshotId,
+        apps: value.apps,
+        createdBy: value.createdBy,
+        createdAt: value.createdAt.toISOString(),
+        startedAt: value.startedAt?.toISOString() ?? null,
+        deletedAt: value.deletedAt?.toISOString() ?? null,
+        expiresAt: value.expiresAt?.toISOString() ?? null,
+    };
+}
+export function snapshotResult(value) {
+    return {
+        ...value,
+        createdAt: value.createdAt.toISOString(),
+        readyAt: value.readyAt?.toISOString() ?? null,
+        deletedAt: value.deletedAt?.toISOString() ?? null,
+    };
+}
+export function requestResult(value) {
+    return {
+        ...value,
+        receivedAt: value.receivedAt.toISOString(),
+        completedAt: value.completedAt.toISOString(),
+    };
+}
+export function resourceText(value) {
+    return `${value.id}\t${value.status}${value.name === null ? '' : `\t${value.name}`}\n`;
+}

package/dist/resources/schema.d.ts

@@ -0,0 +1,177 @@
+import { z } from 'zod';
+export declare const pageInput: {
+    limit: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodString>;
+    all: z.ZodDefault<z.ZodBoolean>;
+};
+export declare const pageFlags: ({
+    negatedName?: undefined;
+    name: string;
+    key: string;
+    type: "string";
+    description: string;
+} | {
+    name: string;
+    key: string;
+    type: "boolean";
+    negatedName: null;
+    description: string;
+})[];
+export declare const idArgument: {
+    name: string;
+    key: string;
+    required: boolean;
+    many: boolean;
+};
+export declare const idInputSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strict>;
+export declare const idempotencyKeySchema: z.ZodOptional<z.ZodString>;
+export declare const labelInputSchema: z.ZodDefault<z.ZodArray<z.ZodString>>;
+export declare const labelFlag: {
+    name: string;
+    key: string;
+    type: "string[]";
+    description: string;
+};
+export declare const environmentStatusSchema: z.ZodEnum<{
+    deleted: "deleted";
+    failed: "failed";
+    running: "running";
+    starting: "starting";
+}>;
+export declare const waitFlag: {
+    name: string;
+    key: string;
+    type: "boolean";
+    negatedName: string;
+    description: string;
+};
+export declare const acceptedSchema: z.ZodObject<{
+    event: z.ZodLiteral<"accepted">;
+    id: z.ZodString;
+}, z.core.$strict>;
+export declare const environmentResultSchema: 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>;
+export declare const snapshotResultSchema: 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>;
+export declare const requestResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    environmentId: z.ZodString;
+    appName: z.ZodString;
+    method: z.ZodString;
+    path: z.ZodString;
+    query: z.ZodString;
+    service: z.ZodNullable<z.ZodString>;
+    mcpServer: z.ZodNullable<z.ZodString>;
+    tool: z.ZodNullable<z.ZodString>;
+    operation: z.ZodNullable<z.ZodString>;
+    responseStatus: z.ZodNumber;
+    respondedBy: z.ZodString;
+    errorCode: z.ZodNullable<z.ZodString>;
+    durationMs: z.ZodNumber;
+    requestBytes: z.ZodNullable<z.ZodNumber>;
+    responseBytes: z.ZodNullable<z.ZodNumber>;
+    receivedAt: z.ZodString;
+    completedAt: z.ZodString;
+}, z.core.$strict>;
+export declare const requestDetailResultSchema: z.ZodObject<{
+    id: z.ZodString;
+    environmentId: z.ZodString;
+    appName: z.ZodString;
+    method: z.ZodString;
+    path: z.ZodString;
+    query: z.ZodString;
+    service: z.ZodNullable<z.ZodString>;
+    mcpServer: z.ZodNullable<z.ZodString>;
+    tool: z.ZodNullable<z.ZodString>;
+    operation: z.ZodNullable<z.ZodString>;
+    responseStatus: z.ZodNumber;
+    respondedBy: z.ZodString;
+    errorCode: z.ZodNullable<z.ZodString>;
+    durationMs: z.ZodNumber;
+    requestBytes: z.ZodNullable<z.ZodNumber>;
+    responseBytes: z.ZodNullable<z.ZodNumber>;
+    receivedAt: z.ZodString;
+    completedAt: z.ZodString;
+    requestBody: z.ZodObject<{
+        bytes: z.ZodNullable<z.ZodNumber>;
+        contentType: z.ZodNullable<z.ZodString>;
+        coverage: z.ZodString;
+        encoding: z.ZodString;
+        preview: z.ZodNullable<z.ZodString>;
+        previewTruncated: z.ZodBoolean;
+        reason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    requestHeaders: z.ZodRecord<z.ZodString, z.ZodString>;
+    responseBody: z.ZodObject<{
+        bytes: z.ZodNullable<z.ZodNumber>;
+        contentType: z.ZodNullable<z.ZodString>;
+        coverage: z.ZodString;
+        encoding: z.ZodString;
+        preview: z.ZodNullable<z.ZodString>;
+        previewTruncated: z.ZodBoolean;
+        reason: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    responseHeaders: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strict>;

package/dist/resources/schema.js

@@ -0,0 +1,158 @@
+import { z } from 'zod';
+export const pageInput = {
+    limit: z
+        .string()
+        .regex(/^[1-9]\d*$/)
+        .refine((value) => Number(value) <= 100)
+        .optional(),
+    cursor: z.string().min(1).max(2048).optional(),
+    all: z.boolean().default(false),
+};
+export const pageFlags = [
+    {
+        name: 'limit',
+        key: 'limit',
+        type: 'string',
+        description: 'Maximum results per page, from 1 to 100.',
+    },
+    {
+        name: 'cursor',
+        key: 'cursor',
+        type: 'string',
+        description: 'Continue from this cursor.',
+    },
+    {
+        name: 'all',
+        key: 'all',
+        type: 'boolean',
+        negatedName: null,
+        description: 'Read every page.',
+    },
+];
+export const idArgument = {
+    name: 'id',
+    key: 'id',
+    required: true,
+    many: false,
+};
+export const idInputSchema = z.strictObject({ id: z.string().min(1) });
+export const idempotencyKeySchema = z
+    .string()
+    .min(8)
+    .max(128)
+    .regex(/^[A-Za-z0-9._:-]+$/)
+    .optional();
+export const labelInputSchema = z
+    .array(z.string().regex(/^[^=]+=.*$/))
+    .max(32)
+    .default([]);
+export const labelFlag = {
+    name: 'label',
+    key: 'label',
+    type: 'string[]',
+    description: 'Match or set a key=value label. Repeat for more labels.',
+};
+export const environmentStatusSchema = z.enum([
+    'starting',
+    'running',
+    'failed',
+    'deleted',
+]);
+export const waitFlag = {
+    name: 'wait',
+    key: 'wait',
+    type: 'boolean',
+    negatedName: 'no-wait',
+    description: 'Wait until the resource is ready.',
+};
+export const acceptedSchema = z.strictObject({
+    event: z.literal('accepted'),
+    id: z.string(),
+});
+const principalSchema = z.strictObject({
+    id: z.string().nullable(),
+    name: z.string().nullable(),
+    type: z.string(),
+});
+const appVersionSchema = z.strictObject({
+    appId: z.string(),
+    name: z.string(),
+    version: z.string(),
+    versionId: z.string(),
+    setup: z.record(z.string(), z.json()),
+    services: z.record(z.string(), z.json()),
+});
+export const environmentResultSchema = z.strictObject({
+    id: z.string(),
+    workspaceId: z.string(),
+    name: z.string().nullable(),
+    labels: z.record(z.string(), z.string()),
+    status: z.string(),
+    reason: z.string().nullable(),
+    failure: z
+        .strictObject({
+        appName: z.string(),
+        code: z.string(),
+        message: z.string(),
+    })
+        .nullable(),
+    timeLimitMinutes: z.number(),
+    tokenInUrl: z.boolean(),
+    snapshotId: z.string().nullable(),
+    apps: z.array(appVersionSchema.extend({ url: z.string() })),
+    createdBy: principalSchema,
+    createdAt: z.string(),
+    startedAt: z.string().nullable(),
+    deletedAt: z.string().nullable(),
+    expiresAt: z.string().nullable(),
+});
+export const snapshotResultSchema = z.strictObject({
+    id: z.string(),
+    workspaceId: z.string(),
+    environmentId: z.string(),
+    environmentName: z.string().nullable(),
+    name: z.string().nullable(),
+    status: z.string(),
+    failure: z.strictObject({ code: z.string(), message: z.string() }).nullable(),
+    sizeBytes: z.number().nullable(),
+    apps: z.array(appVersionSchema.extend({ sizeBytes: z.number().nullable() })),
+    createdBy: principalSchema,
+    createdAt: z.string(),
+    readyAt: z.string().nullable(),
+    deletedAt: z.string().nullable(),
+});
+export const requestResultSchema = z.strictObject({
+    id: z.string(),
+    environmentId: z.string(),
+    appName: z.string(),
+    method: z.string(),
+    path: z.string(),
+    query: z.string(),
+    service: z.string().nullable(),
+    mcpServer: z.string().nullable(),
+    tool: z.string().nullable(),
+    operation: z.string().nullable(),
+    responseStatus: z.number(),
+    respondedBy: z.string(),
+    errorCode: z.string().nullable(),
+    durationMs: z.number(),
+    requestBytes: z.number().nullable(),
+    responseBytes: z.number().nullable(),
+    receivedAt: z.string(),
+    completedAt: z.string(),
+});
+const bodyPreviewSchema = z.strictObject({
+    bytes: z.number().nullable(),
+    contentType: z.string().nullable(),
+    coverage: z.string(),
+    encoding: z.string(),
+    preview: z.string().nullable(),
+    previewTruncated: z.boolean(),
+    reason: z.string().nullable(),
+});
+export const requestDetailResultSchema = requestResultSchema.extend({
+    requestBody: bodyPreviewSchema,
+    requestHeaders: z.record(z.string(), z.string()),
+    responseBody: bodyPreviewSchema,
+    responseHeaders: z.record(z.string(), z.string()),
+});

package/dist/text.d.ts

@@ -0,0 +1,3 @@
+import type { JsonValue } from './command.js';
+export declare function untrustedText(value: string): string;
+export declare function untrustedResult(value: JsonValue): JsonValue;