@pingagent/sdk 0.1.7 → 0.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pingagent/sdk",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -15,10 +15,18 @@
   "bin": {
     "pingagent": "bin/pingagent.js"
   },
+  "files": [
+    "dist",
+    "bin/pingagent.js"
+  ],
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./web-server": {
+      "types": "./dist/web-server.d.ts",
+      "import": "./dist/web-server.js"
     }
   },
   "dependencies": {
@@ -26,9 +34,9 @@
     "commander": "^13.0.0",
     "uuid": "^11.0.0",
     "ws": "^8.0.0",
-    "@pingagent/schemas": "0.1.1",
+    "@pingagent/protocol": "0.1.1",
     "@pingagent/a2a": "0.1.1",
-    "@pingagent/protocol": "0.1.1"
+    "@pingagent/schemas": "0.1.1"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.0",

package/__tests__/cli.test.ts

@@ -1,225 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,332 +0,0 @@
-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);
-  });
-});