Zero-Human Provisioning

import { DaimonClient } from 'daimon-email';

class AutonomousAgent {
  private client: DaimonClient;
  private inbox: any;
  private apiKey: string;

  async bootstrap() {
    console.log('🤖 Agent starting from nothing...');

    // Step 1: Create inbox (no auth required)
    const client = new DaimonClient();
    this.inbox = await client.inboxes.create({
      username: 'autonomous-agent-' + Date.now(),
      clientId: `deployment-${process.env.DEPLOYMENT_ID}`
    });

    this.apiKey = this.inbox.apiKey;
    this.client = new DaimonClient({ apiKey: this.apiKey });

    console.log(`✅ Created inbox: ${this.inbox.address}`);
    console.log(`🔑 API Key: ${this.apiKey.slice(0, 20)}...`);

    // Step 2: Check what we can do
    const capabilities = await this.client.account.getCapabilities();
    console.log('📋 Current capabilities:', capabilities.can.map(c => c.action));

    return this.inbox;
  }

  async signUpForService(serviceUrl: string) {
    console.log(`📝 Signing up for service: ${serviceUrl}`);

    // Use our email to sign up for external service
    const signupResponse = await fetch(`${serviceUrl}/api/signup`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        email: this.inbox.address,
        name: 'Autonomous Agent'
      })
    });

    console.log('📧 Waiting for confirmation email...');

    // Poll for confirmation email
    let confirmationEmail = null;
    for (let i = 0; i < 60; i++) {
      const messages = await this.client.inboxes.messages.list(this.inbox.id);
      confirmationEmail = messages.find(m =>
        m.from.includes(serviceUrl.replace('https://', ''))
      );

      if (confirmationEmail) break;
      await new Promise(resolve => setTimeout(resolve, 5000));
    }

    if (!confirmationEmail) {
      throw new Error('Confirmation email never arrived');
    }

    // Extract and click confirmation link
    const confirmLink = confirmationEmail.ctaLinks[0];
    console.log(`🔗 Found confirmation link: ${confirmLink.url}`);

    await fetch(confirmLink.url);
    console.log('✅ Service account verified!');

    return confirmationEmail;
  }

  async upgradeWhenNeeded() {
    try {
      // Try to send an email
      await this.client.inboxes.send(this.inbox.id, {
        to: 'test@example.com',
        subject: 'Test',
        body: 'Testing send capability'
      });
    } catch (error: any) {
      if (error.code === 'SEND_REQUIRES_PAID') {
        console.log('⚠️  Send requires paid tier');
        console.log('💡 Agent suggestion:', error.upgradeContext.agentScript);

        // Generate magic upgrade link
        const upgradeLink = await this.client.account.createUpgradeLink({
          reason: 'Need sending capabilities for email automation',
          returnUrl: `https://my-dashboard.com/agent/${this.inbox.id}`
        });

        console.log('🔗 Upgrade link:', upgradeLink.url);
        console.log('⏳ Waiting for operator to upgrade...');

        // In production: send this link via Slack/Discord to operator
        // For demo: just log it
        return upgradeLink;
      }
    }
  }

  async handleUpgradeCallback(webhookEvent: any) {
    if (webhookEvent.event === 'account.upgraded') {
      console.log('🎉 Account upgraded!');
      console.log('New tier:', webhookEvent.account.tier);

      // Now we can send
      const result = await this.client.inboxes.send(this.inbox.id, {
        to: 'test@example.com',
        subject: 'Hello!',
        body: 'I can now send emails!'
      });

      console.log('✅ First email sent:', result.messageId);
    }
  }
}

// Usage
const agent = new AutonomousAgent();
await agent.bootstrap();
await agent.signUpForService('https://external-service.com');
const upgradeLink = await agent.upgradeWhenNeeded();

import time
import requests
from daimon_email import DaimonClient

class AutonomousAgent:
    def __init__(self):
        self.client = None
        self.inbox = None
        self.api_key = None

    def bootstrap(self):
        print('🤖 Agent starting from nothing...')

        # Step 1: Create inbox (no auth required)
        client = DaimonClient()
        self.inbox = client.inboxes.create(
            username=f'autonomous-agent-{int(time.time())}',
            client_id=f'deployment-{os.getenv("DEPLOYMENT_ID")}'
        )

        self.api_key = self.inbox.api_key
        self.client = DaimonClient(api_key=self.api_key)

        print(f'✅ Created inbox: {self.inbox.address}')
        print(f'🔑 API Key: {self.api_key[:20]}...')

        # Step 2: Check what we can do
        capabilities = self.client.account.get_capabilities()
        print(f'📋 Current capabilities: {[c["action"] for c in capabilities.can]}')

        return self.inbox

    def sign_up_for_service(self, service_url: str):
        print(f'📝 Signing up for service: {service_url}')

        # Use our email to sign up for external service
        signup_response = requests.post(
            f'{service_url}/api/signup',
            json={
                'email': self.inbox.address,
                'name': 'Autonomous Agent'
            }
        )

        print('📧 Waiting for confirmation email...')

        # Poll for confirmation email
        confirmation_email = None
        for i in range(60):
            messages = self.client.inboxes.messages.list(self.inbox.id)
            confirmation_email = next(
                (m for m in messages if service_url.replace('https://', '') in m.from_address),
                None
            )

            if confirmation_email:
                break
            time.sleep(5)

        if not confirmation_email:
            raise Exception('Confirmation email never arrived')

        # Extract and click confirmation link
        confirm_link = confirmation_email.cta_links[0]
        print(f'🔗 Found confirmation link: {confirm_link["url"]}')

        requests.get(confirm_link['url'])
        print('✅ Service account verified!')

        return confirmation_email

    def upgrade_when_needed(self):
        try:
            # Try to send an email
            self.client.inboxes.send(
                self.inbox.id,
                to='test@example.com',
                subject='Test',
                body='Testing send capability'
            )
        except Exception as error:
            if hasattr(error, 'code') and error.code == 'SEND_REQUIRES_PAID':
                print('⚠️  Send requires paid tier')
                print(f'💡 Agent suggestion: {error.upgrade_context["agent_script"]}')

                # Generate magic upgrade link
                upgrade_link = self.client.account.create_upgrade_link({
                    'reason': 'Need sending capabilities for email automation',
                    'return_url': f'https://my-dashboard.com/agent/{self.inbox.id}'
                })

                print(f'🔗 Upgrade link: {upgrade_link.url}')
                print('⏳ Waiting for operator to upgrade...')

                # In production: send this link via Slack/Discord to operator
                return upgrade_link

    def handle_upgrade_callback(self, webhook_event):
        if webhook_event['event'] == 'account.upgraded':
            print('🎉 Account upgraded!')
            print(f'New tier: {webhook_event["account"]["tier"]}')

            # Now we can send
            result = self.client.inboxes.send(
                self.inbox.id,
                to='test@example.com',
                subject='Hello!',
                body='I can now send emails!'
            )

            print(f'✅ First email sent: {result.message_id}')

# Usage
agent = AutonomousAgent()
agent.bootstrap()
agent.sign_up_for_service('https://external-service.com')
upgrade_link = agent.upgrade_when_needed()