admin/openhuman
1
0
Fork 0
mirror of https://github.com/tinyhumansai/openhuman.git synced 2026-07-30 23:14:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix/prod build (#51)

Browse Source 
* chore: add CI secrets management and local testing script

- Added ci-secrets.example.json to provide a template for CI secrets configuration.
- Introduced test-ci-local.sh script to facilitate local testing of the package-and-publish workflow using act.
- Updated .gitignore to exclude the actual ci-secrets.json file containing sensitive tokens.

* chore: enhance local testing and environment loading scripts

- Added scripts to load environment variables from .env and JSON files, improving local development setup.
- Introduced ci-event.json to simulate GitHub event payloads for local CI testing.
- Updated test-ci-local.sh to utilize the new event JSON for better integration with local testing workflows.
- Modified .gitignore to include ci-secrets.local.json for local secret management.

* chore: enhance environment loading and improve V8 memory management

- Updated load-env.sh to conditionally load ci-secrets.local.json and set APPLE_PASSWORD for notarization.
- Introduced a delay in auto-starting skills to prevent memory spikes during initialization.
- Adjusted V8 runtime memory settings to minimize initial heap allocation, reducing the risk of OOM errors.

* chore: update version bump workflow to modify tauri.conf.json

- Changed the version update process to reflect changes in tauri.conf.json instead of Cargo.toml.
- Adjusted the commit message to indicate the inclusion of tauri.conf.json in the version bump process.

* chore: migrate from V8 to QuickJS runtime and update related configurations

- Replaced V8 runtime references with QuickJS throughout the codebase, including updates to initialization and error handling.
- Modified package.json to change the build command for macOS to source environment variables correctly.
- Updated Cargo.toml to remove deno_core dependency and include rquickjs with appropriate features.
- Cleaned up unused V8-related code and comments in the runtime modules.
- Adjusted skill manifest checks to support QuickJS compatibility.

* refactor: implement QuickJS runtime and remove V8 references

- Replaced V8 engine with QuickJS in the runtime module, updating related imports and initialization logic.
- Introduced new `qjs_engine.rs` and `qjs_skill_instance.rs` files to handle QuickJS-specific functionality.
- Removed the deprecated `v8_skill_instance.rs` and associated V8-related code.
- Updated JavaScript bootstrap code to align with QuickJS operations and APIs.
- Adjusted documentation and comments to reflect the transition to QuickJS.

* refactor: update IdbStorage to use parking_lot::Mutex for improved concurrency

- Changed the connection management in IdbStorage from RwLock to parking_lot::Mutex for better performance.
- Updated related methods to reflect the new locking mechanism, enhancing the efficiency of database operations.
- Adjusted the IdbOpenResult struct to include serde::Serialize for potential serialization needs.

* refactor: update QuickJS skill instance and timer management

- Modified memory limit and stack size settings in QjsSkillInstance to be asynchronous, improving performance.
- Cleaned up imports in qjs_ops.rs by removing unused dependencies and enhancing function definitions for clarity.
- Refactored timer management functions for better readability and efficiency, including renaming and restructuring comments.

* chore: update package.json scripts and clean up build.rs

- Added a new script for running the Tauri app with environment variable loading.
- Simplified the macOS development command to use a dedicated build script.
- Removed unnecessary environment variable logging from build.rs to streamline the build process.
- Cleaned up commented-out sections in the GitHub Actions workflow for Android packaging.
This commit is contained in:
Steven Enamakel
2026-02-05 19:29:21 +05:30
committed by GitHub
parent 29d62544d6
commit ceb03fb2bc
32 changed files with 2010 additions and 2985 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src-tauri/src/commands/runtime.rs
+1 -1
View File
@@ -14,7 +14,7 @@ use tauri::State;
// Desktop-only imports
#[cfg(not(any(target_os = "android", target_os = "ios")))]
use crate::runtime::v8_engine::RuntimeEngine;
use crate::runtime::qjs_engine::RuntimeEngine;
#[cfg(not(any(target_os = "android", target_os = "ios")))]
use crate::runtime::types::{SkillSnapshot, ToolResult};
src-tauri/src/lib.rs
+17 -25
View File
@@ -84,7 +84,7 @@ macro_rules! common_handlers {
ai_read_memory_file,
ai_write_memory_file,
ai_list_memory_files,
// V8 runtime commands
// Runtime commands
runtime_discover_skills,
runtime_list_skills,
runtime_start_skill,
@@ -93,14 +93,14 @@ macro_rules! common_handlers {
runtime_call_tool,
runtime_all_tools,
runtime_broadcast_event,
// V8 runtime enable/disable + KV commands
// Runtime enable/disable + KV commands
runtime_enable_skill,
runtime_disable_skill,
runtime_is_skill_enabled,
runtime_get_skill_preferences,
runtime_skill_kv_get,
runtime_skill_kv_set,
// V8 runtime JSON-RPC + data commands
// Runtime JSON-RPC + data commands
runtime_rpc,
runtime_skill_data_read,
runtime_skill_data_write,
@@ -207,15 +207,6 @@ fn setup_tray(app: &AppHandle) -> Result<(), Box<dyn std::error::Error>> {
#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
// Load .env file (silently ignore if missing — production won't have one)
// Try current directory first, then parent (for when running from src-tauri)
if dotenvy::dotenv().is_err() {
if let Ok(cwd) = std::env::current_dir() {
if let Some(parent) = cwd.parent() {
let _ = dotenvy::from_path(parent.join(".env"));
}
}
}
// Initialize platform-appropriate logger
#[cfg(target_os = "android")]
@@ -289,7 +280,7 @@ pub fn run() {
);
socket_mgr.set_app_handle(app.handle().clone());
// Initialize V8 Runtime Engine (desktop only - V8 not available on Android/iOS)
// Initialize QuickJS Runtime Engine (desktop only - not available on Android/iOS)
#[cfg(not(any(target_os = "android", target_os = "ios")))]
{
let data_dir = app
@@ -308,7 +299,7 @@ pub fn run() {
services::llama::LLAMA_MANAGER.set_data_dir(model_dir);
log::info!("[runtime] Local model service initialized");
match runtime::v8_engine::RuntimeEngine::new(skills_data_dir) {
match runtime::qjs_engine::RuntimeEngine::new(skills_data_dir) {
Ok(engine) => {
engine.set_app_handle(app.handle().clone());
@@ -330,28 +321,29 @@ pub fn run() {
cron.start();
});
// Auto-start skills in background
// Auto-start skills in background (no delay needed for QuickJS -
// lightweight contexts don't have V8's memory reservation issue)
let engine_clone = engine.clone();
tauri::async_runtime::spawn(async move {
engine_clone.auto_start_skills().await;
});
log::info!("[runtime] V8 runtime engine initialized");
log::info!("[runtime] QuickJS runtime engine initialized");
}
Err(e) => {
log::error!("[runtime] Failed to initialize V8 runtime: {e}");
log::error!("[runtime] Failed to initialize QuickJS runtime: {e}");
}
}
}
#[cfg(target_os = "android")]
{
log::info!("[runtime] V8 runtime and local model disabled on Android");
log::info!("[runtime] QuickJS runtime and local model disabled on Android");
}
#[cfg(target_os = "ios")]
{
log::info!("[runtime] V8 runtime and local model disabled on iOS");
log::info!("[runtime] QuickJS runtime and local model disabled on iOS");
}
// Store SocketManager as Tauri state
@@ -433,7 +425,7 @@ pub fn run() {
ai_read_memory_file,
ai_write_memory_file,
ai_list_memory_files,
// V8 runtime commands
// Runtime commands
runtime_discover_skills,
runtime_list_skills,
runtime_start_skill,
@@ -442,14 +434,14 @@ pub fn run() {
runtime_call_tool,
runtime_all_tools,
runtime_broadcast_event,
// V8 runtime enable/disable + KV commands
// Runtime enable/disable + KV commands
runtime_enable_skill,
runtime_disable_skill,
runtime_is_skill_enabled,
runtime_get_skill_preferences,
runtime_skill_kv_get,
runtime_skill_kv_set,
// V8 runtime JSON-RPC + data commands
// Runtime JSON-RPC + data commands
runtime_rpc,
runtime_skill_data_read,
runtime_skill_data_write,
@@ -525,7 +517,7 @@ pub fn run() {
ai_read_memory_file,
ai_write_memory_file,
ai_list_memory_files,
// V8 runtime commands
// Runtime commands
runtime_discover_skills,
runtime_list_skills,
runtime_start_skill,
@@ -534,14 +526,14 @@ pub fn run() {
runtime_call_tool,
runtime_all_tools,
runtime_broadcast_event,
// V8 runtime enable/disable + KV commands
// Runtime enable/disable + KV commands
runtime_enable_skill,
runtime_disable_skill,
runtime_is_skill_enabled,
runtime_get_skill_preferences,
runtime_skill_kv_get,
runtime_skill_kv_set,
// V8 runtime JSON-RPC + data commands
// Runtime JSON-RPC + data commands
runtime_rpc,
runtime_skill_data_read,
runtime_skill_data_write,
src-tauri/src/runtime/loader.rs
+3 -4
View File
@@ -1,10 +1,9 @@
//! Custom V8 module resolver and loader for `@alphahuman/*` imports.
//! Custom module resolver and loader for `@alphahuman/*` imports.
//!
//! NOTE: Currently unused. Skills access bridge APIs via globals (db, store, console)
//! injected by v8_skill_instance.rs. This module is reserved for future ES module
//! injected by qjs_skill_instance.rs. This module is reserved for future ES module
//! import support (e.g., `import { db } from '@alphahuman/db'`).
//!
//! The globals-based approach was chosen because:
//! - V8/deno_core shares the module loader across all contexts in the same runtime
//! - Per-skill module loaders would require separate runtime instances
//! - Globals are simpler and sufficient for the initial implementation
//! - Per-skill module loaders can be added later if needed
src-tauri/src/runtime/manifest.rs
+3 -3
View File
@@ -86,10 +86,10 @@ impl SkillManifest {
Self::from_json(&content)
}
/// Whether this manifest declares a JavaScript runtime (V8).
/// Accepts "v8", "javascript" for compatibility.
/// Whether this manifest declares a JavaScript runtime (QuickJS).
/// Accepts "v8", "javascript", "quickjs" for compatibility.
pub fn is_javascript(&self) -> bool {
self.runtime == "v8" || self.runtime == "javascript"
matches!(self.runtime.as_str(), "v8" | "javascript" | "quickjs")
}
/// Whether the skill is available on the current platform.
src-tauri/src/runtime/mod.rs
+6 -6
View File
@@ -1,9 +1,9 @@
//! V8 skill runtime module.
//! QuickJS skill runtime module.
//!
//! Provides a persistent JavaScript execution environment for skills
//! using the V8 engine via `deno_core`.
//! using the QuickJS engine via `rquickjs`.
//!
//! Note: V8/deno_core is only available on desktop platforms.
//! Note: The skill runtime is only available on desktop platforms.
//! On mobile (Android/iOS), the skill runtime is disabled.
// Platform-agnostic modules
@@ -13,7 +13,7 @@ pub mod preferences;
pub mod socket_manager;
pub mod types;
// V8/deno_core modules - desktop only (no prebuilt binaries for Android/iOS)
// QuickJS modules - desktop only (not available on Android/iOS)
#[cfg(not(any(target_os = "android", target_os = "ios")))]
pub mod bridge;
#[cfg(not(any(target_os = "android", target_os = "ios")))]
@@ -21,6 +21,6 @@ pub mod cron_scheduler;
#[cfg(not(any(target_os = "android", target_os = "ios")))]
pub mod skill_registry;
#[cfg(not(any(target_os = "android", target_os = "ios")))]
pub mod v8_engine;
pub mod qjs_engine;
#[cfg(not(any(target_os = "android", target_os = "ios")))]
pub mod v8_skill_instance;
pub mod qjs_skill_instance;
src-tauri/src/runtime/v8_engine.rs → src-tauri/src/runtime/qjs_engine.rs
+14 -24
View File
@@ -1,7 +1,7 @@
//! RuntimeEngine — top-level orchestrator for the V8 skill runtime.
//! RuntimeEngine — top-level orchestrator for the QuickJS skill runtime.
//!
//! Manages skill lifecycle and provides the public API consumed by Tauri commands.
//! Uses V8 (via deno_core) for JavaScript execution.
//! Uses QuickJS (via rquickjs) for JavaScript execution.
use std::path::PathBuf;
use std::sync::Arc;
@@ -14,10 +14,10 @@ use crate::runtime::manifest::SkillManifest;
use crate::runtime::preferences::PreferencesStore;
use crate::runtime::skill_registry::SkillRegistry;
use crate::runtime::types::{events, SkillSnapshot, SkillStatus, ToolResult};
use crate::runtime::v8_skill_instance::{BridgeDeps, V8SkillInstance};
use crate::runtime::qjs_skill_instance::{BridgeDeps, QjsSkillInstance};
use crate::services::tdlib_v8::storage::IdbStorage;
/// The central runtime engine using V8.
/// The central runtime engine using QuickJS.
pub struct RuntimeEngine {
/// Registry of all skills.
registry: Arc<SkillRegistry>,
@@ -43,7 +43,7 @@ impl RuntimeEngine {
cron_scheduler.set_registry(Arc::clone(&registry));
let preferences = Arc::new(PreferencesStore::new(&skills_data_dir));
log::info!("[runtime] V8 RuntimeEngine created");
log::info!("[runtime] QuickJS RuntimeEngine created");
Ok(Self {
registry,
@@ -111,9 +111,7 @@ impl RuntimeEngine {
}
// 4. Production: bundled resources
// Tauri converts "../" to "_up_/" when bundling resources with array notation
if let Some(resource_dir) = self.resource_dir.read().as_ref() {
// Try: $RESOURCE/_up_/skills/skills/ (array notation with ../)
let bundled_skills = resource_dir.join("_up_").join("skills").join("skills");
if bundled_skills.exists() {
log::info!(
@@ -123,7 +121,6 @@ impl RuntimeEngine {
return Ok(bundled_skills);
}
// Try: $RESOURCE/skills/ (map notation)
let bundled_skills_alt = resource_dir.join("skills");
if bundled_skills_alt.exists() {
log::info!(
@@ -140,7 +137,7 @@ impl RuntimeEngine {
);
}
// 5. Final fallback: app data dir (for user-installed skills)
// 5. Final fallback: app data dir
let prod_dir = self.skills_data_dir.clone();
log::info!(
"[runtime] Skills source dir (data dir fallback): {:?}",
@@ -184,7 +181,6 @@ impl RuntimeEngine {
);
}
Ok(_) => {
// Not a JavaScript skill, skip
log::info!(
"[runtime] Skipping skill '{}': not a JavaScript skill",
manifest_path.display()
@@ -227,7 +223,7 @@ impl RuntimeEngine {
let manifest = SkillManifest::from_path(&manifest_path).await?;
if !manifest.is_javascript() {
return Err(format!(
"Skill '{}' uses runtime '{}', not 'v8' or 'javascript'",
"Skill '{}' uses runtime '{}', not a supported JavaScript runtime",
skill_id, manifest.runtime
));
}
@@ -235,15 +231,15 @@ impl RuntimeEngine {
let config = manifest.to_config();
let data_dir = self.skills_data_dir.join(skill_id);
// Create the V8 skill instance
log::info!("[runtime] Creating V8 skill instance for '{}'", skill_id);
// Create the QuickJS skill instance
log::info!("[runtime] Creating QuickJS skill instance for '{}'", skill_id);
log::info!("[runtime] Config: {:?}", config);
log::info!("[runtime] Skill dir: {:?}", skill_dir);
log::info!("[runtime] Data dir: {:?}", data_dir);
let (instance, rx) = V8SkillInstance::new(config.clone(), skill_dir, data_dir.clone());
log::info!("[runtime] V8 skill instance created for '{}'", skill_id);
let (instance, rx) = QjsSkillInstance::new(config.clone(), skill_dir, data_dir.clone());
log::info!("[runtime] QuickJS skill instance created for '{}'", skill_id);
// Bundle bridge dependencies
// Bundle bridge dependencies (no creation lock needed for QuickJS)
let deps = BridgeDeps {
cron_scheduler: self.cron_scheduler.clone(),
skill_registry: self.registry.clone(),
@@ -265,8 +261,7 @@ impl RuntimeEngine {
self.emit_status_change(skill_id);
// Wait for initialization to complete (Running or Error status)
// with a reasonable timeout
// Wait for initialization to complete
let state = instance.state.clone();
let skill_id_owned = skill_id.to_string();
let max_wait = std::time::Duration::from_secs(10);
@@ -278,12 +273,10 @@ impl RuntimeEngine {
match current_status {
SkillStatus::Running => {
// Successfully started
self.emit_status_change(&skill_id_owned);
return Ok(instance.snapshot());
}
SkillStatus::Error => {
// Initialization failed - unregister and return error
let error_msg = state
.read()
.error
@@ -297,7 +290,6 @@ impl RuntimeEngine {
));
}
SkillStatus::Stopped => {
// Skill stopped unexpectedly during init
self.registry.unregister(&skill_id_owned);
return Err(format!(
"Skill '{}' stopped unexpectedly during initialization",
@@ -305,9 +297,7 @@ impl RuntimeEngine {
));
}
SkillStatus::Initializing | SkillStatus::Pending => {
// Still initializing, continue waiting
if start.elapsed() > max_wait {
// Timeout - skill is taking too long
log::warn!(
"[runtime] Skill '{}' initialization timeout, returning current state",
skill_id_owned
@@ -317,7 +307,6 @@ impl RuntimeEngine {
tokio::time::sleep(poll_interval).await;
}
SkillStatus::Stopping => {
// Unexpected state during startup
return Err(format!(
"Skill '{}' is in unexpected Stopping state during startup",
skill_id_owned
@@ -375,6 +364,7 @@ impl RuntimeEngine {
}
/// Auto-start skills based on user preferences.
/// No stagger delay needed for QuickJS (lightweight contexts).
pub async fn auto_start_skills(&self) {
match self.discover_skills().await {
Ok(manifests) => {
src-tauri/src/runtime/qjs_skill_instance.rs
+649
View File
@@ -0,0 +1,649 @@
//! QjsSkillInstance — manages one QuickJS context per skill.
//!
//! Key differences from V8 version:
//! - QuickJS contexts are Send+Sync with `parallel` feature, so we use regular tokio::spawn (not spawn_blocking)
//! - No V8 creation lock needed (QuickJS contexts are lightweight ~1-2MB)
//! - No stagger delay needed between skill starts
//! - Direct memory limits via `rt.set_memory_limit()`
//! - Uses `ctx.eval::<T, _>(code)` instead of `runtime.execute_script()`
//! - Simplified error handling with rquickjs::Error
use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::Arc;
use std::time::Duration;
use parking_lot::RwLock;
use tokio::sync::mpsc;
use crate::runtime::cron_scheduler::CronScheduler;
use crate::runtime::skill_registry::SkillRegistry;
use crate::runtime::types::{
SkillConfig, SkillMessage, SkillSnapshot, SkillStatus, ToolContent, ToolDefinition, ToolResult,
};
use crate::services::tdlib_v8::{qjs_ops, IdbStorage};
/// Dependencies passed to a skill instance for bridge installation.
#[allow(dead_code)]
pub struct BridgeDeps {
pub cron_scheduler: Arc<CronScheduler>,
pub skill_registry: Arc<SkillRegistry>,
pub app_handle: Option<tauri::AppHandle>,
pub data_dir: PathBuf,
// NOTE: No v8_creation_lock - QuickJS doesn't need it
}
/// Shared mutable state for a skill instance.
pub struct SkillState {
pub status: SkillStatus,
pub tools: Vec<ToolDefinition>,
pub error: Option<String>,
pub published_state: HashMap<String, serde_json::Value>,
}
impl Default for SkillState {
fn default() -> Self {
Self {
status: SkillStatus::Pending,
tools: Vec::new(),
error: None,
published_state: HashMap::new(),
}
}
}
/// A running skill instance using QuickJS.
pub struct QjsSkillInstance {
pub config: SkillConfig,
pub state: Arc<RwLock<SkillState>>,
pub sender: mpsc::Sender<SkillMessage>,
pub skill_dir: PathBuf,
pub data_dir: PathBuf,
}
impl QjsSkillInstance {
/// Create a new QuickJS skill instance.
pub fn new(
config: SkillConfig,
skill_dir: PathBuf,
data_dir: PathBuf,
) -> (Self, mpsc::Receiver<SkillMessage>) {
let (tx, rx) = mpsc::channel(64);
let instance = Self {
config,
state: Arc::new(RwLock::new(SkillState::default())),
sender: tx,
skill_dir,
data_dir,
};
(instance, rx)
}
/// Take a snapshot of the current skill state.
pub fn snapshot(&self) -> SkillSnapshot {
let state = self.state.read();
SkillSnapshot {
skill_id: self.config.skill_id.clone(),
name: self.config.name.clone(),
status: state.status,
tools: state.tools.clone(),
error: state.error.clone(),
state: state.published_state.clone(),
}
}
/// Spawn the skill's execution loop as a tokio task.
/// Unlike V8 (which needed spawn_blocking), QuickJS contexts are Send.
pub fn spawn(
&self,
mut rx: mpsc::Receiver<SkillMessage>,
_deps: BridgeDeps,
) -> tokio::task::JoinHandle<()> {
let config = self.config.clone();
let state = self.state.clone();
let skill_dir = self.skill_dir.clone();
let data_dir = self.data_dir.clone();
tokio::spawn(async move {
// Update status
state.write().status = SkillStatus::Initializing;
// Create storage
let storage = match IdbStorage::new(&data_dir) {
Ok(s) => s,
Err(e) => {
let mut s = state.write();
s.status = SkillStatus::Error;
s.error = Some(format!("Failed to create storage: {e}"));
log::error!("[skill:{}] Storage creation failed: {e}", config.skill_id);
return;
}
};
// Read the entry point JS file
let entry_path = skill_dir.join(&config.entry_point);
let js_source = match tokio::fs::read_to_string(&entry_path).await {
Ok(src) => src,
Err(e) => {
let mut s = state.write();
s.status = SkillStatus::Error;
s.error = Some(format!("Failed to read {}: {e}", config.entry_point));
log::error!("[skill:{}] Failed to read entry point: {e}", config.skill_id);
return;
}
};
// Create QuickJS runtime with memory limits
let rt = match rquickjs::AsyncRuntime::new() {
Ok(rt) => rt,
Err(e) => {
let mut s = state.write();
s.status = SkillStatus::Error;
s.error = Some(format!("Failed to create QuickJS runtime: {e}"));
log::error!("[skill:{}] Failed to create QuickJS runtime: {e}", config.skill_id);
return;
}
};
// Set memory limit (config.memory_limit is in bytes)
rt.set_memory_limit(config.memory_limit).await;
rt.set_max_stack_size(512 * 1024).await; // 512KB stack
// Create context with full standard library
let ctx = match rquickjs::AsyncContext::full(&rt).await {
Ok(ctx) => ctx,
Err(e) => {
let mut s = state.write();
s.status = SkillStatus::Error;
s.error = Some(format!("Failed to create QuickJS context: {e}"));
log::error!("[skill:{}] Failed to create context: {e}", config.skill_id);
return;
}
};
// Create shared timer state
let timer_state = Arc::new(RwLock::new(qjs_ops::TimerState::default()));
// Create WebSocket state
let ws_state = Arc::new(RwLock::new(qjs_ops::WebSocketState::default()));
// Create published skill state (different from SkillState above)
let published_state = Arc::new(RwLock::new(qjs_ops::SkillState::default()));
// Register ops and run bootstrap + skill code
let skill_id = config.skill_id.clone();
let init_result = ctx.with(|js_ctx| {
// Register native ops as __ops global
let skill_context = qjs_ops::SkillContext {
skill_id: skill_id.clone(),
data_dir: data_dir.clone(),
};
if let Err(e) = qjs_ops::register_ops(
&js_ctx,
storage.clone(),
skill_context,
published_state.clone(),
timer_state.clone(),
ws_state.clone(),
) {
return Err(format!("Failed to register ops: {e}"));
}
// Load bootstrap
let bootstrap_code = include_str!("../services/tdlib_v8/bootstrap.js");
if let Err(e) = js_ctx.eval::<rquickjs::Value, _>(bootstrap_code) {
let err_str = format!("Bootstrap failed: {e}");
return Err(err_str);
}
// Set skill ID
let bridge_code = format!(
r#"globalThis.__skillId = "{}";"#,
skill_id.replace('"', r#"\""#)
);
if let Err(e) = js_ctx.eval::<rquickjs::Value, _>(bridge_code.as_bytes()) {
return Err(format!("Skill init failed: {e}"));
}
// Execute the skill's entry point
if let Err(e) = js_ctx.eval::<rquickjs::Value, _>(js_source.as_bytes()) {
return Err(format!("Skill load failed: {e}"));
}
// Extract tool definitions
extract_tools(&js_ctx, &state);
Ok(())
}).await;
if let Err(e) = init_result {
let mut s = state.write();
s.status = SkillStatus::Error;
s.error = Some(e.clone());
log::error!("[skill:{}] {e}", config.skill_id);
return;
}
// Call init() lifecycle
if let Err(e) = call_lifecycle(&ctx, "init").await {
let mut s = state.write();
s.status = SkillStatus::Error;
s.error = Some(format!("init() failed: {e}"));
log::error!("[skill:{}] init() failed: {e}", config.skill_id);
return;
}
// Execute pending jobs after init (process promises)
drive_jobs(&rt).await;
// Call start() lifecycle
if let Err(e) = call_lifecycle(&ctx, "start").await {
let mut s = state.write();
s.status = SkillStatus::Error;
s.error = Some(format!("start() failed: {e}"));
log::error!("[skill:{}] start() failed: {e}", config.skill_id);
return;
}
// Execute pending jobs after start
drive_jobs(&rt).await;
// Mark as running
state.write().status = SkillStatus::Running;
log::info!("[skill:{}] Running (QuickJS)", config.skill_id);
// Run the event loop
run_event_loop(&rt, &ctx, &mut rx, &state, &config.skill_id, &timer_state).await;
})
}
}
// ============================================================================
// Event Loop
// ============================================================================
/// The main event loop that drives the QuickJS runtime.
/// This continuously:
/// 1. Polls for ready timers and fires their callbacks
/// 2. Checks for incoming messages (non-blocking)
/// 3. Runs the QuickJS job queue for promises/async ops
/// 4. Sleeps efficiently when idle
async fn run_event_loop(
rt: &rquickjs::AsyncRuntime,
ctx: &rquickjs::AsyncContext,
rx: &mut mpsc::Receiver<SkillMessage>,
state: &Arc<RwLock<SkillState>>,
skill_id: &str,
timer_state: &Arc<RwLock<qjs_ops::TimerState>>,
) {
// Maximum sleep duration when no timers are pending
const MAX_IDLE_SLEEP: Duration = Duration::from_millis(100);
// Minimum sleep to prevent busy-spinning
const MIN_SLEEP: Duration = Duration::from_millis(1);
loop {
// 1. Poll and fire ready timers
let ready_timers = {
let (ready, _next) = qjs_ops::poll_timers(timer_state);
ready
};
// Fire timer callbacks in JavaScript
for timer_id in ready_timers {
fire_timer_callback(ctx, timer_id).await;
}
// 2. Check for incoming messages (non-blocking)
match rx.try_recv() {
Ok(msg) => {
let should_stop = handle_message(ctx, msg, state, skill_id).await;
if should_stop {
break;
}
}
Err(mpsc::error::TryRecvError::Empty) => {
// No message - that's fine
}
Err(mpsc::error::TryRecvError::Disconnected) => {
// Channel closed, exit
log::info!("[skill:{}] Message channel disconnected, stopping", skill_id);
break;
}
}
// 3. Drive QuickJS job queue (process pending promises)
drive_jobs(rt).await;
// 4. Calculate sleep duration based on next timer
let sleep_duration = {
let (_, next_timer) = qjs_ops::poll_timers(timer_state);
match next_timer {
Some(d) if d < MIN_SLEEP => MIN_SLEEP,
Some(d) if d > MAX_IDLE_SLEEP => MAX_IDLE_SLEEP,
Some(d) => d,
None => MAX_IDLE_SLEEP,
}
};
// Sleep efficiently - this yields the thread when no work is needed
tokio::time::sleep(sleep_duration).await;
}
}
/// Drive the QuickJS job queue until no more jobs are pending.
async fn drive_jobs(rt: &rquickjs::AsyncRuntime) {
// idle() runs all pending futures and jobs
rt.idle().await;
}
/// Fire a timer callback in JavaScript.
async fn fire_timer_callback(ctx: &rquickjs::AsyncContext, timer_id: u32) {
let code = format!("globalThis.__handleTimer({});", timer_id);
ctx.with(|js_ctx| {
if let Err(e) = js_ctx.eval::<rquickjs::Value, _>(code.as_bytes()) {
log::error!("[timer] Callback for timer {} failed: {}", timer_id, e);
}
}).await;
}
/// Handle a single message from the channel.
/// Returns true if the skill should stop.
async fn handle_message(
ctx: &rquickjs::AsyncContext,
msg: SkillMessage,
state: &Arc<RwLock<SkillState>>,
skill_id: &str,
) -> bool {
match msg {
SkillMessage::CallTool { tool_name, arguments, reply } => {
let result = handle_tool_call(ctx, &tool_name, arguments).await;
let _ = reply.send(result);
}
SkillMessage::ServerEvent { event, data } => {
let _ = handle_server_event(ctx, &event, data).await;
}
SkillMessage::CronTrigger { schedule_id } => {
let _ = handle_cron_trigger(ctx, &schedule_id).await;
}
SkillMessage::Stop { reply } => {
let _ = call_lifecycle(ctx, "stop").await;
state.write().status = SkillStatus::Stopped;
log::info!("[skill:{}] Stopped", skill_id);
let _ = reply.send(());
return true; // Signal to stop
}
SkillMessage::SetupStart { reply } => {
let result = handle_js_call(ctx, "onSetupStart", "{}").await;
let _ = reply.send(result);
}
SkillMessage::SetupSubmit { step_id, values, reply } => {
let args = serde_json::json!({ "stepId": step_id, "values": values });
let result = handle_js_call(ctx, "onSetupSubmit", &args.to_string()).await;
let _ = reply.send(result);
}
SkillMessage::SetupCancel { reply } => {
let result = handle_js_void_call(ctx, "onSetupCancel", "{}").await;
let _ = reply.send(result);
}
SkillMessage::ListOptions { reply } => {
let result = handle_js_call(ctx, "onListOptions", "{}").await;
let _ = reply.send(result);
}
SkillMessage::SetOption { name, value, reply } => {
let args = serde_json::json!({ "name": name, "value": value });
let result = handle_js_void_call(ctx, "onSetOption", &args.to_string()).await;
let _ = reply.send(result);
}
SkillMessage::SessionStart { session_id, reply } => {
let args = serde_json::json!({ "sessionId": session_id });
let result = handle_js_void_call(ctx, "onSessionStart", &args.to_string()).await;
let _ = reply.send(result);
}
SkillMessage::SessionEnd { session_id, reply } => {
let args = serde_json::json!({ "sessionId": session_id });
let result = handle_js_void_call(ctx, "onSessionEnd", &args.to_string()).await;
let _ = reply.send(result);
}
SkillMessage::Tick { reply } => {
let result = handle_js_void_call(ctx, "onTick", "{}").await;
let _ = reply.send(result);
}
SkillMessage::Rpc { method, params, reply } => {
let args = serde_json::json!({ "method": method, "params": params });
let result = handle_js_call(ctx, "onRpc", &args.to_string()).await;
let _ = reply.send(result);
}
}
false // Don't stop
}
// ============================================================================
// Helper Functions
// ============================================================================
/// Call a lifecycle function on the skill object.
/// Looks for the skill at globalThis.__skill.default first, then falls back to globalThis.
async fn call_lifecycle(ctx: &rquickjs::AsyncContext, name: &str) -> Result<(), String> {
let name = name.to_string();
ctx.with(|js_ctx| {
let code = format!(
r#"(function() {{
var skill = globalThis.__skill && globalThis.__skill.default
? globalThis.__skill.default
: (globalThis.__skill || globalThis);
if (typeof skill.{name} === 'function') {{
skill.{name}();
}} else if (typeof globalThis.{name} === 'function') {{
globalThis.{name}();
}}
}})()"#
);
js_ctx.eval::<rquickjs::Value, _>(code.as_bytes())
.map_err(|e| format!("{name}() failed: {e}"))?;
Ok(())
}).await
}
/// Extract tool definitions from the skill.
fn extract_tools(js_ctx: &rquickjs::Ctx<'_>, state: &Arc<RwLock<SkillState>>) {
let code = r#"
(function() {
var skill = globalThis.__skill && globalThis.__skill.default
? globalThis.__skill.default
: (globalThis.__skill || null);
var tools = (skill && skill.tools) || globalThis.tools || [];
return JSON.stringify(tools.map(function(t) {
return {
name: t.name || "",
description: t.description || "",
input_schema: t.inputSchema || t.input_schema || {}
};
}));
})()
"#;
// eval with String type hint tells rquickjs to convert the result to a Rust String
match js_ctx.eval::<String, _>(code) {
Ok(json_str) => {
match serde_json::from_str::<Vec<ToolDefinition>>(&json_str) {
Ok(tools) => {
state.write().tools = tools;
}
Err(e) => {
log::warn!("[tools] Failed to parse tools JSON: {e}");
}
}
}
Err(e) => {
log::warn!("[tools] Failed to extract tools: {e}");
}
}
}
/// Handle a tool call.
async fn handle_tool_call(
ctx: &rquickjs::AsyncContext,
tool_name: &str,
arguments: serde_json::Value,
) -> Result<ToolResult, String> {
let args_str = serde_json::to_string(&arguments)
.map_err(|e| format!("Failed to serialize args: {e}"))?;
let tool_name = tool_name.to_string();
let result_text = ctx.with(|js_ctx| {
let code = format!(
r#"(function() {{
var skill = globalThis.__skill && globalThis.__skill.default
? globalThis.__skill.default
: (globalThis.__skill || null);
var tools = (skill && skill.tools) || globalThis.tools || [];
for (var i = 0; i < tools.length; i++) {{
if (tools[i].name === "{}") {{
var args = {};
var result = tools[i].execute(args);
if (result && typeof result === 'object') {{
return JSON.stringify(result);
}}
return String(result);
}}
}}
throw new Error("Tool '{}' not found");
}})()"#,
tool_name.replace('"', r#"\""#),
args_str,
tool_name.replace('"', r#"\""#),
);
match js_ctx.eval::<String, _>(code.as_bytes()) {
Ok(s) => Ok(s),
Err(e) => Err(format!("Tool execution failed: {e}"))
}
}).await?;
Ok(ToolResult {
content: vec![ToolContent::Text { text: result_text }],
is_error: false,
})
}
/// Handle a server event.
async fn handle_server_event(
ctx: &rquickjs::AsyncContext,
event: &str,
data: serde_json::Value,
) -> Result<(), String> {
let data_str = serde_json::to_string(&data).unwrap_or_else(|_| "null".to_string());
let event = event.to_string();
ctx.with(|js_ctx| {
let code = format!(
r#"(function() {{
var skill = globalThis.__skill && globalThis.__skill.default
? globalThis.__skill.default
: (globalThis.__skill || globalThis);
if (typeof skill.onServerEvent === 'function') {{
skill.onServerEvent("{}", {});
}} else if (typeof globalThis.onServerEvent === 'function') {{
globalThis.onServerEvent("{}", {});
}}
}})()"#,
event.replace('"', r#"\""#),
data_str,
event.replace('"', r#"\""#),
data_str,
);
js_ctx.eval::<rquickjs::Value, _>(code.as_bytes())
.map_err(|e| format!("Event handler failed: {e}"))?;
Ok(())
}).await
}
/// Handle a cron trigger.
async fn handle_cron_trigger(ctx: &rquickjs::AsyncContext, schedule_id: &str) -> Result<(), String> {
let schedule_id = schedule_id.to_string();
ctx.with(|js_ctx| {
let code = format!(
r#"(function() {{
var skill = globalThis.__skill && globalThis.__skill.default
? globalThis.__skill.default
: (globalThis.__skill || globalThis);
if (typeof skill.onCronTrigger === 'function') {{
skill.onCronTrigger("{}");
}} else if (typeof globalThis.onCronTrigger === 'function') {{
globalThis.onCronTrigger("{}");
}}
}})()"#,
schedule_id.replace('"', r#"\""#),
schedule_id.replace('"', r#"\""#),
);
js_ctx.eval::<rquickjs::Value, _>(code.as_bytes())
.map_err(|e| format!("Cron trigger failed: {e}"))
.map(|_| ())
}).await
}
/// Call a JS function on the skill object that returns a JSON value.
async fn handle_js_call(
ctx: &rquickjs::AsyncContext,
fn_name: &str,
args_json: &str,
) -> Result<serde_json::Value, String> {
let fn_name = fn_name.to_string();
let args_json = args_json.to_string();
let result_text = ctx.with(|js_ctx| {
let code = format!(
r#"(function() {{
var skill = globalThis.__skill && globalThis.__skill.default
? globalThis.__skill.default
: (globalThis.__skill || globalThis);
var fn = skill.{fn_name} || globalThis.{fn_name};
if (typeof fn === 'function') {{
var args = {args_json};
var result = fn.call(skill, args);
return JSON.stringify(result);
}}
return "null";
}})()"#
);
match js_ctx.eval::<String, _>(code.as_bytes()) {
Ok(s) => Ok(s),
Err(e) => Err(format!("{fn_name}() failed: {e}"))
}
}).await?;
serde_json::from_str(&result_text)
.map_err(|e| format!("{fn_name}() returned invalid JSON: {e}"))
}
/// Call a JS function on the skill object that returns void.
async fn handle_js_void_call(
ctx: &rquickjs::AsyncContext,
fn_name: &str,
args_json: &str,
) -> Result<(), String> {
let fn_name = fn_name.to_string();
let args_json = args_json.to_string();
ctx.with(|js_ctx| {
let code = format!(
r#"(function() {{
var skill = globalThis.__skill && globalThis.__skill.default
? globalThis.__skill.default
: (globalThis.__skill || globalThis);
var fn = skill.{fn_name} || globalThis.{fn_name};
if (typeof fn === 'function') {{
var args = {args_json};
fn.call(skill, args);
}}
}})()"#
);
js_ctx.eval::<rquickjs::Value, _>(code.as_bytes())
.map_err(|e| format!("{fn_name}() failed: {e}"))
.map(|_| ())
}).await
}
src-tauri/src/runtime/skill_registry.rs
+1 -1
View File
@@ -6,7 +6,7 @@ use std::sync::Arc;
use parking_lot::RwLock;
use tokio::sync::{mpsc, oneshot};
use crate::runtime::v8_skill_instance::SkillState;
use crate::runtime::qjs_skill_instance::SkillState;
use crate::runtime::types::{
SkillConfig, SkillMessage, SkillSnapshot, SkillStatus, ToolDefinition, ToolResult,
};
src-tauri/src/runtime/socket_manager.rs
+1 -1
View File
@@ -30,7 +30,7 @@ use rust_socketio::{
Event, Payload,
};
// SkillRegistry only available on desktop (V8/deno_core required)
// SkillRegistry only available on desktop (QuickJS required)
#[cfg(not(any(target_os = "android", target_os = "ios")))]
use crate::runtime::skill_registry::SkillRegistry;
src-tauri/src/runtime/v8_skill_instance.rs
-712
View File
@@ -1,712 +0,0 @@
//! V8SkillInstance — manages one V8 context per skill.
//!
//! Each skill runs on its own dedicated thread (V8's JsRuntime is not Send)
//! with:
//! - A scoped SQLite database
//! - Bridge globals (db, store, net, platform, console)
//! - An async event loop that drives timers, promises, and handles messages
//! - Lifecycle hooks: init() -> start() -> [event loop] -> stop()
use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::Arc;
use std::time::Duration;
use deno_core::{v8, JsRuntime, PollEventLoopOptions, RuntimeOptions};
use parking_lot::RwLock;
use tokio::sync::mpsc;
use crate::runtime::cron_scheduler::CronScheduler;
use crate::runtime::skill_registry::SkillRegistry;
use crate::runtime::types::{
SkillConfig, SkillMessage, SkillSnapshot, SkillStatus, ToolContent, ToolDefinition, ToolResult,
};
use crate::services::tdlib_v8::{ops, IdbStorage};
/// Dependencies passed to a skill instance for bridge installation.
/// Currently not all fields are used, but they're kept for future feature parity.
#[allow(dead_code)]
pub struct BridgeDeps {
pub cron_scheduler: Arc<CronScheduler>,
pub skill_registry: Arc<SkillRegistry>,
pub app_handle: Option<tauri::AppHandle>,
pub data_dir: PathBuf,
}
/// Shared mutable state for a skill instance.
pub struct SkillState {
pub status: SkillStatus,
pub tools: Vec<ToolDefinition>,
pub error: Option<String>,
pub published_state: HashMap<String, serde_json::Value>,
}
impl Default for SkillState {
fn default() -> Self {
Self {
status: SkillStatus::Pending,
tools: Vec::new(),
error: None,
published_state: HashMap::new(),
}
}
}
/// A running skill instance using V8.
pub struct V8SkillInstance {
pub config: SkillConfig,
pub state: Arc<RwLock<SkillState>>,
pub sender: mpsc::Sender<SkillMessage>,
pub skill_dir: PathBuf,
pub data_dir: PathBuf,
}
impl V8SkillInstance {
/// Create a new V8 skill instance.
pub fn new(
config: SkillConfig,
skill_dir: PathBuf,
data_dir: PathBuf,
) -> (Self, mpsc::Receiver<SkillMessage>) {
let (tx, rx) = mpsc::channel(64);
let instance = Self {
config,
state: Arc::new(RwLock::new(SkillState::default())),
sender: tx,
skill_dir,
data_dir,
};
(instance, rx)
}
/// Take a snapshot of the current skill state.
pub fn snapshot(&self) -> SkillSnapshot {
let state = self.state.read();
SkillSnapshot {
skill_id: self.config.skill_id.clone(),
name: self.config.name.clone(),
status: state.status,
tools: state.tools.clone(),
error: state.error.clone(),
state: state.published_state.clone(),
}
}
/// Spawn the skill's execution loop in a dedicated thread.
/// Returns a JoinHandle wrapped in a tokio task for compatibility.
pub fn spawn(
&self,
mut rx: mpsc::Receiver<SkillMessage>,
_deps: BridgeDeps,
) -> tokio::task::JoinHandle<()> {
let config = self.config.clone();
let state = self.state.clone();
let skill_dir = self.skill_dir.clone();
let data_dir = self.data_dir.clone();
// Use std::thread::spawn since JsRuntime is not Send
// Wrap in tokio task for API compatibility
tokio::task::spawn_blocking(move || {
// Update status
state.write().status = SkillStatus::Initializing;
// Create storage
let storage = match IdbStorage::new(&data_dir) {
Ok(s) => s,
Err(e) => {
let mut s = state.write();
s.status = SkillStatus::Error;
s.error = Some(format!("Failed to create storage: {e}"));
log::error!("[skill:{}] Storage creation failed: {e}", config.skill_id);
return;
}
};
// Read the entry point JS file synchronously
let entry_path = skill_dir.join(&config.entry_point);
let js_source = match std::fs::read_to_string(&entry_path) {
Ok(src) => src,
Err(e) => {
let mut s = state.write();
s.status = SkillStatus::Error;
s.error = Some(format!("Failed to read {}: {e}", config.entry_point));
log::error!("[skill:{}] Failed to read entry point: {e}", config.skill_id);
return;
}
};
// Create V8 runtime with memory limits to prevent OOM crashes.
// Each skill gets its own V8 isolate; without limits V8 tries to reserve
// ~1.4 GB per isolate which can exhaust memory when multiple skills start.
let extension = ops::build_extension(storage.clone());
let create_params = v8::CreateParams::default()
.heap_limits(0, config.memory_limit);
let mut runtime = match JsRuntime::try_new(RuntimeOptions {
extensions: vec![extension],
create_params: Some(create_params),
..Default::default()
}) {
Ok(rt) => rt,
Err(e) => {
let mut s = state.write();
s.status = SkillStatus::Error;
s.error = Some(format!("Failed to create V8 runtime: {e}"));
log::error!(
"[skill:{}] Failed to create V8 runtime (memory_limit={}): {e}",
config.skill_id,
config.memory_limit
);
return;
}
};
// Set skill context in op state
{
let op_state = runtime.op_state();
let mut state_ref = op_state.borrow_mut();
ops::init_state_with_data_dir(
&mut state_ref,
storage,
config.skill_id.clone(),
data_dir.clone(),
state.clone(),
);
}
// Load bootstrap
let bootstrap_code = include_str!("../services/tdlib_v8/bootstrap.js");
if let Err(e) = runtime.execute_script("<bootstrap>", bootstrap_code.to_string()) {
let mut s = state.write();
s.status = SkillStatus::Error;
s.error = Some(format!("Bootstrap failed: {e}"));
log::error!("[skill:{}] Bootstrap failed: {e}", config.skill_id);
return;
}
// Install skill-specific bridges
let skill_id = config.skill_id.clone();
let bridge_code = format!(
r#"globalThis.__skillId = "{}";"#,
skill_id.replace('"', r#"\""#)
);
if let Err(e) = runtime.execute_script("<skill-init>", bridge_code) {
let mut s = state.write();
s.status = SkillStatus::Error;
s.error = Some(format!("Skill init failed: {e}"));
return;
}
// Execute the skill's entry point
// Use a static string for the filename
let filename: &'static str = Box::leak(format!("<skill:{}>", config.skill_id).into_boxed_str());
if let Err(e) = runtime.execute_script(filename, js_source) {
let mut s = state.write();
s.status = SkillStatus::Error;
s.error = Some(format!("Skill load failed: {e}"));
log::error!("[skill:{}] Load failed: {e}", config.skill_id);
return;
}
// Extract tool definitions
extract_tools(&mut runtime, &state);
// Create a tokio runtime for this thread FIRST - all async ops must run inside it
// This is critical because deno_unsync requires CurrentThread runtime for async ops
let rt = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.expect("Failed to create tokio runtime");
// Run the entire lifecycle inside the CurrentThread runtime
rt.block_on(async {
// Call init()
if let Err(e) = call_lifecycle_fn_async(&mut runtime, "init").await {
let mut s = state.write();
s.status = SkillStatus::Error;
s.error = Some(format!("init() failed: {e}"));
log::error!("[skill:{}] init() failed: {e}", config.skill_id);
return;
}
// Call start()
if let Err(e) = call_lifecycle_fn_async(&mut runtime, "start").await {
let mut s = state.write();
s.status = SkillStatus::Error;
s.error = Some(format!("start() failed: {e}"));
log::error!("[skill:{}] start() failed: {e}", config.skill_id);
return;
}
// Mark as running
state.write().status = SkillStatus::Running;
log::info!("[skill:{}] Running (V8)", config.skill_id);
// Run the event loop
run_event_loop(&mut runtime, &mut rx, &state, &config.skill_id).await;
});
})
}
}
// ============================================================================
// Event Loop
// ============================================================================
/// The main event loop that drives the V8 runtime.
/// This continuously:
/// 1. Polls for ready timers and fires their callbacks
/// 2. Checks for incoming messages (non-blocking)
/// 3. Runs the V8 event loop for promises/async ops
/// 4. Sleeps efficiently when idle
async fn run_event_loop(
runtime: &mut JsRuntime,
rx: &mut mpsc::Receiver<SkillMessage>,
state: &Arc<RwLock<SkillState>>,
skill_id: &str,
) {
// Maximum sleep duration when no timers are pending
const MAX_IDLE_SLEEP: Duration = Duration::from_millis(100);
// Minimum sleep to prevent busy-spinning
const MIN_SLEEP: Duration = Duration::from_millis(1);
loop {
// 1. Poll and fire ready timers
let ready_timers = {
let op_state = runtime.op_state();
let mut state_ref = op_state.borrow_mut();
let (ready, _next) = ops::poll_timers(&mut state_ref);
ready
};
// Fire timer callbacks in JavaScript
for timer_id in ready_timers {
fire_timer_callback(runtime, timer_id);
}
// 2. Check for incoming messages (non-blocking)
match rx.try_recv() {
Ok(msg) => {
let should_stop = handle_message(runtime, msg, state, skill_id).await;
if should_stop {
break;
}
}
Err(mpsc::error::TryRecvError::Empty) => {
// No message - that's fine
}
Err(mpsc::error::TryRecvError::Disconnected) => {
// Channel closed, exit
log::info!("[skill:{}] Message channel disconnected, stopping", skill_id);
break;
}
}
// 3. Run the V8 event loop (processes promises, async ops, etc.)
// Use poll mode - returns immediately if nothing to do
let poll_result = runtime
.run_event_loop(PollEventLoopOptions {
wait_for_inspector: false,
pump_v8_message_loop: true,
})
.await;
if let Err(e) = poll_result {
log::error!("[skill:{}] Event loop error: {}", skill_id, e);
// Don't break - try to continue
}
// 4. Calculate sleep duration based on next timer
let sleep_duration = {
let op_state = runtime.op_state();
let mut state_ref = op_state.borrow_mut();
let (_, next_timer) = ops::poll_timers(&mut state_ref);
match next_timer {
Some(d) if d < MIN_SLEEP => MIN_SLEEP,
Some(d) if d > MAX_IDLE_SLEEP => MAX_IDLE_SLEEP,
Some(d) => d,
None => MAX_IDLE_SLEEP,
}
};
// Sleep efficiently - this yields the thread when no work is needed
tokio::time::sleep(sleep_duration).await;
}
}
/// Fire a timer callback in JavaScript.
fn fire_timer_callback(runtime: &mut JsRuntime, timer_id: u32) {
let code = format!("globalThis.__handleTimer({});", timer_id);
if let Err(e) = runtime.execute_script("<timer-callback>", code) {
log::error!("[timer] Callback for timer {} failed: {}", timer_id, e);
}
}
/// Handle a single message from the channel.
/// Returns true if the skill should stop.
async fn handle_message(
runtime: &mut JsRuntime,
msg: SkillMessage,
state: &Arc<RwLock<SkillState>>,
skill_id: &str,
) -> bool {
match msg {
SkillMessage::CallTool {
tool_name,
arguments,
reply,
} => {
let result = handle_tool_call_sync(runtime, &tool_name, arguments);
let _ = reply.send(result);
}
SkillMessage::ServerEvent { event, data } => {
let _ = handle_server_event_sync(runtime, &event, data);
}
SkillMessage::CronTrigger { schedule_id } => {
let _ = handle_cron_trigger_sync(runtime, &schedule_id);
}
SkillMessage::Stop { reply } => {
let _ = call_lifecycle_fn_sync(runtime, "stop");
state.write().status = SkillStatus::Stopped;
log::info!("[skill:{}] Stopped", skill_id);
let _ = reply.send(());
return true; // Signal to stop
}
SkillMessage::SetupStart { reply } => {
let result = handle_js_call_sync(runtime, "onSetupStart", "{}");
let _ = reply.send(result);
}
SkillMessage::SetupSubmit {
step_id,
values,
reply,
} => {
let args = serde_json::json!({
"stepId": step_id,
"values": values,
});
let result = handle_js_call_sync(runtime, "onSetupSubmit", &args.to_string());
let _ = reply.send(result);
}
SkillMessage::SetupCancel { reply } => {
let result = handle_js_void_call_sync(runtime, "onSetupCancel", "{}");
let _ = reply.send(result);
}
SkillMessage::ListOptions { reply } => {
let result = handle_js_call_sync(runtime, "onListOptions", "{}");
let _ = reply.send(result);
}
SkillMessage::SetOption { name, value, reply } => {
let args = serde_json::json!({
"name": name,
"value": value,
});
let result = handle_js_void_call_sync(runtime, "onSetOption", &args.to_string());
let _ = reply.send(result);
}
SkillMessage::SessionStart { session_id, reply } => {
let args = serde_json::json!({ "sessionId": session_id });
let result = handle_js_void_call_sync(runtime, "onSessionStart", &args.to_string());
let _ = reply.send(result);
}
SkillMessage::SessionEnd { session_id, reply } => {
let args = serde_json::json!({ "sessionId": session_id });
let result = handle_js_void_call_sync(runtime, "onSessionEnd", &args.to_string());
let _ = reply.send(result);
}
SkillMessage::Tick { reply } => {
let result = handle_js_void_call_sync(runtime, "onTick", "{}");
let _ = reply.send(result);
}
SkillMessage::Rpc {
method,
params,
reply,
} => {
let args = serde_json::json!({
"method": method,
"params": params,
});
let result = handle_js_call_sync(runtime, "onRpc", &args.to_string());
let _ = reply.send(result);
}
}
false // Don't stop
}
/// Extract tool definitions from skill.tools (supports both globalThis.__skill.default and globalThis.tools).
fn extract_tools(runtime: &mut JsRuntime, state: &Arc<RwLock<SkillState>>) {
let code = r#"
(function() {
// Try to get skill from bundled export first, then fall back to globalThis.tools
var skill = globalThis.__skill && globalThis.__skill.default
? globalThis.__skill.default
: (globalThis.__skill || null);
var tools = (skill && skill.tools) || globalThis.tools || [];
return JSON.stringify(tools.map(function(t) {
return {
name: t.name || "",
description: t.description || "",
input_schema: t.inputSchema || t.input_schema || {}
};
}));
})()
"#;
if let Ok(result) = runtime.execute_script("<extract-tools>", code.to_string()) {
let scope = &mut runtime.handle_scope();
let local = v8::Local::new(scope, result);
if let Some(s) = local.to_string(scope) {
let json_str = s.to_rust_string_lossy(scope);
if let Ok(tools) = serde_json::from_str::<Vec<ToolDefinition>>(&json_str) {
state.write().tools = tools;
}
}
}
}
/// Call a lifecycle function on the skill object asynchronously.
/// This version runs inside the skill's CurrentThread runtime - no nested runtime creation.
/// Looks for the skill at globalThis.__skill.default first, then falls back to globalThis.
///
/// Note: This does NOT wait for the event loop to complete, because lifecycle functions
/// may start async operations (like update loops) that run indefinitely. The main event
/// loop will process pending async work after init/start complete.
async fn call_lifecycle_fn_async(runtime: &mut JsRuntime, name: &str) -> Result<(), String> {
let code = format!(
r#"(function() {{
var skill = globalThis.__skill && globalThis.__skill.default
? globalThis.__skill.default
: (globalThis.__skill || globalThis);
if (typeof skill.{name} === 'function') {{
skill.{name}();
}} else if (typeof globalThis.{name} === 'function') {{
globalThis.{name}();
}}
}})()"#
);
runtime
.execute_script("<lifecycle>", code)
.map_err(|e| format!("{name}() failed: {e}"))?;
// Don't wait for event loop here - the main event loop will handle pending async work.
// This is important because lifecycle functions may start long-running async operations
// (like TDLib update loops) that would block init/start from completing.
Ok(())
}
/// Call a lifecycle function on the skill object synchronously.
/// WARNING: This creates its own tokio runtime - only use when NOT inside an async context.
/// Looks for the skill at globalThis.__skill.default first, then falls back to globalThis.
#[allow(dead_code)]
fn call_lifecycle_fn_sync(runtime: &mut JsRuntime, name: &str) -> Result<(), String> {
let code = format!(
r#"(function() {{
var skill = globalThis.__skill && globalThis.__skill.default
? globalThis.__skill.default
: (globalThis.__skill || globalThis);
if (typeof skill.{name} === 'function') {{
skill.{name}();
}} else if (typeof globalThis.{name} === 'function') {{
globalThis.{name}();
}}
}})()"#
);
runtime
.execute_script("<lifecycle>", code)
.map_err(|e| format!("{name}() failed: {e}"))?;
// Run event loop synchronously to handle any pending ops
let rt = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.map_err(|e| format!("Failed to create runtime: {e}"))?;
rt.block_on(async {
runtime
.run_event_loop(PollEventLoopOptions::default())
.await
.map_err(|e| format!("Event loop error: {e}"))
})?;
Ok(())
}
/// Handle a tool call synchronously (no async ops waited).
/// This is used when we just need to invoke the tool and get immediate result.
fn handle_tool_call_sync(
runtime: &mut JsRuntime,
tool_name: &str,
arguments: serde_json::Value,
) -> Result<ToolResult, String> {
let args_str =
serde_json::to_string(&arguments).map_err(|e| format!("Failed to serialize args: {e}"))?;
let code = format!(
r#"(function() {{
var skill = globalThis.__skill && globalThis.__skill.default
? globalThis.__skill.default
: (globalThis.__skill || null);
var tools = (skill && skill.tools) || globalThis.tools || [];
for (var i = 0; i < tools.length; i++) {{
if (tools[i].name === "{}") {{
var args = {};
var result = tools[i].execute(args);
if (result && typeof result === 'object') {{
return JSON.stringify(result);
}}
return String(result);
}}
}}
throw new Error("Tool '{}' not found");
}})()"#,
tool_name.replace('"', r#"\""#),
args_str,
tool_name.replace('"', r#"\""#),
);
let result = runtime
.execute_script("<tool-call>", code)
.map_err(|e| format!("Tool execution failed: {e}"))?;
// Note: We don't run the event loop here because we're already inside
// the skill's event loop. Pending async ops will be handled by the main loop.
let scope = &mut runtime.handle_scope();
let local = v8::Local::new(scope, result);
let result_text = if let Some(s) = local.to_string(scope) {
s.to_rust_string_lossy(scope)
} else {
"null".to_string()
};
Ok(ToolResult {
content: vec![ToolContent::Text { text: result_text }],
is_error: false,
})
}
/// Handle a server event synchronously.
fn handle_server_event_sync(
runtime: &mut JsRuntime,
event: &str,
data: serde_json::Value,
) -> Result<(), String> {
let data_str = serde_json::to_string(&data).unwrap_or_else(|_| "null".to_string());
let code = format!(
r#"(function() {{
var skill = globalThis.__skill && globalThis.__skill.default
? globalThis.__skill.default
: (globalThis.__skill || globalThis);
if (typeof skill.onServerEvent === 'function') {{
skill.onServerEvent("{}", {});
}} else if (typeof globalThis.onServerEvent === 'function') {{
globalThis.onServerEvent("{}", {});
}}
}})()"#,
event.replace('"', r#"\""#),
data_str,
event.replace('"', r#"\""#),
data_str,
);
runtime
.execute_script("<server-event>", code)
.map_err(|e| format!("Event handler failed: {e}"))?;
Ok(())
}
/// Handle a cron trigger synchronously.
fn handle_cron_trigger_sync(runtime: &mut JsRuntime, schedule_id: &str) -> Result<(), String> {
let code = format!(
r#"(function() {{
var skill = globalThis.__skill && globalThis.__skill.default
? globalThis.__skill.default
: (globalThis.__skill || globalThis);
if (typeof skill.onCronTrigger === 'function') {{
skill.onCronTrigger("{}");
}} else if (typeof globalThis.onCronTrigger === 'function') {{
globalThis.onCronTrigger("{}");
}}
}})()"#,
schedule_id.replace('"', r#"\""#),
schedule_id.replace('"', r#"\""#),
);
runtime
.execute_script("<cron-trigger>", code)
.map_err(|e| format!("Cron trigger failed: {e}"))?;
Ok(())
}
/// Call a JS function on the skill object that returns a JSON value synchronously.
fn handle_js_call_sync(
runtime: &mut JsRuntime,
fn_name: &str,
args_json: &str,
) -> Result<serde_json::Value, String> {
let code = format!(
r#"(function() {{
var skill = globalThis.__skill && globalThis.__skill.default
? globalThis.__skill.default
: (globalThis.__skill || globalThis);
var fn = skill.{fn_name} || globalThis.{fn_name};
if (typeof fn === 'function') {{
var args = {args_json};
var result = fn.call(skill, args);
return JSON.stringify(result);
}}
return "null";
}})()"#
);
let result = runtime
.execute_script("<js-call>", code)
.map_err(|e| format!("{fn_name}() failed: {e}"))?;
let scope = &mut runtime.handle_scope();
let local = v8::Local::new(scope, result);
let result_text = if let Some(s) = local.to_string(scope) {
s.to_rust_string_lossy(scope)
} else {
"null".to_string()
};
serde_json::from_str(&result_text)
.map_err(|e| format!("{fn_name}() returned invalid JSON: {e}"))
}
/// Call a JS function on the skill object that returns void synchronously.
fn handle_js_void_call_sync(
runtime: &mut JsRuntime,
fn_name: &str,
args_json: &str,
) -> Result<(), String> {
let code = format!(
r#"(function() {{
var skill = globalThis.__skill && globalThis.__skill.default
? globalThis.__skill.default
: (globalThis.__skill || globalThis);
var fn = skill.{fn_name} || globalThis.{fn_name};
if (typeof fn === 'function') {{
var args = {args_json};
fn.call(skill, args);
}}
}})()"#
);
runtime
.execute_script("<js-void-call>", code)
.map_err(|e| format!("{fn_name}() failed: {e}"))?;
Ok(())
}
src-tauri/src/services/tdlib_v8/bootstrap.js
Vendored
+67 -67
View File
@@ -1,5 +1,5 @@
/**
* Bootstrap JavaScript for V8 Runtime
* Bootstrap JavaScript for QuickJS Runtime
*
* Provides browser-like API shims that tdweb expects.
* These shims call Rust "ops" for actual I/O.
@@ -14,19 +14,19 @@ globalThis.window = globalThis;
// ============================================================================
globalThis.console = {
log: function (...args) {
Deno.core.ops.op_console_log(args.map(String).join(' '));
__ops.console_log(args.map(String).join(' '));
},
info: function (...args) {
Deno.core.ops.op_console_log(args.map(String).join(' '));
__ops.console_log(args.map(String).join(' '));
},
warn: function (...args) {
Deno.core.ops.op_console_warn(args.map(String).join(' '));
__ops.console_warn(args.map(String).join(' '));
},
error: function (...args) {
Deno.core.ops.op_console_error(args.map(String).join(' '));
__ops.console_error(args.map(String).join(' '));
},
debug: function (...args) {
Deno.core.ops.op_console_log('[DEBUG] ' + args.map(String).join(' '));
__ops.console_log('[DEBUG] ' + args.map(String).join(' '));
},
};
@@ -39,25 +39,25 @@ let nextTimerId = 1;
globalThis.setTimeout = function (callback, delay, ...args) {
const id = nextTimerId++;
timerCallbacks.set(id, { callback, args, type: 'timeout' });
Deno.core.ops.op_ah_timer_start(id, delay || 0, false);
__ops.timer_start(id, delay || 0, false);
return id;
};
globalThis.setInterval = function (callback, delay, ...args) {
const id = nextTimerId++;
timerCallbacks.set(id, { callback, args, type: 'interval' });
Deno.core.ops.op_ah_timer_start(id, delay || 0, true);
__ops.timer_start(id, delay || 0, true);
return id;
};
globalThis.clearTimeout = function (id) {
timerCallbacks.delete(id);
Deno.core.ops.op_ah_timer_cancel(id);
__ops.timer_cancel(id);
};
globalThis.clearInterval = function (id) {
timerCallbacks.delete(id);
Deno.core.ops.op_ah_timer_cancel(id);
__ops.timer_cancel(id);
};
// Timer callback handler (called from Rust)
@@ -146,7 +146,7 @@ globalThis.fetch = async function (url, options = {}) {
headersObj = headers;
}
const result = await Deno.core.ops.op_fetch(url.toString(), {
const result = await __ops.fetch(url.toString(), {
method,
headers: headersObj,
body: typeof body === 'string' ? body : body ? JSON.stringify(body) : null,
@@ -259,7 +259,7 @@ class WebSocket {
async _connect() {
try {
this._id = await Deno.core.ops.op_ws_connect(this.url);
this._id = await __ops.ws_connect(this.url);
this.readyState = WebSocket.OPEN;
// Register for message callbacks
@@ -282,7 +282,7 @@ class WebSocket {
async _startReceiving() {
while (this.readyState === WebSocket.OPEN) {
try {
const message = await Deno.core.ops.op_ws_recv(this._id);
const message = await __ops.ws_recv(this._id);
if (message === null) {
// Connection closed
this._handleClose(1000, '');
@@ -322,7 +322,7 @@ class WebSocket {
}
const dataStr = typeof data === 'string' ? data : JSON.stringify(data);
Deno.core.ops.op_ws_send(this._id, dataStr);
__ops.ws_send(this._id, dataStr);
}
close(code = 1000, reason = '') {
@@ -331,7 +331,7 @@ class WebSocket {
}
this.readyState = WebSocket.CLOSING;
Deno.core.ops.op_ws_close(this._id, code, reason);
__ops.ws_close(this._id, code, reason);
}
}
@@ -350,7 +350,7 @@ class IDBFactory {
const request = new IDBRequest();
(async () => {
try {
await Deno.core.ops.op_idb_delete_database(name);
await __ops.idb_delete_database(name);
request._success(undefined);
} catch (e) {
request._error(e);
@@ -398,7 +398,7 @@ class IDBOpenDBRequest extends IDBRequest {
async _open() {
try {
const info = await Deno.core.ops.op_idb_open(this._name, this._version);
const info = await __ops.idb_open(this._name, this._version);
const db = new IDBDatabase(this._name, this._version, info.objectStores || []);
if (info.needsUpgrade) {
@@ -433,13 +433,13 @@ class IDBDatabase {
}
createObjectStore(name, options = {}) {
Deno.core.ops.op_idb_create_object_store(this.name, name, options);
__ops.idb_create_object_store(this.name, name, options);
this.objectStoreNames.push(name);
return new IDBObjectStore(this, name);
}
deleteObjectStore(name) {
Deno.core.ops.op_idb_delete_object_store(this.name, name);
__ops.idb_delete_object_store(this.name, name);
const idx = this.objectStoreNames.indexOf(name);
if (idx >= 0) this.objectStoreNames.splice(idx, 1);
}
@@ -449,7 +449,7 @@ class IDBDatabase {
}
close() {
Deno.core.ops.op_idb_close(this.name);
__ops.idb_close(this.name);
}
}
@@ -495,7 +495,7 @@ class IDBObjectStore {
const request = new IDBRequest();
(async () => {
try {
const value = await Deno.core.ops.op_idb_get(this._db.name, this.name, key);
const value = await __ops.idb_get(this._db.name, this.name, key);
request._success(value);
} catch (e) {
request._error(e);
@@ -508,7 +508,7 @@ class IDBObjectStore {
const request = new IDBRequest();
(async () => {
try {
await Deno.core.ops.op_idb_put(this._db.name, this.name, key, value);
await __ops.idb_put(this._db.name, this.name, key, value);
request._success(key);
} catch (e) {
request._error(e);
@@ -525,7 +525,7 @@ class IDBObjectStore {
const request = new IDBRequest();
(async () => {
try {
await Deno.core.ops.op_idb_delete(this._db.name, this.name, key);
await __ops.idb_delete(this._db.name, this.name, key);
request._success(undefined);
} catch (e) {
request._error(e);
@@ -538,7 +538,7 @@ class IDBObjectStore {
const request = new IDBRequest();
(async () => {
try {
await Deno.core.ops.op_idb_clear(this._db.name, this.name);
await __ops.idb_clear(this._db.name, this.name);
request._success(undefined);
} catch (e) {
request._error(e);
@@ -551,7 +551,7 @@ class IDBObjectStore {
const request = new IDBRequest();
(async () => {
try {
const values = await Deno.core.ops.op_idb_get_all(this._db.name, this.name, count);
const values = await __ops.idb_get_all(this._db.name, this.name, count);
request._success(values);
} catch (e) {
request._error(e);
@@ -564,7 +564,7 @@ class IDBObjectStore {
const request = new IDBRequest();
(async () => {
try {
const keys = await Deno.core.ops.op_idb_get_all_keys(this._db.name, this.name, count);
const keys = await __ops.idb_get_all_keys(this._db.name, this.name, count);
request._success(keys);
} catch (e) {
request._error(e);
@@ -577,7 +577,7 @@ class IDBObjectStore {
const request = new IDBRequest();
(async () => {
try {
const count = await Deno.core.ops.op_idb_count(this._db.name, this.name);
const count = await __ops.idb_count(this._db.name, this.name);
request._success(count);
} catch (e) {
request._error(e);
@@ -636,13 +636,13 @@ if (typeof globalThis.TextDecoder === 'undefined') {
// ============================================================================
if (typeof globalThis.atob === 'undefined') {
globalThis.atob = function (str) {
return Deno.core.ops.op_atob(str);
return __ops.atob(str);
};
}
if (typeof globalThis.btoa === 'undefined') {
globalThis.btoa = function (str) {
return Deno.core.ops.op_btoa(str);
return __ops.btoa(str);
};
}
@@ -651,7 +651,7 @@ if (typeof globalThis.btoa === 'undefined') {
// ============================================================================
globalThis.crypto = {
getRandomValues: function (array) {
const bytes = Deno.core.ops.op_crypto_random(array.length);
const bytes = __ops.crypto_random(array.length);
array.set(bytes);
return array;
},
@@ -662,7 +662,7 @@ globalThis.crypto = {
// ============================================================================
globalThis.performance = {
now: function () {
return Deno.core.ops.op_performance_now();
return __ops.performance_now();
},
};
@@ -673,53 +673,53 @@ globalThis.performance = {
globalThis.__db = {
exec: function (sql, paramsJson) {
return Deno.core.ops.op_db_exec(sql, paramsJson);
return __ops.db_exec(sql, paramsJson);
},
get: function (sql, paramsJson) {
return Deno.core.ops.op_db_get(sql, paramsJson);
return __ops.db_get(sql, paramsJson);
},
all: function (sql, paramsJson) {
return Deno.core.ops.op_db_all(sql, paramsJson);
return __ops.db_all(sql, paramsJson);
},
kvGet: function (key) {
return Deno.core.ops.op_db_kv_get(key);
return __ops.db_kv_get(key);
},
kvSet: function (key, valueJson) {
return Deno.core.ops.op_db_kv_set(key, valueJson);
return __ops.db_kv_set(key, valueJson);
},
};
globalThis.__store = {
get: function (key) {
return Deno.core.ops.op_store_get(key);
return __ops.store_get(key);
},
set: function (key, valueJson) {
return Deno.core.ops.op_store_set(key, valueJson);
return __ops.store_set(key, valueJson);
},
delete: function (key) {
return Deno.core.ops.op_store_delete(key);
return __ops.store_delete(key);
},
keys: function () {
return Deno.core.ops.op_store_keys();
return __ops.store_keys();
},
};
globalThis.__net = {
fetch: function (url, optionsJson) {
return Deno.core.ops.op_net_fetch(url, optionsJson);
return __ops.net_fetch(url, optionsJson);
},
};
globalThis.__platform = {
os: function () {
return Deno.core.ops.op_platform_os();
return __ops.platform_os();
},
env: function (key) {
return Deno.core.ops.op_platform_env(key);
return __ops.platform_env(key);
},
};
// High-level wrappers for skills (V8 bridge)
// High-level wrappers for skills (QuickJS bridge)
globalThis.db = {
exec: function (sql, params) {
return __db.exec(sql, params ? JSON.stringify(params) : undefined);
@@ -779,13 +779,13 @@ globalThis.platform = {
// ============================================================================
globalThis.__state = {
get: function (key) {
return Deno.core.ops.op_state_get(key);
return __ops.state_get(key);
},
set: function (key, valueJson) {
return Deno.core.ops.op_state_set(key, valueJson);
return __ops.state_set(key, valueJson);
},
setPartial: function (partialJson) {
return Deno.core.ops.op_state_set_partial(partialJson);
return __ops.state_set_partial(partialJson);
},
};
@@ -807,10 +807,10 @@ globalThis.state = {
// ============================================================================
globalThis.__data = {
read: function (filename) {
return Deno.core.ops.op_data_read(filename);
return __ops.data_read(filename);
},
write: function (filename, content) {
return Deno.core.ops.op_data_write(filename, content);
return __ops.data_write(filename, content);
},
};
@@ -828,15 +828,15 @@ globalThis.data = {
// ============================================================================
globalThis.cron = {
register: function (scheduleId, cronExpr) {
console.warn('[cron] register not implemented in V8 runtime yet');
console.warn('[cron] register not implemented in QuickJS runtime yet');
return false;
},
unregister: function (scheduleId) {
console.warn('[cron] unregister not implemented in V8 runtime yet');
console.warn('[cron] unregister not implemented in QuickJS runtime yet');
return false;
},
list: function () {
console.warn('[cron] list not implemented in V8 runtime yet');
console.warn('[cron] list not implemented in QuickJS runtime yet');
return [];
},
};
@@ -846,11 +846,11 @@ globalThis.cron = {
// ============================================================================
globalThis.skills = {
list: function () {
console.warn('[skills] list not implemented in V8 runtime yet');
console.warn('[skills] list not implemented in QuickJS runtime yet');
return [];
},
callTool: function (skillId, toolName, args) {
console.warn('[skills] callTool not implemented in V8 runtime yet');
console.warn('[skills] callTool not implemented in QuickJS runtime yet');
return { error: 'Not implemented' };
},
};
@@ -868,8 +868,8 @@ globalThis.tdlib = {
*/
isAvailable: function () {
try {
return typeof Deno?.core?.ops?.op_tdlib_is_available === 'function'
? Deno.core.ops.op_tdlib_is_available()
return typeof __ops?.tdlib_is_available === 'function'
? __ops.tdlib_is_available()
: false;
} catch (e) {
return false;
@@ -881,8 +881,8 @@ globalThis.tdlib = {
* @param {string} dataDir - Path to store TDLib data files.
* @returns {Promise<number>} Client ID (always 1 for singleton).
*/
createClient: async function (dataDir) {
return await Deno.core.ops.op_tdlib_create_client(dataDir);
createClient: function (dataDir) {
return __ops.tdlib_create_client(dataDir);
},
/**
@@ -891,7 +891,7 @@ globalThis.tdlib = {
* @returns {Promise<object>} TDLib response object.
*/
send: async function (request) {
return await Deno.core.ops.op_tdlib_send(request);
return await __ops.tdlib_send(request);
},
/**
@@ -900,7 +900,7 @@ globalThis.tdlib = {
* @returns {Promise<object|null>} Update object or null if timeout.
*/
receive: async function (timeoutMs = 1000) {
return await Deno.core.ops.op_tdlib_receive(timeoutMs);
return await __ops.tdlib_receive(timeoutMs);
},
/**
@@ -908,7 +908,7 @@ globalThis.tdlib = {
* @returns {Promise<void>}
*/
destroy: async function () {
return await Deno.core.ops.op_tdlib_destroy();
return await __ops.tdlib_destroy();
},
};
@@ -919,21 +919,21 @@ globalThis.tdlib = {
globalThis.__model = {
isAvailable: function () {
try {
return typeof Deno?.core?.ops?.op_model_is_available === 'function'
? Deno.core.ops.op_model_is_available()
return typeof __ops?.model_is_available === 'function'
? __ops.model_is_available()
: false;
} catch (e) {
return false;
}
},
getStatus: function () {
return Deno.core.ops.op_model_get_status();
return __ops.model_get_status();
},
generate: async function (prompt, configJson) {
return await Deno.core.ops.op_model_generate(prompt, configJson);
return await __ops.model_generate(prompt, configJson);
},
summarize: async function (text, maxTokens) {
return await Deno.core.ops.op_model_summarize(text, maxTokens);
return await __ops.model_summarize(text, maxTokens);
},
};
@@ -986,4 +986,4 @@ globalThis.model = {
};
console.log('[bootstrap] Model API initialized');
console.log('[bootstrap] V8 browser APIs initialized');
console.log('[bootstrap] QuickJS browser APIs initialized');
src-tauri/src/services/tdlib_v8/mod.rs
+5 -5
View File
@@ -1,10 +1,10 @@
//! TDLib V8 Runtime Module
//! TDLib Runtime Module
//!
//! Provides a V8 JavaScript runtime (via deno_core) for running
//! skill JavaScript code and TDLib via tdweb. Provides a browser-like
//! environment that supports WASM natively.
//! Provides a QuickJS JavaScript runtime (via rquickjs) for running
//! skill JavaScript code and TDLib integration. Provides a browser-like
//! environment for skill execution.
pub mod ops;
pub mod qjs_ops;
pub mod service;
pub mod storage;
src-tauri/src/services/tdlib_v8/ops/mod.rs
-1236
View File
File diff suppressed because it is too large Load Diff
src-tauri/src/services/tdlib_v8/qjs_ops.rs
+799
View File
@@ -0,0 +1,799 @@
use parking_lot::RwLock;
use rquickjs::{function::Async, Ctx, Function, Object, Result as JsResult};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::path::PathBuf;
use std::sync::Arc;
use std::time::{Duration, Instant};
use super::storage::IdbStorage;
// ============================================================================
// Timer State
// ============================================================================
#[derive(Debug)]
pub struct TimerEntry {
pub deadline: Instant,
pub delay_ms: u32,
pub is_interval: bool,
}
#[derive(Debug, Default)]
pub struct TimerState {
pub timers: HashMap<u32, TimerEntry>,
}
impl TimerState {
pub fn poll_ready(&mut self) -> Vec<u32> {
let now = Instant::now();
let mut ready = Vec::new();
let mut to_remove = Vec::new();
for (&id, entry) in &self.timers {
if now >= entry.deadline {
ready.push(id);
if !entry.is_interval {
to_remove.push(id);
}
}
}
for id in to_remove {
self.timers.remove(&id);
}
for &id in &ready {
if let Some(entry) = self.timers.get_mut(&id) {
if entry.is_interval {
entry.deadline = now + Duration::from_millis(entry.delay_ms as u64);
}
}
}
ready
}
pub fn time_until_next(&self) -> Option<Duration> {
let now = Instant::now();
self.timers
.values()
.map(|e| e.deadline.saturating_duration_since(now))
.min()
}
}
pub fn poll_timers(timer_state: &RwLock<TimerState>) -> (Vec<u32>, Option<Duration>) {
let mut ts = timer_state.write();
let ready = ts.poll_ready();
let next = ts.time_until_next();
(ready, next)
}
// ============================================================================
// Skill Context
// ============================================================================
#[derive(Clone)]
pub struct SkillContext {
pub skill_id: String,
pub data_dir: PathBuf,
}
// ============================================================================
// Skill State (shared published state)
// ============================================================================
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SkillState {
#[serde(flatten)]
pub data: serde_json::Map<String, serde_json::Value>,
}
impl Default for SkillState {
fn default() -> Self {
Self {
data: serde_json::Map::new(),
}
}
}
// ============================================================================
// WebSocket State (placeholder)
// ============================================================================
#[derive(Debug)]
pub struct WebSocketConnection {
pub url: String,
}
#[derive(Debug, Default)]
pub struct WebSocketState {
pub connections: HashMap<u32, WebSocketConnection>,
pub next_id: u32,
}
// ============================================================================
// Allowed Environment Variables
// ============================================================================
const ALLOWED_ENV_VARS: &[&str] = &[
"VITE_BACKEND_URL",
"VITE_TELEGRAM_API_ID",
"VITE_TELEGRAM_API_HASH",
"VITE_TELEGRAM_BOT_USERNAME",
"VITE_TELEGRAM_BOT_ID",
"NODE_ENV",
];
// ============================================================================
// Helpers
// ============================================================================
fn check_telegram_skill(skill_id: &str) -> Result<(), String> {
if skill_id != "telegram" {
Err("TDLib operations only available in telegram skill".to_string())
} else {
Ok(())
}
}
fn js_err(msg: String) -> rquickjs::Error {
rquickjs::Error::new_from_js_message("ops", "Error", msg)
}
// ============================================================================
// Main Registration Function
// ============================================================================
pub fn register_ops(
ctx: &Ctx<'_>,
storage: IdbStorage,
skill_context: SkillContext,
skill_state: Arc<RwLock<SkillState>>,
timer_state: Arc<RwLock<TimerState>>,
ws_state: Arc<RwLock<WebSocketState>>,
) -> JsResult<()> {
let globals = ctx.globals();
let ops = Object::new(ctx.clone())?;
// ========================================================================
// Console (3)
// ========================================================================
ops.set("console_log", Function::new(ctx.clone(), |msg: String| {
log::info!("[js] {}", msg);
}))?;
ops.set("console_warn", Function::new(ctx.clone(), |msg: String| {
log::warn!("[js] {}", msg);
}))?;
ops.set("console_error", Function::new(ctx.clone(), |msg: String| {
log::error!("[js] {}", msg);
}))?;
// ========================================================================
// Crypto (3)
// ========================================================================
ops.set("crypto_random", Function::new(ctx.clone(), |len: usize| -> Vec<u8> {
use rand::RngCore;
let mut buf = vec![0u8; len];
rand::thread_rng().fill_bytes(&mut buf);
buf
}))?;
ops.set("atob", Function::new(ctx.clone(), |input: String| -> rquickjs::Result<String> {
use base64::Engine;
let bytes = base64::engine::general_purpose::STANDARD
.decode(&input)
.map_err(|e| js_err(e.to_string()))?;
String::from_utf8(bytes).map_err(|e| js_err(e.to_string()))
}))?;
ops.set("btoa", Function::new(ctx.clone(), |input: String| -> String {
use base64::Engine;
base64::engine::general_purpose::STANDARD.encode(input.as_bytes())
}))?;
// ========================================================================
// Performance (1)
// ========================================================================
ops.set("performance_now", Function::new(ctx.clone(), || -> f64 {
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_secs_f64()
* 1000.0
}))?;
// ========================================================================
// Platform (2)
// ========================================================================
ops.set("platform_os", Function::new(ctx.clone(), || -> &'static str {
if cfg!(target_os = "windows") { "windows" }
else if cfg!(target_os = "macos") { "macos" }
else if cfg!(target_os = "linux") { "linux" }
else if cfg!(target_os = "android") { "android" }
else if cfg!(target_os = "ios") { "ios" }
else { "unknown" }
}))?;
ops.set("platform_env", Function::new(ctx.clone(), |key: String| -> Option<String> {
if ALLOWED_ENV_VARS.contains(&key.as_str()) {
std::env::var(&key).ok()
} else {
None
}
}))?;
// ========================================================================
// Timers (2)
// ========================================================================
{
let ts = timer_state.clone();
ops.set("timer_start", Function::new(ctx.clone(),
move |id: u32, delay_ms: u32, is_interval: bool| {
let mut state = ts.write();
state.timers.insert(id, TimerEntry {
deadline: Instant::now() + Duration::from_millis(delay_ms as u64),
delay_ms,
is_interval,
});
},
))?;
}
{
let ts = timer_state.clone();
ops.set("timer_cancel", Function::new(ctx.clone(), move |id: u32| {
let mut state = ts.write();
state.timers.remove(&id);
}))?;
}
// ========================================================================
// Fetch (1) - ASYNC
// ========================================================================
ops.set("fetch", Function::new(ctx.clone(),
Async(move |url: String, options: String| async move {
let opts: serde_json::Value =
serde_json::from_str(&options).map_err(|e| js_err(e.to_string()))?;
let method = opts["method"].as_str().unwrap_or("GET");
let headers_obj = opts["headers"].as_object();
let body = opts["body"].as_str();
let client = reqwest::Client::new();
let mut req = match method {
"GET" => client.get(&url),
"POST" => client.post(&url),
"PUT" => client.put(&url),
"DELETE" => client.delete(&url),
_ => client.get(&url),
};
if let Some(h) = headers_obj {
for (k, v) in h {
if let Some(val_str) = v.as_str() {
req = req.header(k, val_str);
}
}
}
if let Some(b) = body {
req = req.body(b.to_string());
}
let response = req.send().await.map_err(|e| js_err(e.to_string()))?;
let status = response.status().as_u16();
let status_text = response.status().canonical_reason().unwrap_or("").to_string();
let headers: HashMap<String, String> = response
.headers()
.iter()
.map(|(k, v)| (k.to_string(), v.to_str().unwrap_or("").to_string()))
.collect();
let body_text = response.text().await.map_err(|e| js_err(e.to_string()))?;
let result = serde_json::json!({
"status": status,
"statusText": status_text,
"headers": headers,
"body": body_text,
});
Ok::<String, rquickjs::Error>(result.to_string())
}),
))?;
// ========================================================================
// WebSocket (4) - placeholders
// ========================================================================
{
let ws = ws_state.clone();
ops.set("ws_connect", Function::new(ctx.clone(),
Async(move |url: String| {
let ws = ws.clone();
async move {
let mut state = ws.write();
let id = state.next_id;
state.next_id += 1;
state.connections.insert(id, WebSocketConnection { url });
Ok::<u32, rquickjs::Error>(id)
}
}),
))?;
}
{
let ws = ws_state.clone();
ops.set("ws_send", Function::new(ctx.clone(), move |_id: u32, _data: String| {
let _state = ws.read();
}))?;
}
{
let ws = ws_state.clone();
ops.set("ws_recv", Function::new(ctx.clone(),
Async(move |_id: u32| {
let _ws = ws.clone();
async move { Ok::<Option<String>, rquickjs::Error>(None) }
}),
))?;
}
{
let ws = ws_state.clone();
ops.set("ws_close", Function::new(ctx.clone(), move |id: u32, _code: u16, _reason: String| {
let mut state = ws.write();
state.connections.remove(&id);
}))?;
}
// ========================================================================
// IndexedDB (11) - all sync
// ========================================================================
{
let s = storage.clone();
ops.set("idb_open", Function::new(ctx.clone(),
move |name: String, version: u32| -> rquickjs::Result<String> {
let result = s.open_database(&name, version).map_err(|e| js_err(e))?;
serde_json::to_string(&result).map_err(|e| js_err(e.to_string()))
},
))?;
}
{
let s = storage.clone();
ops.set("idb_close", Function::new(ctx.clone(), move |name: String| {
s.close_database(&name);
}))?;
}
{
let s = storage.clone();
ops.set("idb_delete_database", Function::new(ctx.clone(),
move |name: String| -> rquickjs::Result<()> {
s.delete_database(&name).map_err(|e| js_err(e))
},
))?;
}
{
let s = storage.clone();
ops.set("idb_create_object_store", Function::new(ctx.clone(),
move |db_name: String, store_name: String, options: String| -> rquickjs::Result<()> {
let opts: serde_json::Value =
serde_json::from_str(&options).map_err(|e| js_err(e.to_string()))?;
let key_path = opts["keyPath"].as_str();
let auto_increment = opts["autoIncrement"].as_bool().unwrap_or(false);
s.create_object_store(&db_name, &store_name, key_path, auto_increment)
.map_err(|e| js_err(e))
},
))?;
}
{
let s = storage.clone();
ops.set("idb_delete_object_store", Function::new(ctx.clone(),
move |db_name: String, store_name: String| -> rquickjs::Result<()> {
s.delete_object_store(&db_name, &store_name).map_err(|e| js_err(e))
},
))?;
}
{
let s = storage.clone();
ops.set("idb_get", Function::new(ctx.clone(),
move |db_name: String, store_name: String, key: String| -> rquickjs::Result<String> {
let key_val: serde_json::Value =
serde_json::from_str(&key).map_err(|e| js_err(e.to_string()))?;
let result = s.get(&db_name, &store_name, &key_val).map_err(|e| js_err(e))?;
serde_json::to_string(&result).map_err(|e| js_err(e.to_string()))
},
))?;
}
{
let s = storage.clone();
ops.set("idb_put", Function::new(ctx.clone(),
move |db_name: String, store_name: String, key: String, value: String| -> rquickjs::Result<()> {
let key_val: serde_json::Value =
serde_json::from_str(&key).map_err(|e| js_err(e.to_string()))?;
let value_val: serde_json::Value =
serde_json::from_str(&value).map_err(|e| js_err(e.to_string()))?;
s.put(&db_name, &store_name, &key_val, &value_val).map_err(|e| js_err(e))
},
))?;
}
{
let s = storage.clone();
ops.set("idb_delete", Function::new(ctx.clone(),
move |db_name: String, store_name: String, key: String| -> rquickjs::Result<()> {
let key_val: serde_json::Value =
serde_json::from_str(&key).map_err(|e| js_err(e.to_string()))?;
s.delete(&db_name, &store_name, &key_val).map_err(|e| js_err(e))
},
))?;
}
{
let s = storage.clone();
ops.set("idb_clear", Function::new(ctx.clone(),
move |db_name: String, store_name: String| -> rquickjs::Result<()> {
s.clear(&db_name, &store_name).map_err(|e| js_err(e))
},
))?;
}
{
let s = storage.clone();
ops.set("idb_get_all", Function::new(ctx.clone(),
move |db_name: String, store_name: String, count: Option<u32>| -> rquickjs::Result<String> {
let result = s.get_all(&db_name, &store_name, count).map_err(|e| js_err(e))?;
serde_json::to_string(&result).map_err(|e| js_err(e.to_string()))
},
))?;
}
{
let s = storage.clone();
ops.set("idb_get_all_keys", Function::new(ctx.clone(),
move |db_name: String, store_name: String, count: Option<u32>| -> rquickjs::Result<String> {
let result = s.get_all_keys(&db_name, &store_name, count).map_err(|e| js_err(e))?;
serde_json::to_string(&result).map_err(|e| js_err(e.to_string()))
},
))?;
}
{
let s = storage.clone();
ops.set("idb_count", Function::new(ctx.clone(),
move |db_name: String, store_name: String| -> rquickjs::Result<u32> {
s.count(&db_name, &store_name).map_err(|e| js_err(e))
},
))?;
}
// ========================================================================
// DB Bridge (5)
// ========================================================================
{
let s = storage.clone();
let sc = skill_context.clone();
ops.set("db_exec", Function::new(ctx.clone(),
move |sql: String, params_json: Option<String>| -> rquickjs::Result<i64> {
let params: Vec<serde_json::Value> = if let Some(p) = params_json {
serde_json::from_str(&p).map_err(|e| js_err(e.to_string()))?
} else {
Vec::new()
};
let rows = s.skill_db_exec(&sc.skill_id, &sql, &params).map_err(|e| js_err(e))?;
Ok(rows as i64)
},
))?;
}
{
let s = storage.clone();
let sc = skill_context.clone();
ops.set("db_get", Function::new(ctx.clone(),
move |sql: String, params_json: Option<String>| -> rquickjs::Result<String> {
let params: Vec<serde_json::Value> = if let Some(p) = params_json {
serde_json::from_str(&p).map_err(|e| js_err(e.to_string()))?
} else {
Vec::new()
};
let result = s.skill_db_get(&sc.skill_id, &sql, &params).map_err(|e| js_err(e))?;
serde_json::to_string(&result).map_err(|e| js_err(e.to_string()))
},
))?;
}
{
let s = storage.clone();
let sc = skill_context.clone();
ops.set("db_all", Function::new(ctx.clone(),
move |sql: String, params_json: Option<String>| -> rquickjs::Result<String> {
let params: Vec<serde_json::Value> = if let Some(p) = params_json {
serde_json::from_str(&p).map_err(|e| js_err(e.to_string()))?
} else {
Vec::new()
};
let result = s.skill_db_all(&sc.skill_id, &sql, &params).map_err(|e| js_err(e))?;
serde_json::to_string(&result).map_err(|e| js_err(e.to_string()))
},
))?;
}
{
let s = storage.clone();
let sc = skill_context.clone();
ops.set("db_kv_get", Function::new(ctx.clone(),
move |key: String| -> rquickjs::Result<String> {
let result = s.skill_kv_get(&sc.skill_id, &key).map_err(|e| js_err(e))?;
serde_json::to_string(&result).map_err(|e| js_err(e.to_string()))
},
))?;
}
{
let s = storage.clone();
let sc = skill_context.clone();
ops.set("db_kv_set", Function::new(ctx.clone(),
move |key: String, value_json: String| -> rquickjs::Result<()> {
let value: serde_json::Value =
serde_json::from_str(&value_json).map_err(|e| js_err(e.to_string()))?;
s.skill_kv_set(&sc.skill_id, &key, &value).map_err(|e| js_err(e))
},
))?;
}
// ========================================================================
// Store Bridge (4)
// ========================================================================
{
let s = storage.clone();
let sc = skill_context.clone();
ops.set("store_get", Function::new(ctx.clone(),
move |key: String| -> rquickjs::Result<String> {
let result = s.skill_store_get(&sc.skill_id, &key).map_err(|e| js_err(e))?;
serde_json::to_string(&result).map_err(|e| js_err(e.to_string()))
},
))?;
}
{
let s = storage.clone();
let sc = skill_context.clone();
ops.set("store_set", Function::new(ctx.clone(),
move |key: String, value_json: String| -> rquickjs::Result<()> {
let value: serde_json::Value =
serde_json::from_str(&value_json).map_err(|e| js_err(e.to_string()))?;
s.skill_store_set(&sc.skill_id, &key, &value).map_err(|e| js_err(e))
},
))?;
}
{
let s = storage.clone();
let sc = skill_context.clone();
ops.set("store_delete", Function::new(ctx.clone(),
move |key: String| -> rquickjs::Result<()> {
s.skill_store_delete(&sc.skill_id, &key).map_err(|e| js_err(e))
},
))?;
}
{
let s = storage.clone();
let sc = skill_context.clone();
ops.set("store_keys", Function::new(ctx.clone(),
move || -> rquickjs::Result<String> {
let keys = s.skill_store_keys(&sc.skill_id).map_err(|e| js_err(e))?;
serde_json::to_string(&keys).map_err(|e| js_err(e.to_string()))
},
))?;
}
// ========================================================================
// Net (1)
// ========================================================================
ops.set("net_fetch", Function::new(ctx.clone(),
|url: String, options_json: String| -> rquickjs::Result<String> {
crate::runtime::bridge::net::http_fetch(&url, &options_json).map_err(|e| js_err(e))
},
))?;
// ========================================================================
// State Bridge (3)
// ========================================================================
{
let ss = skill_state.clone();
ops.set("state_get", Function::new(ctx.clone(),
move |key: String| -> rquickjs::Result<String> {
let state = ss.read();
let value = state.data.get(&key).cloned().unwrap_or(serde_json::Value::Null);
serde_json::to_string(&value).map_err(|e| js_err(e.to_string()))
},
))?;
}
{
let ss = skill_state.clone();
ops.set("state_set", Function::new(ctx.clone(),
move |key: String, value_json: String| -> rquickjs::Result<()> {
let value: serde_json::Value =
serde_json::from_str(&value_json).map_err(|e| js_err(e.to_string()))?;
let mut state = ss.write();
state.data.insert(key, value);
Ok(())
},
))?;
}
{
let ss = skill_state.clone();
ops.set("state_set_partial", Function::new(ctx.clone(),
move |partial_json: String| -> rquickjs::Result<()> {
let partial: serde_json::Map<String, serde_json::Value> =
serde_json::from_str(&partial_json).map_err(|e| js_err(e.to_string()))?;
let mut state = ss.write();
for (k, v) in partial {
state.data.insert(k, v);
}
Ok(())
},
))?;
}
// ========================================================================
// Data Bridge (2)
// ========================================================================
{
let sc = skill_context.clone();
ops.set("data_read", Function::new(ctx.clone(),
move |filename: String| -> rquickjs::Result<String> {
let path = sc.data_dir.join(&filename);
std::fs::read_to_string(&path).map_err(|e| js_err(e.to_string()))
},
))?;
}
{
let sc = skill_context.clone();
ops.set("data_write", Function::new(ctx.clone(),
move |filename: String, content: String| -> rquickjs::Result<()> {
let path = sc.data_dir.join(&filename);
std::fs::write(&path, content).map_err(|e| js_err(e.to_string()))
},
))?;
}
// ========================================================================
// TDLib (5) - gated on skill_id == "telegram"
// ========================================================================
{
let sc = skill_context.clone();
ops.set("tdlib_is_available", Function::new(ctx.clone(),
move || -> bool { sc.skill_id == "telegram" },
))?;
}
{
let sc = skill_context.clone();
ops.set("tdlib_create_client", Function::new(ctx.clone(),
move |data_dir: String| -> rquickjs::Result<i32> {
check_telegram_skill(&sc.skill_id).map_err(|e| js_err(e))?;
crate::services::tdlib::TDLIB_MANAGER
.create_client(PathBuf::from(data_dir))
.map_err(|e| js_err(e))
},
))?;
}
{
let sc = skill_context.clone();
ops.set("tdlib_send", Function::new(ctx.clone(),
Async(move |request_json: String| {
let skill_id = sc.skill_id.clone();
async move {
check_telegram_skill(&skill_id).map_err(|e| js_err(e))?;
let request: serde_json::Value =
serde_json::from_str(&request_json).map_err(|e| js_err(e.to_string()))?;
let result = crate::services::tdlib::TDLIB_MANAGER
.send(request)
.await
.map_err(|e| js_err(e))?;
serde_json::to_string(&result).map_err(|e| js_err(e.to_string()))
}
}),
))?;
}
{
let sc = skill_context.clone();
ops.set("tdlib_receive", Function::new(ctx.clone(),
Async(move |timeout_ms: u32| {
let skill_id = sc.skill_id.clone();
async move {
check_telegram_skill(&skill_id).map_err(|e| js_err(e))?;
let result = crate::services::tdlib::TDLIB_MANAGER.receive(timeout_ms).await;
if let Some(val) = result {
let json = serde_json::to_string(&val).map_err(|e| js_err(e.to_string()))?;
Ok::<Option<String>, rquickjs::Error>(Some(json))
} else {
Ok(None)
}
}
}),
))?;
}
{
let sc = skill_context.clone();
ops.set("tdlib_destroy", Function::new(ctx.clone(),
Async(move || {
let skill_id = sc.skill_id.clone();
async move {
check_telegram_skill(&skill_id).map_err(|e| js_err(e))?;
crate::services::tdlib::TDLIB_MANAGER.destroy().await.map_err(|e| js_err(e))
}
}),
))?;
}
// ========================================================================
// Model (4) - local LLM
// ========================================================================
ops.set("model_is_available", Function::new(ctx.clone(), || -> bool { false }))?;
ops.set("model_get_status", Function::new(ctx.clone(), || -> rquickjs::Result<String> {
let status = crate::services::llama::LLAMA_MANAGER.get_status();
serde_json::to_string(&status).map_err(|e| js_err(e.to_string()))
}))?;
ops.set("model_generate", Function::new(ctx.clone(),
Async(move |prompt: String, config_json: String| async move {
let config: crate::services::llama::GenerateConfig =
serde_json::from_str(&config_json).map_err(|e| js_err(e.to_string()))?;
crate::services::llama::LLAMA_MANAGER
.generate(&prompt, config)
.await
.map_err(|e| js_err(e))
}),
))?;
ops.set("model_summarize", Function::new(ctx.clone(),
Async(move |text: String, max_tokens: u32| async move {
crate::services::llama::LLAMA_MANAGER
.summarize(&text, max_tokens)
.await
.map_err(|e| js_err(e))
}),
))?;
// ========================================================================
// Register on globalThis
// ========================================================================
globals.set("__ops", ops)?;
Ok(())
}
src-tauri/src/services/tdlib_v8/storage.rs
+30 -30
View File
@@ -13,7 +13,7 @@ use std::sync::Arc;
/// Result of opening an IndexedDB database.
/// Used by the IndexedDB emulation layer for tdweb.
#[derive(Debug, Clone)]
#[derive(Debug, Clone, serde::Serialize)]
pub struct IdbOpenResult {
/// Whether a version upgrade is needed.
pub needs_upgrade: bool,
@@ -29,7 +29,7 @@ pub struct IdbStorage {
/// Base directory for all databases.
data_dir: PathBuf,
/// Open database connections (db_name -> connection).
connections: Arc<RwLock<HashMap<String, Arc<RwLock<Connection>>>>>,
connections: Arc<RwLock<HashMap<String, Arc<parking_lot::Mutex<Connection>>>>>,
/// Database version info (used by IndexedDB emulation).
#[allow(dead_code)]
versions: Arc<RwLock<HashMap<String, u32>>>,
@@ -49,7 +49,7 @@ impl IdbStorage {
}
/// Get or create a database connection.
fn get_connection(&self, db_name: &str) -> Result<Arc<RwLock<Connection>>, String> {
fn get_connection(&self, db_name: &str) -> Result<Arc<parking_lot::Mutex<Connection>>, String> {
// Check if already open
if let Some(conn) = self.connections.read().get(db_name) {
return Ok(conn.clone());
@@ -81,7 +81,7 @@ impl IdbStorage {
)
.map_err(|e| format!("Failed to initialize database schema: {e}"))?;
let conn = Arc::new(RwLock::new(conn));
let conn = Arc::new(parking_lot::Mutex::new(conn));
self.connections
.write()
.insert(db_name.to_string(), conn.clone());
@@ -90,9 +90,9 @@ impl IdbStorage {
}
/// Open or create an IndexedDB database.
pub async fn open_database(&self, name: &str, version: u32) -> Result<IdbOpenResult, String> {
pub fn open_database(&self, name: &str, version: u32) -> Result<IdbOpenResult, String> {
let conn = self.get_connection(name)?;
let conn_guard = conn.read();
let conn_guard = conn.lock();
// Get current version
let current_version: u32 = conn_guard
@@ -145,7 +145,7 @@ impl IdbStorage {
}
/// Delete a database.
pub async fn delete_database(&self, name: &str) -> Result<(), String> {
pub fn delete_database(&self, name: &str) -> Result<(), String> {
self.close_database(name);
let db_path = self.data_dir.join(format!("{}.sqlite", name));
if db_path.exists() {
@@ -164,7 +164,7 @@ impl IdbStorage {
auto_increment: bool,
) -> Result<(), String> {
let conn = self.get_connection(db_name)?;
let conn_guard = conn.read();
let conn_guard = conn.lock();
// Register the store
conn_guard
@@ -197,7 +197,7 @@ impl IdbStorage {
/// Delete an object store.
pub fn delete_object_store(&self, db_name: &str, store_name: &str) -> Result<(), String> {
let conn = self.get_connection(db_name)?;
let conn_guard = conn.read();
let conn_guard = conn.lock();
// Remove from registry
conn_guard
@@ -214,14 +214,14 @@ impl IdbStorage {
}
/// Get a value from an object store.
pub async fn get(
pub fn get(
&self,
db_name: &str,
store_name: &str,
key: &serde_json::Value,
) -> Result<Option<serde_json::Value>, String> {
let conn = self.get_connection(db_name)?;
let conn_guard = conn.read();
let conn_guard = conn.lock();
let table_name = format!("store_{}", sanitize_name(store_name));
let key_str = serde_json::to_string(key).unwrap_or_else(|_| "null".to_string());
@@ -245,7 +245,7 @@ impl IdbStorage {
}
/// Put a value into an object store.
pub async fn put(
pub fn put(
&self,
db_name: &str,
store_name: &str,
@@ -253,7 +253,7 @@ impl IdbStorage {
value: &serde_json::Value,
) -> Result<(), String> {
let conn = self.get_connection(db_name)?;
let conn_guard = conn.read();
let conn_guard = conn.lock();
let table_name = format!("store_{}", sanitize_name(store_name));
let key_str = serde_json::to_string(key).unwrap_or_else(|_| "null".to_string());
@@ -273,14 +273,14 @@ impl IdbStorage {
}
/// Delete a value from an object store.
pub async fn delete(
pub fn delete(
&self,
db_name: &str,
store_name: &str,
key: &serde_json::Value,
) -> Result<(), String> {
let conn = self.get_connection(db_name)?;
let conn_guard = conn.read();
let conn_guard = conn.lock();
let table_name = format!("store_{}", sanitize_name(store_name));
let key_str = serde_json::to_string(key).unwrap_or_else(|_| "null".to_string());
@@ -296,9 +296,9 @@ impl IdbStorage {
}
/// Clear all values from an object store.
pub async fn clear(&self, db_name: &str, store_name: &str) -> Result<(), String> {
pub fn clear(&self, db_name: &str, store_name: &str) -> Result<(), String> {
let conn = self.get_connection(db_name)?;
let conn_guard = conn.read();
let conn_guard = conn.lock();
let table_name = format!("store_{}", sanitize_name(store_name));
@@ -310,14 +310,14 @@ impl IdbStorage {
}
/// Get all values from an object store.
pub async fn get_all(
pub fn get_all(
&self,
db_name: &str,
store_name: &str,
count: Option<u32>,
) -> Result<Vec<serde_json::Value>, String> {
let conn = self.get_connection(db_name)?;
let conn_guard = conn.read();
let conn_guard = conn.lock();
let table_name = format!("store_{}", sanitize_name(store_name));
let limit = count.map(|c| format!(" LIMIT {}", c)).unwrap_or_default();
@@ -337,14 +337,14 @@ impl IdbStorage {
}
/// Get all keys from an object store.
pub async fn get_all_keys(
pub fn get_all_keys(
&self,
db_name: &str,
store_name: &str,
count: Option<u32>,
) -> Result<Vec<serde_json::Value>, String> {
let conn = self.get_connection(db_name)?;
let conn_guard = conn.read();
let conn_guard = conn.lock();
let table_name = format!("store_{}", sanitize_name(store_name));
let limit = count.map(|c| format!(" LIMIT {}", c)).unwrap_or_default();
@@ -364,9 +364,9 @@ impl IdbStorage {
}
/// Count values in an object store.
pub async fn count(&self, db_name: &str, store_name: &str) -> Result<u32, String> {
pub fn count(&self, db_name: &str, store_name: &str) -> Result<u32, String> {
let conn = self.get_connection(db_name)?;
let conn_guard = conn.read();
let conn_guard = conn.lock();
let table_name = format!("store_{}", sanitize_name(store_name));
@@ -394,7 +394,7 @@ impl IdbStorage {
) -> Result<usize, String> {
let db_name = format!("skill_{}", skill_id);
let conn = self.get_connection(&db_name)?;
let conn_guard = conn.read();
let conn_guard = conn.lock();
let params: Vec<Box<dyn rusqlite::ToSql>> = params
.iter()
@@ -418,7 +418,7 @@ impl IdbStorage {
) -> Result<serde_json::Value, String> {
let db_name = format!("skill_{}", skill_id);
let conn = self.get_connection(&db_name)?;
let conn_guard = conn.read();
let conn_guard = conn.lock();
let params: Vec<Box<dyn rusqlite::ToSql>> = params
.iter()
@@ -463,7 +463,7 @@ impl IdbStorage {
) -> Result<serde_json::Value, String> {
let db_name = format!("skill_{}", skill_id);
let conn = self.get_connection(&db_name)?;
let conn_guard = conn.read();
let conn_guard = conn.lock();
let params: Vec<Box<dyn rusqlite::ToSql>> = params
.iter()
@@ -502,7 +502,7 @@ impl IdbStorage {
pub fn skill_kv_get(&self, skill_id: &str, key: &str) -> Result<serde_json::Value, String> {
let db_name = format!("skill_{}", skill_id);
let conn = self.get_connection(&db_name)?;
let conn_guard = conn.read();
let conn_guard = conn.lock();
// Ensure KV table exists
conn_guard
@@ -535,7 +535,7 @@ impl IdbStorage {
) -> Result<(), String> {
let db_name = format!("skill_{}", skill_id);
let conn = self.get_connection(&db_name)?;
let conn_guard = conn.read();
let conn_guard = conn.lock();
// Ensure KV table exists
conn_guard
@@ -580,7 +580,7 @@ impl IdbStorage {
pub fn skill_store_delete(&self, skill_id: &str, key: &str) -> Result<(), String> {
let db_name = format!("skill_{}", skill_id);
let conn = self.get_connection(&db_name)?;
let conn_guard = conn.read();
let conn_guard = conn.lock();
conn_guard
.execute(
@@ -596,7 +596,7 @@ impl IdbStorage {
pub fn skill_store_keys(&self, skill_id: &str) -> Result<Vec<String>, String> {
let db_name = format!("skill_{}", skill_id);
let conn = self.get_connection(&db_name)?;
let conn_guard = conn.read();
let conn_guard = conn.lock();
// Ensure KV table exists
conn_guard
src-tauri/src/utils/config.rs
-48
View File
@@ -3,8 +3,6 @@
/// This module provides configuration values that can be
/// overridden via environment variables at runtime.
use std::env;
use std::path::PathBuf;
use std::sync::Once;
/// Default backend URL (can be overridden via BACKEND_URL env var)
pub const DEFAULT_BACKEND_URL: &str = "https://api.alphahuman.xyz";
@@ -15,55 +13,9 @@ pub const APP_IDENTIFIER: &str = "com.alphahuman.app";
/// Service name for keychain
pub const KEYCHAIN_SERVICE: &str = "AlphaHuman";
/// Ensure .env is loaded once
static DOTENV_INIT: Once = Once::new();
/// Try to find and load .env file from various locations
fn ensure_dotenv_loaded() {
DOTENV_INIT.call_once(|| {
// Try current directory first (project root when running `tauri dev`)
if dotenvy::dotenv().is_ok() {
log::debug!("[config] Loaded .env from current directory");
return;
}
// Try parent directory (when cwd is src-tauri)
if let Ok(cwd) = env::current_dir() {
let parent_env = cwd.parent().map(|p| p.join(".env"));
if let Some(path) = parent_env {
if path.exists() {
if dotenvy::from_path(&path).is_ok() {
log::debug!("[config] Loaded .env from parent directory: {:?}", path);
return;
}
}
}
}
// Try CARGO_MANIFEST_DIR (available during development builds)
if let Ok(manifest_dir) = env::var("CARGO_MANIFEST_DIR") {
let manifest_path = PathBuf::from(&manifest_dir);
// .env is one level up from src-tauri
let project_root_env = manifest_path.parent().map(|p| p.join(".env"));
if let Some(path) = project_root_env {
if path.exists() {
if dotenvy::from_path(&path).is_ok() {
log::debug!("[config] Loaded .env from project root: {:?}", path);
return;
}
}
}
}
log::debug!("[config] No .env file found, using defaults/environment");
});
}
/// Get the backend URL from environment or use default
/// Checks VITE_BACKEND_URL first, then BACKEND_URL, then defaults
pub fn get_backend_url() -> String {
ensure_dotenv_loaded();
let url = env::var("VITE_BACKEND_URL")
.or_else(|_| env::var("BACKEND_URL"))
.unwrap_or_else(|_| DEFAULT_BACKEND_URL.to_string());