FilesExpand file tree

main

/

opencode-credential-backend.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

91 lines (86 loc) · 2.65 KB

main

/

opencode-credential-backend.ts

Copy path

Top

File metadata and controls

• Code
• Blame

91 lines (86 loc) · 2.65 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

import { runProcess } from '@orca/process-host'

import { resolveCommandOnLocalPath } from '../ipc/command-path-resolver'

import { createHash } from 'node:crypto'

import { realpath, stat } from 'node:fs/promises'

export type OpenCodeCredentialBackend = 'v1' | 'v2'

// Native runtime processes own separate execution-host caches.

const probes = new Map<

string,

{ result: Promise<OpenCodeCredentialBackend | null>; expiresAt: number }

>()

const MAX_PROBES = 32

export function resetOpenCodeCredentialBackendProbes(): void {

probes.clear()

}

export async function detectOpenCodeCredentialBackend(

environment: NodeJS.ProcessEnv = process.env,

cwd = process.cwd()

): Promise<OpenCodeCredentialBackend | null> {

// The execution host's default CLI owns this lookup; table presence proves neither backend.

const program =

(await resolveCommandOnLocalPath('opencode', { env: environment, cwd })) ??

(await resolveCommandOnLocalPath('opencode2', { env: environment, cwd }))

if (!program) {

return null

}

try {

const binary = await realpath(program)

const identity = await stat(binary)

const environmentDigest = createHash('sha256')

.update(JSON.stringify(Object.entries(environment).sort(([a], [b]) => a.localeCompare(b))))

.digest('hex')

const key = JSON.stringify([

binary,

identity.dev,

identity.ino,

identity.size,

identity.mtimeMs,

identity.ctimeMs,

cwd,

environmentDigest

])

const cached = probes.get(key)

if (cached && cached.expiresAt > Date.now()) {

return cached.result

}

const result = probeBackend(binary, environment, cwd)

const entry = { result, expiresAt: Number.POSITIVE_INFINITY }

probes.set(key, entry)

if (probes.size > MAX_PROBES) {

const oldest = probes.keys().next().value

if (oldest !== undefined) {

probes.delete(oldest)

}

}

const backend = await result

entry.expiresAt = Date.now() + (backend ? 60_000 : 5_000)

return backend

} catch {

return null

}

}

async function probeBackend(

program: string,

environment: NodeJS.ProcessEnv,

cwd: string

): Promise<OpenCodeCredentialBackend | null> {

try {

const result = await runProcess({

program,

args: ['--version'],

env: environment,

cwd,

timeoutMs: 5_000,

maxOutputBytes: 1_024

})

if (result.code !== 0 || result.timedOut || result.outputTruncated) {

return null

}

const version = /^(?:opencode\s+)?v?([12])\.\d+\.\d+(?:[-+][\w.-]+)?$/i.exec(

result.stdout.trim()

)

return version?.[1] === '1' ? 'v1' : version?.[1] === '2' ? 'v2' : null

} catch {

return null

}

}