ultraclaude-agent 0.0.20 → 0.0.21

package/__tests__/claude-profiles-ops.test.ts

@@ -0,0 +1,441 @@
+/**
+ * Tests for high-level claude-profiles operations:
+ *   switchProfile, loginProfile, deleteProfileByName, saveCurrentAsProfile
+ *
+ * These cover success criteria that are NOT tested in claude-profiles.test.ts:
+ * - claude switch <name>: atomic write, active.json update, auth status verify
+ * - claude switch with expired token: refreshes and saves updated credentials
+ * - claude login <name> --email: pre-populates from existing profile when present
+ * - claude delete <name>: warns and clears active.json when deleting active profile
+ * - claude save <name>: saves current credentials + auth status metadata
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { join } from 'node:path';
+
+// Mock node:os for consistent homedir
+vi.mock('node:os', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('node:os')>();
+  return {
+    ...actual,
+    homedir: () => '/home/testuser',
+  };
+});
+
+// Mock fs/promises
+const mockReadFile = vi.fn();
+const mockWriteFile = vi.fn().mockResolvedValue(undefined);
+const mockRename = vi.fn().mockResolvedValue(undefined);
+const mockMkdir = vi.fn().mockResolvedValue(undefined);
+const mockUnlink = vi.fn().mockResolvedValue(undefined);
+const mockReaddir = vi.fn();
+const mockStat = vi.fn();
+
+vi.mock('node:fs/promises', () => ({
+  readFile: (...args: unknown[]) => mockReadFile(...args),
+  writeFile: (...args: unknown[]) => mockWriteFile(...args),
+  rename: (...args: unknown[]) => mockRename(...args),
+  mkdir: (...args: unknown[]) => mockMkdir(...args),
+  unlink: (...args: unknown[]) => mockUnlink(...args),
+  readdir: (...args: unknown[]) => mockReaddir(...args),
+  stat: (...args: unknown[]) => mockStat(...args),
+}));
+
+// Mock logger
+vi.mock('../src/logger.js', () => ({
+  logger: {
+    child: () => ({
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      debug: vi.fn(),
+    }),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn(),
+  },
+}));
+
+// Spawn mock infrastructure
+const mockExecFileSync = vi.fn();
+const mockSpawn = vi.fn();
+
+vi.mock('node:child_process', () => ({
+  execFileSync: (...args: unknown[]) => mockExecFileSync(...args),
+  spawn: (...args: unknown[]) => mockSpawn(...args),
+}));
+
+type Handler = (...args: unknown[]) => void;
+
+function createMockChild(output: string, exitCode = 0) {
+  const stdoutHandlers: Record<string, Handler[]> = {};
+  const childHandlers: Record<string, Handler[]> = {};
+
+  const mockStdout = {
+    on(event: string, handler: Handler) {
+      (stdoutHandlers[event] ??= []).push(handler);
+      return mockStdout;
+    },
+  };
+  const mockStderr = {
+    on(_event: string, _handler: Handler) { return mockStderr; },
+  };
+
+  const child = {
+    stdout: mockStdout,
+    stderr: mockStderr,
+    kill: vi.fn(),
+    on(event: string, handler: Handler) {
+      (childHandlers[event] ??= []).push(handler);
+      if (event === 'close') {
+        setTimeout(() => {
+          for (const h of stdoutHandlers['data'] ?? []) h(Buffer.from(output));
+          for (const h of childHandlers['close'] ?? []) h(exitCode);
+        }, 0);
+      }
+      return child;
+    },
+  };
+
+  return child;
+}
+
+const PROFILES_DIR = '/home/testuser/.claude/ultra/claude-profiles';
+const CREDENTIALS_FILE = '/home/testuser/.claude/.credentials.json';
+const ACTIVE_FILE = join(PROFILES_DIR, 'active.json');
+
+const sampleCredentials = {
+  claudeAiOauth: {
+    accessToken: 'sk-ant-oat01-test',
+    refreshToken: 'sk-ant-ort01-test',
+    expiresAt: Date.now() + 3600_000,
+    scopes: ['user:profile', 'user:inference'],
+    subscriptionType: 'team',
+    rateLimitTier: 'default_claude_max_5x',
+  },
+};
+
+const sampleProfile = {
+  name: 'work',
+  email: 'user@work.com',
+  orgName: 'WorkOrg',
+  subscriptionType: 'team',
+  savedAt: '2026-04-11T18:05:36Z',
+  credentials: sampleCredentials,
+};
+
+const authStatusOutput = JSON.stringify({
+  email: 'user@work.com',
+  orgName: 'WorkOrg',
+  subscriptionType: 'team',
+  loggedIn: true,
+});
+
+describe('switchProfile', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+    mockExecFileSync.mockReturnValue('/usr/bin/claude');
+    // Reset self-trigger flag
+  });
+
+  it('returns error when profile does not exist', async () => {
+    // Profile not found
+    mockReadFile.mockRejectedValue(Object.assign(new Error('ENOENT'), { code: 'ENOENT' }));
+
+    const { switchProfile, clearSelfTriggerFlag } = await import('../src/claude-profiles.js');
+    clearSelfTriggerFlag();
+
+    const result = await switchProfile('nonexistent');
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('"nonexistent" not found');
+  });
+
+  it('atomically writes credentials, updates active.json, and verifies via auth status', async () => {
+    // Profile load → work.json
+    // Then readCredentialsFile (freshCredentials) → sampleCredentials
+    // Then active file write
+    let readCallIdx = 0;
+    mockReadFile.mockImplementation(() => {
+      readCallIdx++;
+      if (readCallIdx === 1) {
+        // loadProfile('work')
+        return Promise.resolve(JSON.stringify(sampleProfile));
+      }
+      // readCredentialsFile() after auth status
+      return Promise.resolve(JSON.stringify(sampleCredentials));
+    });
+
+    mockSpawn.mockReturnValue(createMockChild(authStatusOutput, 0));
+
+    const { switchProfile, clearSelfTriggerFlag } = await import('../src/claude-profiles.js');
+    clearSelfTriggerFlag();
+
+    const result = await switchProfile('work');
+    expect(result.success).toBe(true);
+    expect(result.message).toContain('Switched to "work"');
+    expect(result.message).toContain('user@work.com');
+
+    // Should have written credentials file atomically (temp + rename)
+    const writeCallsToCredentials = mockWriteFile.mock.calls.filter(
+      (c) => (c[0] as string).startsWith(CREDENTIALS_FILE),
+    );
+    expect(writeCallsToCredentials.length).toBeGreaterThan(0);
+
+    // Atomic rename of credentials
+    const renameToCredentials = mockRename.mock.calls.filter(
+      (c) => (c[1] as string) === CREDENTIALS_FILE,
+    );
+    expect(renameToCredentials.length).toBeGreaterThan(0);
+
+    // Should have updated active.json
+    const writeCallsToActive = mockWriteFile.mock.calls.filter(
+      (c) => (c[0] as string).startsWith(ACTIVE_FILE),
+    );
+    expect(writeCallsToActive.length).toBeGreaterThan(0);
+  });
+
+  it('sets self-trigger flag before writing credentials', async () => {
+    mockReadFile.mockResolvedValue(JSON.stringify(sampleProfile));
+    mockSpawn.mockReturnValue(createMockChild(authStatusOutput, 0));
+
+    const { switchProfile, isSelfTriggered, clearSelfTriggerFlag } = await import('../src/claude-profiles.js');
+    clearSelfTriggerFlag();
+
+    // Spy on writeFile to check flag state at write time
+    let flagStateAtWrite = false;
+    mockWriteFile.mockImplementationOnce((..._args: unknown[]) => {
+      flagStateAtWrite = isSelfTriggered();
+      return Promise.resolve();
+    });
+
+    await switchProfile('work');
+    expect(flagStateAtWrite).toBe(true);
+  });
+
+  it('updates saved profile with refreshed credentials from auth status', async () => {
+    const refreshedCredentials = {
+      claudeAiOauth: {
+        ...sampleCredentials.claudeAiOauth,
+        accessToken: 'sk-ant-refreshed-token',
+        expiresAt: Date.now() + 7200_000, // new expiry
+      },
+    };
+
+    let readCallIdx = 0;
+    mockReadFile.mockImplementation(() => {
+      readCallIdx++;
+      if (readCallIdx === 1) return Promise.resolve(JSON.stringify(sampleProfile));
+      // After auth status runs, credentials file has refreshed tokens
+      return Promise.resolve(JSON.stringify(refreshedCredentials));
+    });
+
+    mockSpawn.mockReturnValue(createMockChild(authStatusOutput, 0));
+
+    const { switchProfile, clearSelfTriggerFlag } = await import('../src/claude-profiles.js');
+    clearSelfTriggerFlag();
+
+    const result = await switchProfile('work');
+    expect(result.success).toBe(true);
+
+    // The profile should be saved with the refreshed credentials
+    const savedProfileCall = mockWriteFile.mock.calls.find((c) => {
+      try {
+        const content = JSON.parse(c[1] as string);
+        return content.credentials?.claudeAiOauth?.accessToken === 'sk-ant-refreshed-token';
+      } catch {
+        return false;
+      }
+    });
+    expect(savedProfileCall).toBeDefined();
+  });
+});
+
+describe('deleteProfileByName', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+    mockExecFileSync.mockReturnValue('/usr/bin/claude');
+  });
+
+  it('returns error when profile does not exist', async () => {
+    mockReadFile.mockRejectedValue(Object.assign(new Error('ENOENT'), { code: 'ENOENT' }));
+
+    const { deleteProfileByName } = await import('../src/claude-profiles.js');
+    const result = await deleteProfileByName('nonexistent');
+    expect(result.success).toBe(false);
+    expect(result.wasActive).toBe(false);
+  });
+
+  it('deletes profile file and returns wasActive=false when not active', async () => {
+    let readCallIdx = 0;
+    mockReadFile.mockImplementation(() => {
+      readCallIdx++;
+      if (readCallIdx === 1) return Promise.resolve(JSON.stringify(sampleProfile)); // loadProfile
+      // loadActiveProfile → different profile active
+      return Promise.resolve(JSON.stringify({ profile: 'personal', switchedAt: '2026-04-11T18:00:00Z' }));
+    });
+
+    const { deleteProfileByName } = await import('../src/claude-profiles.js');
+    const result = await deleteProfileByName('work');
+
+    expect(result.success).toBe(true);
+    expect(result.wasActive).toBe(false);
+    expect(result.message).toBe('Deleted profile "work"');
+
+    // Should delete the profile file
+    expect(mockUnlink).toHaveBeenCalledWith(join(PROFILES_DIR, 'work.json'));
+    // Should NOT delete active.json
+    expect(mockUnlink).not.toHaveBeenCalledWith(ACTIVE_FILE);
+  });
+
+  it('clears active.json and warns when deleting active profile', async () => {
+    let readCallIdx = 0;
+    mockReadFile.mockImplementation(() => {
+      readCallIdx++;
+      if (readCallIdx === 1) return Promise.resolve(JSON.stringify(sampleProfile)); // loadProfile
+      // loadActiveProfile → work is active
+      return Promise.resolve(JSON.stringify({ profile: 'work', switchedAt: '2026-04-11T18:00:00Z' }));
+    });
+
+    const { deleteProfileByName } = await import('../src/claude-profiles.js');
+    const result = await deleteProfileByName('work');
+
+    expect(result.success).toBe(true);
+    expect(result.wasActive).toBe(true);
+    expect(result.message).toContain('was active');
+
+    // Should delete profile file AND active.json
+    expect(mockUnlink).toHaveBeenCalledWith(join(PROFILES_DIR, 'work.json'));
+    expect(mockUnlink).toHaveBeenCalledWith(ACTIVE_FILE);
+  });
+});
+
+describe('loginProfile', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+    mockExecFileSync.mockReturnValue('/usr/bin/claude');
+  });
+
+  it('pre-populates --email from existing profile when profile already exists', async () => {
+    const existingProfile = { ...sampleProfile, email: 'user@work.com' };
+
+    // loginProfile read order:
+    //   1. readCredentialsFile() for backup → sampleCredentials
+    //   2. loadProfile('work') → existingProfile (has stored email)
+    //   3. readCredentialsFile() after login → sampleCredentials
+    let readCallIdx = 0;
+    mockReadFile.mockImplementation(() => {
+      readCallIdx++;
+      if (readCallIdx === 1) {
+        // readCredentialsFile for backup
+        return Promise.resolve(JSON.stringify(sampleCredentials));
+      }
+      if (readCallIdx === 2) {
+        // loadProfile('work') — profile exists with stored email
+        return Promise.resolve(JSON.stringify(existingProfile));
+      }
+      // readCredentialsFile after login
+      return Promise.resolve(JSON.stringify(sampleCredentials));
+    });
+
+    // Mock the interactive login spawn (exits with code 0)
+    const loginChild = {
+      on: vi.fn().mockImplementation((event: string, handler: Handler) => {
+        if (event === 'close') setTimeout(() => handler(0), 0);
+        return loginChild;
+      }),
+      kill: vi.fn(),
+      stdout: null,
+      stderr: null,
+    };
+
+    // Mock auth status spawn
+    mockSpawn.mockImplementationOnce(() => loginChild); // claude auth login
+    mockSpawn.mockImplementationOnce(() => createMockChild(authStatusOutput, 0)); // claude auth status
+
+    const { loginProfile } = await import('../src/claude-profiles.js');
+    const result = await loginProfile('work'); // no explicit email — should use profile's email
+
+    expect(result.success).toBe(true);
+
+    // claude auth login should have been called with --email from existing profile
+    const loginSpawnCall = mockSpawn.mock.calls[0]!;
+    expect(loginSpawnCall[0]).toBe('claude');
+    const loginArgs = loginSpawnCall[1] as string[];
+    expect(loginArgs).toContain('--email');
+    expect(loginArgs).toContain('user@work.com');
+  });
+
+  it('uses provided --email even when profile does not exist', async () => {
+    // loginProfile read order:
+    //   1. readCredentialsFile() for backup → ENOENT (no credentials yet)
+    //   2. loadProfile('newaccount') → ENOENT (no profile)
+    //   3. readCredentialsFile() after login → sampleCredentials
+    let readCallIdx = 0;
+    mockReadFile.mockImplementation(() => {
+      readCallIdx++;
+      if (readCallIdx === 1 || readCallIdx === 2) {
+        throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+      }
+      return Promise.resolve(JSON.stringify(sampleCredentials));
+    });
+
+    const loginChild = {
+      on: vi.fn().mockImplementation((event: string, handler: Handler) => {
+        if (event === 'close') setTimeout(() => handler(0), 0);
+        return loginChild;
+      }),
+      kill: vi.fn(),
+      stdout: null,
+      stderr: null,
+    };
+
+    mockSpawn.mockImplementationOnce(() => loginChild);
+    mockSpawn.mockImplementationOnce(() => createMockChild(authStatusOutput, 0));
+
+    const { loginProfile } = await import('../src/claude-profiles.js');
+    await loginProfile('newaccount', 'explicit@email.com');
+
+    const loginSpawnCall = mockSpawn.mock.calls[0]!;
+    const loginArgs = loginSpawnCall[1] as string[];
+    expect(loginArgs).toContain('--email');
+    expect(loginArgs).toContain('explicit@email.com');
+  });
+});
+
+describe('saveCurrentAsProfile', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+    mockExecFileSync.mockReturnValue('/usr/bin/claude');
+  });
+
+  it('saves current credentials with auth status metadata', async () => {
+    mockReadFile.mockResolvedValue(JSON.stringify(sampleCredentials));
+    mockSpawn.mockReturnValue(createMockChild(authStatusOutput, 0));
+
+    const { saveCurrentAsProfile } = await import('../src/claude-profiles.js');
+    const result = await saveCurrentAsProfile('work');
+
+    expect(result.success).toBe(true);
+    expect(result.message).toContain('work');
+    expect(result.message).toContain('user@work.com');
+
+    // Should write the profile with metadata
+    const profileWrite = mockWriteFile.mock.calls.find((c) => {
+      try {
+        const parsed = JSON.parse(c[1] as string);
+        return parsed.name === 'work' && parsed.email === 'user@work.com';
+      } catch { return false; }
+    });
+    expect(profileWrite).toBeDefined();
+  });
+
+  it('returns error when no credentials file exists', async () => {
+    mockReadFile.mockRejectedValue(Object.assign(new Error('ENOENT'), { code: 'ENOENT' }));
+
+    const { saveCurrentAsProfile } = await import('../src/claude-profiles.js');
+    const result = await saveCurrentAsProfile('work');
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('No credentials file');
+  });
+});