ultraclaude-agent 0.0.13 → 0.0.15

package/__tests__/config-multi-account.test.ts

@@ -0,0 +1,413 @@
+/**
+ * Tests for Task 1 multi-account credential storage functions.
+ * Covers: loadAllCredentials, saveAccountCredentials, saveCredentials,
+ *         migrateCredentialsToAccounts, loadServerConfig/saveServerConfig,
+ *         getDefaultAccount/setDefaultAccount, getProjectAccount/setProjectAccount.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { join } from 'node:path';
+import { mkdtemp, writeFile, mkdir, rm, readFile, readdir } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+
+// Mock node:os for homedir/platform control
+const mockPlatform = vi.fn().mockReturnValue('linux');
+const mockHomedir = vi.fn().mockReturnValue('/home/testuser');
+
+vi.mock('node:os', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:os')>();
+  return {
+    ...actual,
+    homedir: () => mockHomedir(),
+    platform: () => mockPlatform(),
+  };
+});
+
+describe('config — loadAllCredentials', () => {
+  let tempHome: string;
+
+  beforeEach(async () => {
+    vi.resetModules();
+    mockPlatform.mockReturnValue('linux');
+    tempHome = await mkdtemp(join(tmpdir(), 'multi-acct-load-test-'));
+    mockHomedir.mockReturnValue(tempHome);
+  });
+
+  afterEach(async () => {
+    await rm(tempHome, { recursive: true, force: true });
+  });
+
+  it('returns empty Map when no accounts directory exists', async () => {
+    const { loadAllCredentials } = await import('../src/config.js');
+    const result = await loadAllCredentials('https://dashboard.ultra-claude.dev');
+    expect(result).toBeInstanceOf(Map);
+    expect(result.size).toBe(0);
+  });
+
+  it('returns Map of userId → credentials for each account file', async () => {
+    const { loadAllCredentials } = await import('../src/config.js');
+
+    const serverKey = 'dashboard.ultra-claude.dev';
+    const accountsDir = join(tempHome, '.claude', 'ultra', 'agent', serverKey, 'accounts');
+    await mkdir(accountsDir, { recursive: true });
+
+    const creds1 = { apiKey: 'key-1', userId: 'user-1', serverUrl: 'https://dashboard.ultra-claude.dev', email: 'alice@example.com' };
+    const creds2 = { apiKey: 'key-2', userId: 'user-2', serverUrl: 'https://dashboard.ultra-claude.dev', email: 'bob@example.com' };
+
+    await writeFile(join(accountsDir, 'user-1.json'), JSON.stringify(creds1));
+    await writeFile(join(accountsDir, 'user-2.json'), JSON.stringify(creds2));
+
+    const result = await loadAllCredentials('https://dashboard.ultra-claude.dev');
+
+    expect(result.size).toBe(2);
+    expect(result.get('user-1')).toEqual(creds1);
+    expect(result.get('user-2')).toEqual(creds2);
+  });
+
+  it('ignores non-JSON files in accounts directory', async () => {
+    const { loadAllCredentials } = await import('../src/config.js');
+
+    const serverKey = 'dashboard.ultra-claude.dev';
+    const accountsDir = join(tempHome, '.claude', 'ultra', 'agent', serverKey, 'accounts');
+    await mkdir(accountsDir, { recursive: true });
+
+    const creds = { apiKey: 'key-1', userId: 'user-1', serverUrl: 'https://dashboard.ultra-claude.dev' };
+    await writeFile(join(accountsDir, 'user-1.json'), JSON.stringify(creds));
+    await writeFile(join(accountsDir, 'README.txt'), 'not a json file');
+    await writeFile(join(accountsDir, '.DS_Store'), 'binary data');
+
+    const result = await loadAllCredentials('https://dashboard.ultra-claude.dev');
+    expect(result.size).toBe(1);
+    expect(result.has('user-1')).toBe(true);
+  });
+
+  it('runs migration from credentials.json on first call', async () => {
+    const { loadAllCredentials } = await import('../src/config.js');
+
+    // Set up old credentials.json
+    const serverKey = 'dashboard.ultra-claude.dev';
+    const configDir = join(tempHome, '.claude', 'ultra', 'agent', serverKey);
+    await mkdir(configDir, { recursive: true });
+
+    const oldCreds = { apiKey: 'old-key', userId: 'migrated-user', serverUrl: 'https://dashboard.ultra-claude.dev' };
+    await writeFile(join(configDir, 'credentials.json'), JSON.stringify(oldCreds));
+
+    const result = await loadAllCredentials('https://dashboard.ultra-claude.dev');
+
+    // Should have migrated the old credentials
+    expect(result.size).toBe(1);
+    expect(result.get('migrated-user')).toMatchObject({ apiKey: 'old-key', userId: 'migrated-user' });
+
+    // Old credentials.json should have been renamed to .bak
+    const backupExists = await readFile(join(configDir, 'credentials.json.bak'), 'utf8').catch(() => null);
+    expect(backupExists).not.toBeNull();
+
+    // New account file should exist
+    const accountFile = await readFile(join(configDir, 'accounts', 'migrated-user.json'), 'utf8').catch(() => null);
+    expect(accountFile).not.toBeNull();
+    const parsed = JSON.parse(accountFile!);
+    expect(parsed.userId).toBe('migrated-user');
+  });
+});
+
+describe('config — saveAccountCredentials (saveCredentials)', () => {
+  let tempHome: string;
+
+  beforeEach(async () => {
+    vi.resetModules();
+    mockPlatform.mockReturnValue('linux');
+    tempHome = await mkdtemp(join(tmpdir(), 'multi-acct-save-test-'));
+    mockHomedir.mockReturnValue(tempHome);
+  });
+
+  afterEach(async () => {
+    await rm(tempHome, { recursive: true, force: true });
+  });
+
+  it('stores credentials to accounts/{userId}.json', async () => {
+    const { saveAccountCredentials } = await import('../src/config.js');
+
+    const creds = { apiKey: 'my-key', userId: 'alice', serverUrl: 'https://dashboard.ultra-claude.dev', email: 'alice@example.com' };
+    await saveAccountCredentials(creds);
+
+    const expectedPath = join(tempHome, '.claude', 'ultra', 'agent', 'dashboard.ultra-claude.dev', 'accounts', 'alice.json');
+    const saved = JSON.parse(await readFile(expectedPath, 'utf8'));
+    expect(saved).toEqual(creds);
+  });
+
+  it('does not overwrite other accounts when saving', async () => {
+    const { saveAccountCredentials } = await import('../src/config.js');
+
+    const creds1 = { apiKey: 'key-1', userId: 'alice', serverUrl: 'https://dashboard.ultra-claude.dev' };
+    const creds2 = { apiKey: 'key-2', userId: 'bob', serverUrl: 'https://dashboard.ultra-claude.dev' };
+
+    await saveAccountCredentials(creds1);
+    await saveAccountCredentials(creds2);
+
+    const accountsDir = join(tempHome, '.claude', 'ultra', 'agent', 'dashboard.ultra-claude.dev', 'accounts');
+    const files = await readdir(accountsDir);
+    expect(files).toContain('alice.json');
+    expect(files).toContain('bob.json');
+    expect(files).toHaveLength(2);
+
+    const aliceSaved = JSON.parse(await readFile(join(accountsDir, 'alice.json'), 'utf8'));
+    expect(aliceSaved.apiKey).toBe('key-1');
+
+    const bobSaved = JSON.parse(await readFile(join(accountsDir, 'bob.json'), 'utf8'));
+    expect(bobSaved.apiKey).toBe('key-2');
+  });
+
+  it('saveCredentials (deprecated wrapper) stores to accounts/{userId}.json', async () => {
+    const { saveCredentials } = await import('../src/config.js');
+
+    const creds = { apiKey: 'legacy-key', userId: 'legacy-user', serverUrl: 'https://dashboard.ultra-claude.dev' };
+    await saveCredentials(creds);
+
+    const expectedPath = join(tempHome, '.claude', 'ultra', 'agent', 'dashboard.ultra-claude.dev', 'accounts', 'legacy-user.json');
+    const saved = JSON.parse(await readFile(expectedPath, 'utf8'));
+    expect(saved.apiKey).toBe('legacy-key');
+    expect(saved.userId).toBe('legacy-user');
+  });
+
+  it('saving same user twice updates the existing account file', async () => {
+    const { saveAccountCredentials } = await import('../src/config.js');
+
+    const creds1 = { apiKey: 'old-key', userId: 'alice', serverUrl: 'https://dashboard.ultra-claude.dev' };
+    const creds2 = { apiKey: 'new-key', userId: 'alice', serverUrl: 'https://dashboard.ultra-claude.dev' };
+
+    await saveAccountCredentials(creds1);
+    await saveAccountCredentials(creds2);
+
+    const accountsDir = join(tempHome, '.claude', 'ultra', 'agent', 'dashboard.ultra-claude.dev', 'accounts');
+    const files = await readdir(accountsDir);
+    expect(files).toHaveLength(1); // Still one file, not two
+
+    const saved = JSON.parse(await readFile(join(accountsDir, 'alice.json'), 'utf8'));
+    expect(saved.apiKey).toBe('new-key'); // Updated
+  });
+});
+
+describe('config — migrateCredentialsToAccounts', () => {
+  let tempHome: string;
+
+  beforeEach(async () => {
+    vi.resetModules();
+    mockPlatform.mockReturnValue('linux');
+    tempHome = await mkdtemp(join(tmpdir(), 'multi-acct-migrate-test-'));
+    mockHomedir.mockReturnValue(tempHome);
+  });
+
+  afterEach(async () => {
+    await rm(tempHome, { recursive: true, force: true });
+  });
+
+  it('migrates credentials.json to accounts/{userId}.json', async () => {
+    const { migrateCredentialsToAccounts } = await import('../src/config.js');
+
+    const serverKey = 'dashboard.ultra-claude.dev';
+    const configDir = join(tempHome, '.claude', 'ultra', 'agent', serverKey);
+    await mkdir(configDir, { recursive: true });
+
+    const oldCreds = { apiKey: 'old-key', userId: 'user-123', serverUrl: 'https://dashboard.ultra-claude.dev', email: 'user@example.com' };
+    await writeFile(join(configDir, 'credentials.json'), JSON.stringify(oldCreds));
+
+    const migrated = await migrateCredentialsToAccounts('https://dashboard.ultra-claude.dev');
+    expect(migrated).toBe(true);
+
+    // Check account file was created
+    const accountFile = join(configDir, 'accounts', 'user-123.json');
+    const saved = JSON.parse(await readFile(accountFile, 'utf8'));
+    expect(saved).toEqual(oldCreds);
+
+    // Check old file was backed up
+    const backupContent = await readFile(join(configDir, 'credentials.json.bak'), 'utf8');
+    expect(JSON.parse(backupContent)).toEqual(oldCreds);
+  });
+
+  it('creates config.json with defaultAccount set to migrated userId', async () => {
+    const { migrateCredentialsToAccounts } = await import('../src/config.js');
+
+    const serverKey = 'dashboard.ultra-claude.dev';
+    const configDir = join(tempHome, '.claude', 'ultra', 'agent', serverKey);
+    await mkdir(configDir, { recursive: true });
+
+    const oldCreds = { apiKey: 'key', userId: 'the-user', serverUrl: 'https://dashboard.ultra-claude.dev' };
+    await writeFile(join(configDir, 'credentials.json'), JSON.stringify(oldCreds));
+
+    await migrateCredentialsToAccounts('https://dashboard.ultra-claude.dev');
+
+    const configContent = JSON.parse(await readFile(join(configDir, 'config.json'), 'utf8'));
+    expect(configContent.defaultAccount).toBe('the-user');
+    expect(configContent.projectAccounts).toEqual({});
+  });
+
+  it('returns false when credentials.json does not exist', async () => {
+    const { migrateCredentialsToAccounts } = await import('../src/config.js');
+    const migrated = await migrateCredentialsToAccounts('https://dashboard.ultra-claude.dev');
+    expect(migrated).toBe(false);
+  });
+
+  it('returns false when accounts/ already has JSON files (already migrated)', async () => {
+    const { migrateCredentialsToAccounts } = await import('../src/config.js');
+
+    const serverKey = 'dashboard.ultra-claude.dev';
+    const configDir = join(tempHome, '.claude', 'ultra', 'agent', serverKey);
+    const accountsDir = join(configDir, 'accounts');
+    await mkdir(accountsDir, { recursive: true });
+
+    // Both credentials.json AND accounts/ exist (already migrated)
+    const creds = { apiKey: 'key', userId: 'user', serverUrl: 'https://dashboard.ultra-claude.dev' };
+    await writeFile(join(configDir, 'credentials.json'), JSON.stringify(creds));
+    await writeFile(join(accountsDir, 'user.json'), JSON.stringify(creds));
+
+    const migrated = await migrateCredentialsToAccounts('https://dashboard.ultra-claude.dev');
+    expect(migrated).toBe(false);
+  });
+});
+
+describe('config — loadServerConfig / saveServerConfig', () => {
+  let tempHome: string;
+
+  beforeEach(async () => {
+    vi.resetModules();
+    mockPlatform.mockReturnValue('linux');
+    tempHome = await mkdtemp(join(tmpdir(), 'multi-acct-config-test-'));
+    mockHomedir.mockReturnValue(tempHome);
+  });
+
+  afterEach(async () => {
+    await rm(tempHome, { recursive: true, force: true });
+  });
+
+  it('returns default empty config when config.json does not exist', async () => {
+    const { loadServerConfig } = await import('../src/config.js');
+    const config = await loadServerConfig('https://dashboard.ultra-claude.dev');
+    expect(config.defaultAccount).toBe('');
+    expect(config.projectAccounts).toEqual({});
+  });
+
+  it('saves and loads config.json atomically', async () => {
+    const { loadServerConfig, saveServerConfig } = await import('../src/config.js');
+
+    const config = { defaultAccount: 'user-abc', projectAccounts: { '/home/user/project': 'user-abc' } };
+    await saveServerConfig('https://dashboard.ultra-claude.dev', config);
+
+    const loaded = await loadServerConfig('https://dashboard.ultra-claude.dev');
+    expect(loaded.defaultAccount).toBe('user-abc');
+    expect(loaded.projectAccounts['/home/user/project']).toBe('user-abc');
+  });
+});
+
+describe('config — getDefaultAccount / setDefaultAccount', () => {
+  let tempHome: string;
+
+  beforeEach(async () => {
+    vi.resetModules();
+    mockPlatform.mockReturnValue('linux');
+    tempHome = await mkdtemp(join(tmpdir(), 'multi-acct-default-test-'));
+    mockHomedir.mockReturnValue(tempHome);
+  });
+
+  afterEach(async () => {
+    await rm(tempHome, { recursive: true, force: true });
+  });
+
+  it('returns null when no default account is set', async () => {
+    const { getDefaultAccount } = await import('../src/config.js');
+    const result = await getDefaultAccount('https://dashboard.ultra-claude.dev');
+    expect(result).toBeNull();
+  });
+
+  it('sets and gets the default account', async () => {
+    const { getDefaultAccount, setDefaultAccount } = await import('../src/config.js');
+
+    await setDefaultAccount('https://dashboard.ultra-claude.dev', 'user-xyz');
+    const result = await getDefaultAccount('https://dashboard.ultra-claude.dev');
+    expect(result).toBe('user-xyz');
+  });
+
+  it('updating default does not lose projectAccounts', async () => {
+    const { setDefaultAccount, setProjectAccount, loadServerConfig } = await import('../src/config.js');
+
+    await setProjectAccount('https://dashboard.ultra-claude.dev', '/home/user/proj', 'original-user');
+    await setDefaultAccount('https://dashboard.ultra-claude.dev', 'new-default');
+
+    const config = await loadServerConfig('https://dashboard.ultra-claude.dev');
+    expect(config.defaultAccount).toBe('new-default');
+    expect(config.projectAccounts['/home/user/proj']).toBe('original-user');
+  });
+});
+
+describe('config — getProjectAccount / setProjectAccount', () => {
+  let tempHome: string;
+
+  beforeEach(async () => {
+    vi.resetModules();
+    mockPlatform.mockReturnValue('linux');
+    tempHome = await mkdtemp(join(tmpdir(), 'multi-acct-project-test-'));
+    mockHomedir.mockReturnValue(tempHome);
+  });
+
+  afterEach(async () => {
+    await rm(tempHome, { recursive: true, force: true });
+  });
+
+  it('returns null when no mapping exists for a project', async () => {
+    const { getProjectAccount } = await import('../src/config.js');
+    const result = await getProjectAccount('https://dashboard.ultra-claude.dev', '/home/user/project');
+    expect(result).toBeNull();
+  });
+
+  it('sets and gets a project-to-account mapping', async () => {
+    const { getProjectAccount, setProjectAccount } = await import('../src/config.js');
+
+    await setProjectAccount('https://dashboard.ultra-claude.dev', '/home/user/project', 'user-abc');
+    const result = await getProjectAccount('https://dashboard.ultra-claude.dev', '/home/user/project');
+    expect(result).toBe('user-abc');
+  });
+
+  it('setting one project does not affect another project mapping', async () => {
+    const { getProjectAccount, setProjectAccount } = await import('../src/config.js');
+
+    await setProjectAccount('https://dashboard.ultra-claude.dev', '/home/user/project-a', 'user-1');
+    await setProjectAccount('https://dashboard.ultra-claude.dev', '/home/user/project-b', 'user-2');
+
+    expect(await getProjectAccount('https://dashboard.ultra-claude.dev', '/home/user/project-a')).toBe('user-1');
+    expect(await getProjectAccount('https://dashboard.ultra-claude.dev', '/home/user/project-b')).toBe('user-2');
+  });
+});
+
+describe('config — login creates two account files for two different users', () => {
+  /**
+   * Verifies that calling saveAccountCredentials twice with different userId values
+   * results in two separate files, not one overwriting the other.
+   * This simulates the login() flow being called twice with different Clerk users.
+   */
+  let tempHome: string;
+
+  beforeEach(async () => {
+    vi.resetModules();
+    mockPlatform.mockReturnValue('linux');
+    tempHome = await mkdtemp(join(tmpdir(), 'multi-acct-dual-login-test-'));
+    mockHomedir.mockReturnValue(tempHome);
+  });
+
+  afterEach(async () => {
+    await rm(tempHome, { recursive: true, force: true });
+  });
+
+  it('two saveAccountCredentials calls with different users → two separate account files', async () => {
+    const { saveAccountCredentials, loadAllCredentials } = await import('../src/config.js');
+
+    const user1Creds = { apiKey: 'key-user1', userId: 'clerk-user-1', serverUrl: 'https://dashboard.ultra-claude.dev', email: 'user1@org.com' };
+    const user2Creds = { apiKey: 'key-user2', userId: 'clerk-user-2', serverUrl: 'https://dashboard.ultra-claude.dev', email: 'user2@org.com' };
+
+    await saveAccountCredentials(user1Creds);
+    await saveAccountCredentials(user2Creds);
+
+    const allCreds = await loadAllCredentials('https://dashboard.ultra-claude.dev');
+    expect(allCreds.size).toBe(2);
+    expect(allCreds.get('clerk-user-1')).toMatchObject({ email: 'user1@org.com' });
+    expect(allCreds.get('clerk-user-2')).toMatchObject({ email: 'user2@org.com' });
+  });
+});