FilesExpand file tree

main

/

agent-command-line-entrypoint.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

132 lines (123 loc) · 3.48 KB

main

/

agent-command-line-entrypoint.ts

Copy path

Top

File metadata and controls

• Code
• Blame

132 lines (123 loc) · 3.48 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

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

/**

* Finding the real entrypoint inside an interpreter command line.

*

* Split out of `agent-process-recognition.ts`: recognizing WHICH agent a process is is a

* separate concern from parsing a `node …/cli.js` / `python -m pkg` argv down to the token

* that names it. Only the latter lives here.

*/

const PROCESS_EXTENSION_RE = /\.(?:exe|cmd|bat|ps1)$/i

const STATIC_INTERPRETER_PROCESS_NAMES = new Set([

'node',

'python',

'python3',

'bash',

'zsh',

'sh',

'fish',

'pwsh',

'powershell'

])

export const PYTHON_PROCESS_RE = /^python(?:\d+(?:\.\d+)*)?$/

const INTERPRETER_OPTIONS_WITH_VALUE = new Set([

'-r',

'--require',

'--import',

'--loader',

'--experimental-loader'

])

const INTERPRETER_OPTIONS_WITH_INLINE_SOURCE = new Set(['-e', '--eval', '-p', '--print', '--check'])

export function isInterpreterProcessName(normalized: string): boolean {

return STATIC_INTERPRETER_PROCESS_NAMES.has(normalized) || PYTHON_PROCESS_RE.test(normalized)

}

export function tokenizeCommandLine(commandLine: string): string[] {

const tokens: string[] = []

let current = ''

let quote: '"' | "'" | null = null

let escaped = false

for (let index = 0; index < commandLine.length; index += 1) {

const char = commandLine[index]

if (escaped) {

current += char

escaped = false

continue

}

if (char === '\\' && quote !== "'") {

const next = commandLine[index + 1]

if (next && (/\s/.test(next) || next === '"' || next === "'" || next === '\\')) {

escaped = true

continue

}

}

if ((char === '"' || char === "'") && quote === null) {

quote = char

continue

}

if (quote === char) {

quote = null

continue

}

if (/\s/.test(char) && quote === null) {

if (current) {

tokens.push(current)

current = ''

}

continue

}

current += char

}

if (current) {

tokens.push(current)

}

return tokens

}

function tokenLooksExecutable(token: string, index: number, firstNormalized: string): boolean {

if (index === 0) {

return true

}

if (!isInterpreterProcessName(firstNormalized)) {

return false

}

// Why: only inspect interpreter script paths. Prompt text can mention other

// agents ("compare opencode vs orca"), and treating every argv token as an

// executable would reintroduce the substring-style false identity class that

// foreground-process detection is meant to avoid.

return token.includes('/') || token.includes('\\') || PROCESS_EXTENSION_RE.test(token)

}

export function findInterpreterEntrypointToken(

tokens: string[],

firstNormalized: string

): string | null {

if (!isInterpreterProcessName(firstNormalized)) {

return null

}

for (let index = 1; index < tokens.length; index += 1) {

const token = tokens[index]

if (token === '--') {

continue

}

if (PYTHON_PROCESS_RE.test(firstNormalized) && token === '-m') {

return tokens[index + 1] ?? null

}

if (token.startsWith('-')) {

const name = token.split('=', 1)[0] ?? ''

if (INTERPRETER_OPTIONS_WITH_INLINE_SOURCE.has(name)) {

return null

}

if (INTERPRETER_OPTIONS_WITH_VALUE.has(name) && name === token) {

index += 1

}

continue

}

if (tokenLooksExecutable(token, index, firstNormalized)) {

return token

}

}

return null

}

export function comparablePath(token: string): string {

return token

.trim()

.replace(/^["']|["']$/g, '')

.replace(/\\/g, '/')

.toLowerCase()

}