@volcengine/tls-observer-claude-code 0.0.2 → 0.0.4

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "tls-observer-claude-code",
   "description": "Export Claude Code prompts, assistant responses, tool calls, and token usage to Volcengine TLS as OTLP traces.",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "author": {
     "name": "Volcengine"
   },

package/dist/index.js

@@ -222,7 +222,7 @@ async function closeTraceLogProducers() {
     }));
 }
 var package_namespaceObject = {
-    rE: "0.0.2"
+    rE: "0.0.4"
 };
 function toOtlpAnyValue(value) {
     if ('string' == typeof value) return {
@@ -687,11 +687,11 @@ const SESSION_MAX_AGE_MS = 86400000;
 function sleep(ms) {
     return new Promise((resolve)=>setTimeout(resolve, ms));
 }
-function lockPath(stateFilePath) {
+function state_lockPath(stateFilePath) {
     return `${stateFilePath}.lock`;
 }
 async function acquireLock(stateFilePath) {
-    const lock = lockPath(stateFilePath);
+    const lock = state_lockPath(stateFilePath);
     const deadline = Date.now() + LOCK_TIMEOUT_MS;
     __rspack_external_node_fs_5ea92f0c.mkdirSync(__rspack_external_node_path_c5b9b54f.dirname(stateFilePath), {
         recursive: true
@@ -711,7 +711,7 @@ async function acquireLock(stateFilePath) {
 }
 function releaseLock(stateFilePath) {
     try {
-        __rspack_external_node_fs_5ea92f0c.unlinkSync(lockPath(stateFilePath));
+        __rspack_external_node_fs_5ea92f0c.unlinkSync(state_lockPath(stateFilePath));
     } catch  {}
 }
 function loadState(stateFilePath) {
@@ -1218,6 +1218,10 @@ async function writeTextFileAtomic(filePath, text, options = {}) {
 async function writeJsonFileAtomic(filePath, value, options = {}) {
     await writeTextFileAtomic(filePath, `${JSON.stringify(value, null, 2)}\n`, options);
 }
+const DEFAULT_MAX_FILES = 3;
+const LOCK_STALE_MS = 30000;
+const jsonl_LOCK_TIMEOUT_MS = 5000;
+const jsonl_LOCK_RETRY_MS = 25;
 async function appendJsonlFile(filePath, values) {
     const entries = Array.isArray(values) ? values : [
         values
@@ -1228,6 +1232,79 @@ async function appendJsonlFile(filePath, values) {
     });
     await __rspack_external_node_fs_promises_153e37e0.appendFile(filePath, `${entries.map((entry)=>JSON.stringify(entry)).join('\n')}\n`, 'utf8');
 }
+async function delay(ms) {
+    await new Promise((resolve)=>setTimeout(resolve, ms));
+}
+async function withJsonlFileLock(filePath, action) {
+    await __rspack_external_node_fs_promises_153e37e0.mkdir(__rspack_external_node_path_c5b9b54f.dirname(filePath), {
+        recursive: true
+    });
+    const lockPath = `${filePath}.lock`;
+    const startedAt = Date.now();
+    while(true)try {
+        const handle = await __rspack_external_node_fs_promises_153e37e0.open(lockPath, 'wx');
+        try {
+            await handle.writeFile(`${process.pid}:${new Date().toISOString()}\n`, 'utf8');
+            return await action();
+        } finally{
+            await handle.close().catch(()=>void 0);
+            await __rspack_external_node_fs_promises_153e37e0.rm(lockPath, {
+                force: true
+            }).catch(()=>void 0);
+        }
+    } catch (error) {
+        if ('EEXIST' !== error.code) throw error;
+        try {
+            const stat = await __rspack_external_node_fs_promises_153e37e0.stat(lockPath);
+            if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
+                await __rspack_external_node_fs_promises_153e37e0.rm(lockPath, {
+                    force: true
+                }).catch(()=>void 0);
+                continue;
+            }
+        } catch (statError) {
+            if ('ENOENT' === statError.code) continue;
+            throw statError;
+        }
+        if (Date.now() - startedAt > jsonl_LOCK_TIMEOUT_MS) throw new Error(`Timed out waiting for JSONL file lock: ${lockPath}`);
+        await delay(jsonl_LOCK_RETRY_MS);
+    }
+}
+function rotatedFileName(filePath, now = new Date()) {
+    const dir = __rspack_external_node_path_c5b9b54f.dirname(filePath);
+    const ext = __rspack_external_node_path_c5b9b54f.extname(filePath);
+    const base = __rspack_external_node_path_c5b9b54f.basename(filePath, ext);
+    const stamp = now.toISOString().replace(/[-:.TZ]/g, '').slice(0, 17);
+    return __rspack_external_node_path_c5b9b54f.join(dir, `${base}.${stamp}.${process.pid}.${randomUUID()}${ext || '.jsonl'}`);
+}
+function rotatedFilePattern(filePath) {
+    const ext = __rspack_external_node_path_c5b9b54f.extname(filePath);
+    const base = __rspack_external_node_path_c5b9b54f.basename(filePath, ext).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const escapedExt = (ext || '.jsonl').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`^${base}\\.\\d{17}\\.\\d+\\.[0-9a-f-]+${escapedExt}$`);
+}
+async function pruneRotatedJsonlFiles(filePath, maxFiles) {
+    const maxRotatedFiles = Math.max(0, maxFiles - 1);
+    const dir = __rspack_external_node_path_c5b9b54f.dirname(filePath);
+    const pattern = rotatedFilePattern(filePath);
+    let entries;
+    try {
+        entries = await __rspack_external_node_fs_promises_153e37e0.readdir(dir);
+    } catch (error) {
+        if ('ENOENT' === error.code) return;
+        throw error;
+    }
+    const rotated = entries.filter((entry)=>pattern.test(entry)).sort((left, right)=>right.localeCompare(left)).map((entry)=>__rspack_external_node_path_c5b9b54f.join(dir, entry));
+    await Promise.all(rotated.slice(maxRotatedFiles).map((target)=>__rspack_external_node_fs_promises_153e37e0.rm(target, {
+            force: true
+        })));
+}
+async function rotateActiveJsonlFile(filePath, maxFiles) {
+    await __rspack_external_node_fs_promises_153e37e0.rename(filePath, rotatedFileName(filePath)).catch(async (error)=>{
+        if ('ENOENT' !== error.code) throw error;
+    });
+    await pruneRotatedJsonlFiles(filePath, maxFiles);
+}
 async function trimJsonlFileByBytes(filePath, maxBytes) {
     if (maxBytes <= 0) return void await __rspack_external_node_fs_promises_153e37e0.rm(filePath, {
         force: true
@@ -1253,9 +1330,42 @@ async function trimJsonlFileByBytes(filePath, maxBytes) {
     }
     await writeTextFileAtomic(filePath, kept.length ? `${kept.reverse().join('\n')}\n` : '');
 }
-async function appendBoundedJsonlFile(filePath, values, maxBytes) {
-    await appendJsonlFile(filePath, values);
-    await trimJsonlFileByBytes(filePath, maxBytes);
+async function appendBoundedJsonlFile(filePath, values, maxBytes, options = {}) {
+    const entries = Array.isArray(values) ? values : [
+        values
+    ];
+    if (0 === entries.length) return;
+    if ('rotate' !== options.strategy) return void await withJsonlFileLock(filePath, async ()=>{
+        await appendJsonlFile(filePath, entries);
+        await trimJsonlFileByBytes(filePath, maxBytes);
+    });
+    await withJsonlFileLock(filePath, async ()=>{
+        const maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
+        if (maxBytes <= 0 || maxFiles <= 0) {
+            await __rspack_external_node_fs_promises_153e37e0.rm(filePath, {
+                force: true
+            }).catch(()=>void 0);
+            await pruneRotatedJsonlFiles(filePath, 0);
+            return;
+        }
+        let currentBytes = 0;
+        try {
+            currentBytes = (await __rspack_external_node_fs_promises_153e37e0.stat(filePath)).size;
+        } catch (error) {
+            if ('ENOENT' !== error.code) throw error;
+        }
+        for (const entry of entries){
+            const line = `${JSON.stringify(entry)}\n`;
+            const lineBytes = Buffer.byteLength(line, 'utf8');
+            if (currentBytes > 0 && currentBytes + lineBytes > maxBytes) {
+                await rotateActiveJsonlFile(filePath, maxFiles);
+                currentBytes = 0;
+            }
+            await __rspack_external_node_fs_promises_153e37e0.appendFile(filePath, line, 'utf8');
+            currentBytes += lineBytes;
+        }
+        await pruneRotatedJsonlFiles(filePath, maxFiles);
+    });
 }
 function readTranscript(filePath, afterLine = -1, afterOffset = 0) {
     let size;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volcengine/tls-observer-claude-code",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "Export Claude Code hook telemetry to Volcengine TLS with OTLP traces.",
   "type": "module",
   "main": "./dist/index.js",