@usestatemachines/cli 0.0.0-stage → 0.1.0

package/dist/link.d.ts

@@ -0,0 +1,6 @@
+import type { z } from 'zod';
+import type { linkResultSchema } from './commands/link/command.js';
+import { type AccountContext } from './context-types.js';
+export declare function linkWorkspace(context: AccountContext, input: {
+    readonly force: boolean;
+}): Promise<z.infer<typeof linkResultSchema>>;

package/dist/link.js

@@ -0,0 +1,58 @@
+import { allWorkspaces } from './context.js';
+import { organizationIdSchema, workspaceIdSchema, } from './context-types.js';
+import { CliError } from './errors.js';
+export async function linkWorkspace(context, input) {
+    const selected = context.globals.workspace ??
+        context.io.host.environment.STATEMACHINES_WORKSPACE;
+    let workspace;
+    if (selected !== undefined && selected !== null) {
+        workspace = await context.findWorkspace(selected);
+    }
+    else {
+        const workspaces = await allWorkspaces(context.sdk);
+        const first = workspaces[0];
+        if (first === undefined) {
+            throw new CliError('cli.not_linked', {
+                message: 'No accessible workspaces are available.',
+            });
+        }
+        if (context.globals.yes && workspaces.length === 1) {
+            workspace = { id: workspaceIdSchema.parse(first.id), name: first.name };
+        }
+        else {
+            if (context.presentation.mode !== 'interactive') {
+                throw new CliError('cli.input_required', {
+                    message: 'Choose a workspace with --workspace, or use --yes when there is one workspace.',
+                    next: [
+                        {
+                            command: 'statemachines link --workspace <id>',
+                            reason: 'Choose the workspace to link.',
+                        },
+                    ],
+                });
+            }
+            const id = await context.io.prompt.select('Choose a workspace', workspaces.map((value) => ({ value: value.id, label: value.name })), { signal: context.io.signal, deadline: null });
+            workspace = await context.findWorkspace(id);
+        }
+    }
+    if (context.account.kind === 'workspace-key' &&
+        workspace.id !== context.account.workspaceId) {
+        throw new CliError('cli.workspace_mismatch');
+    }
+    const organization = organizationIdSchema.safeParse(context.account.kind === 'cli-token'
+        ? context.account.organizationId
+        : (await context.sdk.me()).organization?.id);
+    if (!organization.success) {
+        throw new CliError('cli.invalid_response');
+    }
+    const organizationId = organization.data;
+    const link = await context.projects.link({ organizationId, workspaceId: workspace.id }, input.force);
+    if (context.account.kind === 'cli-token') {
+        await context.accounts.setWorkspace({
+            account: context.account,
+            workspace: workspace.id,
+            mode: 'if-unset',
+        });
+    }
+    return { path: link.path, organizationId, workspace };
+}

package/dist/login.d.ts

@@ -0,0 +1,92 @@
+import { z } from 'zod';
+import type { AnonymousApi, AuthenticatedInternalApi } from './api-internal.js';
+import type { CommandEvent } from './command.js';
+import type { loginProgressSchema, loginResultSchema } from './commands/login/schema.js';
+import type { logoutResultSchema } from './commands/logout/schema.js';
+import type { profilesResultSchema } from './commands/profiles/schema.js';
+import { type SecretRef } from './config/schema.js';
+import { type Account, type ApiOrigin, type ProfileName, type WorkspaceId } from './context-types.js';
+import type { EffectOptions, Io } from './io-types.js';
+import type { EnvironmentFiles, ProgramKeys } from './program-types.js';
+export declare const recoveryReportSchema: z.ZodObject<{
+    acknowledged: z.ZodArray<z.ZodString>;
+    revoked: z.ZodArray<z.ZodString>;
+    pending: z.ZodArray<z.ZodString>;
+    unconfirmed: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type LoginResult = z.infer<typeof loginResultSchema>;
+export type LoginProgress = z.infer<typeof loginProgressSchema>;
+export type LoginInput = {
+    profile: ProfileName | null;
+    origin: ApiOrigin | null;
+    mode: 'wait' | 'no-wait' | 'resume';
+    browser: boolean;
+    replace: boolean;
+    interactive: boolean;
+};
+export interface AccountClients {
+    anonymous(origin: ApiOrigin): AnonymousApi;
+    authenticated(origin: ApiOrigin, token: string): Pick<AuthenticatedInternalApi, 'collected' | 'revokeCurrent' | 'createKey' | 'revokeKey'>;
+    validateKey(origin: ApiOrigin, key: string, options: EffectOptions): Promise<{
+        id: string;
+        workspaceId: WorkspaceId;
+        kind: 'dashboard' | 'cli_run' | 'env_pull';
+        expiresAt: string | null;
+    }>;
+    defaultWorkspace(origin: ApiOrigin, token: string, options: EffectOptions): Promise<WorkspaceId | null>;
+}
+export interface Accounts {
+    inspect(options?: EffectOptions): Promise<{
+        defaultProfile: string | null;
+        profiles: {
+            name: string;
+            origin: ApiOrigin;
+            organizationId: string;
+            store: SecretRef['store'];
+            idleExpiresAt: string;
+            expiresAt: string;
+        }[];
+        pendingAcknowledgements: number;
+        pendingRevocations: number;
+        pendingCleanup: number;
+    }>;
+    login(input: LoginInput, options?: EffectOptions): AsyncIterable<CommandEvent<LoginResult, LoginProgress>>;
+    logout(input: {
+        profiles: 'all' | ProfileName | null;
+    }, options?: EffectOptions): Promise<z.infer<typeof logoutResultSchema>>;
+    list(options?: EffectOptions): Promise<z.infer<typeof profilesResultSchema>>;
+    use(profile: ProfileName, options?: EffectOptions): Promise<{
+        profile: string;
+    }>;
+    setWorkspace(input: {
+        account: Extract<Account, {
+            kind: 'cli-token';
+        }>;
+        workspace: WorkspaceId;
+        mode: 'replace' | 'if-unset';
+    }, options?: EffectOptions): Promise<void>;
+    reconcile(reason: 'next-command' | 'login' | 'logout' | 'doctor', options?: EffectOptions): Promise<z.infer<typeof recoveryReportSchema>>;
+}
+export interface AccountAuthentication {
+    withCredential<Value>(selection: {
+        profile: ProfileName | null;
+        expectedOrigin: ApiOrigin | null;
+    }, action: (value: {
+        account: Extract<Account, {
+            kind: 'cli-token';
+        }>;
+        defaultWorkspace: WorkspaceId | null;
+        token: string;
+    }) => Promise<Value>, options?: EffectOptions): Promise<Value>;
+}
+export declare function createAccounts(input: {
+    io: Io;
+    version: string;
+    clients: AccountClients;
+    environmentFiles: EnvironmentFiles;
+    options?: EffectOptions;
+}): {
+    accounts: Accounts;
+    authentication: AccountAuthentication;
+    programKeys: ProgramKeys;
+};