openscript_sdk 0.1.0

Standard library and AI integration for OpenScript
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

//! HTTP plugin for OpenScript
use std::collections::HashMap;
use async_trait::async_trait;
use crate::plugin::{Plugin, PluginCommand, PluginMetadata};
use crate::http;

type PluginResult<T> = std::result::Result<T, Box<dyn std::error::Error + Send + Sync>>;

pub struct HttpPlugin {
    metadata: PluginMetadata,
}

impl HttpPlugin {
    pub fn new() -> Self {
        Self {
            metadata: PluginMetadata {
                name: "http".to_string(),
                version: "1.0.0".to_string(),
                description: "HTTP plugin for OpenScript".to_string(),
                author: "OpenScript Team".to_string(),
                license: "MIT".to_string(),
                dependencies: vec!["reqwest".to_string()],
                api_version: "1.0".to_string(),
            },
        }
    }
}

#[async_trait]
impl Plugin for HttpPlugin {
    fn metadata(&self) -> &PluginMetadata {
        &self.metadata
    }
    
    async fn initialize(&mut self) -> PluginResult<()> {
        Ok(())
    }
    
    fn register_commands(&self) -> HashMap<String, Box<dyn PluginCommand>> {
        let mut commands = HashMap::new();
        commands.insert("http_get".to_string(), Box::new(HttpGetCommand) as Box<dyn PluginCommand>);
        commands.insert("http_post".to_string(), Box::new(HttpPostCommand) as Box<dyn PluginCommand>);
        commands
    }
    
    async fn cleanup(&mut self) -> PluginResult<()> {
        Ok(())
    }
}

struct HttpGetCommand;

#[async_trait]
impl PluginCommand for HttpGetCommand {
    async fn execute(&self, args: &[String]) -> PluginResult<String> {
        if args.is_empty() {
            return Err("http_get() requires a URL".into());
        }
        let url = &args[0];
        // TODO: Parse headers from args
        let headers = HashMap::new();
        let result = http::http_get(url, headers).await.map_err(|e| Box::new(e) as Box<dyn std::error::Error + Send + Sync>)?;
        Ok(result.to_string())
    }
    
    fn help(&self) -> &str {
        "Sends an HTTP GET request."
    }
    
    fn usage(&self) -> &str {
        "http_get <url> [headers]"
    }
}

struct HttpPostCommand;

#[async_trait]
impl PluginCommand for HttpPostCommand {
    async fn execute(&self, args: &[String]) -> PluginResult<String> {
        if args.len() < 2 {
            return Err("http_post() requires a URL and a body".into());
        }
        let url = &args[0];
        let body = &args[1];
        // TODO: Parse headers from args
        let headers = HashMap::new();
        let result = http::http_post(url, body, headers).await.map_err(|e| Box::new(e) as Box<dyn std::error::Error + Send + Sync>)?;
        Ok(result.to_string())
    }
    
    fn help(&self) -> &str {
        "Sends an HTTP POST request."
    }
    
    fn usage(&self) -> &str {
        "http_post <url> <body> [headers]"
    }
}