@build-astron-co/nimbus 0.4.1 → 0.4.3

package/src/__tests__/doctor.test.ts

@@ -1,48 +0,0 @@
-/**
- * Doctor Command Tests — C1
- *
- * Verifies that process.exit(1) is called when any check fails.
- */
-
-import { describe, test, expect, vi, beforeEach, afterEach } from 'vitest';
-
-// We need to mock process.exit before importing doctorCommand
-const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {}) as (code?: string | number | null) => never);
-
-describe('doctorCommand exit codes (C1)', () => {
-  beforeEach(() => {
-    exitSpy.mockClear();
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  test('exits 0 when all checks pass (spy stays uncalled)', async () => {
-    // A simple unit test: verify the exit spy pattern works
-    // We don't call process.exit here, so the spy should not be called
-    expect(exitSpy).not.toHaveBeenCalled();
-  });
-
-  test('process.exit(1) is called after JSON output when a check fails', async () => {
-    // Simulate what doctorCommand does on failure
-    const allPassed = false;
-    if (!allPassed) process.exit(1);
-    expect(exitSpy).toHaveBeenCalledWith(1);
-  });
-
-  test('process.exit(1) is called in summary section when a check fails', async () => {
-    exitSpy.mockClear();
-    // Simulate text-mode failure path
-    const allPassed = false;
-    if (!allPassed) process.exit(1);
-    expect(exitSpy).toHaveBeenCalledWith(1);
-  });
-
-  test('process.exit is not called when all checks pass', async () => {
-    exitSpy.mockClear();
-    const allPassed = true;
-    if (!allPassed) process.exit(1);
-    expect(exitSpy).not.toHaveBeenCalled();
-  });
-});

package/src/__tests__/enterprise.test.ts

@@ -1,401 +0,0 @@
-/**
- * Tests for the enterprise modules:
- *   - src/enterprise/auth.ts    – initiateDeviceFlow, pollDeviceCode, verifyDeviceCode, validateToken
- *   - src/enterprise/teams.ts   – createTeam, getTeam, listUserTeams, inviteMember, listMembers
- *   - src/enterprise/billing.ts – subscribe, getBillingStatus, recordUsage, getUsage
- *   - src/enterprise/audit.ts   – createLog, queryLogs, exportLogs
- *
- * Every test uses an isolated in-memory SQLite database via NIMBUS_DB_PATH=':memory:'
- * so the real ~/.nimbus/nimbus.db is never touched.
- *
- * IMPORTANT: The enterprise modules use `getDb()` (singleton) internally when
- * they reach for the database.  We set NIMBUS_DB_PATH to ':memory:' before
- * each test group and reset the db singleton afterwards via `closeDb()`.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { getTestDb, closeDb } from '../state/db';
-
-// ---------------------------------------------------------------------------
-// Setup: point every getDb() call to a fresh in-memory database.
-// ---------------------------------------------------------------------------
-
-beforeEach(() => {
-  // closeDb() resets the db singleton so the next getDb() call re-opens.
-  closeDb();
-  // Re-initialise using NIMBUS_DB_PATH=':memory:' by creating a test db
-  // and setting the env variable so subsequent getDb() calls hit :memory:.
-  process.env.NIMBUS_DB_PATH = ':memory:';
-  // Warm-up the singleton with migrations applied
-  getTestDb(); // just to confirm migration works; enterprise fns call getDb() on their own
-});
-
-afterEach(() => {
-  closeDb();
-  delete process.env.NIMBUS_DB_PATH;
-});
-
-// ---------------------------------------------------------------------------
-// Auth: device-authorization flow
-// ---------------------------------------------------------------------------
-
-describe('enterprise auth – initiateDeviceFlow', () => {
-  it('returns a DeviceCodeResponse with all expected fields', async () => {
-    const { initiateDeviceFlow } = await import('../enterprise/auth');
-    const response = await initiateDeviceFlow();
-
-    expect(typeof response.deviceCode).toBe('string');
-    expect(response.deviceCode.length).toBeGreaterThan(0);
-    expect(typeof response.userCode).toBe('string');
-    // User code format: XXXX-NNNN
-    expect(/^[A-Z]{4}-\d{4}$/.test(response.userCode)).toBe(true);
-    expect(typeof response.verificationUri).toBe('string');
-    expect(response.expiresIn).toBe(900);
-    expect(response.interval).toBe(5);
-  });
-
-  it('generates a unique deviceCode on each call', async () => {
-    const { initiateDeviceFlow } = await import('../enterprise/auth');
-    const r1 = await initiateDeviceFlow();
-    const r2 = await initiateDeviceFlow();
-    expect(r1.deviceCode).not.toBe(r2.deviceCode);
-    expect(r1.userCode).not.toBe(r2.userCode);
-  });
-
-  it('userCode consists of uppercase letters and digits only', async () => {
-    const { initiateDeviceFlow } = await import('../enterprise/auth');
-    const { userCode } = await initiateDeviceFlow();
-    // Valid chars: uppercase ASCII letters (no I or O) + digits + hyphen
-    expect(/^[A-HJ-NP-Z0-9]{4}-[0-9]{4}$/.test(userCode)).toBe(true);
-  });
-});
-
-describe('enterprise auth – pollDeviceCode', () => {
-  it('returns authorization_pending for a newly created device code', async () => {
-    const { initiateDeviceFlow, pollDeviceCode } = await import('../enterprise/auth');
-    const { deviceCode } = await initiateDeviceFlow();
-    const response = await pollDeviceCode(deviceCode);
-
-    expect(response.error).toBe('authorization_pending');
-    expect(response.accessToken).toBeUndefined();
-  });
-
-  it('returns expired_token for an unknown device code', async () => {
-    const { pollDeviceCode } = await import('../enterprise/auth');
-    const response = await pollDeviceCode('nonexistent-device-code');
-    expect(response.error).toBe('expired_token');
-  });
-});
-
-describe('enterprise auth – validateToken', () => {
-  it('returns valid: false for a non-existent token', async () => {
-    const { validateToken } = await import('../enterprise/auth');
-    const result = await validateToken({ accessToken: 'not-a-real-token' });
-    expect(result.valid).toBe(false);
-  });
-
-  it('returns valid: false for an empty token string', async () => {
-    const { validateToken } = await import('../enterprise/auth');
-    const result = await validateToken({ accessToken: '' });
-    expect(result.valid).toBe(false);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Teams
-// ---------------------------------------------------------------------------
-
-describe('enterprise teams – createTeam', () => {
-  it('creates a team and returns a Team object', async () => {
-    const { createTeam } = await import('../enterprise/teams');
-    const team = await createTeam({ name: 'Nimbus Core', ownerId: 'user-001' });
-
-    expect(typeof team.id).toBe('string');
-    expect(team.id.length).toBeGreaterThan(0);
-    expect(team.name).toBe('Nimbus Core');
-    expect(team.ownerId).toBe('user-001');
-    expect(team.plan).toBe('free');
-  });
-
-  it('throws when name is missing', async () => {
-    const { createTeam } = await import('../enterprise/teams');
-    await expect(createTeam({ name: '', ownerId: 'user-001' })).rejects.toThrow();
-  });
-
-  it('throws when ownerId is missing', async () => {
-    const { createTeam } = await import('../enterprise/teams');
-    await expect(createTeam({ name: 'Team', ownerId: '' })).rejects.toThrow();
-  });
-});
-
-describe('enterprise teams – getTeam', () => {
-  it('retrieves a team that was just created', async () => {
-    const { createTeam, getTeam } = await import('../enterprise/teams');
-    const created = await createTeam({ name: 'Alpha Team', ownerId: 'u-alpha' });
-    const fetched = await getTeam(created.id);
-
-    expect(fetched).not.toBeNull();
-    expect(fetched!.id).toBe(created.id);
-    expect(fetched!.name).toBe('Alpha Team');
-  });
-
-  it('returns null for a non-existent team id', async () => {
-    const { getTeam } = await import('../enterprise/teams');
-    const result = await getTeam('non-existent-id');
-    expect(result).toBeNull();
-  });
-});
-
-describe('enterprise teams – listUserTeams', () => {
-  it('returns teams where user is a member', async () => {
-    const { createTeam, listUserTeams } = await import('../enterprise/teams');
-    await createTeam({ name: 'My Team', ownerId: 'user-list' });
-    const teams = await listUserTeams('user-list');
-
-    expect(Array.isArray(teams)).toBe(true);
-    expect(teams.length).toBeGreaterThanOrEqual(1);
-    expect(teams.some(t => t.name === 'My Team')).toBe(true);
-  });
-
-  it('returns empty array for user with no team memberships', async () => {
-    const { listUserTeams } = await import('../enterprise/teams');
-    const teams = await listUserTeams('user-with-no-teams-xyz');
-    expect(Array.isArray(teams)).toBe(true);
-    expect(teams.length).toBe(0);
-  });
-});
-
-describe('enterprise teams – inviteMember', () => {
-  it('invites a new member to a team by email', async () => {
-    const { createTeam, inviteMember } = await import('../enterprise/teams');
-    const team = await createTeam({ name: 'Invite Team', ownerId: 'owner-u' });
-    const member = await inviteMember(team.id, { email: 'new@example.com', role: 'member' });
-
-    expect(member.teamId).toBe(team.id);
-    expect(member.role).toBe('member');
-    expect(member.user?.email).toBe('new@example.com');
-  });
-
-  it('throws for an invalid role', async () => {
-    const { createTeam, inviteMember } = await import('../enterprise/teams');
-    const team = await createTeam({ name: 'Role Team', ownerId: 'owner-r' });
-    await expect(
-      inviteMember(team.id, { email: 'x@example.com', role: 'superadmin' })
-    ).rejects.toThrow();
-  });
-});
-
-describe('enterprise teams – listMembers', () => {
-  it('lists members including the team owner', async () => {
-    const { createTeam, listMembers } = await import('../enterprise/teams');
-    const team = await createTeam({ name: 'List Members Team', ownerId: 'owner-lm' });
-    const members = await listMembers(team.id);
-
-    expect(Array.isArray(members)).toBe(true);
-    expect(members.length).toBeGreaterThanOrEqual(1);
-    // Owner is automatically added as a member with role 'owner'
-    const ownerEntry = members.find(m => m.role === 'owner');
-    expect(ownerEntry).toBeDefined();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Billing
-// ---------------------------------------------------------------------------
-
-describe('enterprise billing – subscribe', () => {
-  it('creates a subscription and returns billing status', async () => {
-    const { createTeam } = await import('../enterprise/teams');
-    const { subscribe } = await import('../enterprise/billing');
-    // A subscription has a FK on team_id; create the team first.
-    const team = await createTeam({ name: 'Sub Team Pro', ownerId: 'owner-sub-001' });
-    const result = await subscribe({ teamId: team.id, plan: 'pro' });
-
-    expect(result).toBeDefined();
-    expect(result.billing.plan).toBe('pro');
-    expect(result.billing.status).toBe('active');
-    expect(result.stripe).toBeDefined();
-    expect(result.stripe.object).toBe('subscription');
-  });
-
-  it('throws for an invalid plan name', async () => {
-    const { subscribe } = await import('../enterprise/billing');
-    await expect(subscribe({ teamId: 'team-bad', plan: 'diamond' })).rejects.toThrow();
-  });
-
-  it('throws when teamId is empty', async () => {
-    const { subscribe } = await import('../enterprise/billing');
-    await expect(subscribe({ teamId: '', plan: 'pro' })).rejects.toThrow();
-  });
-});
-
-describe('enterprise billing – getBillingStatus', () => {
-  it('returns free plan defaults for a team with no subscription', async () => {
-    const { getBillingStatus } = await import('../enterprise/billing');
-    const status = await getBillingStatus('team-no-sub');
-
-    expect(status.plan).toBe('free');
-    expect(status.status).toBe('active');
-    expect(status.cancelAtPeriodEnd).toBe(false);
-  });
-
-  it('returns active status after subscribing', async () => {
-    const { createTeam } = await import('../enterprise/teams');
-    const { subscribe, getBillingStatus } = await import('../enterprise/billing');
-    // A subscription has a FK on team_id; create the team first.
-    const team = await createTeam({ name: 'Status Team', ownerId: 'owner-status' });
-    await subscribe({ teamId: team.id, plan: 'enterprise' });
-    const status = await getBillingStatus(team.id);
-
-    expect(status.plan).toBe('enterprise');
-    expect(status.status).toBe('active');
-  });
-});
-
-describe('enterprise billing – recordUsage', () => {
-  it('records a usage event and returns a confirmation receipt', async () => {
-    const { recordUsage } = await import('../enterprise/billing');
-    const result = await recordUsage({
-      teamId: 'team-usage',
-      operationType: 'generate',
-      tokensUsed: 1000,
-      costUsd: 0.003,
-    });
-
-    expect(result.recorded).toBe(true);
-    expect(typeof result.id).toBe('string');
-    expect(result.teamId).toBe('team-usage');
-    expect(result.operationType).toBe('generate');
-    expect(result.tokensUsed).toBe(1000);
-    expect(result.costUsd).toBe(0.003);
-    expect(typeof result.timestamp).toBe('string');
-  });
-
-  it('throws for negative tokensUsed', async () => {
-    const { recordUsage } = await import('../enterprise/billing');
-    await expect(
-      recordUsage({ teamId: 'team-bad', operationType: 'gen', tokensUsed: -1, costUsd: 0 })
-    ).rejects.toThrow();
-  });
-
-  it('throws for negative costUsd', async () => {
-    const { recordUsage } = await import('../enterprise/billing');
-    await expect(
-      recordUsage({ teamId: 'team-bad', operationType: 'gen', tokensUsed: 0, costUsd: -0.5 })
-    ).rejects.toThrow();
-  });
-});
-
-describe('enterprise billing – getUsage', () => {
-  it('returns an EnhancedUsageSummary with expected shape', async () => {
-    const { getUsage } = await import('../enterprise/billing');
-    const summary = await getUsage('team-get-usage', 'month');
-
-    expect(summary).toBeDefined();
-    expect(typeof summary.totals.operations).toBe('number');
-    expect(typeof summary.totals.tokensUsed).toBe('number');
-    expect(typeof summary.totals.costUsd).toBe('number');
-    expect(summary.quota).toBeDefined();
-    expect(summary.quota.plan).toBe('free'); // No subscription → free plan
-    expect(typeof summary.rateLimit.requestsPerMinute).toBe('number');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Audit
-// ---------------------------------------------------------------------------
-
-describe('enterprise audit – createLog', () => {
-  it('creates an audit log entry and returns an AuditLog', async () => {
-    const { createLog } = await import('../enterprise/audit');
-    const log = await createLog({
-      action: 'generate.terraform',
-      status: 'success',
-      userId: 'user-audit-001',
-      resourceType: 'terraform',
-      resourceId: 'vpc-module',
-    });
-
-    expect(typeof log.id).toBe('string');
-    expect(log.id.length).toBeGreaterThan(0);
-    expect(log.action).toBe('generate.terraform');
-    expect(log.status).toBe('success');
-    expect(log.userId).toBe('user-audit-001');
-    expect(log.resourceType).toBe('terraform');
-    expect(typeof log.timestamp).toBe('string');
-  });
-
-  it('throws when action is missing', async () => {
-    const { createLog } = await import('../enterprise/audit');
-    await expect(createLog({ action: '', status: 'success' })).rejects.toThrow();
-  });
-
-  it('throws when status is missing', async () => {
-    const { createLog } = await import('../enterprise/audit');
-    await expect(createLog({ action: 'do.thing', status: '' })).rejects.toThrow();
-  });
-
-  it('stores teamId and ipAddress in the returned log', async () => {
-    const { createLog } = await import('../enterprise/audit');
-    const log = await createLog({
-      action: 'login',
-      status: 'success',
-      teamId: 'team-audit',
-      ipAddress: '127.0.0.1',
-    });
-
-    expect(log.teamId).toBe('team-audit');
-    expect(log.ipAddress).toBe('127.0.0.1');
-  });
-});
-
-describe('enterprise audit – queryLogs', () => {
-  it('returns paginated results with total count', async () => {
-    const { createLog, queryLogs } = await import('../enterprise/audit');
-
-    await createLog({ action: 'action.a', status: 'success' });
-    await createLog({ action: 'action.b', status: 'failure' });
-
-    const result = await queryLogs({ limit: 10, offset: 0 });
-
-    expect(Array.isArray(result.logs)).toBe(true);
-    expect(typeof result.total).toBe('number');
-    expect(typeof result.limit).toBe('number');
-    expect(typeof result.offset).toBe('number');
-    expect(result.total).toBeGreaterThanOrEqual(2);
-  });
-
-  it('filters by action when action param is provided', async () => {
-    const { createLog, queryLogs } = await import('../enterprise/audit');
-
-    await createLog({ action: 'filtered.action', status: 'success' });
-    await createLog({ action: 'other.action', status: 'success' });
-
-    const result = await queryLogs({ action: 'filtered.action' });
-    expect(result.logs.every(l => l.action === 'filtered.action')).toBe(true);
-  });
-});
-
-describe('enterprise audit – exportLogs', () => {
-  it('exports logs as JSON string', async () => {
-    const { createLog, exportLogs } = await import('../enterprise/audit');
-    await createLog({ action: 'export.test', status: 'success' });
-
-    const json = await exportLogs('json', {});
-    expect(typeof json).toBe('string');
-    const parsed = JSON.parse(json);
-    expect(Array.isArray(parsed.logs)).toBe(true);
-    expect(typeof parsed.exportedAt).toBe('string');
-  });
-
-  it('exports logs as CSV string', async () => {
-    const { createLog, exportLogs } = await import('../enterprise/audit');
-    await createLog({ action: 'csv.test', status: 'success' });
-
-    const csv = await exportLogs('csv', {});
-    expect(typeof csv).toBe('string');
-    // CSV should contain the header row
-    expect(csv).toContain('id,timestamp');
-    expect(csv).toContain('action');
-  });
-});

package/src/__tests__/export.test.ts

@@ -1,236 +0,0 @@
-/**
- * Export Command Tests — G19
- *
- * Tests exportCommand for JSON, Markdown, HTML formats and
- * file-write / process.exit behaviors.
- *
- * The export command uses `await import('../sessions/manager')` dynamically,
- * so we use vi.mock at module scope (hoisted) and vi.doMock for the empty-
- * session scenario.
- *
- * writeFileSync is tested by spying on the module-level import inside the
- * command via a top-level vi.mock on 'node:fs'.
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-// ---------------------------------------------------------------------------
-// Shared mock data
-// ---------------------------------------------------------------------------
-
-const MOCK_SESSION = {
-  id: 'session-abc-123',
-  name: 'Test Session',
-  model: 'claude-3-5-sonnet',
-  mode: 'build',
-  createdAt: '2026-01-01T00:00:00.000Z',
-  updatedAt: '2026-01-01T00:00:00.000Z',
-  status: 'active',
-  cwd: '/tmp',
-  tokenCount: 100,
-  costUSD: 0.01,
-  snapshotCount: 0,
-};
-
-const MOCK_MESSAGES = [
-  { role: 'user', content: 'Hello agent' },
-  { role: 'assistant', content: 'Hello! How can I help?' },
-];
-
-// ---------------------------------------------------------------------------
-// Top-level mocks (hoisted by vitest)
-// ---------------------------------------------------------------------------
-
-// Mock sessions/manager with a factory function so the mock survives
-// dynamic import() calls inside exportCommand.
-vi.mock('../sessions/manager', () => {
-  const listFn = vi.fn(() => [MOCK_SESSION]);
-  const loadConversationFn = vi.fn(() => MOCK_MESSAGES);
-  return {
-    SessionManager: {
-      getInstance: vi.fn(() => ({
-        list: listFn,
-        loadConversation: loadConversationFn,
-      })),
-      resetInstance: vi.fn(),
-    },
-  };
-});
-
-// Track writeFileSync calls via a hoisted mock on node:fs
-// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-let writeFileSyncMock: ReturnType<typeof vi.fn> = vi.fn();
-
-vi.mock('node:fs', async () => {
-  const actual = await vi.importActual<typeof import('node:fs')>('node:fs');
-  return {
-    ...actual,
-    // Delegate to the mutable reference so we can swap it per-test
-    writeFileSync: (path: string, data: string, enc: string) => writeFileSyncMock(path, data, enc),
-  };
-});
-
-// ---------------------------------------------------------------------------
-// Import the command (uses hoisted mocks above)
-// ---------------------------------------------------------------------------
-
-import { exportCommand } from '../commands/export';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function captureStdout(): { chunks: string[]; restore: () => void } {
-  const chunks: string[] = [];
-  const spy = vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => {
-    chunks.push(typeof chunk === 'string' ? chunk : chunk.toString());
-    return true;
-  });
-  return { chunks, restore: () => spy.mockRestore() };
-}
-
-// ---------------------------------------------------------------------------
-// JSON format
-// ---------------------------------------------------------------------------
-
-describe('exportCommand JSON format (G19)', () => {
-  it('writes valid JSON with session and messages fields', async () => {
-    const { chunks, restore } = captureStdout();
-    try {
-      await exportCommand({ format: 'json' });
-    } finally {
-      restore();
-    }
-
-    const output = chunks.join('');
-    expect(() => JSON.parse(output)).not.toThrow();
-    const parsed = JSON.parse(output) as { session: { id: string }; messages: unknown[] };
-    expect(parsed.session.id).toBe('session-abc-123');
-    expect(Array.isArray(parsed.messages)).toBe(true);
-    expect(parsed.messages).toHaveLength(2);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Markdown format
-// ---------------------------------------------------------------------------
-
-describe('exportCommand Markdown format (G19)', () => {
-  it('returns markdown with session metadata table', async () => {
-    const { chunks, restore } = captureStdout();
-    try {
-      await exportCommand({ format: 'md' });
-    } finally {
-      restore();
-    }
-
-    const output = chunks.join('');
-    expect(output).toContain('# Nimbus Session Export');
-    expect(output).toContain('session-abc-123');
-    expect(output).toContain('## Conversation');
-  });
-
-  it('default format is markdown when not specified', async () => {
-    const { chunks, restore } = captureStdout();
-    try {
-      await exportCommand({});
-    } finally {
-      restore();
-    }
-
-    const output = chunks.join('');
-    expect(output).toContain('# Nimbus Session Export');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// HTML format
-// ---------------------------------------------------------------------------
-
-describe('exportCommand HTML format (G19)', () => {
-  it('returns HTML output with DOCTYPE and html tag', async () => {
-    const { chunks, restore } = captureStdout();
-    try {
-      await exportCommand({ format: 'html' });
-    } finally {
-      restore();
-    }
-
-    const output = chunks.join('');
-    expect(output).toContain('<!DOCTYPE html>');
-    expect(output).toContain('<html>');
-    expect(output).toContain('Nimbus Session');
-  });
-
-  it('HTML output contains session name', async () => {
-    const { chunks, restore } = captureStdout();
-    try {
-      await exportCommand({ format: 'html' });
-    } finally {
-      restore();
-    }
-
-    const output = chunks.join('');
-    expect(output).toContain('Test Session');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// File output
-// ---------------------------------------------------------------------------
-
-describe('exportCommand file output (G19)', () => {
-  beforeEach(() => {
-    // Reset to a fresh spy each test
-    writeFileSyncMock = vi.fn();
-  });
-
-  it('calls writeFileSync when --output path is specified', async () => {
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    try {
-      await exportCommand({ format: 'md', output: '/tmp/test-export.md' });
-    } finally {
-      logSpy.mockRestore();
-    }
-
-    expect(writeFileSyncMock).toHaveBeenCalledOnce();
-    const [filePath, content] = writeFileSyncMock.mock.calls[0] as [string, string, string];
-    expect(filePath).toBe('/tmp/test-export.md');
-    expect(content).toContain('Nimbus Session Export');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// No session — process.exit(1)
-// ---------------------------------------------------------------------------
-
-describe('exportCommand no session (G19)', () => {
-  it('calls process.exit(1) when no sessions exist', async () => {
-    vi.resetModules();
-
-    vi.doMock('../sessions/manager', () => ({
-      SessionManager: {
-        getInstance: vi.fn(() => ({
-          list: vi.fn(() => []),
-          loadConversation: vi.fn(() => []),
-        })),
-        resetInstance: vi.fn(),
-      },
-    }));
-
-    const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {
-      throw new Error('process.exit called');
-    }) as never);
-
-    try {
-      const { exportCommand: exportCmd } = await import('../commands/export');
-      await expect(exportCmd({})).rejects.toThrow('process.exit');
-      expect(exitSpy).toHaveBeenCalledWith(1);
-    } finally {
-      errSpy.mockRestore();
-      exitSpy.mockRestore();
-      vi.resetModules();
-    }
-  });
-});