Implement interactive prompts for authentication

- Add promptForIdentifier() with validation
- Add promptForPassword() with masking
- Add promptForLogin() combining both prompts
- Use @inquirer/prompts for user-friendly CLI interaction
- Add 5 tests covering all prompt functions and validation

Co-Authored-By: Claude Sonnet 4.5 <[e-mail]>

src/utils/prompts.ts

···
+import { input, password } from '@inquirer/prompts';
+import { safeValidateIdentifier } from './validation.js';
+
+/**
+ * Prompt for user's AT Protocol identifier (handle or DID)
+ */
+export async function promptForIdentifier(): Promise<string> {
+  return await input({
+    message: 'Enter your AT Protocol identifier (handle or DID):',
+    validate: (value: string) => {
+      if (!value.trim()) {
+        return 'Identifier cannot be empty';
+      }
+
+      const result = safeValidateIdentifier(value.trim());
+      if (!result.success) {
+        return result.error;
+      }
+
+      return true;
+    },
+  });
+}
+
+/**
+ * Prompt for app password
+ */
+export async function promptForPassword(): Promise<string> {
+  return await password({
+    message: 'Enter your app password:',
+    mask: '*',
+    validate: (value: string) => {
+      if (!value) {
+        return 'Password cannot be empty';
+      }
+      return true;
+    },
+  });
+}
+
+/**
+ * Prompt for login credentials
+ * Returns identifier and password
+ */
+export async function promptForLogin(): Promise<{
+  identifier: string;
+  password: string;
+}> {
+  const identifier = await promptForIdentifier();
+  const passwordValue = await promptForPassword();
+
+  return {
+    identifier,
+    password: passwordValue,
+  };
+}

tests/utils/prompts.test.ts

···
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { promptForIdentifier, promptForLogin, promptForPassword } from '../../src/utils/prompts.js';
+
+// Mock @inquirer/prompts
+vi.mock('@inquirer/prompts', () => ({
+  input: vi.fn(),
+  password: vi.fn(),
+}));
+
+describe('Prompts', () => {
+  let mockInput: ReturnType<typeof vi.fn>;
+  let mockPassword: ReturnType<typeof vi.fn>;
+
+  beforeEach(async () => {
+    const inquirer = await import('@inquirer/prompts');
+    mockInput = vi.mocked(inquirer.input);
+    mockPassword = vi.mocked(inquirer.password);
+    vi.clearAllMocks();
+  });
+
+  describe('promptForIdentifier', () => {
+    it('should prompt for identifier and return valid handle', async () => {
+      mockInput.mockResolvedValue('user.bsky.social');
+
+      const result = await promptForIdentifier();
+
+      expect(result).toBe('user.bsky.social');
+      expect(mockInput).toHaveBeenCalledWith({
+        message: 'Enter your AT Protocol identifier (handle or DID):',
+        validate: expect.any(Function),
+      });
+    });
+
+    it('should validate identifier format', async () => {
+      mockInput.mockResolvedValue('user.bsky.social');
+
+      await promptForIdentifier();
+
+      const validateFn = mockInput.mock.calls[0]?.[0]?.validate;
+      expect(validateFn).toBeDefined();
+
+      if (validateFn) {
+        // Valid handle
+        expect(validateFn('user.bsky.social')).toBe(true);
+
+        // Valid DID
+        expect(validateFn('did:plc:test123')).toBe(true);
+
+        // Empty
+        expect(validateFn('')).toBe('Identifier cannot be empty');
+        expect(validateFn('   ')).toBe('Identifier cannot be empty');
+
+        // Invalid format
+        expect(validateFn('invalid')).toContain('Invalid');
+      }
+    });
+  });
+
+  describe('promptForPassword', () => {
+    it('should prompt for password with masking', async () => {
+      mockPassword.mockResolvedValue('test-password');
+
+      const result = await promptForPassword();
+
+      expect(result).toBe('test-password');
+      expect(mockPassword).toHaveBeenCalledWith({
+        message: 'Enter your app password:',
+        mask: '*',
+        validate: expect.any(Function),
+      });
+    });
+
+    it('should validate password is not empty', async () => {
+      mockPassword.mockResolvedValue('test-password');
+
+      await promptForPassword();
+
+      const validateFn = mockPassword.mock.calls[0]?.[0]?.validate;
+      expect(validateFn).toBeDefined();
+
+      if (validateFn) {
+        // Valid password
+        expect(validateFn('password123')).toBe(true);
+
+        // Empty
+        expect(validateFn('')).toBe('Password cannot be empty');
+      }
+    });
+  });
+
+  describe('promptForLogin', () => {
+    it('should prompt for both identifier and password', async () => {
+      mockInput.mockResolvedValue('user.bsky.social');
+      mockPassword.mockResolvedValue('test-password');
+
+      const result = await promptForLogin();
+
+      expect(result).toEqual({
+        identifier: 'user.bsky.social',
+        password: 'test-password',
+      });
+      expect(mockInput).toHaveBeenCalledOnce();
+      expect(mockPassword).toHaveBeenCalledOnce();
+    });
+  });
+});