@groundtrack/hooks 0.1.25 → 0.1.26

package/dist/session-import/cli.js

@@ -207,7 +207,7 @@ async function runAgentImport(args, agent, context, interactive) {
     const home = resolve(context.env[format.homeEnvironmentVariable] ||
         resolve(context.homeDir, format.defaultHomeDirectory));
     const repository = args.allRepositories ? undefined : repositoryIdentity(context.repoDir);
-    const discovery = discoverSessions({
+    const discovery = await discoverSessions({
         home,
         format,
         repository,

package/dist/session-import/compression.d.ts

@@ -0,0 +1,8 @@
+import { Transform } from "node:stream";
+/**
+ * Codex compresses sessions older than a few weeks into `.jsonl.zst`. The file is
+ * a standard zstd frame containing the same JSONL records, so decompressing
+ * before hashing keeps the content hash identical to an uncompressed copy.
+ */
+export declare function isCompressedSession(path: string): boolean;
+export declare function createSessionDecompressor(): Transform;

package/dist/session-import/compression.js

@@ -0,0 +1,16 @@
+import { Transform } from "node:stream";
+import * as zlib from "node:zlib";
+/**
+ * Codex compresses sessions older than a few weeks into `.jsonl.zst`. The file is
+ * a standard zstd frame containing the same JSONL records, so decompressing
+ * before hashing keeps the content hash identical to an uncompressed copy.
+ */
+export function isCompressedSession(path) {
+    return path.toLowerCase().endsWith(".jsonl.zst");
+}
+export function createSessionDecompressor() {
+    const create = zlib.createZstdDecompress;
+    if (typeof create !== "function")
+        throw new Error("Reading .jsonl.zst sessions requires Node 22.19 or newer.");
+    return create();
+}

package/dist/session-import/discovery.d.ts

@@ -23,9 +23,9 @@ export type DiscoverSessionsOptions = Readonly<{
     platform?: NodeJS.Platform;
     workingDirectory?: string;
 }>;
-export declare function discoverSessions(options: DiscoverSessionsOptions): {
+export declare function discoverSessions(options: DiscoverSessionsOptions): Promise<{
     included: AgentSessionCandidate[];
     skipped: SkippedAgentSession[];
     failed: FailedAgentSession[];
     cleanup?: () => void;
-};
+}>;

package/dist/session-import/discovery.js

@@ -1,45 +1,71 @@
 import { execFileSync } from "node:child_process";
-import { closeSync, existsSync, lstatSync, openSync, readSync, readdirSync, realpathSync, } from "node:fs";
+import { createReadStream, existsSync, lstatSync, readdirSync, realpathSync } from "node:fs";
 import { isAbsolute, relative, resolve, sep } from "node:path";
 import { homedir } from "node:os";
+import { StringDecoder } from "node:string_decoder";
 import { isSessionRecord } from "./canonical.js";
-function initialRecords(path, maxRecords, maxBytes = 1024 * 1024) {
-    const file = openSync(path, "r");
-    try {
-        const chunks = [];
-        let offset = 0;
-        let newlineCount = 0;
-        while (offset < maxBytes && newlineCount < maxRecords) {
-            const chunk = Buffer.alloc(Math.min(64 * 1024, maxBytes - offset));
-            const read = readSync(file, chunk, 0, chunk.length, offset);
-            if (read === 0)
-                break;
-            const bytes = chunk.subarray(0, read);
-            chunks.push(bytes);
-            offset += read;
-            for (const byte of bytes) {
-                if (byte === 10 && ++newlineCount >= maxRecords)
-                    break;
-            }
-        }
-        return Buffer.concat(chunks)
-            .toString("utf8")
-            .split(/\r?\n/, maxRecords)
-            .flatMap((line) => {
-            if (!line.trim())
-                return [];
+import { createSessionDecompressor, isCompressedSession } from "./compression.js";
+async function initialRecords(path, maxRecords, maxBytes = 1024 * 1024) {
+    const input = createReadStream(path);
+    const source = isCompressedSession(path) ? input.pipe(createSessionDecompressor()) : input;
+    // `pipe()` does not forward upstream errors to the destination. Surface them on
+    // the stream being iterated so the catch below handles a vanished or unreadable
+    // file instead of crashing on an unhandled 'error' event.
+    input.on("error", (error) => source.destroy(error));
+    const decoder = new StringDecoder("utf8");
+    const records = [];
+    let pending = "";
+    let lineCount = 0;
+    let bytes = 0;
+    const consume = (line) => {
+        const nextCount = lineCount + 1;
+        const nextBytes = bytes + Buffer.byteLength(line) + 1;
+        if (nextCount > maxRecords || nextBytes > maxBytes)
+            return false;
+        lineCount = nextCount;
+        bytes = nextBytes;
+        if (line.trim()) {
             try {
                 const record = JSON.parse(line);
-                return isSessionRecord(record) ? [record] : [];
+                if (isSessionRecord(record))
+                    records.push(record);
             }
             catch {
-                return [];
+                // Ignore malformed lines, matching the previous behavior.
             }
-        });
+        }
+        return true;
+    };
+    try {
+        for await (const chunk of source) {
+            pending += decoder.write(chunk);
+            let newline = pending.indexOf("\n");
+            while (newline >= 0) {
+                const line = pending.slice(0, newline).replace(/\r$/, "");
+                pending = pending.slice(newline + 1);
+                if (!consume(line))
+                    return records;
+                newline = pending.indexOf("\n");
+            }
+            // Stop before buffering a line that cannot fit in the byte budget.
+            if (bytes + Buffer.byteLength(pending) > maxBytes)
+                return records;
+        }
+        pending += decoder.end();
+        if (pending.trim())
+            consume(pending.replace(/\r$/, ""));
+    }
+    catch {
+        // A truncated or corrupt compression stream should not abort discovery.
     }
     finally {
-        closeSync(file);
+        // `pipe()` does not destroy the source when the destination is destroyed.
+        // Close both ends explicitly so an early-stopped `.jsonl.zst` read does not
+        // leak a file descriptor.
+        source.destroy();
+        input.destroy();
     }
+    return records;
 }
 function walkJsonl(root) {
     if (!existsSync(root))
@@ -50,7 +76,9 @@ function walkJsonl(root) {
             const path = resolve(directory, entry.name);
             if (entry.isDirectory())
                 visit(path);
-            else if (entry.isFile() && entry.name.toLowerCase().endsWith(".jsonl"))
+            else if (entry.isFile() &&
+                (entry.name.toLowerCase().endsWith(".jsonl") ||
+                    entry.name.toLowerCase().endsWith(".jsonl.zst")))
                 result.push(path);
         }
     };
@@ -116,7 +144,7 @@ function isInside(candidate, root) {
     const child = relative(root, resolve(candidate));
     return child === "" || (!child.startsWith(`..${sep}`) && child !== "..");
 }
-export function discoverSessions(options) {
+export async function discoverSessions(options) {
     const nowMs = options.nowMs ?? Date.now();
     const liveWindowMs = options.liveWindowMs ?? 5 * 60_000;
     const included = [];
@@ -127,13 +155,14 @@ export function discoverSessions(options) {
         env: options.env ?? process.env,
         platform: options.platform ?? process.platform,
     };
-    const discovered = options.format.discovery === "custom"
-        ? options.format.discoverCandidates(discoveryContext)
-        : (() => {
+    const format = options.format;
+    const discovered = format.discovery === "custom"
+        ? format.discoverCandidates(discoveryContext)
+        : await (async () => {
             const candidates = [];
             const rejected = [];
-            for (const path of options.format.sessionRoots(options.home).flatMap(walkJsonl)) {
-                const metadata = options.format.parseDiscoveryMetadata(initialRecords(path, options.format.discoveryRecordLimit));
+            for (const path of format.sessionRoots(options.home).flatMap(walkJsonl)) {
+                const metadata = format.parseDiscoveryMetadata(await initialRecords(path, format.discoveryRecordLimit));
                 if (metadata)
                     candidates.push({ path, metadata });
                 else

package/dist/session-import/prune.js

@@ -4,6 +4,7 @@ import { stat } from "node:fs/promises";
 import { createInterface } from "node:readline";
 import { Transform } from "node:stream";
 import { CANONICAL_IMPORT_MAX_RECORD_BYTES } from "./canonical.js";
+import { createSessionDecompressor, isCompressedSession } from "./compression.js";
 import { createSessionNormalizationAccumulator } from "./normalize.js";
 async function scanSession(path, format, discoveryMetadata, onEntry) {
     const before = await stat(path);
@@ -12,6 +13,7 @@ async function scanSession(path, format, discoveryMetadata, onEntry) {
         hash.update(`${format.sourceHashSeed(discoveryMetadata)}\0`);
     const encoder = new TextEncoder();
     let entryBytes = 0;
+    let originalBytes = 0;
     const accumulator = createSessionNormalizationAccumulator(format.createNormalizer(discoveryMetadata), {
         discoveryMetadata,
         onEntry: (entry) => {
@@ -24,24 +26,40 @@ async function scanSession(path, format, discoveryMetadata, onEntry) {
     });
     const hashingStream = new Transform({
         transform(chunk, _encoding, callback) {
+            originalBytes += chunk.length;
             hash.update(chunk);
             callback(null, chunk);
         },
     });
-    const input = createReadStream(path);
+    const rawInput = createReadStream(path);
+    const input = isCompressedSession(path) ? rawInput.pipe(createSessionDecompressor()) : rawInput;
+    // `pipe()` does not forward upstream errors. Move an error from the file stream
+    // to the decoder, then to the hashing stream that readline is consuming, so the
+    // loop below observes it instead of the process crashing.
+    rawInput.on("error", (error) => input.destroy(error));
+    input.on("error", (error) => hashingStream.destroy(error));
     input.pipe(hashingStream);
     const lines = createInterface({ input: hashingStream, crlfDelay: Infinity });
-    for await (const line of lines) {
-        if (!line.trim())
-            continue;
-        let record;
-        try {
-            record = JSON.parse(line);
+    try {
+        for await (const line of lines) {
+            if (!line.trim())
+                continue;
+            let record;
+            try {
+                record = JSON.parse(line);
+            }
+            catch {
+                record = null;
+            }
+            accumulator.add(record);
         }
-        catch {
-            record = null;
-        }
-        accumulator.add(record);
+    }
+    finally {
+        lines.close();
+        hashingStream.destroy();
+        input.destroy();
+        if (input !== rawInput)
+            rawInput.destroy();
     }
     const after = await stat(path);
     if (before.size !== after.size || before.mtimeMs !== after.mtimeMs)
@@ -52,7 +70,7 @@ async function scanSession(path, format, discoveryMetadata, onEntry) {
         throw new Error(`Canonical session metadata is too large: ${path}`);
     return {
         sourceContentHash: hash.digest("hex"),
-        originalBytes: before.size,
+        originalBytes,
         prunedBytes: headerBytes.byteLength + entryBytes,
         metadata: header,
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groundtrack/hooks",
-  "version": "0.1.25",
+  "version": "0.1.26",
   "description": "Lifecycle hook utilities for Groundtrack MCP clients.",
   "keywords": [
     "claude-code",
@@ -116,6 +116,6 @@
     "typescript": "~7.0.2"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=22.19"
   }
 }