pi-export-my-chat 1.0.0

package/tests/helpers.test.mjs

@@ -0,0 +1,345 @@
+import assert from "node:assert/strict";
+import { chmod, lstat, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { symlinkSync } from "node:fs";
+import {
+    EXPORT_FORMAT,
+    SCHEMA_VERSION,
+    buildRevivePlan,
+    buildSessionJsonl,
+    collectTimingRecords,
+    collectUsage,
+    contextUsageSnapshot,
+    parseReviveArgs,
+    resolveExportPath,
+    sessionFileTimestamp,
+    sha256Hex,
+    summarizeTimings,
+    timestampedExportName,
+    validateExportDocument,
+    validateSessionCore,
+    writeExclusiveJson,
+} from "../helpers.mjs";
+
+// ─── Path resolution ─────────────────────────────────────────────────────────
+
+test("resolves default, absolute, and quoted export destinations", () => {
+    const date = new Date("2026-04-13T12:34:56.789Z");
+    assert.equal(timestampedExportName(date), "pi-my-chat-export-20260413T123456-789Z.json");
+    // Revived session filenames use pi's own timestamp convention exactly.
+    assert.equal(sessionFileTimestamp(date), "2026-04-13T12-34-56-789Z");
+    assert.equal(
+        resolveExportPath("", "/work/project", date),
+        "/work/project/pi-my-chat-export-20260413T123456-789Z.json",
+    );
+    assert.equal(resolveExportPath('"/tmp/chat with spaces.json"', "/work", date), "/tmp/chat with spaces.json");
+    assert.equal(resolveExportPath("/tmp/sub/../chat.json", "/work", date), "/tmp/chat.json");
+    assert.throws(() => resolveExportPath("relative.json", "/work", date), /must be an absolute path/);
+    assert.throws(() => resolveExportPath("/tmp/chat.txt", "/work", date), /must have a \.json extension/);
+    assert.throws(() => resolveExportPath('"/tmp/chat.json', "/work", date), /unmatched quote/);
+});
+
+test("revive args: relative paths resolve, --force extracts anywhere, quotes unwrap", () => {
+    const r1 = parseReviveArgs("export.json", "/work");
+    assert.deepEqual(r1, { ok: true, force: false, path: "/work/export.json" });
+
+    const r2 = parseReviveArgs('/mnt/d/exports/chat with spaces.json --force', "/work");
+    assert.equal(r2.ok, true);
+    assert.equal(r2.force, true);
+    assert.equal(r2.path, "/mnt/d/exports/chat with spaces.json");
+
+    const r3 = parseReviveArgs("--force", "/work");
+    assert.equal(r3.ok, false);
+    assert.match(r3.error, /Provide the path/);
+
+    assert.equal(parseReviveArgs("", "/work").ok, false);
+});
+
+// ─── Usage accounting ────────────────────────────────────────────────────────
+
+test("collects usage from all sources without double-counting timing entries", () => {
+    const usage = {
+        input: 10,
+        output: 4,
+        cacheRead: 3,
+        cacheWrite: 2,
+        totalTokens: 19,
+        cost: { input: 1, output: 2, cacheRead: 0.3, cacheWrite: 0.2, total: 3.5 },
+    };
+    const totals = collectUsage([
+        { type: "message", message: { role: "assistant", usage } },
+        { type: "message", message: { role: "toolResult", usage: { input: 1, output: 2, cost: { total: 0.5 } } } },
+        { type: "compaction", usage: { input: 5, output: 1, totalTokens: 6, cost: { input: 0.4, output: 0.1 } } },
+        { type: "branch_summary", usage: { input: 2, output: 0, cost: { total: 0.25 } } },
+        { type: "custom", customType: "operation-timing", data: { usage } }, // must be ignored
+    ]);
+    assert.deepEqual(totals, {
+        usageRecords: 4,
+        input: 18,
+        output: 7,
+        cacheRead: 3,
+        cacheWrite: 2,
+        totalTokens: 30,
+        cost: { input: 1.4, output: 2.1, cacheRead: 0.3, cacheWrite: 0.2, total: 4.75 },
+    });
+});
+
+test("usage guards clamp NaN, Infinity, and negative values", () => {
+    const totals = collectUsage([
+        { type: "message", message: { role: "assistant", usage: { input: Number.NaN, output: -5, totalTokens: Number.POSITIVE_INFINITY, cost: { total: Number.NaN } } } },
+    ]);
+    assert.equal(totals.input, 0);
+    assert.equal(totals.output, 0);
+    assert.equal(totals.totalTokens, 0);
+    assert.equal(totals.cost.total, 0);
+});
+
+// ─── Context snapshot ────────────────────────────────────────────────────────
+
+test("context snapshot computes used/remaining/percent, preserves unknown tokens, and falls back to the snapshot's window", () => {
+    assert.deepEqual(contextUsageSnapshot({ tokens: 25000, contextWindow: 100000, percent: 25 }, 100000), {
+        used: 25000,
+        window: 100000,
+        remaining: 75000,
+        percentUsed: 25,
+    });
+    // Model window missing: the snapshot's own window is used instead.
+    assert.deepEqual(contextUsageSnapshot({ tokens: 25000, contextWindow: 100000, percent: 25 }, undefined), {
+        used: 25000,
+        window: 100000,
+        remaining: 75000,
+        percentUsed: 25,
+    });
+    // pi reports tokens === null right after compaction — recorded as null, never 0.
+    assert.deepEqual(contextUsageSnapshot({ tokens: null, contextWindow: 100000, percent: null }, 100000), {
+        used: null,
+        window: 100000,
+        remaining: null,
+        percentUsed: null,
+    });
+    assert.deepEqual(contextUsageSnapshot(undefined, 0), {
+        used: null,
+        window: 0,
+        remaining: null,
+        percentUsed: null,
+    });
+    // Negative or non-finite token counts clamp to 0.
+    assert.deepEqual(contextUsageSnapshot({ tokens: -5, contextWindow: 100, percent: null }, 100), {
+        used: 0,
+        window: 100,
+        remaining: 100,
+        percentUsed: 0,
+    });
+});
+
+// ─── Timings ─────────────────────────────────────────────────────────────────
+
+test("extracts and summarizes timing records", () => {
+    const records = collectTimingRecords([
+        { type: "custom", customType: "operation-timing", data: { schemaVersion: 1, operationId: "a", kind: "model", startedAt: 1, endedAt: 11, durationMs: 10, status: "success" } },
+        { type: "custom", customType: "operation-timing", data: { schemaVersion: 1, operationId: "b", kind: "model", startedAt: 12, endedAt: 42, durationMs: 30, status: "error" } },
+        { type: "custom", customType: "operation-timing", data: { kind: "model" } }, // invalid: dropped
+        { type: "custom", customType: "other", data: {} },
+    ]);
+    assert.equal(records.length, 2);
+    assert.deepEqual(summarizeTimings(records).byKind.model, {
+        count: 2,
+        totalDurationMs: 40,
+        averageDurationMs: 20,
+        minDurationMs: 10,
+        maxDurationMs: 30,
+        statuses: { success: 1, error: 1 },
+    });
+});
+
+test("empty timing summaries behave cleanly", () => {
+    const summary = summarizeTimings([]);
+    assert.equal(summary.recordCount, 0);
+    assert.deepEqual(summary.byKind, {});
+});
+
+// ─── Exclusive private write ─────────────────────────────────────────────────
+
+test("writes private JSON exclusively and rejects existing paths", async () => {
+    const root = await mkdtemp(join(tmpdir(), "pi-export-my-chat-"));
+    try {
+        await chmod(root, 0o700);
+        const destination = join(root, "chat.json");
+        const bytes = await writeExclusiveJson(destination, { ok: true });
+        assert.equal(bytes, Buffer.byteLength('{\n  "ok": true\n}\n'));
+        assert.deepEqual(JSON.parse(await readFile(destination, "utf8")), { ok: true });
+        assert.equal((await lstat(destination)).mode & 0o777, 0o600);
+        await assert.rejects(() => writeExclusiveJson(destination, {}), /already exists/);
+
+        const directoryDestination = join(root, "directory.json");
+        await mkdir(directoryDestination);
+        await assert.rejects(() => writeExclusiveJson(directoryDestination, {}), /is a directory/);
+        await assert.rejects(() => writeExclusiveJson(join(root, "chat.txt"), {}), /must have a \.json extension/);
+        await assert.rejects(
+            () => writeExclusiveJson(join(root, "missing", "chat.json"), {}),
+            /parent directory does not exist/,
+        );
+
+        const symlinkDestination = join(root, "link.json");
+        await writeFile(join(root, "real.json"), "{}");
+        symlinkSync(join(root, "real.json"), symlinkDestination);
+        await assert.rejects(() => writeExclusiveJson(symlinkDestination, {}), /symbolic link/);
+    } finally {
+        await rm(root, { recursive: true, force: true });
+    }
+});
+
+// ─── Lossless core: JSONL, checksum, validation ───────────────────────────────
+
+const header = { type: "session", version: 3, id: "11111111-2222-3333-4444-555555555555", timestamp: "2026-04-13T10:00:00.000Z", cwd: "/old/machine/project" };
+const entries = [
+    { type: "model_change", id: "a1b2c3d4", parentId: null, timestamp: "2026-04-13T10:00:01.000Z", provider: "anthropic", modelId: "claude-sonnet-4-5" },
+    { type: "message", id: "b2c3d4e5", parentId: "a1b2c3d4", timestamp: "2026-04-13T10:00:02.000Z", message: { role: "user", content: "Hello" } },
+    { type: "message", id: "c3d4e5f6", parentId: "b2c3d4e5", timestamp: "2026-04-13T10:00:03.000Z", message: { role: "assistant", content: [{ type: "text", text: "Hi!" }], provider: "anthropic", model: "claude-sonnet-4-5", usage: { input: 1, output: 2, cacheRead: 0, cacheWrite: 0, totalTokens: 3, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } }, stopReason: "stop", timestamp: 1776132003000 } },
+];
+
+test("canonical JSONL: header line + one compact line per entry, trailing newline", () => {
+    const jsonl = buildSessionJsonl(header, entries);
+    const lines = jsonl.split("\n");
+    assert.equal(lines.length, entries.length + 2); // header + entries + trailing ""
+    assert.equal(lines[lines.length - 1], "");
+    assert.equal(lines[0], JSON.stringify(header));
+    assert.equal(lines[1], JSON.stringify(entries[0]));
+    // Deterministic: same inputs, same bytes, same checksum.
+    assert.equal(sha256Hex(jsonl), sha256Hex(buildSessionJsonl(header, entries)));
+    // Empty session: header only.
+    assert.equal(buildSessionJsonl(header, []), `${JSON.stringify(header)}\n`);
+});
+
+test("validateSessionCore: accepts a sound core and verifies checksum + leaf", () => {
+    const jsonl = buildSessionJsonl(header, entries);
+    const result = validateSessionCore(header, entries, {
+        expectedChecksum: sha256Hex(jsonl),
+        expectedLastEntryId: "c3d4e5f6",
+    });
+    assert.equal(result.ok, true);
+    assert.deepEqual(result.errors, []);
+});
+
+test("validateSessionCore: rejects duplicates, orphan parents, leaf mismatch, checksum mismatch", () => {
+    const bad = validateSessionCore(header, [entries[0], { ...entries[0] }], {});
+    assert.equal(bad.ok, false);
+    assert.match(bad.errors.join(" "), /Duplicate entry id/);
+
+    const orphan = validateSessionCore(header, [entries[0], { ...entries[1], parentId: "zzzzzzzz" }], {});
+    assert.match(orphan.errors.join(" "), /unknown parentId/);
+
+    const wrongLeaf = validateSessionCore(header, entries, { expectedLastEntryId: "a1b2c3d4" });
+    assert.match(wrongLeaf.errors.join(" "), /Leaf mismatch/);
+
+    const corrupt = validateSessionCore(header, entries, { expectedChecksum: sha256Hex("tampered") });
+    assert.match(corrupt.errors.join(" "), /Checksum mismatch/);
+});
+
+function makeExportDoc(overrides = {}) {
+    const jsonl = buildSessionJsonl(header, entries);
+    return {
+        format: EXPORT_FORMAT,
+        schemaVersion: SCHEMA_VERSION,
+        exportedAt: "2026-04-13T11:00:00.000Z",
+        session: {
+            name: "Refactor auth module",
+            cwd: "/old/machine/project",
+            header,
+            entries,
+            revive: {
+                checksum: sha256Hex(jsonl),
+                headerVersion: 3,
+                entryCount: entries.length,
+                lastEntryId: "c3d4e5f6",
+            },
+        },
+        ...overrides,
+    };
+}
+
+test("validateExportDocument: accepts a sound export", () => {
+    const result = validateExportDocument(makeExportDoc(), { maxHeaderVersion: 3 });
+    assert.equal(result.ok, true);
+});
+
+test("validateExportDocument: refuses wrong format, newer schema, newer header version, corruption", () => {
+    assert.match(
+        validateExportDocument({ format: "something-else" }, { maxHeaderVersion: 3 }).errors.join(" "),
+        /Not a pi-my-chat-export/,
+    );
+    assert.match(
+        validateExportDocument(makeExportDoc({ schemaVersion: 99 }), { maxHeaderVersion: 3 }).errors.join(" "),
+        /newer than this extension understands/,
+    );
+    assert.match(
+        validateExportDocument(makeExportDoc({ session: { ...makeExportDoc().session, header: { ...header, version: 4 } } }), { maxHeaderVersion: 3 }).errors.join(" "),
+        /newer than this pi supports/,
+    );
+    const tampered = makeExportDoc();
+    tampered.session.entries[1].message.content = "TAMPERED";
+    assert.match(
+        validateExportDocument(tampered, { maxHeaderVersion: 3 }).errors.join(" "),
+        /Checksum mismatch/,
+    );
+    const miscounted = makeExportDoc();
+    miscounted.session.revive.entryCount = entries.length + 1;
+    assert.match(
+        validateExportDocument(miscounted, { maxHeaderVersion: 3 }).errors.join(" "),
+        /Entry count mismatch/,
+    );
+});
+
+// ─── Revive plan ─────────────────────────────────────────────────────────────
+
+test("revive plan: re-roots cwd, keeps UUID when absent, re-mints on collision, re-attaches lost names", () => {
+    const newSessionDir = "/home/user/.pi/agent/sessions/--home-user-project--";
+    const base = { cwd: "/home/user/project", sessionDir: newSessionDir, now: new Date("2026-04-14T09:00:00.000Z") };
+
+    // Fresh machine: original UUID kept, name already in entries (as a
+    // session_info entry) so no fallback append.
+    const withNameEntry = [...entries, { type: "session_info", id: "d4e5f6a7", parentId: "c3d4e5f6", timestamp: "2026-04-13T10:05:00.000Z", name: "Refactor auth module" }];
+    const docFresh = makeExportDoc();
+    docFresh.session.entries = withNameEntry;
+    docFresh.session.revive = {
+        checksum: sha256Hex(buildSessionJsonl(header, withNameEntry)),
+        headerVersion: 3,
+        entryCount: withNameEntry.length,
+        lastEntryId: "d4e5f6a7",
+    };
+
+    const planFresh = buildRevivePlan(docFresh, { ...base, uuidExists: () => false, newUUID: () => "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee" });
+    assert.equal(planFresh.sessionUUID, header.id); // identity continuity
+    assert.equal(planFresh.header.cwd, "/home/user/project"); // re-rooted
+    assert.equal(planFresh.appendedName, null); // name already travelled
+    assert.ok(planFresh.filePath.startsWith(newSessionDir));
+    assert.ok(planFresh.filePath.endsWith(`_${header.id}.jsonl`));
+    // The rebuilt JSONL parses back to exactly header + entries, in order.
+    const lines = planFresh.jsonl.trim().split("\n").map((line) => JSON.parse(line));
+    assert.equal(lines.length, withNameEntry.length + 1);
+    assert.deepEqual(lines[0], { ...header, cwd: "/home/user/project" });
+    assert.deepEqual(lines.at(-1), withNameEntry.at(-1));
+
+    // Same machine (UUID collision): fresh UUID minted.
+    const planCollide = buildRevivePlan(docFresh, { ...base, uuidExists: () => true, newUUID: () => "00000000-0000-0000-0000-000000000001" });
+    assert.equal(planCollide.sessionUUID, "00000000-0000-0000-0000-000000000001");
+
+    // Name lost from entries: re-attached as a trailing session_info entry.
+    const docNameless = makeExportDoc(); // entries lack session_info
+    const planName = buildRevivePlan(docNameless, { ...base, uuidExists: () => false, newUUID: () => "x", newEntryId: () => "feedface" });
+    assert.equal(planName.appendedName, "Refactor auth module");
+    const nameLine = JSON.parse(planName.jsonl.trim().split("\n").at(-1));
+    assert.equal(nameLine.type, "session_info");
+    assert.equal(nameLine.name, "Refactor auth module");
+    assert.equal(nameLine.id, "feedface");
+    assert.equal(nameLine.parentId, "c3d4e5f6");
+
+    // No name at all: nothing appended (pi default naming applies).
+    const docUnnamed = makeExportDoc();
+    docUnnamed.session.name = null;
+    const planUnnamed = buildRevivePlan(docUnnamed, { ...base, uuidExists: () => false, newUUID: () => "x", newEntryId: () => "feedface" });
+    assert.equal(planUnnamed.appendedName, null);
+    assert.equal(planUnnamed.entryCount, entries.length);
+});