Soul-driven AI agent with permission-hardened tools, token budgets, and multi-channel access. Runs 24/7 from CLI, Telegram or More.
import { mkdtempSync, readFileSync, readdirSync, writeFileSync, mkdirSync, unlinkSync } from 'node:fs';
import { join } from 'node:path';
import { tmpdir } from 'node:os';
import { describe, expect, it } from 'vitest';
import { SessionRepository, SessionResolutionError } from './repository.js';
function fixture() {
const root = mkdtempSync(join(tmpdir(), 'mercury-sessions-'));
return { root, repository: new SessionRepository({ rootDir: join(root, 'sessions'), autoMigrate: false }) };
}
describe('SessionRepository', () => {
it('creates, lists, gets, and reloads atomically persisted sessions', () => {
const { root, repository } = fixture();
const created = repository.create({ title: 'Test session', alias: 'amber-comet' });
repository.appendMessage(created.id, { role: 'user', content: 'hello' });
const reloaded = new SessionRepository({ rootDir: join(root, 'sessions'), autoMigrate: false });
expect(reloaded.list()).toHaveLength(1);
expect(reloaded.get(created.id).messages[0]).toMatchObject({ content: 'hello', sequence: 1, sessionId: created.id });
expect(readdirSync(join(root, 'sessions')).some((file) => file.endsWith('.tmp'))).toBe(false);
expect(JSON.parse(readFileSync(join(root, 'sessions', 'index.json'), 'utf8')).sessions[0].alias).toBe('amber-comet');
});
it('quarantines a malformed index and rebuilds sessions and bindings', () => {
const { root, repository } = fixture();
const session = repository.create({ binding: { channelType: 'cli', externalConversationId: 'current' } });
const sessionsDir = join(root, 'sessions');
writeFileSync(join(sessionsDir, 'index.json'), '{not json');
writeFileSync(join(sessionsDir, `${session.id}.json.123.tmp`), 'ignored');
const recovered = new SessionRepository({ rootDir: sessionsDir, autoMigrate: false });
expect(recovered.getByBinding('cli', 'current')?.id).toBe(session.id);
expect(recovered.list()).toHaveLength(1);
const files = readdirSync(sessionsDir);
expect(files.some((file) => /^index\.json\.invalid-/.test(file))).toBe(true);
expect(files).toContain(`${session.id}.json.123.tmp`);
});
it('rebuilds an index that references a missing session', () => {
const { root, repository } = fixture();
const present = repository.create({ alias: 'present-session' });
const missing = repository.create({ alias: 'missing-session' });
const sessionsDir = join(root, 'sessions');
unlinkSync(join(sessionsDir, `${missing.id}.json`));
const recovered = new SessionRepository({ rootDir: sessionsDir, autoMigrate: false });
expect(recovered.dump().map((session) => session.id)).toEqual([present.id]);
expect(() => recovered.get(missing.id)).toThrow(/not found/);
expect(readdirSync(sessionsDir).some((file) => /^index\.json\.invalid-/.test(file))).toBe(true);
});
it('quarantines a corrupt individual session while retaining valid sessions', () => {
const { root, repository } = fixture();
const valid = repository.create({ alias: 'valid-session' });
const corrupt = repository.create({ alias: 'corrupt-session' });
const sessionsDir = join(root, 'sessions');
writeFileSync(join(sessionsDir, `${corrupt.id}.json`), JSON.stringify({ id: corrupt.id, messages: null }));
const recovered = new SessionRepository({ rootDir: sessionsDir, autoMigrate: false });
expect(recovered.dump().map((session) => session.id)).toEqual([valid.id]);
const quarantined = readdirSync(sessionsDir).find((file) => file.startsWith(`${corrupt.id}.json.invalid-`));
expect(quarantined).toBeDefined();
expect(JSON.parse(readFileSync(join(sessionsDir, quarantined!), 'utf8'))).toEqual({ id: corrupt.id, messages: null });
});
it('resolves UUID prefixes and aliases without guessing ambiguity', () => {
const { repository } = fixture();
const first = repository.create({ id: 'aaaaaaaa-1111-4111-8111-111111111111', alias: 'silver-star' });
repository.create({ id: 'aaaabbbb-2222-4222-8222-222222222222', alias: 'silver-signal' });
expect(repository.resolve(first.shortId).id).toBe(first.id);
expect(repository.resolve('silver-star').id).toBe(first.id);
expect(repository.resolve('SILVER-ST').id).toBe(first.id);
expect(() => repository.resolve('aaaa')).toThrow(SessionResolutionError);
expect(() => repository.resolve('silver-s')).toThrow(/silver-star.*silver-signal/);
});
it('maintains one mutable binding and adopts canonical UUIDs', () => {
const { repository } = fixture();
const first = repository.getOrCreateBound('cli', 'current');
const adopted = repository.getOrCreateBound('web', 'browser-thread', 'bbbbbbbb-1111-4111-8111-111111111111');
expect(repository.getByBinding('cli', 'current')?.id).toBe(first.id);
repository.bind(adopted.id, 'cli', 'current');
expect(repository.getByBinding('cli', 'current')?.id).toBe(adopted.id);
expect(repository.get(first.id).bindings).toHaveLength(0);
expect(repository.getByBinding('web', 'browser-thread')?.id).toBe(adopted.id);
});
it('deduplicates messages by external ID and archives sessions', () => {
const { repository } = fixture();
const session = repository.create();
const first = repository.appendMessage(session.id, { role: 'user', content: 'once', externalMessageId: 'transport-1' });
const duplicate = repository.appendMessage(session.id, { role: 'user', content: 'changed', externalMessageId: 'transport-1' });
expect(duplicate.id).toBe(first.id);
expect(repository.get(session.id).messages).toHaveLength(1);
repository.archive(session.id);
expect(repository.list()).toHaveLength(0);
expect(repository.list({ includeArchived: true })[0].status).toBe('archived');
});
it('keeps a message-free deletion tombstone until it is purged after sync', () => {
const { root, repository } = fixture();
const session = repository.create({ binding: { channelType: 'cli', externalConversationId: 'current' } });
repository.appendMessage(session.id, { role: 'user', content: 'private transcript' });
const deleted = repository.markDeleted(session.id);
expect(deleted).toMatchObject({ status: 'deleted', messages: [], bindings: [] });
expect(repository.list()).toHaveLength(0);
expect(repository.dump()).toHaveLength(1);
expect(repository.getByBinding('cli', 'current')).toBeNull();
repository.purgeDeleted([session.id]);
expect(repository.dump()).toHaveLength(0);
expect(() => repository.get(session.id)).toThrow(/not found/);
expect(readdirSync(join(root, 'sessions'))).not.toContain(`${session.id}.json`);
});
it('permanently deletes the session file, index entry, and every binding', () => {
const { root, repository } = fixture();
const session = repository.create({ binding: { channelType: 'cli', externalConversationId: 'current' } });
repository.bind(session.id, 'web', 'thread-1');
repository.appendMessage(session.id, { role: 'user', content: 'erase me' });
const deleted = repository.deletePermanently(session.alias);
expect(deleted.id).toBe(session.id);
expect(repository.list({ includeArchived: true, includeDeleted: true })).toEqual([]);
expect(repository.getByBinding('cli', 'current')).toBeNull();
expect(repository.getByBinding('web', 'thread-1')).toBeNull();
expect(readdirSync(join(root, 'sessions'))).not.toContain(`${session.id}.json`);
const index = JSON.parse(readFileSync(join(root, 'sessions', 'index.json'), 'utf8'));
expect(index.sessions).toEqual([]);
expect(index.bindings).toEqual({});
expect(() => repository.deletePermanently(session.id)).toThrow(/not found/);
});
it('updates titles, revisions, and mutation subscribers idempotently', () => {
const { repository } = fixture();
const session = repository.create();
let mutations = 0;
const unsubscribe = repository.subscribe(() => mutations++);
const updated = repository.updateTitle(session.id, ' Canonical Session Title ', 'generated');
expect(updated).toMatchObject({ title: 'Canonical Session Title', titleSource: 'generated' });
expect(updated.revision).toBeGreaterThan(session.revision);
repository.updateTitle(session.id, 'Canonical Session Title', 'generated');
expect(mutations).toBe(1);
unsubscribe();
repository.archive(session.id);
expect(mutations).toBe(1);
expect(() => repository.updateTitle(session.id, ' '.repeat(2))).toThrow(/required/);
});
it('keeps a user rename when automatic generation or startup repair finishes later', async () => {
const { root, repository } = fixture();
const session = repository.create();
repository.appendMessage(session.id, { role: 'user', content: 'Discuss the launch' });
// Simulate a title generator/repair suspended while the owner renames.
let finish!: () => void;
const delayedTitle = new Promise<void>(resolve => { finish = resolve; }).then(() => repository.updateTitle(session.id, 'Automatic title', 'generated'));
const renamed = repository.updateTitle(session.id, 'My launch plan', 'user', { touch: false });
finish();
await delayedTitle;
repository.updateTitle(session.id, 'Fallback title', 'fallback');
const reloaded = new SessionRepository({ rootDir: join(root, 'sessions'), autoMigrate: false });
expect(reloaded.get(session.id)).toMatchObject({ title: 'My launch plan', titleSource: 'user', revision: renamed.revision });
});
it('imports legacy web and short-term JSON idempotently without deleting sources', () => {
const root = mkdtempSync(join(tmpdir(), 'mercury-migration-'));
const web = join(root, 'web-chat-history');
const short = join(root, 'short-term');
mkdirSync(web);
mkdirSync(short);
writeFileSync(join(web, 'thread.json'), JSON.stringify({
id: 'thread-1', title: 'Legacy thread', createdAt: 1, updatedAt: 3, messages: [
{ id: 'u1', role: 'user', content: 'same', timestamp: 1 },
{ id: 'u2', role: 'user', content: 'same', timestamp: 2 },
{ id: 'a1', role: 'assistant', content: 'answer', timestamp: 3 },
],
}));
writeFileSync(join(short, 'cli.json'), JSON.stringify([{ id: 'c1', role: 'user', content: 'cli legacy', timestamp: 4 }]));
const options = { rootDir: join(root, 'sessions'), legacyWebChatDir: web, legacyShortTermDir: short };
const repository = new SessionRepository(options);
expect(repository.getByBinding('web', 'thread-1')).toMatchObject({ createdAt: 1, updatedAt: 3 });
expect(repository.getByBinding('web', 'thread-1')?.messages).toHaveLength(2);
expect(repository.getByBinding('cli', 'cli')?.messages[0].content).toBe('cli legacy');
expect(new SessionRepository(options).dump()).toHaveLength(2);
expect(readdirSync(web)).toContain('thread.json');
expect(readdirSync(short)).toContain('cli.json');
});
});
describe('SessionRepository.updateTitle without touching', () => {
it('renames without moving the session in the list', () => {
const repo = new SessionRepository({ rootDir: mkdtempSync(join(tmpdir(), 'mercury-retitle-')), autoMigrate: false });
const older = repo.create({ title: 'Older', titleSource: 'generated' });
repo.appendMessage(older.id, { role: 'user', content: 'a', timestamp: 1_000 });
const newer = repo.create({ title: 'Newer' });
repo.appendMessage(newer.id, { role: 'user', content: 'b', timestamp: Date.now() + 60_000 });
const before = repo.get(older.id).updatedAt;
repo.updateTitle(older.id, 'Fixed Title', 'generated', { touch: false });
expect(repo.get(older.id)).toMatchObject({ title: 'Fixed Title', titleSource: 'generated', updatedAt: before });
expect(repo.list().map((s) => s.id)).toEqual([newer.id, older.id]);
});
});