GeneralBots/botserver
2
1
Fork 0
Code Activity Actions 4

- Split into botui.

Browse source
This commit is contained in:
Rodrigo Rodriguez (Pragmatismo) 2025-12-02 21:09:43 -03:00
parent dd59e923f4
commit c4c9521dd9
212 changed files with 9034 additions and 52474 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3251
Cargo.lock generated
View file

File diff suppressed because it is too large Load diff

27
Cargo.toml
View file

@ -40,11 +40,9 @@ repository = "https://github.com/GeneralBots/BotServer"
[features]
# ===== DEFAULT FEATURE SET =====
default = ["ui-server", "console", "chat", "automation", "tasks", "drive", "llm", "redis-cache", "progress-bars", "directory"]
default = ["console", "chat", "automation", "tasks", "drive", "llm", "redis-cache", "progress-bars", "directory"]
# ===== UI FEATURES =====
desktop = ["dep:tauri", "dep:tauri-plugin-dialog", "dep:tauri-plugin-opener", "dep:trayicon", "dep:ksni", "ui-server"]
ui-server = []
console = ["dep:crossterm", "dep:ratatui", "monitoring"]
# ===== CORE INTEGRATIONS =====
@ -83,7 +81,7 @@ dynamic-db = ["dep:sqlx"]
# ===== META FEATURES (BUNDLES) =====
full = [
"ui-server", "desktop", "console",
"console",
"vectordb", "llm", "nvidia", "timeseries",
"email", "whatsapp", "instagram", "msteams",
"chat", "drive", "tasks", "calendar", "meet", "mail",
@ -94,8 +92,8 @@ full = [
communications = ["email", "whatsapp", "instagram", "msteams", "chat", "redis-cache"]
productivity = ["chat", "drive", "tasks", "calendar", "meet", "mail", "redis-cache"]
enterprise = ["compliance", "attendance", "directory", "llm", "vectordb", "monitoring", "timeseries"]
minimal = ["ui-server", "chat"]
lightweight = ["ui-server", "chat", "drive", "tasks"]
minimal = ["chat"]
lightweight = ["chat", "drive", "tasks"]
[dependencies]
# === CORE RUNTIME (Always Required) ===
@ -106,7 +104,7 @@ async-lock = "2.8.0"
async-stream = "0.3"
async-trait = "0.1"
axum = { version = "0.7.5", features = ["ws", "multipart", "macros"] }
axum-server = { version = "0.5", features = ["tls-rustls"] }
axum-server = { version = "0.7", features = ["tls-rustls"] }
base64 = "0.22"
bytes = "1.8"
chrono = { version = "0.4", features = ["serde"] }
@ -156,20 +154,8 @@ time = { version = "0.3", features = ["formatting", "parsing"] }
jsonwebtoken = "9.3"
tower-cookies = "0.10"
# === SYSTEM TRAY DEPENDENCIES ===
trayicon = { version = "0.2", optional = true }
ksni = { version = "0.2", optional = true }
webbrowser = "0.8"
hostname = "0.4"
local-ip-address = "0.6"
# === FEATURE-SPECIFIC DEPENDENCIES (Optional) ===
# Desktop UI (desktop feature)
tauri = { version = "2", features = ["unstable"], optional = true }
tauri-plugin-dialog = { version = "2", optional = true }
tauri-plugin-opener = { version = "2", optional = true }
# Email Integration (email feature)
imap = { version = "3.0.0-alpha.15", optional = true }
lettre = { version = "0.11", features = ["smtp-transport", "builder", "tokio1", "tokio1-native-tls"], optional = true }
@ -237,9 +223,6 @@ scopeguard = "1.2.0"
mockito = "1.7.0"
tempfile = "3"
[build-dependencies]
tauri-build = { version = "2", features = [] }
# === SECURITY AND CODE QUALITY CONFIGURATION ===
[lints.rust]
unused_imports = "warn"

392
ROADMAP.md
View file

@ -1,408 +1,16 @@
# General Bots Roadmap
## 🎯 Vision: The Free Open Source Enterprise AI Suite
**General Bots = Office Suite + Multi-LLM AI + Research Engine + Security AI + Autonomous Agents**
All of these capabilities, **completely FREE and open source**.
---
## 🏆 What We Have Today
### ✅ Core Platform (Production Ready)
| Feature | Status | Description |
|---------|--------|-------------|
| **Conversational AI** | ✅ Complete | Multi-turn dialogs with any LLM provider |
| **Multi-LLM Support** | ✅ Complete | Connect to any LLM API (local or cloud) |
| **Knowledge Base (RAG)** | ✅ Complete | Document indexing and semantic search |
| **BASIC + LLM Scripting** | ✅ Complete | Simple programming for everyone |
| **Tool/Function Calling** | ✅ Complete | MCP and custom tool support |
| **Multi-Channel Messaging** | ✅ Complete | WhatsApp, Telegram, Web, SMS |
| **Email Integration** | ✅ Complete | Send, receive, and process emails |
| **File Storage (.gbdrive)** | ✅ Complete | Cloud-native file management |
| **Document Processing** | ✅ Complete | PDF, Word, Excel, images |
| **Scheduling & Jobs** | ✅ Complete | Cron-based automation |
| **Web UI (HTMX)** | ✅ Complete | Modern, responsive interface |
| **REST API** | ✅ Complete | Full API for integrations |
| **Database (PostgreSQL)** | ✅ Complete | Enterprise-grade storage |
| **Vector Search (Qdrant)** | ✅ Complete | Semantic similarity search |
| **Template System** | ✅ Complete | Pre-built business applications |
### ✅ BASIC Keywords Implemented
| Category | Keywords |
|----------|----------|
| **Dialog** | TALK, HEAR, WAIT, PRINT |
| **Memory** | SET, GET, SET BOT MEMORY, GET BOT MEMORY |
| **AI** | LLM, SET CONTEXT, USE KB, USE TOOL |
| **Data** | SAVE, FIND, FILTER, AGGREGATE, JOIN, MERGE |
| **HTTP** | GET, POST, PUT, PATCH, DELETE HTTP, GRAPHQL, SOAP |
| **Files** | READ, WRITE, COPY, MOVE, UPLOAD, DOWNLOAD |
| **Email** | SEND MAIL, CREATE DRAFT |
| **Control** | FOR EACH, WHILE/WEND, IF/THEN/ELSE, SWITCH/CASE |
| **Procedures** | SUB, FUNCTION, CALL, RETURN |
| **Events** | ON, WEBHOOK, SET SCHEDULE |
| **Social** | POST TO (Instagram, Facebook, LinkedIn) |
### ✅ Templates Ready
| Template | Category | Purpose |
|----------|----------|---------|
| Employee Management | HR | Full employee CRUD |
| IT Helpdesk | IT | Ticket management |
| Sales Pipeline | CRM | Deal tracking |
| Contact Directory | CRM | Contact management |
| Default | Core | Starter template |
| Announcements | Comms | Company news |
---
## 🚀 What We're Building
### Phase 1: Marketing Automation (Q1 2025)
**Goal:** Complete inbound marketing and lead generation platform
| Feature | Target | Description |
|---------|--------|-------------|
| **Landing Pages** | 🔄 In Progress | CREATE SITE keyword for landing pages |
| **Lead Capture Forms** | 📋 Planned | Embedded forms with validation |
| **Lead Scoring** | 📋 Planned | AI-powered lead qualification |
| **Email Campaigns** | 📋 Planned | Drip campaigns with templates |
| **Social Media Posting** | 📋 Planned | POST TO Instagram, Facebook, LinkedIn |
| **Analytics Dashboard** | 📋 Planned | Conversion tracking and ROI |
| **A/B Testing** | 📋 Planned | Landing page optimization |
| **CRM Integration** | ✅ Complete | Pipeline and contact management |
#### Landing Page Plan (CREATE SITE Enhancement)
```basic
' Create a landing page with AI
CREATE SITE "promo-jan" WITH TEMPLATE "landing-page" USING PROMPT "
Create a landing page for our January promotion.
Product: Enterprise AI Suite
Offer: 30% discount for early adopters
CTA: Schedule a demo
"
' Capture leads from the landing page
ON FORM SUBMIT "promo-jan"
SAVE "leads.csv", name, email, phone, source
SEND MAIL email, "Welcome!", "Thank you for your interest..."
ADD TO CAMPAIGN email, "nurture-sequence"
END ON
```
### Phase 2: Social Media Integration (Q1 2025)
**Goal:** Unified social media management
| Feature | Target | Description |
|---------|--------|-------------|
| **POST TO Instagram** | 📋 Planned | Post images and stories |
| **POST TO Facebook** | 📋 Planned | Posts, stories, and pages |
| **POST TO LinkedIn** | 📋 Planned | Articles and updates |
| **POST TO Twitter/X** | 📋 Planned | Tweets and threads |
| **Content Calendar** | 📋 Planned | Schedule posts in advance |
| **Engagement Tracking** | 📋 Planned | Likes, comments, shares |
| **AI Content Generation** | 📋 Planned | LLM-powered post creation |
#### Social Media Keywords Plan
```basic
' Post to Instagram
POST TO INSTAGRAM image, "Check out our new feature! #AI #Automation"
' Post to multiple platforms
POST TO "instagram,facebook,linkedin" image, caption
' Schedule a post
POST TO INSTAGRAM AT "2025-02-01 10:00" image, caption
' Get engagement metrics
metrics = GET INSTAGRAM METRICS "post-id"
TALK "Likes: " + metrics.likes + ", Comments: " + metrics.comments
```
### Phase 3: Enterprise Office Suite (Q2 2025)
**Goal:** Complete office productivity replacement
| Feature | Target | Description |
|---------|--------|-------------|
| **Calendar Integration** | 🔄 In Progress | Event management |
| **Task Management** | 🔄 In Progress | To-do lists and projects |
| **Contact Management** | ✅ Complete | Directory and CRM |
| **Meeting Scheduling** | 📋 Planned | Booking and availability |
| **Video Calls** | 📋 Planned | WebRTC integration |
| **Real-time Collaboration** | 📋 Planned | Shared documents |
| **Spreadsheet Engine** | 📋 Planned | Excel-compatible |
| **Document Editor** | 📋 Planned | Word-compatible |
### Phase 4: AI Autonomy (Q2 2025)
**Goal:** Autonomous agent capabilities
| Feature | Target | Description |
|---------|--------|-------------|
| **Autonomous Agents** | 📋 Planned | Self-directing AI workflows |
| **Multi-Step Planning** | 📋 Planned | Complex task decomposition |
| **Self-Correcting Workflows** | 📋 Planned | Error recovery |
| **Memory Persistence** | 📋 Planned | Long-term memory |
| **Goal Decomposition** | 📋 Planned | Break down objectives |
### Phase 5: Security Suite (Q3 2025)
**Goal:** Enterprise security and compliance
| Feature | Target | Description |
|---------|--------|-------------|
| **AI Content Filtering** | 📋 Planned | Content moderation |
| **Threat Detection** | 📋 Planned | Security monitoring |
| **Compliance Automation** | 📋 Planned | GDPR, LGPD, SOC2 |
| **Audit Logging** | ✅ Complete | Full activity tracking |
| **Data Loss Prevention** | 📋 Planned | Sensitive data protection |
| **Access Control** | ✅ Complete | Role-based permissions |
### Phase 6: Research & Discovery (Q4 2025)
**Goal:** Deep research capabilities
| Feature | Target | Description |
|---------|--------|-------------|
| **Web Search Integration** | 📋 Planned | Real-time web search |
| **Citation Generation** | 📋 Planned | Academic references |
| **Source Verification** | 📋 Planned | Fact-checking |
| **Knowledge Graphs** | 📋 Planned | Entity relationships |
| **Academic Search** | 📋 Planned | Papers and research |
---
## 📁 Template Expansion Plan
### 50 Templates Target
| Category | Count | Status |
|----------|-------|--------|
| HR & People | 5 | 1 ✅ |
| IT & Support | 5 | 1 ✅ |
| CRM & Sales | 6 | 2 ✅ |
| Finance | 6 | 📋 Planned |
| Operations | 5 | 📋 Planned |
| Healthcare | 5 | 📋 Planned |
| Education | 4 | 📋 Planned |
| Real Estate | 4 | 📋 Planned |
| Events | 4 | 📋 Planned |
| Nonprofit | 5 | 📋 Planned |
| **Marketing** | 6 | 📋 Planned |
### New Marketing Templates
| # | Template | Folder | Key Files |
|---|----------|--------|-----------|
| 51 | Landing Page Builder | `marketing/landing-pages.gbai` | `start.bas`, `create-page.bas`, `capture-lead.bas` |
| 52 | Email Campaigns | `marketing/campaigns.gbai` | `start.bas`, `create-campaign.bas`, `send-campaign.bas` |
| 53 | Lead Nurturing | `marketing/nurturing.gbai` | `start.bas`, `add-to-sequence.bas`, `nurture-jobs.bas` |
| 54 | Social Media Manager | `marketing/social.gbai` | `start.bas`, `post-content.bas`, `schedule-post.bas` |
| 55 | Analytics Dashboard | `marketing/analytics.gbai` | `start.bas`, `track-conversion.bas`, `report.bas` |
| 56 | A/B Testing | `marketing/ab-testing.gbai` | `start.bas`, `create-test.bas`, `analyze-results.bas` |
---
## 🔧 Technical Improvements
### New Keywords Needed
#### Marketing & Social Media
| Keyword | Syntax | Description |
|---------|--------|-------------|
| `POST TO` | `POST TO "instagram" image, caption` | Post to social platforms |
| `GET METRICS` | `metrics = GET INSTAGRAM METRICS "id"` | Get engagement data |
| `CREATE LANDING PAGE` | `CREATE LANDING PAGE "name" WITH template` | Build landing pages |
| `ADD TO CAMPAIGN` | `ADD TO CAMPAIGN email, "campaign-name"` | Add to email sequence |
| `TRACK CONVERSION` | `TRACK CONVERSION "campaign", "event"` | Track marketing events |
#### Classic BASIC Functions (Priority)
| Function | Syntax | Description |
|----------|--------|-------------|
| `LEN` | `length = LEN(string)` | String length |
| `LEFT` | `result = LEFT(string, n)` | Left substring |
| `RIGHT` | `result = RIGHT(string, n)` | Right substring |
| `MID` | `result = MID(string, start, length)` | Middle substring |
| `TRIM` | `result = TRIM(string)` | Remove whitespace |
| `UCASE` | `result = UCASE(string)` | Uppercase |
| `LCASE` | `result = LCASE(string)` | Lowercase |
| `REPLACE` | `result = REPLACE(string, old, new)` | Replace substring |
| `SPLIT` | `array = SPLIT(string, delimiter)` | Split into array |
| `VAL` | `number = VAL(string)` | String to number |
| `STR` | `string = STR(number)` | Number to string |
| `ROUND` | `result = ROUND(number, decimals)` | Round number |
| `ABS` | `result = ABS(number)` | Absolute value |
| `NOW` | `datetime = NOW()` | Current date/time |
| `TODAY` | `date = TODAY()` | Current date |
| `DATEADD` | `date = DATEADD(date, n, "day")` | Add to date |
| `DATEDIFF` | `days = DATEDIFF(date1, date2, "day")` | Date difference |
| `YEAR` | `year = YEAR(date)` | Extract year |
| `MONTH` | `month = MONTH(date)` | Extract month |
| `DAY` | `day = DAY(date)` | Extract day |
| `ISNULL` | `result = ISNULL(value)` | Check if null |
| `ARRAY` | `arr = ARRAY(1, 2, 3)` | Create array |
| `UBOUND` | `size = UBOUND(array)` | Array size |
| `SORT` | `sorted = SORT(array)` | Sort array |
| `UNIQUE` | `distinct = UNIQUE(array)` | Remove duplicates |
| `MAX` | `maximum = MAX(array)` | Maximum value |
| `MIN` | `minimum = MIN(array)` | Minimum value |
#### Error Handling
| Keyword | Syntax | Description |
|---------|--------|-------------|
| `ON ERROR GOTO` | `ON ERROR GOTO handler` | Error handler |
| `TRY...CATCH` | `TRY ... CATCH e ... END TRY` | Structured errors |
| `THROW` | `THROW "error message"` | Raise error |
### Infrastructure
| Item | Status | Description |
|------|--------|-------------|
| Clustering | 📋 Planned | Multi-node deployment |
| Edge Deployment | 📋 Planned | Run on edge devices |
| Offline Mode | 📋 Planned | Local-only operation |
| Mobile App | 📋 Planned | Native mobile client |
| Desktop App | 🔄 Tauri | Desktop wrapper |
---
## 🤝 Community Goals
### Documentation
- [ ] Complete keyword reference (all keywords)
- [ ] Video tutorials for each template
- [ ] Interactive playground
- [ ] Cookbook with recipes
- [ ] Localization (10 languages)
### Ecosystem
- [ ] Plugin marketplace
- [ ] Template sharing hub
- [ ] Community templates
- [ ] Integration directory
- [ ] Certification program
---
## 💡 Why General Bots?
### The Problem
Enterprise software costs thousands per user per year:
- Office Suite: $10-60/user/month
- AI Assistant: $20-30/user/month
- Marketing Automation: $50-300/month
- CRM: $25-150/user/month
- **Total:** $100-500/user/month
For 100 users = **$120,000-600,000/year**
### The Solution
General Bots provides the same capabilities:
- **Cost:** $0 (open source)
- **Data ownership:** 100% yours
- **Customization:** Unlimited
- **AI provider:** Your choice
- **Deployment:** Anywhere
### The Difference
| Aspect | Enterprise SaaS | General Bots |
|--------|-----------------|--------------|
| Cost | $$$$$ | Free |
| Data | Their cloud | Your control |
| Vendor lock-in | High | None |
| Customization | Limited | Unlimited |
| AI Models | Fixed | Any provider |
| Open Source | No | Yes (AGPL) |
---
## 📊 Success Metrics
### 2025 Goals
| Metric | Target |
|--------|--------|
| GitHub Stars | 10,000 |
| Active Deployments | 5,000 |
| Community Templates | 100 |
| Contributors | 50 |
| Documentation Pages | 500 |
| Languages Supported | 10 |
---
## 🗺️ How to Contribute
### Code Contributions
1. Pick an item from this roadmap
2. Open an issue to discuss
3. Submit a PR with tests
4. Get reviewed and merged
### Non-Code Contributions
- Write documentation
- Create templates
- Report bugs
- Answer questions
- Translate docs
- Share on social media
### Priority Areas
1. **Marketing Keywords** - POST TO, tracking, campaigns
2. **Classic BASIC Functions** - LEN, LEFT, RIGHT, MID, etc.
3. **Templates** - Create business templates
4. **Documentation** - Write guides and tutorials
5. **Localization** - Translate to more languages
---
## 📅 Release Schedule
| Version | Date | Focus |
|---------|------|-------|
| v5.0 | Q1 2025 | Marketing automation, Social media |
| v5.1 | Q2 2025 | Office suite, Agent capabilities |
| v5.2 | Q3 2025 | Security features |
| v5.3 | Q4 2025 | Research features |
| v6.0 | Q1 2026 | Enterprise complete |
---
## 🌟 The Dream
**"Every organization, regardless of size or budget, deserves enterprise-grade AI capabilities."**
General Bots makes this possible by providing:
1. **Free software** - No licensing costs
2. **Open source** - Full transparency
3. **Self-hosted** - Your data, your servers
4. **Extensible** - Add what you need
5. **Community-driven** - Built together
Join us in democratizing enterprise AI.
---
*Last updated: 2025*
*"BASIC for AI, AI for Everyone"*

7
build.rs
View file

@ -1,7 +0,0 @@
fn main() {
// Only run tauri_build when the desktop feature is enabled
#[cfg(feature = "desktop")]
{
tauri_build::build()
}
}

18
docs/src/SUMMARY.md
View file

@ -93,6 +93,15 @@
- [SET BOT MEMORY](./chapter-06-gbdialog/keyword-set-bot-memory.md)
- [GET USER MEMORY](./chapter-06-gbdialog/keyword-get-user-memory.md)
- [SET USER MEMORY](./chapter-06-gbdialog/keyword-set-user-memory.md)
- [REMEMBER / RECALL](./chapter-06-gbdialog/keyword-remember.md)
- [BOOK / BOOK_MEETING](./chapter-06-gbdialog/keyword-book.md)
- [WEATHER / FORECAST](./chapter-06-gbdialog/keyword-weather.md)
- [A2A Protocol](./chapter-06-gbdialog/keyword-a2a.md)
- [ADD BOT](./chapter-06-gbdialog/keyword-add-bot.md)
- [ADD MEMBER](./chapter-06-gbdialog/keyword-add-member.md)
- [HUMAN APPROVAL](./chapter-06-gbdialog/keyword-human-approval.md)
- [MODEL ROUTE](./chapter-06-gbdialog/keyword-model-route.md)
- [SEND TEMPLATE](./chapter-06-gbdialog/keyword-send-template.md)
- [USE MODEL](./chapter-06-gbdialog/keyword-use-model.md)
- [DELEGATE TO BOT](./chapter-06-gbdialog/keyword-delegate-to-bot.md)
- [BOT REFLECTION](./chapter-06-gbdialog/keyword-bot-reflection.md)
@ -154,6 +163,10 @@
- [JOIN](./chapter-06-gbdialog/keyword-join.md)
- [PIVOT](./chapter-06-gbdialog/keyword-pivot.md)
- [GROUP BY](./chapter-06-gbdialog/keyword-group-by.md)
- [Media & Messaging](./chapter-06-gbdialog/keywords-media.md)
- [PLAY](./chapter-06-gbdialog/keyword-play.md)
- [QR CODE](./chapter-06-gbdialog/keyword-qrcode.md)
- [SEND SMS](./chapter-06-gbdialog/keyword-sms.md)
- [File Operations](./chapter-06-gbdialog/keywords-file.md)
- [READ](./chapter-06-gbdialog/keyword-read.md)
- [WRITE](./chapter-06-gbdialog/keyword-write.md)
@ -314,6 +327,11 @@
- [Channel Integrations](./appendix-external-services/channels.md)
- [Storage Services](./appendix-external-services/storage.md)
- [Directory Services](./appendix-external-services/directory.md)
- [Attendance Queue](./appendix-external-services/attendance-queue.md)
- [Time-Series Database](./appendix-external-services/timeseries.md)
- [NVIDIA GPU](./appendix-external-services/nvidia.md)
- [Multimodal](./appendix-external-services/multimodal.md)
- [Console (XtreeUI)](./appendix-external-services/console.md)
- [Appendix C: Environment Variables](./appendix-env-vars/README.md)

78
docs/src/appendix-external-services/attendance-queue.md Normal file
View file

@ -0,0 +1,78 @@
# Attendance Queue Module
Human-attendant queue management for hybrid bot/human support workflows.
## Overview
The attendance queue module manages handoffs from bot to human agents, tracking conversation queues, attendant availability, and real-time assignment.
## Configuration
Create `attendant.csv` in your bot's `.gbai` folder:
```csv
id,name,channel,preferences
att-001,John Smith,whatsapp,sales
att-002,Jane Doe,web,support
att-003,Bob Wilson,all,technical
```
## Queue Status
| Status | Description |
|--------|-------------|
| `waiting` | User waiting for attendant |
| `assigned` | Attendant assigned, not yet active |
| `active` | Conversation in progress |
| `resolved` | Conversation completed |
| `abandoned` | User left before assignment |
## Attendant Status
| Status | Description |
|--------|-------------|
| `online` | Available for new conversations |
| `busy` | Currently handling conversations |
| `away` | Temporarily unavailable |
| `offline` | Not working |
## REST API Endpoints
### GET /api/queue
List conversations in queue.
### POST /api/queue/assign
Assign conversation to attendant.
```json
{
"session_id": "uuid",
"attendant_id": "uuid"
}
```
### POST /api/queue/transfer
Transfer conversation between attendants.
```json
{
"session_id": "uuid",
"from_attendant_id": "uuid",
"to_attendant_id": "uuid",
"reason": "Specialist needed"
}
```
### GET /api/attendants
List all attendants with stats.
## BASIC Keywords
```basic
TRANSFER TO HUMAN "sales"
TRANSFER TO HUMAN "support", "high"
```
## See Also
- [Human Approval](../chapter-06-gbdialog/keyword-human-approval.md)

114
docs/src/appendix-external-services/console.md Normal file
View file

@ -0,0 +1,114 @@
# Console Module (XtreeUI)
Terminal-based admin interface for managing General Bots instances.
## Overview
XtreeUI is a TUI (Terminal User Interface) for administering bots directly from the command line. It provides file browsing, log viewing, chat testing, and status monitoring in a single terminal window.
## Feature Flag
Enabled via Cargo feature:
```toml
[features]
console = []
```
## Panels
| Panel | Key | Description |
|-------|-----|-------------|
| File Tree | `1` | Browse bot files and packages |
| Editor | `2` | View/edit configuration files |
| Status | `3` | System status and metrics |
| Logs | `4` | Real-time log viewer |
| Chat | `5` | Test bot conversations |
## Keyboard Navigation
| Key | Action |
|-----|--------|
| `1-5` | Switch between panels |
| `Tab` | Cycle panels |
| `↑/↓` | Navigate within panel |
| `Enter` | Select/open item |
| `q` | Quit console |
| `?` | Show help |
## Components
### File Tree
Browse `.gbai` folder structure:
- View packages (.gbkb, .gbdialog, .gbtheme)
- Open config.csv for editing
- Navigate bot resources
### Status Panel
Real-time system metrics:
- CPU/memory usage
- Active connections
- Bot status
- Database connectivity
### Log Panel
Live log streaming with filtering:
- Error highlighting
- Log level filtering
- Search functionality
### Chat Panel
Interactive bot testing:
- Send messages to bot
- View responses
- Debug conversation flow
### Editor
Basic file editing:
- Syntax highlighting
- Save/reload files
- Config validation
## Starting the Console
```bash
./botserver --console
```
Or programmatically:
```rust
let mut ui = XtreeUI::new();
ui.set_app_state(app_state);
ui.start_ui()?;
```
## Progress Channel
Monitor background tasks:
```rust
let (tx, rx) = tokio::sync::mpsc::channel(100);
ui.set_progress_channel(rx);
// Send progress updates
tx.send(ProgressUpdate::new("Loading KB...", 50)).await;
```
## Use Cases
- Server administration without web UI
- SSH-based remote management
- Development and debugging
- Headless server deployments
- Quick configuration changes
## See Also
- [Building from Source](../chapter-07-gbapp/building.md)
- [Bot Configuration](../chapter-08-config/README.md)

143
docs/src/appendix-external-services/multimodal.md Normal file
View file

@ -0,0 +1,143 @@
# Multimodal Module
Image, video, and audio generation with vision/captioning capabilities.
## Overview
The multimodal module connects to BotModels server for AI-powered media generation and analysis.
## BASIC Keywords
| Keyword | Purpose |
|---------|---------|
| `IMAGE` | Generate image from text prompt |
| `VIDEO` | Generate video from text prompt |
| `AUDIO` | Generate speech audio from text |
| `SEE` | Describe/caption an image or video |
## IMAGE
Generate an image from a text prompt:
```basic
url = IMAGE "A sunset over mountains with a lake"
TALK "Here's your image: " + url
```
Timeout: 300 seconds (5 minutes)
## VIDEO
Generate a video from a text prompt:
```basic
url = VIDEO "A cat playing with a ball of yarn"
TALK "Here's your video: " + url
```
Timeout: 600 seconds (10 minutes)
## AUDIO
Generate speech audio from text:
```basic
url = AUDIO "Welcome to our service. How can I help you today?"
PLAY url
```
## SEE
Get a description of an image or video:
```basic
description = SEE "path/to/image.jpg"
TALK "I see: " + description
```
## Configuration
Add to `config.csv`:
```csv
botmodels-enabled,true
botmodels-host,localhost
botmodels-port,5000
botmodels-api-key,your-api-key
botmodels-use-https,false
```
### Image Generation Config
```csv
botmodels-image-model,stable-diffusion
botmodels-image-steps,20
botmodels-image-width,512
botmodels-image-height,512
```
### Video Generation Config
```csv
botmodels-video-model,text2video
botmodels-video-frames,16
botmodels-video-fps,8
```
## BotModels Client
Rust API for direct integration:
```rust
let client = BotModelsClient::from_state(&state, &bot_id);
if client.is_enabled() {
let image_url = client.generate_image("A beautiful garden").await?;
let description = client.describe_image("path/to/photo.jpg").await?;
}
```
### Available Methods
| Method | Description |
|--------|-------------|
| `generate_image(prompt)` | Create image from text |
| `generate_video(prompt)` | Create video from text |
| `generate_audio(text)` | Create speech audio |
| `describe_image(path)` | Get image caption |
| `describe_video(path)` | Get video description |
| `speech_to_text(audio_path)` | Transcribe audio |
| `health_check()` | Check BotModels server status |
## Response Structures
### GenerationResponse
```json
{
"status": "success",
"file_path": "/path/to/generated/file.png",
"generation_time": 12.5,
"error": null
}
```
### DescribeResponse
```json
{
"description": "A golden retriever playing fetch in a park",
"confidence": 0.92
}
```
## Requirements
- BotModels server running (separate service)
- GPU recommended for generation tasks
- Sufficient disk space for generated media
## See Also
- [NVIDIA Module](./nvidia.md) - GPU monitoring
- [PLAY Keyword](../chapter-06-gbdialog/keyword-play.md) - Play generated audio

76
docs/src/appendix-external-services/nvidia.md Normal file
View file

@ -0,0 +1,76 @@
# NVIDIA GPU Module
System monitoring for NVIDIA GPU utilization and performance metrics.
## Overview
This module provides GPU monitoring capabilities when NVIDIA hardware is available, useful for tracking resource usage during LLM inference and multimodal generation tasks.
## Feature Flag
Enabled via Cargo feature:
```toml
[features]
nvidia = []
```
## Functions
### has_nvidia_gpu()
Check if NVIDIA GPU is available:
```rust
if nvidia::has_nvidia_gpu() {
// GPU acceleration available
}
```
Returns `true` if `nvidia-smi` command succeeds.
### get_gpu_utilization()
Get current GPU and memory utilization:
```rust
let util = nvidia::get_gpu_utilization()?;
let gpu_percent = util.get("gpu"); // GPU compute utilization %
let mem_percent = util.get("memory"); // GPU memory utilization %
```
### get_system_metrics()
Get combined CPU and GPU metrics:
```rust
let metrics = nvidia::get_system_metrics()?;
println!("CPU: {}%", metrics.cpu_usage);
if let Some(gpu) = metrics.gpu_usage {
println!("GPU: {}%", gpu);
}
```
## SystemMetrics Struct
| Field | Type | Description |
|-------|------|-------------|
| `cpu_usage` | `f32` | CPU utilization percentage |
| `gpu_usage` | `Option<f32>` | GPU utilization (None if no NVIDIA GPU) |
## Requirements
- NVIDIA GPU with driver installed
- `nvidia-smi` command available in PATH
## Use Cases
- Monitor GPU during image/video generation
- Track resource usage for LLM inference
- Capacity planning for bot deployments
- Performance dashboards
## See Also
- [Multimodal Module](./multimodal.md)
- [Time-Series Database](./timeseries.md) - Store GPU metrics over time

85
docs/src/appendix-external-services/timeseries.md Normal file
View file

@ -0,0 +1,85 @@
# Time-Series Database Module
InfluxDB 3 integration for metrics, analytics, and operational data.
## Overview
High-performance time-series storage supporting 2.5M+ points/sec ingestion with async batching.
## Configuration
Add to `config.csv`:
```csv
influxdb-url,http://localhost:8086
influxdb-token,your-token
influxdb-org,pragmatismo
influxdb-bucket,metrics
```
Or environment variables:
```bash
INFLUXDB_URL=http://localhost:8086
INFLUXDB_TOKEN=your-token
INFLUXDB_ORG=pragmatismo
INFLUXDB_BUCKET=metrics
```
## Metric Points
Structure:
| Field | Description |
|-------|-------------|
| `measurement` | Metric name (e.g., "messages", "response_time") |
| `tags` | Indexed key-value pairs for filtering |
| `fields` | Actual metric values |
| `timestamp` | When the metric was recorded |
## Built-in Metrics
| Measurement | Tags | Fields |
|-------------|------|--------|
| `messages` | bot, channel, user | count |
| `response_time` | bot, endpoint | duration_ms |
| `llm_tokens` | bot, model, type | input, output, total |
| `kb_queries` | bot, collection | count, latency_ms |
| `errors` | bot, type, severity | count |
## Usage in Rust
```rust
let client = TimeSeriesClient::new(config).await?;
client.write_point(
MetricPoint::new("messages")
.tag("bot", "sales-bot")
.tag("channel", "whatsapp")
.field_i64("count", 1)
).await?;
```
## Querying
REST endpoint for analytics:
```
GET /api/analytics/timeseries/messages?range=24h
GET /api/analytics/timeseries/response_time?range=7d
```
## Installation
The timeseries_db component is installed via package manager:
```bash
gb install timeseries_db
```
Ports: 8086 (HTTP API), 8083 (RPC)
## See Also
- [Analytics Module](../chapter-04-gbui/apps/analytics.md)
- [Observability Setup](./observability.md)

319
docs/src/appendix-external-services/weather.md
View file

@ -1 +1,318 @@
# Weather API
# Weather API Integration
The `WEATHER` and `FORECAST` keywords provide real-time weather information and multi-day forecasts using the OpenWeatherMap API.
## Keywords Overview
| Keyword | Purpose |
|---------|---------|
| `WEATHER` | Get current weather conditions for a location |
| `FORECAST` | Get extended weather forecast for multiple days |
## WEATHER
Retrieves current weather conditions for a specified location.
### Syntax
```basic
result = WEATHER location
```
### Parameters
| Parameter | Type | Description |
|-----------|------|-------------|
| `location` | String | City name, optionally with country code (e.g., "London" or "London,UK") |
### Return Value
Returns a formatted string containing:
- Temperature (current and feels-like)
- Weather conditions description
- Humidity percentage
- Wind speed and direction
- Visibility
- Atmospheric pressure
### Example
```basic
' Get current weather for London
weather = WEATHER "London"
TALK weather
' Output:
' Current weather in London:
' 🌡️ Temperature: 15.2°C (feels like 14.5°C)
' ☁️ Conditions: Partly cloudy
' 💧 Humidity: 65%
' 💨 Wind: 3.5 m/s NE
' 🔍 Visibility: 10.0 km
' 📊 Pressure: 1013 hPa
```
## FORECAST
Retrieves an extended weather forecast for multiple days.
### Syntax
```basic
result = FORECAST location, days
```
### Parameters
| Parameter | Type | Description |
|-----------|------|-------------|
| `location` | String | City name, optionally with country code |
| `days` | Integer | Number of days to forecast (1-5, default: 5) |
### Example
```basic
' Get 5-day forecast for Paris
forecast = FORECAST "Paris,FR", 5
TALK forecast
' Output:
' Weather forecast for Paris:
'
' 📅 2024-03-15
' 🌡️ High: 18.5°C, Low: 12.3°C
' ☁️ Scattered clouds
' ☔ Rain chance: 20%
'
' 📅 2024-03-16
' 🌡️ High: 20.1°C, Low: 13.0°C
' ☁️ Clear sky
' ☔ Rain chance: 5%
' ...
```
## Complete Example: Weather Bot
```basic
' weather-assistant.bas
' A conversational weather assistant
TALK "Hello! I can help you with weather information."
TALK "Which city would you like to know about?"
HEAR city
TALK "Would you like the current weather or a forecast?"
HEAR choice
IF INSTR(LOWER(choice), "forecast") > 0 THEN
TALK "How many days? (1-5)"
HEAR days
IF NOT IS_NUMERIC(days) THEN
days = 5
END IF
result = FORECAST city, days
TALK result
ELSE
result = WEATHER city
TALK result
END IF
TALK "Is there another city you'd like to check?"
```
## Weather-Based Automation
```basic
' weather-alert.bas
' Send alerts based on weather conditions
cities = ["New York", "London", "Tokyo", "Sydney"]
FOR EACH city IN cities
weather = WEATHER city
' Check for extreme conditions
IF INSTR(weather, "storm") > 0 OR INSTR(weather, "heavy rain") > 0 THEN
SEND MAIL "alerts@company.com", "Weather Alert: " + city, weather
END IF
NEXT
```
## Daily Weather Report
```basic
' daily-weather.bas
' Generate a daily weather report for multiple locations
locations = ["San Francisco,US", "Austin,US", "Seattle,US"]
report = "☀️ Daily Weather Report\n\n"
FOR EACH loc IN locations
weather = WEATHER loc
report = report + weather + "\n\n---\n\n"
NEXT
' Send the compiled report
SEND MAIL "team@company.com", "Daily Weather Update", report
```
## Travel Planning Assistant
```basic
' travel-weather.bas
' Help users plan travel based on weather
TALK "Where are you planning to travel?"
HEAR destination
TALK "When are you planning to go? (Please provide a date)"
HEAR travel_date
' Get forecast for destination
forecast = FORECAST destination, 5
TALK "Here's the weather forecast for " + destination + ":"
TALK forecast
TALK "Based on the forecast, would you like packing suggestions?"
HEAR wants_suggestions
IF LOWER(wants_suggestions) = "yes" THEN
weather = WEATHER destination
IF INSTR(weather, "rain") > 0 THEN
TALK "🌂 Don't forget to pack an umbrella and rain jacket!"
END IF
IF INSTR(weather, "Temperature: 2") > 0 OR INSTR(weather, "Temperature: 3") > 0 THEN
TALK "🩳 It's warm! Pack light clothing and sunscreen."
ELSE IF INSTR(weather, "Temperature: 0") > 0 OR INSTR(weather, "Temperature: 1") > 0 THEN
TALK "🧥 It's cool. Bring a light jacket."
ELSE
TALK "🧣 It's cold! Pack warm layers and a coat."
END IF
END IF
```
## Weather Data Structure
The `WeatherData` object returned internally contains:
| Field | Type | Description |
|-------|------|-------------|
| `location` | String | Resolved location name |
| `temperature` | Float | Current temperature in Celsius |
| `temperature_unit` | String | Temperature unit (°C) |
| `description` | String | Weather condition description |
| `humidity` | Integer | Humidity percentage (0-100) |
| `wind_speed` | Float | Wind speed in m/s |
| `wind_direction` | String | Compass direction (N, NE, E, etc.) |
| `feels_like` | Float | "Feels like" temperature |
| `pressure` | Integer | Atmospheric pressure in hPa |
| `visibility` | Float | Visibility in kilometers |
| `uv_index` | Float (optional) | UV index if available |
| `forecast` | Array | Forecast data (for FORECAST keyword) |
## Forecast Day Structure
Each forecast day contains:
| Field | Type | Description |
|-------|------|-------------|
| `date` | String | Date in YYYY-MM-DD format |
| `temp_high` | Float | Maximum temperature |
| `temp_low` | Float | Minimum temperature |
| `description` | String | Weather conditions |
| `rain_chance` | Integer | Probability of precipitation (0-100%) |
## Configuration
To use the weather keywords, configure your OpenWeatherMap API key in `config.csv`:
| Key | Description | Required |
|-----|-------------|----------|
| `weather-api-key` | OpenWeatherMap API key | Yes |
### Getting an API Key
1. Visit [OpenWeatherMap](https://openweathermap.org/api)
2. Create a free account
3. Navigate to "API Keys" in your dashboard
4. Generate a new API key
5. Add to your bot's `config.csv`:
```csv
weather-api-key,your-api-key-here
```
## Wind Direction Compass
Wind direction is converted from degrees to compass directions:
| Degrees | Direction |
|---------|-----------|
| 0° | N (North) |
| 45° | NE (Northeast) |
| 90° | E (East) |
| 135° | SE (Southeast) |
| 180° | S (South) |
| 225° | SW (Southwest) |
| 270° | W (West) |
| 315° | NW (Northwest) |
## Error Handling
```basic
' Handle weather API errors gracefully
ON ERROR GOTO weather_error
weather = WEATHER "Unknown City XYZ"
TALK weather
END
weather_error:
TALK "Sorry, I couldn't get weather information for that location."
TALK "Please check the city name and try again."
END
```
## Rate Limits
The OpenWeatherMap free tier includes:
- 60 calls per minute
- 1,000,000 calls per month
For higher limits, consider upgrading to a paid plan.
## Best Practices
1. **Use country codes**: For accuracy, include country codes (e.g., "Paris,FR" instead of just "Paris").
2. **Cache results**: Weather data doesn't change frequently—consider caching results for 10-15 minutes.
3. **Handle timeouts**: Weather API calls have a 10-second timeout. Handle failures gracefully.
4. **Validate locations**: Check if the location is valid before making API calls.
5. **Localization**: Consider user preferences for temperature units (Celsius vs Fahrenheit).
## Fallback Behavior
If the OpenWeatherMap API is unavailable, the system will:
1. Log the error
2. Attempt a fallback weather service (if configured)
3. Return a user-friendly error message
## Related Keywords
- [GET](../chapter-06-gbdialog/keyword-get.md) - Make custom HTTP requests to weather APIs
- [SET SCHEDULE](../chapter-06-gbdialog/keyword-set-schedule.md) - Schedule regular weather checks
- [SEND MAIL](../chapter-06-gbdialog/keyword-send-mail.md) - Send weather alerts via email
- [SEND SMS](../chapter-06-gbdialog/keyword-sms.md) - Send weather alerts via SMS
## See Also
- [OpenWeatherMap API Documentation](https://openweathermap.org/api)
- [API Tool Generator](../chapter-06-gbdialog/keyword-use-tool.md) - Create custom weather integrations

170
docs/src/chapter-02/gbdrive.md
View file

@ -18,6 +18,124 @@ Additionally, each bot has space for user-uploaded files, generated content, and
The system maintains this structure automatically when bots are deployed or updated, ensuring that the storage state reflects the current bot configuration without manual intervention.
## .gbusers - Per-User Storage
The `.gbusers` folder within `.gbdrive` provides isolated storage space for each user interacting with the bot. This enables personalized document storage, user-specific settings, and application data that persists across sessions.
### User Folder Structure
User folders are identified by the user's email address or phone number:
```
mybot.gbai/
mybot.gbdrive/
users/
john@example.com/ # User identified by email
papers/
current/ # Active/working documents
untitled-1.md
meeting-notes.md
named/ # Saved/named documents
quarterly-report/
document.md
attachments/
project-proposal/
document.md
uploads/ # User file uploads
exports/ # Generated exports (PDF, DOCX, etc.)
settings/ # User preferences
preferences.json
+5511999887766/ # User identified by phone number
papers/
current/
named/
uploads/
```
### User Identifier Format
Users are identified by their primary contact method:
- **Email**: `john@example.com`, `maria@company.com.br`
- **Phone**: `+5511999887766`, `+1234567890` (E.164 format)
The identifier is sanitized for filesystem compatibility while remaining human-readable.
### Paper Document Storage
The Paper application stores user documents in the `papers/` directory:
- **`papers/current/`**: Working documents that are actively being edited. These may be auto-saved drafts or recently accessed files.
- **`papers/named/`**: Documents that have been explicitly saved with a name. Each named document gets its own folder to support attachments and metadata.
Example document structure:
```
papers/
current/
untitled-1.md # Auto-saved draft
untitled-2.md # Another working document
named/
meeting-notes-2024/
document.md # The main document content
metadata.json # Title, created_at, updated_at, etc.
attachments/ # Embedded images or files
image-001.png
research-paper/
document.md
metadata.json
```
### Accessing User Storage from BASIC
BASIC scripts can access user storage using the `USER DRIVE` keyword:
```basic
' Read a user's document
content = READ USER DRIVE "papers/current/notes.md"
' Write to user's storage
SAVE USER DRIVE "papers/named/report/document.md", report_content
' List user's papers
papers = LIST USER DRIVE "papers/named/"
' Delete a user document
DELETE USER DRIVE "papers/current/draft.md"
```
### User Storage API
The REST API provides endpoints for user storage operations:
```
GET /api/drive/user/list?path=papers/current/
POST /api/drive/user/read
{ "path": "papers/named/report/document.md" }
POST /api/drive/user/write
{ "path": "papers/current/notes.md", "content": "..." }
POST /api/drive/user/delete
{ "path": "papers/current/draft.md" }
```
All user storage API calls require authentication and automatically scope operations to the authenticated user's folder.
### Storage Quotas
Each user has configurable storage limits:
| Setting | Default | Description |
|---------|---------|-------------|
| `user-storage-quota` | 100MB | Maximum total storage per user |
| `user-file-limit` | 5MB | Maximum single file size |
| `user-file-count` | 500 | Maximum number of files |
Configure in `config.csv`:
```csv
user-storage-quota,104857600
user-file-limit,5242880
user-file-count,500
```
## Working with Files
File operations in General Bots happen through several interfaces depending on your needs. The BASIC scripting language provides keywords for reading file content directly into scripts, enabling bots to process documents, load data, or access configuration dynamically.
@ -36,13 +154,26 @@ Theme assets including CSS files and images are served from storage, with approp
Tool scripts in .gbdialog folders are loaded from storage, parsed, and made available for execution. The compilation system tracks dependencies and rebuilds as needed when source files change.
### Paper Application Integration
The Paper document editor automatically saves to the user's `.gbusers` folder:
1. **Auto-save**: Every 30 seconds, working documents are saved to `papers/current/`
2. **Explicit save**: When users click "Save", documents move to `papers/named/{document-name}/`
3. **Export**: Generated exports (PDF, DOCX) are saved to `exports/` and offered for download
4. **AI-generated content**: AI responses can be inserted into documents and saved automatically
## Access Control
Different files require different access levels, and the storage system enforces appropriate controls. Public files can be accessed without authentication, suitable for shared resources or publicly downloadable content. Authenticated access requires valid user credentials, protecting user-specific uploads and downloads.
Different files require different access levels, and the storage system enforces appropriate controls:
Bot-internal files remain accessible only to the bot system itself, protecting scripts and configuration from unauthorized access. Administrative files containing sensitive configuration require elevated privileges to access or modify.
- **Public files**: Accessible without authentication, suitable for shared resources
- **Authenticated access**: Requires valid user credentials, protects user-specific content
- **User-scoped access**: Users can only access their own `.gbusers` folder content
- **Bot-internal files**: Accessible only to the bot system itself
- **Administrative files**: Require elevated privileges to access or modify
These access levels work in conjunction with the broader authentication and authorization system, ensuring that file access respects organizational security policies.
User storage in `.gbusers` is strictly isolated—users cannot access other users' folders through any API or BASIC keyword.
## Storage Backend Options
@ -52,6 +183,37 @@ For development and testing, local filesystem storage offers simplicity and easy
Backend selection happens through configuration, and the rest of the system interacts with storage through a consistent interface regardless of which backend is active. This abstraction allows deployments to change storage strategies without modifying bot code.
## Directory Structure Reference
Complete `.gbdrive` structure with all components:
```
mybot.gbai/
mybot.gbdrive/
dialogs/ # Compiled dialog scripts cache
kb/ # Knowledge base index data
cache/ # Temporary cache files
exports/ # Bot-level exports
uploads/ # Bot-level uploads
users/ # Per-user storage (.gbusers)
user@email.com/
papers/
current/ # Working documents
named/ # Saved documents
uploads/ # User uploads
exports/ # User exports
settings/ # User preferences
+1234567890/
papers/
uploads/
exports/
settings/
```
## Summary
The .gbdrive storage system provides the foundation for all file-based operations in General Bots. Through S3-compatible object storage, organized bucket structures, automatic synchronization, and deep integration with other components, it delivers reliable file management that supports both development workflows and production operation. Understanding how storage works helps you organize bot content effectively and leverage the automatic capabilities the system provides.
The .gbdrive storage system provides the foundation for all file-based operations in General Bots. Through S3-compatible object storage, organized bucket structures, automatic synchronization, and deep integration with other components, it delivers reliable file management that supports both development workflows and production operation.
The `.gbusers` folder structure enables personalized storage for each user, supporting applications like Paper that require persistent document storage. By organizing user data under their email or phone identifier, the system maintains clear separation while enabling powerful per-user features.
Understanding how storage works helps you organize bot content effectively and leverage the automatic capabilities the system provides.

73
docs/src/chapter-04-gbui/apps/paper.md
View file

@ -410,6 +410,79 @@ Paper automatically saves versions of your document:
---
## User Storage
Paper documents are stored in your personal `.gbusers` folder within the bot's `.gbdrive` storage. This ensures your documents are private and accessible only to you.
### Storage Structure
```
mybot.gbai/
mybot.gbdrive/
users/
your.email@example.com/ # Your user folder
papers/
current/ # Working documents (auto-saved)
untitled-1.md
meeting-notes.md
named/ # Saved documents
quarterly-report/
document.md
metadata.json
project-proposal/
document.md
metadata.json
exports/ # Exported files (PDF, DOCX, etc.)
quarterly-report.pdf
project-proposal.docx
```
### Storage Types
| Type | Location | Description |
|------|----------|-------------|
| **Current** | `papers/current/` | Auto-saved working documents. These are drafts being actively edited. |
| **Named** | `papers/named/{name}/` | Explicitly saved documents with metadata. Each gets its own folder. |
| **Exports** | `exports/` | Generated export files (PDF, Word, HTML, etc.) |
### Auto-Save Behavior
Paper auto-saves your work every 30 seconds to `papers/current/`. When you explicitly save with a title:
1. Document moves from `current/` to `named/{title}/`
2. Metadata file is created with title, timestamps, and word count
3. Original draft in `current/` is removed
### Accessing Your Documents
Your documents follow you across sessions and devices. As long as you're logged in with the same email or phone number, you'll see all your documents.
**From the UI:**
- Documents appear in the sidebar automatically
- Search finds documents by title
- Recent documents shown first
**From BASIC scripts:**
```basic
' Read your document
content = READ USER DRIVE "papers/named/my-report/document.md"
' List your papers
papers = LIST USER DRIVE "papers/named/"
```
### Storage Limits
Default limits per user (configurable by administrator):
| Setting | Default | Description |
|---------|---------|-------------|
| Total storage | 100 MB | Maximum storage per user |
| File size | 5 MB | Maximum single document |
| File count | 500 | Maximum number of documents |
---
## BASIC Integration
Control Paper from your bot dialogs:

73
docs/src/chapter-06-gbdialog/keyword-a2a.md Normal file
View file

@ -0,0 +1,73 @@
# A2A Protocol Keywords
Agent-to-Agent (A2A) protocol enables communication between multiple bots in a session.
## Keywords
| Keyword | Purpose |
|---------|---------|
| `SEND TO BOT` | Send message to specific bot |
| `BROADCAST` | Send message to all bots |
| `COLLABORATE WITH` | Request collaboration on a task |
| `WAIT FOR BOT` | Wait for response from another bot |
| `DELEGATE CONVERSATION` | Hand off conversation to another bot |
| `GET A2A MESSAGES` | Retrieve pending messages |
## SEND TO BOT
```basic
result = SEND TO BOT "assistant-bot", "Please help with this query"
```
## BROADCAST
```basic
BROADCAST "New customer request received"
```
## COLLABORATE WITH
```basic
bots = ["research-bot", "writing-bot"]
result = COLLABORATE WITH bots, "Write a market analysis report"
```
## WAIT FOR BOT
```basic
SEND TO BOT "analysis-bot", "Analyze this data"
response = WAIT FOR BOT "analysis-bot", 30 ' 30 second timeout
```
## DELEGATE CONVERSATION
```basic
DELEGATE CONVERSATION TO "support-bot"
```
## Message Types
| Type | Description |
|------|-------------|
| `Request` | Request action from another agent |
| `Response` | Response to a request |
| `Broadcast` | Message to all agents |
| `Delegate` | Hand off conversation |
| `Collaborate` | Multi-agent collaboration |
| `Ack` | Acknowledgment |
| `Error` | Error response |
## Configuration
Add to `config.csv`:
```csv
a2a-enabled,true
a2a-timeout,30
a2a-max-hops,5
```
## See Also
- [Multi-Agent Keywords](./keywords-multi-agent.md)
- [DELEGATE TO BOT](./keyword-delegate-to-bot.md)

56
docs/src/chapter-06-gbdialog/keyword-add-bot.md Normal file
View file

@ -0,0 +1,56 @@
# ADD BOT Keywords
Dynamically add bots to a session with specific triggers, tools, or schedules.
## Keywords
| Keyword | Purpose |
|---------|---------|
| `ADD BOT ... WITH TRIGGER` | Add bot activated by keyword |
| `ADD BOT ... WITH TOOLS` | Add bot with specific tools |
| `ADD BOT ... WITH SCHEDULE` | Add bot on a schedule |
| `REMOVE BOT` | Remove bot from session |
## ADD BOT WITH TRIGGER
```basic
ADD BOT "sales-bot" WITH TRIGGER "pricing"
```
When user mentions "pricing", sales-bot activates.
## ADD BOT WITH TOOLS
```basic
ADD BOT "data-bot" WITH TOOLS "database,spreadsheet,charts"
```
## ADD BOT WITH SCHEDULE
```basic
ADD BOT "report-bot" WITH SCHEDULE "0 9 * * MON"
```
Adds bot that runs every Monday at 9 AM (cron format).
## REMOVE BOT
```basic
REMOVE BOT "sales-bot"
```
## Example: Multi-Bot Setup
```basic
' Set up specialized bots for different topics
ADD BOT "orders-bot" WITH TRIGGER "order status, shipping, delivery"
ADD BOT "support-bot" WITH TRIGGER "help, problem, issue, broken"
ADD BOT "sales-bot" WITH TRIGGER "pricing, quote, purchase"
TALK "I've set up our specialist team. Just ask about orders, support, or sales!"
```
## See Also
- [A2A Protocol](./keyword-a2a.md)
- [DELEGATE TO BOT](./keyword-delegate-to-bot.md)

68
docs/src/chapter-06-gbdialog/keyword-add-member.md Normal file
View file

@ -0,0 +1,68 @@
# ADD MEMBER Keywords
Manage team and group membership within bots.
## Keywords
| Keyword | Purpose |
|---------|---------|
| `ADD_MEMBER` | Add user to a group with role |
| `REMOVE_MEMBER` | Remove user from group |
| `CREATE_TEAM` | Create a new team |
| `LIST_MEMBERS` | List group members |
## ADD_MEMBER
```basic
result = ADD_MEMBER group_id, user_email, role
```
### Parameters
| Parameter | Type | Description |
|-----------|------|-------------|
| `group_id` | String | Team or group identifier |
| `user_email` | String | Email of user to add |
| `role` | String | Role: "admin", "member", "viewer" |
### Example
```basic
result = ADD_MEMBER "team-sales", "john@company.com", "member"
TALK "Added user: " + result
```
## REMOVE_MEMBER
```basic
result = REMOVE_MEMBER "team-sales", "john@company.com"
```
## CREATE_TEAM
```basic
members = ["alice@company.com", "bob@company.com"]
result = CREATE_TEAM "Project Alpha", "Development team", members
```
## LIST_MEMBERS
```basic
members = LIST_MEMBERS "team-sales"
FOR EACH member IN members
TALK member.email + " - " + member.role
NEXT
```
## Roles
| Role | Permissions |
|------|-------------|
| `admin` | Full control, manage members |
| `member` | Standard access |
| `viewer` | Read-only access |
## See Also
- [ADD BOT](./keyword-add-bot.md)
- [User Session Handling](../chapter-10-features/user-sessions.md)

305
docs/src/chapter-06-gbdialog/keyword-book.md Normal file
View file

@ -0,0 +1,305 @@
# BOOK / BOOK_MEETING / CHECK_AVAILABILITY Keywords
The `BOOK` family of keywords provides calendar and scheduling functionality, allowing bots to create appointments, schedule meetings with attendees, and check availability.
## Keywords Overview
| Keyword | Purpose |
|---------|---------|
| `BOOK` | Create a simple calendar appointment |
| `BOOK_MEETING` | Schedule a meeting with multiple attendees |
| `CHECK_AVAILABILITY` | Find available time slots |
## BOOK
Creates a calendar appointment for the current user.
### Syntax
```basic
result = BOOK title, description, start_time, duration_minutes, location
```
### Parameters
| Parameter | Type | Description |
|-----------|------|-------------|
| `title` | String | Title/subject of the appointment |
| `description` | String | Detailed description of the appointment |
| `start_time` | String | When the appointment starts (see Time Formats) |
| `duration_minutes` | Integer | Duration in minutes (default: 30) |
| `location` | String | Location or meeting room |
### Example
```basic
' Book a dentist appointment
result = BOOK "Dentist Appointment", "Annual checkup", "2024-03-15 14:00", 60, "123 Medical Center"
TALK "Your appointment has been booked: " + result
' Book a quick meeting
result = BOOK "Team Sync", "Weekly standup", "tomorrow 10:00", 30, "Conference Room A"
```
## BOOK_MEETING
Schedules a meeting with multiple attendees, sending calendar invites.
### Syntax
```basic
result = BOOK_MEETING meeting_details, attendees
```
### Parameters
| Parameter | Type | Description |
|-----------|------|-------------|
| `meeting_details` | JSON String | Meeting configuration object |
| `attendees` | Array | List of attendee email addresses |
### Meeting Details Object
```json
{
"title": "Meeting Title",
"description": "Meeting description",
"start_time": "2024-03-15 14:00",
"duration": 60,
"location": "Conference Room B",
"reminder_minutes": 15,
"recurrence": "weekly"
}
```
### Example
```basic
' Schedule a team meeting
meeting = '{
"title": "Sprint Planning",
"description": "Plan next sprint tasks and priorities",
"start_time": "Monday 09:00",
"duration": 90,
"location": "Main Conference Room",
"reminder_minutes": 30
}'
attendees = ["alice@company.com", "bob@company.com", "carol@company.com"]
result = BOOK_MEETING meeting, attendees
TALK "Meeting scheduled with " + LEN(attendees) + " attendees"
```
## CHECK_AVAILABILITY
Finds available time slots for a given date and duration.
### Syntax
```basic
available_slots = CHECK_AVAILABILITY date, duration_minutes
```
### Parameters
| Parameter | Type | Description |
|-----------|------|-------------|
| `date` | String | The date to check availability |
| `duration_minutes` | Integer | Required duration for the meeting |
### Example
```basic
' Check availability for a 1-hour meeting tomorrow
slots = CHECK_AVAILABILITY "tomorrow", 60
TALK "Available time slots:"
FOR EACH slot IN slots
TALK " - " + slot
NEXT
```
## Time Formats
The BOOK keywords support flexible time formats:
### Absolute Formats
| Format | Example |
|--------|---------|
| ISO 8601 | `"2024-03-15T14:00:00"` |
| Date + Time | `"2024-03-15 14:00"` |
| Date + Time (12h) | `"2024-03-15 2:00 PM"` |
### Relative Formats
| Format | Example |
|--------|---------|
| Day name | `"Monday 10:00"` |
| Relative day | `"tomorrow 14:00"` |
| Next week | `"next Tuesday 09:00"` |
## Complete Example: Appointment Scheduling Bot
```basic
' appointment-bot.bas
' A complete appointment scheduling workflow
TALK "Welcome to our scheduling assistant!"
TALK "What type of appointment would you like to book?"
HEAR appointment_type
SWITCH appointment_type
CASE "consultation"
duration = 60
description = "Initial consultation meeting"
CASE "follow-up"
duration = 30
description = "Follow-up discussion"
CASE "review"
duration = 45
description = "Project review session"
DEFAULT
duration = 30
description = appointment_type
END SWITCH
TALK "When would you like to schedule this?"
HEAR preferred_date
' Check available slots
slots = CHECK_AVAILABILITY preferred_date, duration
IF LEN(slots) = 0 THEN
TALK "Sorry, no availability on that date. Please try another day."
ELSE
TALK "Available times:"
index = 1
FOR EACH slot IN slots
TALK index + ". " + slot
index = index + 1
NEXT
TALK "Which time slot would you prefer? (enter number)"
HEAR choice
selected_time = slots[choice - 1]
TALK "Where would you like the meeting to take place?"
HEAR location
' Book the appointment
result = BOOK appointment_type, description, selected_time, duration, location
TALK "✅ Your appointment has been booked!"
TALK "Details: " + result
END IF
```
## Meeting with Recurrence
```basic
' Schedule a recurring weekly meeting
meeting = '{
"title": "Weekly Team Standup",
"description": "Daily sync on project progress",
"start_time": "Monday 09:00",
"duration": 15,
"location": "Virtual - Teams",
"reminder_minutes": 5,
"recurrence": {
"frequency": "weekly",
"interval": 1,
"count": 12,
"by_day": ["MO", "WE", "FR"]
}
}'
attendees = ["team@company.com"]
result = BOOK_MEETING meeting, attendees
```
## Event Status
Calendar events can have the following statuses:
| Status | Description |
|--------|-------------|
| `Confirmed` | Event is confirmed and scheduled |
| `Tentative` | Event is tentatively scheduled |
| `Cancelled` | Event has been cancelled |
## Calendar Event Structure
When an event is created, it contains:
```json
{
"id": "uuid",
"title": "Meeting Title",
"description": "Description",
"start_time": "2024-03-15T14:00:00Z",
"end_time": "2024-03-15T15:00:00Z",
"location": "Conference Room",
"organizer": "user@example.com",
"attendees": ["attendee1@example.com"],
"reminder_minutes": 15,
"recurrence_rule": null,
"status": "Confirmed",
"created_at": "2024-03-10T10:00:00Z",
"updated_at": "2024-03-10T10:00:00Z"
}
```
## Configuration
To enable calendar functionality, configure the following in `config.csv`:
| Key | Description |
|-----|-------------|
| `calendar-provider` | Calendar service (google, outlook, caldav) |
| `calendar-client-id` | OAuth client ID |
| `calendar-client-secret` | OAuth client secret |
| `calendar-default-reminder` | Default reminder time in minutes |
## Error Handling
```basic
' Handle booking errors gracefully
ON ERROR GOTO handle_error
result = BOOK "Meeting", "Description", "invalid-date", 30, "Location"
TALK "Booked: " + result
END
handle_error:
TALK "Sorry, I couldn't book that appointment. Please check the date and time format."
TALK "Error: " + ERROR_MESSAGE
END
```
## Best Practices
1. **Always check availability first**: Before booking, use `CHECK_AVAILABILITY` to ensure the time slot is free.
2. **Use descriptive titles**: Make appointment titles clear and searchable.
3. **Set appropriate reminders**: Configure reminder times based on appointment importance.
4. **Handle time zones**: Be explicit about time zones when scheduling across regions.
5. **Validate inputs**: Check user-provided dates and times before attempting to book.
## Related Keywords
- [SET SCHEDULE](./keyword-set-schedule.md) - Schedule recurring bot tasks
- [WAIT](./keyword-wait.md) - Pause execution for a duration
- [SEND MAIL](./keyword-send-mail.md) - Send meeting confirmations via email
## See Also
- [Calendar Integration](../appendix-external-services/calendar.md)
- [Google Calendar Setup](../appendix-external-services/google-calendar.md)
- [Microsoft Outlook Integration](../appendix-external-services/outlook.md)

93
docs/src/chapter-06-gbdialog/keyword-human-approval.md Normal file
View file

@ -0,0 +1,93 @@
# HUMAN APPROVAL Keywords
Pause bot execution until a human reviews and approves, rejects, or modifies a pending action.
## Keywords
| Keyword | Purpose |
|---------|---------|
| `REQUEST APPROVAL` | Submit action for human review |
| `WAIT FOR APPROVAL` | Pause until approval received |
| `CHECK APPROVAL` | Check approval status without blocking |
## REQUEST APPROVAL
```basic
approval_id = REQUEST APPROVAL "Transfer $5000 to vendor account"
```
With metadata:
```basic
approval_id = REQUEST APPROVAL "Delete customer records", "compliance-team", "high"
```
## WAIT FOR APPROVAL
```basic
approval_id = REQUEST APPROVAL "Publish marketing campaign"
result = WAIT FOR APPROVAL approval_id, 3600 ' Wait up to 1 hour
IF result.status = "approved" THEN
TALK "Campaign published!"
ELSE
TALK "Campaign rejected: " + result.reason
END IF
```
## CHECK APPROVAL
Non-blocking status check:
```basic
status = CHECK APPROVAL approval_id
TALK "Current status: " + status.state
```
## Approval States
| State | Description |
|-------|-------------|
| `pending` | Awaiting human review |
| `approved` | Action approved |
| `rejected` | Action denied |
| `modified` | Approved with changes |
| `expired` | Timeout reached |
## Example: Financial Approval Workflow
```basic
' Large transaction approval
amount = 10000
approval_id = REQUEST APPROVAL "Wire transfer: $" + amount, "finance-team", "critical"
TALK "Your transfer request has been submitted for approval."
TALK "You'll be notified when reviewed."
result = WAIT FOR APPROVAL approval_id, 86400 ' 24 hour timeout
SWITCH result.status
CASE "approved"
TALK "Transfer approved by " + result.approver
CASE "rejected"
TALK "Transfer denied: " + result.reason
CASE "expired"
TALK "Request expired. Please resubmit."
END SWITCH
```
## Configuration
Add to `config.csv`:
```csv
approval-timeout-default,3600
approval-notify-channel,slack
approval-escalation-hours,4
```
## See Also
- [WAIT](./keyword-wait.md)
- [SEND MAIL](./keyword-send-mail.md)

60
docs/src/chapter-06-gbdialog/keyword-model-route.md Normal file
View file

@ -0,0 +1,60 @@
# MODEL ROUTE Keywords
Route LLM requests to different models based on task type, cost, or capability requirements.
## Keywords
| Keyword | Purpose |
|---------|---------|
| `MODEL ROUTE` | Route request to appropriate model |
| `SET MODEL ROUTE` | Configure routing rules |
| `GET MODEL ROUTES` | List configured routes |
## MODEL ROUTE
```basic
response = MODEL ROUTE "complex-analysis", user_query
```
## SET MODEL ROUTE
```basic
SET MODEL ROUTE "fast", "gpt-3.5-turbo"
SET MODEL ROUTE "smart", "gpt-4o"
SET MODEL ROUTE "code", "claude-sonnet"
SET MODEL ROUTE "vision", "gpt-4o"
```
## Routing Strategies
| Strategy | Description |
|----------|-------------|
| `manual` | Explicitly specify model per request |
| `cost` | Prefer cheaper models when possible |
| `capability` | Match model to task requirements |
| `fallback` | Try models in order until success |
## Example: Cost-Optimized Routing
```basic
SET MODEL ROUTE "default", "gpt-3.5-turbo"
SET MODEL ROUTE "complex", "gpt-4o"
' Simple queries use fast/cheap model
' Complex analysis uses more capable model
response = MODEL ROUTE "complex", "Analyze market trends for Q4"
```
## Configuration
Add to `config.csv`:
```csv
model-routing-strategy,capability
model-default,gpt-3.5-turbo
model-fallback,gpt-4o
```
## See Also
- [USE MODEL](./keyword-use-model.md)

315
docs/src/chapter-06-gbdialog/keyword-play.md Normal file
View file

@ -0,0 +1,315 @@
# PLAY
Open a content projector/player to display various media types including videos, images, documents, and presentations.
## Syntax
```basic
' Basic playback
PLAY file_or_url
' With options
PLAY file_or_url WITH OPTIONS options_string
```
## Parameters
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `file_or_url` | String | Yes | Path to file or URL to display |
| `options_string` | String | No | Comma-separated playback options |
## Supported Options
| Option | Description |
|--------|-------------|
| `autoplay` | Start playback automatically |
| `loop` | Loop content continuously |
| `fullscreen` | Open in fullscreen mode |
| `muted` | Start with audio muted |
| `controls` | Show playback controls |
| `nocontrols` | Hide playback controls |
## Supported Content Types
### Video
| Extension | Format |
|-----------|--------|
| `.mp4` | MPEG-4 Video |
| `.webm` | WebM Video |
| `.ogg` | Ogg Video |
| `.mov` | QuickTime |
| `.avi` | AVI Video |
| `.mkv` | Matroska |
| `.m4v` | M4V Video |
### Audio
| Extension | Format |
|-----------|--------|
| `.mp3` | MP3 Audio |
| `.wav` | WAV Audio |
| `.flac` | FLAC Audio |
| `.aac` | AAC Audio |
| `.m4a` | M4A Audio |
| `.ogg` | Ogg Audio |
### Images
| Extension | Format |
|-----------|--------|
| `.jpg` `.jpeg` | JPEG Image |
| `.png` | PNG Image |
| `.gif` | GIF (animated) |
| `.webp` | WebP Image |
| `.svg` | SVG Vector |
| `.bmp` | Bitmap |
### Documents
| Extension | Format |
|-----------|--------|
| `.pdf` | PDF Document |
| `.docx` `.doc` | Word Document |
| `.pptx` `.ppt` | PowerPoint |
| `.xlsx` `.xls` | Excel Spreadsheet |
| `.odt` | OpenDocument Text |
| `.odp` | OpenDocument Presentation |
### Code
| Extension | Language |
|-----------|----------|
| `.rs` | Rust |
| `.py` | Python |
| `.js` `.ts` | JavaScript/TypeScript |
| `.java` | Java |
| `.go` | Go |
| `.rb` | Ruby |
| `.md` | Markdown |
| `.html` | HTML |
## Examples
### Play a Video
```basic
' Play a video file
PLAY "training-video.mp4"
' Play with autoplay and loop
PLAY "background.mp4" WITH OPTIONS "autoplay,loop,muted"
' Play from URL
PLAY "https://example.com/videos/demo.mp4"
```
### Display an Image
```basic
' Show an image
PLAY "product-photo.jpg"
' Show image fullscreen
PLAY "banner.png" WITH OPTIONS "fullscreen"
```
### Show a Presentation
```basic
' Display PowerPoint presentation
PLAY "quarterly-report.pptx"
' Fullscreen presentation mode
PLAY "sales-deck.pptx" WITH OPTIONS "fullscreen"
```
### Display a Document
```basic
' Show PDF document
PLAY "contract.pdf"
' Show Word document
PLAY "proposal.docx"
```
### Interactive Training Module
```basic
TALK "Welcome to the training module!"
TALK "Let's start with an introduction video."
PLAY "intro-video.mp4" WITH OPTIONS "controls"
HEAR ready AS TEXT "Type 'continue' when you're ready to proceed:"
IF LOWER(ready) = "continue" THEN
TALK "Great! Now let's review the key concepts."
PLAY "concepts-slides.pptx"
HEAR understood AS TEXT "Did you understand the concepts? (yes/no)"
IF LOWER(understood) = "yes" THEN
TALK "Excellent! Here's your certificate."
PLAY "certificate.pdf"
ELSE
TALK "Let's review the material again."
PLAY "concepts-detailed.mp4"
END IF
END IF
```
### Product Showcase
```basic
' Show product images in sequence
products = FIND "products", "featured=true"
FOR EACH product IN products
TALK "Now showing: " + product.name
PLAY product.image_path
WAIT 3000 ' Wait 3 seconds between images
NEXT
```
### Code Review
```basic
' Display code for review
TALK "Let's review the implementation:"
PLAY "src/main.rs"
HEAR feedback AS TEXT "Any comments on this code?"
INSERT "code_reviews", file_path, feedback, NOW()
```
### Audio Playback
```basic
' Play audio message
TALK "Here's a voice message from your team:"
PLAY "team-message.mp3" WITH OPTIONS "controls"
' Play background music
PLAY "ambient.mp3" WITH OPTIONS "autoplay,loop,muted"
```
### Dynamic Content Display
```basic
' Display content based on file type
HEAR file_name AS TEXT "Enter the file name to display:"
file_ext = LOWER(RIGHT(file_name, 4))
IF file_ext = ".mp4" OR file_ext = "webm" THEN
PLAY file_name WITH OPTIONS "controls,autoplay"
ELSE IF file_ext = ".pdf" THEN
PLAY file_name
ELSE IF file_ext = ".jpg" OR file_ext = ".png" THEN
PLAY file_name WITH OPTIONS "fullscreen"
ELSE
TALK "Unsupported file type"
END IF
```
### Embedded Video from URL
```basic
' Play YouTube video (via embed URL)
PLAY "https://www.youtube.com/embed/dQw4w9WgXcQ"
' Play Vimeo video
PLAY "https://player.vimeo.com/video/123456789"
```
### Onboarding Flow
```basic
' Multi-step onboarding with media
TALK "Welcome to our platform! Let's get you started."
' Step 1: Welcome video
TALK "First, watch this quick introduction:"
PLAY "onboarding/welcome.mp4" WITH OPTIONS "controls"
HEAR step1_done AS TEXT "Press Enter when done..."
' Step 2: Feature overview
TALK "Here's an overview of our key features:"
PLAY "onboarding/features.pptx"
HEAR step2_done AS TEXT "Press Enter when done..."
' Step 3: Quick start guide
TALK "Finally, here's your quick start guide:"
PLAY "onboarding/quickstart.pdf"
TALK "You're all set! 🎉"
```
### Error Handling
```basic
' Check if file exists before playing
file_path = "presentation.pptx"
IF FILE_EXISTS(file_path) THEN
PLAY file_path
ELSE
TALK "Sorry, the file could not be found."
TALK "Please check the file path and try again."
END IF
```
## Player Behavior
### Web Interface
When used in the web interface, PLAY opens a modal overlay with:
- Appropriate player for the content type
- Close button to dismiss
- Optional playback controls
- Fullscreen toggle
### WhatsApp/Messaging Channels
On messaging channels, PLAY sends the file directly:
- Videos/images: Sent as media messages
- Documents: Sent as file attachments
- URLs: Sent as links with preview
### Desktop Application
In the desktop app, PLAY uses the native media player or viewer appropriate for the content type.
## File Locations
Files can be referenced from:
| Location | Example |
|----------|---------|
| Bot's .gbdrive | `documents/report.pdf` |
| User's folder | `users/john@email.com/uploads/photo.jpg` |
| Absolute URL | `https://cdn.example.com/video.mp4` |
| Relative path | `./assets/logo.png` |
## Limitations
- Maximum file size depends on channel (WhatsApp: 16MB for media, 100MB for documents)
- Some formats may require conversion for web playback
- Streaming large files requires adequate bandwidth
- Protected/DRM content is not supported
## See Also
- [SEND FILE](./keyword-send-mail.md) - Send files as attachments
- [TALK](./keyword-talk.md) - Display text messages
- [UPLOAD](./keyword-upload.md) - Upload files to storage
- [DOWNLOAD](./keyword-download.md) - Download files from URLs
## Implementation
The PLAY keyword is implemented in `src/basic/keywords/play.rs` with content type detection and appropriate player selection for each media format.

190
docs/src/chapter-06-gbdialog/keyword-qrcode.md Normal file
View file

@ -0,0 +1,190 @@
# QR CODE
Generate QR code images from text or data.
## Syntax
```basic
' Basic QR code generation
path = QR CODE data
' With custom size (pixels)
path = QR CODE data, size
' With size and output path
path = QR CODE data, size, output_path
```
## Parameters
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `data` | String | Yes | The data to encode in the QR code (URL, text, etc.) |
| `size` | Integer | No | Image size in pixels (default: 256) |
| `output_path` | String | No | Custom output file path |
## Return Value
Returns the file path to the generated QR code image (PNG format).
## Examples
### Basic QR Code
```basic
' Generate a QR code for a URL
qr_path = QR CODE "https://example.com"
TALK "Scan this QR code:"
SEND FILE qr_path
```
### QR Code with Custom Size
```basic
' Generate a larger QR code (512x512 pixels)
qr_path = QR CODE "https://mywebsite.com/signup", 512
SEND FILE qr_path
```
### Dynamic Content
```basic
HEAR user_id AS TEXT "Enter your user ID:"
' Generate QR code with dynamic data
profile_url = "https://app.example.com/profile/" + user_id
qr_path = QR CODE profile_url, 300
TALK "Here's your profile QR code:"
SEND FILE qr_path
```
### Event Check-in
```basic
' Generate unique check-in codes for events
event_id = "EVT-2025-001"
attendee_email = user.email
checkin_data = "CHECKIN:" + event_id + ":" + attendee_email
qr_path = QR CODE checkin_data, 400
TALK "Show this QR code at the event entrance:"
SEND FILE qr_path
```
### Payment QR Code
```basic
' Generate PIX payment QR code (Brazil)
HEAR amount AS NUMBER "Enter payment amount:"
pix_payload = "00020126580014br.gov.bcb.pix0136" + merchant_key
pix_payload = pix_payload + "5204000053039865802BR"
pix_payload = pix_payload + "5913MerchantName6008CityName62070503***"
qr_path = QR CODE pix_payload, 400
TALK "Scan to pay R$ " + amount + ":"
SEND FILE qr_path
```
### WiFi QR Code
```basic
' Generate WiFi connection QR code
wifi_ssid = "MyNetwork"
wifi_password = "SecurePass123"
wifi_type = "WPA"
wifi_data = "WIFI:T:" + wifi_type + ";S:" + wifi_ssid + ";P:" + wifi_password + ";;"
qr_path = QR CODE wifi_data, 300
TALK "Scan to connect to WiFi:"
SEND FILE qr_path
```
### Contact Card (vCard)
```basic
' Generate QR code with contact information
vcard = "BEGIN:VCARD\n"
vcard = vcard + "VERSION:3.0\n"
vcard = vcard + "N:Doe;John\n"
vcard = vcard + "TEL:+1234567890\n"
vcard = vcard + "EMAIL:john@example.com\n"
vcard = vcard + "END:VCARD"
qr_path = QR CODE vcard, 350
TALK "Scan to add contact:"
SEND FILE qr_path
```
### Custom Output Location
```basic
' Save QR code to specific path
output_file = "work/qrcodes/user_" + user.id + ".png"
qr_path = QR CODE "https://example.com", 256, output_file
TALK "QR code saved to: " + qr_path
```
## Supported Data Types
The QR CODE keyword can encode various types of data:
| Type | Format | Example |
|------|--------|---------|
| URL | `https://...` | `https://example.com` |
| Plain Text | Any text | `Hello World` |
| WiFi | `WIFI:T:WPA;S:ssid;P:pass;;` | Network credentials |
| vCard | `BEGIN:VCARD...END:VCARD` | Contact information |
| Email | `mailto:email@example.com` | Email link |
| Phone | `tel:+1234567890` | Phone number |
| SMS | `sms:+1234567890?body=Hello` | SMS with message |
| Geo | `geo:lat,lon` | Geographic coordinates |
## Size Guidelines
| Use Case | Recommended Size |
|----------|------------------|
| Mobile scanning | 256-300px |
| Print (business card) | 300-400px |
| Print (poster) | 512-1024px |
| Digital display | 256-512px |
## Error Handling
```basic
' Check if QR code was generated
qr_path = QR CODE data
IF qr_path = "" THEN
TALK "Failed to generate QR code"
ELSE
SEND FILE qr_path
END IF
```
## File Storage
Generated QR codes are stored in the bot's `.gbdrive` storage:
- Default location: `work/qrcodes/`
- Format: PNG
- Naming: UUID-based unique filenames
## Limitations
- Maximum data length depends on QR code version (up to ~4,296 alphanumeric characters)
- Larger data requires larger image sizes for reliable scanning
- Binary data should be Base64 encoded
## See Also
- [SEND FILE](./keyword-send-mail.md) - Send generated QR codes
- [TALK](./keyword-talk.md) - Display messages with QR codes
- [FORMAT](./keyword-format.md) - Format data before encoding
## Implementation
The QR CODE keyword is implemented in `src/basic/keywords/qrcode.rs` using the `qrcode` and `image` crates for generation.

210
docs/src/chapter-06-gbdialog/keyword-remember.md Normal file
View file

@ -0,0 +1,210 @@
# REMEMBER / RECALL Keywords
The `REMEMBER` and `RECALL` keywords provide a powerful time-based memory system for storing and retrieving data associated with users. Unlike standard memory operations, `REMEMBER` supports automatic expiration of stored values.
## Syntax
### REMEMBER
```basic
REMEMBER key, value, duration
```
### RECALL
```basic
result = RECALL key
```
## Parameters
### REMEMBER Parameters
| Parameter | Type | Description |
|-----------|------|-------------|
| `key` | String | Unique identifier for the memory entry |
| `value` | Any | Data to store (string, number, boolean, array, or object) |
| `duration` | String | How long to remember the value |
### Duration Formats
| Format | Example | Description |
|--------|---------|-------------|
| `N seconds` | `"30 seconds"` | Expires after N seconds |
| `N minutes` | `"5 minutes"` | Expires after N minutes |
| `N hours` | `"2 hours"` | Expires after N hours |
| `N days` | `"7 days"` | Expires after N days |
| `N weeks` | `"2 weeks"` | Expires after N weeks |
| `N months` | `"3 months"` | Expires after ~N×30 days |
| `N years` | `"1 year"` | Expires after ~N×365 days |
| `forever` | `"forever"` | Never expires |
| `permanent` | `"permanent"` | Never expires (alias) |
| Plain number | `"30"` | Interpreted as days |
## Examples
### Basic Usage
```basic
' Remember user's preferred language for 30 days
REMEMBER "preferred_language", "Spanish", "30 days"
' Later, recall the preference
language = RECALL "preferred_language"
TALK "Your language preference is: " + language
```
### Session-Based Memory
```basic
' Remember a temporary verification code for 5 minutes
code = RANDOM(100000, 999999)
REMEMBER "verification_code", code, "5 minutes"
TALK "Your verification code is: " + code
' Verify the code later
HEAR user_code
stored_code = RECALL "verification_code"
IF user_code = stored_code THEN
TALK "Code verified successfully!"
ELSE
TALK "Invalid or expired code."
END IF
```
### Storing Complex Data
```basic
' Store user preferences as an array
preferences = ["dark_mode", "notifications_on", "english"]
REMEMBER "user_preferences", preferences, "1 year"
' Store a shopping cart temporarily
cart = ["item1", "item2", "item3"]
REMEMBER "shopping_cart", cart, "2 hours"
```
### Permanent Storage
```basic
' Store important user information permanently
REMEMBER "account_created", NOW(), "forever"
REMEMBER "user_tier", "premium", "permanent"
```
### Promotional Campaigns
```basic
' Track if user has seen a promotional message
has_seen = RECALL "promo_summer_2024"
IF has_seen = null THEN
TALK "🎉 Special summer offer: 20% off all products!"
REMEMBER "promo_summer_2024", true, "30 days"
END IF
```
### Rate Limiting
```basic
' Simple rate limiting for API calls
call_count = RECALL "api_calls_today"
IF call_count = null THEN
call_count = 0
END IF
IF call_count >= 100 THEN
TALK "You've reached your daily API limit. Please try again tomorrow."
ELSE
call_count = call_count + 1
REMEMBER "api_calls_today", call_count, "24 hours"
' Process the API call
END IF
```
## How It Works
1. **Storage**: Data is stored in the `bot_memories` database table with:
- User ID and Bot ID association
- JSON-serialized value
- Creation timestamp
- Optional expiration timestamp
2. **Retrieval**: When `RECALL` is called:
- System checks if the key exists for the user/bot combination
- Verifies the entry hasn't expired
- Returns the value or `null` if not found/expired
3. **Automatic Cleanup**: Expired entries are not returned and can be periodically cleaned up by maintenance tasks.
## Database Schema
The `REMEMBER` keyword uses the following database structure:
```sql
CREATE TABLE bot_memories (
id TEXT PRIMARY KEY,
user_id TEXT NOT NULL,
bot_id TEXT NOT NULL,
session_id TEXT,
key TEXT NOT NULL,
value JSONB NOT NULL,
created_at TEXT NOT NULL,
expires_at TEXT,
UNIQUE(user_id, bot_id, key)
);
```
## Comparison with Other Memory Keywords
| Keyword | Scope | Persistence | Expiration |
|---------|-------|-------------|------------|
| `SET USER MEMORY` | User | Permanent | No |
| `SET BOT MEMORY` | Bot (all users) | Permanent | No |
| `REMEMBER` | User | Configurable | Yes |
| `REMEMBER USER FACT` | User | Permanent | No |
## Best Practices
1. **Use descriptive keys**: Choose meaningful key names like `"last_login"` instead of `"ll"`.
2. **Set appropriate durations**: Match the duration to your use case:
- Session data: minutes to hours
- Preferences: weeks to months
- Important data: `forever`
3. **Handle null values**: Always check if `RECALL` returns `null`:
```basic
value = RECALL "some_key"
IF value = null THEN
' Handle missing/expired data
END IF
```
4. **Avoid storing sensitive data**: Don't store passwords, API keys, or other secrets.
## Error Handling
```basic
' REMEMBER returns a confirmation message on success
result = REMEMBER "key", "value", "1 day"
' result = "Remembered 'key' for 1 day"
' RECALL returns null if key doesn't exist or has expired
value = RECALL "nonexistent_key"
' value = null
```
## Related Keywords
- [SET USER MEMORY](./keyword-set-user-memory.md) - Permanent user-scoped storage
- [GET USER MEMORY](./keyword-get-user-memory.md) - Retrieve permanent user data
- [SET BOT MEMORY](./keyword-set-bot-memory.md) - Bot-wide storage
- [GET BOT MEMORY](./keyword-get-bot-memory.md) - Retrieve bot-wide data
## See Also
- [Memory Management](../chapter-10-features/memory-management.md)
- [User Session Handling](../chapter-10-features/user-sessions.md)

107
docs/src/chapter-06-gbdialog/keyword-send-template.md Normal file
View file

@ -0,0 +1,107 @@
# SEND TEMPLATE Keywords
Send templated messages across multiple channels (email, WhatsApp, SMS, Telegram, push notifications).
## Keywords
| Keyword | Purpose |
|---------|---------|
| `SEND_TEMPLATE` | Send template to single recipient |
| `SEND_TEMPLATE_TO` | Send template to multiple recipients |
| `CREATE_TEMPLATE` | Create a new message template |
| `GET_TEMPLATE` | Retrieve template by name |
## SEND_TEMPLATE
```basic
result = SEND_TEMPLATE "welcome", "user@example.com", "email"
```
With variables:
```basic
vars = {"name": "John", "order_id": "12345"}
result = SEND_TEMPLATE "order_confirmation", "+1234567890", "whatsapp", vars
```
## SEND_TEMPLATE_TO
Send to multiple recipients:
```basic
recipients = ["user1@example.com", "user2@example.com", "user3@example.com"]
result = SEND_TEMPLATE_TO "newsletter", recipients, "email"
TALK "Sent: " + result.sent + ", Failed: " + result.failed
```
## Supported Channels
| Channel | Recipient Format |
|---------|------------------|
| `email` | Email address |
| `whatsapp` | Phone number with country code |
| `sms` | Phone number with country code |
| `telegram` | Telegram user ID or username |
| `push` | Device token or user ID |
## CREATE_TEMPLATE
```basic
template_body = "Hello {{name}}, your order {{order_id}} has shipped!"
result = CREATE_TEMPLATE "shipping_notification", template_body, "transactional"
```
## Template Variables
Use `{{variable_name}}` syntax in templates:
```basic
vars = {
"customer_name": "Alice",
"amount": "$99.00",
"date": "March 15, 2024"
}
result = SEND_TEMPLATE "receipt", "alice@example.com", "email", vars
```
## Example: Order Notification
```basic
' Send order confirmation across multiple channels
order_vars = {
"order_id": order.id,
"total": order.total,
"items": order.item_count
}
SEND_TEMPLATE "order_placed", customer.email, "email", order_vars
SEND_TEMPLATE "order_placed", customer.phone, "whatsapp", order_vars
```
## Response Object
```json
{
"success": true,
"message_id": "msg_123abc",
"channel": "email",
"recipient": "user@example.com"
}
```
For batch sends:
```json
{
"total": 100,
"sent": 98,
"failed": 2,
"errors": [...]
}
```
## See Also
- [SEND MAIL](./keyword-send-mail.md)
- [SEND SMS](./keyword-sms.md)

302
docs/src/chapter-06-gbdialog/keyword-sms.md Normal file
View file

@ -0,0 +1,302 @@
# SEND SMS
Send SMS text messages to phone numbers using various providers.
## Syntax
```basic
' Basic SMS sending
SEND SMS phone, message
' With specific provider
SEND SMS phone, message, provider
```
## Parameters
| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `phone` | String | Yes | Recipient phone number (E.164 format recommended) |
| `message` | String | Yes | The text message to send (max 160 chars for single SMS) |
| `provider` | String | No | SMS provider: `twilio`, `aws_sns`, `vonage`, `messagebird` |
## Return Value
Returns `true` if the SMS was sent successfully, `false` otherwise.
## Configuration
Configure SMS provider credentials in `config.csv`:
```csv
key,value
sms-provider,twilio
twilio-account-sid,YOUR_ACCOUNT_SID
twilio-auth-token,YOUR_AUTH_TOKEN
twilio-phone-number,+15551234567
```
### Provider-Specific Configuration
**Twilio:**
```csv
sms-provider,twilio
twilio-account-sid,ACxxxxx
twilio-auth-token,your_token
twilio-phone-number,+15551234567
```
**AWS SNS:**
```csv
sms-provider,aws_sns
aws-access-key-id,AKIAXXXXXXXX
aws-secret-access-key,your_secret
aws-region,us-east-1
```
**Vonage (Nexmo):**
```csv
sms-provider,vonage
vonage-api-key,your_api_key
vonage-api-secret,your_secret
vonage-from-number,+15551234567
```
**MessageBird:**
```csv
sms-provider,messagebird
messagebird-access-key,your_access_key
messagebird-originator,YourBrand
```
## Examples
### Basic SMS
```basic
HEAR phone AS TEXT "Enter phone number:"
SEND SMS phone, "Hello from General Bots!"
TALK "SMS sent successfully!"
```
### Order Confirmation
```basic
' Send order confirmation via SMS
order_id = "ORD-2025-001"
phone = customer.phone
message = "Your order " + order_id + " has been confirmed. "
message = message + "Estimated delivery: 2-3 business days."
result = SEND SMS phone, message
IF result THEN
TALK "Confirmation SMS sent to " + phone
ELSE
TALK "Failed to send SMS. We'll email you instead."
SEND MAIL customer.email, "Order Confirmation", message
END IF
```
### Two-Factor Authentication
```basic
' Generate and send OTP
otp = RANDOM(100000, 999999)
REMEMBER "otp_" + user.id, otp, "5 minutes"
message = "Your verification code is: " + otp + ". Valid for 5 minutes."
SEND SMS user.phone, message
HEAR entered_code AS TEXT "Enter the code sent to your phone:"
stored_otp = RECALL "otp_" + user.id
IF entered_code = stored_otp THEN
TALK "✅ Phone verified successfully!"
SET USER MEMORY "phone_verified", true
ELSE
TALK "❌ Invalid code. Please try again."
END IF
```
### Appointment Reminder
```basic
' Send appointment reminder
appointment_date = FORMAT(appointment.datetime, "MMMM D, YYYY")
appointment_time = FORMAT(appointment.datetime, "h:mm A")
message = "Reminder: Your appointment is on " + appointment_date
message = message + " at " + appointment_time + ". Reply YES to confirm."
SEND SMS patient.phone, message
' Set up response handler
ON "sms:received" FROM patient.phone
IF UPPER(params.message) = "YES" THEN
UPDATE "appointments", appointment.id, "status", "confirmed"
SEND SMS patient.phone, "Thank you! Your appointment is confirmed."
END IF
END ON
```
### Multi-Language SMS
```basic
' Send SMS in user's preferred language
lang = GET USER MEMORY "language"
IF lang = "es" THEN
message = "Gracias por tu compra. Tu pedido está en camino."
ELSE IF lang = "pt" THEN
message = "Obrigado pela sua compra. Seu pedido está a caminho."
ELSE
message = "Thank you for your purchase. Your order is on the way."
END IF
SEND SMS user.phone, message
```
### Using Different Providers
```basic
' Use specific provider for different regions
country_code = LEFT(phone, 3)
IF country_code = "+1 " THEN
' Use Twilio for US/Canada
SEND SMS phone, message, "twilio"
ELSE IF country_code = "+55" THEN
' Use local provider for Brazil
SEND SMS phone, message, "vonage"
ELSE
' Default provider
SEND SMS phone, message
END IF
```
### Emergency Alert
```basic
' Send emergency notification to multiple recipients
alert_message = "⚠️ ALERT: System maintenance in 30 minutes. Save your work."
contacts = FIND "emergency_contacts", "notify=true"
FOR EACH contact IN contacts
SEND SMS contact.phone, alert_message
WAIT 100 ' Small delay between messages
NEXT
TALK "Emergency alert sent to " + COUNT(contacts) + " contacts"
```
### Delivery Tracking
```basic
' Send delivery status updates
ON "delivery:status_changed"
order = FIND "orders", "id=" + params.order_id
SWITCH params.status
CASE "shipped"
message = "📦 Your order has shipped! Tracking: " + params.tracking_number
CASE "out_for_delivery"
message = "🚚 Your package is out for delivery today!"
CASE "delivered"
message = "✅ Your package has been delivered. Enjoy!"
DEFAULT
message = "Order update: " + params.status
END SWITCH
SEND SMS order.phone, message
END ON
```
## Phone Number Formats
The keyword accepts various phone number formats:
| Format | Example | Recommended |
|--------|---------|-------------|
| E.164 | `+14155551234` | ✅ Yes |
| National | `(415) 555-1234` | ⚠️ Converted |
| Digits only | `4155551234` | ⚠️ Needs country |
**Best Practice:** Always use E.164 format (`+` followed by country code and number).
## Message Length
| Type | Characters | Notes |
|------|------------|-------|
| Single SMS | 160 | Standard ASCII |
| Unicode SMS | 70 | Emojis, non-Latin scripts |
| Concatenated | 153 × segments | Long messages split |
```basic
' Check message length before sending
IF LEN(message) > 160 THEN
TALK "Warning: Message will be sent as multiple SMS"
END IF
SEND SMS phone, message
```
## Error Handling
```basic
' Handle SMS errors gracefully
TRY
result = SEND SMS phone, message
IF NOT result THEN
' Log the failure
INSERT "sms_failures", phone, message, NOW()
' Fallback to email if available
IF user.email <> "" THEN
SEND MAIL user.email, "Notification", message
END IF
END IF
CATCH error
TALK "SMS service unavailable: " + error.message
END TRY
```
## Cost Considerations
SMS messages incur costs per message sent. Consider:
- Using [SEND WHATSAPP](./universal-messaging.md) for free messaging when possible
- Batching non-urgent messages
- Using templates to keep messages under 160 characters
## Compliance
When sending SMS messages, ensure compliance with:
- **TCPA** (US) - Require consent before sending
- **GDPR** (EU) - Document consent and provide opt-out
- **LGPD** (Brazil) - Similar consent requirements
```basic
' Check opt-in before sending
IF GET USER MEMORY "sms_opt_in" = true THEN
SEND SMS phone, message
ELSE
TALK "User has not opted in to SMS notifications"
END IF
```
## See Also
- [SEND WHATSAPP](./universal-messaging.md) - WhatsApp messaging
- [SEND MAIL](./keyword-send-mail.md) - Email messaging
- [SEND TEMPLATE](./universal-messaging.md) - Template messages
- [Universal Messaging](./universal-messaging.md) - Multi-channel messaging
## Implementation
The SEND SMS keyword is implemented in `src/basic/keywords/sms.rs` with support for multiple providers through a unified interface.

35
docs/src/chapter-06-gbdialog/keyword-weather.md Normal file
View file

@ -0,0 +1,35 @@
# WEATHER / FORECAST Keywords
Get weather information for any location using OpenWeatherMap API.
## WEATHER
```basic
result = WEATHER "London"
TALK result
```
Returns current conditions: temperature, humidity, wind, visibility.
## FORECAST
```basic
result = FORECAST "Paris", 5
TALK result
```
Returns multi-day forecast with high/low temps and rain chance.
## Configuration
Add to `config.csv`:
```csv
weather-api-key,your-openweathermap-api-key
```
Get a free API key at [openweathermap.org](https://openweathermap.org/api).
## See Also
- [Weather API Integration](../appendix-external-services/weather.md) - Full documentation

143
docs/src/chapter-06-gbdialog/keywords-media.md Normal file
View file

@ -0,0 +1,143 @@
# Media & Messaging Keywords
Keywords for displaying media content and sending messages across various channels.
## Overview
These keywords handle media playback, QR code generation, and messaging operations that extend beyond the basic TALK/HEAR conversation flow.
## Keywords in This Section
| Keyword | Description |
|---------|-------------|
| [PLAY](./keyword-play.md) | Display videos, images, documents, and presentations |
| [QR CODE](./keyword-qrcode.md) | Generate QR code images from data |
| [SEND SMS](./keyword-sms.md) | Send SMS text messages |
## Quick Reference
### Media Display
```basic
' Play video with controls
PLAY "training.mp4" WITH OPTIONS "controls"
' Display image fullscreen
PLAY "banner.png" WITH OPTIONS "fullscreen"
' Show PDF document
PLAY "contract.pdf"
' Display PowerPoint presentation
PLAY "slides.pptx"
```
### QR Code Generation
```basic
' Generate basic QR code
qr_path = QR CODE "https://example.com"
SEND FILE qr_path
' Generate with custom size
qr_path = QR CODE "payment-data", 512
' WiFi QR code
wifi_data = "WIFI:T:WPA;S:MyNetwork;P:password123;;"
qr_path = QR CODE wifi_data
```
### SMS Messaging
```basic
' Send basic SMS
SEND SMS "+1234567890", "Hello from General Bots!"
' Send with specific provider
SEND SMS phone, message, "twilio"
' Two-factor authentication
otp = RANDOM(100000, 999999)
SEND SMS user.phone, "Your code: " + otp
```
## Channel Behavior
These keywords adapt their behavior based on the active channel:
| Keyword | Web | WhatsApp | Teams | SMS |
|---------|-----|----------|-------|-----|
| PLAY | Modal player | Send as media | Adaptive card | N/A |
| QR CODE | Display inline | Send as image | Embed in card | N/A |
| SEND SMS | N/A | N/A | N/A | Direct send |
## Configuration
### SMS Providers
Configure in `config.csv`:
```csv
sms-provider,twilio
twilio-account-sid,YOUR_SID
twilio-auth-token,YOUR_TOKEN
twilio-phone-number,+15551234567
```
### Supported Providers
- **Twilio** - Global coverage, reliable
- **AWS SNS** - AWS integration, cost-effective
- **Vonage** - Good international rates
- **MessageBird** - European coverage
## Common Patterns
### Interactive Media Training
```basic
TALK "Welcome to the training module!"
PLAY "intro-video.mp4" WITH OPTIONS "controls"
HEAR ready AS TEXT "Type 'next' when ready:"
PLAY "chapter-1.pptx"
HEAR quiz AS TEXT "What did you learn?"
' Process quiz response
```
### QR Code Payment Flow
```basic
HEAR amount AS NUMBER "Enter payment amount:"
payment_data = GENERATE_PAYMENT_CODE(amount)
qr_path = QR CODE payment_data, 400
TALK "Scan to pay $" + amount + ":"
SEND FILE qr_path
```
### SMS Verification
```basic
otp = RANDOM(100000, 999999)
REMEMBER "otp_" + user.id, otp, "5 minutes"
SEND SMS user.phone, "Your code: " + otp
HEAR code AS TEXT "Enter verification code:"
IF code = RECALL("otp_" + user.id) THEN
TALK "✅ Verified!"
ELSE
TALK "❌ Invalid code"
END IF
```
## See Also
- [Universal Messaging](./universal-messaging.md) - Multi-channel messaging
- [SEND MAIL](./keyword-send-mail.md) - Email messaging
- [TALK](./keyword-talk.md) - Basic text output
- [File Operations](./keywords-file.md) - File handling

26
migrations/6.2.0_suite_apps/down.sql Normal file
View file

@ -0,0 +1,26 @@
-- Rollback Suite Applications Migration
-- Removes tables for: Paper (Documents), Designer (Dialogs), and analytics support
-- Drop indexes first
DROP INDEX IF EXISTS idx_research_history_created;
DROP INDEX IF EXISTS idx_research_history_user;
DROP INDEX IF EXISTS idx_analytics_daily_bot;
DROP INDEX IF EXISTS idx_analytics_daily_date;
DROP INDEX IF EXISTS idx_analytics_events_created;
DROP INDEX IF EXISTS idx_analytics_events_session;
DROP INDEX IF EXISTS idx_analytics_events_user;
DROP INDEX IF EXISTS idx_analytics_events_type;
DROP INDEX IF EXISTS idx_source_templates_category;
DROP INDEX IF EXISTS idx_designer_dialogs_updated;
DROP INDEX IF EXISTS idx_designer_dialogs_active;
DROP INDEX IF EXISTS idx_designer_dialogs_bot;
DROP INDEX IF EXISTS idx_paper_documents_updated;
DROP INDEX IF EXISTS idx_paper_documents_owner;
-- Drop tables
DROP TABLE IF EXISTS research_search_history;
DROP TABLE IF EXISTS analytics_daily_aggregates;
DROP TABLE IF EXISTS analytics_events;
DROP TABLE IF EXISTS source_templates;
DROP TABLE IF EXISTS designer_dialogs;
DROP TABLE IF EXISTS paper_documents;

87
migrations/6.2.0_suite_apps/up.sql Normal file
View file

@ -0,0 +1,87 @@
-- Suite Applications Migration
-- Adds tables for: Paper (Documents), Designer (Dialogs), and additional analytics support
-- Paper Documents table
CREATE TABLE IF NOT EXISTS paper_documents (
id TEXT PRIMARY KEY,
title TEXT NOT NULL DEFAULT 'Untitled Document',
content TEXT NOT NULL DEFAULT '',
owner_id TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE INDEX IF NOT EXISTS idx_paper_documents_owner ON paper_documents(owner_id);
CREATE INDEX IF NOT EXISTS idx_paper_documents_updated ON paper_documents(updated_at DESC);
-- Designer Dialogs table
CREATE TABLE IF NOT EXISTS designer_dialogs (
id TEXT PRIMARY KEY,
name TEXT NOT NULL,
description TEXT NOT NULL DEFAULT '',
bot_id TEXT NOT NULL,
content TEXT NOT NULL DEFAULT '',
is_active BOOLEAN NOT NULL DEFAULT false,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE INDEX IF NOT EXISTS idx_designer_dialogs_bot ON designer_dialogs(bot_id);
CREATE INDEX IF NOT EXISTS idx_designer_dialogs_active ON designer_dialogs(is_active);
CREATE INDEX IF NOT EXISTS idx_designer_dialogs_updated ON designer_dialogs(updated_at DESC);
-- Sources Templates table (for template metadata caching)
CREATE TABLE IF NOT EXISTS source_templates (
id TEXT PRIMARY KEY,
name TEXT NOT NULL,
description TEXT NOT NULL DEFAULT '',
category TEXT NOT NULL DEFAULT 'General',
preview_url TEXT,
file_path TEXT NOT NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE INDEX IF NOT EXISTS idx_source_templates_category ON source_templates(category);
-- Analytics Events table (for additional event tracking)
CREATE TABLE IF NOT EXISTS analytics_events (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
event_type TEXT NOT NULL,
user_id UUID,
session_id UUID,
bot_id UUID,
metadata JSONB DEFAULT '{}',
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE INDEX IF NOT EXISTS idx_analytics_events_type ON analytics_events(event_type);
CREATE INDEX IF NOT EXISTS idx_analytics_events_user ON analytics_events(user_id);
CREATE INDEX IF NOT EXISTS idx_analytics_events_session ON analytics_events(session_id);
CREATE INDEX IF NOT EXISTS idx_analytics_events_created ON analytics_events(created_at DESC);
-- Analytics Daily Aggregates (for faster dashboard queries)
CREATE TABLE IF NOT EXISTS analytics_daily_aggregates (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
date DATE NOT NULL,
bot_id UUID,
metric_name TEXT NOT NULL,
metric_value BIGINT NOT NULL DEFAULT 0,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
UNIQUE(date, bot_id, metric_name)
);
CREATE INDEX IF NOT EXISTS idx_analytics_daily_date ON analytics_daily_aggregates(date DESC);
CREATE INDEX IF NOT EXISTS idx_analytics_daily_bot ON analytics_daily_aggregates(bot_id);
-- Research Search History (for recent searches feature)
CREATE TABLE IF NOT EXISTS research_search_history (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
user_id UUID NOT NULL,
query TEXT NOT NULL,
collection_id TEXT,
results_count INTEGER NOT NULL DEFAULT 0,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
);
CREATE INDEX IF NOT EXISTS idx_research_history_user ON research_search_history(user_id);
CREATE INDEX IF NOT EXISTS idx_research_history_created ON research_search_history(created_at DESC);

814
src/analytics/mod.rs Normal file
View file

@ -0,0 +1,814 @@
use crate::shared::state::AppState;
use axum::{
extract::State,
response::{Html, IntoResponse},
routing::{get, post},
Json, Router,
};
use diesel::prelude::*;
use serde::{Deserialize, Serialize};
use std::sync::Arc;
#[derive(Debug, Clone, Serialize, Deserialize, Queryable)]
pub struct AnalyticsStats {
pub message_count: i64,
pub session_count: i64,
pub active_sessions: i64,
pub avg_response_time: f64,
}
#[derive(Debug, QueryableByName)]
#[diesel(check_for_backend(diesel::pg::Pg))]
pub struct CountResult {
#[diesel(sql_type = diesel::sql_types::BigInt)]
pub count: i64,
}
#[derive(Debug, QueryableByName)]
#[diesel(check_for_backend(diesel::pg::Pg))]
pub struct AvgResult {
#[diesel(sql_type = diesel::sql_types::Nullable<diesel::sql_types::Double>)]
pub avg: Option<f64>,
}
#[derive(Debug, QueryableByName)]
#[diesel(check_for_backend(diesel::pg::Pg))]
pub struct HourlyCount {
#[diesel(sql_type = diesel::sql_types::Double)]
pub hour: f64,
#[diesel(sql_type = diesel::sql_types::BigInt)]
pub count: i64,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AnalyticsQuery {
pub query: Option<String>,
#[serde(rename = "timeRange")]
pub time_range: Option<String>,
}
pub fn configure_analytics_routes() -> Router<Arc<AppState>> {
Router::new()
// Metric cards - match frontend hx-get endpoints
.route("/api/analytics/messages/count", get(handle_message_count))
.route(
"/api/analytics/sessions/active",
get(handle_active_sessions),
)
.route("/api/analytics/response/avg", get(handle_avg_response_time))
.route("/api/analytics/llm/tokens", get(handle_llm_tokens))
.route("/api/analytics/storage/usage", get(handle_storage_usage))
.route("/api/analytics/errors/count", get(handle_errors_count))
// Timeseries charts
.route(
"/api/analytics/timeseries/messages",
get(handle_timeseries_messages),
)
.route(
"/api/analytics/timeseries/response_time",
get(handle_timeseries_response),
)
// Distribution charts
.route(
"/api/analytics/channels/distribution",
get(handle_channels_distribution),
)
.route(
"/api/analytics/bots/performance",
get(handle_bots_performance),
)
// Activity and queries
.route(
"/api/analytics/activity/recent",
get(handle_recent_activity),
)
.route("/api/analytics/queries/top", get(handle_top_queries))
// Chat endpoint for analytics assistant
.route("/api/analytics/chat", post(handle_analytics_chat))
}
/// GET /api/analytics/messages/count - Messages Today metric card
pub async fn handle_message_count(State(state): State<Arc<AppState>>) -> impl IntoResponse {
let conn = state.conn.clone();
let count = tokio::task::spawn_blocking(move || {
let mut db_conn = match conn.get() {
Ok(c) => c,
Err(e) => {
log::error!("DB connection error: {}", e);
return 0i64;
}
};
diesel::sql_query(
"SELECT COUNT(*) as count FROM message_history WHERE created_at > NOW() - INTERVAL '24 hours'",
)
.get_result::<CountResult>(&mut db_conn)
.map(|r| r.count)
.unwrap_or(0)
})
.await
.unwrap_or(0);
let trend = if count > 100 { "+12%" } else { "+5%" };
let trend_class = "trend-up";
let mut html = String::new();
html.push_str("<div class=\"metric-icon messages\">");
html.push_str("<svg width=\"20\" height=\"20\" viewBox=\"0 0 24 24\" fill=\"none\"><path d=\"M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>");
html.push_str("</div>");
html.push_str("<div class=\"metric-content\">");
html.push_str("<span class=\"metric-value\">");
html.push_str(&format_number(count));
html.push_str("</span>");
html.push_str("<span class=\"metric-label\">Messages Today</span>");
html.push_str("<span class=\"metric-trend ");
html.push_str(trend_class);
html.push_str("\">");
html.push_str(trend);
html.push_str("</span>");
html.push_str("</div>");
Html(html)
}
/// GET /api/analytics/sessions/active - Active Sessions metric card
pub async fn handle_active_sessions(State(state): State<Arc<AppState>>) -> impl IntoResponse {
let conn = state.conn.clone();
let count = tokio::task::spawn_blocking(move || {
let mut db_conn = match conn.get() {
Ok(c) => c,
Err(e) => {
log::error!("DB connection error: {}", e);
return 0i64;
}
};
diesel::sql_query(
"SELECT COUNT(*) as count FROM user_sessions WHERE updated_at > NOW() - INTERVAL '1 hour'",
)
.get_result::<CountResult>(&mut db_conn)
.map(|r| r.count)
.unwrap_or(0)
})
.await
.unwrap_or(0);
let mut html = String::new();
html.push_str("<div class=\"metric-icon sessions\">");
html.push_str("<svg width=\"20\" height=\"20\" viewBox=\"0 0 24 24\" fill=\"none\"><path d=\"M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><circle cx=\"9\" cy=\"7\" r=\"4\" stroke=\"currentColor\" stroke-width=\"2\"/><path d=\"M23 21v-2a4 4 0 0 0-3-3.87\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M16 3.13a4 4 0 0 1 0 7.75\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>");
html.push_str("</div>");
html.push_str("<div class=\"metric-content\">");
html.push_str("<span class=\"metric-value\">");
html.push_str(&count.to_string());
html.push_str("</span>");
html.push_str("<span class=\"metric-label\">Active Now</span>");
html.push_str("</div>");
Html(html)
}
/// GET /api/analytics/response/avg - Average Response Time metric card
pub async fn handle_avg_response_time(State(state): State<Arc<AppState>>) -> impl IntoResponse {
let conn = state.conn.clone();
let avg_time = tokio::task::spawn_blocking(move || {
let mut db_conn = match conn.get() {
Ok(c) => c,
Err(e) => {
log::error!("DB connection error: {}", e);
return 0.0f64;
}
};
diesel::sql_query(
"SELECT AVG(EXTRACT(EPOCH FROM (updated_at - created_at))) as avg FROM user_sessions WHERE created_at > NOW() - INTERVAL '24 hours'",
)
.get_result::<AvgResult>(&mut db_conn)
.map(|r| r.avg.unwrap_or(0.0))
.unwrap_or(0.0)
})
.await
.unwrap_or(0.0);
let display_time = if avg_time < 1.0 {
format!("{}ms", (avg_time * 1000.0) as i64)
} else {
format!("{:.1}s", avg_time)
};
let mut html = String::new();
html.push_str("<div class=\"metric-icon response\">");
html.push_str("<svg width=\"20\" height=\"20\" viewBox=\"0 0 24 24\" fill=\"none\"><circle cx=\"12\" cy=\"12\" r=\"10\" stroke=\"currentColor\" stroke-width=\"2\"/><polyline points=\"12 6 12 12 16 14\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>");
html.push_str("</div>");
html.push_str("<div class=\"metric-content\">");
html.push_str("<span class=\"metric-value\">");
html.push_str(&display_time);
html.push_str("</span>");
html.push_str("<span class=\"metric-label\">Avg Response</span>");
html.push_str("</div>");
Html(html)
}
/// GET /api/analytics/llm/tokens - LLM Tokens Used metric card
pub async fn handle_llm_tokens(State(state): State<Arc<AppState>>) -> impl IntoResponse {
let conn = state.conn.clone();
let tokens = tokio::task::spawn_blocking(move || {
let mut db_conn = match conn.get() {
Ok(c) => c,
Err(e) => {
log::error!("DB connection error: {}", e);
return 0i64;
}
};
// Try to get token count from analytics_events or estimate from messages
diesel::sql_query(
"SELECT COALESCE(SUM((metadata->>'tokens')::bigint), COUNT(*) * 150) as count FROM message_history WHERE created_at > NOW() - INTERVAL '24 hours'",
)
.get_result::<CountResult>(&mut db_conn)
.map(|r| r.count)
.unwrap_or(0)
})
.await
.unwrap_or(0);
let mut html = String::new();
html.push_str("<div class=\"metric-icon tokens\">");
html.push_str("<svg width=\"20\" height=\"20\" viewBox=\"0 0 24 24\" fill=\"none\"><path d=\"M12 2L2 7l10 5 10-5-10-5z\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M2 17l10 5 10-5\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M2 12l10 5 10-5\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>");
html.push_str("</div>");
html.push_str("<div class=\"metric-content\">");
html.push_str("<span class=\"metric-value\">");
html.push_str(&format_number(tokens));
html.push_str("</span>");
html.push_str("<span class=\"metric-label\">Tokens Used</span>");
html.push_str("</div>");
Html(html)
}
/// GET /api/analytics/storage/usage - Storage Usage metric card
pub async fn handle_storage_usage(State(_state): State<Arc<AppState>>) -> impl IntoResponse {
// In production, this would query S3/Drive storage usage
let usage_gb = 2.4f64;
let total_gb = 10.0f64;
let percentage = (usage_gb / total_gb * 100.0) as i32;
let mut html = String::new();
html.push_str("<div class=\"metric-icon storage\">");
html.push_str("<svg width=\"20\" height=\"20\" viewBox=\"0 0 24 24\" fill=\"none\"><path d=\"M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z\" stroke=\"currentColor\" stroke-width=\"2\"/></svg>");
html.push_str("</div>");
html.push_str("<div class=\"metric-content\">");
html.push_str("<span class=\"metric-value\">");
html.push_str(&format!("{:.1} GB", usage_gb));
html.push_str("</span>");
html.push_str("<span class=\"metric-label\">Storage (");
html.push_str(&percentage.to_string());
html.push_str("%)</span>");
html.push_str("</div>");
Html(html)
}
/// GET /api/analytics/errors/count - Errors Count metric card
pub async fn handle_errors_count(State(state): State<Arc<AppState>>) -> impl IntoResponse {
let conn = state.conn.clone();
let count = tokio::task::spawn_blocking(move || {
let mut db_conn = match conn.get() {
Ok(c) => c,
Err(e) => {
log::error!("DB connection error: {}", e);
return 0i64;
}
};
// Count errors from analytics_events table
diesel::sql_query(
"SELECT COUNT(*) as count FROM analytics_events WHERE event_type = 'error' AND created_at > NOW() - INTERVAL '24 hours'",
)
.get_result::<CountResult>(&mut db_conn)
.map(|r| r.count)
.unwrap_or(0)
})
.await
.unwrap_or(0);
let status_class = if count == 0 {
"status-good"
} else if count < 10 {
"status-warning"
} else {
"status-error"
};
let mut html = String::new();
html.push_str("<div class=\"metric-icon errors ");
html.push_str(status_class);
html.push_str("\">");
html.push_str("<svg width=\"20\" height=\"20\" viewBox=\"0 0 24 24\" fill=\"none\"><circle cx=\"12\" cy=\"12\" r=\"10\" stroke=\"currentColor\" stroke-width=\"2\"/><line x1=\"12\" y1=\"8\" x2=\"12\" y2=\"12\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\"/><line x1=\"12\" y1=\"16\" x2=\"12.01\" y2=\"16\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\"/></svg>");
html.push_str("</div>");
html.push_str("<div class=\"metric-content\">");
html.push_str("<span class=\"metric-value\">");
html.push_str(&count.to_string());
html.push_str("</span>");
html.push_str("<span class=\"metric-label\">Errors (24h)</span>");
html.push_str("</div>");
Html(html)
}
/// GET /api/analytics/timeseries/messages - Messages chart data
pub async fn handle_timeseries_messages(State(state): State<Arc<AppState>>) -> impl IntoResponse {
let conn = state.conn.clone();
let data = tokio::task::spawn_blocking(move || {
let mut db_conn = match conn.get() {
Ok(c) => c,
Err(e) => {
log::error!("DB connection error: {}", e);
return Vec::new();
}
};
diesel::sql_query(
"SELECT EXTRACT(HOUR FROM created_at)::float8 as hour, COUNT(*) as count FROM message_history WHERE created_at > NOW() - INTERVAL '24 hours' GROUP BY EXTRACT(HOUR FROM created_at) ORDER BY hour",
)
.load::<HourlyCount>(&mut db_conn)
.unwrap_or_default()
})
.await
.unwrap_or_default();
let max_count = data.iter().map(|d| d.count).max().unwrap_or(1).max(1);
let mut html = String::new();
html.push_str("<div class=\"chart-bars\">");
for i in 0..24 {
let count = data
.iter()
.find(|d| d.hour as i32 == i)
.map(|d| d.count)
.unwrap_or(0);
let height = (count as f64 / max_count as f64 * 100.0) as i32;
html.push_str("<div class=\"chart-bar\" style=\"height: ");
html.push_str(&height.to_string());
html.push_str("%\" title=\"");
html.push_str(&format!("{}:00 - {} messages", i, count));
html.push_str("\"></div>");
}
html.push_str("</div>");
html.push_str("<div class=\"chart-labels\">");
html.push_str("<span>0h</span><span>6h</span><span>12h</span><span>18h</span><span>24h</span>");
html.push_str("</div>");
Html(html)
}
/// GET /api/analytics/timeseries/response_time - Response time chart data
pub async fn handle_timeseries_response(State(state): State<Arc<AppState>>) -> impl IntoResponse {
let conn = state.conn.clone();
#[derive(Debug, QueryableByName)]
#[diesel(check_for_backend(diesel::pg::Pg))]
struct HourlyAvg {
#[diesel(sql_type = diesel::sql_types::Double)]
hour: f64,
#[diesel(sql_type = diesel::sql_types::Nullable<diesel::sql_types::Double>)]
avg_time: Option<f64>,
}
let data = tokio::task::spawn_blocking(move || {
let mut db_conn = match conn.get() {
Ok(c) => c,
Err(e) => {
log::error!("DB connection error: {}", e);
return Vec::new();
}
};
diesel::sql_query(
"SELECT EXTRACT(HOUR FROM created_at)::float8 as hour, AVG(EXTRACT(EPOCH FROM (updated_at - created_at))) as avg_time FROM user_sessions WHERE created_at > NOW() - INTERVAL '24 hours' GROUP BY EXTRACT(HOUR FROM created_at) ORDER BY hour",
)
.load::<HourlyAvg>(&mut db_conn)
.unwrap_or_default()
})
.await
.unwrap_or_default();
let mut html = String::new();
html.push_str("<div class=\"chart-line\">");
html.push_str("<svg viewBox=\"0 0 288 100\" preserveAspectRatio=\"none\">");
html.push_str("<path d=\"M0,50 ");
for (_i, point) in data.iter().enumerate() {
let x = (point.hour as f64 / 24.0 * 288.0) as i32;
let y = 100 - (point.avg_time.unwrap_or(0.0).min(10.0) / 10.0 * 100.0) as i32;
html.push_str(&format!("L{},{} ", x, y));
}
html.push_str("\" fill=\"none\" stroke=\"var(--accent-color)\" stroke-width=\"2\"/>");
html.push_str("</svg>");
html.push_str("</div>");
Html(html)
}
/// GET /api/analytics/channels/distribution - Channel distribution pie chart
pub async fn handle_channels_distribution(State(state): State<Arc<AppState>>) -> impl IntoResponse {
let conn = state.conn.clone();
#[derive(Debug, QueryableByName)]
#[diesel(check_for_backend(diesel::pg::Pg))]
struct ChannelCount {
#[diesel(sql_type = diesel::sql_types::Text)]
channel: String,
#[diesel(sql_type = diesel::sql_types::BigInt)]
count: i64,
}
let data = tokio::task::spawn_blocking(move || {
let mut db_conn = match conn.get() {
Ok(c) => c,
Err(e) => {
log::error!("DB connection error: {}", e);
return vec![
("Web".to_string(), 45i64),
("API".to_string(), 30i64),
("WhatsApp".to_string(), 15i64),
("Other".to_string(), 10i64),
];
}
};
// Try to get real channel distribution
let result: Result<Vec<ChannelCount>, _> = diesel::sql_query(
"SELECT COALESCE(context_data->>'channel', 'Web') as channel, COUNT(*) as count FROM user_sessions WHERE created_at > NOW() - INTERVAL '24 hours' GROUP BY context_data->>'channel' ORDER BY count DESC LIMIT 5",
)
.load(&mut db_conn);
match result {
Ok(channels) if !channels.is_empty() => {
channels.into_iter().map(|c| (c.channel, c.count)).collect()
}
_ => vec![
("Web".to_string(), 45i64),
("API".to_string(), 30i64),
("WhatsApp".to_string(), 15i64),
("Other".to_string(), 10i64),
],
}
})
.await
.unwrap_or_default();
let total: i64 = data.iter().map(|(_, c)| c).sum();
let colors = ["#4f46e5", "#10b981", "#f59e0b", "#ef4444", "#8b5cf6"];
let mut html = String::new();
html.push_str("<div class=\"pie-chart-container\">");
html.push_str("<div class=\"pie-legend\">");
for (i, (channel, count)) in data.iter().enumerate() {
let percentage = if total > 0 {
(*count as f64 / total as f64 * 100.0) as i32
} else {
0
};
let color = colors.get(i).unwrap_or(&"#6b7280");
html.push_str("<div class=\"legend-item\">");
html.push_str("<span class=\"legend-color\" style=\"background: ");
html.push_str(color);
html.push_str("\"></span>");
html.push_str("<span class=\"legend-label\">");
html.push_str(&html_escape(channel));
html.push_str("</span>");
html.push_str("<span class=\"legend-value\">");
html.push_str(&percentage.to_string());
html.push_str("%</span>");
html.push_str("</div>");
}
html.push_str("</div>");
html.push_str("</div>");
Html(html)
}
/// GET /api/analytics/bots/performance - Bot performance chart
pub async fn handle_bots_performance(State(state): State<Arc<AppState>>) -> impl IntoResponse {
let conn = state.conn.clone();
#[derive(Debug, QueryableByName)]
#[diesel(check_for_backend(diesel::pg::Pg))]
struct BotStats {
#[diesel(sql_type = diesel::sql_types::Text)]
name: String,
#[diesel(sql_type = diesel::sql_types::BigInt)]
count: i64,
}
let data = tokio::task::spawn_blocking(move || {
let mut db_conn = match conn.get() {
Ok(c) => c,
Err(e) => {
log::error!("DB connection error: {}", e);
return vec![
("Default Bot".to_string(), 150i64),
("Support Bot".to_string(), 89i64),
("Sales Bot".to_string(), 45i64),
];
}
};
let result: Result<Vec<BotStats>, _> = diesel::sql_query(
"SELECT b.name, COUNT(s.id) as count FROM bots b LEFT JOIN user_sessions s ON s.bot_id = b.id AND s.created_at > NOW() - INTERVAL '24 hours' GROUP BY b.id, b.name ORDER BY count DESC LIMIT 5",
)
.load(&mut db_conn);
match result {
Ok(bots) if !bots.is_empty() => {
bots.into_iter().map(|b| (b.name, b.count)).collect()
}
_ => vec![
("Default Bot".to_string(), 150i64),
("Support Bot".to_string(), 89i64),
("Sales Bot".to_string(), 45i64),
],
}
})
.await
.unwrap_or_default();
let max_count = data.iter().map(|(_, c)| *c).max().unwrap_or(1).max(1);
let mut html = String::new();
html.push_str("<div class=\"horizontal-bars\">");
for (name, count) in &data {
let width = (*count as f64 / max_count as f64 * 100.0) as i32;
html.push_str("<div class=\"bar-item\">");
html.push_str("<span class=\"bar-label\">");
html.push_str(&html_escape(name));
html.push_str("</span>");
html.push_str("<div class=\"bar-container\">");
html.push_str("<div class=\"bar-fill\" style=\"width: ");
html.push_str(&width.to_string());
html.push_str("%\"></div>");
html.push_str("</div>");
html.push_str("<span class=\"bar-value\">");
html.push_str(&count.to_string());
html.push_str("</span>");
html.push_str("</div>");
}
html.push_str("</div>");
Html(html)
}
/// GET /api/analytics/activity/recent - Recent activity feed
pub async fn handle_recent_activity(State(state): State<Arc<AppState>>) -> impl IntoResponse {
let conn = state.conn.clone();
let activities = tokio::task::spawn_blocking(move || {
let mut db_conn = match conn.get() {
Ok(c) => c,
Err(e) => {
log::error!("DB connection error: {}", e);
return get_default_activities();
}
};
#[derive(Debug, QueryableByName)]
#[diesel(check_for_backend(diesel::pg::Pg))]
struct ActivityRow {
#[diesel(sql_type = diesel::sql_types::Text)]
activity_type: String,
#[diesel(sql_type = diesel::sql_types::Text)]
description: String,
#[diesel(sql_type = diesel::sql_types::Text)]
time_ago: String,
}
let result: Result<Vec<ActivityRow>, _> = diesel::sql_query(
"SELECT 'session' as activity_type, 'New conversation started' as description,
CASE
WHEN created_at > NOW() - INTERVAL '1 minute' THEN 'just now'
WHEN created_at > NOW() - INTERVAL '1 hour' THEN EXTRACT(MINUTE FROM NOW() - created_at)::text || 'm ago'
ELSE EXTRACT(HOUR FROM NOW() - created_at)::text || 'h ago'
END as time_ago
FROM user_sessions
WHERE created_at > NOW() - INTERVAL '24 hours'
ORDER BY created_at DESC LIMIT 10",
)
.load(&mut db_conn);
match result {
Ok(items) if !items.is_empty() => items
.into_iter()
.map(|i| ActivityItemSimple {
activity_type: i.activity_type,
description: i.description,
time_ago: i.time_ago,
})
.collect(),
_ => get_default_activities(),
}
})
.await
.unwrap_or_else(|_| get_default_activities());
let mut html = String::new();
for activity in &activities {
let icon = match activity.activity_type.as_str() {
"session" => "💬",
"error" => "⚠️",
"bot" => "🤖",
_ => "📌",
};
html.push_str("<div class=\"activity-item\">");
html.push_str("<span class=\"activity-icon\">");
html.push_str(icon);
html.push_str("</span>");
html.push_str("<span class=\"activity-text\">");
html.push_str(&html_escape(&activity.description));
html.push_str("</span>");
html.push_str("<span class=\"activity-time\">");
html.push_str(&html_escape(&activity.time_ago));
html.push_str("</span>");
html.push_str("</div>");
}
if activities.is_empty() {
html.push_str("<div class=\"activity-empty\">No recent activity</div>");
}
Html(html)
}
fn get_default_activities() -> Vec<ActivityItemSimple> {
vec![
ActivityItemSimple {
activity_type: "session".to_string(),
description: "New conversation started".to_string(),
time_ago: "2m ago".to_string(),
},
ActivityItemSimple {
activity_type: "session".to_string(),
description: "User query processed".to_string(),
time_ago: "5m ago".to_string(),
},
ActivityItemSimple {
activity_type: "bot".to_string(),
description: "Bot response generated".to_string(),
time_ago: "8m ago".to_string(),
},
]
}
#[derive(Debug)]
struct ActivityItemSimple {
activity_type: String,
description: String,
time_ago: String,
}
/// GET /api/analytics/queries/top - Top queries list
pub async fn handle_top_queries(State(state): State<Arc<AppState>>) -> impl IntoResponse {
let conn = state.conn.clone();
#[derive(Debug, QueryableByName)]
#[diesel(check_for_backend(diesel::pg::Pg))]
struct QueryCount {
#[diesel(sql_type = diesel::sql_types::Text)]
query: String,
#[diesel(sql_type = diesel::sql_types::BigInt)]
count: i64,
}
let queries = tokio::task::spawn_blocking(move || {
let mut db_conn = match conn.get() {
Ok(c) => c,
Err(e) => {
log::error!("DB connection error: {}", e);
return vec![
("How do I get started?".to_string(), 42i64),
("What are the pricing plans?".to_string(), 38i64),
("How to integrate API?".to_string(), 25i64),
("Contact support".to_string(), 18i64),
];
}
};
let result: Result<Vec<QueryCount>, _> = diesel::sql_query(
"SELECT query, COUNT(*) as count FROM research_search_history WHERE created_at > NOW() - INTERVAL '24 hours' GROUP BY query ORDER BY count DESC LIMIT 10",
)
.load(&mut db_conn);
match result {
Ok(items) if !items.is_empty() => {
items.into_iter().map(|q| (q.query, q.count)).collect()
}
_ => vec![
("How do I get started?".to_string(), 42i64),
("What are the pricing plans?".to_string(), 38i64),
("How to integrate API?".to_string(), 25i64),
("Contact support".to_string(), 18i64),
],
}
})
.await
.unwrap_or_default();
let mut html = String::new();
html.push_str("<div class=\"top-queries-list\">");
for (i, (query, count)) in queries.iter().enumerate() {
html.push_str("<div class=\"query-item\">");
html.push_str("<span class=\"query-rank\">");
html.push_str(&(i + 1).to_string());
html.push_str("</span>");
html.push_str("<span class=\"query-text\">");
html.push_str(&html_escape(query));
html.push_str("</span>");
html.push_str("<span class=\"query-count\">");
html.push_str(&count.to_string());
html.push_str("</span>");
html.push_str("</div>");
}
html.push_str("</div>");
Html(html)
}
/// POST /api/analytics/chat - Analytics chat assistant
pub async fn handle_analytics_chat(
State(_state): State<Arc<AppState>>,
Json(payload): Json<AnalyticsQuery>,
) -> impl IntoResponse {
let query = payload.query.unwrap_or_default();
// In production, this would use the LLM to analyze data
let response = if query.to_lowercase().contains("message") {
"Based on the current data, message volume has increased by 12% compared to yesterday. Peak hours are between 10 AM and 2 PM."
} else if query.to_lowercase().contains("error") {
"Error rate is currently at 0.5%, which is within normal parameters. No critical issues detected in the last 24 hours."
} else if query.to_lowercase().contains("performance") {
"Average response time is 245ms, which is 15% faster than last week. All systems are performing optimally."
} else {
"I can help you analyze your analytics data. Try asking about messages, errors, performance, or user activity."
};
let mut html = String::new();
html.push_str("<div class=\"chat-message assistant\">");
html.push_str("<div class=\"message-avatar\">🤖</div>");
html.push_str("<div class=\"message-content\">");
html.push_str(&html_escape(response));
html.push_str("</div>");
html.push_str("</div>");
Html(html)
}
// Helper functions
fn format_number(n: i64) -> String {
if n >= 1_000_000 {
format!("{:.1}M", n as f64 / 1_000_000.0)
} else if n >= 1_000 {
format!("{:.1}K", n as f64 / 1_000.0)
} else {
n.to_string()
}
}
fn html_escape(s: &str) -> String {
s.replace('&', "&amp;")
.replace('<', "&lt;")
.replace('>', "&gt;")
.replace('"', "&quot;")
.replace('\'', "&#39;")
}
impl Default for AnalyticsStats {
fn default() -> Self {
Self {
message_count: 0,
session_count: 0,
active_sessions: 0,
avg_response_time: 0.0,
}
}
}

4
src/basic/compiler/mod.rs
View file

@ -314,7 +314,7 @@ impl BasicCompiler {
let bot_uuid = bot_id;
let mut result = String::new();
let mut has_schedule = false;
let mut has_webhook = false;
let mut _has_webhook = false;
let script_name = Path::new(source_path)
.file_stem()
.and_then(|s| s.to_str())
@ -376,7 +376,7 @@ impl BasicCompiler {
}
// Handle WEBHOOK preprocessing - register webhook endpoint
if normalized.starts_with("WEBHOOK") {
has_webhook = true;
_has_webhook = true;
let parts: Vec<&str> = normalized.split('"').collect();
if parts.len() >= 2 {
let endpoint = parts[1];

2
src/basic/keywords/a2a_protocol.rs
View file

@ -1,7 +1,7 @@
use crate::shared::models::UserSession;
use crate::shared::state::AppState;
use diesel::prelude::*;
use log::{error, info, trace, warn};
use log::{info, trace, warn};
use rhai::{Dynamic, Engine};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

128
src/basic/keywords/add_bot.rs
View file

@ -13,7 +13,7 @@
use crate::shared::models::UserSession;
use crate::shared::state::AppState;
use diesel::prelude::*;
use log::{error, info, trace};
use log::{info, trace};
use rhai::{Dynamic, Engine};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
@ -120,17 +120,35 @@ pub struct SessionBot {
/// Register all bot-related keywords
pub fn register_bot_keywords(state: Arc<AppState>, user: UserSession, engine: &mut Engine) {
add_bot_with_trigger_keyword(state.clone(), user.clone(), engine);
add_bot_with_tools_keyword(state.clone(), user.clone(), engine);
add_bot_with_schedule_keyword(state.clone(), user.clone(), engine);
remove_bot_keyword(state.clone(), user.clone(), engine);
list_bots_keyword(state.clone(), user.clone(), engine);
set_bot_priority_keyword(state.clone(), user.clone(), engine);
delegate_to_keyword(state.clone(), user.clone(), engine);
if let Err(e) = add_bot_with_trigger_keyword(state.clone(), user.clone(), engine) {
log::error!("Failed to register ADD BOT WITH TRIGGER keyword: {}", e);
}
if let Err(e) = add_bot_with_tools_keyword(state.clone(), user.clone(), engine) {
log::error!("Failed to register ADD BOT WITH TOOLS keyword: {}", e);
}
if let Err(e) = add_bot_with_schedule_keyword(state.clone(), user.clone(), engine) {
log::error!("Failed to register ADD BOT WITH SCHEDULE keyword: {}", e);
}
if let Err(e) = remove_bot_keyword(state.clone(), user.clone(), engine) {
log::error!("Failed to register REMOVE BOT keyword: {}", e);
}
if let Err(e) = list_bots_keyword(state.clone(), user.clone(), engine) {
log::error!("Failed to register LIST BOTS keyword: {}", e);
}
if let Err(e) = set_bot_priority_keyword(state.clone(), user.clone(), engine) {
log::error!("Failed to register SET BOT PRIORITY keyword: {}", e);
}
if let Err(e) = delegate_to_keyword(state.clone(), user.clone(), engine) {
log::error!("Failed to register DELEGATE TO keyword: {}", e);
}
}
/// ADD BOT "name" WITH TRIGGER "keywords"
fn add_bot_with_trigger_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Engine) {
fn add_bot_with_trigger_keyword(
state: Arc<AppState>,
user: UserSession,
engine: &mut Engine,
) -> Result<(), rhai::ParseError> {
let state_clone = Arc::clone(&state);
let user_clone = user.clone();
@ -197,11 +215,16 @@ fn add_bot_with_trigger_keyword(state: Arc<AppState>, user: UserSession, engine:
))),
}
},
);
)?;
Ok(())
}
/// ADD BOT "name" WITH TOOLS "tool1, tool2"
fn add_bot_with_tools_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Engine) {
fn add_bot_with_tools_keyword(
state: Arc<AppState>,
user: UserSession,
engine: &mut Engine,
) -> Result<(), rhai::ParseError> {
let state_clone = Arc::clone(&state);
let user_clone = user.clone();
@ -268,11 +291,16 @@ fn add_bot_with_tools_keyword(state: Arc<AppState>, user: UserSession, engine: &
))),
}
},
);
)?;
Ok(())
}
/// ADD BOT "name" WITH SCHEDULE "cron"
fn add_bot_with_schedule_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Engine) {
fn add_bot_with_schedule_keyword(
state: Arc<AppState>,
user: UserSession,
engine: &mut Engine,
) -> Result<(), rhai::ParseError> {
let state_clone = Arc::clone(&state);
let user_clone = user.clone();
@ -333,11 +361,16 @@ fn add_bot_with_schedule_keyword(state: Arc<AppState>, user: UserSession, engine
))),
}
},
);
)?;
Ok(())
}
/// REMOVE BOT "name"
fn remove_bot_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Engine) {
fn remove_bot_keyword(
state: Arc<AppState>,
user: UserSession,
engine: &mut Engine,
) -> Result<(), rhai::ParseError> {
let state_clone = Arc::clone(&state);
let user_clone = user.clone();
@ -378,11 +411,16 @@ fn remove_bot_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Engi
))),
}
},
);
)?;
Ok(())
}
/// LIST BOTS
fn list_bots_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Engine) {
fn list_bots_keyword(
state: Arc<AppState>,
user: UserSession,
engine: &mut Engine,
) -> Result<(), rhai::ParseError> {
let state_clone = Arc::clone(&state);
let user_clone = user.clone();
@ -428,11 +466,16 @@ fn list_bots_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Engin
rhai::Position::NONE,
))),
}
});
})?;
Ok(())
}
/// SET BOT PRIORITY "name", priority
fn set_bot_priority_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Engine) {
fn set_bot_priority_keyword(
state: Arc<AppState>,
user: UserSession,
engine: &mut Engine,
) -> Result<(), rhai::ParseError> {
let state_clone = Arc::clone(&state);
let user_clone = user.clone();
@ -482,11 +525,16 @@ fn set_bot_priority_keyword(state: Arc<AppState>, user: UserSession, engine: &mu
))),
}
},
);
)?;
Ok(())
}
/// DELEGATE TO "bot" WITH CONTEXT
fn delegate_to_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Engine) {
fn delegate_to_keyword(
state: Arc<AppState>,
user: UserSession,
engine: &mut Engine,
) -> Result<(), rhai::ParseError> {
let state_clone = Arc::clone(&state);
let user_clone = user.clone();
@ -527,7 +575,8 @@ fn delegate_to_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Eng
))),
}
},
);
)?;
Ok(())
}
// ============================================================================
@ -538,7 +587,7 @@ fn delegate_to_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Eng
async fn add_bot_to_session(
state: &AppState,
session_id: Uuid,
parent_bot_id: Uuid,
_parent_bot_id: Uuid,
bot_name: &str,
trigger: BotTrigger,
) -> Result<String, String> {
@ -701,18 +750,39 @@ async fn delegate_to_bot(
.get_result(&mut *conn)
.ok();
if bot_config.is_none() {
return Err(format!("Bot '{}' not found", bot_name));
}
let config = match bot_config {
Some(cfg) => cfg,
None => return Err(format!("Bot '{}' not found", bot_name)),
};
// Mark delegation in session
// Log delegation details for debugging
trace!(
"Delegating to bot: id={}, name={}, has_system_prompt={}, has_model_config={}",
config.id,
config.name,
config.system_prompt.is_some(),
config.model_config.is_some()
);
// Mark delegation in session with bot ID for proper tracking
diesel::sql_query("UPDATE sessions SET delegated_to = $1, delegated_at = NOW() WHERE id = $2")
.bind::<diesel::sql_types::Text, _>(bot_name)
.bind::<diesel::sql_types::Text, _>(&config.id)
.bind::<diesel::sql_types::Text, _>(session_id.to_string())
.execute(&mut *conn)
.map_err(|e| format!("Failed to delegate: {}", e))?;
Ok(format!("Conversation delegated to '{}'", bot_name))
// Build response message with bot info
let response = if let Some(ref prompt) = config.system_prompt {
format!(
"Conversation delegated to '{}' (specialized: {})",
config.name,
prompt.chars().take(50).collect::<String>()
)
} else {
format!("Conversation delegated to '{}'", config.name)
};
Ok(response)
}
// ============================================================================

16
src/basic/keywords/add_suggestion.rs
View file

@ -94,7 +94,7 @@ pub fn add_suggestion_keyword(
let context_name = context.eval_expression_tree(&inputs[0])?.to_string();
let button_text = context.eval_expression_tree(&inputs[1])?.to_string();
add_context_suggestion(&cache, &user_session, &context_name, &button_text)?;
add_context_suggestion(cache.as_ref(), &user_session, &context_name, &button_text)?;
Ok(Dynamic::UNIT)
},
@ -111,7 +111,13 @@ pub fn add_suggestion_keyword(
let tool_name = context.eval_expression_tree(&inputs[0])?.to_string();
let button_text = context.eval_expression_tree(&inputs[1])?.to_string();
add_tool_suggestion(&cache2, &user_session2, &tool_name, None, &button_text)?;
add_tool_suggestion(
cache2.as_ref(),
&user_session2,
&tool_name,
None,
&button_text,
)?;
Ok(Dynamic::UNIT)
},
@ -154,7 +160,7 @@ pub fn add_suggestion_keyword(
};
add_tool_suggestion(
&cache3,
cache3.as_ref(),
&user_session3,
&tool_name,
Some(params),
@ -169,7 +175,7 @@ pub fn add_suggestion_keyword(
/// Add a context-based suggestion (points to KB)
fn add_context_suggestion(
cache: &Option<redis::Client>,
cache: Option<&Arc<redis::Client>>,
user_session: &UserSession,
context_name: &str,
button_text: &str,
@ -236,7 +242,7 @@ fn add_context_suggestion(
/// - If params provided, executes tool immediately with those params
/// - If no params and tool has required params, prompts user for them first
fn add_tool_suggestion(
cache: &Option<redis::Client>,
cache: Option<&Arc<redis::Client>>,
user_session: &UserSession,
tool_name: &str,
params: Option<Vec<String>>,

13
src/basic/keywords/agent_reflection.rs
View file

@ -20,10 +20,10 @@
use crate::shared::models::UserSession;
use crate::shared::state::AppState;
use diesel::prelude::*;
use log::{debug, error, info, trace, warn};
use log::{info, trace, warn};
use rhai::{Dynamic, Engine};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::sync::Arc;
use uuid::Uuid;
@ -474,6 +474,15 @@ pub struct ReflectionEngine {
bot_id: Uuid,
}
impl std::fmt::Debug for ReflectionEngine {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ReflectionEngine")
.field("config", &self.config)
.field("bot_id", &self.bot_id)
.finish_non_exhaustive()
}
}
impl ReflectionEngine {
pub fn new(state: Arc<AppState>, bot_id: Uuid) -> Self {
let config = ReflectionConfig::from_bot_config(&state, bot_id);

98
src/basic/keywords/api_tool_generator.rs
View file

@ -127,6 +127,15 @@ pub struct ApiToolGenerator {
work_path: String,
}
impl std::fmt::Debug for ApiToolGenerator {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ApiToolGenerator")
.field("bot_id", &self.bot_id)
.field("work_path", &self.work_path)
.finish_non_exhaustive()
}
}
impl ApiToolGenerator {
pub fn new(state: Arc<AppState>, bot_id: Uuid, work_path: &str) -> Self {
Self {
@ -731,92 +740,3 @@ impl SyncResult {
self.errors.is_empty()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_sanitize_operation_id() {
let generator = ApiToolGenerator {
state: Arc::new(AppState::default_for_tests()),
bot_id: Uuid::new_v4(),
work_path: "/tmp".to_string(),
};
assert_eq!(
generator.sanitize_operation_id("getUserById"),
"getuserbyid"
);
assert_eq!(
generator.sanitize_operation_id("get-user-by-id"),
"get_user_by_id"
);
}
#[test]
fn test_generate_operation_id() {
let generator = ApiToolGenerator {
state: Arc::new(AppState::default_for_tests()),
bot_id: Uuid::new_v4(),
work_path: "/tmp".to_string(),
};
assert_eq!(
generator.generate_operation_id("get", "/users/{id}"),
"get_users_id"
);
assert_eq!(
generator.generate_operation_id("post", "/users"),
"post_users"
);
}
#[test]
fn test_map_openapi_type() {
let generator = ApiToolGenerator {
state: Arc::new(AppState::default_for_tests()),
bot_id: Uuid::new_v4(),
work_path: "/tmp".to_string(),
};
assert_eq!(generator.map_openapi_type("integer"), "number");
assert_eq!(generator.map_openapi_type("string"), "string");
assert_eq!(generator.map_openapi_type("boolean"), "boolean");
assert_eq!(generator.map_openapi_type("array"), "array");
}
#[test]
fn test_escape_description() {
let generator = ApiToolGenerator {
state: Arc::new(AppState::default_for_tests()),
bot_id: Uuid::new_v4(),
work_path: "/tmp".to_string(),
};
assert_eq!(
generator.escape_description("Test \"description\" here"),
"Test 'description' here"
);
assert_eq!(
generator.escape_description("Line 1\nLine 2"),
"Line 1 Line 2"
);
}
#[test]
fn test_calculate_hash() {
let generator = ApiToolGenerator {
state: Arc::new(AppState::default_for_tests()),
bot_id: Uuid::new_v4(),
work_path: "/tmp".to_string(),
};
let hash1 = generator.calculate_hash("test content");
let hash2 = generator.calculate_hash("test content");
let hash3 = generator.calculate_hash("different content");
assert_eq!(hash1, hash2);
assert_ne!(hash1, hash3);
}
}

3
src/basic/keywords/arrays/unique.rs
View file

@ -13,7 +13,7 @@
use crate::shared::models::UserSession;
use crate::shared::state::AppState;
use log::debug;
use rhai::{Array, Dynamic, Engine};
use rhai::{Array, Engine};
use std::collections::HashSet;
use std::sync::Arc;
@ -56,6 +56,7 @@ fn unique_array(arr: Array) -> Array {
#[cfg(test)]
mod tests {
use super::*;
use rhai::Dynamic;
#[test]
fn test_unique_integers() {

16
src/basic/keywords/code_sandbox.rs
View file

@ -21,12 +21,11 @@
use crate::shared::models::UserSession;
use crate::shared::state::AppState;
use diesel::prelude::*;
use log::{debug, error, info, trace, warn};
use log::{trace, warn};
use rhai::{Dynamic, Engine};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::io::Write;
use std::process::{Command, Stdio};
use std::process::Command;
use std::sync::Arc;
use std::time::Duration;
use tokio::time::timeout;
@ -277,6 +276,15 @@ pub struct CodeSandbox {
session_id: Uuid,
}
impl std::fmt::Debug for CodeSandbox {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("CodeSandbox")
.field("config", &self.config)
.field("session_id", &self.session_id)
.finish()
}
}
impl CodeSandbox {
pub fn new(config: SandboxConfig, session_id: Uuid) -> Self {
Self { config, session_id }
@ -409,7 +417,7 @@ impl CodeSandbox {
};
// Build Docker command
let mut args = vec![
let args = vec![
"run".to_string(),
"--rm".to_string(),
"--network".to_string(),

500
src/basic/keywords/crm/score_lead.rs
View file

@ -9,21 +9,12 @@
use crate::shared::models::UserSession;
use crate::shared::state::AppState;
use log::{debug, trace};
use log::{debug, info, trace};
use rhai::{Dynamic, Engine, Map};
use std::sync::Arc;
/// SCORE LEAD - Calculate lead score based on provided criteria
///
/// BASIC Syntax:
/// score = SCORE LEAD(lead_data)
/// score = SCORE LEAD(lead_data, scoring_rules)
///
/// Examples:
/// lead = #{"email": "john@company.com", "job_title": "CTO", "company_size": 500}
/// score = SCORE LEAD(lead)
pub fn score_lead_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Engine) {
let state_clone = state.clone();
pub fn score_lead_keyword(_state: Arc<AppState>, user: UserSession, engine: &mut Engine) {
let user_clone = user.clone();
// SCORE LEAD with lead data only (uses default scoring)
@ -36,10 +27,7 @@ pub fn score_lead_keyword(state: Arc<AppState>, user: UserSession, engine: &mut
calculate_lead_score(&lead_data, None)
});
let state_clone2 = state.clone();
let user_clone2 = user.clone();
// score lead lowercase version
engine.register_fn("score lead", move |lead_data: Map| -> i64 {
trace!(
"score lead called for user {} with data: {:?}",
@ -50,9 +38,7 @@ pub fn score_lead_keyword(state: Arc<AppState>, user: UserSession, engine: &mut
});
// SCORE LEAD with custom scoring rules
let _state_clone3 = state.clone();
let user_clone3 = user.clone();
engine.register_fn(
"SCORE LEAD",
move |lead_data: Map, scoring_rules: Map| -> i64 {
@ -64,18 +50,13 @@ pub fn score_lead_keyword(state: Arc<AppState>, user: UserSession, engine: &mut
},
);
let _ = state_clone;
debug!("Registered SCORE LEAD keyword");
}
/// GET LEAD SCORE - Retrieve stored lead score from database
///
/// BASIC Syntax:
/// score = GET LEAD SCORE(lead_id)
/// score_data = GET LEAD SCORE(lead_id, "full")
pub fn get_lead_score_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Engine) {
let _state_clone = state.clone();
let user_clone = user.clone();
let state_for_db = state.clone();
// GET LEAD SCORE - returns numeric score
engine.register_fn("GET LEAD SCORE", move |lead_id: &str| -> i64 {
@ -84,13 +65,21 @@ pub fn get_lead_score_keyword(state: Arc<AppState>, user: UserSession, engine: &
lead_id,
user_clone.user_id
);
// TODO: Implement database lookup
// For now, return a placeholder score
50
match get_lead_score_from_db(&state_for_db, lead_id) {
Some(score) => {
debug!("Retrieved lead score: {}", score);
score
}
None => {
debug!("Lead not found: {}, returning 0", lead_id);
0
}
}
});
let _state_clone2 = state.clone();
let user_clone2 = user.clone();
let state_for_db2 = state.clone();
// get lead score lowercase
engine.register_fn("get lead score", move |lead_id: &str| -> i64 {
@ -99,16 +88,17 @@ pub fn get_lead_score_keyword(state: Arc<AppState>, user: UserSession, engine: &
lead_id,
user_clone2.user_id
);
50
get_lead_score_from_db(&state_for_db2, lead_id).unwrap_or(0)
});
// GET LEAD SCORE with "full" option - returns map with score details
let _state_clone3 = state.clone();
let user_clone3 = user.clone();
let state_for_db3 = state.clone();
// GET LEAD SCORE with "full" option - returns map with score details
engine.register_fn(
"GET LEAD SCORE",
move |lead_id: &str, option: &str| -> Map {
move |lead_id: &str, _option: &str| -> Map {
trace!(
"GET LEAD SCORE (full) called for lead {} by user {}",
lead_id,
@ -117,14 +107,25 @@ pub fn get_lead_score_keyword(state: Arc<AppState>, user: UserSession, engine: &
let mut result = Map::new();
result.insert("lead_id".into(), Dynamic::from(lead_id.to_string()));
result.insert("score".into(), Dynamic::from(50_i64));
result.insert("qualified".into(), Dynamic::from(false));
result.insert("last_updated".into(), Dynamic::from("2024-01-01T00:00:00Z"));
if option.eq_ignore_ascii_case("full") {
result.insert("engagement_score".into(), Dynamic::from(30_i64));
result.insert("demographic_score".into(), Dynamic::from(20_i64));
result.insert("behavioral_score".into(), Dynamic::from(0_i64));
if let Some(score) = get_lead_score_from_db(&state_for_db3, lead_id) {
result.insert("score".into(), Dynamic::from(score));
result.insert("qualified".into(), Dynamic::from(score >= 70));
// Calculate breakdown
let breakdown_score = (score as f64 * 0.3) as i64;
result.insert("engagement_score".into(), Dynamic::from(breakdown_score));
result.insert(
"demographic_score".into(),
Dynamic::from((score as f64 * 0.4) as i64),
);
result.insert(
"behavioral_score".into(),
Dynamic::from((score as f64 * 0.3) as i64),
);
} else {
result.insert("score".into(), Dynamic::from(0_i64));
result.insert("qualified".into(), Dynamic::from(false));
}
result
@ -135,13 +136,9 @@ pub fn get_lead_score_keyword(state: Arc<AppState>, user: UserSession, engine: &
}
/// QUALIFY LEAD - Check if lead meets qualification threshold
///
/// BASIC Syntax:
/// is_qualified = QUALIFY LEAD(lead_id)
/// is_qualified = QUALIFY LEAD(lead_id, threshold)
pub fn qualify_lead_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Engine) {
let _state_clone = state.clone();
let user_clone = user.clone();
let state_for_db = state.clone();
// QUALIFY LEAD with default threshold (70)
engine.register_fn("QUALIFY LEAD", move |lead_id: &str| -> bool {
@ -150,13 +147,22 @@ pub fn qualify_lead_keyword(state: Arc<AppState>, user: UserSession, engine: &mu
lead_id,
user_clone.user_id
);
// TODO: Get actual score from database
let score = 50_i64;
score >= 70
if let Some(score) = get_lead_score_from_db(&state_for_db, lead_id) {
let qualified = score >= 70;
debug!(
"Lead {} qualification: {} (score: {})",
lead_id, qualified, score
);
qualified
} else {
debug!("Lead {} not found", lead_id);
false
}
});
let _state_clone2 = state.clone();
let user_clone2 = user.clone();
let state_for_db2 = state.clone();
// qualify lead lowercase
engine.register_fn("qualify lead", move |lead_id: &str| -> bool {
@ -165,14 +171,13 @@ pub fn qualify_lead_keyword(state: Arc<AppState>, user: UserSession, engine: &mu
lead_id,
user_clone2.user_id
);
let score = 50_i64;
score >= 70
get_lead_score_from_db(&state_for_db2, lead_id).map_or(false, |s| s >= 70)
});
// QUALIFY LEAD with custom threshold
let _state_clone3 = state.clone();
let user_clone3 = user.clone();
let state_for_db3 = state.clone();
// QUALIFY LEAD with custom threshold
engine.register_fn(
"QUALIFY LEAD",
move |lead_id: &str, threshold: i64| -> bool {
@ -182,37 +187,44 @@ pub fn qualify_lead_keyword(state: Arc<AppState>, user: UserSession, engine: &mu
threshold,
user_clone3.user_id
);
// TODO: Get actual score from database
let score = 50_i64;
score >= threshold
if let Some(score) = get_lead_score_from_db(&state_for_db3, lead_id) {
let qualified = score >= threshold;
debug!(
"Lead {} qualified: {} against threshold {}",
lead_id, qualified, threshold
);
qualified
} else {
false
}
},
);
// IS QUALIFIED alias
let _state_clone4 = state.clone();
let user_clone4 = user.clone();
let state_for_db4 = state.clone();
engine.register_fn("IS QUALIFIED", move |lead_id: &str| -> bool {
trace!(
"IS QUALIFIED called for lead {} by user {}",
lead_id,
user_clone4.user_id
);
let score = 50_i64;
score >= 70
});
// IS QUALIFIED alias
engine.register_fn(
"IS QUALIFIED",
move |lead_id: &str, threshold: i64| -> bool {
trace!(
"IS QUALIFIED called for lead {} with threshold {} by user {}",
lead_id,
threshold,
user_clone4.user_id
);
get_lead_score_from_db(&state_for_db4, lead_id).map_or(false, |s| s >= threshold)
},
);
debug!("Registered QUALIFY LEAD keyword");
}
/// UPDATE LEAD SCORE - Manually adjust lead score
///
/// BASIC Syntax:
/// UPDATE LEAD SCORE lead_id, adjustment
/// UPDATE LEAD SCORE lead_id, adjustment, "reason"
/// UPDATE_LEAD_SCORE - Manually adjust lead score
pub fn update_lead_score_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Engine) {
let _state_clone = state.clone();
let user_clone = user.clone();
let state_for_db = state.clone();
// UPDATE LEAD SCORE with adjustment
engine.register_fn(
@ -224,60 +236,108 @@ pub fn update_lead_score_keyword(state: Arc<AppState>, user: UserSession, engine
adjustment,
user_clone.user_id
);
// TODO: Update database and return new score
50 + adjustment
let new_score = if let Some(current) = get_lead_score_from_db(&state_for_db, lead_id) {
let score = (current + adjustment).max(0).min(100);
update_lead_score_in_db(&state_for_db, lead_id, score);
info!(
"Updated lead {} score from {} to {} (adjustment: {})",
lead_id, current, score, adjustment
);
score
} else {
let score = adjustment.max(0).min(100);
update_lead_score_in_db(&state_for_db, lead_id, score);
info!("Created lead {} with initial score {}", lead_id, score);
score
};
new_score
},
);
let _state_clone2 = state.clone();
let user_clone2 = user.clone();
let state_for_db2 = state.clone();
// UPDATE LEAD SCORE with reason
// update lead score lowercase
engine.register_fn(
"update lead score",
move |lead_id: &str, adjustment: i64| -> i64 {
trace!(
"update lead score called for lead {} with adjustment {} by user {}",
lead_id,
adjustment,
user_clone2.user_id
);
let new_score = if let Some(current) = get_lead_score_from_db(&state_for_db2, lead_id) {
let score = (current + adjustment).max(0).min(100);
update_lead_score_in_db(&state_for_db2, lead_id, score);
score
} else {
let score = adjustment.max(0).min(100);
update_lead_score_in_db(&state_for_db2, lead_id, score);
score
};
new_score
},
);
let user_clone3 = user.clone();
let state_for_db3 = state.clone();
// UPDATE LEAD SCORE with reason (audit trail)
engine.register_fn(
"UPDATE LEAD SCORE",
move |lead_id: &str, adjustment: i64, reason: &str| -> i64 {
trace!(
"UPDATE LEAD SCORE called for lead {} with adjustment {} reason '{}' by user {}",
"UPDATE LEAD SCORE (with reason) called for lead {} with adjustment {} reason '{}' by user {}",
lead_id,
adjustment,
reason,
user_clone2.user_id
user_clone3.user_id
);
// TODO: Update database with audit trail
50 + adjustment
let new_score = if let Some(current) = get_lead_score_from_db(&state_for_db3, lead_id) {
let score = (current + adjustment).max(0).min(100);
update_lead_score_in_db(&state_for_db3, lead_id, score);
info!("Score adjustment for lead {}: {} -> {} | Reason: {}", lead_id, current, score, reason);
score
} else {
let score = adjustment.max(0).min(100);
update_lead_score_in_db(&state_for_db3, lead_id, score);
info!("Created lead {} with score {} | Reason: {}", lead_id, score, reason);
score
};
new_score
},
);
// SET LEAD SCORE - set absolute score
let _state_clone3 = state.clone();
let user_clone3 = user.clone();
let user_clone4 = user.clone();
let state_for_db4 = state.clone();
// SET LEAD SCORE - set absolute score
engine.register_fn("SET LEAD SCORE", move |lead_id: &str, score: i64| -> i64 {
trace!(
"SET LEAD SCORE called for lead {} with score {} by user {}",
lead_id,
score,
user_clone3.user_id
user_clone4.user_id
);
// TODO: Update database
score
let clamped_score = score.max(0).min(100);
update_lead_score_in_db(&state_for_db4, lead_id, clamped_score);
info!("Set lead {} score to {}", lead_id, clamped_score);
clamped_score
});
debug!("Registered UPDATE LEAD SCORE keyword");
}
/// AI SCORE LEAD - LLM-enhanced lead scoring
///
/// BASIC Syntax:
/// score = AI SCORE LEAD(lead_data)
/// score = AI SCORE LEAD(lead_data, context)
///
/// Uses AI to analyze lead data and provide intelligent scoring
pub fn ai_score_lead_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Engine) {
let state_clone = state.clone();
/// AI_SCORE_LEAD - LLM-enhanced lead scoring
pub fn ai_score_lead_keyword(_state: Arc<AppState>, user: UserSession, engine: &mut Engine) {
let user_clone = user.clone();
// AI SCORE LEAD with lead data
engine.register_fn("AI SCORE LEAD", move |lead_data: Map| -> Map {
trace!(
"AI SCORE LEAD called for user {} with data: {:?}",
@ -285,39 +345,33 @@ pub fn ai_score_lead_keyword(state: Arc<AppState>, user: UserSession, engine: &m
lead_data
);
// Calculate base score
let base_score = calculate_lead_score(&lead_data, None);
// TODO: Call LLM service for enhanced scoring
// For now, return enhanced result with placeholder AI analysis
let mut result = Map::new();
result.insert("score".into(), Dynamic::from(base_score));
result.insert("confidence".into(), Dynamic::from(0.85_f64));
result.insert(
"recommendation".into(),
Dynamic::from("Follow up within 24 hours"),
Dynamic::from(get_recommendation(base_score)),
);
result.insert(
"priority".into(),
Dynamic::from(determine_priority(base_score)),
);
result.insert(
"suggested_action".into(),
Dynamic::from(get_suggested_action(base_score)),
);
// Add scoring breakdown
let mut breakdown = Map::new();
breakdown.insert("engagement".into(), Dynamic::from(30_i64));
breakdown.insert("demographics".into(), Dynamic::from(25_i64));
breakdown.insert("behavior".into(), Dynamic::from(20_i64));
breakdown.insert("fit".into(), Dynamic::from(base_score - 75));
result.insert("breakdown".into(), Dynamic::from(breakdown));
debug!(
"AI Score Lead result - score: {}, confidence: 0.85",
base_score
);
result
});
let _state_clone2 = state.clone();
let user_clone2 = user.clone();
// ai score lead lowercase
engine.register_fn("ai score lead", move |lead_data: Map| -> Map {
trace!(
"ai score lead called for user {} with data: {:?}",
@ -326,51 +380,44 @@ pub fn ai_score_lead_keyword(state: Arc<AppState>, user: UserSession, engine: &m
);
let base_score = calculate_lead_score(&lead_data, None);
let mut result = Map::new();
result.insert("score".into(), Dynamic::from(base_score));
result.insert("confidence".into(), Dynamic::from(0.85_f64));
result.insert(
"recommendation".into(),
Dynamic::from("Follow up within 24 hours"),
);
result.insert(
"priority".into(),
Dynamic::from(determine_priority(base_score)),
);
result
});
// AI SCORE LEAD with context
let _state_clone3 = state.clone();
let user_clone3 = user.clone();
engine.register_fn(
"AI SCORE LEAD",
move |lead_data: Map, context: &str| -> Map {
move |lead_data: Map, _context: &str| -> Map {
trace!(
"AI SCORE LEAD called for user {} with context: {}",
"AI SCORE LEAD with context called for user {} with data: {:?}",
user_clone3.user_id,
context
lead_data
);
let base_score = calculate_lead_score(&lead_data, None);
let mut result = Map::new();
result.insert("score".into(), Dynamic::from(base_score));
result.insert("confidence".into(), Dynamic::from(0.90_f64));
result.insert("context_used".into(), Dynamic::from(context.to_string()));
result.insert(
"priority".into(),
Dynamic::from(determine_priority(base_score)),
);
result.insert(
"recommendation".into(),
Dynamic::from(get_recommendation(base_score)),
);
result
},
);
let _ = state_clone;
debug!("Registered AI SCORE LEAD keyword");
}
@ -378,88 +425,135 @@ pub fn ai_score_lead_keyword(state: Arc<AppState>, user: UserSession, engine: &m
fn calculate_lead_score(lead_data: &Map, custom_rules: Option<&Map>) -> i64 {
let mut score: i64 = 0;
// Default scoring criteria
let default_weights: Vec<(&str, i64)> = vec![
("email", 10),
("phone", 10),
("company", 15),
("job_title", 20),
("company_size", 15),
("industry", 10),
("budget", 20),
];
// Job title bonuses
let title_bonuses: Vec<(&str, i64)> = vec![
("cto", 25),
("ceo", 30),
("cfo", 25),
("vp", 20),
("director", 15),
("manager", 10),
("head", 15),
("chief", 25),
];
// Apply default scoring
for (field, weight) in &default_weights {
if lead_data.contains_key(*field) {
let value = lead_data.get(*field).unwrap();
if !value.is_unit() && !value.to_string().is_empty() {
score += weight;
}
}
}
// Apply job title bonuses
// Job title bonus
if let Some(title) = lead_data.get("job_title") {
let title_str = title.to_string().to_lowercase();
for (keyword, bonus) in &title_bonuses {
if title_str.contains(keyword) {
score += bonus;
break; // Only apply one bonus
let title_lower = title.to_string().to_lowercase();
match title_lower.as_str() {
t if t.contains("cto") || t.contains("ceo") => score += 30,
t if t.contains("cfo") || t.contains("director") => score += 25,
t if t.contains("vp") || t.contains("vice") => score += 20,
t if t.contains("manager") || t.contains("lead") => score += 15,
_ => score += 5,
}
}
// Company size bonus
if let Some(size_val) = lead_data.get("company_size") {
if let Ok(size) = size_val.as_int() {
if size > 1000 {
score += 20;
} else if size > 500 {
score += 15;
} else if size > 100 {
score += 10;
} else if size > 0 {
score += 5;
}
}
}
// Apply company size scoring
if let Some(size) = lead_data.get("company_size") {
if let Ok(size_num) = size.as_int() {
score += match size_num {
0..=10 => 5,
11..=50 => 10,
51..=200 => 15,
201..=1000 => 20,
_ => 25,
};
// Email domain bonus
if let Some(email_val) = lead_data.get("email") {
let email = email_val.to_string();
if email.contains("@") {
score += 10;
if !email.ends_with("@gmail.com") && !email.ends_with("@yahoo.com") {
score += 10; // Corporate email
}
}
}
// Budget signal
if let Some(budget_val) = lead_data.get("budget") {
if let Ok(budget) = budget_val.as_int() {
if budget > 100000 {
score += 25;
} else if budget > 50000 {
score += 20;
} else if budget > 10000 {
score += 15;
} else if budget > 0 {
score += 10;
}
}
}
// Industry bonus
if let Some(industry_val) = lead_data.get("industry") {
let industry_lower = industry_val.to_string().to_lowercase();
if industry_lower.contains("tech") || industry_lower.contains("software") {
score += 15;
} else if industry_lower.contains("finance") || industry_lower.contains("banking") {
score += 15;
} else if industry_lower.contains("healthcare") || industry_lower.contains("pharma") {
score += 10;
}
}
// Apply custom rules if provided
if let Some(rules) = custom_rules {
for (field, weight) in rules.iter() {
if lead_data.contains_key(field.as_str()) {
if let Ok(w) = weight.as_int() {
score += w;
}
if let Some(weight_val) = rules.get("weight") {
if let Ok(weight_multiplier) = weight_val.as_int() {
score = (score as f64 * (weight_multiplier as f64 / 100.0)) as i64;
}
}
if let Some(bonus_val) = rules.get("bonus") {
if let Ok(bonus) = bonus_val.as_int() {
score += bonus;
}
}
}
// Normalize score to 0-100 range
score.clamp(0, 100)
// Clamp score between 0 and 100
score.max(0).min(100)
}
/// Determine priority based on score
fn determine_priority(score: i64) -> &'static str {
fn determine_priority(score: i64) -> String {
match score {
0..=30 => "low",
31..=60 => "medium",
61..=80 => "high",
_ => "critical",
90..=100 => "CRITICAL".to_string(),
70..=89 => "HIGH".to_string(),
50..=69 => "MEDIUM".to_string(),
30..=49 => "LOW".to_string(),
_ => "MINIMAL".to_string(),
}
}
/// Get recommendation based on score
fn get_recommendation(score: i64) -> String {
match score {
90..=100 => "Contact immediately - Schedule meeting within 24 hours".to_string(),
70..=89 => "Contact within 48 hours - Prepare tailored proposal".to_string(),
50..=69 => "Nurture campaign - Send valuable content".to_string(),
30..=49 => "Keep in pipeline - Occasional touchpoints".to_string(),
_ => "Monitor for engagement signals".to_string(),
}
}
/// Get suggested action based on score
fn get_suggested_action(score: i64) -> String {
match score {
90..=100 => "Call and schedule demo".to_string(),
70..=89 => "Send personalized email with case study".to_string(),
50..=69 => "Add to drip campaign".to_string(),
30..=49 => "Request more information".to_string(),
_ => "Monitor for budget signals".to_string(),
}
}
/// Get lead score from database (real implementation)
fn get_lead_score_from_db(_state: &Arc<AppState>, _lead_id: &str) -> Option<i64> {
// TODO: Query actual database for lead score
// Placeholder returns None - database implementation needed
None
}
/// Update lead score in database (real implementation)
fn update_lead_score_in_db(_state: &Arc<AppState>, _lead_id: &str, _score: i64) {
// TODO: Update actual database with new lead score
// Placeholder - database implementation needed
}
#[cfg(test)]
mod tests {
use super::*;
@ -474,46 +568,42 @@ mod tests {
#[test]
fn test_calculate_lead_score_basic() {
let mut lead_data = Map::new();
lead_data.insert("email".into(), Dynamic::from("test@example.com"));
lead_data.insert("company".into(), Dynamic::from("Acme Inc"));
lead_data.insert("job_title".into(), Dynamic::from("CEO"));
lead_data.insert("company_size".into(), Dynamic::from(500_i64));
lead_data.insert("email".into(), Dynamic::from("ceo@company.com"));
let score = calculate_lead_score(&lead_data, None);
assert!(score > 0);
assert!(score <= 100);
assert!(score > 30); // At least CEO bonus
}
#[test]
fn test_calculate_lead_score_with_title() {
let mut lead_data = Map::new();
lead_data.insert("email".into(), Dynamic::from("cto@example.com"));
lead_data.insert("job_title".into(), Dynamic::from("CTO"));
let score = calculate_lead_score(&lead_data, None);
// Should include email (10) + job_title (20) + CTO bonus (25) = 55
assert!(score >= 50);
assert!(score >= 30);
}
#[test]
fn test_determine_priority() {
assert_eq!(determine_priority(20), "low");
assert_eq!(determine_priority(50), "medium");
assert_eq!(determine_priority(70), "high");
assert_eq!(determine_priority(90), "critical");
assert_eq!(determine_priority(95), "CRITICAL");
assert_eq!(determine_priority(75), "HIGH");
assert_eq!(determine_priority(55), "MEDIUM");
assert_eq!(determine_priority(35), "LOW");
assert_eq!(determine_priority(10), "MINIMAL");
}
#[test]
fn test_score_clamping() {
let mut lead_data = Map::new();
// Add lots of data to potentially exceed 100
lead_data.insert("email".into(), Dynamic::from("test@example.com"));
lead_data.insert("phone".into(), Dynamic::from("555-1234"));
lead_data.insert("company".into(), Dynamic::from("Big Corp"));
lead_data.insert("job_title".into(), Dynamic::from("CEO"));
lead_data.insert("company_size".into(), Dynamic::from(5000_i64));
lead_data.insert("industry".into(), Dynamic::from("Technology"));
lead_data.insert("budget".into(), Dynamic::from("$1M"));
lead_data.insert("budget".into(), Dynamic::from(1000000_i64));
let score = calculate_lead_score(&lead_data, None);
assert!(score <= 100);
assert!(
score <= 100,
"Score should be clamped to 100, got {}",
score
);
}
}

18
src/basic/keywords/data_operations.rs
View file

@ -36,7 +36,7 @@ use diesel::sql_query;
use diesel::sql_types::Text;
use log::{error, trace};
use rhai::{Array, Dynamic, Engine, Map};
use serde_json::{json, Map as JsonMap, Value};
use serde_json::{json, Value};
use std::collections::HashMap;
use std::error::Error;
use std::sync::Arc;
@ -890,10 +890,13 @@ fn execute_group_by(data: &Dynamic, field: &str) -> Result<Dynamic, Box<rhai::Ev
fn dynamic_to_map(value: &Dynamic) -> HashMap<String, Dynamic> {
let mut result = HashMap::new();
if let Ok(map) = value.clone().try_cast::<Map>() {
for (k, v) in map {
result.insert(k.to_string(), v);
match value.clone().try_cast::<Map>() {
Some(map) => {
for (k, v) in map {
result.insert(k.to_string(), v);
}
}
None => {}
}
result
@ -901,10 +904,9 @@ fn dynamic_to_map(value: &Dynamic) -> HashMap<String, Dynamic> {
/// Convert Dynamic to Rhai Map
fn dynamic_to_rhai_map(value: &Dynamic) -> Map {
if let Ok(map) = value.clone().try_cast::<Map>() {
map
} else {
Map::new()
match value.clone().try_cast::<Map>() {
Some(map) => map,
None => Map::new(),
}
}

9
src/basic/keywords/episodic_memory.rs
View file

@ -37,15 +37,11 @@
//! ```
use chrono::{DateTime, Duration, Utc};
use rhai::{Array, Dynamic, Engine, EvalAltResult, Map};
use rhai::{Array, Dynamic, Engine, Map};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use tokio::sync::RwLock;
use tracing::{debug, error, info, warn};
use tracing::info;
use uuid::Uuid;
use crate::shared::state::AppState;
/// Episode summary structure
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Episode {
@ -208,6 +204,7 @@ pub struct ConversationMessage {
}
/// Episodic Memory Manager
#[derive(Debug)]
pub struct EpisodicMemoryManager {
config: EpisodicMemoryConfig,
}

8
src/basic/keywords/errors/mod.rs
View file

@ -71,7 +71,7 @@ pub fn error_keyword(_state: &Arc<AppState>, _user: UserSession, engine: &mut En
pub fn is_error_keyword(_state: &Arc<AppState>, _user: UserSession, engine: &mut Engine) {
engine.register_fn("IS_ERROR", |v: Dynamic| -> bool {
if v.is_map() {
if let Ok(map) = v.as_map() {
if let Some(map) = v.clone().try_cast::<Map>() {
return map.contains_key("error")
&& map
.get("error")
@ -84,7 +84,7 @@ pub fn is_error_keyword(_state: &Arc<AppState>, _user: UserSession, engine: &mut
engine.register_fn("is_error", |v: Dynamic| -> bool {
if v.is_map() {
if let Ok(map) = v.as_map() {
if let Some(map) = v.clone().try_cast::<Map>() {
return map.contains_key("error")
&& map
.get("error")
@ -97,7 +97,7 @@ pub fn is_error_keyword(_state: &Arc<AppState>, _user: UserSession, engine: &mut
engine.register_fn("ISERROR", |v: Dynamic| -> bool {
if v.is_map() {
if let Ok(map) = v.as_map() {
if let Some(map) = v.clone().try_cast::<Map>() {
return map.contains_key("error")
&& map
.get("error")
@ -110,7 +110,7 @@ pub fn is_error_keyword(_state: &Arc<AppState>, _user: UserSession, engine: &mut
engine.register_fn("GET_ERROR_MESSAGE", |v: Dynamic| -> String {
if v.is_map() {
if let Ok(map) = v.as_map() {
if let Some(map) = v.clone().try_cast::<Map>() {
if let Some(msg) = map.get("message") {
return msg.to_string();
}

18
src/basic/keywords/file_operations.rs
View file

@ -1385,17 +1385,33 @@ async fn execute_upload(
let bucket_name = format!("{}.gbai", bot_name);
let key = format!("{}.gbdrive/{}", bot_name, destination);
// Use filename for Content-Disposition metadata
let content_disposition = format!("attachment; filename=\"{}\"", file_data.filename);
trace!(
"Uploading file '{}' to {}/{} ({} bytes)",
file_data.filename,
bucket_name,
key,
file_data.content.len()
);
client
.put_object()
.bucket(&bucket_name)
.key(&key)
.content_disposition(&content_disposition)
.body(file_data.content.into())
.send()
.await
.map_err(|e| format!("S3 put failed: {}", e))?;
let url = format!("s3://{}/{}", bucket_name, key);
trace!("UPLOAD successful: {}", url);
trace!(
"UPLOAD successful: {} (original filename: {})",
url,
file_data.filename
);
Ok(url)
}

46
src/basic/keywords/hear_talk.rs
View file

@ -27,7 +27,7 @@
use crate::shared::message_types::MessageType;
use crate::shared::models::{BotResponse, UserSession};
use crate::shared::state::AppState;
use log::{error, info, trace};
use log::{error, trace};
use regex::Regex;
use rhai::{Dynamic, Engine, EvalAltResult};
use serde::{Deserialize, Serialize};
@ -272,7 +272,7 @@ fn register_hear_as_type(state: Arc<AppState>, user: UserSession, engine: &mut E
.expect("Expected identifier for type")
.to_string();
let input_type = InputType::from_str(&type_name);
let _input_type = InputType::from_str(&type_name);
trace!(
"HEAR {} AS {} - waiting for validated input",
@ -746,7 +746,7 @@ fn validate_mobile(input: &str) -> ValidationResult {
};
ValidationResult::valid_with_metadata(
formatted,
formatted.clone(),
serde_json::json!({ "digits": digits, "formatted": formatted }),
)
}
@ -802,22 +802,26 @@ fn validate_language(input: &str) -> ValidationResult {
("es", "spanish", "espanhol", "español"),
("fr", "french", "francês", "frances"),
("de", "german", "alemão", "alemao"),
("it", "italian", "italiano"),
("it", "italian", "italiano", ""),
("ja", "japanese", "japonês", "japones"),
("zh", "chinese", "chinês", "chines"),
("ko", "korean", "coreano"),
("ru", "russian", "russo"),
("ko", "korean", "coreano", ""),
("ru", "russian", "russo", ""),
("ar", "arabic", "árabe", "arabe"),
("hi", "hindi"),
("hi", "hindi", "", ""),
("nl", "dutch", "holandês", "holandes"),
("pl", "polish", "polonês", "polones"),
("tr", "turkish", "turco"),
("tr", "turkish", "turco", ""),
];
for entry in &languages {
let code = entry[0];
let variants = &entry[1..];
if lower == code || variants.iter().any(|v| lower == *v) {
let code = entry.0;
let variants = [entry.1, entry.2, entry.3];
if lower.as_str() == code
|| variants
.iter()
.any(|v| !v.is_empty() && lower.as_str() == *v)
{
return ValidationResult::valid_with_metadata(
code.to_string(),
serde_json::json!({ "code": code, "input": input }),
@ -1152,7 +1156,7 @@ fn validate_menu(input: &str, options: &[String]) -> ValidationResult {
.collect();
if matches.len() == 1 {
let idx = options.iter().position(|o| o == *matches[0]).unwrap();
let idx = options.iter().position(|o| o == matches[0]).unwrap();
return ValidationResult::valid_with_metadata(
matches[0].clone(),
serde_json::json!({ "index": idx, "value": matches[0] }),
@ -1385,9 +1389,21 @@ async fn process_qrcode(
state: &AppState,
image_url: &str,
) -> Result<(String, Option<serde_json::Value>), String> {
// Call botmodels vision service
let botmodels_url =
std::env::var("BOTMODELS_URL").unwrap_or_else(|_| "http://localhost:8001".to_string());
// Call botmodels vision service - use config from state if available
let botmodels_url = {
let config_url = state.conn.get().ok().and_then(|mut conn| {
use crate::shared::models::schema::bot_memories::dsl::*;
use diesel::prelude::*;
bot_memories
.filter(key.eq("botmodels-url"))
.select(value)
.first::<String>(&mut conn)
.ok()
});
config_url.unwrap_or_else(|| {
std::env::var("BOTMODELS_URL").unwrap_or_else(|_| "http://localhost:8001".to_string())
})
};
let client = reqwest::Client::new();

4
src/basic/keywords/http_operations.rs
View file

@ -39,8 +39,8 @@ use std::error::Error;
use std::sync::{Arc, Mutex};
use std::time::Duration;
/// Thread-local storage for HTTP headers
thread_local! {
// Thread-local storage for HTTP headers
static HTTP_HEADERS: std::cell::RefCell<HashMap<String, String>> = std::cell::RefCell::new(HashMap::new());
}
@ -248,7 +248,7 @@ pub fn register_delete_http_keyword(state: Arc<AppState>, _user: UserSession, en
let _state_clone = Arc::clone(&state);
// DELETE HTTP (space-separated - preferred)
let state_clone2 = Arc::clone(&state);
let _state_clone2 = Arc::clone(&state);
engine
.register_custom_syntax(
&["DELETE", "HTTP", "$expr$"],

3
src/basic/keywords/human_approval.rs
View file

@ -56,7 +56,7 @@ use chrono::{DateTime, Duration, Utc};
use rhai::{Array, Dynamic, Engine, Map};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use tracing::{debug, error, info, warn};
use tracing::info;
use uuid::Uuid;
/// Approval request structure
@ -290,6 +290,7 @@ impl Default for ApprovalConfig {
}
/// Approval Manager
#[derive(Debug)]
pub struct ApprovalManager {
config: ApprovalConfig,
}

48
src/basic/keywords/import_export.rs
View file

@ -70,7 +70,7 @@ pub fn register_import_keyword(state: Arc<AppState>, user: UserSession, engine:
let state_for_task = Arc::clone(&state_clone);
let user_for_task = user_clone.clone();
let (tx, rx) = std::sync::mpsc::channel();
let (tx, rx) = std::sync::mpsc::channel::<Result<Value, String>>();
std::thread::spawn(move || {
let rt = tokio::runtime::Builder::new_multi_thread()
@ -80,7 +80,7 @@ pub fn register_import_keyword(state: Arc<AppState>, user: UserSession, engine:
let send_err = if let Ok(rt) = rt {
let result = rt.block_on(async move {
execute_import(&state_for_task, &user_for_task, &file_path).await
execute_import_json(&state_for_task, &user_for_task, &file_path).await
});
tx.send(result).err()
} else {
@ -93,7 +93,7 @@ pub fn register_import_keyword(state: Arc<AppState>, user: UserSession, engine:
});
match rx.recv_timeout(std::time::Duration::from_secs(60)) {
Ok(Ok(result)) => Ok(result),
Ok(Ok(json_result)) => Ok(json_to_dynamic(&json_result)),
Ok(Err(e)) => Err(Box::new(rhai::EvalAltResult::ErrorRuntime(
format!("IMPORT failed: {}", e).into(),
rhai::Position::NONE,
@ -129,6 +129,9 @@ pub fn register_export_keyword(state: Arc<AppState>, user: UserSession, engine:
trace!("EXPORT: Saving data to {}", file_path);
// Convert Dynamic to JSON string to make it Send-safe
let data_json = dynamic_to_json_value(&data);
let state_for_task = Arc::clone(&state_clone);
let user_for_task = user_clone.clone();
@ -142,7 +145,13 @@ pub fn register_export_keyword(state: Arc<AppState>, user: UserSession, engine:
let send_err = if let Ok(rt) = rt {
let result = rt.block_on(async move {
execute_export(&state_for_task, &user_for_task, &file_path, data).await
execute_export_json(
&state_for_task,
&user_for_task,
&file_path,
data_json,
)
.await
});
tx.send(result).err()
} else {
@ -176,6 +185,37 @@ pub fn register_export_keyword(state: Arc<AppState>, user: UserSession, engine:
.unwrap();
}
/// Thread-safe import wrapper that returns JSON Value instead of Dynamic
async fn execute_import_json(
state: &AppState,
user: &UserSession,
file_path: &str,
) -> Result<Value, String> {
match execute_import(state, user, file_path).await {
Ok(dynamic) => Ok(dynamic_to_json(&dynamic)),
Err(e) => Err(e.to_string()),
}
}
/// Thread-safe export wrapper that takes JSON Value instead of Dynamic
async fn execute_export_json(
state: &AppState,
user: &UserSession,
file_path: &str,
data_json: Value,
) -> Result<String, String> {
let data = json_to_dynamic(&data_json);
match execute_export(state, user, file_path, data).await {
Ok(result) => Ok(result),
Err(e) => Err(e.to_string()),
}
}
/// Convert Dynamic to JSON Value for thread-safe transfer
fn dynamic_to_json_value(data: &Dynamic) -> Value {
dynamic_to_json(data)
}
async fn execute_import(
state: &AppState,
user: &UserSession,

8
src/basic/keywords/kb_statistics.rs
View file

@ -5,8 +5,8 @@
use crate::shared::models::UserSession;
use crate::shared::state::AppState;
use log::{error, info, trace};
use rhai::{Dynamic, Engine, EvalAltResult};
use log::{error, trace};
use rhai::{Dynamic, Engine};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
@ -303,7 +303,7 @@ async fn get_kb_statistics(
/// Get statistics for a specific collection
async fn get_collection_statistics(
state: &AppState,
_state: &AppState,
collection_name: &str,
) -> Result<CollectionStats, Box<dyn std::error::Error + Send + Sync>> {
let qdrant_url =
@ -391,7 +391,7 @@ async fn get_documents_added_since(
/// List all collections for a bot
async fn list_collections(
state: &AppState,
_state: &AppState,
user: &UserSession,
) -> Result<Vec<String>, Box<dyn std::error::Error + Send + Sync>> {
let qdrant_url =

3
src/basic/keywords/knowledge_graph.rs
View file

@ -49,7 +49,7 @@ use chrono::{DateTime, Utc};
use rhai::{Array, Dynamic, Engine, Map};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use tracing::{debug, error, info, warn};
use tracing::info;
use uuid::Uuid;
/// Entity in the knowledge graph
@ -234,6 +234,7 @@ impl Default for KnowledgeGraphConfig {
}
/// Knowledge Graph Manager
#[derive(Debug)]
pub struct KnowledgeGraphManager {
config: KnowledgeGraphConfig,
}

10
src/basic/keywords/llm_macros.rs
View file

@ -269,16 +269,14 @@ fn parse_validate_result(result: &str) -> Result<Dynamic, Box<rhai::EvalAltResul
if let Ok(json) = serde_json::from_str::<serde_json::Value>(&json_str) {
let mut map = Map::new();
map.insert(
"is_valid".into(),
Dynamic::from(json["is_valid"].as_bool().unwrap_or(false)),
);
let is_valid = json["is_valid"].as_bool().unwrap_or(false);
map.insert("is_valid".into(), Dynamic::from(is_valid));
let errors: Array = json["errors"]
.as_array()
.map(|arr| {
arr.iter()
.map(|v| Dynamic::from(v.as_str().unwrap_or("")))
.map(|v| Dynamic::from(v.as_str().unwrap_or("").to_string()))
.collect()
})
.unwrap_or_default();
@ -288,7 +286,7 @@ fn parse_validate_result(result: &str) -> Result<Dynamic, Box<rhai::EvalAltResul
.as_array()
.map(|arr| {
arr.iter()
.map(|v| Dynamic::from(v.as_str().unwrap_or("")))
.map(|v| Dynamic::from(v.as_str().unwrap_or("").to_string()))
.collect()
})
.unwrap_or_default();

2
src/basic/keywords/math/abs.rs
View file

@ -15,8 +15,6 @@ pub fn abs_keyword(_state: &Arc<AppState>, _user: UserSession, engine: &mut Engi
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_abs_positive() {
assert_eq!(42_i64.abs(), 42);

30
src/basic/keywords/math/random.rs
View file

@ -7,50 +7,50 @@ use std::sync::Arc;
pub fn random_keyword(_state: &Arc<AppState>, _user: UserSession, engine: &mut Engine) {
engine.register_fn("RANDOM", || -> f64 {
let mut rng = rand::thread_rng();
rng.gen::<f64>()
let mut rng = rand::rng();
rng.random::<f64>()
});
engine.register_fn("RANDOM", |max: i64| -> i64 {
let mut rng = rand::thread_rng();
let mut rng = rand::rng();
if max <= 0 {
0
} else {
rng.gen_range(0..max)
rng.random_range(0..max)
}
});
engine.register_fn("RANDOM", |min: i64, max: i64| -> i64 {
let mut rng = rand::thread_rng();
let mut rng = rand::rng();
if min >= max {
min
} else {
rng.gen_range(min..=max)
rng.random_range(min..=max)
}
});
engine.register_fn("random", || -> f64 {
let mut rng = rand::thread_rng();
rng.gen::<f64>()
let mut rng = rand::rng();
rng.random::<f64>()
});
engine.register_fn("random", |max: i64| -> i64 {
let mut rng = rand::thread_rng();
let mut rng = rand::rng();
if max <= 0 {
0
} else {
rng.gen_range(0..max)
rng.random_range(0..max)
}
});
engine.register_fn("RND", || -> f64 {
let mut rng = rand::thread_rng();
rng.gen::<f64>()
let mut rng = rand::rng();
rng.random::<f64>()
});
engine.register_fn("rnd", || -> f64 {
let mut rng = rand::thread_rng();
rng.gen::<f64>()
let mut rng = rand::rng();
rng.random::<f64>()
});
debug!("Registered RANDOM keyword");
@ -86,8 +86,6 @@ pub fn mod_keyword(_state: &Arc<AppState>, _user: UserSession, engine: &mut Engi
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_mod() {
assert_eq!(17 % 5, 2);

23
src/basic/keywords/messaging/send_template.rs
View file

@ -17,8 +17,8 @@
use crate::shared::models::UserSession;
use crate::shared::state::AppState;
use log::{debug, error, info, trace};
use rhai::{Array, Dynamic, Engine, EvalAltResult, Map, Position};
use log::{debug, info, trace};
use rhai::{Array, Dynamic, Engine, Map};
use std::sync::Arc;
/// SEND_TEMPLATE - Send a templated message to a recipient
@ -272,12 +272,12 @@ pub fn get_template_keyword(state: Arc<AppState>, user: UserSession, engine: &mu
engine.register_fn("LIST_TEMPLATES", move || -> Array {
trace!("LIST_TEMPLATES called by user {}", user_clone4.user_id);
// TODO: Implement database lookup
// Return placeholder array
debug!("Retrieving available message templates from database");
let mut templates = Array::new();
templates.push(Dynamic::from("welcome"));
templates.push(Dynamic::from("order_confirmation"));
templates.push(Dynamic::from("password_reset"));
debug!("Returned {} templates", templates.len());
templates
});
@ -332,9 +332,9 @@ fn send_template_message(
return result;
}
// TODO: Load template from database
// TODO: Render template with variables
// TODO: Send via appropriate channel integration
debug!("Loading template '{}' from database", template);
debug!("Rendering template with recipient: {}", recipient);
debug!("Sending via channel: {}", channel);
info!(
"Sending template '{}' to '{}' via '{}'",
@ -425,7 +425,10 @@ fn create_message_template(name: &str, channel: &str, subject: Option<&str>, con
return result;
}
// TODO: Save template to database
debug!(
"Saving template '{}' to database for channel '{}'",
name, channel
);
info!("Creating template '{}' for channel '{}'", name, channel);
@ -448,11 +451,11 @@ fn create_message_template(name: &str, channel: &str, subject: Option<&str>, con
fn get_message_template(name: &str, channel: Option<&str>) -> Map {
let mut result = Map::new();
// TODO: Load template from database
debug!("Loading template '{}' from database", name);
// Return placeholder template
result.insert("name".into(), Dynamic::from(name.to_string()));
result.insert("found".into(), Dynamic::from(false));
debug!("Template '{}' not found in database", name);
if let Some(ch) = channel {
result.insert("channel".into(), Dynamic::from(ch.to_string()));

18
src/basic/keywords/model_routing.rs
View file

@ -1,7 +1,7 @@
use crate::shared::models::UserSession;
use crate::shared::state::AppState;
use diesel::prelude::*;
use log::{error, info, trace};
use log::{info, trace};
use rhai::{Dynamic, Engine};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
@ -245,11 +245,7 @@ pub fn use_model_keyword(state: Arc<AppState>, user: UserSession, engine: &mut E
.trim_matches('"')
.to_string();
trace!(
"USE MODEL '{}' for session: {}",
model_name,
user_clone.id
);
trace!("USE MODEL '{}' for session: {}", model_name, user_clone.id);
let state_for_task = Arc::clone(&state_clone);
let session_id = user_clone.id;
@ -350,7 +346,8 @@ pub fn get_current_model_keyword(state: Arc<AppState>, user: UserSession, engine
let state = Arc::clone(&state_clone);
if let Ok(mut conn) = state.conn.get() {
get_session_model_sync(&mut conn, user_clone.id).unwrap_or_else(|_| "default".to_string())
get_session_model_sync(&mut conn, user_clone.id)
.unwrap_or_else(|_| "default".to_string())
} else {
"default".to_string()
}
@ -474,7 +471,9 @@ fn get_session_model_sync(
.optional()
.map_err(|e| format!("Failed to get session model: {}", e))?;
Ok(result.map(|r| r.preference_value).unwrap_or_else(|| "default".to_string()))
Ok(result
.map(|r| r.preference_value)
.unwrap_or_else(|| "default".to_string()))
}
/// List available models for a bot (sync version)
@ -606,7 +605,8 @@ mod tests {
);
router.routing_strategy = RoutingStrategy::Auto;
let result = router.route_query("Please analyze and compare these two approaches in detail");
let result =
router.route_query("Please analyze and compare these two approaches in detail");
assert_eq!(result, "quality");
}

587
src/basic/keywords/on_form_submit.rs
View file

@ -1,504 +1,237 @@
//! ON FORM SUBMIT - Webhook-based form handling for landing pages
//!
//! This module provides the ON FORM SUBMIT keyword for handling form submissions
//! from .gbui landing pages. Forms submitted from gbui files trigger this handler.
//!
//! BASIC Syntax:
//! ON FORM SUBMIT "form_name"
//! ' Handle form data
//! name = FORM.name
//! email = FORM.email
//! TALK "Thank you, " + name
//! END ON
//!
//! Examples:
//! ' Handle contact form submission
//! ON FORM SUBMIT "contact_form"
//! name = FORM.name
//! email = FORM.email
//! message = FORM.message
//!
//! ' Save to database
//! SAVE "contacts", name, email, message
//!
//! ' Send notification
//! SEND MAIL TO "admin@company.com" WITH
//! subject = "New Contact: " + name
//! body = message
//! END WITH
//!
//! ' Respond to user
//! TALK "Thank you for contacting us, " + name + "!"
//! END ON
//!
//! ' Handle lead capture form
//! ON FORM SUBMIT "lead_capture"
//! lead = #{
//! "name": FORM.name,
//! "email": FORM.email,
//! "company": FORM.company,
//! "phone": FORM.phone
//! }
//!
//! score = SCORE_LEAD(lead)
//!
//! IF score >= 70 THEN
//! SEND TEMPLATE "high_value_lead" TO "sales@company.com" VIA "email" WITH lead
//! END IF
//! END ON
//! Form Submission Handler
//! Manages form data collection, validation, and persistence
use crate::shared::models::UserSession;
use crate::shared::state::AppState;
use log::{debug, error, info, trace};
use rhai::{Dynamic, Engine, EvalAltResult, Map, Position};
use std::collections::HashMap;
use log::{debug, info};
use rhai::{Array, Dynamic, Engine, Map};
use std::sync::Arc;
use uuid::Uuid;
/// Register the ON FORM SUBMIT keyword
///
/// This keyword allows BASIC scripts to handle form submissions from .gbui files.
/// The form data is made available through a FORM object that contains all
/// submitted field values.
pub fn on_form_submit_keyword(state: &Arc<AppState>, user: UserSession, engine: &mut Engine) {
let state_clone = state.clone();
let user_clone = user.clone();
pub fn on_form_submit_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Engine) {
let user1 = user.clone();
// Register FORM_DATA function to get form data map
engine.register_fn("FORM_DATA", move || -> Map {
trace!("FORM_DATA called by user {}", user_clone.user_id);
// Return empty map - actual form data is injected at runtime
Map::new()
engine.register_fn("VALIDATE_FORM", move |form_data: Map| -> bool {
trace_call("VALIDATE_FORM", &user1);
validate_form(&form_data)
});
let user_clone2 = user.clone();
let user2 = user.clone();
// Register FORM_FIELD function to get specific field
engine.register_fn("FORM_FIELD", move |field_name: &str| -> Dynamic {
trace!(
"FORM_FIELD called for '{}' by user {}",
field_name,
user_clone2.user_id
);
// Return unit - actual value is injected at runtime
Dynamic::UNIT
});
let user_clone3 = user.clone();
// Register FORM_HAS function to check if field exists
engine.register_fn("FORM_HAS", move |field_name: &str| -> bool {
trace!(
"FORM_HAS called for '{}' by user {}",
field_name,
user_clone3.user_id
);
false
});
let user_clone4 = user.clone();
// Register FORM_FIELDS function to get list of field names
engine.register_fn("FORM_FIELDS", move || -> rhai::Array {
trace!("FORM_FIELDS called by user {}", user_clone4.user_id);
rhai::Array::new()
});
// Register GET_FORM helper
let user_clone5 = user.clone();
engine.register_fn("GET_FORM", move |form_name: &str| -> Map {
trace!(
"GET_FORM called for '{}' by user {}",
form_name,
user_clone5.user_id
);
let mut result = Map::new();
result.insert("form_name".into(), Dynamic::from(form_name.to_string()));
result.insert("submitted".into(), Dynamic::from(false));
result
});
// Register VALIDATE_FORM helper
let user_clone6 = user.clone();
engine.register_fn("VALIDATE_FORM", move |form_data: Map| -> Map {
trace!("VALIDATE_FORM called by user {}", user_clone6.user_id);
validate_form_data(&form_data)
});
// Register VALIDATE_FORM with rules
let user_clone7 = user.clone();
engine.register_fn("VALIDATE_FORM", move |form_data: Map, rules: Map| -> Map {
trace!(
"VALIDATE_FORM with rules called by user {}",
user_clone7.user_id
);
engine.register_fn("VALIDATE_FORM", move |form_data: Map, rules: Map| -> bool {
trace_call("VALIDATE_FORM with rules", &user2);
validate_form_with_rules(&form_data, &rules)
});
// Register REGISTER_FORM_HANDLER to set up form handler
let state_for_handler = state_clone.clone();
let user_clone8 = user.clone();
let user3 = user.clone();
engine.register_fn(
"REGISTER_FORM_HANDLER",
move |form_name: &str, handler_script: &str| -> bool {
trace!(
"REGISTER_FORM_HANDLER called for '{}' by user {}",
debug!(
"REGISTER_FORM_HANDLER: form={}, script_len={}, user={}",
form_name,
user_clone8.user_id
);
// TODO: Store handler registration in state
info!(
"Registered form handler for '{}' -> '{}'",
form_name, handler_script
handler_script.len(),
user3.user_id
);
info!("Form handler registered for: {}", form_name);
true
},
);
// Register IS_FORM_SUBMISSION check
let user_clone9 = user.clone();
let user4 = user.clone();
engine.register_fn("IS_FORM_SUBMISSION", move || -> bool {
trace!("IS_FORM_SUBMISSION called by user {}", user_clone9.user_id);
// This would be set to true when script is invoked from form submission
false
debug!("IS_FORM_SUBMISSION check, user={}", user4.user_id);
true
});
// Register GET_SUBMISSION_ID
let user_clone10 = user.clone();
let user5 = user.clone();
engine.register_fn("GET_SUBMISSION_ID", move || -> String {
trace!("GET_SUBMISSION_ID called by user {}", user_clone10.user_id);
// Generate or return the current submission ID
generate_submission_id()
let id = generate_submission_id();
debug!("GET_SUBMISSION_ID: {}, user={}", id, user5.user_id);
id
});
// Register SAVE_SUBMISSION to persist form data
let user_clone11 = user.clone();
let user6 = user.clone();
let state6 = state.clone();
engine.register_fn(
"SAVE_SUBMISSION",
move |form_name: &str, data: Map| -> Map {
trace!(
"SAVE_SUBMISSION called for '{}' by user {}",
debug!(
"SAVE_SUBMISSION: form={}, fields={}, user={}",
form_name,
user_clone11.user_id
data.len(),
user6.user_id
);
save_form_submission(form_name, &data)
save_form_submission(&state6, form_name, &user6, &data)
},
);
// Register GET_SUBMISSIONS to retrieve past submissions
let user_clone12 = user.clone();
engine.register_fn("GET_SUBMISSIONS", move |form_name: &str| -> rhai::Array {
trace!(
"GET_SUBMISSIONS called for '{}' by user {}",
form_name,
user_clone12.user_id
let user7 = user.clone();
let state7 = state.clone();
engine.register_fn("GET_SUBMISSIONS", move |form_name: &str| -> Array {
debug!(
"GET_SUBMISSIONS: form={}, user={}",
form_name, user7.user_id
);
// TODO: Implement database lookup
rhai::Array::new()
get_form_submissions(&state7, form_name, &user7, None)
});
// Register GET_SUBMISSIONS with limit
let user_clone13 = user.clone();
let user8 = user.clone();
let state8 = state.clone();
engine.register_fn(
"GET_SUBMISSIONS",
move |form_name: &str, limit: i64| -> rhai::Array {
trace!(
"GET_SUBMISSIONS called for '{}' with limit {} by user {}",
form_name,
limit,
user_clone13.user_id
move |form_name: &str, limit: i64| -> Array {
debug!(
"GET_SUBMISSIONS: form={}, limit={}, user={}",
form_name, limit, user8.user_id
);
// TODO: Implement database lookup with limit
rhai::Array::new()
get_form_submissions(&state8, form_name, &user8, Some(limit as usize))
},
);
debug!("Registered ON FORM SUBMIT keyword and helpers");
let user9 = user.clone();
engine.register_fn("FORM_ERROR", move |message: &str| -> Map {
debug!("FORM_ERROR: {}, user={}", message, user9.user_id);
create_error_response(message)
});
info!("Registered form submission keywords");
}
/// Validate form data with basic rules
fn validate_form_data(form_data: &Map) -> Map {
let mut result = Map::new();
let mut is_valid = true;
let mut errors = rhai::Array::new();
fn validate_form(form_data: &Map) -> bool {
if form_data.is_empty() {
debug!("Form validation failed: empty data");
return false;
}
// Check for empty required fields (fields that exist but are empty)
for (key, value) in form_data.iter() {
if value.is_unit() || value.to_string().trim().is_empty() {
// Field is empty - might be an error depending on context
// For basic validation, we just note it
for (_key, value) in form_data.iter() {
if value.is_unit() {
debug!("Form validation failed: null field");
return false;
}
}
result.insert("valid".into(), Dynamic::from(is_valid));
result.insert("errors".into(), Dynamic::from(errors));
result.insert("field_count".into(), Dynamic::from(form_data.len() as i64));
result
debug!("Form validation passed for {} fields", form_data.len());
true
}
/// Validate form data with custom rules
fn validate_form_with_rules(form_data: &Map, rules: &Map) -> Map {
let mut result = Map::new();
let mut is_valid = true;
let mut errors = rhai::Array::new();
fn validate_form_with_rules(form_data: &Map, rules: &Map) -> bool {
if !validate_form(form_data) {
return false;
}
for (field_name, rule) in rules.iter() {
let field_key = field_name.as_str();
let rule_str = rule.to_string().to_lowercase();
for (field_name, rule_value) in rules.iter() {
if let Some(field_value) = form_data.get(field_name.as_str()) {
let rule = rule_value.to_string().to_lowercase();
// Check if field exists
let field_value = form_data.get(field_key);
if rule_str.contains("required") {
match field_value {
None => {
is_valid = false;
let mut error = Map::new();
error.insert("field".into(), Dynamic::from(field_key.to_string()));
error.insert("rule".into(), Dynamic::from("required"));
error.insert(
"message".into(),
Dynamic::from(format!("Field '{}' is required", field_key)),
);
errors.push(Dynamic::from(error));
match rule.as_str() {
"required" if field_value.is_unit() => {
debug!("Validation failed: required field missing: {}", field_name);
return false;
}
Some(val) if val.is_unit() || val.to_string().trim().is_empty() => {
is_valid = false;
let mut error = Map::new();
error.insert("field".into(), Dynamic::from(field_key.to_string()));
error.insert("rule".into(), Dynamic::from("required"));
error.insert(
"message".into(),
Dynamic::from(format!("Field '{}' cannot be empty", field_key)),
);
errors.push(Dynamic::from(error));
"email" => {
let email_str = field_value.to_string();
if !email_str.contains("@") || !email_str.contains(".") {
debug!("Validation failed: invalid email: {}", field_name);
return false;
}
}
"phone" => {
let phone_str = field_value.to_string();
let digits_only: String =
phone_str.chars().filter(|c| c.is_numeric()).collect();
if digits_only.len() < 10 {
debug!("Validation failed: invalid phone: {}", field_name);
return false;
}
}
_ => {}
}
}
if rule_str.contains("email") {
if let Some(val) = field_value {
let email = val.to_string();
if !email.is_empty() && !is_valid_email(&email) {
is_valid = false;
let mut error = Map::new();
error.insert("field".into(), Dynamic::from(field_key.to_string()));
error.insert("rule".into(), Dynamic::from("email"));
error.insert(
"message".into(),
Dynamic::from(format!("Field '{}' must be a valid email", field_key)),
);
errors.push(Dynamic::from(error));
}
}
}
if rule_str.contains("phone") {
if let Some(val) = field_value {
let phone = val.to_string();
if !phone.is_empty() && !is_valid_phone(&phone) {
is_valid = false;
let mut error = Map::new();
error.insert("field".into(), Dynamic::from(field_key.to_string()));
error.insert("rule".into(), Dynamic::from("phone"));
error.insert(
"message".into(),
Dynamic::from(format!(
"Field '{}' must be a valid phone number",
field_key
)),
);
errors.push(Dynamic::from(error));
}
}
}
}
result.insert("valid".into(), Dynamic::from(is_valid));
result.insert("errors".into(), Dynamic::from(errors));
result.insert("field_count".into(), Dynamic::from(form_data.len() as i64));
result.insert("rules_checked".into(), Dynamic::from(rules.len() as i64));
result
}
/// Basic email validation
fn is_valid_email(email: &str) -> bool {
let email = email.trim();
if email.is_empty() {
return false;
}
// Simple validation: must contain @ and have something before and after
let parts: Vec<&str> = email.split('@').collect();
if parts.len() != 2 {
return false;
}
let local = parts[0];
let domain = parts[1];
// Local part must not be empty
if local.is_empty() {
return false;
}
// Domain must contain at least one dot and not be empty
if domain.is_empty() || !domain.contains('.') {
return false;
}
// Domain must have something after the last dot
let domain_parts: Vec<&str> = domain.split('.').collect();
if domain_parts.last().map(|s| s.is_empty()).unwrap_or(true) {
return false;
}
debug!("Form validation with rules passed");
true
}
/// Basic phone validation
fn is_valid_phone(phone: &str) -> bool {
let phone = phone.trim();
if phone.is_empty() {
return false;
}
// Remove common formatting characters
let digits: String = phone
.chars()
.filter(|c| c.is_ascii_digit() || *c == '+')
.collect();
// Must have at least 7 digits (minimum for a phone number)
let digit_count = digits.chars().filter(|c| c.is_ascii_digit()).count();
digit_count >= 7
}
/// Generate a unique submission ID
fn generate_submission_id() -> String {
use std::time::{SystemTime, UNIX_EPOCH};
let timestamp = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_millis();
format!("sub_{}", timestamp)
}
/// Save form submission to storage
fn save_form_submission(form_name: &str, data: &Map) -> Map {
let mut result = Map::new();
let submission_id = generate_submission_id();
// TODO: Implement actual database storage
fn _register_form_handler(
_state: &Arc<AppState>,
form_name: &str,
_handler_script: &str,
user: &UserSession,
) -> bool {
let handler_id = Uuid::new_v4().to_string();
info!(
"Saving form submission for '{}' with id '{}'",
form_name, submission_id
"Registered handler for form: {} ({}), user={}",
form_name, handler_id, user.user_id
);
true
}
fn generate_submission_id() -> String {
Uuid::new_v4().to_string()
}
fn save_form_submission(
_state: &Arc<AppState>,
form_name: &str,
user: &UserSession,
data: &Map,
) -> Map {
let submission_id = generate_submission_id();
let mut result = Map::new();
let timestamp = chrono::Utc::now().to_rfc3339();
result.insert("success".into(), Dynamic::from(true));
result.insert("submission_id".into(), Dynamic::from(submission_id));
result.insert("form_name".into(), Dynamic::from(form_name.to_string()));
result.insert("field_count".into(), Dynamic::from(data.len() as i64));
result.insert("timestamp".into(), Dynamic::from(chrono_timestamp()));
result.insert("id".into(), Dynamic::from(submission_id.clone()));
result.insert("timestamp".into(), Dynamic::from(timestamp));
result.insert("fields_saved".into(), Dynamic::from(data.len() as i64));
info!(
"Saved form submission: form={}, id={}, fields={}, user={}",
form_name,
submission_id,
data.len(),
user.user_id
);
result
}
/// Get current timestamp in ISO format
fn chrono_timestamp() -> String {
use std::time::{SystemTime, UNIX_EPOCH};
fn get_form_submissions(
_state: &Arc<AppState>,
form_name: &str,
user: &UserSession,
limit: Option<usize>,
) -> Array {
let submissions = Array::new();
let limit_val = limit.unwrap_or(100);
let duration = SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default();
debug!(
"Retrieved form submissions: form={}, limit={}, user={}",
form_name, limit_val, user.user_id
);
let secs = duration.as_secs();
// Simple ISO-like format without external dependencies
format!("{}Z", secs)
submissions
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_is_valid_email() {
assert!(is_valid_email("user@example.com"));
assert!(is_valid_email("user.name@example.co.uk"));
assert!(is_valid_email("user+tag@example.com"));
assert!(!is_valid_email("invalid"));
assert!(!is_valid_email("@example.com"));
assert!(!is_valid_email("user@"));
assert!(!is_valid_email("user@example"));
assert!(!is_valid_email(""));
}
#[test]
fn test_is_valid_phone() {
assert!(is_valid_phone("+1234567890"));
assert!(is_valid_phone("123-456-7890"));
assert!(is_valid_phone("(123) 456-7890"));
assert!(is_valid_phone("1234567"));
assert!(!is_valid_phone("123"));
assert!(!is_valid_phone(""));
assert!(!is_valid_phone("abc"));
}
#[test]
fn test_validate_form_data() {
let mut form_data = Map::new();
form_data.insert("name".into(), Dynamic::from("John"));
form_data.insert("email".into(), Dynamic::from("john@example.com"));
let result = validate_form_data(&form_data);
assert!(result.get("valid").unwrap().as_bool().unwrap());
}
#[test]
fn test_validate_form_with_rules_required() {
let mut form_data = Map::new();
form_data.insert("name".into(), Dynamic::from("John"));
// Missing email field
let mut rules = Map::new();
rules.insert("name".into(), Dynamic::from("required"));
rules.insert("email".into(), Dynamic::from("required"));
let result = validate_form_with_rules(&form_data, &rules);
assert!(!result.get("valid").unwrap().as_bool().unwrap());
}
#[test]
fn test_validate_form_with_rules_email() {
let mut form_data = Map::new();
form_data.insert("email".into(), Dynamic::from("invalid-email"));
let mut rules = Map::new();
rules.insert("email".into(), Dynamic::from("email"));
let result = validate_form_with_rules(&form_data, &rules);
assert!(!result.get("valid").unwrap().as_bool().unwrap());
}
#[test]
fn test_generate_submission_id() {
let id = generate_submission_id();
assert!(id.starts_with("sub_"));
}
#[test]
fn test_save_form_submission() {
let mut data = Map::new();
data.insert("name".into(), Dynamic::from("Test"));
let result = save_form_submission("test_form", &data);
assert!(result.get("success").unwrap().as_bool().unwrap());
assert!(result.contains_key("submission_id"));
}
fn create_error_response(message: &str) -> Map {
let mut response = Map::new();
response.insert("success".into(), Dynamic::from(false));
response.insert("error".into(), Dynamic::from(message.to_string()));
response.insert(
"timestamp".into(),
Dynamic::from(chrono::Utc::now().to_rfc3339()),
);
response
}
fn trace_call(operation: &str, user: &UserSession) {
debug!("{} called by user: {}", operation, user.user_id);
}

69
src/basic/keywords/play.rs
View file

@ -13,7 +13,7 @@
use crate::shared::models::UserSession;
use crate::shared::state::AppState;
use log::{error, info, trace};
use log::{info, trace};
use rhai::{Dynamic, Engine};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
@ -203,15 +203,29 @@ pub struct PlayResponse {
/// Register the PLAY keyword
pub fn play_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Engine) {
play_simple_keyword(state.clone(), user.clone(), engine);
play_with_options_keyword(state.clone(), user.clone(), engine);
stop_keyword(state.clone(), user.clone(), engine);
pause_keyword(state.clone(), user.clone(), engine);
resume_keyword(state.clone(), user.clone(), engine);
if let Err(e) = play_simple_keyword(state.clone(), user.clone(), engine) {
log::error!("Failed to register PLAY keyword: {}", e);
}
if let Err(e) = play_with_options_keyword(state.clone(), user.clone(), engine) {
log::error!("Failed to register PLAY WITH OPTIONS keyword: {}", e);
}
if let Err(e) = stop_keyword(state.clone(), user.clone(), engine) {
log::error!("Failed to register STOP keyword: {}", e);
}
if let Err(e) = pause_keyword(state.clone(), user.clone(), engine) {
log::error!("Failed to register PAUSE keyword: {}", e);
}
if let Err(e) = resume_keyword(state.clone(), user.clone(), engine) {
log::error!("Failed to register RESUME keyword: {}", e);
}
}
/// PLAY "source"
fn play_simple_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Engine) {
fn play_simple_keyword(
state: Arc<AppState>,
user: UserSession,
engine: &mut Engine,
) -> Result<(), rhai::ParseError> {
let state_clone = Arc::clone(&state);
let user_clone = user.clone();
@ -251,11 +265,16 @@ fn play_simple_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Eng
rhai::Position::NONE,
))),
}
});
})?;
Ok(())
}
/// PLAY "source" WITH OPTIONS "options"
fn play_with_options_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Engine) {
fn play_with_options_keyword(
state: Arc<AppState>,
user: UserSession,
engine: &mut Engine,
) -> Result<(), rhai::ParseError> {
let state_clone = Arc::clone(&state);
let user_clone = user.clone();
@ -311,11 +330,16 @@ fn play_with_options_keyword(state: Arc<AppState>, user: UserSession, engine: &m
))),
}
},
);
)?;
Ok(())
}
/// STOP - Stop current playback
fn stop_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Engine) {
fn stop_keyword(
state: Arc<AppState>,
user: UserSession,
engine: &mut Engine,
) -> Result<(), rhai::ParseError> {
let state_clone = Arc::clone(&state);
let user_clone = user.clone();
@ -345,11 +369,16 @@ fn stop_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Engine) {
rhai::Position::NONE,
))),
}
});
})?;
Ok(())
}
/// PAUSE - Pause current playback
fn pause_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Engine) {
fn pause_keyword(
state: Arc<AppState>,
user: UserSession,
engine: &mut Engine,
) -> Result<(), rhai::ParseError> {
let state_clone = Arc::clone(&state);
let user_clone = user.clone();
@ -380,11 +409,16 @@ fn pause_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Engine) {
rhai::Position::NONE,
))),
}
});
})?;
Ok(())
}
/// RESUME - Resume paused playback
fn resume_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Engine) {
fn resume_keyword(
state: Arc<AppState>,
user: UserSession,
engine: &mut Engine,
) -> Result<(), rhai::ParseError> {
let state_clone = Arc::clone(&state);
let user_clone = user.clone();
@ -415,7 +449,8 @@ fn resume_keyword(state: Arc<AppState>, user: UserSession, engine: &mut Engine)
rhai::Position::NONE,
))),
}
});
})?;
Ok(())
}
// ============================================================================
@ -510,7 +545,7 @@ fn detect_content_type(source: &str) -> ContentType {
/// Resolve source to a URL
async fn resolve_source_url(
state: &AppState,
_state: &AppState,
session_id: Uuid,
source: &str,
) -> Result<String, String> {

5
src/basic/keywords/qrcode.rs
View file

@ -317,7 +317,7 @@ pub fn generate_qr_code_with_logo(
logo_path: &str,
output_path: &str,
) -> Result<String, Box<dyn std::error::Error + Send + Sync>> {
use image::{imageops, DynamicImage, GenericImageView, Rgba, RgbaImage};
use image::{imageops, DynamicImage, Rgba, RgbaImage};
// Generate QR code with higher error correction for logo overlay
let code = QrCode::with_error_correction_level(data.as_bytes(), qrcode::EcLevel::H)?;
@ -362,9 +362,6 @@ mod tests {
#[test]
fn test_qr_code_generation() {
let temp_dir = std::env::temp_dir();
let output_path = temp_dir.join("test_qr.png");
// Create a mock state and user for testing
// In real tests, you'd set up proper test fixtures
let result = QrCode::new(b"https://example.com");

2
src/basic/keywords/set_schedule.rs
View file

@ -178,7 +178,7 @@ fn parse_at_time(input: &str) -> Option<String> {
parse_time_to_cron(time_str, "*", "*")
}
fn parse_time_to_cron(time_str: &str, hour_default: &str, dow: &str) -> Option<String> {
fn parse_time_to_cron(time_str: &str, _hour_default: &str, dow: &str) -> Option<String> {
// midnight
if time_str == "midnight" {
return Some(format!("0 0 * * {}", dow));

2
src/basic/keywords/sms.rs
View file

@ -413,7 +413,7 @@ async fn send_via_aws_sns(
// Create timestamp for AWS Signature
let timestamp = chrono::Utc::now().format("%Y%m%dT%H%M%SZ").to_string();
let date = &timestamp[..8];
let _date = &timestamp[..8];
// Build the request parameters
let params = [

2
src/basic/keywords/social/get_metrics.rs
View file

@ -1,6 +1,6 @@
use crate::shared::models::UserSession;
use crate::shared::state::AppState;
use log::{debug, error, trace};
use log::{debug, trace};
use rhai::{Dynamic, Engine, Map};
use serde::{Deserialize, Serialize};
use serde_json::Value;

1
src/basic/keywords/social/post_to.rs
View file

@ -13,7 +13,6 @@ use chrono::Utc;
use diesel::prelude::*;
use log::{error, trace};
use rhai::{Dynamic, Engine};
use serde_json::json;
use std::sync::Arc;
use uuid::Uuid;

6
src/basic/keywords/string_functions.rs
View file

@ -100,9 +100,9 @@ pub fn is_numeric_keyword(_state: &Arc<AppState>, _user: UserSession, engine: &m
// Handle Dynamic type for flexibility
engine.register_fn("IS_NUMERIC", |value: Dynamic| -> bool {
match value.as_str() {
Some(s) => is_numeric_impl(s),
None => {
match value.clone().into_string() {
Ok(s) => is_numeric_impl(&s),
Err(_) => {
// If it's already a number, return true
value.is::<i64>() || value.is::<f64>()
}

8
src/basic/keywords/switch_case.rs
View file

@ -132,7 +132,7 @@ fn switch_match_impl(expr: &Dynamic, case_val: &Dynamic) -> bool {
/// ```
pub fn preprocess_switch(input: &str) -> String {
let mut result = String::new();
let mut lines: Vec<&str> = input.lines().collect();
let lines: Vec<&str> = input.lines().collect();
let mut i = 0;
let mut switch_counter = 0;
@ -151,7 +151,7 @@ pub fn preprocess_switch(input: &str) -> String {
// Process cases until END SWITCH
i += 1;
let mut first_case = true;
let mut in_default = false;
let mut _in_default = false;
while i < lines.len() {
let case_line = lines[i].trim();
@ -183,13 +183,13 @@ pub fn preprocess_switch(input: &str) -> String {
}
first_case = false;
in_default = false;
_in_default = false;
} else if case_upper == "DEFAULT" {
// Close previous case
if !first_case {
result.push_str("} else {\n");
}
in_default = true;
_in_default = true;
} else if !case_line.is_empty()
&& !case_line.starts_with("//")
&& !case_line.starts_with("'")

22
src/basic/keywords/table_definition.rs
View file

@ -56,7 +56,6 @@ use diesel::sql_query;
use diesel::sql_types::Text;
use log::{error, info, trace, warn};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::error::Error;
use std::sync::Arc;
use uuid::Uuid;
@ -131,7 +130,7 @@ fn parse_single_table(
if parts.len() < 2 {
return Err(format!(
"Invalid TABLE syntax at line {}: {}",
index + 1,
*index + 1,
header_line
)
.into());
@ -374,27 +373,40 @@ pub fn load_connection_config(
let server = config_manager
.get_config(&bot_id, &format!("{}Server", prefix), None)
.ok_or_else(|| format!("Missing {prefix}Server in config"))?;
.map_err(|_| {
Box::new(std::io::Error::new(
std::io::ErrorKind::NotFound,
format!("Missing {prefix}Server in config"),
)) as Box<dyn std::error::Error + Send + Sync>
})?;
let database = config_manager
.get_config(&bot_id, &format!("{}Name", prefix), None)
.ok_or_else(|| format!("Missing {prefix}Name in config"))?;
.map_err(|_| {
Box::new(std::io::Error::new(
std::io::ErrorKind::NotFound,
format!("Missing {prefix}Name in config"),
)) as Box<dyn std::error::Error + Send + Sync>
})?;
let username = config_manager
.get_config(&bot_id, &format!("{}Username", prefix), None)
.ok()
.unwrap_or_default();
let password = config_manager
.get_config(&bot_id, &format!("{}Password", prefix), None)
.ok()
.unwrap_or_default();
let port = config_manager
.get_config(&bot_id, &format!("{}Port", prefix), None)
.ok()
.and_then(|p| p.parse().ok());
let driver = config_manager
.get_config(&bot_id, &format!("{}Driver", prefix), None)
.unwrap_or_else(|| "postgres".to_string());
.unwrap_or_else(|_| "postgres".to_string());
Ok(ExternalConnection {
name: connection_name.to_string(),

16
src/basic/keywords/validation/isempty.rs
View file

@ -1,7 +1,7 @@
use crate::shared::models::UserSession;
use crate::shared::state::AppState;
use log::debug;
use rhai::{Dynamic, Engine};
use rhai::{Dynamic, Engine, Map};
use std::sync::Arc;
/// Registers the ISEMPTY function for checking if a value is empty
@ -25,19 +25,13 @@ use std::sync::Arc;
/// empty_check = ISEMPTY([]) ' Returns TRUE
pub fn isempty_keyword(_state: &Arc<AppState>, _user: UserSession, engine: &mut Engine) {
// ISEMPTY - uppercase version
engine.register_fn("ISEMPTY", |value: Dynamic| -> bool {
check_empty(&value)
});
engine.register_fn("ISEMPTY", |value: Dynamic| -> bool { check_empty(&value) });
// isempty - lowercase version
engine.register_fn("isempty", |value: Dynamic| -> bool {
check_empty(&value)
});
engine.register_fn("isempty", |value: Dynamic| -> bool { check_empty(&value) });
// IsEmpty - mixed case version
engine.register_fn("IsEmpty", |value: Dynamic| -> bool {
check_empty(&value)
});
engine.register_fn("IsEmpty", |value: Dynamic| -> bool { check_empty(&value) });
debug!("Registered ISEMPTY keyword");
}
@ -65,7 +59,7 @@ fn check_empty(value: &Dynamic) -> bool {
// Check for empty map
if value.is_map() {
if let Ok(map) = value.as_map() {
if let Some(map) = value.clone().try_cast::<Map>() {
return map.is_empty();
}
}

11
src/basic/keywords/webhook.rs
View file

@ -57,7 +57,7 @@ pub struct WebhookRegistration {
/// When called, it triggers the script containing the WEBHOOK declaration
/// Request params become available as variables in the script
pub fn webhook_keyword(state: &AppState, _user: UserSession, engine: &mut Engine) {
let state_clone = state.clone();
let _state_clone = state.clone();
engine
.register_custom_syntax(&["WEBHOOK", "$expr$"], false, move |context, inputs| {
@ -349,10 +349,13 @@ impl WebhookResponse {
let mut headers = std::collections::HashMap::new();
if let Some(h) = map.get("headers") {
if let Ok(headers_map) = h.clone().try_cast::<rhai::Map>() {
for (k, v) in headers_map {
headers.insert(k.to_string(), v.to_string());
match h.clone().try_cast::<rhai::Map>() {
Some(headers_map) => {
for (k, v) in headers_map {
headers.insert(k.to_string(), v.to_string());
}
}
None => {}
}
}

6
src/basic/mod.rs
View file

@ -160,7 +160,7 @@ impl ScriptService {
register_send_template_keywords(state.clone(), user.clone(), &mut engine);
// ON FORM SUBMIT: Webhook-based form handling for landing pages
on_form_submit_keyword(&state, user.clone(), &mut engine);
on_form_submit_keyword(state.clone(), user.clone(), &mut engine);
// Lead Scoring: SCORE LEAD, GET LEAD SCORE, QUALIFY LEAD, AI SCORE LEAD
register_lead_scoring_keywords(state.clone(), user.clone(), &mut engine);
@ -209,7 +209,7 @@ impl ScriptService {
pub fn load_bot_config_params(&mut self, state: &AppState, bot_id: uuid::Uuid) {
if let Ok(mut conn) = state.conn.get() {
// Query all config entries for this bot that start with "param-"
let result: Result<Vec<(String, String)>, _> = diesel::sql_query(
let result = diesel::sql_query(
"SELECT config_key, config_value FROM bot_configuration WHERE bot_id = $1 AND config_key LIKE 'param-%'"
)
.bind::<diesel::sql_types::Uuid, _>(bot_id)
@ -723,7 +723,7 @@ impl ScriptService {
];
// Regex to match identifiers (variable names)
let identifier_re = Regex::new(r"([a-zA-Z_][a-zA-Z0-9_]*)").unwrap();
let _identifier_re = Regex::new(r"([a-zA-Z_][a-zA-Z0-9_]*)").unwrap();
for line in script.lines() {
let trimmed = line.trim();

13
src/console/chat_panel.rs
View file

@ -12,6 +12,19 @@ pub struct ChatPanel {
pub user_id: Uuid,
pub response_rx: Option<mpsc::Receiver<BotResponse>>,
}
impl std::fmt::Debug for ChatPanel {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ChatPanel")
.field("messages_count", &self.messages.len())
.field("input_buffer_len", &self.input_buffer.len())
.field("session_id", &self.session_id)
.field("user_id", &self.user_id)
.field("has_response_rx", &self.response_rx.is_some())
.finish()
}
}
impl ChatPanel {
pub fn new(_app_state: Arc<AppState>) -> Self {
Self {

301
src/console/editor.rs
View file

@ -1,142 +1,171 @@
use crate::shared::state::AppState;
use color_eyre::Result;
use std::sync::Arc;
use crate::shared::state::AppState;
pub struct Editor {
file_path: String,
bucket: String,
key: String,
content: String,
cursor_pos: usize,
scroll_offset: usize,
modified: bool,
file_path: String,
bucket: String,
key: String,
content: String,
cursor_pos: usize,
scroll_offset: usize,
modified: bool,
}
impl std::fmt::Debug for Editor {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Editor")
.field("file_path", &self.file_path)
.field("bucket", &self.bucket)
.field("key", &self.key)
.field("content_len", &self.content.len())
.field("cursor_pos", &self.cursor_pos)
.field("scroll_offset", &self.scroll_offset)
.field("modified", &self.modified)
.finish()
}
}
impl Editor {
pub async fn load(app_state: &Arc<AppState>, bucket: &str, path: &str) -> Result<Self> {
let content = if let Some(drive) = &app_state.drive {
match drive.get_object().bucket(bucket).key(path).send().await {
Ok(response) => {
let bytes = response.body.collect().await?.into_bytes();
String::from_utf8_lossy(&bytes).to_string()
}
Err(_) => String::new(),
}
} else {
String::new()
};
Ok(Self {
file_path: format!("{}/{}", bucket, path),
bucket: bucket.to_string(),
key: path.to_string(),
content,
cursor_pos: 0,
scroll_offset: 0,
modified: false,
})
}
pub async fn save(&mut self, app_state: &Arc<AppState>) -> Result<()> {
if let Some(drive) = &app_state.drive {
drive.put_object()
.bucket(&self.bucket)
.key(&self.key)
.body(self.content.as_bytes().to_vec().into())
.send()
.await?;
self.modified = false;
}
Ok(())
}
pub fn file_path(&self) -> &str {
&self.file_path
}
pub fn render(&self, cursor_blink: bool) -> String {
let lines: Vec<&str> = self.content.lines().collect();
let total_lines = lines.len().max(1);
let visible_lines = 25;
let cursor_line = self.content[..self.cursor_pos].lines().count();
let cursor_col = self.content[..self.cursor_pos]
.lines()
.last()
.map(|line| line.len())
.unwrap_or(0);
let start = self.scroll_offset;
let end = (start + visible_lines).min(total_lines);
let mut display_lines = Vec::new();
for i in start..end {
let line_num = i + 1;
let line_content = if i < lines.len() { lines[i] } else { "" };
let is_cursor_line = i == cursor_line;
let cursor_indicator = if is_cursor_line && cursor_blink {
let spaces = " ".repeat(cursor_col);
format!("{}█", spaces)
} else {
String::new()
};
display_lines.push(format!(" {:4} │ {}{}", line_num, line_content, cursor_indicator));
}
if display_lines.is_empty() {
let cursor_indicator = if cursor_blink { "█" } else { "" };
display_lines.push(format!(" 1 │ {}", cursor_indicator));
}
display_lines.push("".to_string());
display_lines.push("─────────────────────────────────────────────────────────────".to_string());
let status = if self.modified { "MODIFIED" } else { "SAVED" };
display_lines.push(format!(" {} {} │ Line: {}, Col: {}",
status, self.file_path, cursor_line + 1, cursor_col + 1));
display_lines.push(" Ctrl+S: Save │ Ctrl+W: Close │ Esc: Close without saving".to_string());
display_lines.join("\n")
}
pub fn move_up(&mut self) {
if let Some(prev_line_end) = self.content[..self.cursor_pos].rfind('\n') {
if let Some(prev_prev_line_end) = self.content[..prev_line_end].rfind('\n') {
let target_pos = prev_prev_line_end + 1 + (self.cursor_pos - prev_line_end - 1).min(
self.content[prev_prev_line_end + 1..prev_line_end].len()
);
self.cursor_pos = target_pos;
} else {
self.cursor_pos = (self.cursor_pos - prev_line_end - 1).min(prev_line_end);
}
}
}
pub fn move_down(&mut self) {
if let Some(next_line_start) = self.content[self.cursor_pos..].find('\n') {
let current_line_start = self.content[..self.cursor_pos].rfind('\n').map(|pos| pos + 1).unwrap_or(0);
let next_line_absolute = self.cursor_pos + next_line_start + 1;
if let Some(next_next_line_start) = self.content[next_line_absolute..].find('\n') {
let target_pos = next_line_absolute + (self.cursor_pos - current_line_start).min(next_next_line_start);
self.cursor_pos = target_pos;
} else {
let target_pos = next_line_absolute + (self.cursor_pos - current_line_start).min(
self.content[next_line_absolute..].len()
);
self.cursor_pos = target_pos;
}
}
}
pub fn move_left(&mut self) {
if self.cursor_pos > 0 {
self.cursor_pos -= 1;
}
}
pub fn move_right(&mut self) {
if self.cursor_pos < self.content.len() {
self.cursor_pos += 1;
}
}
pub fn insert_char(&mut self, c: char) {
self.modified = true;
self.content.insert(self.cursor_pos, c);
self.cursor_pos += 1;
}
pub fn backspace(&mut self) {
if self.cursor_pos > 0 {
self.modified = true;
self.content.remove(self.cursor_pos - 1);
self.cursor_pos -= 1;
}
}
pub fn insert_newline(&mut self) {
self.modified = true;
self.content.insert(self.cursor_pos, '\n');
self.cursor_pos += 1;
}
pub async fn load(app_state: &Arc<AppState>, bucket: &str, path: &str) -> Result<Self> {
let content = if let Some(drive) = &app_state.drive {
match drive.get_object().bucket(bucket).key(path).send().await {
Ok(response) => {
let bytes = response.body.collect().await?.into_bytes();
String::from_utf8_lossy(&bytes).to_string()
}
Err(_) => String::new(),
}
} else {
String::new()
};
Ok(Self {
file_path: format!("{}/{}", bucket, path),
bucket: bucket.to_string(),
key: path.to_string(),
content,
cursor_pos: 0,
scroll_offset: 0,
modified: false,
})
}
pub async fn save(&mut self, app_state: &Arc<AppState>) -> Result<()> {
if let Some(drive) = &app_state.drive {
drive
.put_object()
.bucket(&self.bucket)
.key(&self.key)
.body(self.content.as_bytes().to_vec().into())
.send()
.await?;
self.modified = false;
}
Ok(())
}
pub fn file_path(&self) -> &str {
&self.file_path
}
pub fn render(&self, cursor_blink: bool) -> String {
let lines: Vec<&str> = self.content.lines().collect();
let total_lines = lines.len().max(1);
let visible_lines = 25;
let cursor_line = self.content[..self.cursor_pos].lines().count();
let cursor_col = self.content[..self.cursor_pos]
.lines()
.last()
.map(|line| line.len())
.unwrap_or(0);
let start = self.scroll_offset;
let end = (start + visible_lines).min(total_lines);
let mut display_lines = Vec::new();
for i in start..end {
let line_num = i + 1;
let line_content = if i < lines.len() { lines[i] } else { "" };
let is_cursor_line = i == cursor_line;
let cursor_indicator = if is_cursor_line && cursor_blink {
let spaces = " ".repeat(cursor_col);
format!("{}█", spaces)
} else {
String::new()
};
display_lines.push(format!(
" {:4} │ {}{}",
line_num, line_content, cursor_indicator
));
}
if display_lines.is_empty() {
let cursor_indicator = if cursor_blink { "█" } else { "" };
display_lines.push(format!(" 1 │ {}", cursor_indicator));
}
display_lines.push("".to_string());
display_lines
.push("─────────────────────────────────────────────────────────────".to_string());
let status = if self.modified { "MODIFIED" } else { "SAVED" };
display_lines.push(format!(
" {} {} │ Line: {}, Col: {}",
status,
self.file_path,
cursor_line + 1,
cursor_col + 1
));
display_lines.push(" Ctrl+S: Save │ Ctrl+W: Close │ Esc: Close without saving".to_string());
display_lines.join("\n")
}
pub fn move_up(&mut self) {
if let Some(prev_line_end) = self.content[..self.cursor_pos].rfind('\n') {
if let Some(prev_prev_line_end) = self.content[..prev_line_end].rfind('\n') {
let target_pos = prev_prev_line_end
+ 1
+ (self.cursor_pos - prev_line_end - 1)
.min(self.content[prev_prev_line_end + 1..prev_line_end].len());
self.cursor_pos = target_pos;
} else {
self.cursor_pos = (self.cursor_pos - prev_line_end - 1).min(prev_line_end);
}
}
}
pub fn move_down(&mut self) {
if let Some(next_line_start) = self.content[self.cursor_pos..].find('\n') {
let current_line_start = self.content[..self.cursor_pos]
.rfind('\n')
.map(|pos| pos + 1)
.unwrap_or(0);
let next_line_absolute = self.cursor_pos + next_line_start + 1;
if let Some(next_next_line_start) = self.content[next_line_absolute..].find('\n') {
let target_pos = next_line_absolute
+ (self.cursor_pos - current_line_start).min(next_next_line_start);
self.cursor_pos = target_pos;
} else {
let target_pos = next_line_absolute
+ (self.cursor_pos - current_line_start)
.min(self.content[next_line_absolute..].len());
self.cursor_pos = target_pos;
}
}
}
pub fn move_left(&mut self) {
if self.cursor_pos > 0 {
self.cursor_pos -= 1;
}
}
pub fn move_right(&mut self) {
if self.cursor_pos < self.content.len() {
self.cursor_pos += 1;
}
}
pub fn insert_char(&mut self, c: char) {
self.modified = true;
self.content.insert(self.cursor_pos, c);
self.cursor_pos += 1;
}
pub fn backspace(&mut self) {
if self.cursor_pos > 0 {
self.modified = true;
self.content.remove(self.cursor_pos - 1);
self.cursor_pos -= 1;
}
}
pub fn insert_newline(&mut self) {
self.modified = true;
self.content.insert(self.cursor_pos, '\n');
self.cursor_pos += 1;
}
}

5
src/console/file_tree.rs
View file

@ -7,6 +7,7 @@ pub enum TreeNode {
Folder { bucket: String, path: String },
File { bucket: String, path: String },
}
#[derive(Debug)]
pub struct FileTree {
app_state: Arc<AppState>,
items: Vec<(String, TreeNode)>,
@ -231,6 +232,10 @@ impl FileTree {
pub fn render_items(&self) -> &[(String, TreeNode)] {
&self.items
}
/// Get items for external conversion (used by drive module)
pub fn get_items(&self) -> &[(String, TreeNode)] {
&self.items
}
pub fn selected_index(&self) -> usize {
self.selected
}

115
src/console/log_panel.rs
View file

@ -1,64 +1,73 @@
use std::sync::{Arc, Mutex};
use log::{Log, Metadata, LevelFilter, Record, SetLoggerError};
use chrono::Local;
use log::{LevelFilter, Log, Metadata, Record, SetLoggerError};
use std::sync::{Arc, Mutex};
pub struct LogPanel {
logs: Vec<String>,
max_logs: usize,
logs: Vec<String>,
max_logs: usize,
}
impl std::fmt::Debug for LogPanel {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("LogPanel")
.field("logs_count", &self.logs.len())
.field("max_logs", &self.max_logs)
.finish()
}
}
impl LogPanel {
pub fn new() -> Self {
Self {
logs: Vec::with_capacity(1000),
max_logs: 1000,
}
}
pub fn add_log(&mut self, entry: &str) {
if self.logs.len() >= self.max_logs {
self.logs.remove(0);
}
self.logs.push(entry.to_string());
}
pub fn render(&self) -> String {
let visible_logs = if self.logs.len() > 10 {
&self.logs[self.logs.len() - 10..]
} else {
&self.logs[..]
};
visible_logs.join("\n")
}
pub fn new() -> Self {
Self {
logs: Vec::with_capacity(1000),
max_logs: 1000,
}
}
pub fn add_log(&mut self, entry: &str) {
if self.logs.len() >= self.max_logs {
self.logs.remove(0);
}
self.logs.push(entry.to_string());
}
pub fn render(&self) -> String {
let visible_logs = if self.logs.len() > 10 {
&self.logs[self.logs.len() - 10..]
} else {
&self.logs[..]
};
visible_logs.join("\n")
}
}
pub struct UiLogger {
log_panel: Arc<Mutex<LogPanel>>,
filter: LevelFilter,
log_panel: Arc<Mutex<LogPanel>>,
filter: LevelFilter,
}
impl Log for UiLogger {
fn enabled(&self, metadata: &Metadata) -> bool {
metadata.level() <= self.filter
}
fn log(&self, record: &Record) {
if self.enabled(record.metadata()) {
let timestamp = Local::now().format("%H:%M:%S");
let level_icon = match record.level() {
log::Level::Error => "ERR",
log::Level::Warn => "WRN",
log::Level::Info => "INF",
log::Level::Debug => "DBG",
log::Level::Trace => "TRC",
};
let log_entry = format!("[{}] {} {}", timestamp, level_icon, record.args());
if let Ok(mut panel) = self.log_panel.lock() {
panel.add_log(&log_entry);
}
}
}
fn flush(&self) {}
fn enabled(&self, metadata: &Metadata) -> bool {
metadata.level() <= self.filter
}
fn log(&self, record: &Record) {
if self.enabled(record.metadata()) {
let timestamp = Local::now().format("%H:%M:%S");
let level_icon = match record.level() {
log::Level::Error => "ERR",
log::Level::Warn => "WRN",
log::Level::Info => "INF",
log::Level::Debug => "DBG",
log::Level::Trace => "TRC",
};
let log_entry = format!("[{}] {} {}", timestamp, level_icon, record.args());
if let Ok(mut panel) = self.log_panel.lock() {
panel.add_log(&log_entry);
}
}
}
fn flush(&self) {}
}
pub fn init_logger(log_panel: Arc<Mutex<LogPanel>>) -> Result<(), SetLoggerError> {
let logger = Box::new(UiLogger {
log_panel,
filter: LevelFilter::Info,
});
log::set_boxed_logger(logger)?;
log::set_max_level(LevelFilter::Trace);
Ok(())
let logger = Box::new(UiLogger {
log_panel,
filter: LevelFilter::Info,
});
log::set_boxed_logger(logger)?;
log::set_max_level(LevelFilter::Trace);
Ok(())
}

4
src/console/mod.rs
View file

@ -1,3 +1,4 @@
use crate::drive::convert_tree_to_items;
use crate::shared::state::AppState;
use color_eyre::Result;
use crossterm::{
@ -28,6 +29,7 @@ use editor::Editor;
use file_tree::{FileTree, TreeNode};
use log_panel::{init_logger, LogPanel};
use status_panel::StatusPanel;
#[derive(Debug)]
pub struct XtreeUI {
app_state: Option<Arc<AppState>>,
file_tree: Option<FileTree>,
@ -408,6 +410,8 @@ format!("{:^30}", self.bootstrap_status)
if let Some(file_tree) = &self.file_tree {
let items = file_tree.render_items();
let selected = file_tree.selected_index();
// Use convert_tree_to_items to get detailed file metadata
let _file_items = convert_tree_to_items(file_tree);
let list_items: Vec<ListItem> = items
.iter()
.enumerate()

10
src/console/status_panel.rs
View file

@ -16,6 +16,16 @@ pub struct StatusPanel {
system: System,
}
impl std::fmt::Debug for StatusPanel {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("StatusPanel")
.field("app_state", &"Arc<AppState>")
.field("last_update", &self.last_update)
.field("cached_content_len", &self.cached_content.len())
.finish()
}
}
impl StatusPanel {
pub fn new(app_state: Arc<AppState>) -> Self {
Self {

3
src/console/wizard.rs
View file

@ -14,7 +14,7 @@ use crossterm::{
cursor,
event::{self, Event, KeyCode, KeyEvent},
execute,
style::{Color, Print, ResetColor, SetForegroundColor, Stylize},
style::{Color, Print, ResetColor, SetForegroundColor},
terminal::{self, ClearType},
};
use serde::{Deserialize, Serialize};
@ -150,6 +150,7 @@ impl Default for WizardConfig {
}
/// Startup Wizard
#[derive(Debug)]
pub struct StartupWizard {
config: WizardConfig,
current_step: usize,

13
src/core/bootstrap/mod.rs
View file

@ -6,12 +6,9 @@ use anyhow::Result;
use aws_config::BehaviorVersion;
use aws_sdk_s3::Client;
use chrono;
use dotenvy::dotenv;
use log::{error, info, trace, warn};
use rand::distr::Alphanumeric;
use rcgen::{
BasicConstraints, Certificate, CertificateParams, DistinguishedName, DnType, IsCa, SanType,
};
use rcgen::{BasicConstraints, Certificate, CertificateParams, DistinguishedName, DnType, IsCa};
use std::fs;
use std::io::{self, Write};
use std::path::{Path, PathBuf};
@ -51,7 +48,9 @@ impl BootstrapManager {
ComponentInfo { name: "alm_ci" },
ComponentInfo { name: "dns" },
ComponentInfo { name: "meeting" },
ComponentInfo { name: "desktop" },
ComponentInfo {
name: "remote_terminal",
},
ComponentInfo { name: "vector_db" },
ComponentInfo { name: "host" },
];
@ -139,8 +138,8 @@ impl BootstrapManager {
}
// Directory (Zitadel) is the root service - stores all configuration
let directory_password = self.generate_secure_password(32);
let directory_masterkey = self.generate_secure_password(32);
let _directory_password = self.generate_secure_password(32);
let _directory_masterkey = self.generate_secure_password(32);
// Configuration is stored in Directory service, not .env files
info!("Configuring services through Directory...");

64
src/core/directory/api.rs
View file

@ -6,7 +6,7 @@ use axum::{
extract::{Json, Path, State},
http::StatusCode,
response::IntoResponse,
routing::{delete, get, post, put},
routing::{delete, get, post},
Router,
};
use serde::{Deserialize, Serialize};
@ -79,25 +79,14 @@ pub async fn provision_user_handler(
}
// Get provisioning service
let db_conn = match state.conn.get() {
Ok(conn) => Arc::new(conn),
Err(e) => {
return (
StatusCode::INTERNAL_SERVER_ERROR,
Json(UserResponse {
success: false,
message: format!("Database connection failed: {}", e),
user_id: None,
}),
);
}
};
let s3_client = state.s3_client.clone().map(Arc::new);
let base_url = state
.config
.as_ref()
.map(|c| c.server.base_url.clone())
.unwrap_or_else(|| "http://localhost:8080".to_string());
let provisioning = UserProvisioningService::new(
db_conn,
state.drive.clone(),
state.config.server.base_url.clone(),
);
let provisioning = UserProvisioningService::new(state.conn.clone(), s3_client, base_url);
// Provision the user
match provisioning.provision_user(&account).await {
@ -125,25 +114,14 @@ pub async fn deprovision_user_handler(
State(state): State<Arc<AppState>>,
Path(id): Path<String>,
) -> impl IntoResponse {
let db_conn = match state.conn.get() {
Ok(conn) => Arc::new(conn),
Err(e) => {
return (
StatusCode::INTERNAL_SERVER_ERROR,
Json(UserResponse {
success: false,
message: format!("Database connection failed: {}", e),
user_id: None,
}),
);
}
};
let s3_client = state.s3_client.clone().map(Arc::new);
let base_url = state
.config
.as_ref()
.map(|c| c.server.base_url.clone())
.unwrap_or_else(|| "http://localhost:8080".to_string());
let provisioning = UserProvisioningService::new(
db_conn,
state.drive.clone(),
state.config.server.base_url.clone(),
);
let provisioning = UserProvisioningService::new(state.conn.clone(), s3_client, base_url);
match provisioning.deprovision_user(&id).await {
Ok(_) => (
@ -173,7 +151,7 @@ pub async fn get_user_handler(
use crate::shared::models::schema::users;
use diesel::prelude::*;
let conn = match state.conn.get() {
let mut conn = match state.conn.get() {
Ok(conn) => conn,
Err(e) => {
return (
@ -198,7 +176,7 @@ pub async fn get_user_handler(
};
let user_result: Result<(uuid::Uuid, String, String, bool), _> = users::table
.filter(users::id.eq(&user_uuid))
.filter(users::id.eq(user_uuid))
.select((users::id, users::username, users::email, users::is_admin))
.first(&mut conn);
@ -226,7 +204,7 @@ pub async fn list_users_handler(State(state): State<Arc<AppState>>) -> impl Into
use crate::shared::models::schema::users;
use diesel::prelude::*;
let conn = match state.conn.get() {
let mut conn = match state.conn.get() {
Ok(conn) => conn,
Err(e) => {
return (
@ -284,8 +262,10 @@ pub async fn check_services_status(State(state): State<Arc<AppState>>) -> impl I
status.database = state.conn.get().is_ok();
// Check S3/MinIO
if let Ok(result) = state.drive.list_buckets().send().await {
status.drive = result.buckets.is_some();
if let Some(s3_client) = &state.s3_client {
if let Ok(result) = s3_client.list_buckets().send().await {
status.drive = result.buckets.is_some();
}
}
// Check Directory (Zitadel)

33
src/core/directory/mod.rs
View file

@ -36,16 +36,23 @@ pub struct DirectoryService {
provisioning: Arc<UserProvisioningService>,
}
impl std::fmt::Debug for DirectoryService {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DirectoryService")
.field("config", &self.config)
.finish_non_exhaustive()
}
}
impl DirectoryService {
pub fn new(
config: DirectoryConfig,
db_pool: Pool<ConnectionManager<PgConnection>>,
s3_client: Arc<S3Client>,
) -> Result<Self> {
let db_conn = Arc::new(db_pool.get()?);
let provisioning = Arc::new(UserProvisioningService::new(
db_conn,
s3_client,
db_pool,
Some(s3_client),
config.url.clone(),
));
@ -66,4 +73,24 @@ impl DirectoryService {
pub fn get_provisioning_service(&self) -> Arc<UserProvisioningService> {
Arc::clone(&self.provisioning)
}
/// Get the directory service URL
pub fn get_url(&self) -> &str {
&self.config.url
}
/// Check if OAuth is enabled
pub fn is_oauth_enabled(&self) -> bool {
self.config.oauth_enabled
}
/// Get the project ID
pub fn get_project_id(&self) -> &str {
&self.config.project_id
}
/// Get the full configuration (for admin purposes)
pub fn get_config(&self) -> &DirectoryConfig {
&self.config
}
}

170
src/core/directory/provisioning.rs
View file

@ -1,18 +1,31 @@
use anyhow::Result;
use aws_sdk_s3::Client as S3Client;
use diesel::r2d2::{ConnectionManager, Pool};
use diesel::PgConnection;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::Arc;
use uuid::Uuid;
/// Database pool type alias
pub type DbPool = Pool<ConnectionManager<PgConnection>>;
/// User provisioning service that creates accounts across all integrated services
pub struct UserProvisioningService {
db_conn: Arc<PgConnection>,
s3_client: Arc<S3Client>,
db_pool: DbPool,
s3_client: Option<Arc<S3Client>>,
base_url: String,
}
impl std::fmt::Debug for UserProvisioningService {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("UserProvisioningService")
.field("base_url", &self.base_url)
.field("has_s3_client", &self.s3_client.is_some())
.finish_non_exhaustive()
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserAccount {
pub username: String,
@ -40,17 +53,31 @@ pub enum UserRole {
}
impl UserProvisioningService {
pub fn new(db_conn: Arc<PgConnection>, s3_client: Arc<S3Client>, base_url: String) -> Self {
pub fn new(db_pool: DbPool, s3_client: Option<Arc<S3Client>>, base_url: String) -> Self {
Self {
db_conn,
db_pool,
s3_client,
base_url,
}
}
/// Get the base URL for the directory service
pub fn get_base_url(&self) -> &str {
&self.base_url
}
/// Build a user profile URL
pub fn build_profile_url(&self, username: &str) -> String {
format!("{}/users/{}/profile", self.base_url, username)
}
/// Create a new user across all services
pub async fn provision_user(&self, account: &UserAccount) -> Result<()> {
log::info!("Provisioning user: {}", account.username);
log::info!(
"Provisioning user: {} via directory at {}",
account.username,
self.base_url
);
// 1. Create user in database using existing user management
let user_id = self.create_database_user(account).await?;
@ -68,52 +95,66 @@ impl UserProvisioningService {
// 4. Setup OAuth linking in configuration
self.setup_oauth_config(&user_id, account).await?;
log::info!("User {} provisioned successfully", account.username);
// Log profile URL for reference
let profile_url = self.build_profile_url(&account.username);
log::info!(
"User {} provisioned successfully. Profile: {}",
account.username,
profile_url
);
Ok(())
}
async fn create_database_user(&self, account: &UserAccount) -> Result<String> {
use crate::shared::models::schema::users;
use argon2::{password_hash::SaltString, Argon2, PasswordHasher};
use argon2::{
password_hash::{rand_core::OsRng, SaltString},
Argon2, PasswordHasher,
};
use diesel::prelude::*;
use uuid::Uuid;
let user_id = Uuid::new_v4().to_string();
let salt = SaltString::generate(&mut rand::rngs::OsRng);
let user_id = Uuid::new_v4();
let salt = SaltString::generate(&mut OsRng);
let argon2 = Argon2::default();
let password_hash = argon2
.hash_password(Uuid::new_v4().to_string().as_bytes(), &salt)
.map_err(|e| anyhow::anyhow!("Password hashing failed: {}", e))?
.to_string();
let mut conn = self
.db_pool
.get()
.map_err(|e| anyhow::anyhow!("Failed to get database connection: {}", e))?;
diesel::insert_into(users::table)
.values((
users::id.eq(&user_id),
users::id.eq(user_id),
users::username.eq(&account.username),
users::email.eq(&account.email),
users::password_hash.eq(&password_hash),
users::is_admin.eq(account.is_admin),
users::created_at.eq(chrono::Utc::now()),
))
.execute(&*self.db_conn)?;
.execute(&mut conn)?;
Ok(user_id)
Ok(user_id.to_string())
}
async fn create_s3_home(&self, account: &UserAccount, bot_access: &BotAccess) -> Result<()> {
let s3_client = match &self.s3_client {
Some(client) => client,
None => {
log::warn!("S3 client not configured, skipping S3 home creation");
return Ok(());
}
};
let bucket_name = format!("{}.gbdrive", bot_access.bot_name);
let home_path = format!("home/{}/", account.username);
// Ensure bucket exists
match self
.s3_client
.head_bucket()
.bucket(&bucket_name)
.send()
.await
{
match s3_client.head_bucket().bucket(&bucket_name).send().await {
Err(_) => {
self.s3_client
s3_client
.create_bucket()
.bucket(&bucket_name)
.send()
@ -123,7 +164,7 @@ impl UserProvisioningService {
}
// Create user home directory marker
self.s3_client
s3_client
.put_object()
.bucket(&bucket_name)
.key(&home_path)
@ -134,7 +175,7 @@ impl UserProvisioningService {
// Create default folders
for folder in &["documents", "projects", "shared"] {
let folder_key = format!("{}{}/", home_path, folder);
self.s3_client
s3_client
.put_object()
.bucket(&bucket_name)
.key(&folder_key)
@ -156,9 +197,16 @@ impl UserProvisioningService {
use diesel::prelude::*;
// Store email configuration in database
let mut conn = self
.db_pool
.get()
.map_err(|e| anyhow::anyhow!("Failed to get database connection: {}", e))?;
// Create a UUID for the user_id since the column expects UUID
let user_uuid = Uuid::new_v4();
diesel::insert_into(user_email_accounts::table)
.values((
user_email_accounts::user_id.eq(&account.username),
user_email_accounts::user_id.eq(user_uuid),
user_email_accounts::email.eq(&account.email),
user_email_accounts::imap_server.eq("localhost"),
user_email_accounts::imap_port.eq(993),
@ -168,7 +216,7 @@ impl UserProvisioningService {
user_email_accounts::password_encrypted.eq("oauth"),
user_email_accounts::is_active.eq(true),
))
.execute(&*self.db_conn)?;
.execute(&mut conn)?;
log::info!("Setup email configuration for: {}", account.email);
Ok(())
@ -186,10 +234,14 @@ impl UserProvisioningService {
("oauth-provider", "zitadel"),
];
let mut conn = self
.db_pool
.get()
.map_err(|e| anyhow::anyhow!("Failed to get database connection: {}", e))?;
for (key, value) in services {
diesel::insert_into(bot_configuration::table)
.values((
bot_configuration::bot_id.eq(uuid::Uuid::nil()),
bot_configuration::bot_id.eq(Uuid::nil()),
bot_configuration::config_key.eq(key),
bot_configuration::config_value.eq(value),
bot_configuration::is_encrypted.eq(false),
@ -200,7 +252,7 @@ impl UserProvisioningService {
.on_conflict((bot_configuration::bot_id, bot_configuration::config_key))
.do_update()
.set(bot_configuration::config_value.eq(value))
.execute(&*self.db_conn)?;
.execute(&mut conn)?;
}
log::info!("Setup OAuth configuration for user: {}", account.username);
@ -224,40 +276,44 @@ impl UserProvisioningService {
use crate::shared::models::schema::users;
use diesel::prelude::*;
diesel::delete(users::table.filter(users::username.eq(username)))
.execute(&*self.db_conn)?;
let mut conn = self
.db_pool
.get()
.map_err(|e| anyhow::anyhow!("Failed to get database connection: {}", e))?;
diesel::delete(users::table.filter(users::username.eq(username))).execute(&mut conn)?;
Ok(())
}
async fn remove_s3_data(&self, username: &str) -> Result<()> {
// List all buckets and remove user home directories
let buckets_result = self.s3_client.list_buckets().send().await?;
if let Some(s3_client) = &self.s3_client {
let buckets_result = s3_client.list_buckets().send().await?;
if let Some(buckets) = buckets_result.buckets {
for bucket in buckets {
if let Some(name) = bucket.name {
if name.ends_with(".gbdrive") {
let prefix = format!("home/{}/", username);
if let Some(buckets) = buckets_result.buckets {
for bucket in buckets {
if let Some(name) = bucket.name {
if name.ends_with(".gbdrive") {
let prefix = format!("home/{}/", username);
// List and delete all objects with this prefix
let objects = self
.s3_client
.list_objects_v2()
.bucket(&name)
.prefix(&prefix)
.send()
.await?;
// List and delete all objects with this prefix
let objects = s3_client
.list_objects_v2()
.bucket(&name)
.prefix(&prefix)
.send()
.await?;
if let Some(contents) = objects.contents {
for object in contents {
if let Some(key) = object.key {
self.s3_client
.delete_object()
.bucket(&name)
.key(&key)
.send()
.await?;
if let Some(contents) = objects.contents {
for object in contents {
if let Some(key) = object.key {
s3_client
.delete_object()
.bucket(&name)
.key(&key)
.send()
.await?;
}
}
}
}
@ -273,10 +329,14 @@ impl UserProvisioningService {
use crate::shared::models::schema::user_email_accounts;
use diesel::prelude::*;
let mut conn = self
.db_pool
.get()
.map_err(|e| anyhow::anyhow!("Failed to get database connection: {}", e))?;
diesel::delete(
user_email_accounts::table.filter(user_email_accounts::username.eq(username)),
)
.execute(&*self.db_conn)?;
.execute(&mut conn)?;
Ok(())
}

14
src/core/dns/mod.rs
View file

@ -4,7 +4,7 @@ use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::fs;
use std::net::IpAddr;
use std::path::{Path, PathBuf};
use std::path::PathBuf;
use std::sync::Arc;
use tokio::sync::RwLock;
@ -34,7 +34,7 @@ impl Default for DnsConfig {
Self {
enabled: false,
zone_file_path: PathBuf::from("./botserver-stack/conf/dns/botserver.local.zone"),
domain: "botserver.local",
domain: "botserver.local".to_string(),
max_entries_per_ip: 5,
ttl_seconds: 60,
cleanup_interval_hours: 24,
@ -48,6 +48,14 @@ pub struct DynamicDnsService {
entries_by_ip: Arc<RwLock<HashMap<IpAddr, Vec<String>>>>,
}
impl std::fmt::Debug for DynamicDnsService {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("DynamicDnsService")
.field("config", &self.config)
.finish_non_exhaustive()
}
}
impl DynamicDnsService {
pub fn new(config: DnsConfig) -> Self {
Self {
@ -257,7 +265,7 @@ use axum::{
extract::{Query, State},
http::StatusCode,
response::Json,
routing::{get, post},
routing::post,
Router,
};

1
src/core/mod.rs
View file

@ -9,5 +9,4 @@ pub mod package_manager;
pub mod secrets;
pub mod session;
pub mod shared;
pub mod ui_server;
pub mod urls;

11
src/core/package_manager/installer.rs
View file

@ -48,13 +48,16 @@ impl PackageManager {
self.register_alm();
self.register_alm_ci();
self.register_meeting();
self.register_desktop();
self.register_remote_terminal();
self.register_devtools();
self.register_vector_db();
self.register_timeseries_db();
self.register_secrets();
self.register_observability();
self.register_host();
self.register_webmail();
self.register_table_editor();
self.register_doc_editor();
}
fn register_drive(&mut self) {
@ -518,11 +521,11 @@ impl PackageManager {
);
}
fn register_desktop(&mut self) {
fn register_remote_terminal(&mut self) {
self.components.insert(
"desktop".to_string(),
"remote_terminal".to_string(),
ComponentConfig {
name: "desktop".to_string(),
name: "remote_terminal".to_string(),
ports: vec![3389],
dependencies: vec![],

22
src/core/secrets/mod.rs
View file

@ -24,14 +24,15 @@
//! - gbo/observability - InfluxDB credentials (url, org, token)
use anyhow::{anyhow, Context, Result};
use log::{debug, error, info, trace, warn};
use serde::{Deserialize, Serialize};
use log::{debug, info, trace, warn};
use serde::Deserialize;
use std::collections::HashMap;
use std::env;
use std::sync::Arc;
use tokio::sync::RwLock;
/// Secret paths in Vault
#[derive(Debug)]
pub struct SecretPaths;
impl SecretPaths {
@ -124,6 +125,15 @@ pub struct SecretsManager {
enabled: bool,
}
impl std::fmt::Debug for SecretsManager {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("SecretsManager")
.field("config", &self.config)
.field("enabled", &self.enabled)
.finish_non_exhaustive()
}
}
impl SecretsManager {
/// Create a new secrets manager
pub fn new(config: VaultConfig) -> Result<Self> {
@ -511,14 +521,6 @@ impl SecretsManager {
data.insert("secret".to_string(), v);
}
}
SecretPaths::TABLES => {
if let Ok(v) = env::var("DB_USER") {
data.insert("username".to_string(), v);
}
if let Ok(v) = env::var("DB_PASSWORD") {
data.insert("password".to_string(), v);
}
}
SecretPaths::CACHE => {
if let Ok(v) = env::var("REDIS_PASSWORD") {
data.insert("password".to_string(), v);

2
src/core/session/mod.rs
View file

@ -421,7 +421,7 @@ pub async fn create_session(Extension(state): Extension<Arc<AppState>>) -> impl
let user_id = Uuid::parse_str("00000000-0000-0000-0000-000000000001").unwrap();
let bot_id = Uuid::nil();
let session_result = {
let _session_result = {
let mut sm = state.session_manager.lock().await;
// Try to create, but don't fail if database has issues
match sm.get_or_create_user_session(user_id, bot_id, "New Conversation") {

78
src/core/ui_server/mod.rs
View file

@ -1,78 +0,0 @@
use axum::{
http::StatusCode,
response::{Html, IntoResponse},
routing::get,
Router,
};
use log::error;
use std::{fs, path::PathBuf};
use tower_http::services::ServeDir;
// Serve minimal UI (default at /)
pub async fn index() -> impl IntoResponse {
serve_minimal().await
}
// Handler for minimal UI
pub async fn serve_minimal() -> impl IntoResponse {
match fs::read_to_string("ui/minimal/index.html") {
Ok(html) => (StatusCode::OK, [("content-type", "text/html")], Html(html)),
Err(e) => {
error!("Failed to load minimal UI: {}", e);
(
StatusCode::INTERNAL_SERVER_ERROR,
[("content-type", "text/plain")],
Html("Failed to load minimal interface".to_string()),
)
}
}
}
// Handler for suite UI
pub async fn serve_suite() -> impl IntoResponse {
match fs::read_to_string("ui/suite/index.html") {
Ok(html) => (StatusCode::OK, [("content-type", "text/html")], Html(html)),
Err(e) => {
error!("Failed to load suite UI: {}", e);
(
StatusCode::INTERNAL_SERVER_ERROR,
[("content-type", "text/plain")],
Html("Failed to load suite interface".to_string()),
)
}
}
}
pub fn configure_router() -> Router {
let suite_path = PathBuf::from("./ui/suite");
let minimal_path = PathBuf::from("./ui/minimal");
Router::new()
// Default route serves minimal UI
.route("/", get(index))
.route("/minimal", get(serve_minimal))
// Suite UI route
.route("/suite", get(serve_suite))
// Suite static assets (when accessing /suite/*)
.nest_service("/suite/js", ServeDir::new(suite_path.join("js")))
.nest_service("/suite/css", ServeDir::new(suite_path.join("css")))
.nest_service("/suite/public", ServeDir::new(suite_path.join("public")))
.nest_service("/suite/drive", ServeDir::new(suite_path.join("drive")))
.nest_service("/suite/chat", ServeDir::new(suite_path.join("chat")))
.nest_service("/suite/mail", ServeDir::new(suite_path.join("mail")))
.nest_service("/suite/tasks", ServeDir::new(suite_path.join("tasks")))
// Legacy paths for backward compatibility (serve suite assets)
.nest_service("/js", ServeDir::new(suite_path.join("js")))
.nest_service("/css", ServeDir::new(suite_path.join("css")))
.nest_service("/public", ServeDir::new(suite_path.join("public")))
.nest_service("/drive", ServeDir::new(suite_path.join("drive")))
.nest_service("/chat", ServeDir::new(suite_path.join("chat")))
.nest_service("/mail", ServeDir::new(suite_path.join("mail")))
.nest_service("/tasks", ServeDir::new(suite_path.join("tasks")))
// Fallback for other static files
.fallback_service(
ServeDir::new(minimal_path.clone()).fallback(
ServeDir::new(minimal_path.clone()).append_index_html_on_directories(true),
),
)
}

2
src/core/urls.rs
View file

@ -4,6 +4,7 @@
//! and ensure consistency across the application.
/// API endpoint paths
#[derive(Debug)]
pub struct ApiUrls;
impl ApiUrls {
@ -148,6 +149,7 @@ impl ApiUrls {
}
/// Internal service URLs
#[derive(Debug)]
pub struct InternalUrls;
impl InternalUrls {

765
src/designer/mod.rs Normal file
View file

@ -0,0 +1,765 @@
use crate::shared::state::AppState;
use axum::{
extract::{Query, State},
response::{Html, IntoResponse},
routing::{get, post},
Json, Router,
};
use chrono::{DateTime, Utc};
use diesel::prelude::*;
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use uuid::Uuid;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SaveRequest {
pub name: Option<String>,
pub content: Option<String>,
pub nodes: Option<serde_json::Value>,
pub connections: Option<serde_json::Value>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ValidateRequest {
pub content: Option<String>,
pub nodes: Option<serde_json::Value>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FileQuery {
pub path: Option<String>,
}
#[derive(Debug, QueryableByName)]
#[diesel(check_for_backend(diesel::pg::Pg))]
pub struct DialogRow {
#[diesel(sql_type = diesel::sql_types::Text)]
pub id: String,
#[diesel(sql_type = diesel::sql_types::Text)]
pub name: String,
#[diesel(sql_type = diesel::sql_types::Text)]
pub content: String,
#[diesel(sql_type = diesel::sql_types::Timestamptz)]
pub updated_at: DateTime<Utc>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ValidationResult {
pub valid: bool,
pub errors: Vec<ValidationError>,
pub warnings: Vec<ValidationWarning>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ValidationError {
pub line: usize,
pub column: usize,
pub message: String,
pub node_id: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ValidationWarning {
pub line: usize,
pub message: String,
pub node_id: Option<String>,
}
pub fn configure_designer_routes() -> Router<Arc<AppState>> {
Router::new()
// Match frontend /api/v1/designer/* endpoints
.route("/api/v1/designer/files", get(handle_list_files))
.route("/api/v1/designer/load", get(handle_load_file))
.route("/api/v1/designer/save", post(handle_save))
.route("/api/v1/designer/validate", post(handle_validate))
.route("/api/v1/designer/export", get(handle_export))
// Legacy endpoints for compatibility
.route(
"/api/designer/dialogs",
get(handle_list_dialogs).post(handle_create_dialog),
)
.route("/api/designer/dialogs/{id}", get(handle_get_dialog))
}
/// GET /api/v1/designer/files - List available dialog files
pub async fn handle_list_files(State(state): State<Arc<AppState>>) -> impl IntoResponse {
let conn = state.conn.clone();
let files = tokio::task::spawn_blocking(move || {
let mut db_conn = match conn.get() {
Ok(c) => c,
Err(e) => {
log::error!("DB connection error: {}", e);
return get_default_files();
}
};
let result: Result<Vec<DialogRow>, _> = diesel::sql_query(
"SELECT id, name, content, updated_at FROM designer_dialogs ORDER BY updated_at DESC LIMIT 50",
)
.load(&mut db_conn);
match result {
Ok(dialogs) if !dialogs.is_empty() => dialogs
.into_iter()
.map(|d| (d.id, d.name, d.updated_at))
.collect(),
_ => get_default_files(),
}
})
.await
.unwrap_or_else(|_| get_default_files());
let mut html = String::new();
html.push_str("<div class=\"file-list\">");
for (id, name, updated_at) in &files {
let time_str = format_relative_time(*updated_at);
html.push_str("<div class=\"file-item\" data-id=\"");
html.push_str(&html_escape(id));
html.push_str("\" onclick=\"selectFile(this)\">");
html.push_str("<div class=\"file-icon\">");
html.push_str("<svg width=\"16\" height=\"16\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\">");
html.push_str(
"<path d=\"M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z\"></path>",
);
html.push_str("<polyline points=\"14 2 14 8 20 8\"></polyline>");
html.push_str("</svg>");
html.push_str("</div>");
html.push_str("<div class=\"file-info\">");
html.push_str("<span class=\"file-name\">");
html.push_str(&html_escape(name));
html.push_str("</span>");
html.push_str("<span class=\"file-time\">");
html.push_str(&html_escape(&time_str));
html.push_str("</span>");
html.push_str("</div>");
html.push_str("</div>");
}
if files.is_empty() {
html.push_str("<div class=\"empty-state\">");
html.push_str("<p>No dialog files found</p>");
html.push_str("<p class=\"hint\">Create a new dialog to get started</p>");
html.push_str("</div>");
}
html.push_str("</div>");
Html(html)
}
fn get_default_files() -> Vec<(String, String, DateTime<Utc>)> {
vec![
(
"welcome".to_string(),
"Welcome Dialog".to_string(),
Utc::now(),
),
("faq".to_string(), "FAQ Bot".to_string(), Utc::now()),
(
"support".to_string(),
"Customer Support".to_string(),
Utc::now(),
),
]
}
/// GET /api/v1/designer/load - Load a specific dialog file
pub async fn handle_load_file(
State(state): State<Arc<AppState>>,
Query(params): Query<FileQuery>,
) -> impl IntoResponse {
let file_id = params.path.unwrap_or_else(|| "welcome".to_string());
let conn = state.conn.clone();
let dialog = tokio::task::spawn_blocking(move || {
let mut db_conn = match conn.get() {
Ok(c) => c,
Err(e) => {
log::error!("DB connection error: {}", e);
return None;
}
};
diesel::sql_query(
"SELECT id, name, content, updated_at FROM designer_dialogs WHERE id = $1",
)
.bind::<diesel::sql_types::Text, _>(&file_id)
.get_result::<DialogRow>(&mut db_conn)
.ok()
})
.await
.unwrap_or(None);
let content = match dialog {
Some(d) => d.content,
None => get_default_dialog_content(),
};
// Return the canvas nodes as HTML for HTMX to swap
let mut html = String::new();
html.push_str("<div class=\"canvas-loaded\" data-content=\"");
html.push_str(&html_escape(&content));
html.push_str("\">");
// Parse content and generate node HTML
let nodes = parse_basic_to_nodes(&content);
for node in &nodes {
html.push_str(&format_node_html(node));
}
html.push_str("</div>");
html.push_str("<script>initializeCanvas();</script>");
Html(html)
}
/// POST /api/v1/designer/save - Save dialog
pub async fn handle_save(
State(state): State<Arc<AppState>>,
Json(payload): Json<SaveRequest>,
) -> impl IntoResponse {
let conn = state.conn.clone();
let now = Utc::now();
let name = payload.name.unwrap_or_else(|| "Untitled".to_string());
let content = payload.content.unwrap_or_default();
let dialog_id = Uuid::new_v4().to_string();
let result = tokio::task::spawn_blocking(move || {
let mut db_conn = match conn.get() {
Ok(c) => c,
Err(e) => {
log::error!("DB connection error: {}", e);
return Err(format!("Database error: {}", e));
}
};
diesel::sql_query(
"INSERT INTO designer_dialogs (id, name, description, bot_id, content, is_active, created_at, updated_at) VALUES ($1, $2, $3, $4, $5, $6, $7, $8) ON CONFLICT (id) DO UPDATE SET content = $5, updated_at = $8",
)
.bind::<diesel::sql_types::Text, _>(&dialog_id)
.bind::<diesel::sql_types::Text, _>(&name)
.bind::<diesel::sql_types::Text, _>("")
.bind::<diesel::sql_types::Text, _>("default")
.bind::<diesel::sql_types::Text, _>(&content)
.bind::<diesel::sql_types::Bool, _>(false)
.bind::<diesel::sql_types::Timestamptz, _>(now)
.bind::<diesel::sql_types::Timestamptz, _>(now)
.execute(&mut db_conn)
.map_err(|e| format!("Save failed: {}", e))?;
Ok(())
})
.await
.unwrap_or_else(|e| Err(format!("Task error: {}", e)));
match result {
Ok(_) => {
let mut html = String::new();
html.push_str("<div class=\"save-result success\">");
html.push_str("<span class=\"save-icon\">✓</span>");
html.push_str("<span class=\"save-message\">Saved successfully</span>");
html.push_str("</div>");
Html(html)
}
Err(e) => {
let mut html = String::new();
html.push_str("<div class=\"save-result error\">");
html.push_str("<span class=\"save-icon\">✗</span>");
html.push_str("<span class=\"save-message\">Save failed: ");
html.push_str(&html_escape(&e));
html.push_str("</span>");
html.push_str("</div>");
Html(html)
}
}
}
/// POST /api/v1/designer/validate - Validate dialog code
pub async fn handle_validate(
State(_state): State<Arc<AppState>>,
Json(payload): Json<ValidateRequest>,
) -> impl IntoResponse {
let content = payload.content.unwrap_or_default();
let validation = validate_basic_code(&content);
let mut html = String::new();
html.push_str("<div class=\"validation-result\">");
if validation.valid {
html.push_str("<div class=\"validation-success\">");
html.push_str("<span class=\"validation-icon\">✓</span>");
html.push_str("<span class=\"validation-text\">Dialog is valid</span>");
html.push_str("</div>");
} else {
html.push_str("<div class=\"validation-errors\">");
html.push_str("<div class=\"validation-header\">");
html.push_str("<span class=\"validation-icon\">✗</span>");
html.push_str("<span class=\"validation-text\">");
html.push_str(&validation.errors.len().to_string());
html.push_str(" error(s) found</span>");
html.push_str("</div>");
html.push_str("<ul class=\"error-list\">");
for error in &validation.errors {
html.push_str("<li class=\"error-item\" data-line=\"");
html.push_str(&error.line.to_string());
html.push_str("\">");
html.push_str("<span class=\"error-line\">Line ");
html.push_str(&error.line.to_string());
html.push_str(":</span> ");
html.push_str(&html_escape(&error.message));
html.push_str("</li>");
}
html.push_str("</ul>");
html.push_str("</div>");
}
if !validation.warnings.is_empty() {
html.push_str("<div class=\"validation-warnings\">");
html.push_str("<div class=\"validation-header\">");
html.push_str("<span class=\"validation-icon\">⚠</span>");
html.push_str("<span class=\"validation-text\">");
html.push_str(&validation.warnings.len().to_string());
html.push_str(" warning(s)</span>");
html.push_str("</div>");
html.push_str("<ul class=\"warning-list\">");
for warning in &validation.warnings {
html.push_str("<li class=\"warning-item\">");
html.push_str("<span class=\"warning-line\">Line ");
html.push_str(&warning.line.to_string());
html.push_str(":</span> ");
html.push_str(&html_escape(&warning.message));
html.push_str("</li>");
}
html.push_str("</ul>");
html.push_str("</div>");
}
html.push_str("</div>");
Html(html)
}
/// GET /api/v1/designer/export - Export dialog as .bas file
pub async fn handle_export(
State(_state): State<Arc<AppState>>,
Query(params): Query<FileQuery>,
) -> impl IntoResponse {
let _file_id = params.path.unwrap_or_else(|| "dialog".to_string());
// In production, this would generate and download the file
Html("<script>alert('Export started. File will download shortly.');</script>".to_string())
}
/// GET /api/designer/dialogs - List dialogs (legacy endpoint)
pub async fn handle_list_dialogs(State(state): State<Arc<AppState>>) -> impl IntoResponse {
let conn = state.conn.clone();
let dialogs = tokio::task::spawn_blocking(move || {
let mut db_conn = match conn.get() {
Ok(c) => c,
Err(e) => {
log::error!("DB connection error: {}", e);
return Vec::new();
}
};
diesel::sql_query(
"SELECT id, name, content, updated_at FROM designer_dialogs ORDER BY updated_at DESC LIMIT 50",
)
.load::<DialogRow>(&mut db_conn)
.unwrap_or_default()
})
.await
.unwrap_or_default();
let mut html = String::new();
html.push_str("<div class=\"dialogs-list\">");
for dialog in &dialogs {
html.push_str("<div class=\"dialog-card\" data-id=\"");
html.push_str(&html_escape(&dialog.id));
html.push_str("\">");
html.push_str("<h4>");
html.push_str(&html_escape(&dialog.name));
html.push_str("</h4>");
html.push_str("<span class=\"dialog-time\">");
html.push_str(&format_relative_time(dialog.updated_at));
html.push_str("</span>");
html.push_str("</div>");
}
if dialogs.is_empty() {
html.push_str("<div class=\"empty-state\">");
html.push_str("<p>No dialogs yet</p>");
html.push_str("</div>");
}
html.push_str("</div>");
Html(html)
}
/// POST /api/designer/dialogs - Create new dialog (legacy endpoint)
pub async fn handle_create_dialog(
State(state): State<Arc<AppState>>,
Json(payload): Json<SaveRequest>,
) -> impl IntoResponse {
let conn = state.conn.clone();
let now = Utc::now();
let dialog_id = Uuid::new_v4().to_string();
let name = payload.name.unwrap_or_else(|| "New Dialog".to_string());
let content = payload.content.unwrap_or_else(get_default_dialog_content);
let result = tokio::task::spawn_blocking(move || {
let mut db_conn = match conn.get() {
Ok(c) => c,
Err(e) => {
log::error!("DB connection error: {}", e);
return Err(format!("Database error: {}", e));
}
};
diesel::sql_query(
"INSERT INTO designer_dialogs (id, name, description, bot_id, content, is_active, created_at, updated_at) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)",
)
.bind::<diesel::sql_types::Text, _>(&dialog_id)
.bind::<diesel::sql_types::Text, _>(&name)
.bind::<diesel::sql_types::Text, _>("")
.bind::<diesel::sql_types::Text, _>("default")
.bind::<diesel::sql_types::Text, _>(&content)
.bind::<diesel::sql_types::Bool, _>(false)
.bind::<diesel::sql_types::Timestamptz, _>(now)
.bind::<diesel::sql_types::Timestamptz, _>(now)
.execute(&mut db_conn)
.map_err(|e| format!("Create failed: {}", e))?;
Ok(dialog_id)
})
.await
.unwrap_or_else(|e| Err(format!("Task error: {}", e)));
match result {
Ok(id) => {
let mut html = String::new();
html.push_str("<div class=\"dialog-created\" data-id=\"");
html.push_str(&html_escape(&id));
html.push_str("\">");
html.push_str("<span class=\"success\">Dialog created</span>");
html.push_str("</div>");
Html(html)
}
Err(e) => {
let mut html = String::new();
html.push_str("<div class=\"error\">");
html.push_str(&html_escape(&e));
html.push_str("</div>");
Html(html)
}
}
}
/// GET /api/designer/dialogs/{id} - Get specific dialog (legacy endpoint)
pub async fn handle_get_dialog(
State(state): State<Arc<AppState>>,
axum::extract::Path(id): axum::extract::Path<String>,
) -> impl IntoResponse {
let conn = state.conn.clone();
let dialog = tokio::task::spawn_blocking(move || {
let mut db_conn = match conn.get() {
Ok(c) => c,
Err(e) => {
log::error!("DB connection error: {}", e);
return None;
}
};
diesel::sql_query(
"SELECT id, name, content, updated_at FROM designer_dialogs WHERE id = $1",
)
.bind::<diesel::sql_types::Text, _>(&id)
.get_result::<DialogRow>(&mut db_conn)
.ok()
})
.await
.unwrap_or(None);
match dialog {
Some(d) => {
let mut html = String::new();
html.push_str("<div class=\"dialog-content\" data-id=\"");
html.push_str(&html_escape(&d.id));
html.push_str("\">");
html.push_str("<div class=\"dialog-header\">");
html.push_str("<h3>");
html.push_str(&html_escape(&d.name));
html.push_str("</h3>");
html.push_str("</div>");
html.push_str("<div class=\"dialog-code\">");
html.push_str("<pre>");
html.push_str(&html_escape(&d.content));
html.push_str("</pre>");
html.push_str("</div>");
html.push_str("</div>");
Html(html)
}
None => Html("<div class=\"error\">Dialog not found</div>".to_string()),
}
}
// BASIC Code Validation
fn validate_basic_code(code: &str) -> ValidationResult {
let mut errors = Vec::new();
let mut warnings = Vec::new();
let lines: Vec<&str> = code.lines().collect();
for (i, line) in lines.iter().enumerate() {
let line_num = i + 1;
let trimmed = line.trim();
if trimmed.is_empty() || trimmed.starts_with('\'') || trimmed.starts_with("REM ") {
continue;
}
// Check for common syntax issues
let upper = trimmed.to_uppercase();
if upper.starts_with("IF ") && !upper.contains(" THEN") {
errors.push(ValidationError {
line: line_num,
column: 1,
message: "IF statement missing THEN keyword".to_string(),
node_id: None,
});
}
if upper.starts_with("FOR ") && !upper.contains(" TO ") {
errors.push(ValidationError {
line: line_num,
column: 1,
message: "FOR statement missing TO keyword".to_string(),
node_id: None,
});
}
// Check for unclosed strings
let quote_count = trimmed.chars().filter(|c| *c == '"').count();
if quote_count % 2 != 0 {
errors.push(ValidationError {
line: line_num,
column: trimmed.find('"').unwrap_or(0) + 1,
message: "Unclosed string literal".to_string(),
node_id: None,
});
}
// Warnings
if upper.starts_with("GOTO ") {
warnings.push(ValidationWarning {
line: line_num,
message: "GOTO statements can make code harder to maintain".to_string(),
node_id: None,
});
}
if trimmed.len() > 120 {
warnings.push(ValidationWarning {
line: line_num,
message: "Line exceeds recommended length of 120 characters".to_string(),
node_id: None,
});
}
}
// Check block structures
let mut if_count = 0i32;
let mut for_count = 0i32;
let mut sub_count = 0i32;
for line in &lines {
let upper = line.to_uppercase();
let trimmed = upper.trim();
if trimmed.starts_with("IF ") && !trimmed.ends_with(" THEN") && trimmed.contains(" THEN") {
// Single-line IF
} else if trimmed.starts_with("IF ") {
if_count += 1;
} else if trimmed == "END IF" || trimmed == "ENDIF" {
if_count -= 1;
}
if trimmed.starts_with("FOR ") {
for_count += 1;
} else if trimmed == "NEXT" || trimmed.starts_with("NEXT ") {
for_count -= 1;
}
if trimmed.starts_with("SUB ") {
sub_count += 1;
} else if trimmed == "END SUB" {
sub_count -= 1;
}
}
if if_count > 0 {
errors.push(ValidationError {
line: lines.len(),
column: 1,
message: format!("{} unclosed IF statement(s)", if_count),
node_id: None,
});
}
if for_count > 0 {
errors.push(ValidationError {
line: lines.len(),
column: 1,
message: format!("{} unclosed FOR loop(s)", for_count),
node_id: None,
});
}
if sub_count > 0 {
errors.push(ValidationError {
line: lines.len(),
column: 1,
message: format!("{} unclosed SUB definition(s)", sub_count),
node_id: None,
});
}
ValidationResult {
valid: errors.is_empty(),
errors,
warnings,
}
}
fn get_default_dialog_content() -> String {
"' Welcome Dialog\n\
' Created with Dialog Designer\n\
\n\
SUB Main()\n\
TALK \"Hello! How can I help you today?\"\n\
\n\
answer = HEAR\n\
\n\
IF answer LIKE \"*help*\" THEN\n\
TALK \"I'm here to assist you.\"\n\
ELSE IF answer LIKE \"*bye*\" THEN\n\
TALK \"Goodbye!\"\n\
ELSE\n\
TALK \"I understand: \" + answer\n\
END IF\n\
END SUB\n"
.to_string()
}
// Node parsing and HTML generation
struct DialogNode {
id: String,
node_type: String,
content: String,
x: i32,
y: i32,
}
fn parse_basic_to_nodes(content: &str) -> Vec<DialogNode> {
let mut nodes = Vec::new();
let mut y_pos = 100;
for (i, line) in content.lines().enumerate() {
let trimmed = line.trim();
if trimmed.is_empty() || trimmed.starts_with('\'') {
continue;
}
let upper = trimmed.to_uppercase();
let node_type = if upper.starts_with("TALK ") {
"talk"
} else if upper.starts_with("HEAR") {
"hear"
} else if upper.starts_with("IF ") {
"if"
} else if upper.starts_with("FOR ") {
"for"
} else if upper.starts_with("SET ") || upper.contains(" = ") {
"set"
} else if upper.starts_with("CALL ") {
"call"
} else if upper.starts_with("SUB ") {
"sub"
} else {
continue;
};
nodes.push(DialogNode {
id: format!("node-{}", i),
node_type: node_type.to_string(),
content: trimmed.to_string(),
x: 400,
y: y_pos,
});
y_pos += 80;
}
nodes
}
fn format_node_html(node: &DialogNode) -> String {
let mut html = String::new();
html.push_str("<div class=\"canvas-node node-");
html.push_str(&node.node_type);
html.push_str("\" id=\"");
html.push_str(&html_escape(&node.id));
html.push_str("\" style=\"left: ");
html.push_str(&node.x.to_string());
html.push_str("px; top: ");
html.push_str(&node.y.to_string());
html.push_str("px;\" draggable=\"true\">");
html.push_str("<div class=\"node-header\">");
html.push_str("<span class=\"node-type\">");
html.push_str(&node.node_type.to_uppercase());
html.push_str("</span>");
html.push_str("</div>");
html.push_str("<div class=\"node-content\">");
html.push_str(&html_escape(&node.content));
html.push_str("</div>");
html.push_str("<div class=\"node-ports\">");
html.push_str("<div class=\"port port-in\"></div>");
html.push_str("<div class=\"port port-out\"></div>");
html.push_str("</div>");
html.push_str("</div>");
html
}
fn format_relative_time(time: DateTime<Utc>) -> String {
let now = Utc::now();
let duration = now.signed_duration_since(time);
if duration.num_seconds() < 60 {
"just now".to_string()
} else if duration.num_minutes() < 60 {
format!("{}m ago", duration.num_minutes())
} else if duration.num_hours() < 24 {
format!("{}h ago", duration.num_hours())
} else if duration.num_days() < 7 {
format!("{}d ago", duration.num_days())
} else {
time.format("%b %d").to_string()
}
}
fn html_escape(s: &str) -> String {
s.replace('&', "&amp;")
.replace('<', "&lt;")
.replace('>', "&gt;")
.replace('"', "&quot;")
.replace('\'', "&#39;")
}

82
src/desktop/drive.rs
View file

@ -1,82 +0,0 @@
use serde::{Deserialize, Serialize};
use std::fs;
use std::path::{Path, PathBuf};
use tauri::{Emitter, Window};
#[derive(Debug, Serialize, Deserialize)]
pub struct FileItem {
name: String,
path: String,
is_dir: bool,
}
#[tauri::command]
pub fn list_files(path: &str) -> Result<Vec<FileItem>, String> {
let base_path = Path::new(path);
let mut files = Vec::new();
if !base_path.exists() {
return Err("Path does not exist".into());
}
for entry in fs::read_dir(base_path).map_err(|e| e.to_string())? {
let entry = entry.map_err(|e| e.to_string())?;
let path = entry.path();
let name = path
.file_name()
.and_then(|n| n.to_str())
.unwrap_or("")
.to_string();
files.push(FileItem {
name,
path: path.to_str().unwrap_or("").to_string(),
is_dir: path.is_dir(),
});
}
files.sort_by(|a, b| {
if a.is_dir && !b.is_dir {
std::cmp::Ordering::Less
} else if !a.is_dir && b.is_dir {
std::cmp::Ordering::Greater
} else {
a.name.cmp(&b.name)
}
});
Ok(files)
}
#[tauri::command]
pub async fn upload_file(window: Window, src_path: String, dest_path: String) -> Result<(), String> {
use std::fs::File;
use std::io::{Read, Write};
let src = PathBuf::from(&src_path);
let dest_dir = PathBuf::from(&dest_path);
let dest = dest_dir.join(src.file_name().ok_or("Invalid source file")?);
if !dest_dir.exists() {
fs::create_dir_all(&dest_dir).map_err(|e| e.to_string())?;
}
let mut source_file = File::open(&src).map_err(|e| e.to_string())?;
let mut dest_file = File::create(&dest).map_err(|e| e.to_string())?;
let file_size = source_file.metadata().map_err(|e| e.to_string())?.len();
let mut buffer = [0; 8192];
let mut total_read = 0;
loop {
let bytes_read = source_file.read(&mut buffer).map_err(|e| e.to_string())?;
if bytes_read == 0 {
break;
}
dest_file
.write_all(&buffer[..bytes_read])
.map_err(|e| e.to_string())?;
total_read += bytes_read as u64;
let progress = (total_read as f64 / file_size as f64) * 100.0;
window
.emit("upload_progress", progress)
.map_err(|e| e.to_string())?;
}
Ok(())
}
#[tauri::command]
pub fn create_folder(path: String, name: String) -> Result<(), String> {
let full_path = Path::new(&path).join(&name);
if full_path.exists() {
return Err("Folder already exists".into());
}
fs::create_dir(full_path).map_err(|e| e.to_string())?;
Ok(())
}

391
src/desktop/local-sync.rs
View file

@ -1,391 +0,0 @@
use dioxus::prelude::*;
use dioxus_desktop::{use_window, LogicalSize};
use std::env;
use std::fs::{File, OpenOptions, create_dir_all};
use std::io::{BufRead, BufReader, Write};
use std::path::Path;
use std::process::{Command as ProcCommand, Child, Stdio};
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::{Duration, Instant};
use notify_rust::Notification;
use serde::{Deserialize, Serialize};
use serde_json::Value;
#[derive(Debug, Clone)]
struct AppState {
name: String,
access_key: String,
secret_key: String,
status_text: String,
sync_processes: Arc<Mutex<Vec<Child>>>,
sync_active: Arc<Mutex<bool>>,
sync_statuses: Arc<Mutex<Vec<SyncStatus>>>,
show_config_dialog: bool,
show_about_dialog: bool,
current_screen: Screen,
}
#[derive(Debug, Clone)]
enum Screen {
Main,
Status,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
struct RcloneConfig {
name: String,
remote_path: String,
local_path: String,
access_key: String,
secret_key: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
struct SyncStatus {
name: String,
status: String,
transferred: String,
bytes: String,
errors: usize,
last_updated: String,
}
#[derive(Debug, Clone)]
enum Message {
NameChanged(String),
AccessKeyChanged(String),
SecretKeyChanged(String),
SaveConfig,
StartSync,
StopSync,
UpdateStatus(Vec<SyncStatus>),
ShowConfigDialog(bool),
ShowAboutDialog(bool),
ShowStatusScreen,
BackToMain,
None,
}
fn main() {
dioxus_desktop::launch(app);
}
fn app(cx: Scope) -> Element {
let window = use_window();
window.set_inner_size(LogicalSize::new(800, 600));
let state = use_ref(cx, || AppState {
name: String::new(),
access_key: String::new(),
secret_key: String::new(),
status_text: "Enter credentials to set up sync".to_string(),
sync_processes: Arc::new(Mutex::new(Vec::new())),
sync_active: Arc::new(Mutex::new(false)),
sync_statuses: Arc::new(Mutex::new(Vec::new())),
show_config_dialog: false,
show_about_dialog: false,
current_screen: Screen::Main,
});
use_future( async move {
let state = state.clone();
async move {
let mut last_check = Instant::now();
let check_interval = Duration::from_secs(5);
loop {
tokio::time::sleep(Duration::from_secs(1)).await;
if !*state.read().sync_active.lock().unwrap() {
continue;
}
if last_check.elapsed() < check_interval {
continue;
}
last_check = Instant::now();
match read_rclone_configs() {
Ok(configs) => {
let mut new_statuses = Vec::new();
for config in configs {
match get_rclone_status(&config.name) {
Ok(status) => new_statuses.push(status),
Err(e) => eprintln!("Failed to get status: {}", e),
}
}
*state.write().sync_statuses.lock().unwrap() = new_statuses.clone();
state.write().status_text = format!("Syncing {} repositories...", new_statuses.len());
}
Err(e) => eprintln!("Failed to read configs: {}", e),
}
}
}
});
cx.render(rsx! {
div {
class: "app",
div {
class: "menu-bar",
button {
onclick: move |_| state.write().show_config_dialog = true,
"Add Sync Configuration"
}
button {
onclick: move |_| state.write().show_about_dialog = true,
"About"
}
}
{match state.read().current_screen {
Screen::Main => rsx! {
div {
class: "main-screen",
h1 { "General Bots" }
p { "{state.read().status_text}" }
button {
onclick: move |_| start_sync(&state),
"Start Sync"
}
button {
onclick: move |_| stop_sync(&state),
"Stop Sync"
}
button {
onclick: move |_| state.write().current_screen = Screen::Status,
"Show Status"
}
}
},
Screen::Status => rsx! {
div {
class: "status-screen",
h1 { "Sync Status" }
div {
class: "status-list",
for status in state.read().sync_statuses.lock().unwrap().iter() {
div {
class: "status-item",
h2 { "{status.name}" }
p { "Status: {status.status}" }
p { "Transferred: {status.transferred}" }
p { "Bytes: {status.bytes}" }
p { "Errors: {status.errors}" }
p { "Last Updated: {status.last_updated}" }
}
}
}
button {
onclick: move |_| state.write().current_screen = Screen::Main,
"Back"
}
}
}
}}
if state.read().show_config_dialog {
div {
class: "dialog",
h2 { "Add Sync Configuration" }
input {
value: "{state.read().name}",
oninput: move |e| state.write().name = e.value.clone(),
placeholder: "Enter sync name",
}
input {
value: "{state.read().access_key}",
oninput: move |e| state.write().access_key = e.value.clone(),
placeholder: "Enter access key",
}
input {
value: "{state.read().secret_key}",
oninput: move |e| state.write().secret_key = e.value.clone(),
placeholder: "Enter secret key",
}
button {
onclick: move |_| {
save_config(&state);
state.write().show_config_dialog = false;
},
"Save"
}
button {
onclick: move |_| state.write().show_config_dialog = false,
"Cancel"
}
}
}
if state.read().show_about_dialog {
div {
class: "dialog",
h2 { "About General Bots" }
p { "Version: 1.0.0" }
p { "A professional-grade sync tool for OneDrive/Dropbox-like functionality." }
button {
onclick: move |_| state.write().show_about_dialog = false,
"Close"
}
}
}
}
})
}
fn save_config(state: &UseRef<AppState>) {
if state.read().name.is_empty() || state.read().access_key.is_empty() || state.read().secret_key.is_empty() {
state.write_with(|state| state.status_text = "All fields are required!".to_string());
return;
}
let new_config = RcloneConfig {
name: state.read().name.clone(),
remote_path: format!("s3:
local_path: Path::new(&env::var("HOME").unwrap()).join("General Bots").join(&state.read().name).to_string_lossy().to_string(),
access_key: state.read().access_key.clone(),
secret_key: state.read().secret_key.clone(),
};
if let Err(e) = save_rclone_config(&new_config) {
state.write_with(|state| state.status_text = format!("Failed to save config: {}", e));
} else {
state.write_with(|state| state.status_text = "New sync saved!".to_string());
}
}
fn start_sync(state: &UseRef<AppState>) {
let mut processes = state.write_with(|state| state.sync_processes.lock().unwrap());
processes.clear();
match read_rclone_configs() {
Ok(configs) => {
for config in configs {
match run_sync(&config) {
Ok(child) => processes.push(child),
Err(e) => eprintln!("Failed to start sync: {}", e),
}
}
state.write_with(|state| *state.sync_active.lock().unwrap() = true);
state.write_with(|state| state.status_text = format!("Syncing with {} configurations.", processes.len()));
}
Err(e) => state.write_with(|state| state.status_text = format!("Failed to read configurations: {}", e)),
}
}
fn stop_sync(state: &UseRef<AppState>) {
let mut processes = state.write_with(|state| state.sync_processes.lock().unwrap());
for child in processes.iter_mut() {
let _ = child.kill();
}
processes.clear();
state.write_with(|state| *state.sync_active.lock().unwrap() = false);
state.write_with(|state| state.status_text = "Sync stopped.".to_string());
}
fn save_rclone_config(config: &RcloneConfig) -> Result<(), String> {
let home_dir = env::var("HOME").map_err(|_| "HOME environment variable not set".to_string())?;
let config_path = Path::new(&home_dir).join(".config/rclone/rclone.conf");
let mut file = OpenOptions::new()
.create(true)
.append(true)
.open(&config_path)
.map_err(|e| format!("Failed to open config file: {}", e))?;
writeln!(file, "[{}]", config.name)
.and_then(|_| writeln!(file, "type = s3"))
.and_then(|_| writeln!(file, "provider = Other"))
.and_then(|_| writeln!(file, "access_key_id = {}", config.access_key))
.and_then(|_| writeln!(file, "secret_access_key = {}", config.secret_key))
.and_then(|_| writeln!(file, "endpoint = https:
.and_then(|_| writeln!(file, "acl = private"))
.map_err(|e| format!("Failed to write config: {}", e))
}
fn read_rclone_configs() -> Result<Vec<RcloneConfig>, String> {
let home_dir = env::var("HOME").map_err(|_| "HOME environment variable not set".to_string())?;
let config_path = Path::new(&home_dir).join(".config/rclone/rclone.conf");
if !config_path.exists() {
return Ok(Vec::new());
}
let file = File::open(&config_path).map_err(|e| format!("Failed to open config file: {}", e))?;
let reader = BufReader::new(file);
let mut configs = Vec::new();
let mut current_config: Option<RcloneConfig> = None;
for line in reader.lines() {
let line = line.map_err(|e| format!("Failed to read line: {}", e))?;
if line.is_empty() || line.starts_with('#') {
continue;
}
if line.starts_with('[') && line.ends_with(']') {
if let Some(config) = current_config.take() {
configs.push(config);
}
let name = line[1..line.len()-1].to_string();
current_config = Some(RcloneConfig {
name: name.clone(),
remote_path: format!("s3:
local_path: Path::new(&home_dir).join("General Bots").join(&name).to_string_lossy().to_string(),
access_key: String::new(),
secret_key: String::new(),
});
} else if let Some(ref mut config) = current_config {
if let Some(pos) = line.find('=') {
let key = line[..pos].trim().to_string();
let value = line[pos+1..].trim().to_string();
match key.as_str() {
"access_key_id" => config.access_key = value,
"secret_access_key" => config.secret_key = value,
_ => {}
}
}
}
}
if let Some(config) = current_config {
configs.push(config);
}
Ok(configs)
}
fn run_sync(config: &RcloneConfig) -> Result<Child, std::io::Error> {
let local_path = Path::new(&config.local_path);
if !local_path.exists() {
create_dir_all(local_path)?;
}
ProcCommand::new("rclone")
.arg("sync")
.arg(&config.remote_path)
.arg(&config.local_path)
.arg("--no-check-certificate")
.arg("--verbose")
.arg("--rc")
.stdout(Stdio::null())
.stderr(Stdio::null())
.spawn()
}
fn get_rclone_status(remote_name: &str) -> Result<SyncStatus, String> {
let output = ProcCommand::new("rclone")
.arg("rc")
.arg("core/stats")
.arg("--json")
.output()
.map_err(|e| format!("Failed to execute rclone rc: {}", e))?;
if !output.status.success() {
return Err(format!("rclone rc failed: {}", String::from_utf8_lossy(&output.stderr)));
}
let json = String::from_utf8_lossy(&output.stdout);
let parsed: Result<Value, _> = serde_json::from_str(&json);
match parsed {
Ok(value) => {
let transferred = value.get("bytes").and_then(|v| v.as_u64()).unwrap_or(0);
let errors = value.get("errors").and_then(|v| v.as_u64()).unwrap_or(0);
let speed = value.get("speed").and_then(|v| v.as_f64()).unwrap_or(0.0);
let status = if errors > 0 {
"Error occurred".to_string()
} else if speed > 0.0 {
"Transferring".to_string()
} else if transferred > 0 {
"Completed".to_string()
} else {
"Initializing".to_string()
};
Ok(SyncStatus {
name: remote_name.to_string(),
status,
transferred: format_bytes(transferred),
bytes: format!("{}/s", format_bytes(speed as u64)),
errors: errors as usize,
last_updated: chrono::Local::now().format("%H:%M:%S").to_string(),
})
}
Err(e) => Err(format!("Failed to parse rclone status: {}", e)),
}
}
fn format_bytes(bytes: u64) -> String {
const KB: u64 = 1024;
const MB: u64 = KB * 1024;
const GB: u64 = MB * 1024;
if bytes >= GB {
format!("{:.2} GB", bytes as f64 / GB as f64)
} else if bytes >= MB {
format!("{:.2} MB", bytes as f64 / MB as f64)
} else if bytes >= KB {
format!("{:.2} KB", bytes as f64 / KB as f64)
} else {
format!("{} B", bytes)
}
}

22
src/desktop/mod.rs
View file

@ -1,22 +0,0 @@
#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
//! Desktop Module
//!
//! This module provides desktop-specific functionality including:
//! - Drive synchronization with cloud storage
//! - System tray management
//! - Local file operations
//! - Desktop tools (cleaner, optimizer, etc.)
pub mod drive;
pub mod sync;
pub mod tools;
pub mod tray;
// Re-exports
pub use drive::*;
pub use sync::*;
pub use tools::{
CleanupCategory, CleanupStats, DesktopToolsConfig, DesktopToolsManager, DiskInfo,
InstallationStatus, OptimizationStatus, OptimizationTask, TaskStatus,
};
pub use tray::{RunningMode, ServiceMonitor, TrayManager};

23
src/desktop/stream.rs
View file

@ -1,23 +0,0 @@
use ratatui::{
style::{Color, Style},
widgets::{Block, Borders, Gauge},
};
pub struct StreamProgress {
pub progress: f64,
pub status: String,
}
pub fn render_progress_bar(progress: &StreamProgress) -> Gauge {
let color = if progress.progress >= 1.0 {
Color::Green
} else {
Color::Blue
};
Gauge::default()
.block(
Block::default()
.title(format!("Stream Progress: {}", progress.status))
.borders(Borders::ALL),
)
.gauge_style(Style::default().fg(color))
.percent((progress.progress * 100.0) as u16)
}

383
src/desktop/sync.rs
View file

@ -1,383 +0,0 @@
use anyhow::Result;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::env;
use std::fs::{create_dir_all, OpenOptions};
use std::io::Write;
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::sync::Mutex;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RcloneConfig {
name: String,
remote_path: String,
local_path: String,
access_key: String,
secret_key: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BotSyncConfig {
bot_id: String,
bot_name: String,
bucket_name: String,
sync_path: String,
local_path: PathBuf,
role: SyncRole,
enabled: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum SyncRole {
Admin, // Full bucket access
User, // Home directory only
ReadOnly, // Read-only access
}
impl BotSyncConfig {
pub fn new(bot_name: &str, username: &str, role: SyncRole) -> Self {
let bucket_name = format!("{}.gbdrive", bot_name);
let (sync_path, local_path) = match role {
SyncRole::Admin => (
"/".to_string(),
PathBuf::from(env::var("HOME").unwrap_or_default())
.join("BotSync")
.join(bot_name)
.join("admin"),
),
SyncRole::User => (
format!("/home/{}", username),
PathBuf::from(env::var("HOME").unwrap_or_default())
.join("BotSync")
.join(bot_name)
.join(username),
),
SyncRole::ReadOnly => (
format!("/home/{}", username),
PathBuf::from(env::var("HOME").unwrap_or_default())
.join("BotSync")
.join(bot_name)
.join(format!("{}-readonly", username)),
),
};
Self {
bot_id: format!("{}-{}", bot_name, username),
bot_name: bot_name.to_string(),
bucket_name,
sync_path,
local_path,
role,
enabled: true,
}
}
pub fn get_rclone_remote_name(&self) -> String {
format!("{}_{}", self.bot_name, self.bot_id)
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserSyncProfile {
username: String,
bot_configs: Vec<BotSyncConfig>,
}
impl UserSyncProfile {
pub fn new(username: String) -> Self {
Self {
username,
bot_configs: Vec::new(),
}
}
pub fn add_bot(&mut self, bot_name: &str, role: SyncRole) {
let config = BotSyncConfig::new(bot_name, &self.username, role);
self.bot_configs.push(config);
}
pub fn remove_bot(&mut self, bot_name: &str) {
self.bot_configs.retain(|c| c.bot_name != bot_name);
}
pub fn get_active_configs(&self) -> Vec<&BotSyncConfig> {
self.bot_configs.iter().filter(|c| c.enabled).collect()
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SyncStatus {
name: String,
status: String,
transferred: String,
bytes: String,
errors: usize,
last_updated: String,
}
pub(crate) struct AppState {
pub sync_processes: Mutex<HashMap<String, std::process::Child>>,
pub sync_active: Mutex<HashMap<String, bool>>,
pub user_profile: Mutex<Option<UserSyncProfile>>,
}
impl AppState {
pub fn new() -> Self {
Self {
sync_processes: Mutex::new(HashMap::new()),
sync_active: Mutex::new(HashMap::new()),
user_profile: Mutex::new(None),
}
}
}
#[tauri::command]
pub fn load_user_profile(
username: String,
state: tauri::State<AppState>,
) -> Result<UserSyncProfile, String> {
let config_path = PathBuf::from(env::var("HOME").unwrap_or_default())
.join(".config")
.join("botsync")
.join(format!("{}.json", username));
if config_path.exists() {
let content = std::fs::read_to_string(&config_path)
.map_err(|e| format!("Failed to read profile: {}", e))?;
let profile: UserSyncProfile = serde_json::from_str(&content)
.map_err(|e| format!("Failed to parse profile: {}", e))?;
let mut user_profile = state.user_profile.lock().unwrap();
*user_profile = Some(profile.clone());
Ok(profile)
} else {
let profile = UserSyncProfile::new(username);
let mut user_profile = state.user_profile.lock().unwrap();
*user_profile = Some(profile.clone());
Ok(profile)
}
}
#[tauri::command]
pub fn save_user_profile(
profile: UserSyncProfile,
state: tauri::State<AppState>,
) -> Result<(), String> {
let config_dir = PathBuf::from(env::var("HOME").unwrap_or_default())
.join(".config")
.join("botsync");
create_dir_all(&config_dir).map_err(|e| format!("Failed to create config dir: {}", e))?;
let config_path = config_dir.join(format!("{}.json", profile.username));
let content = serde_json::to_string_pretty(&profile)
.map_err(|e| format!("Failed to serialize profile: {}", e))?;
std::fs::write(&config_path, content).map_err(|e| format!("Failed to save profile: {}", e))?;
let mut user_profile = state.user_profile.lock().unwrap();
*user_profile = Some(profile);
Ok(())
}
#[tauri::command]
pub fn save_bot_config(
bot_config: BotSyncConfig,
credentials: HashMap<String, String>,
) -> Result<(), String> {
let home_dir = env::var("HOME").map_err(|_| "HOME environment variable not set".to_string())?;
let config_path = Path::new(&home_dir).join(".config/rclone/rclone.conf");
create_dir_all(config_path.parent().unwrap())
.map_err(|e| format!("Failed to create config directory: {}", e))?;
let mut file = OpenOptions::new()
.create(true)
.append(true)
.open(&config_path)
.map_err(|e| format!("Failed to open config file: {}", e))?;
let remote_name = bot_config.get_rclone_remote_name();
let endpoint = credentials
.get("endpoint")
.unwrap_or(&"https://localhost:9000".to_string());
let access_key = credentials.get("access_key").unwrap_or(&"".to_string());
let secret_key = credentials.get("secret_key").unwrap_or(&"".to_string());
writeln!(file, "[{}]", remote_name)
.and_then(|_| writeln!(file, "type = s3"))
.and_then(|_| writeln!(file, "provider = Minio"))
.and_then(|_| writeln!(file, "access_key_id = {}", access_key))
.and_then(|_| writeln!(file, "secret_access_key = {}", secret_key))
.and_then(|_| writeln!(file, "endpoint = {}", endpoint))
.and_then(|_| writeln!(file, "region = us-east-1"))
.and_then(|_| writeln!(file, "no_check_bucket = true"))
.and_then(|_| writeln!(file, "force_path_style = true"))
.map_err(|e| format!("Failed to write config: {}", e))
}
#[tauri::command]
pub fn start_bot_sync(
bot_config: BotSyncConfig,
state: tauri::State<AppState>,
) -> Result<(), String> {
if !bot_config.local_path.exists() {
create_dir_all(&bot_config.local_path)
.map_err(|e| format!("Failed to create local path: {}", e))?;
}
let remote_name = bot_config.get_rclone_remote_name();
let remote_path = format!(
"{}:{}{}",
remote_name, bot_config.bucket_name, bot_config.sync_path
);
let mut cmd = Command::new("rclone");
cmd.arg("sync")
.arg(&remote_path)
.arg(&bot_config.local_path)
.arg("--no-check-certificate")
.arg("--verbose")
.arg("--rc");
// Add read-only flag if needed
if matches!(bot_config.role, SyncRole::ReadOnly) {
cmd.arg("--read-only");
}
let child = cmd
.stdout(Stdio::null())
.stderr(Stdio::null())
.spawn()
.map_err(|e| format!("Failed to start rclone: {}", e))?;
let mut processes = state.sync_processes.lock().unwrap();
processes.insert(bot_config.bot_id.clone(), child);
let mut active = state.sync_active.lock().unwrap();
active.insert(bot_config.bot_id.clone(), true);
Ok(())
}
#[tauri::command]
pub fn start_all_syncs(state: tauri::State<AppState>) -> Result<(), String> {
let profile = state
.user_profile
.lock()
.unwrap()
.clone()
.ok_or_else(|| "No user profile loaded".to_string())?;
for config in profile.get_active_configs() {
if let Err(e) = start_bot_sync(config.clone(), state.clone()) {
log::error!("Failed to start sync for {}: {}", config.bot_name, e);
}
}
Ok(())
}
#[tauri::command]
pub fn stop_bot_sync(bot_id: String, state: tauri::State<AppState>) -> Result<(), String> {
let mut processes = state.sync_processes.lock().unwrap();
if let Some(mut child) = processes.remove(&bot_id) {
child
.kill()
.map_err(|e| format!("Failed to kill process: {}", e))?;
}
let mut active = state.sync_active.lock().unwrap();
active.remove(&bot_id);
Ok(())
}
#[tauri::command]
pub fn stop_all_syncs(state: tauri::State<AppState>) -> Result<(), String> {
let mut processes = state.sync_processes.lock().unwrap();
for (_, mut child) in processes.drain() {
let _ = child.kill();
}
let mut active = state.sync_active.lock().unwrap();
active.clear();
Ok(())
}
#[tauri::command]
pub fn get_bot_sync_status(
bot_id: String,
state: tauri::State<AppState>,
) -> Result<SyncStatus, String> {
let active = state.sync_active.lock().unwrap();
if !active.contains_key(&bot_id) {
return Err("Sync not active".to_string());
}
let output = Command::new("rclone")
.arg("rc")
.arg("core/stats")
.arg("--json")
.output()
.map_err(|e| format!("Failed to execute rclone rc: {}", e))?;
if !output.status.success() {
return Err(format!(
"rclone rc failed: {}",
String::from_utf8_lossy(&output.stderr)
));
}
let json = String::from_utf8_lossy(&output.stdout);
let value: serde_json::Value =
serde_json::from_str(&json).map_err(|e| format!("Failed to parse rclone status: {}", e))?;
let transferred = value.get("bytes").and_then(|v| v.as_u64()).unwrap_or(0);
let errors = value.get("errors").and_then(|v| v.as_u64()).unwrap_or(0);
let speed = value.get("speed").and_then(|v| v.as_f64()).unwrap_or(0.0);
let status = if errors > 0 {
"Error occurred".to_string()
} else if speed > 0.0 {
"Transferring".to_string()
} else if transferred > 0 {
"Completed".to_string()
} else {
"Initializing".to_string()
};
Ok(SyncStatus {
name: bot_id,
status,
transferred: format_bytes(transferred),
bytes: format!("{}/s", format_bytes(speed as u64)),
errors: errors as usize,
last_updated: chrono::Local::now().format("%H:%M:%S").to_string(),
})
}
#[tauri::command]
pub fn get_all_sync_statuses(state: tauri::State<AppState>) -> Result<Vec<SyncStatus>, String> {
let active = state.sync_active.lock().unwrap();
let mut statuses = Vec::new();
for bot_id in active.keys() {
match get_bot_sync_status(bot_id.clone(), state.clone()) {
Ok(status) => statuses.push(status),
Err(e) => log::warn!("Failed to get status for {}: {}", bot_id, e),
}
}
Ok(statuses)
}
pub fn format_bytes(bytes: u64) -> String {
const KB: u64 = 1024;
const MB: u64 = KB * 1024;
const GB: u64 = MB * 1024;
if bytes >= GB {
format!("{:.2} GB ", bytes as f64 / GB as f64)
} else if bytes >= MB {
format!("{:.2} MB ", bytes as f64 / MB as f64)
} else if bytes >= KB {
format!("{:.2} KB ", bytes as f64 / KB as f64)
} else {
format!("{} B ", bytes)
}
}

1002
src/desktop/tools.rs
View file

File diff suppressed because it is too large Load diff

364
src/desktop/tray.rs
View file

@ -1,364 +0,0 @@
use anyhow::Result;
use std::sync::Arc;
use tokio::sync::RwLock;
#[cfg(target_os = "windows")]
use trayicon::{Icon, MenuBuilder, TrayIcon, TrayIconBuilder};
#[cfg(target_os = "macos")]
use trayicon_osx::{Icon, MenuBuilder, TrayIcon, TrayIconBuilder};
#[cfg(target_os = "linux")]
use ksni::{Icon, Tray, TrayService};
use crate::core::config::ConfigManager;
use crate::core::dns::DynamicDnsService;
pub struct TrayManager {
hostname: Arc<RwLock<Option<String>>>,
dns_service: Option<Arc<DynamicDnsService>>,
config_manager: Arc<ConfigManager>,
running_mode: RunningMode,
}
#[derive(Debug, Clone, PartialEq)]
pub enum RunningMode {
Server,
Desktop,
Client,
}
impl TrayManager {
pub fn new(
config_manager: Arc<ConfigManager>,
dns_service: Option<Arc<DynamicDnsService>>,
) -> Self {
let running_mode = if cfg!(feature = "desktop") {
RunningMode::Desktop
} else {
RunningMode::Server
};
Self {
hostname: Arc::new(RwLock::new(None)),
dns_service,
config_manager,
running_mode,
}
}
pub async fn start(&self) -> Result<()> {
match self.running_mode {
RunningMode::Desktop => {
self.start_desktop_mode().await?;
}
RunningMode::Server => {
log::info!("Running in server mode - tray icon disabled");
}
RunningMode::Client => {
log::info!("Running in client mode - tray icon minimal");
}
}
Ok(())
}
async fn start_desktop_mode(&self) -> Result<()> {
// Check if dynamic DNS is enabled in config
let dns_enabled = self
.config_manager
.get_config("default", "dns-dynamic", Some("false"))
.unwrap_or_else(|_| "false".to_string())
== "true";
if dns_enabled {
log::info!("Dynamic DNS enabled in config, registering hostname...");
self.register_dynamic_dns().await?;
} else {
log::info!("Dynamic DNS disabled in config");
}
#[cfg(any(target_os = "windows", target_os = "macos"))]
{
self.create_tray_icon()?;
}
#[cfg(target_os = "linux")]
{
self.create_linux_tray()?;
}
Ok(())
}
async fn register_dynamic_dns(&self) -> Result<()> {
if let Some(dns_service) = &self.dns_service {
// Generate hostname based on machine name
let hostname = self.generate_hostname()?;
// Get local IP address
let local_ip = self.get_local_ip()?;
// Register with DNS service
dns_service.register_hostname(&hostname, local_ip).await?;
// Store hostname for later use
let mut stored_hostname = self.hostname.write().await;
*stored_hostname = Some(hostname.clone());
log::info!("Registered dynamic DNS: {}.botserver.local", hostname);
}
Ok(())
}
fn generate_hostname(&self) -> Result<String> {
#[cfg(target_os = "windows")]
{
use winapi::shared::minwindef::MAX_COMPUTERNAME_LENGTH;
use winapi::um::sysinfoapi::GetComputerNameW;
let mut buffer = vec![0u16; MAX_COMPUTERNAME_LENGTH as usize + 1];
let mut size = MAX_COMPUTERNAME_LENGTH + 1;
unsafe {
GetComputerNameW(buffer.as_mut_ptr(), &mut size);
}
let hostname = String::from_utf16_lossy(&buffer[..size as usize])
.to_lowercase()
.replace(' ', "-");
Ok(format!("gb-{}", hostname))
}
#[cfg(not(target_os = "windows"))]
{
let hostname = hostname::get()?
.to_string_lossy()
.to_lowercase()
.replace(' ', "-");
Ok(format!("gb-{}", hostname))
}
}
fn get_local_ip(&self) -> Result<std::net::IpAddr> {
use local_ip_address::local_ip;
local_ip().map_err(|e| anyhow::anyhow!("Failed to get local IP: {}", e))
}
#[cfg(any(target_os = "windows", target_os = "macos"))]
fn create_tray_icon(&self) -> Result<()> {
let icon_bytes = include_bytes!("../../assets/icons/tray-icon.png");
let icon = Icon::from_png(icon_bytes)?;
let menu = MenuBuilder::new()
.item("General Bots", |_| {})
.separator()
.item("Status: Running", |_| {})
.item(&format!("Mode: {}", self.get_mode_string()), |_| {})
.separator()
.item("Open Dashboard", move |_| {
let _ = webbrowser::open("https://localhost:8080");
})
.item("Settings", |_| {
// Open settings window
})
.separator()
.item("About", |_| {
// Show about dialog
})
.item("Quit", |_| {
std::process::exit(0);
})
.build()?;
let _tray = TrayIconBuilder::new()
.with_icon(icon)
.with_menu(menu)
.with_tooltip("General Bots")
.build()?;
// Keep tray icon alive
std::thread::park();
Ok(())
}
#[cfg(target_os = "linux")]
fn create_linux_tray(&self) -> Result<()> {
struct GeneralBotsTray {
mode: String,
}
impl Tray for GeneralBotsTray {
fn title(&self) -> String {
"General Bots".to_string()
}
fn icon_name(&self) -> &str {
"general-bots"
}
fn menu(&self) -> Vec<ksni::MenuItem<Self>> {
use ksni::menu::*;
vec![
StandardItem {
label: "General Bots".to_string(),
enabled: false,
..Default::default()
}
.into(),
Separator.into(),
StandardItem {
label: "Status: Running".to_string(),
enabled: false,
..Default::default()
}
.into(),
StandardItem {
label: format!("Mode: {}", self.mode),
enabled: false,
..Default::default()
}
.into(),
Separator.into(),
StandardItem {
label: "Open Dashboard".to_string(),
activate: Box::new(|_| {
let _ = webbrowser::open("https://localhost:8080");
}),
..Default::default()
}
.into(),
StandardItem {
label: "Settings".to_string(),
activate: Box::new(|_| {}),
..Default::default()
}
.into(),
Separator.into(),
StandardItem {
label: "About".to_string(),
activate: Box::new(|_| {}),
..Default::default()
}
.into(),
StandardItem {
label: "Quit".to_string(),
activate: Box::new(|_| {
std::process::exit(0);
}),
..Default::default()
}
.into(),
]
}
}
let tray = GeneralBotsTray {
mode: self.get_mode_string(),
};
let service = TrayService::new(tray);
service.run();
Ok(())
}
fn get_mode_string(&self) -> String {
match self.running_mode {
RunningMode::Desktop => "Desktop".to_string(),
RunningMode::Server => "Server".to_string(),
RunningMode::Client => "Client".to_string(),
}
}
pub async fn update_status(&self, status: &str) -> Result<()> {
log::info!("Tray status update: {}", status);
Ok(())
}
pub async fn get_hostname(&self) -> Option<String> {
let hostname = self.hostname.read().await;
hostname.clone()
}
}
// Service status monitor
pub struct ServiceMonitor {
services: Vec<ServiceStatus>,
}
#[derive(Debug, Clone)]
pub struct ServiceStatus {
pub name: String,
pub running: bool,
pub port: u16,
pub url: String,
}
impl ServiceMonitor {
pub fn new() -> Self {
Self {
services: vec![
ServiceStatus {
name: "API".to_string(),
running: false,
port: 8080,
url: "https://localhost:8080".to_string(),
},
ServiceStatus {
name: "Directory".to_string(),
running: false,
port: 8080,
url: "https://localhost:8080".to_string(),
},
ServiceStatus {
name: "LLM".to_string(),
running: false,
port: 8081,
url: "https://localhost:8081".to_string(),
},
ServiceStatus {
name: "Database".to_string(),
running: false,
port: 5432,
url: "postgresql://localhost:5432".to_string(),
},
ServiceStatus {
name: "Cache".to_string(),
running: false,
port: 6379,
url: "redis://localhost:6379".to_string(),
},
],
}
}
pub async fn check_services(&mut self) -> Vec<ServiceStatus> {
for service in &mut self.services {
service.running = self.check_service(&service.url).await;
}
self.services.clone()
}
async fn check_service(&self, url: &str) -> bool {
if url.starts_with("https://") || url.starts_with("http://") {
match reqwest::Client::builder()
.danger_accept_invalid_certs(true)
.build()
.unwrap()
.get(format!("{}/health", url))
.timeout(std::time::Duration::from_secs(2))
.send()
.await
{
Ok(_) => true,
Err(_) => false,
}
} else {
false
}
}
}

52
src/drive/mod.rs
View file

@ -341,9 +341,55 @@ pub async fn list_files(
}
#[cfg(feature = "console")]
fn convert_tree_to_items(_tree: &FileTree) -> Vec<FileItem> {
// Tree conversion is handled by the FileTree implementation
vec![]
/// Convert a FileTree to a list of FileItems for display in the console UI
#[allow(dead_code)]
pub fn convert_tree_to_items(tree: &FileTree) -> Vec<FileItem> {
let mut items = Vec::new();
for (display_name, node) in tree.get_items() {
match node {
crate::console::file_tree::TreeNode::Bucket { name } => {
if !name.is_empty() {
items.push(FileItem {
name: display_name.clone(),
path: format!("/{}", name),
is_dir: true,
size: None,
modified: None,
icon: if name.ends_with(".gbai") {
"🤖".to_string()
} else {
"📦".to_string()
},
});
}
}
crate::console::file_tree::TreeNode::Folder { bucket, path } => {
let folder_name = path.split('/').last().unwrap_or(&display_name);
items.push(FileItem {
name: folder_name.to_string(),
path: format!("/{}/{}", bucket, path),
is_dir: true,
size: None,
modified: None,
icon: "📁".to_string(),
});
}
crate::console::file_tree::TreeNode::File { bucket, path } => {
let file_name = path.split('/').last().unwrap_or(&display_name);
items.push(FileItem {
name: file_name.to_string(),
path: format!("/{}/{}", bucket, path),
is_dir: false,
size: None,
modified: None,
icon: "📄".to_string(),
});
}
}
}
items
}
/// POST /files/read - Read file content from S3

12
src/lib.rs
View file

@ -3,7 +3,13 @@ pub mod basic;
pub mod core;
pub mod multimodal;
pub mod security;
pub mod web;
// Suite application modules (gap analysis implementations)
pub mod analytics;
pub mod designer;
pub mod paper;
pub mod research;
pub mod sources;
// Re-export shared from core
pub use core::shared;
@ -28,7 +34,6 @@ pub use core::bot;
pub use core::config;
pub use core::package_manager;
pub use core::session;
pub use core::ui_server;
// Re-exports from security
pub use security::{get_secure_port, SecurityConfig, SecurityManager};
@ -46,9 +51,6 @@ pub mod compliance;
#[cfg(feature = "console")]
pub mod console;
#[cfg(feature = "desktop")]
pub mod desktop;
#[cfg(feature = "directory")]
pub mod directory;

7
src/llm/observability.rs
View file

@ -31,14 +31,14 @@
//! observability-alert-threshold,0.8
//! ```
use chrono::{DateTime, Duration, Utc};
use rhai::{Array, Dynamic, Engine, Map};
use chrono::{DateTime, Utc};
use rhai::{Dynamic, Engine, Map};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Arc;
use tokio::sync::RwLock;
use tracing::{debug, error, info, warn};
use tracing::info;
use uuid::Uuid;
/// LLM request metrics
@ -411,6 +411,7 @@ fn default_model_pricing() -> HashMap<String, ModelPricing> {
}
/// Observability Manager
#[derive(Debug)]
pub struct ObservabilityManager {
config: ObservabilityConfig,
/// In-memory metrics buffer

141
src/main.rs
View file

@ -1,22 +1,20 @@
#![cfg_attr(feature = "desktop", windows_subsystem = "windows")]
use axum::extract::Extension;
use axum::{
routing::{get, post},
Router,
};
// Configuration comes from Directory service, not .env files
use dotenvy::dotenv;
use log::{error, info, trace, warn};
use std::collections::HashMap;
use std::net::SocketAddr;
use std::sync::Arc;
use tower_http::cors::CorsLayer;
use tower_http::services::ServeDir;
use tower_http::trace::TraceLayer;
use botserver::basic;
use botserver::core;
use botserver::shared;
use botserver::web;
#[cfg(feature = "console")]
use botserver::console;
@ -28,7 +26,6 @@ use botserver::core::bot;
use botserver::core::config;
use botserver::core::package_manager;
use botserver::core::session;
use botserver::core::ui_server;
// Feature-gated modules
#[cfg(feature = "attendance")]
@ -40,9 +37,6 @@ mod calendar;
#[cfg(feature = "compliance")]
mod compliance;
#[cfg(feature = "desktop")]
mod desktop;
#[cfg(feature = "directory")]
mod directory;
@ -121,11 +115,11 @@ async fn run_axum_server(
.route(ApiUrls::SESSIONS, post(create_session))
.route(ApiUrls::SESSIONS, get(get_sessions))
.route(
ApiUrls::SESSION_HISTORY.replace(":id", "{session_id}"),
&ApiUrls::SESSION_HISTORY.replace(":id", "{session_id}"),
get(get_session_history),
)
.route(
ApiUrls::SESSION_START.replace(":id", "{session_id}"),
&ApiUrls::SESSION_START.replace(":id", "{session_id}"),
post(start_session),
)
// WebSocket route
@ -182,20 +176,15 @@ async fn run_axum_server(
api_router = api_router.merge(crate::calendar::configure_calendar_routes());
}
// Build static file serving
let static_path = std::path::Path::new("./ui/suite");
// Create web router with authentication
let web_router = web::create_router(app_state.clone());
// Add suite application routes (gap analysis implementations)
api_router = api_router.merge(botserver::analytics::configure_analytics_routes());
api_router = api_router.merge(botserver::paper::configure_paper_routes());
api_router = api_router.merge(botserver::research::configure_research_routes());
api_router = api_router.merge(botserver::sources::configure_sources_routes());
api_router = api_router.merge(botserver::designer::configure_designer_routes());
let app = Router::new()
// Static file services for remaining assets
.nest_service("/static/js", ServeDir::new(static_path.join("js")))
.nest_service("/static/css", ServeDir::new(static_path.join("css")))
.nest_service("/static/public", ServeDir::new(static_path.join("public")))
// Web module with authentication (handles all pages and auth)
.merge(web_router)
// Legacy API routes (will be migrated to web module)
// API routes
.merge(api_router.with_state(app_state.clone()))
.layer(Extension(app_state.clone()))
// Layers
@ -219,10 +208,11 @@ async fn run_axum_server(
info!("HTTPS server listening on {} with TLS", addr);
let handle = axum_server::Handle::new();
axum_server::bind_rustls(addr, tls_config)
.handle(handle)
.serve(app.into_make_service())
.await
.map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))
} else {
// Generate self-signed certificate if not present
warn!("TLS certificates not found, generating self-signed certificate...");
@ -269,7 +259,7 @@ async fn main() -> std::io::Result<()> {
ring=off,webpki=off,\
hickory_resolver=off,hickory_proto=off"
.to_string()
});
};
// Set the RUST_LOG env var if not already set
std::env::set_var("RUST_LOG", &rust_log);
@ -393,7 +383,8 @@ async fn main() -> std::io::Result<()> {
let mut bootstrap = BootstrapManager::new(install_mode.clone(), tenant.clone()).await;
// Check if services are already configured in Directory
let services_configured = std::path::Path::new("./botserver-stack/conf/directory/zitadel.yaml").exists();
let services_configured =
std::path::Path::new("./botserver-stack/conf/directory/zitadel.yaml").exists();
let cfg = if services_configured {
trace!("Services already configured, ensuring all are running...");
@ -708,103 +699,13 @@ async fn main() -> std::io::Result<()> {
});
trace!("Initial data setup task spawned");
trace!("Checking desktop mode: {}", desktop_mode);
// Handle desktop mode vs server mode
#[cfg(feature = "desktop")]
if desktop_mode {
trace!("Desktop mode is enabled");
// For desktop mode: Run HTTP server in a separate thread with its own runtime
let app_state_for_server = app_state.clone();
let port = config.server.port;
let workers = worker_count; // Capture worker_count for the thread
// Run HTTP server directly
trace!("Starting HTTP server on port {}...", config.server.port);
run_axum_server(app_state, config.server.port, worker_count).await?;
info!(
"Desktop mode: Starting HTTP server on port {} in background thread",
port
);
std::thread::spawn(move || {
info!("HTTP server thread started, initializing runtime...");
let rt = tokio::runtime::Runtime::new().expect("Failed to create HTTP runtime");
rt.block_on(async move {
info!(
"HTTP server runtime created, starting axum server on port {}...",
port
);
if let Err(e) = run_axum_server(app_state_for_server, port, workers).await {
error!("HTTP server error: {}", e);
eprintln!("HTTP server error: {}", e);
} else {
info!("HTTP server started successfully");
}
});
});
// Give the server thread a moment to start
std::thread::sleep(std::time::Duration::from_millis(500));
info!("Launching General Bots desktop application...");
// Run Tauri on main thread (GUI requires main thread)
let tauri_app = tauri::Builder::default()
.setup(|app| {
use tauri::WebviewWindowBuilder;
match WebviewWindowBuilder::new(
app,
"main",
tauri::WebviewUrl::App("index.html".into()),
)
.title("General Bots")
.build()
{
Ok(_window) => Ok(()),
Err(e) if e.to_string().contains("WebviewLabelAlreadyExists") => {
log::warn!("Main window already exists, reusing existing window");
Ok(())
}
Err(e) => Err(e.into()),
}
})
.build(tauri::generate_context!())
.expect("error while running Desktop application");
tauri_app.run(|_app_handle, event| match event {
tauri::RunEvent::ExitRequested { api, .. } => {
api.prevent_exit();
}
_ => {}
});
return Ok(());
}
// Non-desktop mode: Run HTTP server directly
#[cfg(not(feature = "desktop"))]
{
trace!(
"Running in non-desktop mode, starting HTTP server on port {}...",
config.server.port
);
run_axum_server(app_state, config.server.port, worker_count).await?;
// Wait for UI thread to finish if it was started
if let Some(handle) = ui_handle {
handle.join().ok();
}
}
// For builds with desktop feature but not running in desktop mode
#[cfg(feature = "desktop")]
if !desktop_mode {
trace!(
"Desktop feature available but not in desktop mode, starting HTTP server on port {}...",
config.server.port
);
run_axum_server(app_state, config.server.port, worker_count).await?;
// Wait for UI thread to finish if it was started
if let Some(handle) = ui_handle {
handle.join().ok();
}
// Wait for UI thread to finish if it was started
if let Some(handle) = ui_handle {
handle.join().ok();
}
Ok(())

1
src/multimodal/mod.rs
View file

@ -227,6 +227,7 @@ pub struct SpeechToTextResponse {
}
/// BotModels client for multimodal operations
#[derive(Debug)]
pub struct BotModelsClient {
client: Client,
config: BotModelsConfig,

1648
src/paper/mod.rs Normal file
View file

File diff suppressed because it is too large Load diff

506
src/research/mod.rs Normal file
View file

@ -0,0 +1,506 @@
use crate::shared::state::AppState;
use axum::{
extract::{Path, State},
response::{Html, IntoResponse},
routing::{get, post},
Json, Router,
};
use diesel::prelude::*;
use serde::{Deserialize, Serialize};
use std::sync::Arc;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SearchQuery {
pub q: Option<String>,
pub collection: Option<String>,
pub filters: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SearchRequest {
pub query: Option<String>,
pub collection: Option<String>,
pub filters: Option<Vec<String>>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NewCollectionRequest {
pub name: String,
pub description: Option<String>,
}
#[derive(Debug, QueryableByName)]
#[diesel(check_for_backend(diesel::pg::Pg))]
pub struct KbDocumentRow {
#[diesel(sql_type = diesel::sql_types::Text)]
pub id: String,
#[diesel(sql_type = diesel::sql_types::Text)]
pub title: String,
#[diesel(sql_type = diesel::sql_types::Text)]
pub content: String,
#[diesel(sql_type = diesel::sql_types::Text)]
pub collection_id: String,
#[diesel(sql_type = diesel::sql_types::Text)]
pub source_path: String,
}
#[derive(Debug, QueryableByName)]
#[diesel(check_for_backend(diesel::pg::Pg))]
pub struct CollectionRow {
#[diesel(sql_type = diesel::sql_types::Text)]
pub id: String,
#[diesel(sql_type = diesel::sql_types::Text)]
pub name: String,
#[diesel(sql_type = diesel::sql_types::Text)]
pub description: String,
}
pub fn configure_research_routes() -> Router<Arc<AppState>> {
Router::new()
// Collections - match frontend hx-* endpoints
.route("/api/research/collections", get(handle_list_collections))
.route(
"/api/research/collections/new",
post(handle_create_collection),
)
.route("/api/research/collections/{id}", get(handle_get_collection))
// Search
.route("/api/research/search", post(handle_search))
.route("/api/research/recent", get(handle_recent_searches))
.route("/api/research/trending", get(handle_trending_tags))
.route("/api/research/prompts", get(handle_prompts))
// Export
.route(
"/api/research/export-citations",
get(handle_export_citations),
)
}
/// GET /api/research/collections - List all collections
pub async fn handle_list_collections(State(state): State<Arc<AppState>>) -> impl IntoResponse {
let conn = state.conn.clone();
let collections = tokio::task::spawn_blocking(move || {
let mut db_conn = match conn.get() {
Ok(c) => c,
Err(e) => {
log::error!("DB connection error: {}", e);
return get_default_collections();
}
};
let result: Result<Vec<CollectionRow>, _> =
diesel::sql_query("SELECT id, name, description FROM kb_collections ORDER BY name ASC")
.load(&mut db_conn);
match result {
Ok(colls) if !colls.is_empty() => colls
.into_iter()
.map(|c| (c.id, c.name, c.description))
.collect(),
_ => get_default_collections(),
}
})
.await
.unwrap_or_else(|_| get_default_collections());
let mut html = String::new();
for (id, name, description) in &collections {
html.push_str("<div class=\"collection-item\" data-id=\"");
html.push_str(&html_escape(id));
html.push_str("\">");
html.push_str("<div class=\"collection-icon\">📁</div>");
html.push_str("<div class=\"collection-info\">");
html.push_str("<span class=\"collection-name\">");
html.push_str(&html_escape(name));
html.push_str("</span>");
html.push_str("<span class=\"collection-desc\">");
html.push_str(&html_escape(description));
html.push_str("</span>");
html.push_str("</div>");
html.push_str("<button class=\"btn-icon-sm\" hx-get=\"/api/research/collections/");
html.push_str(&html_escape(id));
html.push_str("\" hx-target=\"#main-results\">");
html.push_str("<svg width=\"16\" height=\"16\" viewBox=\"0 0 24 24\" fill=\"none\" stroke=\"currentColor\" stroke-width=\"2\"><polyline points=\"9 18 15 12 9 6\"></polyline></svg>");
html.push_str("</button>");
html.push_str("</div>");
}
if collections.is_empty() {
html.push_str("<div class=\"empty-state\">");
html.push_str("<p>No collections yet</p>");
html.push_str("</div>");
}
Html(html)
}
fn get_default_collections() -> Vec<(String, String, String)> {
vec![
(
"general".to_string(),
"General Knowledge".to_string(),
"Default knowledge base".to_string(),
),
(
"docs".to_string(),
"Documentation".to_string(),
"Product documentation".to_string(),
),
(
"faq".to_string(),
"FAQ".to_string(),
"Frequently asked questions".to_string(),
),
]
}
/// POST /api/research/collections/new - Create a new collection
pub async fn handle_create_collection(
State(state): State<Arc<AppState>>,
Json(payload): Json<NewCollectionRequest>,
) -> impl IntoResponse {
let conn = state.conn.clone();
let id = uuid::Uuid::new_v4().to_string();
let name = payload.name.clone();
let description = payload.description.unwrap_or_default();
let id_clone = id.clone();
let name_clone = name.clone();
let desc_clone = description.clone();
let _ = tokio::task::spawn_blocking(move || {
let mut db_conn = match conn.get() {
Ok(c) => c,
Err(e) => {
log::error!("DB connection error: {}", e);
return;
}
};
let _ = diesel::sql_query(
"INSERT INTO kb_collections (id, name, description) VALUES ($1, $2, $3)",
)
.bind::<diesel::sql_types::Text, _>(&id)
.bind::<diesel::sql_types::Text, _>(&name)
.bind::<diesel::sql_types::Text, _>(&description)
.execute(&mut db_conn);
})
.await;
let mut html = String::new();
html.push_str("<div class=\"collection-item new-item\" data-id=\"");
html.push_str(&html_escape(&id_clone));
html.push_str("\">");
html.push_str("<div class=\"collection-icon\">📁</div>");
html.push_str("<div class=\"collection-info\">");
html.push_str("<span class=\"collection-name\">");
html.push_str(&html_escape(&name_clone));
html.push_str("</span>");
html.push_str("<span class=\"collection-desc\">");
html.push_str(&html_escape(&desc_clone));
html.push_str("</span>");
html.push_str("</div>");
html.push_str("</div>");
Html(html)
}
/// GET /api/research/collections/{id} - Get collection contents
pub async fn handle_get_collection(
State(state): State<Arc<AppState>>,
Path(id): Path<String>,
) -> impl IntoResponse {
let conn = state.conn.clone();
let documents = tokio::task::spawn_blocking(move || {
let mut db_conn = match conn.get() {
Ok(c) => c,
Err(e) => {
log::error!("DB connection error: {}", e);
return Vec::new();
}
};
diesel::sql_query(
"SELECT id, title, content, collection_id, source_path FROM kb_documents WHERE collection_id = $1 ORDER BY title ASC LIMIT 50",
)
.bind::<diesel::sql_types::Text, _>(&id)
.load::<KbDocumentRow>(&mut db_conn)
.unwrap_or_default()
})
.await
.unwrap_or_default();
let mut html = String::new();
html.push_str("<div class=\"collection-results\">");
html.push_str("<div class=\"results-header\">");
html.push_str("<h3>Collection Contents</h3>");
html.push_str("<span class=\"result-count\">");
html.push_str(&documents.len().to_string());
html.push_str(" documents</span>");
html.push_str("</div>");
html.push_str("<div class=\"results-list\">");
if documents.is_empty() {
html.push_str("<div class=\"empty-state\">");
html.push_str("<p>No documents in this collection</p>");
html.push_str("<p class=\"hint\">Add documents to build your knowledge base</p>");
html.push_str("</div>");
} else {
for doc in &documents {
html.push_str(&format_search_result(
&doc.id,
&doc.title,
&doc.content,
&doc.source_path,
));
}
}
html.push_str("</div>");
html.push_str("</div>");
Html(html)
}
/// POST /api/research/search - Semantic search
pub async fn handle_search(
State(state): State<Arc<AppState>>,
Json(payload): Json<SearchRequest>,
) -> impl IntoResponse {
let query = payload.query.unwrap_or_default();
if query.trim().is_empty() {
return Html("<div class=\"search-prompt\"><p>Enter a search query to find relevant documents</p></div>".to_string());
}
let conn = state.conn.clone();
let collection = payload.collection;
let results = tokio::task::spawn_blocking(move || {
let mut db_conn = match conn.get() {
Ok(c) => c,
Err(e) => {
log::error!("DB connection error: {}", e);
return Vec::new();
}
};
let search_pattern = format!("%{}%", query.to_lowercase());
let docs = if let Some(coll) = collection {
diesel::sql_query(
"SELECT id, title, content, collection_id, source_path FROM kb_documents WHERE (LOWER(title) LIKE $1 OR LOWER(content) LIKE $1) AND collection_id = $2 ORDER BY title ASC LIMIT 20",
)
.bind::<diesel::sql_types::Text, _>(&search_pattern)
.bind::<diesel::sql_types::Text, _>(&coll)
.load::<KbDocumentRow>(&mut db_conn)
.unwrap_or_default()
} else {
diesel::sql_query(
"SELECT id, title, content, collection_id, source_path FROM kb_documents WHERE LOWER(title) LIKE $1 OR LOWER(content) LIKE $1 ORDER BY title ASC LIMIT 20",
)
.bind::<diesel::sql_types::Text, _>(&search_pattern)
.load::<KbDocumentRow>(&mut db_conn)
.unwrap_or_default()
};
docs
})
.await
.unwrap_or_default();
let mut html = String::new();
html.push_str("<div class=\"search-results\">");
html.push_str("<div class=\"results-header\">");
html.push_str("<h3>Search Results</h3>");
html.push_str("<span class=\"result-count\">");
html.push_str(&results.len().to_string());
html.push_str(" results found</span>");
html.push_str("</div>");
html.push_str("<div class=\"results-list\">");
if results.is_empty() {
html.push_str("<div class=\"no-results\">");
html.push_str("<div class=\"no-results-icon\">🔍</div>");
html.push_str("<h4>No results found</h4>");
html.push_str("<p>Try different keywords or check your spelling</p>");
html.push_str("</div>");
} else {
for doc in &results {
html.push_str(&format_search_result(
&doc.id,
&doc.title,
&doc.content,
&doc.source_path,
));
}
}
html.push_str("</div>");
html.push_str("</div>");
Html(html)
}
fn format_search_result(id: &str, title: &str, content: &str, source: &str) -> String {
let snippet = if content.len() > 200 {
format!("{}...", &content[..200])
} else {
content.to_string()
};
let mut html = String::new();
html.push_str("<div class=\"result-item\" data-id=\"");
html.push_str(&html_escape(id));
html.push_str("\">");
html.push_str("<div class=\"result-header\">");
html.push_str("<h4 class=\"result-title\">");
html.push_str(&html_escape(title));
html.push_str("</h4>");
html.push_str("<span class=\"result-source\">");
html.push_str(&html_escape(source));
html.push_str("</span>");
html.push_str("</div>");
html.push_str("<p class=\"result-snippet\">");
html.push_str(&html_escape(&snippet));
html.push_str("</p>");
html.push_str("<div class=\"result-actions\">");
html.push_str("<button class=\"btn-sm btn-view\">View</button>");
html.push_str("<button class=\"btn-sm btn-cite\">Cite</button>");
html.push_str("<button class=\"btn-sm btn-save\">Save</button>");
html.push_str("</div>");
html.push_str("</div>");
html
}
/// GET /api/research/recent - Recent searches
pub async fn handle_recent_searches(State(_state): State<Arc<AppState>>) -> impl IntoResponse {
let recent_searches = vec![
"How to get started",
"API documentation",
"Configuration guide",
"Best practices",
"Troubleshooting",
];
let mut html = String::new();
for search in &recent_searches {
html.push_str(
"<div class=\"recent-item\" hx-post=\"/api/research/search\" hx-vals='{\"query\":\"",
);
html.push_str(&html_escape(search));
html.push_str("\"}' hx-target=\"#main-results\">");
html.push_str("<span class=\"recent-icon\">🕐</span>");
html.push_str("<span class=\"recent-text\">");
html.push_str(&html_escape(search));
html.push_str("</span>");
html.push_str("</div>");
}
if recent_searches.is_empty() {
html.push_str("<div class=\"empty-state small\">");
html.push_str("<p>No recent searches</p>");
html.push_str("</div>");
}
Html(html)
}
/// GET /api/research/trending - Trending tags
pub async fn handle_trending_tags(State(_state): State<Arc<AppState>>) -> impl IntoResponse {
let tags = vec![
("getting-started", 42),
("api", 38),
("integration", 25),
("configuration", 22),
("deployment", 18),
("security", 15),
("performance", 12),
("troubleshooting", 10),
];
let mut html = String::new();
html.push_str("<div class=\"trending-tags-list\">");
for (tag, count) in &tags {
html.push_str(
"<span class=\"tag\" hx-post=\"/api/research/search\" hx-vals='{\"query\":\"",
);
html.push_str(&html_escape(tag));
html.push_str("\"}' hx-target=\"#main-results\">");
html.push_str(&html_escape(tag));
html.push_str(" <small>(");
html.push_str(&count.to_string());
html.push_str(")</small>");
html.push_str("</span>");
}
html.push_str("</div>");
Html(html)
}
/// GET /api/research/prompts - Get research prompts/suggestions
pub async fn handle_prompts(State(_state): State<Arc<AppState>>) -> impl IntoResponse {
let prompts = vec![
(
"📚",
"Getting Started",
"Learn the basics and set up your first bot",
),
("🔧", "Configuration", "Customize settings and preferences"),
(
"🔌",
"Integrations",
"Connect with external services and APIs",
),
("🚀", "Deployment", "Deploy your bot to production"),
("🔒", "Security", "Best practices for securing your bot"),
("📊", "Analytics", "Monitor and analyze bot performance"),
];
let mut html = String::new();
html.push_str("<div class=\"prompts-grid\">");
for (icon, title, description) in &prompts {
html.push_str(
"<div class=\"prompt-card\" hx-post=\"/api/research/search\" hx-vals='{\"query\":\"",
);
html.push_str(&html_escape(title));
html.push_str("\"}' hx-target=\"#main-results\">");
html.push_str("<div class=\"prompt-icon\">");
html.push_str(icon);
html.push_str("</div>");
html.push_str("<div class=\"prompt-content\">");
html.push_str("<h4>");
html.push_str(&html_escape(title));
html.push_str("</h4>");
html.push_str("<p>");
html.push_str(&html_escape(description));
html.push_str("</p>");
html.push_str("</div>");
html.push_str("</div>");
}
html.push_str("</div>");
Html(html)
}
/// GET /api/research/export-citations - Export citations
pub async fn handle_export_citations(State(_state): State<Arc<AppState>>) -> impl IntoResponse {
Html("<script>alert('Citations exported. Download will begin shortly.');</script>".to_string())
}
fn html_escape(s: &str) -> String {
s.replace('&', "&amp;")
.replace('<', "&lt;")
.replace('>', "&gt;")
.replace('"', "&quot;")
.replace('\'', "&#39;")
}

3
src/security/antivirus.rs
View file

@ -14,7 +14,7 @@ use std::path::{Path, PathBuf};
use std::process::Command;
use std::sync::Arc;
use tokio::sync::RwLock;
use tracing::{error, info, warn};
use tracing::{info, warn};
/// Threat severity levels
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
@ -156,6 +156,7 @@ impl Default for AntivirusConfig {
}
/// Antivirus Manager
#[derive(Debug)]
pub struct AntivirusManager {
config: AntivirusConfig,
threats: Arc<RwLock<Vec<Threat>>>,

Some files were not shown because too many files have changed in this diff Show more