Skill: seenfinity/tixflow-v2 (version 0.2.0)

--- name: tixflow description: AI-powered event assistant for discovering, booking, and coordinating event tickets. Integrates with KYD Labs protocol and Google Calendar. metadata: openclaw: requires: env: ["GOOGLE_CALENDAR_API_KEY", "KYD_API_KEY"] install: - id: npm kind: npm package: googleapis label: Install Google Calendar API --- # 🎫 TixFlow - AI Event Assistant > Your personal AI agent for event discovery, booking, and coordination ## What TixFlow Does - 🔍 **Event Discovery** - Search events by artist, location, date, or genre - 🎫 **Smart Booking** - Purchase tickets across platforms - 📅 **Calendar Sync** - Sync events to Google Calendar with reminders - ⏰ **Waitlist Management** - Get notified when sold-out events have availability - 🤖 **AI Agent Power** - Let your agent handle everything automatically ## Installation ```bash clawhub install tixflow ``` ## Environment Variables - `GOOGLE_CALENDAR_API_KEY` - Google Calendar API key (for calendar sync) - `KYD_API_KEY` - KYD Labs API key (optional, for real ticketing) ## Functions | Function | Status | Description | |----------|--------|-------------| | `findEvents()` | ✅ Ready | Search events by criteria | | `getEventDetails()` | ✅ Ready | Get event information | | `purchaseTicket()` | 🔄 Demo | Purchase ticket (demo mode) | | `syncToCalendar()` | 🔄 Ready | Sync to Google Calendar | | `addToWaitlist()` | ✅ Ready | Join event waitlist | | `checkPrices()` | ✅ Ready | Compare prices across platforms | ## Usage ```javascript const { findEvents, syncToCalendar, purchaseTicket } = require('./scripts/tixflow.js'); // Find events const events = await findEvents({ type: 'concert', location: 'London', date: '2026-03' }); // Sync to calendar await syncToCalendar({ eventId: '123', userEmail: '[REDACTED_SECRET]' }); // Purchase ticket await purchaseTicket({ eventId: '123', quantity: 2, walletAddress: '...' }); ``` ## Demo Mode Without API keys, the skill runs in demo mode with mock event data. This is perfect for: - Prototyping - Hackathons - User demos ## Built For - KYD Labs Ticketing Track - Solana Graveyard Hackathon - OpenClaw Agents

path: README.md
content: # TixFlow - OpenClaw Skill 🎫🤖

AI-powered event assistant skill for OpenClaw agents.

## Installation

```bash
clawhub install tixflow
```

Or manually:

```bash
cd skill
npm install
```

## Environment Variables

Create a `.env` file:

```env
# Google Calendar (for event scheduling)
GOOGLE_CALENDAR_API_KEY=your_google_api_key

# Google Maps (for directions/routes)
GOOGLE_MAPS_API_KEY=your_google_maps_api_key

# CrossMint (for cNFT ticket minting)
CROSSMINT_API_KEY=your_crossmint_api_key
CROSSMINT_COLLECTION_ID=your_collection_id
```

## Features

| Feature | Description |
|---------|-------------|
| 🔍 **Event Discovery** | Search events by type, location, date |
| 📅 **Calendar Sync** | Add events to Google Calendar |
| 🗺️ **Directions** | Get transport routes to venue |
| 🎟️ **cNFT Minting** | Mint real NFT tickets on Solana |
| 👻 **Wallet Detection** | Detect user wallet (Phantom, Solflare) |
| 💰 **Price Monitoring** | Compare prices across platforms |

## Functions

- `findEvents({type, location, date, budget})` - Search for events
- `getEventDetails(eventId)` - Get event information
- `purchaseTicket({eventId, quantity, walletAddress})` - Buy tickets (mints cNFT)
- `syncToCalendar({eventId})` - Generate Google Calendar link
- `getDirections({eventId, mode})` - Get transport directions (drive, transit, walk)
- `addToWaitlist({eventId, walletAddress})` - Join event waitlist
- `checkPrices(eventId)` - Compare prices across platforms

## Demo Mode

Set `demo_mode: true` in config to run without real API keys (mock data).

## Supported Platforms

- Telegram
- Discord  
- WhatsApp

## License

MIT

---

*Built for KYD Labs Solana Graveyard Hackathon*


path: package.json
content: {
  "name": "tixflow",
  "version": "0.1.0",
  "description": "AI-powered event assistant for discovering, booking, and coordinating event tickets",
  "main": "scripts/index.js",
  "scripts": {
    "test": "node test.js"
  },
  "keywords": [
    "tixflow",
    "events",
    "tickets",
    "kyd",
    "solana",
    "openclaw",
    "ai-agent"
  ],
  "author": "TixFlow Team",
  "license": "MIT",
  "dependencies": {
    "googleapis": "^120.0.0"
  }
}


path: scripts/index.js
content: // TixFlow - AI Event Assistant
// Functions for event discovery, booking, and coordination

// Mock event data for demo mode
const mockEvents = [
  {
    id: "1",
    name: "Classical Symphony Orchestra",
    date: "2026-02-25",
    venue: "Royal Albert Hall, London",
    price: { min: 45, max: 120, currency: "GBP" },
    image: "https://images.unsplash.com/photo-1514320291840-2e0a9bf2a9ae?w=400&q=80",
    available: true,
    category: "classical"
  },
  {
    id: "2",
    name: "Jazz Night Live",
    date: "2026-03-01",
    venue: "Blue Note, NYC",
    price: { min: 35, max: 80, currency: "USD" },
    image: "https://images.unsplash.com/photo-1415201364774-f6f0bb35f28f?w=400&q=80",
    available: true,
    category: "jazz"
  },
  {
    id: "3",
    name: "Electronic Music Festival",
    date: "2026-03-15",
    venue: "Brooklyn Warehouse",
    price: { min: 50, max: 150, currency: "USD" },
    image: "https://images.unsplash.com/photo-1470229722913-7c0e2dbbafd3?w=400&q=80",
    available: false,
    category: "electronic"
  }
];

/**
 * Find events based on criteria
 * @param {Object} params - Search parameters
 * @param {string} params.type - Event type (concert, theater, sports)
 * @param {string} params.location - Location
 * @param {string} params.date - Date or date range
 * @param {number} params.budget - Maximum budget
 */
async function findEvents(params = {}) {
  const { type, location, date, budget } = params;
  
  // In demo mode, return mock events
  // In production, this would call KYD Labs API
  let results = [...mockEvents];
  
  if (type) {
    results = results.filter(e => e.category.toLowerCase().includes(type.toLowerCase()));
  }
  
  if (location) {
    results = results.filter(e => e.venue.toLowerCase().includes(location.toLowerCase()));
  }
  
  if (budget) {
    results = results.filter(e => e.price.min <= budget);
  }
  
  return {
    success: true,
    count: results.length,
    events: results
  };
}

/**
 * Get detailed information about a specific event
 * @param {string} eventId - Event ID
 */
async function getEventDetails(eventId) {
  const event = mockEvents.find(e => e.id === eventId);
  
  if (!event) {
    return { success: false, error: "Event not found" };
  }
  
  return {
    success: true,
    event: {
      ...event,
      description: "An evening of classical masterpieces conducted by renowned artists.",
      seatingChart: "https://example.com/seating.jpg",
      policies: {
        refundable: false,
        transferAllowed: true
      }
    }
  };
}

/**
 * Purchase tickets for an event
 * @param {Object} params - Purchase parameters
 * @param {string} params.eventId - Event ID
 * @param {number} params.quantity - Number of tickets
 * @param {string} params.walletAddress - Wallet address for NFT ticket
 */
async function purchaseTicket(params) {
  const { eventId, quantity, walletAddress } = params;
  
  const event = mockEvents.find(e => e.id === eventId);
  
  if (!event) {
    return { success: false, error: "Event not found" };
  }
  
  if (!event.available) {
    return { success: false, error: "Event is sold out. Added to waitlist." };
  }
  
  // In demo mode, return mock transaction
  // In production, this would call KYD Labs protocol
  return {
    success: true,
    demo: true,
    message: "Demo mode: Ticket would be minted as cNFT on Solana",
    transactionId: "mock_tx_" + Date.now(),
    ticketId: "mock_nft_" + Date.now()
  };
}

/**
 * Sync event to Google Calendar
 * @param {Object} params - Sync parameters
 * @param {string} params.eventId - Event ID
 * @param {string} params.userEmail - User email for calendar
 */
async function syncToCalendar(params) {
  const { eventId, userEmail } = params;
  
  const event = mockEvents.find(e => e.id === eventId);
  
  if (!event) {
    return { success: false, error: "Event not found" };
  }
  
  // In demo mode, return mock calendar event
  // In production, this would call Google Calendar API
  return {
    success: true,
    demo: true,
    message: "Demo mode: Would sync to Google Calendar",
    calendarEventId: "mock_calendar_" + Date.now(),
    eventLink: "https://calendar.google.com/calendar/event?eid=mock"
  };
}

/**
 * Add user to event waitlist
 * @param {Object} params - Waitlist parameters
 * @param {string} params.eventId - Event ID
 * @param {string} params.walletAddress - User wallet
 * @param {string} params.notificationMethod - email, telegram, or discord
 */
async function addToWaitlist(params) {
  const { eventId, walletAddress, notificationMethod } = params;
  
  const event = mockEvents.find(e => e.id === eventId);
  
  if (!event) {
    return { success: false, error: "Event not found" };
  }
  
  // In production, this would store in database and monitor for availability
  return {
    success: true,
    waitlistPosition: Math.floor(Math.random() * 100) + 1,
    message: `Added to waitlist for ${event.name}. We'll notify you when tickets are available.`
  };
}

/**
 * Check prices across platforms
 * @param {string} eventId - Event ID
 */
async function checkPrices(eventId) {
  const event = mockEvents.find(e => e.id === eventId);
  
  if (!event) {
    return { success: false, error: "Event not found" };
  }
  
  // Mock price comparison across platforms
  return {
    success: true,
    eventId,
    prices: [
      { platform: "Ticketmaster", price: event.price.max, fees: 12, total: event.price.max + 12 },
      { platform: "StubHub", price: event.price.max + 10, fees: 8, total: event.price.max + 18 },
      { platform: "KYD Protocol", price: event.price.min, fees: 0, total: event.price.min }
    ],
    recommendation: "KYD Protocol offers the best price with no fees"
  };
}

module.exports = {
  findEvents,
  getEventDetails,
  purchaseTicket,
  syncToCalendar,
  addToWaitlist,
  checkPrices
};


path: skill.json
content: {
  "name": "tixflow",
  "version": "0.2.0",
  "description": "AI-powered event assistant for discovering, booking, and coordinating event tickets on Solana",
  "author": "TixFlow Team",
  "homepage": "https://github.com/seenfinity/tixflow",
  "platforms": ["telegram", "discord", "whatsapp"],
  "skills": {
    "triggers": [
      "find event",
      "search concert",
      "buy ticket",
      "purchase ticket",
      "sync calendar",
      "add to calendar",
      "event notification",
      "waitlist",
      "how do i get there",
      "route to event",
      "directions to",
      "get directions"
    ],
    "commands": [
      {
        "name": "findEvents",
        "description": "Search events based on criteria",
        "usage": "find events [type] in [location] on [date]"
      },
      {
        "name": "getEventDetails",
        "description": "Get detailed information about a specific event",
        "usage": "event details [event_id]"
      },
      {
        "name": "purchaseTicket",
        "description": "Purchase tickets for an event via cNFT",
        "usage": "buy ticket for [event]"
      },
      {
        "name": "syncToCalendar",
        "description": "Sync event to Google Calendar",
        "usage": "add to calendar [event]"
      },
      {
        "name": "getDirections",
        "description": "Get transport directions to event venue",
        "usage": "how do i get to [event]"
      },
      {
        "name": "addToWaitlist",
        "description": "Add user to event waitlist",
        "usage": "add to waitlist for [event]"
      },
      {
        "name": "checkPrices",
        "description": "Check current prices for an event across platforms",
        "usage": "check prices for [event]"
      }
    ],
    "tools": [
      {
        "name": "google_calendar",
        "description": "Sync events to Google Calendar with direct links",
        "required_env": ["GOOGLE_CALENDAR_API_KEY"]
      },
      {
        "name": "google_maps_routes",
        "description": "Calculate transport routes to event venues",
        "required_env": ["GOOGLE_MAPS_API_KEY"]
      },
      {
        "name": "crossmint_api",
        "description": "Mint cNFT tickets on Solana via CrossMint",
        "required_env": ["CROSSMINT_API_KEY", "CROSSMINT_COLLECTION_ID"]
      },
      {
        "name": "event_scraper",
        "description": "Scrape event data from various sources",
        "required_env": []
      },
      {
        "name": "solana_wallet",
        "description": "Detect and manage user wallet connections",
        "required_env": []
      }
    ]
  },
  "installation": {
    "instructions": "Run /skills install tixflow to add this skill to your agent",
    "requirements": [
      "OpenClaw agent",
      "Google Calendar API key (for calendar sync)",
      "Google Maps API key (for directions/routes)",
      "CrossMint API key + Collection ID (for cNFT minting)"
    ]
  },
  "configuration": {
    "default_location": "London",
    "default_event_types": ["concerts", "theater", "sports"],
    "demo_mode": false,
    "notification_preferences": {
      "price_drops": true,
      "event_changes": true,
      "waitlist_updates": true
    }
  },
  "capabilities": {
    "event_discovery": true,
    "price_monitoring": true,
    "calendar_integration": true,
    "directions_routes": true,
    "cnft_minting": true,
    "wallet_detection": true,
    "waitlist_management": true
  },
  "keywords": [
    "tixflow",
    "events",
    "tickets",
    "ticketing",
    "concerts",
    "calendar",
    "solana",
    "cnft",
    "nft",
    "maps",
    "directions"
  ]
}


path: src/index.ts
content: // Event Agent Skill for OpenClaw
// Helps users discover, purchase, and coordinate event tickets

import type { Skill } from "../../types";

export const skill: Skill = {
  id: "event-agent",
  name: "Event Agent",
  description: "AI agent for discovering, purchasing, and coordinating event tickets",
  version: "1.0.0",
  
  // Trigger phrases that activate this skill
  triggers: [
    "find event",
    "search concert",
    "buy ticket",
    "purchase ticket",
    "sync calendar",
    "event notification",
    "waitlist",
    "classical",
    "jazz",
    "music",
    "theater"
  ],
  
  // Actions the skill can perform
  actions: {
    // Find events based on user criteria
    findEvents: async (params: {
      type?: string;
      location?: string;
      date?: string;
      budget?: number;
    }) => {
      // Implementation would call event APIs
      // For now, return mock data
      return {
        events: [
          {
            id: "1",
            name: "Classical Symphony Orchestra",
            date: "2026-02-25",
            venue: "Royal Albert Hall, London",
            price: { min: 45, max: 120, currency: "GBP" },
            image: "https://example.com/image.jpg",
            available: true
          }
        ]
      };
    },
    
    // Get detailed info about an event
    getEventDetails: async (eventId: string) => {
      return {
        id: eventId,
        description: "An evening of classical masterpieces...",
        lineup: ["London Symphony Orchestra"],
        seatingChart: "https://example.com/seating.jpg",
        policies: {
          refundable: false,
          transferAllowed: true
        }
      };
    },
    
    // Purchase a ticket via KYD Protocol
    purchaseTicket: async (params: {
      eventId: string;
      quantity: number;
      walletAddress: string;
    }) => {
      // Would integrate with KYD Labs protocol
      // Returns transaction signature
      return {
        success: true,
        transactionId: "mock_tx_signature",
        ticketId: "mock_nft_mint"
      };
    },
    
    // Sync event to Google Calendar
    syncToCalendar: async (params: {
      eventId: string;
      userEmail: string;
    }) => {
      // Would integrate with Google Calendar API
      return {
        success: true,
        calendarEventId: "mock_calendar_event"
      };
    },
    
    // Add user to waitlist
    addToWaitlist: async (params: {
      eventId: string;
      userWallet: string;
      notificationMethod: "email" | "telegram" | "discord";
    }) => {
      return {
        success: true,
        waitlistPosition: 42
      };
    },
    
    // Monitor prices across platforms
    checkPrices: async (eventId: string) => {
      return {
        eventId,
        prices: [
          { platform: "Ticketmaster", price: 85, fees: 12 },
          { platform: "StubHub", price: 95, fees: 8 },
          { platform: "KYD Protocol", price: 75, fees: 0 }
        ]
      };
    }
  },
  
  // Response templates
  responses: {
    greeting: "Hi! I'm your Event Assistant. I can help you find events, book tickets, and sync them to your calendar. What would you like to do today?",
    
    eventFound: (count: number) => 
      `I found ${count} events that match your criteria!`,
    
    ticketPurchased: (eventName: string) =>
      `Great news! Your ticket for ${eventName} has been purchased and minted as an NFT!`,
    
    calendarSynced: (eventName: string) =>
      `I've added ${eventName} to your Google Calendar. You'll receive reminders before the event!`,
    
    waitlistAdded: (position: number) =>
      `You've been added to the waitlist! Current position: #${position}`
  }
};

export default skill;


Security scan verdicts — ClawScan: suspicious | static analysis:  | VirusTotal: clean | SkillSpector: suspicious (CRITICAL)