Repository navigation
Expand file tree
/
Copy pathasciicast.ts
More file actions
239 lines (218 loc) · 7.57 KB
/
Copy pathasciicast.ts
File metadata and controls
239 lines (218 loc) · 7.57 KB
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
228
229
230
231
232
233
234
235
236
237
238
239
import { appendFile, rename } from 'fs/promises'
import { basename, dirname, join } from 'path'
import { getOriginalCwd, getSessionId } from '../bootstrap/state.js'
import { createBufferedWriter } from './bufferedWriter.js'
import { registerCleanup } from './cleanupRegistry.js'
import { logForDebugging } from './debug.js'
import { getClaudeConfigHomeDir, isEnvTruthy } from './envUtils.js'
import { getFsImplementation } from './fsOperations.js'
import { sanitizePath } from './path.js'
import { jsonStringify } from './slowOperations.js'
// Mutable recording state — filePath is updated when session ID changes (e.g., --resume)
const recordingState: { filePath: string | null; timestamp: number } = {
filePath: null,
timestamp: 0,
}
/**
* Get the asciicast recording file path.
* For ants with CLAUDE_CODE_TERMINAL_RECORDING=1: returns a path.
* Otherwise: returns null.
* The path is computed once and cached in recordingState.
*/
export function getRecordFilePath(): string | null {
if (recordingState.filePath !== null) {
return recordingState.filePath
}
if (process.env.USER_TYPE !== 'ant') {
return null
}
if (!isEnvTruthy(process.env.CLAUDE_CODE_TERMINAL_RECORDING)) {
return null
}
// Record alongside the transcript.
// Each launch gets its own file so --continue produces multiple recordings.
const projectsDir
8000
= join(getClaudeConfigHomeDir(), 'projects')
const projectDir = join(projectsDir, sanitizePath(getOriginalCwd()))
recordingState.timestamp = Date.now()
recordingState.filePath = join(
projectDir,
`${getSessionId()}-${recordingState.timestamp}.cast`,
)
return recordingState.filePath
}
export function _resetRecordingStateForTesting(): void {
recordingState.filePath = null
recordingState.timestamp = 0
}
/**
* Find all .cast files for the current session.
* Returns paths sorted by filename (chronological by timestamp suffix).
*/
export function getSessionRecordingPaths(): string[] {
const sessionId = getSessionId()
const projectsDir = join(getClaudeConfigHomeDir(), 'projects')
const projectDir = join(projectsDir, sanitizePath(getOriginalCwd()))
try {
// eslint-disable-next-line custom-rules/no-sync-fs -- called during /share before upload, not in hot path
const entries = getFsImplementation().readdirSync(projectDir)
const names = (
typeof entries[0] === 'string'
? entries
: (entries as { name: string }[]).map(e => e.name)
) as string[]
const files = names
.filter(f => f.startsWith(sessionId) && f.endsWith('.cast'))
.sort()
return files.map(f => join(projectDir, f))
} catch {
return []
}
}
/**
* Rename the recording file to match the current session ID.
* Called after --resume/--continue changes the session ID via switchSession().
* The recorder was installed with the initial (random) session ID; this renames
* the file so getSessionRecordingPaths() can find it by the resumed session ID.
*/
export async function renameRecordingForSession(): Promise<void> {
const oldPath = recordingState.filePath
if (!oldPath || recordingState.timestamp === 0) {
return
}
const projectsDir = join(getClaudeConfigHomeDir(), 'projects')
const projectDir = join(projectsDir, sanitizePath(getOriginalCwd()))
const newPath = join(
projectDir,
`${getSessionId()}-${recordingState.timestamp}.cast`,
)
if (oldPath === newPath) {
return
}
// Flush pending writes before renaming
await recorder?.flush()
const oldName = basename(oldPath)
const newName = basename(newPath)
try {
await rename(oldPath, newPath)
recordingState.filePath = newPath
logForDebugging(`[asciicast] Renamed recording: ${oldName} → ${newName}`)
} catch {
logForDebugging(
`[asciicast] Failed to rename recording from ${oldName} to ${newName}`,
)
}
}
type AsciicastRecorder = {
flush(): Promise<void>
dispose(): Promise<void>
}
let recorder: AsciicastRecorder | null = null
function getTerminalSize(): { cols: number; rows: number } {
// Direct access to stdout dimensions — not in a React component
// eslint-disable-next-line custom-rules/prefer-use-terminal-size
const cols = process.stdout.columns || 80
// eslint-disable-next-line custom-rules/prefer-use-terminal-size
const rows = process.stdout.rows || 24
return { cols, rows }
}
/**
* Flush pending recording data to disk.
* Call before reading the .cast file (e.g., during /share).
*/
export async function flushAsciicastRecorder(): Promise<void> {
await recorder?.flush()
}
/**
* Install the asciicast recorder.
* Wraps process.stdout.write to capture all terminal output with timestamps.
* Must be called before Ink mounts.
*/
export function installAsciicastRecorder(): void {
const filePath = getRecordFilePath()
if (!filePath) {
return
}
const { cols, rows } = getTerminalSize()
const startTime = performance.now()
// Write the asciicast v2 header
const header = jsonStringify({
version: 2,
width: cols,
height: rows,
timestamp: Math.floor(Date.now() / 1000),
env: {
SHELL: process.env.SHELL || '',
TERM: process.env.TERM || '',
},
})
try {
// eslint-disable-next-line custom-rules/no-sync-fs -- one-time init before Ink mounts
getFsImplementation().mkdirSync(dirname(filePath))
} catch {
// Directory may already exist
}
// eslint-disable-next-line custom-rules/no-sync-fs -- one-time init before Ink mounts
getFsImplementation().appendFileSync(filePath, header + '\n', { mode: 0o600 })
let pendingWrite: Promise<void> = Promise.resolve()
const writer = createBufferedWriter({
writeFn(content: string) {
// Use recordingState.filePath (mutable) so writes follow renames from --resume
const currentPath = recordingState.filePath
if (!currentPath) {
return
}
pendingWrite = pendingWrite
.then(() => appendFile(currentPath, content))
.catch(() => {
// Silently ignore write errors — don't break the session
})
},
flushIntervalMs: 500,
maxBufferSize: 50,
maxBufferBytes: 10 * 1024 * 1024, // 10MB
})
// Wrap process.stdout.write to capture output
const originalWrite = process.stdout.write.bind(
process.stdout,
) as typeof process.stdout.write
process.stdout.write = function (
chunk: string | Uint8Array,
encodingOrCb?: BufferEncoding | ((err?: Error) => void),
cb?: (err?: Error) => void,
): boolean {
// Record the output event
const elapsed = (performance.now() - startTime) / 1000
const text =
typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf-8')
writer.write(jsonStringify([elapsed, 'o', text]) + '\n')
// Pass through to the real stdout
if (typeof encodingOrCb === 'function') {
return originalWrite(chunk, encodingOrCb)
}
return originalWrite(chunk, encodingOrCb, cb)
} as typeof process.stdout.write
// Handle terminal resize events
function onResize(): void {
const elapsed = (performance.now() - startTime) / 1000
const { cols: newCols, rows: newRows } = getTerminalSize()
writer.write(jsonStringify([elapsed, 'r', `${newCols}x${newRows}`]) + '\n')
}
process.stdout.on('resize', onResize)
recorder = {
async flush(): Promise<void> {
writer.flush()
await pendingWrite
},
async dispose(): Promise<void> {
writer.dispose()
await pendingWrite
process.stdout.removeListener('resize', onResize)
process.stdout.write = originalWrite
},
}
registerCleanup(async () => {
await recorder?.dispose()
recorder = null
})
logForDebugging(`[asciicast] Recording to ${filePath}`)
}