FilesExpand file tree

main

/

terminal.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

83 lines (81 loc) · 3.15 KB

main

/

terminal.ts

Copy path

Top

File metadata and controls

• Code
• Blame

83 lines (81 loc) · 3.15 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

import type { Command } from 'commander'

import { dump } from 'js-yaml'

import { styles } from '#sim-cli/output/presentation'

import { CliUpdateError } from '#sim-cli/update/install'

import { ProfileConfigError } from './config/index'

import { profileFrom } from './context'

import {

formatApiErrorDetails,

isRequestTimeout,

RAISE_TIMEOUT_HINT,

SimApiError,

} from './http/client'

import { sanitize } from './output/render'

import { buildProgram } from './program'

import { createCommandTelemetry } from './telemetry/index'

/**

* Prints the one-line explanation for an error the CLI understands and returns

* the exit code it deserves, or `null` for an error it does not: that is a bug

* in the CLI, and hiding it behind a friendly message would make it

* unreportable, so the caller lets it keep its stack trace.

*/

function explainFailure(error: unknown, program: Command): number | null {

if (error instanceof ProfileConfigError || error instanceof CliUpdateError) {

console.error(styles().red(`Error: ${sanitize(error.message)}`))

return 1

}

// `AbortSignal.timeout` keeps firing after `fetch` resolves, so a bound that

// elapses while the body is still being read — a large `files get`, say —

// surfaces here rather than inside the client. A user's own Ctrl-C raises

// `AbortError` instead, which is deliberately left alone.

if (isRequestTimeout(error)) {

console.error(styles().red(`Error: the request timed out. ${RAISE_TIMEOUT_HINT}`))

return 1

}

if (error instanceof SimApiError) {

let output = program.opts().output

try {

output = profileFrom(program).output

} catch {

/** Preserve the original error when configuration is invalid. */

}

if (output === 'json' || output === 'yaml') {

const payload = {

error: {

code: error.code ?? 'CLI_ERROR',

message: error.message,

...(error.details === undefined ? {} : { details: error.details }),

},

}

process.stderr.write(output === 'json' ? `${JSON.stringify(payload)}\n` : dump(payload))

return error.exitCode

}

console.error(styles().red(`Error: ${sanitize(error.message)}`))

if (error.code) console.error(styles().dim(` code: ${sanitize(error.code)}`))

if (error.details !== undefined) {

for (const line of formatApiErrorDetails(error.details)) {

console.error(styles().dim(sanitize(line)))

}

}

return error.exitCode

}

return null

}

/**

* Anything the CLI can explain prints as one line and exits with its code. A

* failure is reported here, where its class and code are known; every other

* way the process ends is reported from the exit listener telemetry installs.

*/

export async function runTerminalCli(suppliedProgram?: Command): Promise<void> {

const telemetry = suppliedProgram ? undefined : createCommandTelemetry()

const program = suppliedProgram ?? buildProgram()

telemetry?.observe(program)

try {

await program.parseAsync(process.argv)

} catch (error) {

const exitCode = explainFailure(error, program)

telemetry?.complete({ exitCode: exitCode ?? 1, error })

if (exitCode === null) throw error

process.exit(exitCode)

}

}