Swadhin Biswas feat: implement mervelas cli engine, built-in tools, and reactive UI · 4/3/2026
0358986
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
import { mkdir, open } from 'fs/promises'
import { join } from 'path'
import { getSessionId } from '../bootstrap/state.js'
import type { PastedContent } from './config.js'
import { logForDebugging } from './debug.js'
import { getClaudeConfigHomeDir } from './envUtils.js'
import { getFsImplementation } from './fsOperations.js'
const IMAGE_STORE_DIR = 'image-cache'
const MAX_STORED_IMAGE_PATHS = 200
// In-memory cache of stored image paths
const storedImagePaths = new Map<number, string>()
/**
* Get the image store directory for the current session.
*/
function getImageStoreDir(): string {
return join(getClaudeConfigHomeDir(), IMAGE_STORE_DIR, getSessionId())
}
/**
* Ensure the image store directory exists.
*/
async function ensureImageStoreDir(): Promise<void> {
const dir = getImageStoreDir()
await mkdir(dir, { recursive: true })
}
/**
* Get the file path for an image by ID.
*/
function getImagePath(imageId: number, mediaType: string): string {
const extension = mediaType.split('/')[1] || 'png'
return join(getImageStoreDir(), `${imageId}.${extension}`)
}
/**
* Cache the image path immediately (fast, no file I/O).
*/
export function cacheImagePath(content: PastedContent): string | null {
if (content.type !== 'image') {
return null
}
const imagePath = getImagePath(content.id, content.mediaType || 'image/png')
evictOldestIfAtCap()
storedImagePaths.set(content.id, imagePath)
return imagePath
}
/**
* Store an image from pastedContents to disk.
*/
export async function storeImage(
content: PastedContent,
): Promise<string | null> {
if (content.type !== 'image') {
return null
}
try {
await ensureImageStoreDir()
const imagePath = getImagePath(content.id, content.mediaType || 'image/png')
const fh = await open(imagePath, 'w', 0o600)
try {
await fh.writeFile(content.content, { encoding: 'base64' })
await fh.datasync()
} finally {
await fh.close()
}
evictOldestIfAtCap()
storedImagePaths.set(content.id, imagePath)
logForDebugging(`Stored image ${content.id} to ${imagePath}`)
return imagePath
} catch (error) {
logForDebugging(`Failed to store image: ${error}`)
return null
}
}
/**
* Store all images from pastedContents to disk.
*/
export async function storeImages(
pastedContents: Record<number, PastedContent>,
): Promise<Map<number, string>> {
const pathMap = new Map<number, string>()
for (const [id, content] of Object.entries(pastedContents)) {
if (content.type === 'image') {
const path = await storeImage(content)
if (path) {
pathMap.set(Number(id), path)
}
}
}
return pathMap
}
/**
* Get the file path for a stored image by ID.
*/
export function getStoredImagePath(imageId: number): string | null {
return storedImagePaths.get(imageId) ?? null
}
/**
* Clear the in-memory cache of stored image paths.
*/
export function clearStoredImagePaths(): void {
storedImagePaths.clear()
}
function evictOldestIfAtCap(): void {
while (storedImagePaths.size >= MAX_STORED_IMAGE_PATHS) {
const oldest = storedImagePaths.keys().next().value
if (oldest !== undefined) {
storedImagePaths.delete(oldest)
} else {
break
}
}
}
/**
* Clean up old image cache directories from previous sessions.
*/
export async function cleanupOldImageCaches(): Promise<void> {
const fsImpl = getFsImplementation()
const baseDir = join(getClaudeConfigHomeDir(), IMAGE_STORE_DIR)
const currentSessionId = getSessionId()
try {
let sessionDirs
try {
sessionDirs = await fsImpl.readdir(baseDir)
} catch {
return
}
for (const sessionDir of sessionDirs) {
if (sessionDir.name === currentSessionId) {
continue
}
const sessionPath = join(baseDir, sessionDir.name)
try {
await fsImpl.rm(sessionPath, { recursive: true, force: true })
logForDebugging(`Cleaned up old image cache: ${sessionPath}`)
} catch {
// Ignore errors for individual directories
}
}
try {
const remaining = await fsImpl.readdir(baseDir)
if (remaining.length === 0) {
await fsImpl.rmdir(baseDir)
}
} catch {
// Ignore
}
} catch {
// Ignore errors reading base directory
}
}