feat: move archived sessions out of active storage

src/server/sessions/sessionArchiveStore.test.ts

@@ -0,0 +1,56 @@
+import { constants } from "node:fs";
+import { access, mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { afterEach, describe, expect, it } from "vitest";
+import { SessionArchiveStore } from "./sessionArchiveStore.js";
+
+const tempRoots: string[] = [];
+
+describe("SessionArchiveStore", () => {
+  afterEach(async () => {
+    await Promise.all(tempRoots.splice(0).map((path) => rm(path, { recursive: true, force: true })));
+  });
+
+  it("moves archived session files out of the active session directory and restores them", async () => {
+    const root = await mkdtemp(join(tmpdir(), "pi-web-archive-"));
+    tempRoots.push(root);
+    const activeDir = join(root, "active");
+    await mkdir(activeDir, { recursive: true });
+    const sourcePath = join(activeDir, "2026-01-01_s1.jsonl");
+    await writeFile(sourcePath, "session contents\n", "utf8");
+
+    const store = new SessionArchiveStore(join(root, "archived-sessions.json"), join(root, "archived-files"));
+    const record = await store.archive({
+      sessionId: "s1",
+      cwd: "/workspace",
+      path: sourcePath,
+      created: "2026-01-01T00:00:00.000Z",
+      modified: "2026-01-01T00:01:00.000Z",
+      messageCount: 2,
+      firstMessage: "hello",
+    });
+
+    expect(await exists(sourcePath)).toBe(false);
+    expect(record.originalPath).toBe(sourcePath);
+    expect(record.archivePath).toBeDefined();
+    if (record.archivePath === undefined) throw new Error("Expected archive path");
+    expect(await readFile(record.archivePath, "utf8")).toBe("session contents\n");
+    await expect(store.list()).resolves.toMatchObject([{ sessionId: "s1", originalPath: sourcePath, archivePath: record.archivePath, messageCount: 2 }]);
+
+    await store.restore("s1");
+
+    expect(await readFile(sourcePath, "utf8")).toBe("session contents\n");
+    expect(await exists(record.archivePath)).toBe(false);
+    await expect(store.list()).resolves.toEqual([]);
+  });
+});
+
+async function exists(path: string): Promise<boolean> {
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}