FilesExpand file tree

main

/

opencode-database-discovery.ts

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

112 lines (104 loc) · 3.8 KB

main

/

opencode-database-discovery.ts

Copy path

Top

File metadata and controls

• Code
• Blame

112 lines (104 loc) · 3.8 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

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

import { basename, join } from 'node:path'

import { wslGatedReaddir, wslGatedStat } from '../native-chat/wsl-transcript-fs-access'

import { WslTranscriptFsError } from '../native-chat/wsl-transcript-fs-gate'

import {

resolveOpenCodeDataDirectory,

resolveOpenCodeDatabasePath

} from '../opencode/opencode-data-directory'

import type { OpenCodeUsageProcessedDatabase } from './types'

type OpenCodeDatabaseOverride = {

isConfigured: boolean

path: string | null

}

function getOpenCodeDatabaseOverride(environment: NodeJS.ProcessEnv): OpenCodeDatabaseOverride {

const raw = environment.OPENCODE_DB?.trim()

if (!raw) {

return { isConfigured: false, path: null }

}

return {

isConfigured: true,

path: resolveOpenCodeDatabasePath(environment)

}

}

// Why gated: the AI Vault's primary OpenCode source delegates here from inside

// its discovery fan-out, so a UNC data dir or a UNC OPENCODE_DB on a stalled

// distro would otherwise hang the whole scan on a raw syscall (STA-4049).

export async function listOpenCodeDatabases(

/** Lets a caller report the refusal; an empty list otherwise reads as

* "OpenCode not used" rather than "we could not look". */

onRefusal?: (path: string, error: WslTranscriptFsError) => void,

/** Every other stat/readdir failure, including ENOENT; also read as an empty list. */

onFsError?: (path: string, error: unknown) => void,

signal?: AbortSignal,

environment: NodeJS.ProcessEnv = process.env

): Promise<string[]> {

const dataDirectory = resolveOpenCodeDataDirectory(environment)

const databaseOverride = getOpenCodeDatabaseOverride(environment)

if (databaseOverride.isConfigured) {

if (!databaseOverride.path) {

return []

}

try {

return (await wslGatedStat(databaseOverride.path, 'scan', signal)).isFile()

? [databaseOverride.path]

: []

} catch (error) {

signal?.throwIfAborted()

reportFailure(databaseOverride.path, error, onRefusal, onFsError)

return []

}

}

return listOpenCodeDatabasesInDirectory(dataDirectory, onRefusal, signal, onFsError)

}

export async function listOpenCodeDatabasesInDirectory(

dataDirectory: string,

onRefusal?: (path: string, error: WslTranscriptFsError) => void,

signal?: AbortSignal,

onFsError?: (path: string, error: unknown) => void

): Promise<string[]> {

try {

const entries = await wslGatedReaddir(dataDirectory, 'scan', signal)

return entries

.filter((entry) => entry.isFile() && /^opencode(?:-[A-Za-z0-9_.-]+)?\.db$/.test(entry.name))

.map((entry) => join(dataDirectory, entry.name))

.sort()

} catch (error) {

signal?.throwIfAborted()

reportFailure(dataDirectory, error, onRefusal, onFsError)

return []

}

}

function reportFailure(

path: string,

error: unknown,

onRefusal?: (path: string, error: WslTranscriptFsError) => void,

onFsError?: (path: string, error: unknown) => void

): void {

if (error instanceof WslTranscriptFsError) {

onRefusal?.(path, error)

} else {

onFsError?.(path, error)

}

}

export function compareOpenCodeClaimPriority(left: string, right: string): number {

// Why: the canonical opencode.db is the live database; it must claim

// duplicated sessions ahead of stale sibling copies. Remaining ties use

// path order so ownership is deterministic across rescans.

const leftRank = basename(left).toLowerCase() === 'opencode.db' ? 0 : 1

const rightRank = basename(right).toLowerCase() === 'opencode.db' ? 0 : 1

if (leftRank !== rightRank) {

return leftRank - rightRank

}

return left < right ? -1 : left > right ? 1 : 0

}

export async function getProcessedDatabaseInfo(

dbPath: string

): Promise<OpenCodeUsageProcessedDatabase> {

const dbStat = await stat(dbPath)

return {

path: dbPath,

mtimeMs: dbStat.mtimeMs,

size: dbStat.size

}

}