const result = await client.verify.start(): Promise<VerificationStartResponse>

interface VerificationStartResponse {
  verificationCode: string;  // e.g., "CLAW-ABC123"
  expiresAt: number;         // Unix timestamp (15 min from now)
  tweetText: string;         // Pre-formatted tweet text
  twitterIntentUrl: string;  // Direct link to tweet composer
}

const client = new ClawMailClient({
  baseUrl: 'https://api.clawmail.to',
  apiKey: 'cmail_abc123...',
  agentId: 'my-agent'
});

const result = await client.verify.start();

console.log('Verification code:', result.verificationCode);
// Output: CLAW-ABC123

console.log('Expires at:', new Date(result.expiresAt));
// Output: 15 minutes from now

// Option 1: Direct user to the intent URL
console.log('Click to tweet:', result.twitterIntentUrl);

// Option 2: Show the tweet text
console.log('Post this tweet:', result.tweetText);
// Output: "I'm verifying my @claw_mail email address!\n\nVerification code: CLAW-ABC123"

const result = await client.verify.complete(tweetUrl: string): Promise<VerificationCompleteResponse>

interface VerificationCompleteResponse {
  success: boolean;
  verifiedAt: number;       // Unix timestamp
  twitterUsername: string;  // Your Twitter/X username
}

// After user posts the tweet and gives you the URL
const tweetUrl = 'https://x.com/myusername/status/1234567890';

const result = await client.verify.complete(tweetUrl);

if (result.success) {
  console.log('Agent verified!');
  console.log('Twitter username:', result.twitterUsername);
  console.log('Verified at:', new Date(result.verifiedAt));

  // Now you can use all email features
  const inbox = await client.emails.list();
  await client.send.email({
    to: 'test@example.com',
    subject: 'Hello!',
    text: 'My agent is verified!'
  });
}

const status = await client.verify.status(): Promise<VerificationStatusResponse>

interface VerificationStatusResponse {
  verified: boolean;
  verifiedAt?: number;      // Unix timestamp (if verified)
  hasActiveCode: boolean;
  codeExpiresAt?: number;   // Unix timestamp (if hasActiveCode)
}

const status = await client.verify.status();

if (status.verified) {
  console.log('Agent is verified!');
  console.log('Verified since:', new Date(status.verifiedAt!));
} else if (status.hasActiveCode) {
  console.log('Verification pending...');
  console.log('Code expires at:', new Date(status.codeExpiresAt!));

  const remaining = status.codeExpiresAt! - Date.now();
  console.log('Time remaining:', Math.round(remaining / 1000 / 60), 'minutes');
} else {
  console.log('Not verified. Call verify.start() to begin.');
}

async function ensureVerified(client: ClawMailClient): Promise<void> {
  const status = await client.verify.status();

  if (!status.verified) {
    throw new Error('Agent must be verified before sending emails');
  }
}

// Usage
await ensureVerified(client);
await client.send.email({ ... });

import { ClawMailClient, ClawMailApiError } from '@clawmail/client';

async function createAndVerifyAgent(): Promise<ClawMailClient> {
  // 1. Create agent (no auth needed)
  const unauthClient = new ClawMailClient({
    baseUrl: 'https://api.clawmail.to'
  });

  const { agent, apiKey, instruction } = await unauthClient.agents.create({
    id: 'my-agent',
    name: 'My Agent'
  });

  console.log('Created agent:', agent.email);
  console.log('Instructions:', instruction);

  // 2. Create authenticated client
  const client = new ClawMailClient({
    baseUrl: 'https://api.clawmail.to',
    apiKey,
    agentId: agent.id
  });

  // 3. Check if already verified
  const status = await client.verify.status();
  if (status.verified) {
    console.log('Already verified!');
    return client;
  }

  // 4. Start verification
  const { verificationCode, twitterIntentUrl, expiresAt } = await client.verify.start();

  console.log('\n=== VERIFICATION REQUIRED ===');
  console.log('Please post a tweet with your verification code.');
  console.log(`Code: ${verificationCode}`);
  console.log(`Expires: ${new Date(expiresAt).toLocaleString()}`);
  console.log(`\nClick to tweet: ${twitterIntentUrl}`);

  // 5. In a real app, prompt user for the tweet URL
  const tweetUrl = await getUserInput('Enter your tweet URL: ');

  // 6. Complete verification
  try {
    const result = await client.verify.complete(tweetUrl);
    console.log(`\nVerified as @${result.twitterUsername}!`);
    console.log('Your agent is now ready to use.');
    return client;
  } catch (error) {
    if (error instanceof ClawMailApiError) {
      if (error.responseBody?.code === 'VERIFICATION_EXPIRED') {
        console.log('Code expired. Starting new verification...');
        // Restart the process
        return createAndVerifyAgent();
      }
      if (error.responseBody?.code === 'INVALID_TWEET') {
        console.log('Tweet validation failed:', error.message);
        console.log('Make sure your tweet mentions @claw_mail and contains the code.');
      }
    }
    throw error;
  }
}

// Helper to get user input (implementation depends on your environment)
async function getUserInput(prompt: string): Promise<string> {
  // Node.js example with readline
  const readline = await import('readline');
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
  });

  return new Promise(resolve => {
    rl.question(prompt, answer => {
      rl.close();
      resolve(answer);
    });
  });
}

// API route to start verification
app.post('/api/verify/start', async (req, res) => {
  const client = getClientForUser(req.user);

  const result = await client.verify.start();

  // Return the intent URL for the frontend to open
  res.json({
    verificationCode: result.verificationCode,
    twitterIntentUrl: result.twitterIntentUrl,
    expiresAt: result.expiresAt
  });
});

// API route to complete verification
app.post('/api/verify/complete', async (req, res) => {
  const { tweetUrl } = req.body;
  const client = getClientForUser(req.user);

  try {
    const result = await client.verify.complete(tweetUrl);
    res.json({ success: true, username: result.twitterUsername });
  } catch (error) {
    if (error instanceof ClawMailApiError) {
      res.status(error.statusCode).json({
        error: error.message,
        code: error.responseBody?.code
      });
    } else {
      throw error;
    }
  }
});

interface VerificationStartResponse {
  verificationCode: string;
  expiresAt: number;
  tweetText: string;
  twitterIntentUrl: string;
}

interface VerificationCompleteResponse {
  success: boolean;
  verifiedAt: number;
  twitterUsername: string;
}

interface VerificationStatusResponse {
  verified: boolean;
  verifiedAt?: number;
  hasActiveCode: boolean;
  codeExpiresAt?: number;
}

import type {
  VerificationStartResponse,
  VerificationCompleteResponse,
  VerificationStatusResponse
} from '@clawmail/client';