@usestatemachines/cli 0.0.0-stage → 0.1.0

package/dist/commands/link/command.js

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { defineCommand } from '../../command.js';
+export const linkInputSchema = z.strictObject({
+    force: z.boolean().default(false),
+});
+export const linkResultSchema = z.strictObject({
+    path: z.string(),
+    organizationId: z.string(),
+    workspace: z.strictObject({ id: z.string(), name: z.string() }),
+});
+export const linkCommand = defineCommand({
+    name: ['link'],
+    summary: 'Link this repository to a workspace.',
+    need: 'account',
+    workspace: true,
+    destructive: false,
+    streams: false,
+    arguments: [],
+    flags: [
+        {
+            name: 'force',
+            key: 'force',
+            type: 'boolean',
+            negatedName: null,
+            description: 'Replace an existing repository link.',
+        },
+    ],
+    input: linkInputSchema,
+    result: linkResultSchema,
+    progress: z.never(),
+    load: () => import('./run.js'),
+});

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

@@ -0,0 +1,12 @@
+import type { z } from 'zod';
+import type { AccountContext } from '../../context-types.js';
+import type { linkInputSchema, linkResultSchema } from './command.js';
+export declare function run(input: z.infer<typeof linkInputSchema>, context: AccountContext): Promise<{
+    path: string;
+    organizationId: string;
+    workspace: {
+        id: string;
+        name: string;
+    };
+}>;
+export declare function text(result: z.infer<typeof linkResultSchema>): string;

package/dist/commands/link/run.js

@@ -0,0 +1,7 @@
+import { linkWorkspace } from '../../link.js';
+export function run(input, context) {
+    return linkWorkspace(context, input);
+}
+export function text(result) {
+    return `Linked to ${result.workspace.name}.\n`;
+}

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

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

package/dist/commands/login/command.js

@@ -0,0 +1,43 @@
+import { defineCommand } from '../../command.js';
+import { loginInputSchema, loginProgressSchema, loginResultSchema, } from './schema.js';
+export const loginCommand = defineCommand({
+    name: ['login'],
+    summary: 'Sign in through the dashboard.',
+    need: 'public',
+    destructive: false,
+    streams: true,
+    arguments: [],
+    flags: [
+        {
+            name: 'base-url',
+            key: 'baseUrl',
+            type: 'string',
+            description: 'Choose the API origin.',
+        },
+        {
+            name: 'browser',
+            negatedName: 'no-browser',
+            key: 'browser',
+            type: 'boolean',
+            description: 'Open the dashboard in a browser.',
+        },
+        {
+            name: 'wait',
+            negatedName: 'no-wait',
+            key: 'wait',
+            type: 'boolean',
+            description: 'Wait for dashboard approval.',
+        },
+        {
+            name: 'resume',
+            negatedName: null,
+            key: 'resume',
+            type: 'boolean',
+            description: 'Continue a saved login.',
+        },
+    ],
+    input: loginInputSchema,
+    result: loginResultSchema,
+    progress: loginProgressSchema,
+    load: () => import('./run.js'),
+});

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

@@ -0,0 +1,30 @@
+import type { z } from 'zod';
+import { type PublicContext } from '../../context-types.js';
+import type { loginInputSchema, loginProgressSchema, loginResultSchema } from './schema.js';
+export declare function run(input: z.infer<typeof loginInputSchema>, context: PublicContext): AsyncIterable<import("../../command.js").CommandEvent<{
+    status: "signed-in";
+    profile: string;
+    organization: {
+        id: string;
+        name: string;
+    };
+    email: string;
+    idleExpiresAt: string;
+    expiresAt: string;
+    userActionRequired: false;
+} | {
+    status: "awaiting-approval";
+    profile: string;
+    loginId: string;
+    userCode: string;
+    verificationUrl: string;
+    expiresAt: string;
+    userActionRequired: true;
+}, {
+    status: "waiting";
+    userCode: string;
+    verificationUrl: string;
+    expiresAt: string;
+}>>;
+export declare function text(result: z.infer<typeof loginResultSchema>): string;
+export declare function progressText(progress: z.infer<typeof loginProgressSchema>): string;

package/dist/commands/login/run.js

@@ -0,0 +1,43 @@
+import { apiOriginSchema } from '../../context-types.js';
+import { CliError } from '../../errors.js';
+export function run(input, context) {
+    if (input.wait &&
+        !input.resume &&
+        context.presentation.mode === 'non-interactive' &&
+        !context.presentation.stream) {
+        throw new CliError('cli.input_required', {
+            message: 'Use --no-wait to receive the approval URL and code, or --json --stream to wait with progress.',
+            next: [
+                {
+                    command: 'statemachines login --no-wait --json',
+                    reason: 'Start a login that can be approved in the dashboard.',
+                },
+            ],
+        });
+    }
+    if (input.resume && !input.wait) {
+        throw new CliError('cli.invalid_arguments');
+    }
+    const origin = input.baseUrl === undefined
+        ? null
+        : apiOriginSchema.safeParse(input.baseUrl);
+    if (origin !== null && !origin.success) {
+        throw new CliError('cli.invalid_arguments');
+    }
+    return context.accounts.login({
+        profile: context.globals.profile,
+        origin: origin?.data ?? null,
+        mode: input.resume ? 'resume' : input.wait ? 'wait' : 'no-wait',
+        browser: input.browser,
+        replace: context.globals.yes,
+        interactive: context.presentation.mode === 'interactive',
+    });
+}
+export function text(result) {
+    return result.status === 'signed-in'
+        ? `Signed in as ${result.email} to ${result.organization.name}.\nIdle expiry: ${result.idleExpiresAt}\nExpiry: ${result.expiresAt}`
+        : `Open ${result.verificationUrl} and approve code ${result.userCode}.\nProfile: ${result.profile}\nContinue with statemachines login --profile <profile> --resume`;
+}
+export function progressText(progress) {
+    return `Open ${progress.verificationUrl} and approve code ${progress.userCode}.`;
+}

package/dist/commands/login/schema.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+export declare const loginInputSchema: z.ZodObject<{
+    baseUrl: z.ZodOptional<z.ZodString>;
+    browser: z.ZodDefault<z.ZodBoolean>;
+    wait: z.ZodDefault<z.ZodBoolean>;
+    resume: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const loginResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"signed-in">;
+    profile: z.ZodString;
+    organization: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>;
+    email: z.ZodString;
+    idleExpiresAt: z.ZodString;
+    expiresAt: z.ZodString;
+    userActionRequired: z.ZodLiteral<false>;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"awaiting-approval">;
+    profile: z.ZodString;
+    loginId: z.ZodString;
+    userCode: z.ZodString;
+    verificationUrl: z.ZodString;
+    expiresAt: z.ZodString;
+    userActionRequired: z.ZodLiteral<true>;
+}, z.core.$strict>], "status">;
+export declare const loginProgressSchema: z.ZodObject<{
+    status: z.ZodLiteral<"waiting">;
+    userCode: z.ZodString;
+    verificationUrl: z.ZodString;
+    expiresAt: z.ZodString;
+}, z.core.$strict>;

package/dist/commands/login/schema.js

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+export const loginInputSchema = z.strictObject({
+    baseUrl: z.string().optional(),
+    browser: z.boolean().default(true),
+    wait: z.boolean().default(true),
+    resume: z.boolean().default(false),
+});
+export const loginResultSchema = z.discriminatedUnion('status', [
+    z.strictObject({
+        status: z.literal('signed-in'),
+        profile: z.string(),
+        organization: z.strictObject({ id: z.string(), name: z.string() }),
+        email: z.string(),
+        idleExpiresAt: z.string(),
+        expiresAt: z.string(),
+        userActionRequired: z.literal(false),
+    }),
+    z.strictObject({
+        status: z.literal('awaiting-approval'),
+        profile: z.string(),
+        loginId: z.string(),
+        userCode: z.string(),
+        verificationUrl: z.string(),
+        expiresAt: z.string(),
+        userActionRequired: z.literal(true),
+    }),
+]);
+export const loginProgressSchema = z.strictObject({
+    status: z.literal('waiting'),
+    userCode: z.string(),
+    verificationUrl: z.string(),
+    expiresAt: z.string(),
+});

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

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

package/dist/commands/logout/command.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { defineCommand } from '../../command.js';
+import { logoutInputSchema, logoutResultSchema } from './schema.js';
+export const logoutCommand = defineCommand({
+    name: ['logout'],
+    summary: 'Revoke the saved session and remove local credentials.',
+    need: 'public',
+    destructive: true,
+    streams: false,
+    arguments: [],
+    flags: [
+        {
+            name: 'all',
+            key: 'all',
+            type: 'boolean',
+            negatedName: null,
+            description: 'Sign out of every profile.',
+        },
+    ],
+    input: logoutInputSchema,
+    result: logoutResultSchema,
+    progress: z.never(),
+    load: () => import('./run.js'),
+});

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

@@ -0,0 +1,10 @@
+import type { z } from 'zod';
+import type { PublicContext } from '../../context-types.js';
+import type { logoutInputSchema, logoutResultSchema } from './schema.js';
+export declare function run(input: z.infer<typeof logoutInputSchema>, context: PublicContext): Promise<{
+    profiles: string[];
+    pendingRevocations: string[];
+    unconfirmedRevocations: string[];
+    environmentCredentialUnchanged: boolean;
+}>;
+export declare function text(result: z.infer<typeof logoutResultSchema>): string;

package/dist/commands/logout/run.js

@@ -0,0 +1,19 @@
+import { unconfirmedRevocations } from '../../errors.js';
+export function run(input, context) {
+    return context.accounts.logout({
+        profiles: input.all ? 'all' : context.globals.profile,
+    });
+}
+export function text(result) {
+    const unconfirmed = result.unconfirmedRevocations.length;
+    const { problem, remedy } = unconfirmedRevocations(unconfirmed);
+    return [
+        result.profiles.length === 0
+            ? 'No saved session.'
+            : `Signed out of ${result.profiles.join(', ')}.`,
+        ...(unconfirmed === 0 ? [] : [`${problem} ${remedy}`]),
+        ...(result.environmentCredentialUnchanged
+            ? ['STATEMACHINES_API_KEY is still set and remains active.']
+            : []),
+    ].join('\n');
+}

package/dist/commands/logout/schema.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const logoutInputSchema: z.ZodObject<{
+    all: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const logoutResultSchema: z.ZodObject<{
+    profiles: z.ZodArray<z.ZodString>;
+    pendingRevocations: z.ZodArray<z.ZodString>;
+    unconfirmedRevocations: z.ZodArray<z.ZodString>;
+    environmentCredentialUnchanged: z.ZodBoolean;
+}, z.core.$strict>;

package/dist/commands/logout/schema.js

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export const logoutInputSchema = z.strictObject({
+    all: z.boolean().default(false),
+});
+export const logoutResultSchema = z.strictObject({
+    profiles: z.array(z.string()),
+    pendingRevocations: z.array(z.string()),
+    unconfirmedRevocations: z.array(z.string()),
+    environmentCredentialUnchanged: z.boolean(),
+});

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

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

package/dist/commands/profiles/command.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { defineCommand } from '../../command.js';
+import { profilesListInputSchema, profilesResultSchema, profilesUseInputSchema, profilesUseResultSchema, } from './schema.js';
+export const profilesListCommand = defineCommand({
+    name: ['profiles', 'list'],
+    summary: 'List saved profiles.',
+    need: 'public',
+    destructive: false,
+    streams: false,
+    arguments: [],
+    flags: [],
+    input: profilesListInputSchema,
+    result: profilesResultSchema,
+    progress: z.never(),
+    load: () => import('./list.js'),
+});
+export const profilesUseCommand = defineCommand({
+    name: ['profiles', 'use'],
+    summary: 'Choose the default profile.',
+    need: 'public',
+    destructive: false,
+    streams: false,
+    arguments: [{ name: 'name', key: 'name', required: true, many: false }],
+    flags: [],
+    input: profilesUseInputSchema,
+    result: profilesUseResultSchema,
+    progress: z.never(),
+    load: () => import('./use.js'),
+});

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

@@ -0,0 +1,20 @@
+import type { z } from 'zod';
+import type { PublicContext } from '../../context-types.js';
+import type { profilesListInputSchema, profilesResultSchema } from './schema.js';
+export declare function run(_input: z.infer<typeof profilesListInputSchema>, context: PublicContext): Promise<{
+    defaultProfile: string | null;
+    profiles: {
+        name: string;
+        origin: string;
+        organization: {
+            id: string;
+            name: string;
+        };
+        email: string;
+        tokenId: string;
+        idleExpiresAt: string;
+        expiresAt: string;
+        defaultWorkspace: string | null;
+    }[];
+}>;
+export declare function text(result: z.infer<typeof profilesResultSchema>): string;

package/dist/commands/profiles/list.js

@@ -0,0 +1,10 @@
+export function run(_input, context) {
+    return context.accounts.list();
+}
+export function text(result) {
+    return result.profiles.length === 0
+        ? 'No saved profiles. Run statemachines login to sign in.'
+        : result.profiles
+            .map((profile) => `${profile.name === result.defaultProfile ? '* ' : '  '}${profile.name}\t${profile.organization.name}\t${profile.email}`)
+            .join('\n');
+}

package/dist/commands/profiles/schema.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export declare const profilesListInputSchema: z.ZodObject<{}, z.core.$strict>;
+export declare const profilesUseInputSchema: z.ZodObject<{
+    name: z.ZodString;
+}, z.core.$strict>;
+export declare const profilesUseResultSchema: z.ZodObject<{
+    profile: z.ZodString;
+}, z.core.$strict>;
+export declare const profilesResultSchema: z.ZodObject<{
+    defaultProfile: z.ZodNullable<z.ZodString>;
+    profiles: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        origin: z.ZodString;
+        organization: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>;
+        email: z.ZodString;
+        tokenId: z.ZodString;
+        idleExpiresAt: z.ZodString;
+        expiresAt: z.ZodString;
+        defaultWorkspace: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;

package/dist/commands/profiles/schema.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export const profilesListInputSchema = z.strictObject({});
+export const profilesUseInputSchema = z.strictObject({
+    name: z.string().min(1),
+});
+export const profilesUseResultSchema = z.strictObject({ profile: z.string() });
+export const profilesResultSchema = z.strictObject({
+    defaultProfile: z.string().nullable(),
+    profiles: z.array(z.strictObject({
+        name: z.string(),
+        origin: z.string(),
+        organization: z.strictObject({ id: z.string(), name: z.string() }),
+        email: z.string(),
+        tokenId: z.string(),
+        idleExpiresAt: z.string(),
+        expiresAt: z.string(),
+        defaultWorkspace: z.string().nullable(),
+    })),
+});

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

@@ -0,0 +1,7 @@
+import type { z } from 'zod';
+import { type PublicContext } from '../../context-types.js';
+import type { profilesUseInputSchema, profilesUseResultSchema } from './schema.js';
+export declare function run(input: z.infer<typeof profilesUseInputSchema>, context: PublicContext): Promise<{
+    profile: string;
+}>;
+export declare function text(result: z.infer<typeof profilesUseResultSchema>): string;

package/dist/commands/profiles/use.js

@@ -0,0 +1,7 @@
+import { profileNameSchema } from '../../context-types.js';
+export function run(input, context) {
+    return context.accounts.use(profileNameSchema.parse(input.name));
+}
+export function text(result) {
+    return `Using profile ${result.profile}.`;
+}

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

@@ -0,0 +1,39 @@
+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>;
+    environmentId: z.ZodString;
+    app: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        "2xx": "2xx";
+        "3xx": "3xx";
+        "4xx": "4xx";
+        "5xx": "5xx";
+    }>, z.ZodString]>>;
+}, z.core.$strict>;
+export declare const listResultSchema: z.ZodObject<{
+    data: z.ZodArray<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>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const requestsListCommand: import("../../command.js").RegisteredCommand;
+export declare const requestsGetCommand: import("../../command.js").RegisteredCommand;

package/dist/commands/requests/command.js

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { defineCommand } from '../../command.js';
+import { idArgument, idInputSchema, pageFlags, pageInput, requestDetailResultSchema, requestResultSchema, } from '../../resources/schema.js';
+export const listInputSchema = z.strictObject({
+    ...pageInput,
+    environmentId: z.string().min(1),
+    app: z.string().min(1).optional(),
+    status: z
+        .union([
+        z.enum(['2xx', '3xx', '4xx', '5xx']),
+        z.string().regex(/^[1-5]\d{2}$/),
+    ])
+        .optional(),
+});
+export const listResultSchema = z.strictObject({
+    data: z.array(requestResultSchema),
+    nextCursor: z.string().nullable(),
+});
+export const requestsListCommand = defineCommand({
+    name: ['requests', 'list'],
+    summary: 'List gateway requests for an environment.',
+    need: 'workspace',
+    destructive: false,
+    streams: false,
+    arguments: [
+        {
+            name: 'environment-id',
+            key: 'environmentId',
+            required: true,
+            many: false,
+        },
+    ],
+    flags: [
+        ...pageFlags,
+        {
+            name: 'app',
+            key: 'app',
+            type: 'string',
+            description: 'Match requests for this app.',
+        },
+        {
+            name: 'status',
+            key: 'status',
+            type: 'string',
+            description: 'Match an HTTP status or status class, such as 404 or 4xx.',
+        },
+    ],
+    input: listInputSchema,
+    result: listResultSchema,
+    progress: z.never(),
+    load: () => import('./list.js'),
+});
+export const requestsGetCommand = defineCommand({
+    name: ['requests', 'get'],
+    summary: 'Show a gateway request.',
+    need: 'workspace',
+    destructive: false,
+    streams: false,
+    arguments: [idArgument],
+    flags: [],
+    input: idInputSchema,
+    result: requestDetailResultSchema,
+    progress: z.never(),
+    load: () => import('./get.js'),
+});

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

@@ -0,0 +1,32 @@
+import type { z } from 'zod';
+import type { WorkspaceContext } from '../../context-types.js';
+import type { idInputSchema, requestDetailResultSchema } from '../../resources/schema.js';
+export declare function run(input: z.infer<typeof idInputSchema>, context: WorkspaceContext): Promise<{
+    id: string;
+    environmentId: string;
+    appName: string;
+    method: string;
+    path: string;
+    query: string;
+    service: string | null;
+    mcpServer: string | null;
+    tool: string | null;
+    operation: string | null;
+    responseStatus: number;
+    respondedBy: string;
+    errorCode: string | null;
+    durationMs: number;
+    requestBytes: number | null;
+    responseBytes: number | null;
+    receivedAt: string;
+    completedAt: string;
+    requestBody: import("@usestatemachines/sdk").BodyPreview;
+    requestHeaders: {
+        [k: string]: string;
+    };
+    responseBody: import("@usestatemachines/sdk").BodyPreview;
+    responseHeaders: {
+        [k: string]: string;
+    };
+}>;
+export declare function text(result: z.infer<typeof requestDetailResultSchema>): string;

package/dist/commands/requests/get.js

@@ -0,0 +1,15 @@
+import { environment, requestResult } from '../../resources/read.js';
+export async function run(input, context) {
+    const value = await context.sdk.requests.get(input.id);
+    await environment(context, value.environmentId);
+    return {
+        ...requestResult(value),
+        requestBody: value.requestBody,
+        requestHeaders: value.requestHeaders,
+        responseBody: value.responseBody,
+        responseHeaders: value.responseHeaders,
+    };
+}
+export function text(result) {
+    return `${result.id}\t${result.method}\t${result.path}\t${result.responseStatus}\t${result.durationMs} ms\n`;
+}

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

@@ -0,0 +1,27 @@
+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;
+        environmentId: string;
+        appName: string;
+        method: string;
+        path: string;
+        query: string;
+        service: string | null;
+        mcpServer: string | null;
+        tool: string | null;
+        operation: string | null;
+        responseStatus: number;
+        respondedBy: string;
+        errorCode: string | null;
+        durationMs: number;
+        requestBytes: number | null;
+        responseBytes: number | null;
+        receivedAt: string;
+        completedAt: string;
+    }[];
+    nextCursor: string | null;
+}>;
+export declare function text(result: z.infer<typeof listResultSchema>): string;