@pingagent/sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 PingAgent Chat Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/__tests__/cli.test.ts

@@ -0,0 +1,225 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { spawnSync, spawn } from 'node:child_process';
+import * as http from 'node:http';
+import * as net from 'node:net';
+
+const SDK_DIR = path.resolve(__dirname, '..');
+const CLI_BIN = path.join(SDK_DIR, 'bin', 'pingagent.js');
+
+function runCli(args: string[], env: Record<string, string> = {}): { stdout: string; stderr: string; status: number } {
+  const result = spawnSync('node', [CLI_BIN, ...args], {
+    cwd: SDK_DIR,
+    encoding: 'utf-8',
+    env: { ...process.env, ...env },
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  return {
+    stdout: result.stdout ?? '',
+    stderr: result.stderr ?? '',
+    status: result.status ?? -1,
+  };
+}
+
+/** Use when the CLI will hit a server in this process (spawnSync would block the event loop). */
+function runCliAsync(
+  args: string[],
+  env: Record<string, string> = {},
+): Promise<{ stdout: string; stderr: string; status: number }> {
+  return new Promise((resolve) => {
+    const child = spawn('node', [CLI_BIN, ...args], {
+      cwd: SDK_DIR,
+      env: { ...process.env, ...env },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    child.stdout?.on('data', (ch: Buffer) => { stdout += ch.toString(); });
+    child.stderr?.on('data', (ch: Buffer) => { stderr += ch.toString(); });
+    child.on('close', (code, signal) => {
+      resolve({
+        stdout,
+        stderr,
+        status: code ?? (signal ? -1 : 0),
+      });
+    });
+  });
+}
+
+describe('CLI', () => {
+  describe('help and version', () => {
+    it('--help exits 0 and prints usage', () => {
+      const { stdout, status } = runCli(['--help']);
+      expect(status).toBe(0);
+      expect(stdout).toContain('PingAgent');
+      expect(stdout).toContain('init');
+      expect(stdout).toContain('status');
+      expect(stdout).toContain('--identity-dir');
+    });
+
+    it('-V prints version', () => {
+      const { stdout, status } = runCli(['-V']);
+      expect(status).toBe(0);
+      expect(stdout.trim()).toMatch(/^\d+\.\d+\.\d+$/);
+    });
+  });
+
+  describe('status without identity', () => {
+    it('prints "No identity found" when no identity', () => {
+      const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pingagent-cli-'));
+      const identityPath = path.join(tmpDir, 'identity.json');
+      const { stdout, status } = runCli(['status'], {
+        PINGAGENT_IDENTITY_PATH: identityPath,
+      });
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+      expect(status).toBe(0);
+      expect(stdout).toContain('No identity found');
+    });
+
+    it('--identity-dir uses that dir for identity and store', () => {
+      const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pingagent-cli-dir-'));
+      const { stdout, status } = runCli(['--identity-dir', tmpDir, 'status']);
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+      expect(status).toBe(0);
+      expect(stdout).toContain('No identity found');
+    });
+  });
+
+  describe('contacts and history (local store only)', () => {
+    it('contacts list with --identity-dir uses isolated store', () => {
+      const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pingagent-cli-contacts-'));
+      try {
+        const { stdout, status } = runCli(['--identity-dir', tmpDir, 'contacts', 'list']);
+        expect(status).toBe(0);
+        expect(stdout).toContain('No contacts found');
+        const storePath = path.join(tmpDir, 'store.db');
+        expect(fs.existsSync(storePath)).toBe(true);
+      } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      }
+    });
+
+    it('contacts add then list with isolated store', () => {
+      const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pingagent-cli-add-'));
+      try {
+        let r = runCli(['--identity-dir', tmpDir, 'contacts', 'add', 'did:agent:test123', '--name', 'Test'], {});
+        expect(r.status).toBe(0);
+        r = runCli(['--identity-dir', tmpDir, 'contacts', 'list']);
+        expect(r.status).toBe(0);
+        expect(r.stdout).toContain('Test');
+        expect(r.stdout).toContain('did:agent:test123');
+      } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      }
+    });
+
+    it('history conversations with --identity-dir uses isolated store', () => {
+      const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pingagent-cli-hist-'));
+      try {
+        const { stdout, status } = runCli(['--identity-dir', tmpDir, 'history', 'conversations']);
+        expect(status).toBe(0);
+        expect(stdout).toContain('No local history');
+      } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      }
+    });
+  });
+
+  describe('init with mock server', () => {
+    let server: http.Server;
+    let serverUrl: string;
+
+    beforeAll(async () => {
+      server = http.createServer((req, res) => {
+        if (req.method === 'POST' && req.url === '/v1/agent/register') {
+          let body = '';
+          req.on('data', (ch) => { body += ch; });
+          req.on('end', () => {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(
+              JSON.stringify({
+                ok: true,
+                data: {
+                  did: 'did:agent:mock123',
+                  access_token: 'mock_token',
+                  expires_ms: 3600000,
+                  mode: 'ghost',
+                },
+              }),
+            );
+          });
+          return;
+        }
+        if (req.method === 'GET' && req.url === '/v1/subscription') {
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(
+            JSON.stringify({
+              ok: true,
+              data: {
+                tier: 'ghost',
+                limits: { relay_per_day: 200, max_group_size: 0, artifact_storage_mb: 100, audit_export_allowed: false, alias_limit: 0 },
+                usage: { relay_today: 0, relay_limit: 200, artifact_bytes: 0, artifact_limit_bytes: 104857600, alias_count: 0, alias_limit: 0 },
+                has_stripe_customer: false,
+              },
+            }),
+          );
+          return;
+        }
+        res.writeHead(404);
+        res.end();
+      });
+      await new Promise<void>((resolve) => {
+        server.listen(0, '127.0.0.1', () => {
+          const a = server.address() as net.AddressInfo;
+          serverUrl = `http://127.0.0.1:${a.port}`;
+          resolve();
+        });
+      });
+    }, 10_000);
+
+    afterAll(async () => {
+      await new Promise<void>((resolve) => {
+        server.close(() => resolve());
+      });
+    }, 5_000);
+
+    it('init creates identity and store in identity-dir', async () => {
+      const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pingagent-cli-init-'));
+      try {
+        const { stdout, status } = await runCliAsync(['--identity-dir', tmpDir, 'init', '--server', serverUrl]);
+        expect(status).toBe(0);
+        expect(stdout).toContain('PingAgent Chat Setup');
+        expect(stdout).toContain('Ready!');
+        // CLI prints server-returned DID; saved identity uses keypair-derived DID
+        expect(stdout).toMatch(/did:agent:[A-Za-z0-9_-]+/);
+
+        const identityPath = path.join(tmpDir, 'identity.json');
+        expect(fs.existsSync(identityPath)).toBe(true);
+        const identity = JSON.parse(fs.readFileSync(identityPath, 'utf-8'));
+        expect(identity.did).toMatch(/^did:agent:/);
+
+        const { stdout: statusOut, status: statusCode } = await runCliAsync(['--identity-dir', tmpDir, 'status']);
+        expect(statusCode).toBe(0);
+        expect(statusOut).toMatch(/DID: did:agent:/);
+        expect(statusOut).toContain('Tier: ghost');
+      } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      }
+    }, 15_000);
+
+    it('init idempotent: second init reports already exists', async () => {
+      const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pingagent-cli-init2-'));
+      try {
+        await runCliAsync(['--identity-dir', tmpDir, 'init', '--server', serverUrl]);
+        const { stdout, status } = await runCliAsync(['--identity-dir', tmpDir, 'init', '--server', serverUrl]);
+        expect(status).toBe(0);
+        expect(stdout).toContain('Identity already exists');
+        expect(stdout).toMatch(/did:agent:[A-Za-z0-9_-]+/);
+      } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+      }
+    }, 15_000);
+  });
+});

package/__tests__/identity.test.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect } from 'vitest';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { generateIdentity, saveIdentity, loadIdentity } from '../src/identity.js';
+
+describe('Identity Manager', () => {
+  it('generates a valid identity', () => {
+    const id = generateIdentity();
+    expect(id.did).toMatch(/^did:agent:/);
+    expect(id.deviceId).toMatch(/^dev_/);
+    expect(id.publicKey.length).toBe(32);
+    expect(id.privateKey.length).toBe(32);
+  });
+
+  it('saves and loads identity', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pingagent-test-'));
+    const idPath = path.join(tmpDir, 'identity.json');
+
+    const id = generateIdentity();
+    saveIdentity(id, { serverUrl: 'http://localhost:8787', mode: 'ghost' }, idPath);
+
+    const loaded = loadIdentity(idPath);
+    expect(loaded.did).toBe(id.did);
+    expect(loaded.deviceId).toBe(id.deviceId);
+    expect(loaded.serverUrl).toBe('http://localhost:8787');
+    expect(loaded.mode).toBe('ghost');
+    expect(loaded.publicKey).toEqual(id.publicKey);
+    expect(loaded.privateKey).toEqual(id.privateKey);
+
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+
+  it('sets file permissions to 600', () => {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pingagent-test-'));
+    const idPath = path.join(tmpDir, 'identity.json');
+
+    const id = generateIdentity();
+    saveIdentity(id, {}, idPath);
+
+    const stats = fs.statSync(idPath);
+    const mode = (stats.mode & 0o777).toString(8);
+    expect(mode).toBe('600');
+
+    fs.rmSync(tmpDir, { recursive: true });
+  });
+});

package/__tests__/store.test.ts

@@ -0,0 +1,332 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { LocalStore } from '../src/store.js';
+import { ContactManager, type Contact } from '../src/contacts.js';
+import { HistoryManager, type StoredMessage } from '../src/history.js';
+
+function createTempStore(): { store: LocalStore; dbPath: string; cleanup: () => void } {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pingagent-store-test-'));
+  const dbPath = path.join(tmpDir, 'store.db');
+  const store = new LocalStore(dbPath);
+  return { store, dbPath, cleanup: () => { store.close(); fs.rmSync(tmpDir, { recursive: true }); } };
+}
+
+describe('LocalStore', () => {
+  let store: LocalStore;
+  let cleanup: () => void;
+
+  beforeEach(() => {
+    const s = createTempStore();
+    store = s.store;
+    cleanup = s.cleanup;
+  });
+
+  afterEach(() => cleanup());
+
+  it('creates tables on initialization', () => {
+    const db = store.getDb();
+    const tables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name").all() as Array<{ name: string }>;
+    const names = tables.map(t => t.name);
+    expect(names).toContain('contacts');
+    expect(names).toContain('messages');
+    expect(names).toContain('sync_state');
+  });
+
+  it('survives open/close/reopen', () => {
+    const db = store.getDb();
+    db.prepare("INSERT INTO contacts (did, trusted, added_at) VALUES ('did:agent:test', 1, 100)").run();
+    const dbPath = db.name;
+    store.close();
+
+    const store2 = new LocalStore(dbPath);
+    const row = store2.getDb().prepare("SELECT did FROM contacts").get() as { did: string };
+    expect(row.did).toBe('did:agent:test');
+    store2.close();
+  });
+
+  it('uses WAL journal mode', () => {
+    const mode = store.getDb().pragma('journal_mode', { simple: true }) as string;
+    expect(mode).toBe('wal');
+  });
+});
+
+describe('ContactManager', () => {
+  let store: LocalStore;
+  let cm: ContactManager;
+  let cleanup: () => void;
+
+  beforeEach(() => {
+    const s = createTempStore();
+    store = s.store;
+    cm = new ContactManager(store);
+    cleanup = s.cleanup;
+  });
+
+  afterEach(() => cleanup());
+
+  it('adds and retrieves a contact', () => {
+    const contact = cm.add({ did: 'did:agent:alice', alias: 'alice', trusted: true });
+    expect(contact.did).toBe('did:agent:alice');
+    expect(contact.alias).toBe('alice');
+    expect(contact.trusted).toBe(true);
+    expect(contact.added_at).toBeGreaterThan(0);
+
+    const fetched = cm.get('did:agent:alice');
+    expect(fetched).not.toBeNull();
+    expect(fetched!.alias).toBe('alice');
+    expect(fetched!.trusted).toBe(true);
+  });
+
+  it('upserts on duplicate DID', () => {
+    cm.add({ did: 'did:agent:bob', alias: 'bob1', trusted: false });
+    cm.add({ did: 'did:agent:bob', alias: 'bob2', trusted: true });
+    const fetched = cm.get('did:agent:bob');
+    expect(fetched!.alias).toBe('bob2');
+    expect(fetched!.trusted).toBe(true);
+  });
+
+  it('removes a contact', () => {
+    cm.add({ did: 'did:agent:charlie', trusted: false });
+    expect(cm.remove('did:agent:charlie')).toBe(true);
+    expect(cm.get('did:agent:charlie')).toBeNull();
+    expect(cm.remove('did:agent:nonexistent')).toBe(false);
+  });
+
+  it('updates partial fields', () => {
+    cm.add({ did: 'did:agent:dave', alias: 'dave', notes: 'old', trusted: false });
+    const updated = cm.update('did:agent:dave', { notes: 'new', trusted: true });
+    expect(updated!.notes).toBe('new');
+    expect(updated!.trusted).toBe(true);
+    expect(updated!.alias).toBe('dave');
+  });
+
+  it('returns null when updating nonexistent contact', () => {
+    const result = cm.update('did:agent:ghost', { alias: 'x' });
+    expect(result).toBeNull();
+  });
+
+  it('lists contacts with filters', () => {
+    cm.add({ did: 'did:agent:a', trusted: true, tags: ['dev'] });
+    cm.add({ did: 'did:agent:b', trusted: false, tags: ['ops'] });
+    cm.add({ did: 'did:agent:c', trusted: true, tags: ['dev', 'ops'] });
+
+    expect(cm.list()).toHaveLength(3);
+    expect(cm.list({ trusted: true })).toHaveLength(2);
+    expect(cm.list({ trusted: false })).toHaveLength(1);
+    expect(cm.list({ tag: 'dev' })).toHaveLength(2);
+    expect(cm.list({ tag: 'ops' })).toHaveLength(2);
+    expect(cm.list({ limit: 2 })).toHaveLength(2);
+  });
+
+  it('searches across did, alias, display_name, notes', () => {
+    cm.add({ did: 'did:agent:searchme', trusted: false });
+    cm.add({ did: 'did:agent:x', alias: 'findable', trusted: false });
+    cm.add({ did: 'did:agent:y', display_name: 'Mr Find', trusted: false });
+    cm.add({ did: 'did:agent:z', notes: 'hard to find', trusted: false });
+
+    expect(cm.search('find')).toHaveLength(3);
+    expect(cm.search('searchme')).toHaveLength(1);
+    expect(cm.search('nothing')).toHaveLength(0);
+  });
+
+  it('exports and imports JSON', () => {
+    cm.add({ did: 'did:agent:e1', alias: 'export1', trusted: true, tags: ['a'] });
+    cm.add({ did: 'did:agent:e2', alias: 'export2', trusted: false });
+
+    const json = cm.export('json');
+    const parsed = JSON.parse(json);
+    expect(parsed).toHaveLength(2);
+
+    const s2 = createTempStore();
+    const cm2 = new ContactManager(s2.store);
+    const result = cm2.import(json, 'json');
+    expect(result.imported).toBe(2);
+    expect(result.skipped).toBe(0);
+    expect(cm2.list()).toHaveLength(2);
+    s2.cleanup();
+  });
+
+  it('exports and imports CSV', () => {
+    cm.add({ did: 'did:agent:csv1', alias: 'c1', display_name: 'CSV One', trusted: true, tags: ['x'] });
+    const csv = cm.export('csv');
+    expect(csv).toContain('did,alias,display_name');
+    expect(csv).toContain('did:agent:csv1');
+
+    const s2 = createTempStore();
+    const cm2 = new ContactManager(s2.store);
+    const result = cm2.import(csv, 'csv');
+    expect(result.imported).toBe(1);
+    const fetched = cm2.get('did:agent:csv1');
+    expect(fetched).not.toBeNull();
+    expect(fetched!.alias).toBe('c1');
+    s2.cleanup();
+  });
+});
+
+describe('HistoryManager', () => {
+  let store: LocalStore;
+  let hm: HistoryManager;
+  let cleanup: () => void;
+
+  beforeEach(() => {
+    const s = createTempStore();
+    store = s.store;
+    hm = new HistoryManager(store);
+    cleanup = s.cleanup;
+  });
+
+  afterEach(() => cleanup());
+
+  function makeMsg(overrides: Partial<StoredMessage> = {}): StoredMessage {
+    return {
+      conversation_id: 'c_dm_test',
+      message_id: `m_${Math.random().toString(36).slice(2)}`,
+      seq: 1,
+      sender_did: 'did:agent:sender',
+      schema: 'pingagent.text@1',
+      payload: { text: 'hello' },
+      ts_ms: Date.now(),
+      direction: 'received',
+      ...overrides,
+    };
+  }
+
+  it('saves and lists messages', () => {
+    const msgs = [
+      makeMsg({ seq: 1, message_id: 'm_1' }),
+      makeMsg({ seq: 2, message_id: 'm_2' }),
+      makeMsg({ seq: 3, message_id: 'm_3' }),
+    ];
+    const count = hm.save(msgs);
+    expect(count).toBe(3);
+
+    const listed = hm.list('c_dm_test');
+    expect(listed).toHaveLength(3);
+    expect(listed[0].seq).toBe(1);
+    expect(listed[2].seq).toBe(3);
+  });
+
+  it('upserts on duplicate message_id', () => {
+    hm.save([makeMsg({ message_id: 'm_dup', seq: 1, payload: { text: 'v1' } })]);
+    hm.save([makeMsg({ message_id: 'm_dup', seq: 2, payload: { text: 'v2' } })]);
+
+    const listed = hm.list('c_dm_test');
+    expect(listed).toHaveLength(1);
+    expect(listed[0].seq).toBe(2);
+    expect(listed[0].payload.text).toBe('v2');
+  });
+
+  it('lists with pagination (beforeSeq, afterSeq, limit)', () => {
+    const msgs = Array.from({ length: 10 }, (_, i) =>
+      makeMsg({ seq: i + 1, message_id: `m_${i + 1}` }),
+    );
+    hm.save(msgs);
+
+    expect(hm.list('c_dm_test', { limit: 3 })).toHaveLength(3);
+    expect(hm.list('c_dm_test', { afterSeq: 7 })).toHaveLength(3);
+    expect(hm.list('c_dm_test', { beforeSeq: 4 })).toHaveLength(3);
+  });
+
+  it('searches by payload content', () => {
+    hm.save([
+      makeMsg({ message_id: 'm_s1', payload: { text: 'fix the bug' } }),
+      makeMsg({ message_id: 'm_s2', payload: { text: 'deploy the app' } }),
+      makeMsg({ message_id: 'm_s3', payload: { title: 'important bug fix' } }),
+    ]);
+
+    const results = hm.search('bug');
+    expect(results).toHaveLength(2);
+    expect(hm.search('deploy')).toHaveLength(1);
+    expect(hm.search('nonexistent')).toHaveLength(0);
+  });
+
+  it('searches scoped to a conversation', () => {
+    hm.save([
+      makeMsg({ message_id: 'm_c1', conversation_id: 'c_dm_a', payload: { text: 'hello' } }),
+      makeMsg({ message_id: 'm_c2', conversation_id: 'c_dm_b', payload: { text: 'hello there' } }),
+    ]);
+
+    expect(hm.search('hello')).toHaveLength(2);
+    expect(hm.search('hello', { conversationId: 'c_dm_a' })).toHaveLength(1);
+  });
+
+  it('deletes all messages for a conversation', () => {
+    hm.save([
+      makeMsg({ message_id: 'm_d1', conversation_id: 'c_dm_del' }),
+      makeMsg({ message_id: 'm_d2', conversation_id: 'c_dm_del' }),
+      makeMsg({ message_id: 'm_d3', conversation_id: 'c_dm_keep' }),
+    ]);
+
+    const deleted = hm.delete('c_dm_del');
+    expect(deleted).toBe(2);
+    expect(hm.list('c_dm_del')).toHaveLength(0);
+    expect(hm.list('c_dm_keep')).toHaveLength(1);
+  });
+
+  it('lists conversations with aggregates', () => {
+    hm.save([
+      makeMsg({ message_id: 'm_lc1', conversation_id: 'c_dm_x', ts_ms: 1000 }),
+      makeMsg({ message_id: 'm_lc2', conversation_id: 'c_dm_x', ts_ms: 2000 }),
+      makeMsg({ message_id: 'm_lc3', conversation_id: 'c_dm_y', ts_ms: 3000 }),
+    ]);
+
+    const convos = hm.listConversations();
+    expect(convos).toHaveLength(2);
+
+    const x = convos.find(c => c.conversation_id === 'c_dm_x')!;
+    expect(x.message_count).toBe(2);
+    expect(x.last_message_at).toBe(2000);
+
+    const y = convos.find(c => c.conversation_id === 'c_dm_y')!;
+    expect(y.message_count).toBe(1);
+  });
+
+  it('manages sync state', () => {
+    expect(hm.getLastSyncedSeq('c_dm_sync')).toBe(0);
+
+    hm.setLastSyncedSeq('c_dm_sync', 42);
+    expect(hm.getLastSyncedSeq('c_dm_sync')).toBe(42);
+
+    hm.setLastSyncedSeq('c_dm_sync', 100);
+    expect(hm.getLastSyncedSeq('c_dm_sync')).toBe(100);
+  });
+
+  it('exports JSON', () => {
+    hm.save([
+      makeMsg({ message_id: 'm_ej1', conversation_id: 'c_dm_exp', seq: 1 }),
+      makeMsg({ message_id: 'm_ej2', conversation_id: 'c_dm_exp', seq: 2 }),
+    ]);
+
+    const json = hm.export({ conversationId: 'c_dm_exp', format: 'json' });
+    const parsed = JSON.parse(json);
+    expect(parsed).toHaveLength(2);
+    expect(parsed[0].message_id).toBe('m_ej1');
+  });
+
+  it('exports CSV', () => {
+    hm.save([makeMsg({ message_id: 'm_ec1', conversation_id: 'c_dm_exp2' })]);
+    const csv = hm.export({ conversationId: 'c_dm_exp2', format: 'csv' });
+    expect(csv).toContain('conversation_id,message_id');
+    expect(csv).toContain('m_ec1');
+  });
+
+  it('exports all conversations when no conversationId specified', () => {
+    hm.save([
+      makeMsg({ message_id: 'm_all1', conversation_id: 'c_dm_1' }),
+      makeMsg({ message_id: 'm_all2', conversation_id: 'c_dm_2' }),
+    ]);
+    const json = hm.export({ format: 'json' });
+    const parsed = JSON.parse(json);
+    expect(parsed).toHaveLength(2);
+  });
+
+  it('delete also clears sync state', () => {
+    hm.save([makeMsg({ message_id: 'm_ss', conversation_id: 'c_dm_ss' })]);
+    hm.setLastSyncedSeq('c_dm_ss', 50);
+
+    hm.delete('c_dm_ss');
+    expect(hm.getLastSyncedSeq('c_dm_ss')).toBe(0);
+  });
+});