@meistrari/tela-cli 0.6.0 → 0.7.4

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

@@ -1,34 +0,0 @@
-import React from 'react'
-import { Text } from 'ink'
-import { AppFrame, Section, SelectList } from '../../../components.tsx'
-import type { TelaCliAuthState, TelaCliForgejoOrganization } from '../../../../types.ts'
-
-export function OrganizationStep(props: {
-    auth: TelaCliAuthState
-    organizations: TelaCliForgejoOrganization[]
-    currentIndex: number
-    preferredOrganizationId?: string
-}): React.ReactElement {
-    return (
-        <AppFrame
-            title="Setup"
-            subtitle="Choose the workspace organization for Forgejo access."
-            footer="↑/↓ choose · Enter continue · Esc back"
-        >
-            <Section title="Authenticated">
-                <Text>User: {props.auth.user.email}</Text>
-                <Text>Workspace: {props.auth.workspace.title}</Text>
-            </Section>
-            <Section title="Forgejo organization">
-                <SelectList
-                    items={props.organizations.map(organization => ({
-                        key: organization.id,
-                        label: organization.name,
-                        hint: organization.id === props.preferredOrganizationId ? 'saved from previous setup' : undefined,
-                    }))}
-                    currentIndex={props.currentIndex}
-                />
-            </Section>
-        </AppFrame>
-    )
-}

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

@@ -1,77 +0,0 @@
-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>SSH private key: {props.values.sshPrivateKeyPath || '<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

@@ -1,36 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,156 +0,0 @@
-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'
-    | 'sshPrivateKeyPath'
-
-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,
-    },
-    {
-        id: 'sshPrivateKeyPath',
-        label: 'Private Key Path',
-        question: 'Path to your SSH private key',
-        kind: 'text',
-        placeholder: '~/.ssh/id_ed25519',
-        visible: () => true,
-    },
-]
-
-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
-        case 'sshPrivateKeyPath':
-            return values.sshPrivateKeyPath
-    }
-}

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

@@ -1,65 +0,0 @@
-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
-    sshPrivateKeyPath: 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
-            sshPrivateKeyPath: string
-            auth: TelaCliAuthState
-            organization: TelaCliForgejoOrganization
-        },
-        onEvent: (event: Pick<SetupAuthEvent, 'message' | 'title'>) => void,
-    ) => Promise<SetupScreenResult>
-}