Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
import { describe, expect, it } from 'vitest';
import {
SESSION_DRAFT_INVALIDATION_PREFIX,
SESSION_DRAFT_MUTATION_PREFIX,
SESSION_DRAFT_STORAGE_PREFIX,
SessionDraftLocalCache,
} from './sessionDraftLocalCache';
class MemoryStorage {
readonly values = new Map<string, string>();
get length(): number {
return this.values.size;
}
key(index: number): string | null {
return [...this.values.keys()][index] ?? null;
}
getItem(key: string): string | null {
return this.values.get(key) ?? null;
}
setItem(key: string, value: string): void {
this.values.set(key, value);
}
removeItem(key: string): void {
this.values.delete(key);
}
}
describe('SessionDraftLocalCache', () => {
it('stores dirty and clean versioned records per session', () => {
const storage = new MemoryStorage();
let sequence = 0;
const cache = new SessionDraftLocalCache(
storage,
() => `id-${++sequence}`,
() => 100 + sequence,
);
const dirty = cache.writeDirty('session/a', 'typing', 'server-1');
expect(cache.read('session/a')).toEqual({
version: 1,
text: 'typing',
serverUpdatedAt: 'server-1',
dirty: true,
mutationId: 'id-1',
savedAt: 101,
});
expect([...storage.values.keys()]).toEqual([
`${SESSION_DRAFT_MUTATION_PREFIX}session%2Fa:id-1`,
]);
cache.acknowledge('session/a', dirty.mutationId, 'typing', 'server-2');
expect(cache.read('session/a')).toMatchObject({
text: 'typing',
serverUpdatedAt: 'server-2',
dirty: false,
mutationId: 'id-1',
});
expect([...storage.values.keys()]).toEqual([
`${SESSION_DRAFT_STORAGE_PREFIX}session%2Fa`,
]);
});
it('removes an empty clean draft and ignores stale acknowledgements or rebases', () => {
const storage = new MemoryStorage();
const cache = new SessionDraftLocalCache(storage, () => 'current', () => 1);
cache.writeDirty('session-a', 'text', null);
cache.rebaseDirty('session-a', 'stale', 'server-1');
expect(cache.read('session-a')?.serverUpdatedAt).toBeNull();
cache.acknowledge('session-a', 'stale', 'old text', 'server-1');
expect(cache.read('session-a')).toMatchObject({ text: 'text', dirty: true });
cache.acknowledge('session-a', 'current', 'text', 'server-1');
expect(cache.read('session-a')).toMatchObject({
text: 'text',
dirty: false,
mutationId: 'current',
serverUpdatedAt: 'server-1',
});
cache.writeClean('session-a', '', 'server-2');
expect(cache.read('session-a')).toBeNull();
});
it('enumerates only dirty session records for reconnect replay', () => {
const storage = new MemoryStorage();
let sequence = 0;
const cache = new SessionDraftLocalCache(storage, () => `id-${++sequence}`, () => sequence);
cache.writeDirty('session/a', 'offline A', 'server-1');
storage.setItem(`${SESSION_DRAFT_STORAGE_PREFIX}broken`, '{not-json');
cache.writeClean('session-b', 'synced B', 'server-2');
cache.writeDirty('session-c', 'offline C', null);
expect(cache.dirtySessionIds()).toEqual(['session/a', 'session-c']);
expect(storage.getItem(`${SESSION_DRAFT_STORAGE_PREFIX}broken`)).toBeNull();
});
it('acknowledges one tab without replacing another tab mutation', () => {
const storage = new MemoryStorage();
const first = new SessionDraftLocalCache(storage, () => 'tab-a', () => 1);
const second = new SessionDraftLocalCache(storage, () => 'tab-b', () => 2);
first.writeDirty('session-a', 'from tab A', null);
const removeItem = storage.removeItem.bind(storage);
storage.removeItem = (key) => {
if (key === `${SESSION_DRAFT_MUTATION_PREFIX}session-a:tab-a`) {
second.writeDirty('session-a', 'from tab B', null);
}
removeItem(key);
};
first.acknowledge('session-a', 'tab-a', 'from tab A', 'rev-a');
expect(second.read('session-a')).toMatchObject({
text: 'from tab B',
dirty: true,
mutationId: 'tab-b',
});
expect(storage.getItem(
`${SESSION_DRAFT_MUTATION_PREFIX}session-a:tab-b`,
)).not.toBeNull();
first.writeClean('session-a', '', 'clear-revision');
expect(second.read('session-a')).toMatchObject({
text: 'from tab B',
dirty: true,
mutationId: 'tab-b',
});
});
it('retires mutations older than the acknowledged reload winner', () => {
const storage = new MemoryStorage();
let sequence = 0;
const writer = new SessionDraftLocalCache(
storage,
() => `mutation-${++sequence}`,
() => sequence,
);
const older = writer.writeDirty('session-a', 'older text', 'rev-0');
const winner = writer.writeDirty('session-a', 'selected text', 'rev-0');
const restored = new SessionDraftLocalCache(storage, () => 'unused', () => 10);
expect(restored.read('session-a')?.mutationId).toBe(winner.mutationId);
restored.acknowledge('session-a', winner.mutationId, winner.text, 'rev-1');
expect(storage.getItem(
`${SESSION_DRAFT_MUTATION_PREFIX}session-a:${older.mutationId}`,
)).toBeNull();
expect(restored.dirtySessionIds()).toEqual([]);
expect(restored.read('session-a')).toMatchObject({
text: 'selected text',
serverUpdatedAt: 'rev-1',
dirty: false,
});
});
it('persists archive invalidation across cache instances', () => {
const storage = new MemoryStorage();
const first = new SessionDraftLocalCache(storage, () => 'archive-1', () => 1);
const second = new SessionDraftLocalCache(storage, () => 'unused', () => 2);
expect(first.readInvalidation('session/a')).toBeNull();
expect(first.invalidate('session/a')).toBe('archive-1');
expect(second.readInvalidation('session/a')).toBe('archive-1');
expect(storage.getItem(
`${SESSION_DRAFT_INVALIDATION_PREFIX}session%2Fa`,
)).toBe('archive-1');
});
it('keeps a newer in-memory invalidation when storage retains an older token', () => {
const storage = new MemoryStorage();
let sequence = 0;
let blockWrites = false;
const setItem = storage.setItem.bind(storage);
storage.setItem = (key, value) => {
if (blockWrites) throw new Error('read only');
setItem(key, value);
};
const cache = new SessionDraftLocalCache(
storage,
() => `archive-${++sequence}`,
() => sequence,
);
expect(cache.invalidate('session-a')).toBe('archive-1');
blockWrites = true;
expect(cache.invalidate('session-a')).toBe('archive-2');
expect(storage.getItem(
`${SESSION_DRAFT_INVALIDATION_PREFIX}session-a`,
)).toBe('archive-1');
expect(cache.readInvalidation('session-a')).toBe('archive-2');
});
it('discards malformed data and tolerates blocked storage', () => {
const storage = new MemoryStorage();
storage.setItem(`${SESSION_DRAFT_STORAGE_PREFIX}broken`, '{not-json');
const cache = new SessionDraftLocalCache(storage);
expect(cache.read('broken')).toBeNull();
expect(storage.values.size).toBe(0);
const blocked = {
getItem: () => { throw new Error('blocked'); },
setItem: () => { throw new Error('full'); },
removeItem: () => { throw new Error('blocked'); },
};
const fallback = new SessionDraftLocalCache(blocked, () => 'id', () => 1);
expect(() => fallback.writeDirty('session-a', 'text', null)).not.toThrow();
expect(fallback.read('session-a')).toBeNull();
expect(() => fallback.clear('session-a')).not.toThrow();
expect(fallback.invalidate('session-a')).toBe('id');
expect(fallback.readInvalidation('session-a')).toBe('id');
});
});