@meistrari/tela-cli 0.1.1 → 0.3.0

package/src/ink/screens/setup/steps/review-step.tsx

@@ -0,0 +1,76 @@
+import React from 'react'
+import { Text } from 'ink'
+import { DEVICE_FLOW_BROWSER_HELP } from '../../../../config.ts'
+import type { SelectedSshPublicKey } from '../../../../forgejo.ts'
+import type { TelaCliAuthState, TelaCliForgejoOrganization } from '../../../../types.ts'
+import { AppFrame, Callout, Section } from '../../../components.tsx'
+import { getEnvironmentLabel } from '../steps.ts'
+import type { SetupFormValues } from '../types.ts'
+
+export interface ResolvedReviewConfig {
+    agentApiUrl: string
+    authApiUrl: string
+    authDashboardUrl: string
+    telaApiUrl: string
+    requesterApplicationId: string
+    targetApplicationId: string
+}
+
+export function ReviewStep(props: {
+    values: SetupFormValues
+    resolvedConfig: ResolvedReviewConfig
+    auth: TelaCliAuthState | null
+    selectedOrganization: TelaCliForgejoOrganization | null
+    selectedSshKey: SelectedSshPublicKey | undefined
+    cloneRootState: { exists: boolean, isDirectory: boolean }
+    createCloneRoot: boolean
+}): React.ReactElement {
+    const awaitingAuthentication = !props.auth || !props.selectedOrganization
+
+    return (
+        <AppFrame
+            title="Setup"
+            subtitle={awaitingAuthentication
+                ? 'Review your configuration before signing in.'
+                : 'Review the resolved workspace access before Forgejo provisioning.'}
+            footer={awaitingAuthentication
+                ? 'Enter start sign-in · Space toggle clone-root creation · Esc back'
+                : 'Enter provision Forgejo · Space toggle clone-root creation · Esc back'}
+        >
+            <Section title="Review">
+                <Text>Environment: {getEnvironmentLabel(props.values.environment)}</Text>
+                <Text>Agent API origin: {props.resolvedConfig.agentApiUrl}</Text>
+                <Text>Auth API URL: {props.resolvedConfig.authApiUrl}</Text>
+                <Text>Auth dashboard URL: {props.resolvedConfig.authDashboardUrl}</Text>
+                <Text>Tela API URL: {props.resolvedConfig.telaApiUrl}</Text>
+                <Text>Requester app: {props.resolvedConfig.requesterApplicationId}</Text>
+                <Text>Target app: {props.resolvedConfig.targetApplicationId}</Text>
+                <Text>Clone root: {props.values.cloneRoot}</Text>
+                <Text>User: {props.auth?.user.email ?? '<pending sign-in>'}</Text>
+                <Text>Workspace: {props.auth?.workspace.title ?? '<pending sign-in>'}</Text>
+                <Text>Organization: {props.selectedOrganization?.name ?? '<resolve after sign-in>'}</Text>
+                <Text>Forgejo provisioning: yes</Text>
+                <Text>
+                    SSH key:
+                    {' '}
+                    {props.selectedSshKey
+                        ? `${props.selectedSshKey.title} (${props.selectedSshKey.path})`
+                        : '<missing>'}
+                </Text>
+                <Text>
+                    Clone root state:
+                    {' '}
+                    {props.cloneRootState.exists
+                        ? (props.cloneRootState.isDirectory ? 'existing directory' : 'existing non-directory path')
+                        : 'missing'}
+                </Text>
+                {!props.cloneRootState.exists ? (
+                    <Text>Create clone root if missing: {props.createCloneRoot ? 'yes' : 'no'}</Text>
+                ) : null}
+            </Section>
+            {awaitingAuthentication ? (
+                <Callout tone="info">{DEVICE_FLOW_BROWSER_HELP}</Callout>
+            ) : null}
+        </AppFrame>
+    )
+}

package/src/ink/screens/setup/steps/running-step.tsx

@@ -0,0 +1,36 @@
+import React from 'react'
+import { Text } from 'ink'
+import { DEVICE_FLOW_BROWSER_HELP } from '../../../../config.ts'
+import { AppFrame, Callout, Section, SpinnerText } from '../../../components.tsx'
+
+export function RunningStep(props: {
+    stage: 'auth' | 'provision'
+    organizationName?: string
+    verificationUrl: string | null
+    userCode: string | null
+    progressLines: string[]
+}): React.ReactElement {
+    const provisioning = props.stage === 'provision'
+
+    return (
+        <AppFrame
+            title="Setup"
+            subtitle={provisioning
+                ? 'Provisioning Forgejo access for the selected workspace organization.'
+                : 'Authenticating your Tela workspace.'}
+            status={provisioning
+                ? `Provisioning Forgejo access${props.organizationName ? ` for ${props.organizationName}` : ''}`
+                : 'Waiting for browser-based authorization'}
+        >
+            <Section title={provisioning ? 'Provisioning' : 'Authentication'}>
+                <SpinnerText label={provisioning ? 'Provisioning Forgejo access' : 'Polling auth approval'} />
+                {!provisioning && props.verificationUrl ? <Text>Verification URL: {props.verificationUrl}</Text> : null}
+                {!provisioning && props.userCode ? <Text>User code: {props.userCode}</Text> : null}
+                {props.progressLines.map((line, index) => (
+                    <Text key={`${index}-${line}`}>{line}</Text>
+                ))}
+            </Section>
+            {!provisioning ? <Callout tone="info">{DEVICE_FLOW_BROWSER_HELP}</Callout> : null}
+        </AppFrame>
+    )
+}

package/src/ink/screens/setup/steps/ssh-key-step.tsx

@@ -0,0 +1,47 @@
+import React from 'react'
+import { Callout, SelectList } from '../../../components.tsx'
+import type { SelectedSshPublicKey } from '../../../../forgejo.ts'
+import { CUSTOM_SSH_KEY_OPTION } from '../types.ts'
+
+export interface SshKeyOption {
+    key: string
+    label: string
+    hint?: string
+}
+
+export function buildSshKeyOptions(sshPublicKeys: SelectedSshPublicKey[]): SshKeyOption[] {
+    return [
+        ...sshPublicKeys.map(key => ({
+            key: key.path,
+            label: key.title,
+            hint: key.path,
+        })),
+        {
+            key: CUSTOM_SSH_KEY_OPTION,
+            label: 'Custom path…',
+            hint: 'Load another public key file',
+        },
+    ]
+}
+
+export function SshKeyStep(props: {
+    options: SshKeyOption[]
+    selection: string
+    hasDiscoveredKeys: boolean
+}): React.ReactElement {
+    const currentIndex = Math.max(
+        props.options.findIndex(option => option.key === props.selection),
+        0,
+    )
+
+    return (
+        <>
+            <SelectList items={props.options} currentIndex={currentIndex} />
+            {!props.hasDiscoveredKeys ? (
+                <Callout tone="info">
+                    No `~/.ssh/*.pub` keys were found. Use Custom path… to continue.
+                </Callout>
+            ) : null}
+        </>
+    )
+}

package/src/ink/screens/setup/steps/text-field-step.tsx

@@ -0,0 +1,17 @@
+import React from 'react'
+import { TextEntry } from '../../../components.tsx'
+
+export function TextFieldStep(props: {
+    value: string
+    placeholder?: string
+    error?: string
+}): React.ReactElement {
+    return (
+        <TextEntry
+            label=""
+            value={props.value}
+            placeholder={props.placeholder}
+            error={props.error}
+        />
+    )
+}

package/src/ink/screens/setup/steps.ts

@@ -0,0 +1,145 @@
+import { ENVIRONMENT_PRESET_OPTIONS } from '../../../config.ts'
+import { CUSTOM_SSH_KEY_OPTION, type SetupFormValues } from './types.ts'
+
+export type SetupStepId =
+    | 'environment'
+    | 'agentApiUrl'
+    | 'authApiUrl'
+    | 'authDashboardUrl'
+    | 'telaApiUrl'
+    | 'requesterApplicationId'
+    | 'targetApplicationId'
+    | 'cloneRoot'
+    | 'sshKey'
+    | 'sshKeyPath'
+
+export type SetupStepKind = 'select-environment' | 'select-ssh-key' | 'text'
+
+export interface SetupStepDescriptor {
+    id: SetupStepId
+    label: string
+    question: string
+    kind: SetupStepKind
+    placeholder?: string
+    visible: (values: SetupFormValues) => boolean
+}
+
+export const EDIT_STEPS: readonly SetupStepDescriptor[] = [
+    {
+        id: 'environment',
+        label: 'Environment',
+        question: 'Which Tela environment do you want to use?',
+        kind: 'select-environment',
+        visible: () => true,
+    },
+    {
+        id: 'agentApiUrl',
+        label: 'Agent API URL',
+        question: 'Custom Agent API origin URL',
+        kind: 'text',
+        placeholder: 'https://agent-api.example.com',
+        visible: values => values.environment === 'custom',
+    },
+    {
+        id: 'authApiUrl',
+        label: 'Auth API URL',
+        question: 'Custom Auth API URL',
+        kind: 'text',
+        placeholder: 'https://auth.example.com',
+        visible: values => values.environment === 'custom',
+    },
+    {
+        id: 'authDashboardUrl',
+        label: 'Auth Dashboard URL',
+        question: 'Custom Auth dashboard URL',
+        kind: 'text',
+        placeholder: 'https://accounts.example.com',
+        visible: values => values.environment === 'custom',
+    },
+    {
+        id: 'telaApiUrl',
+        label: 'Tela API URL',
+        question: 'Custom Tela API URL',
+        kind: 'text',
+        placeholder: 'https://api.example.com',
+        visible: values => values.environment === 'custom',
+    },
+    {
+        id: 'requesterApplicationId',
+        label: 'Requester App ID',
+        question: 'Requester application ID',
+        kind: 'text',
+        placeholder: '00000000-0000-0000-0000-000000000000',
+        visible: values => values.environment === 'custom',
+    },
+    {
+        id: 'targetApplicationId',
+        label: 'Target App ID',
+        question: 'Target application ID',
+        kind: 'text',
+        placeholder: '00000000-0000-0000-0000-000000000000',
+        visible: values => values.environment === 'custom',
+    },
+    {
+        id: 'cloneRoot',
+        label: 'Clone Root',
+        question: 'Clone root directory',
+        kind: 'text',
+        placeholder: '/path/to/Code/Tela',
+        visible: () => true,
+    },
+    {
+        id: 'sshKey',
+        label: 'SSH Key',
+        question: 'Pick an SSH public key for Forgejo provisioning',
+        kind: 'select-ssh-key',
+        visible: () => true,
+    },
+    {
+        id: 'sshKeyPath',
+        label: 'SSH Key Path',
+        question: 'Path to your SSH public key',
+        kind: 'text',
+        placeholder: '~/.ssh/id_ed25519.pub',
+        visible: values => values.sshKeySelection === CUSTOM_SSH_KEY_OPTION,
+    },
+]
+
+export function getVisibleEditSteps(values: SetupFormValues): SetupStepDescriptor[] {
+    return EDIT_STEPS.filter(step => step.visible(values))
+}
+
+export function getEnvironmentLabel(value: string): string {
+    return ENVIRONMENT_PRESET_OPTIONS.find(option => option.value === value)?.label ?? value
+}
+
+export function summarizeStep(
+    step: SetupStepDescriptor,
+    values: SetupFormValues,
+    sshKeyTitle: string | undefined,
+): string {
+    switch (step.id) {
+        case 'environment':
+            return getEnvironmentLabel(values.environment)
+        case 'agentApiUrl':
+            return values.agentApiUrl
+        case 'authApiUrl':
+            return values.authApiUrl
+        case 'authDashboardUrl':
+            return values.authDashboardUrl
+        case 'telaApiUrl':
+            return values.telaApiUrl
+        case 'requesterApplicationId':
+            return values.requesterApplicationId
+        case 'targetApplicationId':
+            return values.targetApplicationId
+        case 'cloneRoot':
+            return values.cloneRoot
+        case 'sshKey':
+            return values.sshKeySelection === CUSTOM_SSH_KEY_OPTION
+                ? 'Custom path…'
+                : (sshKeyTitle ?? values.sshKeySelection)
+        case 'sshKeyPath':
+            return values.sshKeyPath
+    }
+}

package/src/ink/screens/setup/types.ts

@@ -0,0 +1,63 @@
+import type { SetupAuthEvent } from '../../../auth.ts'
+import type { SetupConfigInput } from '../../../config.ts'
+import type { SelectedSshPublicKey } from '../../../forgejo.ts'
+import type {
+    TelaCliAuthState,
+    TelaCliConfig,
+    TelaCliForgejoOrganization,
+} from '../../../types.ts'
+import type { CommandScreenController } from '../../runtime.tsx'
+
+export const CUSTOM_SSH_KEY_OPTION = '__custom__'
+
+export type SetupFormValues = SetupConfigInput & {
+    sshKeySelection: string
+    sshKeyPath: string
+}
+
+export interface SetupScreenResult {
+    ok: true
+    config: TelaCliConfig
+    warnings: string[]
+    nextActions: string[]
+    checks: Array<{ label: string, status: string, detail: string }>
+}
+
+export interface SetupScreenProps {
+    controller: CommandScreenController<SetupScreenResult>
+    currentConfigSummary: string[]
+    defaults: SetupConfigInput & {
+        forgejoOrganization: TelaCliForgejoOrganization | null
+        forgejoUserRegistered: boolean
+    }
+    sshPublicKeys: SelectedSshPublicKey[]
+    validateAgentApiUrl: (value: string) => string | undefined
+    validateAuthApiUrl: (value: string) => string | undefined
+    validateAuthDashboardUrl: (value: string) => string | undefined
+    validateTelaApiUrl: (value: string) => string | undefined
+    validateApplicationId: (value: string, label?: string) => string | undefined
+    validateCloneRoot: (value: string) => string | undefined
+    inspectCloneRoot: (path: string) => {
+        exists: boolean
+        isDirectory: boolean
+    }
+    authenticate: (
+        input: SetupConfigInput,
+        onEvent: (event: SetupAuthEvent) => void,
+    ) => Promise<TelaCliAuthState>
+    resolveOrganizations: (
+        input: SetupConfigInput & { auth: TelaCliAuthState },
+    ) => Promise<{
+        organizations: TelaCliForgejoOrganization[]
+        preferredOrganization: TelaCliForgejoOrganization | null
+    }>
+    execute: (
+        input: SetupConfigInput & {
+            createCloneRoot: boolean
+            sshKey: SelectedSshPublicKey
+            auth: TelaCliAuthState
+            organization: TelaCliForgejoOrganization
+        },
+        onEvent: (event: Pick<SetupAuthEvent, 'message' | 'title'>) => void,
+    ) => Promise<SetupScreenResult>
+}