FilesExpand file tree

main

/

gitlab-known-host-probe.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

227 lines (211 loc) · 7.93 KB

main

/

gitlab-known-host-probe.ts

Copy path

Top

File metadata and controls

• Code
• Blame

227 lines (211 loc) · 7.93 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

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

import { runCoalescedProbe, type CoalescedProbes } from '../git/coalesced-probe'

import { NEGATIVE_ENTRY_TTL_MS } from '../git/remote-ref-probe-cache'

import { glabExecFileAsync } from '../git/runner'

import { DEFAULT_GITLAB_HOSTS, normalizeGitLabHost } from './project-ref-parser'

import type { GitAdmissionTier } from '../git/command-runner/git-exec-options'

export type LocalGitExecOptions = {

wslDistro?: string

admissionTier?: GitAdmissionTier

}

const GLAB_KNOWN_HOSTS_TIMEOUT_MS = 10_000

const UNAUTHENTICATED_HOSTS_MAX_ENTRIES = 128

export const KNOWN_HOSTS_CACHE_MAX_ENTRIES = 128

export const KNOWN_HOSTS_FAILURE_INITIAL_BACKOFF_MS = 15_000

const knownHostsCacheByExecutionContext = new Map<string, readonly string[]>()

// Failed probes back off exponentially (capped) so locked keyrings are not re-prompted on every poll.

const knownHostsFailureBackoff = new Map<string, { retryAt: number; delayMs: number }>()

const knownHostsInFlightByExecutionContext: CoalescedProbes<readonly string[]> = new Map()

const unauthenticatedHostExpiries = new Map<string, number>()

function knownHostsExecutionKey(

connectionId?: string | null,

localGitOptions: LocalGitExecOptions = {}

): string {

if (connectionId) {

return `connection:${connectionId}`

}

return localGitOptions.wslDistro ? `wsl:${localGitOptions.wslDistro}` : 'native'

}

/** @internal - exposed for tests only */

export function _resetKnownHostsCache(): void {

knownHostsCacheByExecutionContext.clear()

knownHostsInFlightByExecutionContext.clear()

knownHostsFailureBackoff.clear()

unauthenticatedHostExpiries.clear()

}

/** @internal - exposed for tests only */

export function _resetGlabUnauthenticatedHosts(): void {

unauthenticatedHostExpiries.clear()

}

/** @internal - exposed for cache-bound tests only. */

export function _getKnownHostsCacheSize(): number {

return knownHostsCacheByExecutionContext.size

}

function trimKnownHostsCache(): void {

while (knownHostsCacheByExecutionContext.size > KNOWN_HOSTS_CACHE_MAX_ENTRIES) {

const oldest = knownHostsCacheByExecutionContext.keys().next()

if (oldest.done) {

break

}

knownHostsCacheByExecutionContext.delete(oldest.value)

}

}

function unauthenticatedHostKey(

host: string,

connectionId?: string | null,

localGitOptions: LocalGitExecOptions = {}

): string {

return `${knownHostsExecutionKey(connectionId, localGitOptions)}\0${normalizeGitLabHost(host)}`

}

/** Share negative host-auth probes across repositories until expiry, avoiding a subprocess per repo on each poll. */

export function isGlabHostKnownUnauthenticated(

host: string,

connectionId?: string | null,

localGitOptions: LocalGitExecOptions = {}

): boolean {

const key = unauthenticatedHostKey(host, connectionId, localGitOptions)

const expiresAt = unauthenticatedHostExpiries.get(key)

if (expiresAt === undefined) {

return false

}

if (expiresAt > Date.now()) {

return true

}

unauthenticatedHostExpiries.delete(key)

return false

}

export function rememberGlabHostUnauthenticated(

host: string,

connectionId?: string | null,

localGitOptions: LocalGitExecOptions = {}

): void {

unauthenticatedHostExpiries.set(

unauthenticatedHostKey(host, connectionId, localGitOptions),

Date.now() + NEGATIVE_ENTRY_TTL_MS

)

while (unauthenticatedHostExpiries.size > UNAUTHENTICATED_HOSTS_MAX_ENTRIES) {

const oldestKey = unauthenticatedHostExpiries.keys().next().value

if (oldestKey === undefined) {

return

}

unauthenticatedHostExpiries.delete(oldestKey)

}

}

export function rememberGlabKnownHost(

host: string,

connectionId?: string | null,

localGitOptions: LocalGitExecOptions = {}

): void {

rememberGlabKnownHosts([host], connectionId, localGitOptions)

}

export function rememberGlabKnownHosts(

hosts: readonly string[],

connectionId?: string | null,

localGitOptions: LocalGitExecOptions = {}

): void {

const key = knownHostsExecutionKey(connectionId, localGitOptions)

knownHostsFailureBackoff.delete(key)

const cached = knownHostsCacheByExecutionContext.get(key) ?? DEFAULT_GITLAB_HOSTS

const seen = new Set(cached.map(normalizeGitLabHost))

const additions: string[] = []

for (const host of hosts) {

const normalizedHost = normalizeGitLabHost(host)

if (seen.has(normalizedHost)) {

continue

}

seen.add(normalizedHost)

additions.push(normalizedHost)

unauthenticatedHostExpiries.delete(

unauthenticatedHostKey(normalizedHost, connectionId, localGitOptions)

)

}

if (additions.length === 0) {

return

}

knownHostsCacheByExecutionContext.set(key, [...cached, ...additions])

trimKnownHostsCache()

}

export async function getGlabKnownHosts(

connectionId?: string | null,

localGitOptions: LocalGitExecOptions = {}

): Promise<readonly string[]> {

const key = knownHostsExecutionKey(connectionId, localGitOptions)

const cached = knownHostsCacheByExecutionContext.get(key)

if (cached) {

knownHostsCacheByExecutionContext.delete(key)

knownHostsCacheByExecutionContext.set(key, cached)

return cached

}

if ((knownHostsFailureBackoff.get(key)?.retryAt ?? 0) > Date.now()) {

return [...DEFAULT_GITLAB_HOSTS]

}

// Retire wedged probes so later retries can discover recovered auth.

return runCoalescedProbe(knownHostsInFlightByExecutionContext, key, (ownsKey) =>

probeGlabKnownHosts(key, ownsKey, connectionId, localGitOptions)

)

}

async function probeGlabKnownHosts(

key: string,

ownsKey: () => boolean,

connectionId?: string | null,

localGitOptions: LocalGitExecOptions = {}

): Promise<readonly string[]> {

try {

// Isolate native, WSL and connection probe state; bound each auth subprocess.

const { stdout, stderr } = await glabExecFileAsync(['auth', 'status'], {

timeout: GLAB_KNOWN_HOSTS_TIMEOUT_MS,

// Native probes must not cache default-distro auth; connection-keyed API calls retain that same fallback.

...(connectionId ? {} : { allowDefaultWslFallback: false }),

...(!connectionId && localGitOptions.wslDistro

? { wslDistro: localGitOptions.wslDistro }

: {}),

...(localGitOptions.admissionTier ? { admissionTier: localGitOptions.admissionTier } : {})

})

const hosts = parseGlabAuthStatusHosts(`${stdout}\n${stderr}`)

const remembered = knownHostsCacheByExecutionContext.get(key) ?? []

const merged = Array.from(new Set([...DEFAULT_GITLAB_HOSTS, ...remembered, ...hosts]))

if (ownsKey()) {

knownHostsFailureBackoff.delete(key)

knownHostsCacheByExecutionContext.set(key, merged)

trimKnownHostsCache()

}

return merged

} catch {

if (ownsKey()) {

rememberKnownHostsFailure(key)

}

return knownHostsCacheByExecutionContext.get(key) ?? [...DEFAULT_GITLAB_HOSTS]

}

}

function rememberKnownHostsFailure(key: string): void {

const previousDelayMs = knownHostsFailureBackoff.get(key)?.delayMs

const delayMs = previousDelayMs

? Math.min(previousDelayMs * 2, NEGATIVE_ENTRY_TTL_MS)

: KNOWN_HOSTS_FAILURE_INITIAL_BACKOFF_MS

knownHostsFailureBackoff.delete(key)

knownHostsFailureBackoff.set(key, { retryAt: Date.now() + delayMs, delayMs })

while (knownHostsFailureBackoff.size > KNOWN_HOSTS_CACHE_MAX_ENTRIES) {

const oldestKey = knownHostsFailureBackoff.keys().next().value

if (oldestKey === undefined) {

return

}

knownHostsFailureBackoff.delete(oldestKey)

}

}

export function parseGlabAuthStatusHosts(output: string): string[] {

const hosts = new Set<string>()

// Preserve non-default web ports so same-host services retain distinct identity.

for (const match of output.matchAll(/logged in to ([a-zA-Z0-9.-]+(?::\d+)?)/gi)) {

hosts.add(match[1].toLowerCase())

}

for (const line of output.split('\n')) {

const bareLine = line.trim()

const hostLine = bareLine.endsWith(':') ? bareLine.slice(0, -1) : bareLine

if (

line === bareLine &&

/^[a-zA-Z0-9](?:[a-zA-Z0-9.-]*[a-zA-Z0-9])?(?::\d+)?$/.test(hostLine)

) {

hosts.add(hostLine.toLowerCase())

}

}

return Array.from(hosts)

}