ultraclaude-agent 0.0.20 → 0.0.21

package/__tests__/claude-profiles.test.ts

@@ -0,0 +1,407 @@
+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 child_process
+const mockExecFileSync = vi.fn();
+const mockSpawn = vi.fn();
+
+vi.mock('node:child_process', () => ({
+  execFileSync: (...args: unknown[]) => mockExecFileSync(...args),
+  spawn: (...args: unknown[]) => mockSpawn(...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(),
+  },
+}));
+
+const PROFILES_DIR = '/home/testuser/.claude/ultra/claude-profiles';
+const BACKUPS_DIR = join(PROFILES_DIR, 'backups');
+
+const sampleProfile = {
+  name: 'work',
+  email: 'user@work.com',
+  orgName: 'WorkOrg',
+  subscriptionType: 'team',
+  savedAt: '2026-04-11T18:05:36Z',
+  credentials: {
+    claudeAiOauth: {
+      accessToken: 'sk-ant-oat01-test',
+      refreshToken: 'sk-ant-ort01-test',
+      expiresAt: Date.now() + 3600_000, // 1 hour from now
+      scopes: ['user:profile', 'user:inference'],
+      subscriptionType: 'team',
+      rateLimitTier: 'default_claude_max_5x',
+    },
+  },
+};
+
+describe('claude-profiles', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+    // Default: claude binary exists
+    mockExecFileSync.mockReturnValue('/usr/bin/claude');
+  });
+
+  describe('loadProfile', () => {
+    it('returns profile when file exists', async () => {
+      mockReadFile.mockResolvedValue(JSON.stringify(sampleProfile));
+      const { loadProfile } = await import('../src/claude-profiles.js');
+      const profile = await loadProfile('work');
+      expect(profile).toEqual(sampleProfile);
+      expect(mockReadFile).toHaveBeenCalledWith(
+        join(PROFILES_DIR, 'work.json'),
+        'utf8',
+      );
+    });
+
+    it('returns null when file does not exist', async () => {
+      mockReadFile.mockRejectedValue(Object.assign(new Error('ENOENT'), { code: 'ENOENT' }));
+      const { loadProfile } = await import('../src/claude-profiles.js');
+      const profile = await loadProfile('nonexistent');
+      expect(profile).toBeNull();
+    });
+  });
+
+  describe('saveProfile', () => {
+    it('writes profile with atomic temp+rename pattern', async () => {
+      const { saveProfile } = await import('../src/claude-profiles.js');
+      await saveProfile(sampleProfile);
+
+      // Should mkdir for profiles dir
+      expect(mockMkdir).toHaveBeenCalled();
+
+      // Should write to .tmp file with mode 0o600
+      expect(mockWriteFile).toHaveBeenCalledWith(
+        expect.stringMatching(/\.tmp$/),
+        expect.stringContaining('"name": "work"'),
+        expect.objectContaining({ mode: 0o600 }),
+      );
+
+      // Should rename .tmp to final path
+      expect(mockRename).toHaveBeenCalledWith(
+        expect.stringMatching(/\.tmp$/),
+        join(PROFILES_DIR, 'work.json'),
+      );
+    });
+  });
+
+  describe('deleteProfileFile', () => {
+    it('deletes profile file', async () => {
+      const { deleteProfileFile } = await import('../src/claude-profiles.js');
+      const result = await deleteProfileFile('work');
+      expect(result).toBe(true);
+      expect(mockUnlink).toHaveBeenCalledWith(join(PROFILES_DIR, 'work.json'));
+    });
+
+    it('returns false when file does not exist', async () => {
+      mockUnlink.mockRejectedValue(Object.assign(new Error('ENOENT'), { code: 'ENOENT' }));
+      const { deleteProfileFile } = await import('../src/claude-profiles.js');
+      const result = await deleteProfileFile('nonexistent');
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('listProfiles', () => {
+    it('returns all profiles sorted by name', async () => {
+      const personalProfile = { ...sampleProfile, name: 'personal', email: 'me@home.com' };
+      mockReaddir.mockResolvedValue(['work.json', 'personal.json', 'active.json']);
+      mockReadFile
+        .mockResolvedValueOnce(JSON.stringify(sampleProfile))
+        .mockResolvedValueOnce(JSON.stringify(personalProfile));
+
+      const { listProfiles } = await import('../src/claude-profiles.js');
+      const profiles = await listProfiles();
+
+      expect(profiles).toHaveLength(2);
+      expect(profiles[0]!.name).toBe('personal');
+      expect(profiles[1]!.name).toBe('work');
+    });
+
+    it('skips active.json', async () => {
+      mockReaddir.mockResolvedValue(['active.json']);
+      const { listProfiles } = await import('../src/claude-profiles.js');
+      const profiles = await listProfiles();
+      expect(profiles).toHaveLength(0);
+    });
+
+    it('returns empty array when directory does not exist', async () => {
+      mockReaddir.mockRejectedValue(Object.assign(new Error('ENOENT'), { code: 'ENOENT' }));
+      const { listProfiles } = await import('../src/claude-profiles.js');
+      const profiles = await listProfiles();
+      expect(profiles).toHaveLength(0);
+    });
+  });
+
+  describe('active profile tracking', () => {
+    it('loads active profile', async () => {
+      const active = { profile: 'work', switchedAt: '2026-04-11T18:05:36Z' };
+      mockReadFile.mockResolvedValue(JSON.stringify(active));
+      const { loadActiveProfile } = await import('../src/claude-profiles.js');
+      const result = await loadActiveProfile();
+      expect(result).toEqual(active);
+    });
+
+    it('sets active profile with atomic write', async () => {
+      const { setActiveProfile } = await import('../src/claude-profiles.js');
+      await setActiveProfile('work');
+
+      expect(mockWriteFile).toHaveBeenCalledWith(
+        expect.stringMatching(/\.tmp$/),
+        expect.stringContaining('"profile": "work"'),
+        expect.objectContaining({ mode: 0o600 }),
+      );
+    });
+  });
+
+  describe('getExpiryStatus', () => {
+    it('returns valid for tokens expiring in >2 hours', async () => {
+      const { getExpiryStatus } = await import('../src/claude-profiles.js');
+      const profile = {
+        ...sampleProfile,
+        credentials: {
+          claudeAiOauth: { ...sampleProfile.credentials.claudeAiOauth, expiresAt: Date.now() + 5 * 3600_000 },
+        },
+      };
+      const status = getExpiryStatus(profile);
+      expect(status.status).toBe('valid');
+      expect(status.label).toContain('\u2713');
+    });
+
+    it('returns expiring for tokens expiring in <2 hours', async () => {
+      const { getExpiryStatus } = await import('../src/claude-profiles.js');
+      const profile = {
+        ...sampleProfile,
+        credentials: {
+          claudeAiOauth: { ...sampleProfile.credentials.claudeAiOauth, expiresAt: Date.now() + 30 * 60_000 },
+        },
+      };
+      const status = getExpiryStatus(profile);
+      expect(status.status).toBe('expiring');
+      expect(status.label).toContain('\u26a0');
+    });
+
+    it('returns expired for past timestamps', async () => {
+      const { getExpiryStatus } = await import('../src/claude-profiles.js');
+      const profile = {
+        ...sampleProfile,
+        credentials: {
+          claudeAiOauth: { ...sampleProfile.credentials.claudeAiOauth, expiresAt: Date.now() - 60_000 },
+        },
+      };
+      const status = getExpiryStatus(profile);
+      expect(status.status).toBe('expired');
+      expect(status.label).toContain('\u2717');
+    });
+  });
+
+  describe('pruneBackups', () => {
+    it('removes backups older than maxAgeDays', async () => {
+      const now = Date.now();
+      const oldTime = now - 8 * 24 * 3600_000; // 8 days ago
+      const recentTime = now - 1 * 24 * 3600_000; // 1 day ago
+
+      mockReaddir.mockResolvedValue(['old.json', 'recent.json']);
+      mockStat
+        .mockResolvedValueOnce({ mtimeMs: oldTime })
+        .mockResolvedValueOnce({ mtimeMs: recentTime });
+
+      const { pruneBackups } = await import('../src/claude-profiles.js');
+      const pruned = await pruneBackups(7);
+
+      expect(pruned).toBe(1);
+      expect(mockUnlink).toHaveBeenCalledWith(join(BACKUPS_DIR, 'old.json'));
+      expect(mockUnlink).not.toHaveBeenCalledWith(join(BACKUPS_DIR, 'recent.json'));
+    });
+
+    it('returns 0 when no old backups exist', async () => {
+      mockReaddir.mockResolvedValue(['recent.json']);
+      mockStat.mockResolvedValue({ mtimeMs: Date.now() });
+
+      const { pruneBackups } = await import('../src/claude-profiles.js');
+      const pruned = await pruneBackups(7);
+      expect(pruned).toBe(0);
+    });
+  });
+
+  describe('createBackup', () => {
+    it('writes backup with timestamp filename', async () => {
+      const { createBackup } = await import('../src/claude-profiles.js');
+      const creds = sampleProfile.credentials;
+      const path = await createBackup(creds);
+
+      expect(path).toMatch(/backups\/\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}Z\.json$/);
+      expect(mockMkdir).toHaveBeenCalledWith(
+        BACKUPS_DIR,
+        expect.objectContaining({ mode: 0o700 }),
+      );
+      expect(mockWriteFile).toHaveBeenCalledWith(
+        expect.stringContaining('backups/'),
+        expect.any(String),
+        expect.objectContaining({ mode: 0o600 }),
+      );
+    });
+  });
+
+  describe('self-trigger flag', () => {
+    it('starts as false', async () => {
+      const { isSelfTriggered, clearSelfTriggerFlag } = await import('../src/claude-profiles.js');
+      clearSelfTriggerFlag(); // reset state
+      expect(isSelfTriggered()).toBe(false);
+    });
+
+    it('setSelfTriggerFlag sets to true', async () => {
+      const { setSelfTriggerFlag, isSelfTriggered, clearSelfTriggerFlag } = await import('../src/claude-profiles.js');
+      clearSelfTriggerFlag();
+      setSelfTriggerFlag();
+      expect(isSelfTriggered()).toBe(true);
+    });
+
+    it('clearSelfTriggerFlag resets to false', async () => {
+      const { setSelfTriggerFlag, clearSelfTriggerFlag, isSelfTriggered } = await import('../src/claude-profiles.js');
+      setSelfTriggerFlag();
+      clearSelfTriggerFlag();
+      expect(isSelfTriggered()).toBe(false);
+    });
+  });
+
+  describe('writeCredentialsFile', () => {
+    it('performs atomic write without touching self-trigger flag', async () => {
+      const { writeCredentialsFile, isSelfTriggered, clearSelfTriggerFlag } = await import('../src/claude-profiles.js');
+      clearSelfTriggerFlag();
+
+      await writeCredentialsFile(sampleProfile.credentials);
+
+      // Flag should NOT be set — writeCredentialsFile is a pure write
+      expect(isSelfTriggered()).toBe(false);
+
+      // Should use atomic write pattern
+      expect(mockWriteFile).toHaveBeenCalledWith(
+        expect.stringMatching(/\.tmp$/),
+        expect.any(String),
+        expect.objectContaining({ mode: 0o600 }),
+      );
+      expect(mockRename).toHaveBeenCalled();
+    });
+  });
+
+  describe('runClaudeAuthStatus', () => {
+    it('returns null when claude binary not found', async () => {
+      mockExecFileSync.mockImplementation(() => {
+        throw new Error('not found');
+      });
+      const { runClaudeAuthStatus } = await import('../src/claude-profiles.js');
+      const result = await runClaudeAuthStatus();
+      expect(result).toBeNull();
+    });
+
+    it('parses JSON output from claude auth status', async () => {
+      // Mock spawn to emit JSON
+      const mockChild = {
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() },
+        on: vi.fn(),
+        kill: vi.fn(),
+      };
+      mockSpawn.mockReturnValue(mockChild);
+
+      const { runClaudeAuthStatus } = await import('../src/claude-profiles.js');
+      const promise = runClaudeAuthStatus();
+
+      // Simulate stdout data
+      const stdoutHandler = mockChild.stdout.on.mock.calls.find(
+        (c: unknown[]) => c[0] === 'data',
+      )![1] as (data: Buffer) => void;
+      stdoutHandler(Buffer.from(JSON.stringify({
+        email: 'user@work.com',
+        orgName: 'WorkOrg',
+        subscriptionType: 'team',
+        loggedIn: true,
+      })));
+
+      // Simulate close
+      const closeHandler = mockChild.on.mock.calls.find(
+        (c: unknown[]) => c[0] === 'close',
+      )![1] as (code: number) => void;
+      closeHandler(0);
+
+      const result = await promise;
+      expect(result).toEqual({
+        email: 'user@work.com',
+        orgName: 'WorkOrg',
+        subscriptionType: 'team',
+        loggedIn: true,
+      });
+    });
+
+    it('parses text output as fallback', async () => {
+      const mockChild = {
+        stdout: { on: vi.fn() },
+        stderr: { on: vi.fn() },
+        on: vi.fn(),
+        kill: vi.fn(),
+      };
+      mockSpawn.mockReturnValue(mockChild);
+
+      const { runClaudeAuthStatus } = await import('../src/claude-profiles.js');
+      const promise = runClaudeAuthStatus();
+
+      const stdoutHandler = mockChild.stdout.on.mock.calls.find(
+        (c: unknown[]) => c[0] === 'data',
+      )![1] as (data: Buffer) => void;
+      stdoutHandler(Buffer.from('Logged in as: user@work.com\nOrg: WorkOrg\nSubscription: team\n'));
+
+      const closeHandler = mockChild.on.mock.calls.find(
+        (c: unknown[]) => c[0] === 'close',
+      )![1] as (code: number) => void;
+      closeHandler(0);
+
+      const result = await promise;
+      expect(result).toEqual({
+        email: 'user@work.com',
+        orgName: 'WorkOrg',
+        subscriptionType: 'team',
+        loggedIn: true,
+      });
+    });
+  });
+});

package/__tests__/credential-watcher.test.ts

@@ -0,0 +1,229 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// 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 child_process with callback-storage spawn mock
+const mockExecFileSync = vi.fn().mockReturnValue('/usr/bin/claude');
+
+type Handler = (...args: unknown[]) => void;
+
+function createMockChild(output: string, exitCode = 0) {
+  const stdoutHandlers: Record<string, Handler[]> = {};
+  const stderrHandlers: 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) {
+      (stderrHandlers[event] ??= []).push(handler);
+      return mockStderr;
+    },
+  };
+  const child = {
+    stdout: mockStdout,
+    stderr: mockStderr,
+    kill: vi.fn(),
+    on(event: string, handler: Handler) {
+      (childHandlers[event] ??= []).push(handler);
+      // Auto-fire data + close after handlers are registered
+      // Use setTimeout to ensure all handlers are registered first
+      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 mockSpawn = vi.fn();
+
+vi.mock('node:child_process', () => ({
+  execFileSync: (...args: unknown[]) => mockExecFileSync(...args),
+  spawn: (...args: unknown[]) => mockSpawn(...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(),
+  },
+}));
+
+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,
+};
+
+describe('handleCredentialChange', () => {
+  beforeEach(() => {
+    vi.resetAllMocks();
+    mockExecFileSync.mockReturnValue('/usr/bin/claude');
+  });
+
+  it('skips processing when self-triggered', async () => {
+    const {
+      setSelfTriggerFlag,
+      isSelfTriggered,
+      handleCredentialChange,
+    } = await import('../src/claude-profiles.js');
+
+    setSelfTriggerFlag();
+    await handleCredentialChange();
+
+    // Self-trigger flag should be cleared
+    expect(isSelfTriggered()).toBe(false);
+
+    // Should NOT have read credentials or spawned auth status
+    expect(mockReadFile).not.toHaveBeenCalled();
+    expect(mockSpawn).not.toHaveBeenCalled();
+  });
+
+  it('creates backup on external change', async () => {
+    const { handleCredentialChange, clearSelfTriggerFlag } = await import('../src/claude-profiles.js');
+    clearSelfTriggerFlag();
+
+    mockReadFile.mockResolvedValue(JSON.stringify(sampleCredentials));
+
+    mockSpawn.mockReturnValue(createMockChild(JSON.stringify({
+      email: 'unknown@other.com',
+      orgName: 'OtherOrg',
+      subscriptionType: 'free',
+      loggedIn: true,
+    })));
+
+    // No saved profiles
+    mockReaddir.mockResolvedValue([]);
+
+    await handleCredentialChange();
+
+    // Should have written a backup file
+    expect(mockWriteFile).toHaveBeenCalledWith(
+      expect.stringContaining('backups/'),
+      expect.stringContaining('claudeAiOauth'),
+      expect.objectContaining({ mode: 0o600 }),
+    );
+  });
+
+  it('updates matching profile when email matches', async () => {
+    const { handleCredentialChange, clearSelfTriggerFlag } = await import('../src/claude-profiles.js');
+    clearSelfTriggerFlag();
+
+    // readFile calls: readCredentialsFile, then listProfiles reads profile
+    let readFileCallCount = 0;
+    mockReadFile.mockImplementation(() => {
+      readFileCallCount++;
+      if (readFileCallCount <= 1) {
+        return Promise.resolve(JSON.stringify(sampleCredentials));
+      }
+      return Promise.resolve(JSON.stringify(sampleProfile));
+    });
+
+    mockSpawn.mockReturnValue(createMockChild(JSON.stringify({
+      email: 'user@work.com',
+      orgName: 'WorkOrg',
+      subscriptionType: 'team',
+      loggedIn: true,
+    })));
+
+    mockReaddir.mockResolvedValue(['work.json']);
+
+    await handleCredentialChange();
+
+    // Should have written: backup + updated profile (2 writeFile calls)
+    expect(mockWriteFile).toHaveBeenCalledTimes(2);
+
+    // Second write should be the profile update (tmp file for atomic write)
+    const secondWrite = mockWriteFile.mock.calls[1]!;
+    expect(secondWrite[0]).toMatch(/\.tmp$/);
+    const writtenProfile = JSON.parse(secondWrite[1] as string);
+    expect(writtenProfile.name).toBe('work');
+    expect(writtenProfile.email).toBe('user@work.com');
+  });
+
+  it('logs suggestion when email matches no profile', async () => {
+    const { handleCredentialChange, clearSelfTriggerFlag } = await import('../src/claude-profiles.js');
+    clearSelfTriggerFlag();
+
+    mockReadFile.mockResolvedValue(JSON.stringify(sampleCredentials));
+
+    mockSpawn.mockReturnValue(createMockChild(JSON.stringify({
+      email: 'unknown@other.com',
+      orgName: 'OtherOrg',
+      subscriptionType: 'free',
+      loggedIn: true,
+    })));
+
+    // No profiles
+    mockReaddir.mockResolvedValue([]);
+
+    await handleCredentialChange();
+
+    // Should have written backup only (1 writeFile call)
+    expect(mockWriteFile).toHaveBeenCalledTimes(1);
+    expect(mockWriteFile).toHaveBeenCalledWith(
+      expect.stringContaining('backups/'),
+      expect.any(String),
+      expect.any(Object),
+    );
+  });
+});